Merge pull request #2171 from Northeastern-Electric-Racing/#795-slack-ping-on-task-deadline

#795 slack ping on task deadline

Author: RChandler234

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

@@ -0,0 +1,14 @@
+name: Send Task Deadline Notifications
+
+on:
+  schedule:
+    - cron: '0 9 * * *'
+
+jobs:
+  send_notifications:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Send notifications
+        run: |
+          curl -X POST https://api.finishlinebyner.com/notifications/task-deadlines \
+          -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 notificationsRouter from './src/routes/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('/notifications', notificationsRouter);
 app.use('/', (_req, res) => {
   res.json('Welcome to FinishLine');
 });

src/backend/src/controllers/notifications.controllers.ts

@@ -0,0 +1,14 @@
+import { NextFunction, Request, Response } from 'express';
+import NotificationsService from '../services/notifications.services';
+
+export default class NotificationsController {
+  static async sendTaskDeadlineSlackNotifications(_req: Request, res: Response, next: NextFunction) {
+    try {
+      await NotificationsService.sendTaskDeadlineSlackNotifications();
+
+      res.status(200).json({ message: 'Successfully sent task deadline notifications!' });
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+}

src/backend/src/routes/notifications.routes.ts

@@ -0,0 +1,8 @@
+import express from 'express';
+import NotificationsController from '../controllers/notifications.controllers';
+
+const notificationsRouter = express.Router();
+
+notificationsRouter.post('/task-deadlines', NotificationsController.sendTaskDeadlineSlackNotifications);
+
+export default notificationsRouter;

src/backend/src/services/notifications.services.ts

@@ -0,0 +1,75 @@
+import prisma from '../prisma/prisma';
+import {
+  TaskWithAssignees,
+  endOfDayTomorrow,
+  getTeamFromTaskAssignees,
+  startOfDayTomorrow,
+  usersToSlackPings
+} from '../utils/notifications.utils';
+import { sendMessage } from '../integrations/slack';
+
+export default class NotificationsService {
+  /**
+   * Sends the task deadline slack notifications for all tasks with a deadline of tomorrow
+   */
+  static async sendTaskDeadlineSlackNotifications() {
+    const startOfDay = startOfDayTomorrow();
+    const endOfDay = endOfDayTomorrow();
+
+    const tasks = await prisma.task.findMany({
+      where: {
+        deadline: {
+          gte: startOfDay,
+          lt: endOfDay
+        },
+        status: {
+          not: 'DONE'
+        }
+      },
+      include: {
+        assignees: {
+          include: {
+            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).slackId;
+
+      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 ?? [])} ${task.title} due tomorrow in project ${task.wbsElement?.name}`
+        )
+        .join('\n\n');
+
+      // messageBlock will be empty if there are tasks with no assignees
+      if (messageBlock !== '')
+        sendMessage(slackId, ':sparkles: :pepe-coop: UPCOMING TASK DEADLINES :pepe-coop: :sparkles: \n\n\n' + messageBlock);
+    });
+  }
+}

src/backend/src/services/reimbursement-requests.services.ts

@@ -49,7 +49,7 @@ import {
   vendorTransformer
 } from '../transformers/reimbursement-requests.transformer';
 import reimbursementQueryArgs from '../prisma-query-args/reimbursement.query-args';
-import { UserWithSettings } from '../utils/auth.utils';
+import { UserWithSecureSettings } from '../utils/auth.utils';
 import { sendReimbursementRequestDeniedNotification } from '../utils/slack.utils';
 
 export default class ReimbursementRequestService {
@@ -111,7 +111,7 @@ export default class ReimbursementRequestService {
    * @returns the created reimbursement request
    */
   static async createReimbursementRequest(
-    recipient: UserWithSettings,
+    recipient: UserWithSecureSettings,
     dateOfExpense: Date,
     vendorId: string,
     account: ClubAccount,

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

@@ -7,7 +7,7 @@ import prisma from '../prisma/prisma';
 import taskTransformer from '../transformers/tasks.transformer';
 import { NotFoundException, AccessDeniedException, HttpException, DeletedException } from '../utils/errors.utils';
 import { hasPermissionToEditTask, sendSlackTaskAssignedNotificationToUsers } from '../utils/tasks.utils';
-import { areUsersPartOfTeams, isUserOnTeam } from '../utils/teams.utils';
+import { allUsersOnTeam, areUsersPartOfTeams, isUserOnTeam } from '../utils/teams.utils';
 import { getUsers } from '../utils/users.utils';
 import { wbsNumOf } from '../utils/utils';
 
@@ -80,6 +80,9 @@ export default class TasksService {
     if (!areUsersPartOfTeams(teams, users))
       throw new HttpException(400, `All assignees must be part of one of the project's team!`);
 
+    if (!teams.some((team) => allUsersOnTeam(team, users)))
+      throw new HttpException(400, 'All assignees must be part of the same team!');
+
     if (!isUnderWordCount(title, 15)) throw new HttpException(400, 'Title must be less than 15 words');
     if (!isUnderWordCount(notes, 250)) throw new HttpException(400, 'Notes must be less than 250 words');
 
@@ -202,6 +205,9 @@ export default class TasksService {
       throw new HttpException(400, "All assignees must be part of one of the project's teams");
     }
 
+    if (!teams.some((team) => allUsersOnTeam(team, assigneeUsers)))
+      throw new HttpException(400, 'All assignees must be part of the same team!');
+
     // retrieve userId for every assignee to update task's assignees in the database
     const transformedAssigneeUsers = assigneeUsers.map((user) => {
       return {

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';
@@ -32,6 +32,10 @@ export const requireJwtProd = (req: Request, res: Response, next: NextFunction)
     req.method === 'OPTIONS' // this is a pre-flight request and those don't send cookies
   ) {
     next();
+  } else if (
+    req.path.startsWith('/deadline-notifications') // task deadline notification endpoint
+  ) {
+    notificationEndpointAuth(req, res, next);
   } else {
     const { token } = req.cookies;
 
@@ -59,6 +63,10 @@ export const requireJwtDev = (req: Request, res: Response, next: NextFunction) =
     req.path === '/users' // dev login needs the list of users to log in
   ) {
     next();
+  } else if (
+    req.path.startsWith('/deadline-notifications') // task deadline notification endpoint
+  ) {
+    notificationEndpointAuth(req, res, next);
   } else {
     const devUserId = req.headers.authorization;
 
@@ -70,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
@@ -85,6 +107,9 @@ export const getCurrentUser = async (res: Response): Promise<User> => {
 
 export type UserWithSettings = User & {
   userSettings: User_Settings | null;
+};
+
+export type UserWithSecureSettings = UserWithSettings & {
   userSecureSettings: User_Secure_Settings | null;
 };
 
@@ -94,7 +119,7 @@ export type UserWithSettings = User & {
  * @returns the user with their user settings
  * @throws if no user with the userId exists
  */
-export const getCurrentUserWithUserSettings = async (res: Response): Promise<UserWithSettings> => {
+export const getCurrentUserWithUserSettings = async (res: Response): Promise<UserWithSecureSettings> => {
   const { userId } = res.locals;
   const user = await prisma.user.findUnique({
     where: { userId },

src/backend/src/utils/notifications.utils.ts

@@ -0,0 +1,53 @@
+import { Team, Task as Prisma_Task, WBS_Element } from '@prisma/client';
+import { UserWithSettings } from './auth.utils';
+import { HttpException } from './errors.utils';
+import { UserWithTeams, getTeamsFromUsers } from './teams.utils';
+
+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.
+ * Assumes all assigness share a team
+ * @param users the users of the task
+ * @returns the team assigned to the task
+ */
+export const getTeamFromTaskAssignees = (users: UserWithTeams[]): Team => {
+  const usersTeams = getTeamsFromUsers(users);
+
+  firstUsersTeams: for (const team of usersTeams[0]) {
+    for (let i = 1; i < usersTeams.length; i++) {
+      // If the team is not found in the current user's teams, continue to the next team
+      if (!usersTeams[i].some((t) => t.teamId === team.teamId)) continue firstUsersTeams;
+    }
+    return team;
+  }
+
+  throw new HttpException(400, 'All of the users do not share a team!');
+};
+
+/**
+ * Gets the beginning of the day tomorrow
+ * @returns the beginning of the day tomorrow (at 12am)
+ */
+export const startOfDayTomorrow = () => {
+  return new Date(new Date().setHours(24, 0, 0, 0));
+};
+
+/**
+ * Gets the end of the day tomorrow
+ * @returns the end of the day tomorrow (i.e. 12am of the following day)
+ */
+export const endOfDayTomorrow = () => {
+  const startOfDay = startOfDayTomorrow();
+  const endOfDay = new Date(startOfDay);
+  endOfDay.setDate(startOfDay.getDate() + 1);
+  return endOfDay;
+};

src/backend/src/utils/teams.utils.ts

@@ -1,4 +1,5 @@
-import { Prisma, User } from '@prisma/client';
+import { Prisma, User, Team } from '@prisma/client';
+import { UserWithSettings } from './auth.utils';
 
 const teamQueryArgsMembersOnly = Prisma.validator<Prisma.TeamArgs>()({
   include: {
@@ -50,3 +51,24 @@ export const areUsersPartOfTeams = (teams: Prisma.TeamGetPayload<typeof teamQuer
 export const isUserPartOfTeams = (teams: Prisma.TeamGetPayload<typeof teamQueryArgsMembersOnly>[], user: User) => {
   return teams.some((team) => isUserOnTeam(team, user));
 };
+
+export type UserWithTeams = UserWithSettings & {
+  teamAsHead: Team | null;
+  teamsAsLead: Team[] | null;
+  teamsAsMember: Team[] | null;
+};
+
+/**
+ * Gets the teams from a list of users
+ * @param users the users to get the teams from
+ * @returns an array of the teams each user is in
+ */
+export const getTeamsFromUsers = (users: UserWithTeams[]): Team[][] => {
+  return 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;
+  });
+};