remove hash and extra segment params

src/routes/getSkipSegments.ts

@@ -97,7 +97,17 @@ async function getSegmentsByVideoID(req: Request, videoID: VideoID, categories:
 
         const canUseCache = requiredSegments.length === 0;
         let processedSegments: Segment[] = (await prepareCategorySegments(req, videoID, service, segments, cache, canUseCache))
-            .filter((segment: Segment) => categories.includes(segment?.category) && (actionTypes.includes(segment?.actionType)));
+            .filter((segment: Segment) => categories.includes(segment?.category) && (actionTypes.includes(segment?.actionType)))
+            .map((segment: Segment) => ({
+                category: segment.category,
+                actionType: segment.actionType,
+                segment: segment.segment,
+                UUID: segment.UUID,
+                videoDuration: segment.videoDuration,
+                locked: segment.locked,
+                votes: segment.votes,
+                description: segment.description
+            }));
 
         if (forcePoiAsSkip) {
             processedSegments = processedSegments.map((segment) => ({
@@ -127,15 +137,14 @@ async function getSegmentsByHash(req: Request, hashedVideoIDPrefix: VideoIDHash,
     }
 
     try {
-        type SegmentWithHashPerVideoID = SBRecord<VideoID, { hash: VideoIDHash, segments: DBSegment[] }>;
+        type SegmentPerVideoID = SBRecord<VideoID, { segments: DBSegment[] }>;
 
         categories = categories.filter((category) => !(/[^a-z|_|-]/.test(category)));
         if (categories.length === 0) return null;
 
-        const segmentPerVideoID: SegmentWithHashPerVideoID = (await getSegmentsFromDBByHash(hashedVideoIDPrefix, service))
+        const segmentPerVideoID: SegmentPerVideoID = (await getSegmentsFromDBByHash(hashedVideoIDPrefix, service))
-            .reduce((acc: SegmentWithHashPerVideoID, segment: DBSegment) => {
+            .reduce((acc: SegmentPerVideoID, segment: DBSegment) => {
                 acc[segment.videoID] = acc[segment.videoID] || {
-                    hash: segment.hashedVideoID,
                     segments: []
                 };
                 if (filterRequiredSegments(segment.UUID, requiredSegments)) segment.required = true;
@@ -148,13 +157,22 @@ async function getSegmentsByHash(req: Request, hashedVideoIDPrefix: VideoIDHash,
 
         await Promise.all(Object.entries(segmentPerVideoID).map(async ([videoID, videoData]) => {
             const data: VideoData = {
-                hash: videoData.hash,
                 segments: [],
             };
 
             const canUseCache = requiredSegments.length === 0;
             data.segments = (await prepareCategorySegments(req, videoID as VideoID, service, videoData.segments, cache, canUseCache))
-                .filter((segment: Segment) => categories.includes(segment?.category) && actionTypes.includes(segment?.actionType));
+                .filter((segment: Segment) => categories.includes(segment?.category) && actionTypes.includes(segment?.actionType))
+                .map((segment) => ({
+                    category: segment.category,
+                    actionType: segment.actionType,
+                    segment: segment.segment,
+                    UUID: segment.UUID,
+                    videoDuration: segment.videoDuration,
+                    locked: segment.locked,
+                    votes: segment.votes,
+                    description: segment.description
+                }));
 
             if (forcePoiAsSkip) {
                 data.segments = data.segments.map((segment) => ({

src/routes/getSkipSegmentsByHash.ts

@@ -71,7 +71,6 @@ export async function getSkipSegmentsByHash(req: Request, res: Response): Promis
     try {
         const output = Object.entries(segments).map(([videoID, data]) => ({
             videoID,
-            hash: data.hash,
             segments: data.segments,
         }));
         return res.status(output.length === 0 ? 404 : 200).json(output);

src/routes/getVideoLabel.ts

@@ -54,7 +54,6 @@ async function getLabelsByHash(hashedVideoIDPrefix: VideoIDHash, service: Servic
 
         for (const [videoID, videoData] of Object.entries(segmentPerVideoID)) {
             const data: VideoData = {
-                hash: videoData.hash,
                 segments: chooseSegment(videoData.segments),
             };
 

src/routes/getVideoLabelByHash.ts

@@ -20,7 +20,6 @@ export async function getVideoLabelsByHash(req: Request, res: Response): Promise
 
     const output = Object.entries(segments).map(([videoID, data]) => ({
         videoID,
-        hash: data.hash,
         segments: data.segments,
     }));
     return res.status(output.length === 0 ? 404 : 200).json(output);

src/types/segments.model.ts

@@ -45,6 +45,9 @@ export interface Segment {
     segment: number[];
     UUID: SegmentUUID;
     videoDuration: VideoDuration;
+    locked: boolean;
+    votes: number;
+    description: string;
 }
 
 export enum Visibility {
@@ -94,7 +97,6 @@ export interface VotableObjectWithWeight extends VotableObject {
 }
 
 export interface VideoData {
-    hash: VideoIDHash;
     segments: Segment[];
 }
 

test/cases/getSkipSegments.ts

@@ -46,7 +46,6 @@ describe("getSkipSegments", () => {
                 assert.strictEqual(data[0].votes, 1);
                 assert.strictEqual(data[0].locked, 0);
                 assert.strictEqual(data[0].videoDuration, 100);
-                assert.strictEqual(data[0].userID, "testman");
                 done();
             })
             .catch(err => done(err));