ajayyy · mchangrh · Oct 27, 2022 · Jan 22, 2023 · Jan 1, 2023 · Jan 1, 2023
diff --git a/src/routes/postSkipSegments.ts b/src/routes/postSkipSegments.ts
@@ -6,8 +6,7 @@ import { getSubmissionUUID } from "../utils/getSubmissionUUID";
 import { getHash } from "../utils/getHash";
 import { getHashCache } from "../utils/getHashCache";
 import { getIP } from "../utils/getIP";
-import { getFormattedTime } from "../utils/getFormattedTime";
-import { dispatchEvent } from "../utils/webhookUtils";
+import { createDiscordSegmentEmbed, dispatchEvent } from "../utils/webhookUtils";
 import { Request, Response } from "express";
 import { ActionType, Category, IncomingSegment, IPAddress, SegmentUUID, Service, VideoDuration, VideoID } from "../types/segments.model";
 import { deleteLockCategories } from "./deleteLockCategories";
@@ -24,6 +23,7 @@ import { canSubmit } from "../utils/permissions";
 import { getVideoDetails, videoDetails } from "../utils/getVideoDetails";
 import * as youtubeID from "../utils/youtubeID";
 import { banUser } from "./shadowBanUser";
+import { authorType } from "../types/webhook.model";
 
 type CheckResult = {
     pass: boolean,
@@ -37,67 +37,44 @@ const CHECK_PASS: CheckResult = {
     errorCode: 0
 };
 
-async function sendWebhookNotification(userID: string, videoID: string, UUID: string, submissionCount: number, youtubeData: videoDetails, { submissionStart, submissionEnd }: { submissionStart: number; submissionEnd: number; }, segmentInfo: any) {
-    const row = await db.prepare("get", `SELECT "userName" FROM "userNames" WHERE "userID" = ?`, [userID]);
-    const userName = row !== undefined ? row.userName : null;
-
-    let scopeName = "submissions.other";
-    if (submissionCount <= 1) {
-        scopeName = "submissions.new";
-    }
-
-    dispatchEvent(scopeName, {
-        "video": {
-            "id": videoID,
-            "title": youtubeData?.title,
-            "thumbnail": getMaxResThumbnail(videoID),
-            "url": `https://www.youtube.com/watch?v=${videoID}`,
-        },
-        "submission": {
-            "UUID": UUID,
-            "category": segmentInfo.category,
-            "startTime": submissionStart,
-            "endTime": submissionEnd,
-            "user": {
-                "UUID": userID,
-                "username": userName,
-            },
-        },
-    });
-}
-
 async function sendWebhooks(apiVideoDetails: videoDetails, userID: string, videoID: string, UUID: string, segmentInfo: any, service: Service) {
     if (apiVideoDetails && service == Service.YouTube) {
         const userSubmissionCountRow = await db.prepare("get", `SELECT count(*) as "submissionCount" FROM "sponsorTimes" WHERE "userID" = ?`, [userID]);
+        const row = await db.prepare("get", `SELECT "userName" FROM "userNames" WHERE "userID" = ?`, [userID]);
+        const username = row?.userName ?? null;
 
         const startTime = parseFloat(segmentInfo.segment[0]);
         const endTime = parseFloat(segmentInfo.segment[1]);
-        sendWebhookNotification(userID, videoID, UUID, userSubmissionCountRow.submissionCount, apiVideoDetails, {
-            submissionStart: startTime,
-            submissionEnd: endTime,
-        }, segmentInfo).catch((e) => Logger.error(`sending webhooks: ${e}`));
+        const newUser = userSubmissionCountRow.submissionCount <= 1;
+        const webhookData = {
+            user: {
+                status: newUser ? authorType.New : authorType.Other
+            },
+            video: {
+                id: (videoID as VideoID),
+                title: apiVideoDetails?.title,
+                url: `https://www.youtube.com/watch?v=${videoID}`,
+                thumbnail: getMaxResThumbnail(videoID),
+            },
+            submission: {
+                UUID: UUID as SegmentUUID,
+                category: segmentInfo.category,
+                startTime: startTime,
+                endTime: endTime,
+                user: {
+                    userID: userID as HashedUserID,
+                    username,
+                },
+            }
+        };
+        const discordEmbed = createDiscordSegmentEmbed(webhookData);
+        dispatchEvent(newUser ? "submissions.new": "submissions.other", webhookData);
 
         // If it is a first time submission
         // Then send a notification to discord
-        if (config.discordFirstTimeSubmissionsWebhookURL === null || userSubmissionCountRow.submissionCount > 1) return;
-
-        axios.post(config.discordFirstTimeSubmissionsWebhookURL, {
-            embeds: [{
-                title: apiVideoDetails.title,
-                url: `https://www.youtube.com/watch?v=${videoID}&t=${(parseInt(startTime.toFixed(0)) - 2)}s#requiredSegment=${UUID}`,
-                description: `Submission ID: ${UUID}\
-                    \n\nTimestamp: \
-                    ${getFormattedTime(startTime)} to ${getFormattedTime(endTime)}\
-                    \n\nCategory: ${segmentInfo.category}`,
-                color: 10813440,
-                author: {
-                    name: userID,
-                },
-                thumbnail: {
-                    url: getMaxResThumbnail(videoID),
-                },
-            }],
-        })
+        if (!config.discordFirstTimeSubmissionsWebhookURL || userSubmissionCountRow.submissionCount > 1) return;
+
+        axios.post(config.discordFirstTimeSubmissionsWebhookURL, { embeds: [discordEmbed] })
             .then(res => {
                 if (res.status >= 400) {
                     Logger.error("Error sending first time submission Discord hook");

diff --git a/src/routes/voteOnSponsorTime.ts b/src/routes/voteOnSponsorTime.ts
@@ -4,8 +4,8 @@ import { isUserVIP } from "../utils/isUserVIP";
 import { isUserTempVIP } from "../utils/isUserTempVIP";
 import { getMaxResThumbnail, YouTubeAPI } from "../utils/youtubeApi";
 import { db, privateDB } from "../databases/databases";
-import { dispatchEvent, getVoteAuthor, getVoteAuthorRaw } from "../utils/webhookUtils";
-import { getFormattedTime } from "../utils/getFormattedTime";
+import { dispatchEvent, getVoteAuthorRaw, createDiscordVoteEmbed } from "../utils/webhookUtils";
+import { WebhookData } from "../types/webhook.model";
 import { getIP } from "../utils/getIP";
 import { getHashCache } from "../utils/getHashCache";
 import { config } from "../config";
@@ -35,7 +35,7 @@ interface FinalResponse {
 }
 
 interface VoteData {
-    UUID: string;
+    UUID: SegmentUUID;
     nonAnonUserID: string;
     originalType: VoteType;
     voteTypeEnum: number;
@@ -47,7 +47,7 @@ interface VoteData {
         views: number;
         locked: boolean;
     };
-    category: string;
+    category: Category;
     incrementAmount: number;
     oldIncrementAmount: number;
     finalResponse: FinalResponse;
@@ -101,7 +101,7 @@ async function checkVideoDuration(UUID: SegmentUUID) {
 }
 
 async function sendWebhooks(voteData: VoteData) {
-    const submissionInfoRow = await db.prepare("get", `SELECT "s"."videoID", "s"."userID", s."startTime", s."endTime", s."category", u."userName",
+    const submissionInfoRow = await db.prepare("get", `SELECT "s"."videoID", "s"."userID", s."startTime", s."endTime", s."category",  u."userName",
         (select count(1) from "sponsorTimes" where "userID" = s."userID") count,
         (select count(1) from "sponsorTimes" where "userID" = s."userID" and votes <= -2) disregarded
         FROM "sponsorTimes" s left join "userNames" u on s."userID" = u."userID" where s."UUID"=?`,
@@ -133,62 +133,44 @@ async function sendWebhooks(voteData: VoteData) {
 
             const isUpvote = voteData.incrementAmount > 0;
             // Send custom webhooks
-            dispatchEvent(isUpvote ? "vote.up" : "vote.down", {
-                "user": {
-                    "status": getVoteAuthorRaw(userSubmissionCountRow.submissionCount, voteData.isTempVIP, voteData.isVIP, voteData.isOwnSubmission),
+            const webhookData: WebhookData = {
+                user: {
+                    status: getVoteAuthorRaw(userSubmissionCountRow.submissionCount, voteData.isTempVIP, voteData.isVIP, voteData.isOwnSubmission),
                 },
-                "video": {
-                    "id": submissionInfoRow.videoID,
-                    "title": data?.title,
-                    "url": `https://www.youtube.com/watch?v=${videoID}`,
-                    "thumbnail": getMaxResThumbnail(videoID),
+                video: {
+                    id: submissionInfoRow.videoID,
+                    title: data?.title,
+                    url: `https://www.youtube.com/watch?v=${videoID}`,
+                    thumbnail: getMaxResThumbnail(videoID),
                 },
-                "submission": {
-                    "UUID": voteData.UUID,
-                    "views": voteData.row.views,
-                    "category": voteData.category,
-                    "startTime": submissionInfoRow.startTime,
-                    "endTime": submissionInfoRow.endTime,
-                    "user": {
-                        "UUID": submissionInfoRow.userID,
-                        "username": submissionInfoRow.userName,
-                        "submissions": {
-                            "total": submissionInfoRow.count,
-                            "ignored": submissionInfoRow.disregarded,
+                submission: {
+                    UUID: voteData.UUID as SegmentUUID,
+                    views: voteData.row.views,
+                    locked: voteData.row.locked,
+                    category: voteData.category as Category,
+                    startTime: submissionInfoRow.startTime,
+                    endTime: submissionInfoRow.endTime,
+                    user: {
+                        userID: submissionInfoRow.userID,
+                        username: submissionInfoRow.userName,
+                        submissions: {
+                            total: submissionInfoRow.count,
+                            ignored: submissionInfoRow.disregarded,
                         },
                     },
                 },
-                "votes": {
-                    "before": voteData.row.votes,
-                    "after": (voteData.row.votes + voteData.incrementAmount - voteData.oldIncrementAmount),
+                votes: {
+                    before: voteData.row.votes,
+                    after: (voteData.row.votes + voteData.incrementAmount - voteData.oldIncrementAmount),
                 },
-            });
+                authorName: voteData.finalResponse?.webhookMessage ?? voteData.finalResponse?.finalMessage
+            };
+            dispatchEvent(isUpvote ? "vote.up" : "vote.down", webhookData);
 
             // Send discord message
             if (webhookURL !== null && !isUpvote) {
                 axios.post(webhookURL, {
-                    "embeds": [{
-                        "title": data?.title,
-                        "url": `https://www.youtube.com/watch?v=${submissionInfoRow.videoID}&t=${(submissionInfoRow.startTime.toFixed(0) - 2)}s#requiredSegment=${voteData.UUID}`,
-                        "description": `**${voteData.row.votes} Votes Prior | \
-                            ${(voteData.row.votes + voteData.incrementAmount - voteData.oldIncrementAmount)} Votes Now | ${voteData.row.views} \
-                            Views**\n\n**Locked**: ${voteData.row.locked}\n\n**Submission ID:** ${voteData.UUID}\
-                            \n**Category:** ${submissionInfoRow.category}\
-                            \n\n**Submitted by:** ${submissionInfoRow.userName}\n${submissionInfoRow.userID}\
-                            \n\n**Total User Submissions:** ${submissionInfoRow.count}\
-                            \n**Ignored User Submissions:** ${submissionInfoRow.disregarded}\
-                            \n\n**Timestamp:** \
-                            ${getFormattedTime(submissionInfoRow.startTime)} to ${getFormattedTime(submissionInfoRow.endTime)}`,
-                        "color": 10813440,
-                        "author": {
-                            "name": voteData.finalResponse?.webhookMessage ??
-                                    voteData.finalResponse?.finalMessage ??
-                                    `${getVoteAuthor(userSubmissionCountRow.submissionCount, voteData.isTempVIP, voteData.isVIP, voteData.isOwnSubmission)}${voteData.row.locked ? " (Locked)" : ""}`,
-                        },
-                        "thumbnail": {
-                            "url": getMaxResThumbnail(videoID),
-                        },
-                    }],
+                    "embeds": [createDiscordVoteEmbed(webhookData)],
                 })
                     .then(res => {
                         if (res.status >= 400) {

diff --git a/src/types/webhook.model.ts b/src/types/webhook.model.ts
@@ -0,0 +1,48 @@
+import * as segments from "./segments.model";
+import { HashedUserID } from "./user.model";
+
+export enum voteType {
+    up = "vote.up",
+    down = "vote.down",
+}
+
+export enum authorType {
+    Self = "self",
+    TempVIP = "temp vip",
+    VIP = "vip",
+    New = "new",
+    Other = "other",
+}
+
+export interface WebhookData {
+    user: {
+        status: authorType
+    }
+    video: {
+        id: segments.VideoID
+        title: string | undefined,
+        url: URL | string,
+        thumbnail: URL | string,
+    },
+    submission: {
+        UUID: segments.SegmentUUID,
+        views?: number,
+        locked?: boolean,
+        category: segments.Category,
+        startTime: number,
+        endTime: number,
+        user: {
+            userID: HashedUserID,
+            username: string | HashedUserID,
+            submissions?: {
+                total: number,
+                ignored: number,
+            },
+        },
+    },
+    votes?: {
+        before: number,
+        after: number
+    }
+    authorName?: string
+}
diff --git a/src/utils/innerTubeAPI.ts b/src/utils/innerTubeAPI.ts
@@ -34,7 +34,7 @@ async function getFromITube (videoID: string): Promise<innerTubeVideoDetails> {
         context: {
             client: {
                 clientName: "WEB",
-                clientVersion: "2.20221215.04.01"
+                clientVersion: "2.20230217.01.00"
             }
         },
         videoId: videoID