Merge pull request #2681 from Northeastern-Electric-Racing/revert-2678-Send-Weekly-Deadline-Checks

Revert "Send Weekly Deadline checks"

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 sendDailySlackNotifications(_req: Request, res: Response, next: NextFunction) {
+  static async sendTaskDeadlineSlackNotifications(_req: Request, res: Response, next: NextFunction) {
     try {
-      await NotificationsService.sendDailySlackNotifications();
+      await NotificationsService.sendTaskDeadlineSlackNotifications();
 
       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.sendDailySlackNotifications);
+notificationsRouter.post('/task-deadlines', NotificationsController.sendTaskDeadlineSlackNotifications);
 
 export default notificationsRouter;

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

@@ -3,38 +3,23 @@ import {
   TaskWithAssignees,
   endOfDayTomorrow,
   getTeamFromTaskAssignees,
+  startOfDayTomorrow,
   usersToSlackPings
 } from '../utils/notifications.utils';
 import { sendMessage } from '../integrations/slack';
-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 or before that are not done
+   * 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: {

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

@@ -1,6 +1,5 @@
 import { Prisma, User, WBS_Element, WBS_Element_Status } from '@prisma/client';
 import {
-  calculateEndDate,
   DescriptionBulletPreview,
   getDay,
   isAdmin,
@@ -545,10 +544,9 @@ export default class WorkPackagesService {
     });
 
     const upcomingWorkPackages = workPackages
-      .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()
-      );
+      .map(workPackageTransformer)
+      .filter((wp) => getDay(wp.endDate) <= getDay(deadline))
+      .sort((a, b) => a.endDate.getTime() - b.endDate.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, calculateEndDate } from 'shared';
+import { ChangeRequest, daysBetween, Task, UserPreview, wbsPipe, WorkPackage } from 'shared';
 import { User } from '@prisma/client';
 import { editMessage, reactToMessage, replyToMessageInThread, sendMessage } from '../integrations/slack';
 import { getUserFullName, getUserSlackId } from './users.utils';
@@ -8,9 +8,6 @@ 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 => {
@@ -27,27 +24,25 @@ const buildUserString = (lead?: UserPreview, slackId?: string): string => {
   return '(no project lead)';
 };
 
-export const sendSlackUpcomingDeadlineNotification = async (
-  workPackage: Prisma.Work_PackageGetPayload<WorkPackageQueryArgs>
-): Promise<void> => {
+export const sendSlackUpcomingDeadlineNotification = async (workPackage: WorkPackage): 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 } = workPackage.wbsElement;
+  const { LEAD_CHANNEL_SLACK_ID } = process.env;
+  if (!LEAD_CHANNEL_SLACK_ID) return;
+
+  const { lead } = workPackage;
   const slackId = await getUserSlackId(lead?.userId);
-  const daysUntilDeadline = daysBetween(endDate, new Date());
+  const daysUntilDeadline = daysBetween(workPackage.endDate, new Date());
 
-  const userString = lead ? buildUserString(userTransformer(lead), slackId) : 'No Lead Set';
+  const userString = buildUserString(lead, slackId);
   const dueString = buildDueString(daysUntilDeadline);
 
-  const wbsNumber: string = wbsPipe(workPackage.wbsElement);
+  const wbsNumber: string = wbsPipe(workPackage.wbsNum);
   const wbsString = `<https://finishlinebyner.com/projects/${wbsNumber}|${wbsNumber}>`;
 
-  const fullMsg = `${userString} ${wbsString}: ${workPackage.project.wbsElement.name} - ${workPackage.wbsElement.name} ${dueString}`;
+  const fullMsg = `${userString} ${wbsString}: ${workPackage.projectName} - ${workPackage.name} ${dueString}`;
 
-  const promises = workPackage.project.teams.map(async (team) => await sendMessage(team.slackId, fullMsg));
-
-  await Promise.all(promises);
+  await sendMessage(LEAD_CHANNEL_SLACK_ID, fullMsg);
 };
 
 /**