migrate to typescript

src/routes/getSkipSegments.ts

@@ -0,0 +1,190 @@
+import {config} from '../config';
+import {db, privateDB} from '../databases/databases';
+import {Logger} from '../utils/logger';
+import {getHash} from '../utils/getHash';
+import {getIP} from '../utils/getIP';
+import {Request, Response} from 'express';
+
+
+function cleanGetSegments(req: Request, videoID: string, categories: any[]) {
+    let userHashedIP: any;
+    let shadowHiddenSegments: any[];
+
+    let segments: { category: any; segment: any[]; UUID: any; }[] = [];
+
+    try {
+        for (const category of categories) {
+            const categorySegments: any[] = db
+                .prepare(
+                    'all',
+                    'SELECT startTime, endTime, votes, UUID, shadowHidden FROM sponsorTimes WHERE videoID = ? and category = ? ORDER BY startTime',
+                    [videoID, category],
+                )
+                .filter((segment: any) => {
+                    if (segment.votes < -1) {
+                        return false; //too untrustworthy, just ignore it
+                    }
+
+                    //check if shadowHidden
+                    //this means it is hidden to everyone but the original ip that submitted it
+                    if (segment.shadowHidden != 1) {
+                        return true;
+                    }
+
+                    if (shadowHiddenSegments === undefined) {
+                        shadowHiddenSegments = privateDB.prepare('all', 'SELECT hashedIP FROM sponsorTimes WHERE videoID = ?', [videoID]);
+                    }
+
+                    //if this isn't their ip, don't send it to them
+                    return shadowHiddenSegments.some(shadowHiddenSegment => {
+                        if (userHashedIP === undefined) {
+                            //hash the IP only if it's strictly necessary
+                            userHashedIP = getHash(getIP(req) + config.globalSalt);
+                        }
+                        return shadowHiddenSegment.hashedIP === userHashedIP;
+                    });
+                });
+
+            chooseSegments(categorySegments).forEach((chosenSegment: any) => {
+                segments.push({
+                    category,
+                    segment: [chosenSegment.startTime, chosenSegment.endTime],
+                    UUID: chosenSegment.UUID,
+                });
+            });
+        }
+
+        return segments;
+    } catch (err) {
+        if (err) {
+            Logger.error(err);
+            return null;
+        }
+    }
+}
+
+//gets a weighted random choice from the choices array based on their `votes` property.
+//amountOfChoices specifies the maximum amount of choices to return, 1 or more.
+//choices are unique
+function getWeightedRandomChoice(choices: any[], amountOfChoices: number) {
+    //trivial case: no need to go through the whole process
+    if (amountOfChoices >= choices.length) {
+        return choices;
+    }
+
+    //assign a weight to each choice
+    let totalWeight = 0;
+    choices = choices.map(choice => {
+        //The 3 makes -2 the minimum votes before being ignored completely
+        //https://www.desmos.com/calculator/c1duhfrmts
+        //this can be changed if this system increases in popularity.
+        const weight = Math.exp((choice.votes + 3));  // TODO TYPESCRIPT what was this 0.85?
+        totalWeight += weight;
+
+        return {...choice, weight};
+    });
+
+    //iterate and find amountOfChoices choices
+    const chosen = [];
+    while (amountOfChoices-- > 0) {
+        //weighted random draw of one element of choices
+        const randomNumber = Math.random() * totalWeight;
+        let stackWeight = choices[0].weight;
+        let i = 0;
+        while (stackWeight < randomNumber) {
+            stackWeight += choices[++i].weight;
+        }
+
+        //add it to the chosen ones and remove it from the choices before the next iteration
+        chosen.push(choices[i]);
+        totalWeight -= choices[i].weight;
+        choices.splice(i, 1);
+    }
+
+    return chosen;
+}
+
+//This function will find segments that are contained inside of eachother, called similar segments
+//Only one similar time will be returned, randomly generated based on the sqrt of votes.
+//This allows new less voted items to still sometimes appear to give them a chance at getting votes.
+//Segments with less than -1 votes are already ignored before this function is called
+function chooseSegments(segments: any[]) {
+    //Create groups of segments that are similar to eachother
+    //Segments must be sorted by their startTime so that we can build groups chronologically:
+    //1. As long as the segments' startTime fall inside the currentGroup, we keep adding them to that group
+    //2. If a segment starts after the end of the currentGroup (> cursor), no other segment will ever fall
+    //   inside that group (because they're sorted) so we can create a new one
+    const similarSegmentsGroups: any[] = [];
+    let currentGroup: any;
+    let cursor = -1; //-1 to make sure that, even if the 1st segment starts at 0, a new group is created
+    segments.forEach(segment => {
+        if (segment.startTime > cursor) {
+            currentGroup = {segments: [], votes: 0};
+            similarSegmentsGroups.push(currentGroup);
+        }
+
+        currentGroup.segments.push(segment);
+        //only if it is a positive vote, otherwise it is probably just a sponsor time with slightly wrong time
+        if (segment.votes > 0) {
+            currentGroup.votes += segment.votes;
+        }
+
+        cursor = Math.max(cursor, segment.endTime);
+    });
+
+    //if there are too many groups, find the best 8
+    return getWeightedRandomChoice(similarSegmentsGroups, 8).map(
+        //randomly choose 1 good segment per group and return them
+        group => getWeightedRandomChoice(group.segments, 1)[0],
+    );
+}
+
+/**
+ *
+ * Returns what would be sent to the client.
+ * Will respond with errors if required. Returns false if it errors.
+ *
+ * @param req
+ * @param res
+ *
+ * @returns
+ */
+function handleGetSegments(req: Request, res: Response) {
+    const videoID = req.query.videoID as string;
+    // Default to sponsor
+    // If using params instead of JSON, only one category can be pulled
+    const categories = req.query.categories
+        ? JSON.parse(req.query.categories as string)
+        : req.query.category
+            ? [req.query.category]
+            : ['sponsor'];
+
+    let segments = cleanGetSegments(req, videoID, categories);
+
+    if (segments === null || segments === undefined) {
+        res.sendStatus(500);
+        return false;
+    }
+
+    if (segments.length == 0) {
+        res.sendStatus(404);
+        return false;
+    }
+
+    return segments;
+}
+
+function endpoint(req: Request, res: Response) {
+    const segments = handleGetSegments(req, res);
+
+    if (segments) {
+        //send result
+        res.send(segments);
+    }
+}
+
+export {
+    handleGetSegments,
+    cleanGetSegments,
+    endpoint,
+};