fix get_last_active code with before_content instead of before_datetime sorting

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]:
         """
 
         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/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/functional/test_user.py

         # folder subcontent modification does not change folder order
         assert res[6]['content_id'] == main_folder.content_id
 
-    @pytest.mark.skip('Test should be fixed')
     def test_api__get_recently_active_content__ok__200__limit_2_multiple(self):
         # TODO - G.M - 2018-07-20 - Better fix for this test, do not use sleep()
         # anymore to fix datetime lack of precision.
             config=self.app_config,
         )
         main_folder_workspace2 = api.create(ContentType.Folder, workspace2, None, 'Hepla', '', True)  # nopep8
-        sleep(1)
         main_folder = api.create(ContentType.Folder, workspace, None, 'this is randomized folder', '', True)  # nopep8
         # creation order test
         firstly_created = api.create(ContentType.Page, workspace, main_folder, 'creation_order_test', '', True)  # nopep8
-        sleep(1)
         secondly_created = api.create(ContentType.Page, workspace, main_folder, 'another creation_order_test', '', True)  # nopep8
         # update order test
         firstly_created_but_recently_updated = api.create(ContentType.Page, workspace, main_folder, 'update_order_test', '', True)  # nopep8
-        sleep(1)
         secondly_created_but_not_updated = api.create(ContentType.Page, workspace, main_folder, 'another update_order_test', '', True)  # nopep8
-        sleep(1)
         with new_revision(
             session=dbsession,
             tm=transaction.manager,
         api.save(firstly_created_but_recently_updated)
         # comment change order
         firstly_created_but_recently_commented = api.create(ContentType.Page, workspace, main_folder, 'this is randomized label content', '', True)  # nopep8
-        sleep(1)
         secondly_created_but_not_commented = api.create(ContentType.Page, workspace, main_folder, 'this is another randomized label content', '', True)  # nopep8
-        sleep(1)
         comments = api.create_comment(workspace, firstly_created_but_recently_commented, 'juste a super comment', True)  # nopep8
-        sleep(1)
         content_workspace_2 = api.create(ContentType.Page, workspace2,main_folder_workspace2, 'content_workspace_2', '',True)  # nopep8
         dbsession.flush()
         transaction.commit()
 
         params = {
             'limit': 2,
-            'before_datetime': secondly_created_but_not_commented.get_last_activity_date().strftime('%Y-%m-%dT%H:%M:%SZ'),  # nopep8
+            'before_content_id': secondly_created_but_not_commented.content_id,  # nopep8
         }
         res = self.testapp.get(
             '/api/v2/users/1/workspaces/{}/contents/recently_active'.format(workspace.workspace_id),  # nopep8

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 [