#795 Create new router for all deadline notifications, more abstraction

Author: alaneng-neu

.github/workflows/task-deadline-notifications.yml

@@ -10,5 +10,5 @@ jobs:
     steps:
       - name: Send notifications
         run: |
-          curl -X GET https://api.finishlinebyner.com/tasks/sendTaskDeadlineSlackNotifications \
+          curl -X GET https://api.finishlinebyner.com/deadline-notifications/sendTaskDeadlineSlackNotifications \
           -H 'Authorization: ${{ secrets.NOTIFICATION_ENDPOINT_SECRET }}'

src/backend/index.ts

@@ -12,6 +12,7 @@ import descriptionBulletsRouter from './src/routes/description-bullets.routes';
 import tasksRouter from './src/routes/tasks.routes';
 import reimbursementRequestsRouter from './src/routes/reimbursement-requests.routes';
 import designReviewRouter from './src/routes/design-review.routes';
+import deadlineNotificationsRouter from './src/routes/deadline-notifications.routes';
 
 const app = express();
 const port = process.env.PORT || 3001;
@@ -54,6 +55,7 @@ app.use('/description-bullets', descriptionBulletsRouter);
 app.use('/tasks', tasksRouter);
 app.use('/reimbursement-requests', reimbursementRequestsRouter);
 app.use('/design-reviews', designReviewRouter);
+app.use('/deadline-notifications', deadlineNotificationsRouter);
 app.use('/', (_req, res) => {
   res.json('Welcome to FinishLine');
 });

src/backend/src/controllers/deadline-notifications.controllers.ts

@@ -0,0 +1,15 @@
+import { NextFunction, Request, Response } from 'express';
+import DeadlineNotificationsService from '../services/deadline-notifications.services';
+
+export default class DeadlineNotificationsController {
+  static async sendTaskDeadlineSlackNotifications(_req: Request, res: Response, next: NextFunction) {
+    try {
+      const tomorrow = new Date(new Date().setHours(24, 0, 0, 0));
+      await DeadlineNotificationsService.sendTaskDeadlineSlackNotifications(tomorrow);
+
+      res.status(200).json({ message: 'Successfully sent task deadline notifications!' });
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+}

src/backend/src/controllers/tasks.controllers.ts

@@ -91,15 +91,4 @@ export default class TasksController {
       next(error);
     }
   }
-
-  static async sendTaskDeadlineSlackNotifications(_req: Request, res: Response, next: NextFunction) {
-    try {
-      const tomorrow = new Date().setHours(24, 0, 0, 0);
-      await TasksService.sendTaskDeadlineSlackNotifications(tomorrow);
-
-      res.status(200).json({ success: 'true' });
-    } catch (error: unknown) {
-      next(error);
-    }
-  }
 }

src/backend/src/routes/deadline-notifications.routes.ts

@@ -0,0 +1,11 @@
+import express from 'express';
+import DeadlineNotificationsController from '../controllers/deadline-notifications.controllers';
+
+const deadlineNotificationsRouter = express.Router();
+
+deadlineNotificationsRouter.get(
+  '/sendTaskDeadlineSlackNotifications',
+  DeadlineNotificationsController.sendTaskDeadlineSlackNotifications
+);
+
+export default deadlineNotificationsRouter;

src/backend/src/routes/tasks.routes.ts

