reenable endpoints for last_active and read_status

tracim/lib/core/content.py

             workspace: Workspace=None,
             limit: typing.Optional[int]=None,
             before_datetime: typing.Optional[datetime.datetime]= None,
+            content_ids: typing.Optional[typing.List[int]] = None,
     ) -> typing.List[Content]:
         """
         get contents list sorted by last update
         :param workspace: Workspace to check
         :param limit: maximum number of elements to return
         :param before_datetime: date from where we check older content.
+        :param content_ids: restrict selection to some content ids and
+        related Comments
         :return: list of content
         """
 
         resultset = self._get_all_query(
             workspace=workspace,
         )
+        if content_ids:
+            resultset.filter(
+                or_(
+                    Content.content_id.in_(content_ids),
+                    and_(
+                        Content.parent_id.in_(content_ids),
+                        Content.type == ContentType.Comment
+                    )
+                )
+            )
+
         resultset = resultset.order_by(desc(Content.updated))
 
         active_contents = []

tracim/models/context_models.py

         self.content_type = content_type
 
 
+class ActiveContentFilter(object):
+    def __init__(
+            self,
+            limit: int = None,
+            before_datetime: datetime = None,
+    ):
+        self.limit = limit
+        self.before_datetime = before_datetime
+
+
+class ContentIdsQuery(object):
+    def __init__(
+            self,
+            contents_ids: typing.List[int] = None,
+    ):
+        self.contents_ids = contents_ids
+
+
 class ContentCreation(object):
     """
     Content creation model

tracim/views/core_api/schemas.py

 from tracim.models.contents import open_status
 from tracim.models.contents import ContentTypeLegacy as ContentType
 from tracim.models.contents import ContentStatusLegacy as ContentStatus
-from tracim.models.context_models import ContentCreation
+from tracim.models.context_models import ContentCreation, ActiveContentFilter, \
+    ContentIdsQuery
 from tracim.models.context_models import UserWorkspacePath
 from tracim.models.context_models import UserWorkspaceAndContentPath
 from tracim.models.context_models import CommentCreation
         format=DATETIME_FORMAT,
         description='return only content lastly updated before this date',
     )
+    @post_load
+    def make_content_filter(self, data):
+        return ActiveContentFilter(**data)
 
 
 class ContentIdsQuerySchema(marshmallow.Schema):
             validate=Range(min=1, error="Value must be greater than 0"),
         )
     )
+    @post_load
+    def make_contents_ids(self, data):
+        return ContentIdsQuery(**data)
 
 ###
 

tracim/views/core_api/user_controller.py

 
     @hapic.with_api_doc(tags=[USER_ENDPOINTS_TAG])
     @require_same_user_or_profile(Group.TIM_ADMIN)
-    @hapic.input_path(UserIdPathSchema())
+    @hapic.input_path(UserWorkspaceIdPathSchema())
     @hapic.input_query(ActiveContentFilterQuerySchema())
     @hapic.output_body(ContentDigestSchema(many=True))
     def last_active_content(self, context, request: TracimRequest, hapic_data=None):  # nopep8
         """
         Get last_active_content for user
         """
-        raise NotImplemented()
-        # app_config = request.registry.settings['CFG']
-        # content_filter = hapic_data.query
-        # api = ContentApi(
-        #     current_user=request.candidate_user,  # User
-        #     session=request.dbsession,
-        #     config=app_config,
-        #     show_archived=content_filter.show_archived,
-        #     show_deleted=content_filter.show_deleted,
-        #     show_active=content_filter.show_active,
-        # )
-        # wapi = WorkspaceApi(
-        #     current_user=request.candidate_user,  # User
-        #     session=request.dbsession,
-        #     config=app_config,
-        # )
-        # workspace = None
-        # if content_filter.workspace_id:
-        #     workspace = wapi.get_one(content_filter.workspace_id)
-        # last_actives = api.get_last_active(
-        #     parent_id=content_filter.parent_id,
-        #     content_type=content_filter.content_type or ContentType.Any,
-        #     workspace=workspace,
-        #     offset=content_filter.offset or None,
-        #     limit=content_filter.limit or None,
-        # )
-        # return [
-        #     api.get_content_in_context(content)
-        #     for content in last_actives
-        # ]
+        app_config = request.registry.settings['CFG']
+        content_filter = hapic_data.query
+        api = ContentApi(
+            current_user=request.candidate_user,  # User
+            session=request.dbsession,
+            config=app_config,
+        )
+        wapi = WorkspaceApi(
+            current_user=request.candidate_user,  # User
+            session=request.dbsession,
+            config=app_config,
+        )
+        workspace = None
+        if hapic_data.path.workspace_id:
+            workspace = wapi.get_one(hapic_data.path.workspace_id)
+        last_actives = api.get_last_active(
+            workspace=workspace,
+            limit=content_filter.limit or None,
+            before_datetime=content_filter.before_datetime or None,
+        )
+        return [
+            api.get_content_in_context(content)
+            for content in last_actives
+        ]
 
     @hapic.with_api_doc(tags=[USER_ENDPOINTS_TAG])
     @require_same_user_or_profile(Group.TIM_ADMIN)
-    @hapic.input_path(UserWorkspaceAndContentIdPathSchema())
+    @hapic.input_path(UserWorkspaceIdPathSchema())
     @hapic.input_query(ContentIdsQuerySchema())
     @hapic.output_body(ReadStatusSchema(many=True))  # nopep8
     def contents_read_status(self, context, request: TracimRequest, hapic_data=None):  # nopep8
         """
         get user_read status of contents
         """
-        raise NotImplemented()
-        # app_config = request.registry.settings['CFG']
-        # api = ContentApi(
-        #     current_user=request.candidate_user,
-        #     session=request.dbsession,
-        #     config=app_config,
-        # )
-        # return api.get_content_in_context(request.current_content)
+        app_config = request.registry.settings['CFG']
+        content_filter = hapic_data.query
+        api = ContentApi(
+            current_user=request.candidate_user,  # User
+            session=request.dbsession,
+            config=app_config,
+        )
+        wapi = WorkspaceApi(
+            current_user=request.candidate_user,  # User
+            session=request.dbsession,
+            config=app_config,
+        )
+        workspace = None
+        if hapic_data.path.workspace_id:
+            workspace = wapi.get_one(hapic_data.path.workspace_id)
+        last_actives = api.get_last_active(
+            workspace=workspace,
+            limit=None,
+            before_datetime=None,
+            content_ids=hapic_data.query.contents_ids or None
+        )
+        return [
+            api.get_content_in_context(content)
+            for content in last_actives
+        ]
+
 
     @hapic.with_api_doc(tags=[USER_ENDPOINTS_TAG])
     @require_same_user_or_profile(Group.TIM_ADMIN)