feat(events): add separate timeline_focussed API route

Author: palkerecsenyi

invenio_requests/assets/semantic-ui/js/invenio_requests/api/InvenioRequestApi.js

@@ -28,6 +28,13 @@ export class RequestLinksExtractor {
     return this.#urls.timeline;
   }
 
+  get timelineFocussed() {
+    if (!this.#urls.timeline) {
+      throw TypeError("Timeline focussed link missing from resource.");
+    }
+    return this.#urls.timeline_focussed;
+  }
+
   get comments() {
     if (!this.#urls.comments) {
       throw TypeError("Comments link missing from resource.");
@@ -63,6 +70,16 @@ export class InvenioRequestsAPI {
     });
   };
 
+  getTimelineFocussed = async (focusEventId, params) => {
+    return await http.get(this.#urls.timelineFocussed, {
+      params: {
+        expand: 1,
+        focus_event_id: focusEventId,
+        ...params,
+      },
+    });
+  };
+
   getRequest = async () => {
     return await http.get(this.#urls.self, { params: { expand: 1 } });
   };

invenio_requests/assets/semantic-ui/js/invenio_requests/timeline/state/actions.js

@@ -26,27 +26,29 @@ class intervalManager {
   }
 }
 
-export const fetchTimeline = (includeEventId = undefined, loadingState = true) => {
+export const fetchTimeline = (focusEventId = undefined) => {
   return async (dispatch, getState, config) => {
     const state = getState();
     const { size, page, data: timelineData } = state.timeline;
 
-    if (loadingState) {
-      dispatch({
-        type: IS_LOADING,
-      });
-    }
     dispatch({
       type: IS_REFRESHING,
     });
 
     try {
-      const response = await config.requestsApi.getTimeline({
-        size: size,
-        page: page,
-        sort: "oldest",
-        include_event_id: includeEventId,
-      });
+      let response;
+      if (focusEventId) {
+        response = await config.requestsApi.getTimelineFocussed(focusEventId, {
+          size: size,
+        });
+      } else {
+        response = await config.requestsApi.getTimeline({
+          size: size,
+          page: page,
+          sort: "oldest",
+          include_event_id: focusEventId,
+        });
+      }
 
       // Check if timeline has more events than the current state
       const hasMoreEvents = response.data?.hits?.total > timelineData?.hits?.total;
@@ -73,10 +75,7 @@ export const fetchTimeline = (includeEventId = undefined, loadingState = true) =
         });
       }
 
-      if (
-        includeEventId &&
-        !response.data.hits.hits.some((h) => h.id === includeEventId)
-      ) {
+      if (focusEventId && !response.data.hits.hits.some((h) => h.id === focusEventId)) {
         // Show a warning if the event ID in the hash was not found in the response list of events.
         // This happens if the server cannot find the requested event.
         dispatch({
@@ -121,12 +120,15 @@ const timelineReload = (dispatch, getState, config) => {
 
   if (concurrentRequests) return;
 
-  dispatch(fetchTimeline(undefined, false));
+  dispatch(fetchTimeline());
 };
 
-export const getTimelineWithRefresh = (includeEventId) => {
+export const getTimelineWithRefresh = (focusEventId) => {
   return async (dispatch, getState, config) => {
-    dispatch(fetchTimeline(includeEventId, true));
+    dispatch({
+      type: IS_LOADING,
+    });
+    dispatch(fetchTimeline(focusEventId, true));
     dispatch(setTimelineInterval());
   };
 };

invenio_requests/resources/events/config.py

@@ -20,7 +20,7 @@
 class RequestCommentsSearchRequestArgsSchema(SearchRequestArgsSchema):
     """Add parameter to parse tags."""
 
-    include_event_id = fields.UUID()
+    focus_event_id = fields.UUID()
 
 
 class RequestCommentsResourceConfig(RecordResourceConfig):
@@ -32,6 +32,7 @@ class RequestCommentsResourceConfig(RecordResourceConfig):
         "list": "/<request_id>/comments",
         "item": "/<request_id>/comments/<comment_id>",
         "timeline": "/<request_id>/timeline",
+        "timeline_focussed": "/<request_id>/timeline_focussed",
     }
 
     # Input

invenio_requests/resources/events/resource.py

@@ -61,6 +61,7 @@ def create_url_rules(self):
             route("PUT", routes["item"], self.update),
             route("DELETE", routes["item"], self.delete),
             route("GET", routes["timeline"], self.search),
+            route("GET", routes["timeline_focussed"], self.focussed_list),
         ]
 
     @list_view_args_parser
@@ -130,16 +131,28 @@ def search(self):
         """Perform a search over EVENTS.
 
         Its primary purpose is as a batch read of events i.e. the timeline.
-
-        By specifying `include_event_id`, you can ensure that the page containing the
-        given event will be loaded. This will ignore the `page` argument.
         """
         hits = self.service.search(
             identity=g.identity,
             request_id=resource_requestctx.view_args["request_id"],
-            include_event_id=resource_requestctx.args.get("include_event_id"),
             params=resource_requestctx.args,
             search_preference=search_preference(),
             expand=resource_requestctx.args.get("expand", False),
         )
         return hits.to_dict(), 200
+
+    @list_view_args_parser
+    @request_extra_args
+    @search_args_parser
+    @response_handler(many=True)
+    def focussed_list(self):
+        """List the page containing the event with ID focus_event_id, or the first page of results if this is not found."""
+        hits = self.service.focussed_list(
+            identity=g.identity,
+            request_id=resource_requestctx.view_args["request_id"],
+            focus_event_id=resource_requestctx.args.get("focus_event_id"),
+            page_size=resource_requestctx.args.get("size"),
+            search_preference=search_preference(),
+            expand=resource_requestctx.args.get("expand", False),
+        )
+        return hits.to_dict(), 200

invenio_requests/services/events/service.py

@@ -238,13 +238,7 @@ def delete(self, identity, id_, revision_id=None, uow=None):
         return True
 
     def search(
-        self,
-        identity,
-        request_id,
-        include_event_id=None,
-        params=None,
-        search_preference=None,
-        **kwargs
+        self, identity, request_id, params=None, search_preference=None, **kwargs
     ):
         """Search for events for a given request matching the querystring."""
         params = params or {}
@@ -255,45 +249,82 @@ def search(
         request = self._get_request(request_id)
         self.require_permission(identity, "read", request=request)
 
-        request_filter = dsl.Q("term", request_id=str(request.id))
-
         # Prepare the search
-        search = self._search(
+        search_result = self._search(
             "search",
             identity,
             params,
             search_preference,
             permission_action="unused",
-            extra_filter=request_filter,
+            extra_filter=dsl.Q("term", request_id=str(request.id)),
             versioning=False,
             **kwargs,
+        ).execute()
+
+        return self.result_list(
+            self,
+            identity,
+            search_result,
+            params,
+            links_tpl=LinksTemplate(
+                self.config.links_search,
+                context={"request_id": str(request_id), "args": params},
+            ),
+            links_item_tpl=self.links_item_tpl,
+            expandable_fields=self.expandable_fields,
+            expand=expand,
         )
 
-        if include_event_id is not None:
-            # If a specific event ID is requested, we need to work out the corresponding page number.
-            event = None
-            try:
-                event = self._get_event(include_event_id)
-            except sqlalchemy.exc.NoResultFound:
-                # Silently ignore
-                pass
-
-            if event is not None:
-                self.require_permission(identity, "read", request=request, event=event)
-
-                num_older_than_event = search.filter(
-                    "range", created={"lt": event.created}
-                ).count()
-                page = num_older_than_event // params["size"] + 1
-                # Re run the pagination param interpreter to update the search with the new page number
-                params.update(page=page)
-                search = PaginationParam(self.config.search).apply(
-                    identity, search, params
-                )
+    def focussed_list(
+        self,
+        identity,
+        request_id,
+        focus_event_id,
+        page_size,
+        expand=False,
+        search_preference=None,
+    ):
+        """Return a page of results focussed on a given event, or the first page if the event is not found."""
+
+        # Permissions - guarded by the request's can_read.
+        request = self._get_request(request_id)
+        self.require_permission(identity, "read", request=request)
+
+        # If a specific event ID is requested, we need to work out the corresponding page number.
+        focus_event = None
+        try:
+            focus_event = self._get_event(focus_event_id)
+        except sqlalchemy.exc.NoResultFound:
+            # Silently ignore
+            pass
+
+        params = {"sort": "oldest", "size": page_size}
+        search = self._search(
+            "search",
+            identity,
+            params,
+            search_preference,
+            permission_action="unused",
+            extra_filter=dsl.Q("term", request_id=str(request.id)),
+            versioning=False,
+        )
+
+        page = 1
+        if focus_event is not None:
+            self.require_permission(
+                identity, "read", request=request, event=focus_event
+            )
+            num_older_than_event = search.filter(
+                "range", created={"lt": focus_event.created}
+            ).count()
+            page = num_older_than_event // page_size + 1
+
+        # Re run the pagination param interpreter to update the search with the new page number
+        params.update(page=page)
+        search = PaginationParam(self.config.search).apply(identity, search, params)
 
         # We deactivated versioning before (it doesn't apply for count queries) so we need to re-enable it.
         search_result = search.params(version=True).execute()
-
         return self.result_list(
             self,
             identity,

invenio_requests/services/requests/config.py

@@ -107,6 +107,7 @@ class RequestsServiceConfig(RecordServiceConfig, ConfiguratorMixin):
         "self_html": RequestLink("{+ui}/requests/{id}"),
         "comments": RequestLink("{+api}/requests/{id}/comments"),
         "timeline": RequestLink("{+api}/requests/{id}/timeline"),
+        "timeline_focussed": RequestLink("{+api}/requests/{id}/timeline_focussed"),
     }
     links_search = pagination_links("{+api}/requests{?args*}")
     links_user_requests_search = pagination_links("{+api}/user/requests{?args*}")