Merge branch 'develop' into Send-Weekly-Deadline-Checks

Author: Peyton-McKee

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/controllers/projects.controllers.ts

@@ -9,8 +9,9 @@ import { getOrganizationId } from '../utils/utils';
 export default class ProjectsController {
   static async getAllProjects(req: Request, res: Response, next: NextFunction) {
     try {
+      const includeDeleted = req.params.deleted === 'true';
       const organizationId = getOrganizationId(req.headers);
-      const projects: Project[] = await ProjectsService.getAllProjects(organizationId);
+      const projects: Project[] = await ProjectsService.getAllProjects(organizationId, includeDeleted);
       res.status(200).json(projects);
     } catch (error: unknown) {
       next(error);

src/backend/src/prisma/seed.ts

@@ -1947,12 +1947,12 @@ const performSeed: () => Promise<void> = async () => {
     {
       linkId: '1',
       linkTypeName: 'Confluence',
-      url: 'https://google.com'
+      url: 'https://confluence.com'
     },
     {
       linkId: '2',
       linkTypeName: 'Bill of Materials',
-      url: 'https://apple.com'
+      url: 'https://docs.google.com'
     }
   ]);
 };

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/routes/projects.routes.ts

@@ -12,7 +12,7 @@ import ProjectsController from '../controllers/projects.controllers';
 
 const projectRouter = express.Router();
 
-projectRouter.get('/', ProjectsController.getAllProjects);
+projectRouter.get('/all/:deleted', ProjectsController.getAllProjects);
 
 /* Link Types */
 projectRouter.get('/link-types', ProjectsController.getAllLinkTypes);

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

@@ -3,39 +3,25 @@ import {
   TaskWithAssignees,
   endOfDayTomorrow,
   getTeamFromTaskAssignees,
+  startOfDayTomorrow,
   usersToSlackPings
 } from '../utils/notifications.utils';
 import { sendMessage } from '../integrations/slack';
-import WorkPackagesService from './work-packages.services';
-import { addWeeksToDate, daysBetween } from 'shared';
-import { HttpException } from '../utils/errors.utils';
+import { daysBetween } from 'shared';
 import { buildDueString } from '../utils/slack.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/projects.services.ts

@@ -36,13 +36,19 @@ export default class ProjectsService {
   /**
    * Get all the non deleted projects in the database for the given organization.
    * @param organizationId the id of the organization the user is currently in
+   * @param includeDeleted whether or not to include deleted projects
    * @returns all the projects
    */
-  static async getAllProjects(organizationId: string): Promise<Project[]> {
-    const projects = await prisma.project.findMany({
-      where: { wbsElement: { dateDeleted: null, organizationId } },
-      ...getProjectQueryArgs(organizationId)
-    });
+  static async getAllProjects(organizationId: string, includeDeleted: boolean): Promise<Project[]> {
+    const projects = includeDeleted
+      ? await prisma.project.findMany({
+          where: { wbsElement: { organizationId } },
+          ...getProjectQueryArgs(organizationId)
+        })
+      : await prisma.project.findMany({
+          where: { wbsElement: { dateDeleted: null, organizationId } },
+          ...getProjectQueryArgs(organizationId)
+        });
     return projects.map(projectTransformer);
   }
 

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/transformers/cars.transformer.ts

@@ -21,6 +21,7 @@ export const carTransformer = (car: Prisma.CarGetPayload<CarQueryArgs>): Car =>
     descriptionBullets: car.wbsElement.descriptionBullets.map(descBulletConverter),
     materials: car.wbsElement.materials.map(materialTransformer),
     assemblies: car.wbsElement.assemblies.map(assemblyTransformer),
-    changes: []
+    changes: [],
+    deleted: car.wbsElement.dateDeleted !== null
   };
 };

src/backend/src/transformers/projects.transformer.ts

@@ -41,6 +41,7 @@ const projectTransformer = (project: Prisma.ProjectGetPayload<ProjectQueryArgs>)
       detail: change.detail,
       dateImplemented: change.dateImplemented
     })),
+    deleted: wbsElement.dateDeleted !== null,
     favoritedBy: project.favoritedBy.map(userTransformer),
     teams: project.teams.map(teamTransformer),
     summary: project.summary,
@@ -85,7 +86,8 @@ const projectTransformer = (project: Prisma.ProjectGetPayload<ProjectQueryArgs>)
         stage: (workPackage.stage || undefined) as WorkPackageStage,
         materials: workPackage.wbsElement?.materials.map(materialTransformer),
         assemblies: workPackage.wbsElement?.assemblies.map(assemblyTransformer),
-        blocking: workPackage.wbsElement.blocking.map((blocking) => wbsNumOf(blocking.wbsElement))
+        blocking: workPackage.wbsElement.blocking.map((blocking) => wbsNumOf(blocking.wbsElement)),
+        deleted: workPackage.wbsElement.dateDeleted !== null
       };
     })
   };