Merge pull request #421 from HaiDang666/392_getSearchSegments-pagination

add custom pagination in getSearchSegments
2025-12-11 22:17:14 +03:00 · 2021-12-20 22:36:22 -05:00
parent f54b9f7ae1 7caaf833dd
commit f6d68bb3f3
3 changed files with 291 additions and 9 deletions
--- a/src/routes/getSearchSegments.ts
+++ b/src/routes/getSearchSegments.ts
@@ -1,8 +1,9 @@
 import { Request, Response } from "express";
 import { db } from "../databases/databases";
-import { ActionType, Category, DBSegment, Service, VideoID } from "../types/segments.model";
+import { ActionType, Category, DBSegment, Service, VideoID, SortableFields } from "../types/segments.model";
 import { getService } from "../utils/getService";
-const segmentsPerPage = 10;
+const maxSegmentsPerPage = 100;
+const defaultSegmentsPerPage = 10;

 type searchSegmentResponse = {
    segmentCount: number,
@@ -19,6 +20,42 @@ function getSegmentsFromDBByVideoID(videoID: VideoID, service: Service): Promise
    ) as Promise<DBSegment[]>;
 }

+function getSortField<T extends string>(...value: T[]): SortableFields {
+    const fieldByName = Object.values(SortableFields).reduce((acc, fieldName) => {
+        acc[fieldName.toLowerCase()] = fieldName;
+
+        return acc;
+    }, {} as Record<string, SortableFields>);
+
+    for (const name of value) {
+        if (name?.trim()?.toLowerCase() in fieldByName) {
+            return fieldByName[name.trim().toLowerCase()];
+        }
+    }
+
+    return SortableFields.timeSubmitted;
+}
+
+function getLimit<T extends string>(value: T): number {
+    const limit = Number(value);
+    if (Number.isInteger(limit)
+        && limit >= 1
+        && limit <= maxSegmentsPerPage) {
+        return limit;
+    }
+
+    return defaultSegmentsPerPage;
+}
+
+function getPage<T extends string>(value: T): number {
+    const page = Number(value);
+    if (Number.isInteger(page) && page >= 0) {
+        return page;
+    }
+
+    return 0;
+}
+
 /**
 *
 * Returns what would be sent to the client.
@@ -62,8 +99,10 @@ async function handleGetSegments(req: Request, res: Response): Promise<searchSeg

    const service = getService(req.query.service, req.body.service);

-    let page: number = req.query.page ?? req.body.page ?? 0;
-    page = Number(page);
+    const page: number = getPage(req.query.page ?? req.body.page);
+    const limit: number = getLimit(req.query.limit ?? req.body.limit);
+    const sortBy: SortableFields = getSortField(req.query.sortBy, req.body.sortBy);
+    const sortDir: string = req.query.sortDir ?? req.body.sortDir ?? "asc";

    const minVotes: number = req.query.minVotes ?? req.body.minVotes ?? -3;
    const maxVotes: number = req.query.maxVotes ?? req.body.maxVotes ?? Infinity;
@@ -99,11 +138,11 @@ async function handleGetSegments(req: Request, res: Response): Promise<searchSeg
        return false;
    }

-    return filterSegments(segments, page, filters);
+    return filterSegments(segments, filters, page, limit, sortBy, sortDir);
 }
-function filterSegments(segments: DBSegment[], page: number, filters: Record<string, any>) {
-    const startIndex = 0+(page*segmentsPerPage);
-    const endIndex = segmentsPerPage+(page*segmentsPerPage);
+function filterSegments(segments: DBSegment[], filters: Record<string, any>, page: number, limit: number, sortBy: SortableFields, sortDir: string) {
+    const startIndex = 0+(page*limit);
+    const endIndex = limit+(page*limit);
    const filteredSegments = segments.filter((segment) =>
        !((segment.votes < filters.minVotes || segment.votes > filters.maxVotes)
            || (segment.views < filters.minViews || segment.views > filters.maxViews)
@@ -114,10 +153,27 @@ function filterSegments(segments: DBSegment[], page: number, filters: Record<str
        // return false if any of the conditions are met
        // return true if none of the conditions are met
    );
+
+    if (sortBy !== SortableFields.timeSubmitted) {
+        filteredSegments.sort((a,b) => {
+            const key = sortDir === "desc" ? 1 : -1;
+            if (a[sortBy] < b[sortBy]) {
+                return key;
+            }
+
+            if (a[sortBy] > b[sortBy]) {
+                return -key;
+            }
+
+            return 0;
+        });
+    }
+
    return {
        segmentCount: filteredSegments.length,
        page,
        segments: filteredSegments.slice(startIndex, endIndex)
+
    };
 }

--- a/src/types/segments.model.ts
+++ b/src/types/segments.model.ts
@@ -107,4 +107,12 @@ export interface LockCategory {
    reason: string,
    videoID: VideoID,
    userID: UserID
-}
+}
+
+export enum SortableFields {
+    timeSubmitted = "timeSubmitted",
+    startTime = "startTime",
+    endTime = "endTime",
+    votes = "votes",
+    views = "views",
+}
--- a/test/cases/getSearchSegments.ts
+++ b/test/cases/getSearchSegments.ts
@@ -281,4 +281,222 @@ describe("getSearchSegments", () => {
            })
            .catch(err => done(err));
    });
+
+    it("Should be able to get with custom limit", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", limit: 2 } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 0);
+                assert.strictEqual(segments.length, 2);
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be able to get with custom limit(2) and page(2)", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", limit: 2, page: 2 } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 2);
+                assert.strictEqual(segments.length, 2);
+                assert.strictEqual(segments[0].UUID, "search-page1-5");
+                assert.strictEqual(segments[1].UUID, "search-page1-6");
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be able to get with over range page", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", limit: 2, page: 2000 } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 2000);
+                assert.strictEqual(segments.length, 0);
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be able to get with invalid page (=-100)", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", page: -100 } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 0);
+                assert.strictEqual(segments.length, 10);
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be able to get with invalid page (=text)", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", page: "hello" } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 0);
+                assert.strictEqual(segments.length, 10);
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be use default limit if invalid limit query (=0)", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", limit: 0 } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 0);
+                assert.strictEqual(segments[0].UUID, "search-page1-1");
+                assert.strictEqual(segments[1].UUID, "search-page1-2");
+                assert.strictEqual(segments[2].UUID, "search-page1-3");
+                assert.strictEqual(segments[3].UUID, "search-page1-4");
+                assert.strictEqual(segments[4].UUID, "search-page1-5");
+                assert.strictEqual(segments[5].UUID, "search-page1-6");
+                assert.strictEqual(segments[6].UUID, "search-page1-7");
+                assert.strictEqual(segments[7].UUID, "search-page1-8");
+                assert.strictEqual(segments[8].UUID, "search-page1-9");
+                assert.strictEqual(segments[9].UUID, "search-page1-10");
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be use default limit if invalid limit query (=-100)", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", limit: -100 } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 0);
+                assert.strictEqual(segments[0].UUID, "search-page1-1");
+                assert.strictEqual(segments[1].UUID, "search-page1-2");
+                assert.strictEqual(segments[2].UUID, "search-page1-3");
+                assert.strictEqual(segments[3].UUID, "search-page1-4");
+                assert.strictEqual(segments[4].UUID, "search-page1-5");
+                assert.strictEqual(segments[5].UUID, "search-page1-6");
+                assert.strictEqual(segments[6].UUID, "search-page1-7");
+                assert.strictEqual(segments[7].UUID, "search-page1-8");
+                assert.strictEqual(segments[8].UUID, "search-page1-9");
+                assert.strictEqual(segments[9].UUID, "search-page1-10");
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be use default limit if invalid limit query (=text)", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", limit: "hello" } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 0);
+                assert.strictEqual(segments[0].UUID, "search-page1-1");
+                assert.strictEqual(segments[1].UUID, "search-page1-2");
+                assert.strictEqual(segments[2].UUID, "search-page1-3");
+                assert.strictEqual(segments[3].UUID, "search-page1-4");
+                assert.strictEqual(segments[4].UUID, "search-page1-5");
+                assert.strictEqual(segments[5].UUID, "search-page1-6");
+                assert.strictEqual(segments[6].UUID, "search-page1-7");
+                assert.strictEqual(segments[7].UUID, "search-page1-8");
+                assert.strictEqual(segments[8].UUID, "search-page1-9");
+                assert.strictEqual(segments[9].UUID, "search-page1-10");
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be use default limit if invalid limit query (=2000)", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", limit: 2000 } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 0);
+                assert.strictEqual(segments[0].UUID, "search-page1-1");
+                assert.strictEqual(segments[1].UUID, "search-page1-2");
+                assert.strictEqual(segments[2].UUID, "search-page1-3");
+                assert.strictEqual(segments[3].UUID, "search-page1-4");
+                assert.strictEqual(segments[4].UUID, "search-page1-5");
+                assert.strictEqual(segments[5].UUID, "search-page1-6");
+                assert.strictEqual(segments[6].UUID, "search-page1-7");
+                assert.strictEqual(segments[7].UUID, "search-page1-8");
+                assert.strictEqual(segments[8].UUID, "search-page1-9");
+                assert.strictEqual(segments[9].UUID, "search-page1-10");
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be able to get sorted result (desc)", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", sortBy: "endTime", sortDir: "desc" } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 0);
+                assert.strictEqual(segments[0].UUID, "search-page2-2");
+                assert.strictEqual(segments[1].UUID, "search-page2-1");
+                assert.strictEqual(segments[2].UUID, "search-page1-10");
+                assert.strictEqual(segments[3].UUID, "search-page1-9");
+                assert.strictEqual(segments[4].UUID, "search-page1-8");
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be able to get sorted result (asc)", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", sortBy: "endTime" } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 0);
+                assert.strictEqual(segments[0].UUID, "search-page1-1");
+                assert.strictEqual(segments[1].UUID, "search-page1-2");
+                assert.strictEqual(segments[2].UUID, "search-page1-3");
+                assert.strictEqual(segments[3].UUID, "search-page1-4");
+                assert.strictEqual(segments[4].UUID, "search-page1-5");
+                done();
+            })
+            .catch(err => done(err));
+    });
+
+    it("Should be use default sorted if invalid sort field", (done) => {
+        client.get(endpoint, { params: { videoID: "searchTest4", sortBy: "not exist", sortDir: "desc" } })
+            .then(res => {
+                assert.strictEqual(res.status, 200);
+                const data = res.data;
+                const segments = data.segments;
+                assert.strictEqual(data.segmentCount, 12);
+                assert.strictEqual(data.page, 0);
+                assert.strictEqual(segments[0].UUID, "search-page1-1");
+                assert.strictEqual(segments[1].UUID, "search-page1-2");
+                assert.strictEqual(segments[2].UUID, "search-page1-3");
+                assert.strictEqual(segments[3].UUID, "search-page1-4");
+                assert.strictEqual(segments[4].UUID, "search-page1-5");
+                done();
+            })
+            .catch(err => done(err));
+    });
 });