Merge pull request #2 from tracim/fix/fix_read/unread_endpoints

backend/tracim_backend/lib/core/content.py

 
         return resultset.all()
 
-    def get_last_active(self, parent_id: int, content_type: str, workspace: Workspace=None, limit=10) -> typing.List[Content]:
-        assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
-        assert content_type is not None# DYN_REMOVE
-        assert isinstance(content_type, str) # DYN_REMOVE
-
-        resultset = self._base_query(workspace) \
-            .filter(Content.workspace_id == Workspace.workspace_id) \
-            .filter(Workspace.is_deleted.is_(False)) \
-            .order_by(desc(Content.updated))
-
-        if content_type!=ContentType.Any:
-            resultset = resultset.filter(Content.type==content_type)
-
-        if parent_id:
-            resultset = resultset.filter(Content.parent_id==parent_id)
-
-        result = []
-        for item in resultset:
-            new_item = None
-            if ContentType.Comment == item.type:
-                new_item = item.parent
-            else:
-                new_item = item
-
-            # INFO - D.A. - 2015-05-20
-            # We do not want to show only one item if the last 10 items are
-            # comments about one thread for example
-            if new_item not in result:
-                result.append(new_item)
-
-            if len(result) >= limit:
-                break
-
-        return result
-
     def get_last_unread(self, parent_id: int, content_type: str,
                         workspace: Workspace=None, limit=10) -> typing.List[Content]:
         assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
             self,
             workspace: Workspace=None,
             limit: typing.Optional[int]=None,
-            before_datetime: typing.Optional[datetime.datetime]= None,
+            before_content: typing.Optional[Content]= None,
             content_ids: typing.Optional[typing.List[int]] = None,
     ) -> typing.List[Content]:
         """
         (last modification of content itself or one of this comment)
         :param workspace: Workspace to check
         :param limit: maximum number of elements to return
-        :param before_datetime: date from where we check older content.
+        :param before_content: last_active content are only those updated
+         before this content given.
         :param content_ids: restrict selection to some content ids and
         related Comments
         :return: list of content
 
         active_contents = []
         too_recent_content = []
+        before_content_find = False
         for content in resultset:
             related_active_content = None
             if ContentType.Comment == content.type:
             else:
                 related_active_content = content
 
-            if not before_datetime:
-                before_datetime = datetime.datetime.now()
-            # INFO - D.A. - 2015-05-20
-            # We do not want to show only one item if the last 10 items are
-            # comments about one thread for example
             if related_active_content not in active_contents and related_active_content not in too_recent_content:  # nopep8
-                # we verify that content is old enough
-                if content.updated < before_datetime:
+
+                if not before_content or before_content_find:
                     active_contents.append(related_active_content)
                 else:
                     too_recent_content.append(related_active_content)
 
+                if before_content and related_active_content == before_content:
+                    before_content_find = True
+
             if limit and len(active_contents) >= limit:
                 break
 

backend/tracim_backend/lib/core/workspace.py

 
 from sqlalchemy.orm import Query
 from sqlalchemy.orm import Session
+from sqlalchemy.orm.exc import NoResultFound
 
 from tracim_backend import CFG
 from tracim_backend.exceptions import EmptyLabelNotAllowed
+from tracim_backend.exceptions import WorkspaceNotFound
 from tracim_backend.lib.utils.translation import fake_translator as _
 
 from tracim_backend.lib.core.userworkspace import RoleApi
         return workspace
 
     def get_one(self, id):
-        return self._base_query().filter(Workspace.workspace_id == id).one()
+        try:
+            return self._base_query().filter(Workspace.workspace_id == id).one()
+        except NoResultFound as exc:
+            raise WorkspaceNotFound('workspace {} does not exist or not visible for user'.format(id)) from exc  # nopep8
 
     def get_one_by_label(self, label: str) -> Workspace:
-        return self._base_query().filter(Workspace.label == label).one()
+        try:
+            return self._base_query().filter(Workspace.label == label).one()
+        except NoResultFound as exc:
+            raise WorkspaceNotFound('workspace {} does not exist or not visible for user'.format(id)) from exc  # nopep8
 
     """
     def get_one_for_current_user(self, id):