@@ -38,6 +38,4 @@ tasksRouter.post(
 
 tasksRouter.post('/:taskId/delete', TasksController.deleteTask);
 
-tasksRouter.get('/sendTaskDeadlineSlackNotifications', TasksController.sendTaskDeadlineSlackNotifications);
-
 export default tasksRouter;

src/backend/src/services/deadline-notifications.services.ts

@@ -0,0 +1,72 @@
+import prisma from '../prisma/prisma';
+import { TaskWithAssignees, getTeamFromTaskAssignees, usersToSlackPings } from '../utils/deadline-notifications.utils';
+import { sendMessage } from '../integrations/slack';
+
+export default class DeadlineNotificationsService {
+  /**
+   * Sends the task deadline slack notifications for all tasks with a deadline of the given date
+   * @param deadline the beginning of the deadline date (at 12am)
+   */
+  static async sendTaskDeadlineSlackNotifications(deadline: Date) {
+    const startOfDay = deadline;
+    const endOfDay = new Date(startOfDay);
+    endOfDay.setDate(startOfDay.getDate() + 1);
+
+    const tasks = await prisma.task.findMany({
+      where: {
+        deadline: {
+          gte: startOfDay,
+          lt: endOfDay
+        },
+        status: {
+          not: 'DONE'
+        }
+      },
+      include: {
+        assignees: {
+          include: {
+            userSecureSettings: true,
+            userSettings: true,
+            teamAsHead: true,
+            teamsAsLead: true,
+            teamsAsMember: true
+          }
+        },
+        wbsElement: {
+          include: {
+            project: { include: { teams: true } }
+          }
+        }
+      }
+    });
+
+    const teamTaskMap = new Map<string, TaskWithAssignees[]>();
+
+    // group tasks due by team in a map
+    tasks.forEach((task) => {
+      const teamSlackId = getTeamFromTaskAssignees(task.assignees);
+
+      const currentTasks = teamTaskMap.get(teamSlackId);
+      if (currentTasks) {
+        currentTasks.push(task);
+        teamTaskMap.set(teamSlackId, currentTasks);
+      } else {
+        teamTaskMap.set(teamSlackId, [task]);
+      }
+    });
+
+    // send the notifications to each team for their respective tasks
+    teamTaskMap.forEach((tasks, slackId) => {
+      const messageBlock = tasks
+        .map(
+          (task) =>
+            `${usersToSlackPings(task.assignees ?? [])} Reminder: ${task.title} due tomorrow in project ${
+              task.wbsElement?.name
+            }`
+        )
+        .join('\n\n');
+
+      sendMessage(slackId, messageBlock);
+    });
+  }
+}

src/backend/src/services/tasks.services.ts

@@ -6,17 +6,10 @@ import teamQueryArgs from '../prisma-query-args/teams.query-args';
 import prisma from '../prisma/prisma';
 import taskTransformer from '../transformers/tasks.transformer';
 import { NotFoundException, AccessDeniedException, HttpException, DeletedException } from '../utils/errors.utils';
-import {
-  TaskWithAssignees,
-  getTeamFromTaskAssignees,
-  hasPermissionToEditTask,
-  sendSlackTaskAssignedNotificationToUsers,
-  usersToSlackIds
-} from '../utils/tasks.utils';
+import { hasPermissionToEditTask, sendSlackTaskAssignedNotificationToUsers } from '../utils/tasks.utils';
 import { areUsersPartOfTeams, isUserOnTeam } from '../utils/teams.utils';
 import { getUsers } from '../utils/users.utils';
 import { wbsNumOf } from '../utils/utils';
-import { sendMessage } from '../integrations/slack';
 
 export default class TasksService {
   /**
@@ -265,69 +258,4 @@ export default class TasksService {
 
     return deletedTask.taskId;
   }
-
-  /**
-   * Sends the task deadline slack notifications for all tasks with a deadline of the given date
-   * @param deadline the deadline date as a number
-   */
-  static async sendTaskDeadlineSlackNotifications(deadline: number) {
-    const startOfDay = new Date(deadline);
-    const endOfDay = new Date(startOfDay);
-    endOfDay.setDate(startOfDay.getDate() + 1);
-
-    const tasks = await prisma.task.findMany({
-      where: {
-        deadline: {
-          gte: startOfDay,
-          lt: endOfDay
-        },
-        status: {
-          not: 'DONE'
-        }
-      },
-      include: {
-        assignees: {
-          include: {
-            userSecureSettings: true,
-            userSettings: true,
-            teamAsHead: true,
-            teamsAsLead: true,
-            teamsAsMember: true
-          }
-        },
-        wbsElement: {
-          include: {
-            project: { include: { teams: true } }
-          }
-        }
-      }
-    });
-
-    const teamTaskMap = new Map<string, TaskWithAssignees[]>();
-
-    tasks.forEach((task) => {
-      const teamSlackId = getTeamFromTaskAssignees(task.assignees);
-
-      const currentTasks = teamTaskMap.get(teamSlackId);
-      if (currentTasks) {
-        currentTasks.push(task);
-        teamTaskMap.set(teamSlackId, currentTasks);
-      } else {
-        teamTaskMap.set(teamSlackId, [task]);
-      }
-    });
-
-    teamTaskMap.forEach((tasks, slackId) => {
-      const messageBlock = tasks
-        .map(
-          (task) =>
-            `${usersToSlackIds(task.assignees ?? [])} Reminder: ${task.title} due tomorrow in project ${
-              task.wbsElement?.name
-            }`
-        )
-        .join('\n\n');
-
-      sendMessage(slackId, messageBlock);
-    });
-  }
 }

src/backend/src/utils/auth.utils.ts

@@ -2,7 +2,7 @@ import jwt from 'jsonwebtoken';
 import { Request, Response, NextFunction } from 'express';
 import { JwtPayload, VerifyErrors } from 'jsonwebtoken';
 import prisma from '../prisma/prisma';
-import { NotFoundException } from './errors.utils';
+import { HttpException, NotFoundException } from './errors.utils';
 import { User, User_Secure_Settings, User_Settings } from '@prisma/client';
 
 const TOKEN_SECRET = process.env.TOKEN_SECRET || 'i<3security';
@@ -33,17 +33,9 @@ export const requireJwtProd = (req: Request, res: Response, next: NextFunction)
   ) {
     next();
   } else if (
-    req.path === '/tasks/sendTaskDeadlineSlackNotifications' // task deadline notification endpoint
+    req.path.startsWith('/deadline-notifications') // task deadline notification endpoint
   ) {
-    const { authorization } = req.headers;
-    const { NOTIFICATION_ENDPOINT_SECRET } = process.env;
-
-    if (!authorization) return res.status(401).json({ message: 'Authentication Failed: Secret not found!' });
-
-    if (authorization !== NOTIFICATION_ENDPOINT_SECRET)
-      return res.status(401).json({ message: 'Authentication Failed: Invalid secret!' });
-
-    next();
+    notificationEndpointAuth(req, res, next);
   } else {
     const { token } = req.cookies;
 
@@ -72,17 +64,9 @@ export const requireJwtDev = (req: Request, res: Response, next: NextFunction) =
   ) {
     next();
   } else if (
-    req.path === '/tasks/sendTaskDeadlineSlackNotifications' // task deadline notification endpoint
+    req.path.startsWith('/deadline-notifications') // task deadline notification endpoint
   ) {
-    const { authorization } = req.headers;
-    const { NOTIFICATION_ENDPOINT_SECRET } = process.env;
-
-    if (!authorization) return res.status(401).json({ message: 'Authentication Failed: Secret not found!' });
-
-    if (authorization !== NOTIFICATION_ENDPOINT_SECRET)
-      return res.status(401).json({ message: 'Authentication Failed: Invalid secret!' });
-
-    next();
+    notificationEndpointAuth(req, res, next);
   } else {
     const devUserId = req.headers.authorization;
 
@@ -94,6 +78,20 @@ export const requireJwtDev = (req: Request, res: Response, next: NextFunction) =
   }
 };
 
