Dev to Main (RealDevSquad#128)

* Auto fetch task which are overdue

* added type definitions for taskoverdue, refactored the code and removed the use of any

* fixed return type of scheduled func

* added fixtures and tests for getDiscordIds func

* updated type def for user backend

* removed public key from .toml and removed kick command from baseHandler

* removed public key

* added error message in getDiscordIds.ts

* added fixture for taskOverdue, written test for taskOverDue, restructured the code of scheduleEventHandler, altered tests for getDiscordIds, refactored code for taskOverDueDiscordMembers, refactored code for getDiscordIds

* forgot to add updated typeDefinitions for taskOverdue

* extracted url to url.ts

* resolved comments by:bharti

* resolving comments

* keeping schedule event under comments

* error handling in scheduledEventHandler

* resolved comments by:bharti

* resolving comments by:dipayan

* replaced staging url with production

* inserted tracking channel id in url

* extracted super user discord id to constants

* BugFix: /listening (RealDevSquad#126)

* bug fix

* refactored te code

* major fixes

* resolved the comments

---------

Co-authored-by: Prakash Choudhary <[email protected]>

---------

Co-authored-by: FMK2312 <[email protected]>
Co-authored-by: Sunny Sahsi <[email protected]>
Co-authored-by: Fakhruddin KW <[email protected]>
Co-authored-by: Vinit khandal <[email protected]>
Co-authored-by: Prakash Choudhary <[email protected]>

Author: 5 people

src/constants/urls.ts

@@ -9,3 +9,6 @@ export const VERIFICATION_SITE_URL = "https://my.realdevsquad.com";
 export const DEVELOPMENT_VERIFICATION_SITE_URL = "http://localhost:3443";
 export const STAGING_VERIFICATION_SITE_URL =
   "https://staging-my.realdevsquad.com";
+
+export const RDS_TRACKING_CHANNEL_URL =
+  "https://discord.com/api/v10/channels/1136650427878871090/messages";

src/constants/variables.ts

@@ -0,0 +1,2 @@
+export const SUPER_USER_ONE = "154585730465660929";
+export const SUPER_USER_TWO = "1040700289348542566";

src/controllers/baseHandler.ts

@@ -60,26 +60,47 @@ export async function baseHandler(
       const data = message.data?.options;
       const setter = data ? data[0].value : false;
       const nickname = removeListening(message.member.nick || "");
+      let discordEphemeral;
+      let updateNickNameData = "";
       try {
         if (setter) {
-          if (!message.member.nick?.includes(NICKNAME_SUFFIX)) {
-            await updateNickName(
-              `${message.member.user.id}`,
-              NICKNAME_PREFIX + message.member.nick + NICKNAME_SUFFIX,
-              env
-            );
-            return discordEphemeralResponse(LISTENING_SUCCESS_MESSAGE);
+          if (
+            message.member.nick &&
+            !message.member.nick.includes(NICKNAME_SUFFIX)
+          ) {
+            updateNickNameData =
+              NICKNAME_PREFIX + message.member.nick + NICKNAME_SUFFIX;
+            discordEphemeral = LISTENING_SUCCESS_MESSAGE;
+          } else if (!message.member.nick) {
+            (updateNickNameData = NICKNAME_PREFIX + "" + NICKNAME_SUFFIX),
+              (discordEphemeral = LISTENING_SUCCESS_MESSAGE);
           } else {
-            return discordEphemeralResponse(ALREADY_LISTENING);
+            updateNickNameData = message.member.nick;
+            discordEphemeral = ALREADY_LISTENING;
           }
+        } else if (
+          !setter &&
+          !message.member.nick &&
+          message.member.user.username.includes(NICKNAME_SUFFIX)
+        ) {
+          updateNickNameData = message.member.user.username + NICKNAME_SUFFIX;
+
+          discordEphemeral = REMOVED_LISTENING_MESSAGE;
         } else {
           if (message.member.nick?.includes(NICKNAME_SUFFIX)) {
-            await updateNickName(`${message.member.user.id}`, nickname, env);
-            return discordEphemeralResponse(REMOVED_LISTENING_MESSAGE);
+            updateNickNameData = nickname;
+            discordEphemeral = REMOVED_LISTENING_MESSAGE;
           } else {
-            return discordEphemeralResponse(NOTHING_CHANGED);
+            updateNickNameData = nickname;
+            discordEphemeral = NOTHING_CHANGED;
           }
         }
+        await updateNickName(
+          message.member.user.id.toString(),
+          updateNickNameData,
+          env
+        );
+        return discordEphemeralResponse(discordEphemeral);
       } catch (err) {
         return discordEphemeralResponse(RETRY_COMMAND);
       }

src/handlers/scheduledEventHandler.ts

@@ -0,0 +1,56 @@
+import { env } from "../typeDefinitions/default.types";
+import { taskOverDueDiscordMembers } from "../utils/taskOverDueDiscordMembers";
+import * as error from "../constants/responses";
+import { getDiscordIds } from "../utils/getDiscordIds";
+import { RDS_TRACKING_CHANNEL_URL } from "../constants/urls";
+import { SUPER_USER_ONE, SUPER_USER_TWO } from "../constants/variables";
+
+export async function send(env: env): Promise<void> {
+  try {
+    const assigneeIds: string[] | string = await taskOverDueDiscordMembers();
+
+    //A user might have more than one task which are running red
+    //so to mention them just once, we are using Set to filter out
+    const discordIds: string[] | string = await getDiscordIds(assigneeIds);
+    const uniqueDiscordIds = [...new Set(discordIds)];
+
+    //notifying the two users with the authority.
+    let stringToBeSent = `<@${SUPER_USER_ONE}> <@${SUPER_USER_TWO}>\nThese people have their task running red:\n`;
+
+    let forFormatting = 0;
+    uniqueDiscordIds.forEach((id) => {
+      const discordUser = `<@${id}> `;
+      stringToBeSent += discordUser;
+      forFormatting++;
+      if (forFormatting === 3) {
+        //to keep 3 users/line
+        forFormatting = 0;
+        stringToBeSent += `\n`;
+      }
+    });
+
+    if (
+      assigneeIds === error.INTERNAL_SERVER_ERROR ||
+      discordIds === error.INTERNAL_SERVER_ERROR
+    ) {
+      throw new Error(error.INTERNAL_SERVER_ERROR);
+    }
+
+    const bodyObj = {
+      content: stringToBeSent,
+    };
+
+    const url = `${RDS_TRACKING_CHANNEL_URL}`;
+
+    const res = await fetch(url, {
+      method: "POST",
+      body: JSON.stringify(bodyObj),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bot ${env.DISCORD_TOKEN}`,
+      },
+    });
+  } catch (e) {
+    console.log(e);
+  }
+}

src/index.ts

@@ -16,6 +16,7 @@ import {
 import { getMembersInServerHandler } from "./controllers/getMembersInServer";
 import { changeNickname } from "./controllers/changeNickname";
 import { getGuildMemberDetailsHandler } from "./controllers/getGuildMemberDetailsHandler";
+import { send } from "./handlers/scheduledEventHandler";
 
 const router = Router();
 
@@ -50,6 +51,7 @@ router.delete("/roles", removeGuildRoleHandler);
 
 router.post("/", async (request, env) => {
   const message: discordMessageRequest = await request.json();
+
   if (message.type === InteractionType.PING) {
     return new JSONResponse({
       type: InteractionResponseType.PONG,
@@ -78,4 +80,11 @@ export default {
     }
     return router.handle(request, env);
   },
+
+  //keeping these code under comment until we patch the pagination
+  //of overdue tasks API
+
+  // async scheduled(req: Request, env: env, ctx: ExecutionContext) {
+  //   ctx.waitUntil(send(env));
+  // },
 };

src/register.ts

@@ -17,7 +17,7 @@ async function registerGuildCommands(
   discordApplicationId?: string,
   discordGuildId?: string
 ) {
-  const commands = [HELLO, VERIFY, MENTION_EACH];
+  const commands = [HELLO, VERIFY, MENTION_EACH, LISTENING];
 
   try {
     if (!discordBotToken) throw new Error("Please provide a BOT TOKEN");

src/typeDefinitions/taskOverdue.types.d.ts

@@ -0,0 +1,22 @@
+export interface TaskOverdue {
+  id: string;
+  title: string;
+  type: string;
+  endsOn: string;
+  startedOn: string;
+  status: string;
+  assignee?: string;
+  assigneeId: string;
+  percentCompleted: number;
+  dependsOn: string[];
+  participants?: string[];
+  isNoteworthy: boolean;
+  createdBy: string;
+}
+
+export interface TaskOverdueResponse {
+  message: string;
+  tasks: TaskOverdue[];
+  next?: string;
+  prev?: string;
+}

src/typeDefinitions/userBackend.types.d.ts

@@ -0,0 +1,13 @@
+export interface UserBackend {
+  message: string;
+  user: {
+    id: string;
+    username: string;
+    first_name: string;
+    last_name: string;
+    github_id: string;
+    discordId: string;
+    github_display_name: string;
+    isMember: boolean;
+  };
+}

src/utils/getDiscordIds.ts

@@ -0,0 +1,70 @@
+import { RDS_BASE_API_URL } from "../constants/urls";
+import { UserBackend } from "../typeDefinitions/userBackend.types";
+import * as response from "../constants/responses";
+
+export const getDiscordIds = async (
+  userIds: string[] | string
+): Promise<string[] | string> => {
+  try {
+    const url = `${RDS_BASE_API_URL}/users/userId`;
+
+    const numberOfBatches = Math.ceil(userIds.length / 6);
+
+    const fetchCollection = [] as Array<Promise<Response>[]>;
+
+    //for storing the data returned
+    const fetchResponseCollection = [] as Array<UserBackend[]>;
+
+    let indexCollection = 0;
+    let numberOfFetchCalls = 0;
+
+    const discordIds = [] as Array<string>;
+
+    //adding all batch
+    for (let i = 0; i < numberOfBatches; i++) {
+      const batch: Promise<Response>[] = [];
+      fetchCollection.push(batch);
+    }
+
+    //CF workers only allow 6 outgoing simultaneous request, so in order to retrieve all the data
+    //we are making fetch calls in the batches of 6
+
+    for (let i = 0; i < userIds.length; i++) {
+      fetchCollection[indexCollection].push(fetch(`${url}/${userIds[i]}`));
+      numberOfFetchCalls++;
+
+      if (numberOfFetchCalls == 6) {
+        indexCollection++;
+        numberOfFetchCalls = 0;
+      }
+    }
+
+    //now we will make parallel requests in the batches of 6.
+    //and extract the data in response array
+
+    for (let i = 0; i < numberOfBatches; i++) {
+      const responses = await Promise.all(fetchCollection[i]);
+      const json: Promise<UserBackend>[] = responses.map((response) =>
+        response.json()
+      );
+      const data = await Promise.all(json);
+
+      fetchResponseCollection.push(data);
+    }
+
+    //data contains arrays of User objects
+    //we are looping over nested arrays and extracting discordIds
+
+    fetchResponseCollection.forEach((dataArray: UserBackend[]) => {
+      dataArray.forEach((data: UserBackend) => {
+        if (data.user.discordId) {
+          discordIds.push(data.user.discordId);
+        }
+      });
+    });
+
+    return discordIds;
+  } catch (e) {
+    return response.INTERNAL_SERVER_ERROR;
+  }
+};

src/utils/taskOverDueDiscordMembers.ts

@@ -0,0 +1,25 @@
+import { RDS_BASE_API_URL } from "../constants/urls";
+import {
+  TaskOverdue,
+  TaskOverdueResponse,
+} from "../typeDefinitions/taskOverdue.types";
+import * as errors from "../constants/responses";
+
+export const taskOverDueDiscordMembers = async (): Promise<
+  string[] | string
+> => {
+  try {
+    const overDueUrl = `${RDS_BASE_API_URL}/tasks?dev=true&status=overdue&size=100`;
+
+    const response: Response = await fetch(overDueUrl);
+    const responseObj: TaskOverdueResponse = await response.json();
+
+    const assigneeIds: string[] = responseObj.tasks.map(
+      (task: TaskOverdue) => task.assigneeId
+    );
+
+    return assigneeIds;
+  } catch (e) {
+    return errors.INTERNAL_SERVER_ERROR;
+  }
+};