Merge pull request #2683 from Northeastern-Electric-Racing/Send-Weekly-Deadline-Checks

Send Weekly Deadlines and Overdue Task Reminders

Author: walker-sean

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

@@ -2,9 +2,9 @@ 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) {
+  static async sendDailySlackNotifications(_req: Request, res: Response, next: NextFunction) {
     try {
-      await NotificationsService.sendTaskDeadlineSlackNotifications();
+      await NotificationsService.sendDailySlackNotifications();
 
       res.status(200).json({ message: 'Successfully sent task deadline notifications!' });
     } catch (error: unknown) {

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

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

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

@@ -3,23 +3,40 @@ import {
   TaskWithAssignees,
   endOfDayTomorrow,
   getTeamFromTaskAssignees,
-  startOfDayTomorrow,
   usersToSlackPings
 } from '../utils/notifications.utils';
 import { sendMessage } from '../integrations/slack';
+import { daysBetween } from 'shared';
+import { buildDueString } from '../utils/slack.utils';
+import WorkPackagesService from './work-packages.services';
+import { addWeeksToDate } from 'shared';
+import { HttpException } from '../utils/errors.utils';
 
 export default class NotificationsService {
+  static async sendDailySlackNotifications() {
+    await NotificationsService.sendTaskDeadlineSlackNotifications();
+    const date = new Date();
+    if (date.getDay() === 1) {
+      const nextWeek = addWeeksToDate(date, 1);
+      const ADMIN = process.env.ADMIN_USER_ID;
+      const admin = await prisma.user.findUnique({ where: { userId: ADMIN } });
+      if (!admin) throw new HttpException(404, 'Admin user not found');
+      const organizations = await prisma.organization.findMany();
+      for (const organization of organizations) {
+        await WorkPackagesService.slackMessageUpcomingDeadlines(admin, nextWeek, organization.organizationId);
+      }
+    }
+  }
+
   /**
-   * Sends the task deadline slack notifications for all tasks with a deadline of tomorrow
+   * Sends the task deadline slack notifications for all tasks with a deadline of tomorrow or before that are not done
    */
   static async sendTaskDeadlineSlackNotifications() {
-    const startOfDay = startOfDayTomorrow();
     const endOfDay = endOfDayTomorrow();
 
     const tasks = await prisma.task.findMany({
       where: {
         deadline: {
-          gte: startOfDay,
           lt: endOfDay
         },
         status: {
@@ -61,10 +78,13 @@ export default class NotificationsService {
     // 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}`
-        )
+        .map((task) => {
+          const daysUntilDeadline = daysBetween(task.deadline, new Date());
+
+          return `${usersToSlackPings(task.assignees ?? [])} ${task.title} ${buildDueString(daysUntilDeadline)} in project ${
+            task.wbsElement?.name
+          }`;
+        })
         .join('\n\n');
 
       // messageBlock will be empty if there are tasks with no assignees

src/backend/src/services/work-packages.services.ts

@@ -1,5 +1,6 @@
 import { Prisma, User, WBS_Element, WBS_Element_Status } from '@prisma/client';
 import {
+  calculateEndDate,
   DescriptionBulletPreview,
   getDay,
   isAdmin,
@@ -544,9 +545,10 @@ export default class WorkPackagesService {
     });
 
     const upcomingWorkPackages = workPackages
-      .map(workPackageTransformer)
-      .filter((wp) => getDay(wp.endDate) <= getDay(deadline))
-      .sort((a, b) => a.endDate.getTime() - b.endDate.getTime());
+      .filter((wp) => getDay(calculateEndDate(wp.startDate, wp.duration)) <= getDay(deadline))
+      .sort(
+        (a, b) => calculateEndDate(a.startDate, a.duration).getTime() - calculateEndDate(b.startDate, b.duration).getTime()
+      );
 
     // have to do it like this so it goes sequentially and we can sleep between each because of rate limiting
     await upcomingWorkPackages.reduce(

src/backend/src/utils/slack.utils.ts

@@ -1,4 +1,4 @@
-import { ChangeRequest, daysBetween, Task, UserPreview, wbsPipe, WorkPackage } from 'shared';
+import { ChangeRequest, daysBetween, Task, UserPreview, wbsPipe, calculateEndDate } from 'shared';
 import { User } from '@prisma/client';
 import { editMessage, reactToMessage, replyToMessageInThread, sendMessage } from '../integrations/slack';
 import { getUserFullName, getUserSlackId } from './users.utils';
@@ -8,9 +8,12 @@ import { Change_Request, Design_Review, Team, WBS_Element } from '@prisma/client
 import { UserWithSettings } from './auth.utils';
 import { usersToSlackPings, userToSlackPing } from './notifications.utils';
 import { addHours, meetingStartTimePipe } from './design-reviews.utils';
+import { WorkPackageQueryArgs } from '../prisma-query-args/work-packages.query-args';
+import { Prisma } from '@prisma/client';
+import { userTransformer } from '../transformers/user.transformer';
 
 // build the "due" string for the upcoming deadlines slack message
-const buildDueString = (daysUntilDeadline: number): string => {
+export const buildDueString = (daysUntilDeadline: number): string => {
   if (daysUntilDeadline < 0) return `was due *${daysUntilDeadline * -1} days ago!*`;
   else if (daysUntilDeadline === 0) return `is due today!`;
   return `is due in ${daysUntilDeadline} days!`;
@@ -24,25 +27,27 @@ const buildUserString = (lead?: UserPreview, slackId?: string): string => {
   return '(no project lead)';
 };
 
-export const sendSlackUpcomingDeadlineNotification = async (workPackage: WorkPackage): Promise<void> => {
+export const sendSlackUpcomingDeadlineNotification = async (
+  workPackage: Prisma.Work_PackageGetPayload<WorkPackageQueryArgs>
+): Promise<void> => {
   if (process.env.NODE_ENV !== 'production') return; // don't send msgs unless in prod
+  const endDate = calculateEndDate(workPackage.startDate, workPackage.duration);
 
-  const { LEAD_CHANNEL_SLACK_ID } = process.env;
-  if (!LEAD_CHANNEL_SLACK_ID) return;
-
-  const { lead } = workPackage;
+  const { lead } = workPackage.wbsElement;
   const slackId = await getUserSlackId(lead?.userId);
-  const daysUntilDeadline = daysBetween(workPackage.endDate, new Date());
+  const daysUntilDeadline = daysBetween(endDate, new Date());
 
-  const userString = buildUserString(lead, slackId);
+  const userString = lead ? buildUserString(userTransformer(lead), slackId) : 'No Lead Set';
   const dueString = buildDueString(daysUntilDeadline);
 
-  const wbsNumber: string = wbsPipe(workPackage.wbsNum);
+  const wbsNumber: string = wbsPipe(workPackage.wbsElement);
   const wbsString = `<https://finishlinebyner.com/projects/${wbsNumber}|${wbsNumber}>`;
 
-  const fullMsg = `${userString} ${wbsString}: ${workPackage.projectName} - ${workPackage.name} ${dueString}`;
+  const fullMsg = `${userString} ${wbsString}: ${workPackage.project.wbsElement.name} - ${workPackage.wbsElement.name} ${dueString}`;
 
-  await sendMessage(LEAD_CHANNEL_SLACK_ID, fullMsg);
+  const promises = workPackage.project.teams.map(async (team) => await sendMessage(team.slackId, fullMsg));
+
+  await Promise.all(promises);
 };
 
 /**