+const notificationEndpointAuth = (req: Request, res: Response, next: NextFunction) => {
+  const { authorization } = req.headers;
+  const { NOTIFICATION_ENDPOINT_SECRET } = process.env;
+
+  if (!NOTIFICATION_ENDPOINT_SECRET) throw new HttpException(500, 'Notification endpoint secret not found!');
+
+  if (!authorization) return res.status(401).json({ message: 'Authentication Failed: Secret not found!' });
+
+  if (authorization !== NOTIFICATION_ENDPOINT_SECRET)
+    return res.status(401).json({ message: 'Authentication Failed: Invalid secret!' });
+
+  next();
+};
+
 /**
  * get the user making the request.
  * @param res - we use the response because that's where we stored the userId data during jwt validation

src/backend/src/utils/deadline-notifications.utils.ts

@@ -0,0 +1,49 @@
+import { Team, Task as Prisma_Task, WBS_Element } from '@prisma/client';
+import { UserWithSettings } from './auth.utils';
+import { HttpException } from './errors.utils';
+
+export type UserWithTeams = UserWithSettings & {
+  teamAsHead: Team | null;
+  teamsAsLead: Team[] | null;
+  teamsAsMember: Team[] | null;
+};
+
+export type TaskWithAssignees = Prisma_Task & {
+  assignees: UserWithSettings[] | null;
+  wbsElement: WBS_Element | null;
+};
+
+export const usersToSlackPings = (users: UserWithSettings[]) => {
+  // https://api.slack.com/reference/surfaces/formatting#mentioning-users
+  return users.map((user) => `<@${user.userSettings?.slackId}>`).join(' ');
+};
+
+/**
+ * Gets the team of a task's assignees
+ * @param users the users of the task
+ * @returns the slack id of the team assigned to the task
+ */
+export const getTeamFromTaskAssignees = (users: UserWithTeams[]): string => {
+  const allTeams = users.map((user) => {
+    const teams = [];
+    if (user.teamAsHead) teams.push(user.teamAsHead);
+    if (user.teamsAsLead) teams.push(...user.teamsAsLead);
+    if (user.teamsAsMember) teams.push(...user.teamsAsMember);
+    return teams;
+  });
+
+  // Find common teams across all users
+  const commonTeams = allTeams.reduce((acc, teams, index) => {
+    if (index === 0) {
+      return teams;
+    }
+    return acc.filter((team) => teams.some((t) => t.teamId === team.teamId));
+  }, allTeams[0] || []);
+
+  // Assuming we return the Slack ID of the first common team if there are any
+  if (commonTeams.length > 0) {
+    return commonTeams[0].slackId; // Return the slackId of the first common team
+  }
+
+  throw new HttpException(400, 'All of the users do not share a team!');
+};