Add endpoints for rating endpoint (dislikes)

https://github.com/ajayyy/SponsorBlock/issues/1039

src/app.ts

@@ -43,6 +43,8 @@ import ExpressPromiseRouter from "express-promise-router";
 import { Server } from "http";
 import { youtubeApiProxy } from "./routes/youtubeApiProxy";
 import { getChapterNames } from "./routes/getChapterNames";
+import { postRating } from "./routes/ratings/postRating";
+import { getRating } from "./routes/ratings/getRating";
 
 export function createServer(callback: () => void): Server {
     // Create a service (the app object is just a callback).
@@ -74,9 +76,11 @@ function setupRoutes(router: Router) {
     // Rate limit endpoint lists
     const voteEndpoints: RequestHandler[] = [voteOnSponsorTime];
     const viewEndpoints: RequestHandler[] = [viewedVideoSponsorTime];
+    const postRateEndpoints: RequestHandler[] = [postRating];
     if (config.rateLimit) {
         if (config.rateLimit.vote) voteEndpoints.unshift(rateLimitMiddleware(config.rateLimit.vote, voteGetUserID));
         if (config.rateLimit.view) viewEndpoints.unshift(rateLimitMiddleware(config.rateLimit.view));
+        if (config.rateLimit.rate) postRateEndpoints.unshift(rateLimitMiddleware(config.rateLimit.rate));
     }
 
     //add the get function
@@ -186,6 +190,10 @@ function setupRoutes(router: Router) {
 
     router.get("/api/lockReason", getLockReason);
 
+    // ratings
+    router.get("/api/ratings/rate/:prefix", getRating);
+    router.post("/api/ratings/rate", postRateEndpoints);
+
     if (config.postgres) {
         router.get("/database", (req, res) => dumpDatabase(req, res, true));
         router.get("/database.json", (req, res) => dumpDatabase(req, res, false));

src/config.ts

@@ -58,6 +58,12 @@ addDefaults(config, {
             statusCode: 200,
             message: "Too many views, please try again later",
         },
+        rate: {
+            windowMs: 900000,
+            max: 20,
+            statusCode: 200,
+            message: "Success",
+        }
     },
     userCounterURL: null,
     newLeafURLs: null,

src/routes/ratings/getRating.ts

@@ -0,0 +1,82 @@
+import { Request, Response } from "express";
+import { db } from "../../databases/databases";
+import { RatingType } from "../../types/ratings.model";
+import { Service, VideoID, VideoIDHash } from "../../types/segments.model";
+import { getService } from "../../utils/getService";
+import { hashPrefixTester } from "../../utils/hashPrefixTester";
+import { Logger } from "../../utils/logger";
+import { QueryCacher } from "../../utils/queryCacher";
+import { ratingHashKey } from "../../utils/redisKeys";
+
+interface DBRating {
+    videoID: VideoID,
+    hashedVideoID: VideoIDHash,
+    service: Service,
+    type: RatingType,
+    count: number
+}
+
+export async function getRating(req: Request, res: Response): Promise<Response> {
+    let hashPrefix = req.params.prefix as VideoIDHash;
+    if (!hashPrefix || !hashPrefixTester(hashPrefix)) {
+        return res.status(400).send("Hash prefix does not match format requirements."); // Exit early on faulty prefix
+    }
+    hashPrefix = hashPrefix.toLowerCase() as VideoIDHash;
+
+    let types: RatingType[] = [];
+    try {
+        types = req.query.types
+            ? JSON.parse(req.query.types as string)
+            : req.query.type
+                ? Array.isArray(req.query.type)
+                    ? req.query.type
+                    : [req.query.type]
+                : [RatingType.Upvote, RatingType.Downvote];
+        if (!Array.isArray(types)) {
+            return res.status(400).send("Categories parameter does not match format requirements.");
+        }
+
+        types = types.map((type) => parseInt(type as unknown as string, 10));
+    } catch(error) {
+        return res.status(400).send("Bad parameter: categories (invalid JSON)");
+    }
+
+    const service: Service = getService(req.query.service, req.body.service);
+
+    try {
+        const ratings = (await getRatings(hashPrefix, service))
+            .filter((rating) => types.includes(rating.type))
+            .map((rating) => ({
+                videoID: rating.videoID,
+                hash: rating.hashedVideoID,
+                service: rating.service,
+                type: rating.type,
+                count: rating.count
+            }));
+
+        if (ratings) {
+            res.status(200);
+        } else {
+            res.status(404);
+        }
+        return res.send(ratings ?? []);
+    } catch (err) {
+        Logger.error(err as string);
+        return res.sendStatus(500);
+    }
+}
+
+async function getRatings(hashPrefix: VideoIDHash, service: Service): Promise<DBRating[]> {
+    const fetchFromDB = () => db
+        .prepare(
+            "all",
+            `SELECT "videoID", "hashedVideoID", "type", "count" FROM "ratings" WHERE "hashedVideoID" LIKE ? AND "service" = ? ORDER BY "hashedVideoID"`,
+            [`${hashPrefix}%`, service]
+        ) as Promise<DBRating[]>;
+
+    if (hashPrefix.length === 4) {
+        return await QueryCacher.get(fetchFromDB, ratingHashKey(hashPrefix, service));
+    }
+
+    return fetchFromDB();
+}

src/routes/ratings/postRating.ts

@@ -0,0 +1,62 @@
+import { db, privateDB } from "../../databases/databases";
+import { getHash } from "../../utils/getHash";
+import { Logger } from "../../utils/logger";
+import { Request, Response } from "express";
+import { HashedUserID, UserID } from "../../types/user.model";
+import { HashedIP, IPAddress, VideoID } from "../../types/segments.model";
+import { getIP } from "../../utils/getIP";
+import { getService } from "../../utils/getService";
+import { RatingType, RatingTypes } from "../../types/ratings.model";
+import { config } from "../../config";
+
+export async function postRating(req: Request, res: Response): Promise<Response> {
+    const privateUserID = req.body.userID as UserID;
+    const videoID = req.body.videoID as VideoID;
+    const service = getService(req.query.service, req.body.service);
+    const type = req.body.type as RatingType;
+    const enabled = req.body.enabled ?? true;
+
+    if (privateUserID == undefined || videoID == undefined || service == undefined || type == undefined
+          || (typeof privateUserID !== "string") || (typeof videoID !== "string") || (typeof service !== "string")
+          || (typeof type !== "number") || (enabled && (typeof enabled !== "boolean")) || !RatingTypes.includes(type)) {
+        //invalid request
+        return res.sendStatus(400);
+    }
+
+    const hashedIP: HashedIP = getHash(getIP(req) + config.globalSalt as IPAddress, 1);
+    const hashedUserID: HashedUserID = getHash(privateUserID);
+    const hashedVideoID = getHash(videoID, 1);
+
+    try {
+        // Check if this user has voted before
+        const existingVote = await privateDB.prepare("get", `SELECT count(*) as "count" FROM "ratings" WHERE "videoID" = ? AND "service" = ? AND "type" = ? AND "userID" = ?`, [videoID, service, type, hashedUserID]);
+        if (existingVote.count > 0 && !enabled) {
+            // Undo the vote
+            await db.prepare("run", `UPDATE "ratings" SET "count" = "count" - 1 WHERE "videoID" = ? AND "service" = ? AND type = ?`, [videoID, service, type]);
+            await privateDB.prepare("run", `DELETE FROM "ratings" WHERE "videoID" = ? AND "service" = ? AND "type" = ? AND "userID" = ?`, [videoID, service, type, hashedUserID]);
+
+            return res.sendStatus(200);
+        } else if (existingVote.count === 0 && enabled) {
+            // Make sure there hasn't been another vote from this IP
+            const existingIPVote = (await privateDB.prepare("get", `SELECT count(*) as "count" FROM "ratings" WHERE "videoID" = ? AND "service" = ? AND "type" = ? AND "hashedIP" = ?`, [videoID, service, type, hashedIP]))
+                .count > 0;
+            if (!existingIPVote) {
+                // Check if general rating already exists, if so increase it
+                const rating = await db.prepare("get", `SELECT count(*) as "count" FROM "ratings" WHERE "videoID" = ? AND "service" = ? AND type = ?`, [videoID, service, type]);
+                if (rating.count > 0) {
+                    await db.prepare("run", `UPDATE "ratings" SET "count" = "count" + 1 WHERE "videoID" = ? AND "service" = ? AND type = ?`, [videoID, service, type]);
+                } else {
+                    await db.prepare("run", `INSERT INTO "ratings" ("videoID", "service", "type", "count", "hashedVideoID") VALUES (?, ?, ?, 1, ?)`, [videoID, service, type, hashedVideoID]);
+                }
+
+                // Create entry in privateDB
+                await privateDB.prepare("run", `INSERT INTO "ratings" ("videoID", "service", "type", "userID", "timeSubmitted", "hashedIP") VALUES (?, ?, ?, ?, ?, ?)`, [videoID, service, type, hashedUserID, Date.now(), hashedIP]);
+            }
+        }
+
+        return res.sendStatus(200);
+    } catch (err) {
+        Logger.error(err as string);
+        return res.sendStatus(500);
+    }
+}

src/types/config.model.ts

@@ -34,6 +34,7 @@ export interface SBSConfig {
     rateLimit: {
         vote: RateLimitConfig;
         view: RateLimitConfig;
+        rate: RateLimitConfig;
     };
     mysql?: any;
     privateMysql?: any;

src/types/ratings.model.ts

@@ -0,0 +1,6 @@
+export enum RatingType {
+    Downvote = 0,
+    Upvote = 1
+}
+
+export const RatingTypes = [RatingType.Downvote, RatingType.Upvote];

src/utils/getIP.ts

@@ -15,6 +15,6 @@ export function getIP(req: Request): IPAddress {
         case "X-Real-IP":
             return req.headers["x-real-ip"] as IPAddress;
         default:
-            return req.connection.remoteAddress as IPAddress;
+            return (req.connection?.remoteAddress || req.socket?.remoteAddress) as IPAddress;
     }
 }

src/utils/redisKeys.ts

@@ -16,3 +16,10 @@ export function skipSegmentsHashKey(hashedVideoIDPrefix: VideoIDHash, service: S
 export function reputationKey(userID: UserID): string {
     return `reputation.user.${userID}`;
 }
+
+export function ratingHashKey(hashPrefix: VideoIDHash, service: Service): string {
+    hashPrefix = hashPrefix.substring(0, 4) as VideoIDHash;
+    if (hashPrefix.length !== 4) Logger.warn(`Redis rating hash-prefix key is not length 4! ${hashPrefix}`);
+
+    return `rating.${service}.${hashPrefix}`;
+}