Merge pull request #209 from herawo/dev/_/185/button_to_read_all

tracim/tracim/controllers/content.py

 from cgi import FieldStorage
 import tg
 from tg import tmpl_context
+from tg import require
+from tg import predicates
 from tg.i18n import ugettext as _
 from tg.predicates import not_anonymous
 from sqlalchemy.orm.exc import NoResultFound
 from tg import abort
 
 from tracim.controllers import TIMRestController
+from tracim.controllers import StandardController
 from tracim.controllers import TIMRestPathContextSetup
 from tracim.controllers import TIMRestControllerWithBreadcrumb
 from tracim.controllers import TIMWorkspaceContentRestController
 from tracim.lib.predicates import current_user_is_contributor
 from tracim.lib.predicates import current_user_is_content_manager
 from tracim.lib.predicates import require_current_user_is_owner
-from tracim.model.serializers import Context, CTX, DictLikeClass
+from tracim.model.serializers import Context
+from tracim.model.serializers import CTX
+from tracim.model.serializers import DictLikeClass
 from tracim.model.data import ActionDescription
 from tracim.model import new_revision
 from tracim.model import DBSession
             msg = _('{} not un-deleted: {}').format(self._item_type_label, str(e))
             tg.flash(msg, CST.STATUS_ERROR)
             tg.redirect(back_url)
+
+
+class ContentController(StandardController):
+
+    '''
+    Class of controllers used for example in home to mark read the unread 
+    contents via mark_all_read()
+    '''
+
+    @classmethod
+    def current_item_id_key_in_context(cls) -> str:
+        return''
+
+    @tg.expose()
+    def index(self):
+        return dict()
+
+    @require(predicates.not_anonymous())
+    @tg.expose()
+    def mark_all_read(self):
+        '''
+        Mark as read all the content that hasn't been read
+        redirects the user to "/home"
+        '''
+        user = tg.tmpl_context.current_user
+        content_api = ContentApi(user)
+        content_api.mark_read__all()
+
+        tg.redirect("/home")

tracim/tracim/controllers/root.py

 
 from tg.i18n import ugettext as _
 from tracim.controllers.api import APIController
+from tracim.controllers.content import ContentController
 
 from tracim.lib import CST
 from tracim.lib.base import logger
     debug = DebugController()
     error = ErrorController()
 
+
     # Rest controllers
     workspaces = UserWorkspaceRestController()
     user = UserRestController()
 
+    content = ContentController()
+
     # api
     api = APIController()
 

tracim/tracim/controllers/workspace.py

     def get_all(self, *args, **kw):
         tg.redirect(tg.url('/home'))
 
