feat: Update useSerialLogs to accept URL params

Author: steverydz

static/js/publisher/hooks/__tests__/useSerialLogs.test.tsx

@@ -90,6 +90,72 @@ describe("useSerialLogs", () => {
     });
   });
 
+  test("returns serial logs data with pageSize param", async () => {
+    const { result } = renderHook(
+      () =>
+        useSerialLogs("test-brand-id", "test-model", {
+          pageSize: 10,
+        }),
+      {
+        wrapper: createWrapper(),
+      },
+    );
+
+    await waitFor(() => {
+      expect(result.current.isSuccess).toBe(true);
+    });
+
+    expect(result.current.data).toEqual({
+      data: serialLogsResponse,
+      success: true,
+    });
+  });
+
+  test("returns serial logs data with startTime and endTime params", async () => {
+    const { result } = renderHook(
+      () =>
+        useSerialLogs("test-brand-id", "test-model", {
+          startTime: "2026-03-24T04:00:23.875000",
+          endTime: "2026-03-28T04:00:23.875000",
+        }),
+      {
+        wrapper: createWrapper(),
+      },
+    );
+
+    await waitFor(() => {
+      expect(result.current.isSuccess).toBe(true);
+    });
+
+    expect(result.current.data).toEqual({
+      data: serialLogsResponse,
+      success: true,
+    });
+  });
+
+  test("returns serial logs data with startTime, endTime and pageSize params", async () => {
+    const { result } = renderHook(
+      () =>
+        useSerialLogs("test-brand-id", "test-model", {
+          startTime: "2026-03-24T04:00:23.875000",
+          endTime: "2026-03-28T04:00:23.875000",
+          pageSize: 10,
+        }),
+      {
+        wrapper: createWrapper(),
+      },
+    );
+
+    await waitFor(() => {
+      expect(result.current.isSuccess).toBe(true);
+    });
+
+    expect(result.current.data).toEqual({
+      data: serialLogsResponse,
+      success: true,
+    });
+  });
+
   test("returns error if request fails", async () => {
     const { result } = renderHook(
       () => useSerialLogs("test-brand-id-fail", "test-model"),

static/js/publisher/hooks/useSerialLogs.ts

@@ -4,13 +4,35 @@ import type { SerialLogResponse, ApiResponse } from "../types/shared";
 const useSerialLogs = (
   brandId: string | undefined,
   modelId: string | undefined,
+  urlSearchParams?: {
+    startTime?: string;
+    endTime?: string;
+    pageSize?: number;
+  },
 ): UseQueryResult<ApiResponse<SerialLogResponse>, Error> => {
+  const url = new URL(
+    `/api/store/${brandId}/models/${modelId}/serial-log`,
+    window.location.origin,
+  );
+
+  if (urlSearchParams) {
+    const { startTime, endTime, pageSize } = urlSearchParams;
+
+    if (startTime && endTime) {
+      url.searchParams.set("start-time", startTime);
+      url.searchParams.set("end-time", endTime);
+    }
+
+    if (pageSize) {
+      url.searchParams.set("page-size", pageSize.toString());
+    }
+  }
+
   return useQuery<ApiResponse<SerialLogResponse>, Error>({
-    queryKey: ["serials", brandId, modelId],
+    queryKey: ["serials", brandId, modelId, urlSearchParams],
     queryFn: async () => {
-      const response = await fetch(
-        `/api/store/${brandId}/models/${modelId}/serial-log`,
-      );
+      const enc = encodeURI(url.toString());
+      const response = await fetch(enc);
       const responseData = await response.json();
 
       return responseData;

tests/endpoints/tests_models.py

@@ -427,3 +427,70 @@ def test_get_serial_log_general_error(self, mock_get_serial_log):
         self.assertEqual(response.status_code, 500)
         self.assertFalse(data["success"])
         self.assertEqual(data["message"], "Internal server error")
+
+    @patch(
+        "canonicalwebteam.store_api.publishergw.PublisherGW"
+        + ".get_store_model_serial_logs"
+    )
+    def test_get_serial_log_with_time_range(self, mock_get_serial_log):
+        mock_serial_log = []
+        mock_get_serial_log.return_value = mock_serial_log
+        response = self.client.get(
+            "/api/store/1/models/test-model/serial-log"
+            "?start-time=2026-06-01T00:00:00Z"
+            "&end-time=2026-06-30T23:59:59Z"
+        )
+        data = response.json
+
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(data["success"])
+        self.assertEqual(data["data"], [])
+
+    @patch(
+        "canonicalwebteam.store_api.publishergw.PublisherGW"
+        + ".get_store_model_serial_logs"
+    )
+    def test_get_serial_log_with_page_size(self, mock_get_serial_log):
+        mock_serial_log = [
+            {
+                "brand-id": "test-brand-id",
+                "created-at": "2026-03-23T04:00:23.875000",
+                "model-name": "test-model",
+                "serial": "test-serial",
+            }
+        ]
+        mock_get_serial_log.return_value = mock_serial_log
+        response = self.client.get(
+            "/api/store/1/models/test-model/serial-log?page-size=50"
+        )
+        data = response.json
+
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(data["success"])
+        self.assertEqual(data["data"], mock_serial_log)
+
+    @patch(
+        "canonicalwebteam.store_api.publishergw.PublisherGW"
+        + ".get_store_model_serial_logs"
+    )
+    def test_get_serial_log_with_all_parameters(self, mock_get_serial_log):
+        mock_serial_log = [
+            {
+                "brand-id": "test-brand-id",
+                "created-at": "2026-03-23T04:00:23.875000",
+                "model-name": "test-model",
+                "serial": "test-serial",
+            }
+        ]
+        mock_get_serial_log.return_value = mock_serial_log
+        response = self.client.get(
+            "/api/store/1/models/test-model/serial-log"
+            "?start-time=2026-01-01T00:00:00Z"
+            "&end-time=2026-12-31T23:59:59Z"
+            "&page-size=25"
+        )
+        data = response.json
+
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(data["success"])
+        self.assertEqual(data["data"], mock_serial_log)

webapp/endpoints/models.py

@@ -353,13 +353,19 @@ def create_remodel_allowlist(store_id: str):
 @login_required
 @exchange_required
 def get_serial_log(store_id: str, model_name: str):
+    start_time = flask.request.args.get("start-time")
+    end_time = flask.request.args.get("end-time")
+    page_size = flask.request.args.get("page-size")
     res = {}
 
     try:
         logs = publisher_gateway.get_store_model_serial_logs(
             flask.session,
             store_id,
             model_name,
+            start_time,
+            end_time,
+            page_size,
         )
         res["data"] = logs
         res["success"] = True