backend/tracim_backend/models/context_models.py

     def __init__(
             self,
             limit: int = None,
-            before_datetime: datetime = None,
+            before_content_id: datetime = None,
     ):
         self.limit = limit
-        self.before_datetime = before_datetime
+        self.before_content_id = before_content_id
 
 
 class ContentIdsQuery(object):

backend/tracim_backend/tests/library/test_content_api.py

         secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
 
-        last_actives = api.get_last_active(workspace=workspace, limit=2, before_datetime=datetime.datetime.now())  # nopep8
+        last_actives = api.get_last_active(workspace=workspace, limit=2)  # nopep8
         assert len(last_actives) == 2
         # comment is newest than page2
         assert last_actives[0] == firstly_created_but_recently_commented
         assert last_actives[1] == secondly_created_but_not_commented
 
-        last_actives = api.get_last_active(workspace=workspace, limit=2, before_datetime=last_actives[1].get_simple_last_activity_date())  # nopep8
+        last_actives = api.get_last_active(workspace=workspace, limit=2, before_content=last_actives[1])  # nopep8
         assert len(last_actives) == 2
         # last updated content is newer than other one despite creation
         # of the other is more recent
         assert last_actives[0] == firstly_created_but_recently_updated
         assert last_actives[1] == secondly_created_but_not_updated
 
-        last_actives = api.get_last_active(workspace=workspace, limit=2, before_datetime=last_actives[1].get_simple_last_activity_date())  # nopep8
+        last_actives = api.get_last_active(workspace=workspace, limit=2, before_content=last_actives[1])  # nopep8
         assert len(last_actives) == 2
         # creation order is inverted here as last created is last active
         assert last_actives[0] == secondly_created
         assert last_actives[1] == firstly_created
 
-        last_actives = api.get_last_active(workspace=workspace, limit=2, before_datetime=last_actives[1].get_simple_last_activity_date())  # nopep8
+        last_actives = api.get_last_active(workspace=workspace, limit=2, before_content=last_actives[1])  # nopep8
         assert len(last_actives) == 1
         # folder subcontent modification does not change folder order
         assert last_actives[0] == main_folder

backend/tracim_backend/views/core_api/schemas.py

                     'the first limit elem (according to offset)',
         validate=Range(min=0, error="Value must be positive or 0"),
     )
-    before_datetime = marshmallow.fields.DateTime(
-        format=DATETIME_FORMAT,
-        description='return only content lastly updated before this date',
+    before_content_id = marshmallow.fields.Int(
+        example=41,
+        default=None,
+        allow_none=True,
+        description='return only content updated before this content',
     )
     @post_load
     def make_content_filter(self, data):

backend/tracim_backend/views/core_api/user_controller.py

 from tracim_backend.lib.core.user import UserApi
 from tracim_backend.lib.core.workspace import WorkspaceApi
 from tracim_backend.lib.core.content import ContentApi
+from tracim_backend.models.contents import ContentTypeLegacy as ContentType
 from tracim_backend.views.controllers import Controller
 from tracim_backend.lib.utils.authorization import require_same_user_or_profile
 from tracim_backend.lib.utils.authorization import require_profile
         workspace = None
         if hapic_data.path.workspace_id:
             workspace = wapi.get_one(hapic_data.path.workspace_id)
+        before_content = None
+        if content_filter.before_content_id:
+            before_content = api.get_one(
+                content_id=content_filter.before_content_id,
+                workspace=workspace,
+                content_type=ContentType.Any
+            )
         last_actives = api.get_last_active(
             workspace=workspace,
             limit=content_filter.limit or None,
-            before_datetime=content_filter.before_datetime or None,
+            before_content=before_content,
         )
         return [
             api.get_content_in_context(content)
         last_actives = api.get_last_active(
             workspace=workspace,
             limit=None,
-            before_datetime=None,
+            before_content=None,
             content_ids=hapic_data.query.contents_ids or None
         )
         return [