+    @tg.expose()
+    def mark_read(self, workspace_id, **kwargs):
+
+        user = tmpl_context.current_user
+        workspace_api = WorkspaceApi(user)
+        workspace = workspace_api.get_one(workspace_id)
+
+        content_api = ContentApi(user)
+        content_api.mark_read__workspace(workspace)
+
+        tg.redirect('/workspaces/{}'.format(workspace_id))
+        return DictLikeClass(fake_api=fake_api)
+
     @tg.expose('tracim.templates.workspace.getone')
     def get_one(self, workspace_id, **kwargs):
         """
         show_archived = str_as_bool(kwargs.get('show_archived', ''))
         user = tmpl_context.current_user
 
+        workspace_api = WorkspaceApi(user)
+        workspace = workspace_api.get_one(workspace_id)
+
+        unread_contents = ContentApi(user).get_last_unread(None,
+                                                           ContentType.Any,
+                                                           workspace=workspace)
         current_user_content = Context(CTX.CURRENT_USER).toDict(user)
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
 
-        workspace_api = WorkspaceApi(user)
-        workspace = workspace_api.get_one(workspace_id)
+
 
         dictified_current_user = Context(CTX.CURRENT_USER).toDict(user)
         dictified_folders = self.folders.get_all_fake(workspace).result
         fake_api = DictLikeClass(
+            last_unread=Context(CTX.CONTENT_LIST).toDict(unread_contents,
+                                                         'contents',
+                                                         'nb'),
             current_user=dictified_current_user,
             current_workspace_folders=dictified_folders,
             current_user_workspace_role=workspace.get_user_role(user)

tracim/tracim/lib/content.py

 from tracim.lib import cmp_to_key
 from tracim.lib.notifications import NotifierFactory
 from tracim.lib.utils import SameValueError
-from tracim.model import DBSession, new_revision
+from tracim.model import DBSession
+from tracim.model import new_revision
 from tracim.model.auth import User
 from tracim.model.data import ActionDescription
 from tracim.model.data import BreadcrumbItem
         content.is_deleted = False
         content.revision_type = ActionDescription.UNDELETION
 
+    def mark_read__all(self,
+                       read_datetime: datetime=None,
+                       do_flush: bool=True,
+                       recursive: bool=True
+                       ):
+
+        itemset = self.get_last_unread(None, ContentType.Any)
+
+        for item in itemset:
+            self.mark_read(item, read_datetime, do_flush, recursive)
+
+    def mark_read__workspace(self,
+                       workspace : Workspace,
+                       read_datetime: datetime=None,
+                       do_flush: bool=True,
+                       recursive: bool=True
+                       ):
+
+        itemset = self.get_last_unread(None, ContentType.Any, workspace)
+
+        for item in itemset:
+            self.mark_read(item, read_datetime, do_flush, recursive)
+
     def mark_read(self, content: Content,
                   read_datetime: datetime=None,
                   do_flush: bool=True, recursive: bool=True) -> Content:

tracim/tracim/lib/webdav/sql_resources.py

 
 import os
 
+import tg
 import transaction
 import re
 from datetime import datetime

tracim/tracim/templates/home.mak

 
     ## NOT READ
     <div class="" id="unread-content-panel">
+
         <div class="panel panel-success">
             <div class="panel-body">
                 % if fake_api.last_unread.nb <= 0:
                     ${P.EMPTY_CONTENT(_('No new content.'))}
                 % else:
+                    <a href="${tg.url('/content/mark_all_read')}" class="btn btn-default"> ${_('Mark everything as read')} </a>
                     <table class="table table-hover">
                         % for item in fake_api.last_unread.contents:
                             <tr>

tracim/tracim/templates/workspace/getone.mak

 
 
 <div class="workspace__detail__wrapper">
+     %if fake_api.last_unread.nb > 0:
+         <% workspace_id = result.workspace.id %>
+         <a href="${tg.url('/workspaces/{ws_id}/mark_read'.format(ws_id = workspace_id))}" class="btn btn-default"> ${_('Mark this workspace as read')} </a>
+
+     %endif
+
     ${TITLE.H3(_('Detail'), 'fa-align-justify', 'workspace-members')}
     % if result.workspace.description:
         <p>${result.workspace.description}</p>

tracim/tracim/tests/library/test_content_api.py

 # -*- coding: utf-8 -*-
+import datetime
 
 from nose.tools import eq_, ok_
 from nose.tools import raises
         eq_(ActionDescription.COMMENT, c.revision_type)
 
 
+    def test_mark_read__workspace(self):
+        uapi = UserApi(None)
+        groups = [GroupApi(None).get_one(Group.TIM_USER),
+                  GroupApi(None).get_one(Group.TIM_MANAGER),
+                  GroupApi(None).get_one(Group.TIM_ADMIN)]
+        user_a = uapi.create_user(email='this.is@user',
+                                  groups=groups, save_now=True)
+        user_b = uapi.create_user(email='this.is@another.user',
+                                  groups=groups, save_now=True)
+
+        wapi = WorkspaceApi(user_a)
+        workspace1 = wapi.create_workspace(
+            'test workspace n°1',
+            save_now=True)
+        workspace2 = wapi.create_workspace(
+            'test workspace n°2',
+            save_now=True)
+
+        role_api1 = RoleApi(user_a)
+        role_api1.create_one(user_b, workspace1, UserRoleInWorkspace.READER,
+                            False)
+
+        role_api2 = RoleApi(user_a)
+        role_api2.create_one(user_b, workspace2, UserRoleInWorkspace.READER,
+                             False)
+
+        cont_api_a = ContentApi(user_a)
+        cont_api_b = ContentApi(user_b)
+
+
+        # Creates page_1 & page_2 in workspace 1
+        #     and page_3 & page_4 in workspace 2
+        page_1 = cont_api_a.create(ContentType.Page, workspace1, None,
+                                   'this is a page', do_save=True)
+        page_2 = cont_api_a.create(ContentType.Page, workspace1, None,
+                                   'this is page1', do_save=True)
+        page_3 = cont_api_a.create(ContentType.Thread, workspace2, None,
+                                   'this is page2', do_save=True)
+        page_4 = cont_api_a.create(ContentType.File, workspace2, None,
+                                   'this is page3', do_save=True)
+
+        for rev in page_1.revisions:
+            eq_(user_b not in rev.read_by.keys(), True)
+        for rev in page_2.revisions:
+            eq_(user_b not in rev.read_by.keys(), True)
+        for rev in page_3.revisions:
+            eq_(user_b not in rev.read_by.keys(), True)
+        for rev in page_4.revisions:
+            eq_(user_b not in rev.read_by.keys(), True)
+
+        # Set as read the workspace n°1
+        cont_api_b.mark_read__workspace(workspace=workspace1)
+
+        for rev in page_1.revisions:
+            eq_(user_b in rev.read_by.keys(), True)
+        for rev in page_2.revisions:
+            eq_(user_b in rev.read_by.keys(), True)
+        for rev in page_3.revisions:
+            eq_(user_b not in rev.read_by.keys(), True)
+        for rev in page_4.revisions:
+            eq_(user_b not in rev.read_by.keys(), True)
+
+        # Set as read the workspace n°2
+        cont_api_b.mark_read__workspace(workspace=workspace2)
+
+        for rev in page_1.revisions:
+            eq_(user_b in rev.read_by.keys(), True)
+        for rev in page_2.revisions:
+            eq_(user_b in rev.read_by.keys(), True)
+        for rev in page_3.revisions:
+            eq_(user_b in rev.read_by.keys(), True)
+        for rev in page_4.revisions:
+            eq_(user_b in rev.read_by.keys(), True)
+
+    def test_mark_read(self):
+        uapi = UserApi(None)
+        groups = [GroupApi(None).get_one(Group.TIM_USER),
+                  GroupApi(None).get_one(Group.TIM_MANAGER),
+                  GroupApi(None).get_one(Group.TIM_ADMIN)]
+        user_a = uapi.create_user(email='this.is@user',
+                                 groups=groups, save_now=True)
+        user_b = uapi.create_user(email='this.is@another.user',
+                                 groups=groups, save_now=True)
+
+        wapi = WorkspaceApi(user_a)
+        workspace = wapi.create_workspace(
+            'test workspace',
+            save_now=True)
+
+        role_api = RoleApi(user_a)
+        role_api.create_one(user_b, workspace, UserRoleInWorkspace.READER, False)
+        cont_api_a = ContentApi(user_a)
+        cont_api_b = ContentApi(user_b)
+
+        page_1 = cont_api_a.create(ContentType.Page, workspace, None,
+                                   'this is a page', do_save=True)
+
+        for rev in page_1.revisions:
+            eq_(user_b not in rev.read_by.keys(), True)
+
+        cont_api_b.mark_read(page_1)
+
+        for rev in page_1.revisions:
+            eq_(user_b in rev.read_by.keys(), True)
+
+
+    def test_mark_read__all(self):
+        uapi = UserApi(None)
+        groups = [GroupApi(None).get_one(Group.TIM_USER),
+                  GroupApi(None).get_one(Group.TIM_MANAGER),
+                  GroupApi(None).get_one(Group.TIM_ADMIN)]
+        user_a = uapi.create_user(email='this.is@user',
+                                 groups=groups, save_now=True)
+        user_b = uapi.create_user(email='this.is@another.user',
+                                 groups=groups, save_now=True)
+
+        wapi = WorkspaceApi(user_a)
+        workspace = wapi.create_workspace(
+            'test workspace',
+            save_now=True)
+
+        role_api = RoleApi(user_a)
+        role_api.create_one(user_b, workspace, UserRoleInWorkspace.READER, False)
+        cont_api_a = ContentApi(user_a)
+        cont_api_b = ContentApi(user_b)
+
+        page_2 = cont_api_a.create(ContentType.Page, workspace, None, 'this is page1', do_save=True)
+        page_3 = cont_api_a.create(ContentType.Thread, workspace, None, 'this is page2', do_save=True)
+        page_4 = cont_api_a.create(ContentType.File, workspace, None, 'this is page3', do_save=True)
+
+        for rev in page_2.revisions:
+            eq_(user_b not in rev.read_by.keys(), True)
+        for rev in page_3.revisions:
+            eq_(user_b not in rev.read_by.keys(), True)
+        for rev in page_4.revisions:
+            eq_(user_b not in rev.read_by.keys(), True)
+
+        DBSession.refresh(page_2)
+        DBSession.refresh(page_3)
+        DBSession.refresh(page_4)
+
+        cont_api_b.mark_read__all()
+
+        for rev in page_2.revisions:
+            eq_(user_b in rev.read_by.keys(), True)
+        for rev in page_3.revisions:
+            eq_(user_b in rev.read_by.keys(), True)
+        for rev in page_4.revisions:
+            eq_(user_b in rev.read_by.keys(), True)
+
+
+
+
+
     def test_update(self):
         uapi = UserApi(None)
         groups = [GroupApi(None).get_one(Group.TIM_USER),