Merge pull request #4098 from Northeastern-Electric-Racing/#4048-tasks-for-work-packages

#4048 tasks for work packages

Author: wavehassman

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

@@ -29,7 +29,7 @@ export default class TasksController {
 
   static async editTask(req: Request, res: Response, next: NextFunction) {
     try {
-      const { title, notes, priority, deadline, startDate } = req.body;
+      const { title, notes, priority, deadline, startDate, wbsNum } = req.body;
       const { taskId } = req.params as Record<string, string>;
 
       const updateTask = await TasksService.editTask(
@@ -40,7 +40,8 @@ export default class TasksController {
         notes,
         priority,
         startDate ? new Date(startDate) : undefined,
-        deadline ? new Date(deadline) : undefined
+        deadline ? new Date(deadline) : undefined,
+        wbsNum
       );
 
       res.status(200).json(updateTask);
@@ -122,4 +123,14 @@ export default class TasksController {
       next(error);
     }
   }
+
+  static async getTasksByWbsNum(req: Request, res: Response, next: NextFunction) {
+    try {
+      const wbsNum: WbsNumber = validateWBS(req.params.wbsNum as string);
+      const tasks = await TasksService.getTasksByWbsNum(wbsNum, req.organization);
+      res.status(200).json(tasks);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
 }

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

@@ -62,6 +62,17 @@ export default class WorkPackagesController {
     }
   }
 
+  // fetch all work packages for the given project wbs number
+  static async getWorkPackagesByProject(req: Request, res: Response, next: NextFunction) {
+    try {
+      const projectWbsNum: WbsNumber = validateWBS(req.params.wbsNum as string);
+      const workPackages = await WorkPackagesService.getWorkPackagesByProject(projectWbsNum, req.organization);
+      res.status(200).json(workPackages);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
   // Create a work package with the given details
   static async createWorkPackage(req: Request, res: Response, next: NextFunction) {
     try {

src/backend/src/prisma-query-args/projects.query-args.ts

@@ -4,7 +4,7 @@ import { getDescriptionBulletQueryArgs } from './description-bullets.query-args.
 import { getTeamPreviewQueryArgs } from './teams.query-args.js';
 import { getTaskQueryArgs } from './tasks.query-args.js';
 import { getLinkQueryArgs } from './links.query-args.js';
-import { getWorkPackagePreviewQueryArgs, getWorkPackageQueryArgs } from './work-packages.query-args.js';
+import { getWorkPackageQueryArgs, getWorkPackagePreviewQueryArgs } from './work-packages.query-args.js';
 
 export type ProjectQueryArgs = ReturnType<typeof getProjectQueryArgs>;
 

src/backend/src/prisma-query-args/tasks.query-args.ts

@@ -27,7 +27,8 @@ export const getCalendarTaskQueryArgs = (organizationId: string) =>
           organizationId: true,
           dateDeleted: true,
           leadId: true,
-          managerId: true
+          managerId: true,
+          name: true
         }
       },
       createdBy: getUserQueryArgs(organizationId),

src/backend/src/prisma/seed.ts

@@ -2870,7 +2870,7 @@ const performSeed: () => Promise<void> = async () => {
       "of the wheel and put pedal to the metal. Accelerating down straightaways and taking corners with finesse, it's " +
       'easy to forget McCauley, in his blue racing jacket and jet black helmet, is racing laps around the roof of ' +
       "Columbus Parking Garage on Northeastern's Boston campus. But that's the reality of Northeastern Electric " +
-      'Racing, a student club that has made due and found massive success in the world of electric racing despite its ' +
+      'Racing, a student club that has made do and found massive success in the world of electric racing despite its ' +
       "relative rookie status. McCauley, NER's chief electrical engineer, has seen the club's car, Cinnamon, go from " +
       'a 5-foot drive test to hitting 60 miles per hour in competitions. "It\'s a go-kart that has 110 kilowatts of ' +
       'power, 109 kilowatts of power," says McCauley, a fourth-year electrical and computer engineering student. ' +

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

@@ -6,7 +6,8 @@ import {
   isTaskPriority,
   isTaskStatus,
   validateInputs,
-  isOptionalDateOnly
+  isOptionalDateOnly,
+  intMinZero
 } from '../utils/validation.utils.js';
 import { isDate } from '../utils/validation.utils.js';
 
@@ -45,20 +46,27 @@ tasksRouter.post(
   isOptionalDateOnly(body('deadline')),
   isOptionalDateOnly(body('startDate')),
   isTaskPriority(body('priority')),
+  intMinZero(body('wbsNum.carNumber')),
+  intMinZero(body('wbsNum.projectNumber')),
+  intMinZero(body('wbsNum.workPackageNumber')),
+  validateInputs,
   TasksController.editTask
 );
 
-tasksRouter.post('/:taskId/edit-status', isTaskStatus(body('status')), TasksController.editTaskStatus);
+tasksRouter.post('/:taskId/edit-status', isTaskStatus(body('status')), validateInputs, TasksController.editTaskStatus);
 
 tasksRouter.post(
   '/:taskId/edit-assignees',
   body('assignees').isArray(),
   nonEmptyString(body('assignees.*')),
+  validateInputs,
   TasksController.editTaskAssignees
 );
 
-tasksRouter.post('/:taskId/delete', TasksController.deleteTask);
+tasksRouter.post('/:taskId/delete', validateInputs, TasksController.deleteTask);
 
 tasksRouter.get('/overdue-by-team-member/:userId', TasksController.getOverdueTasksByTeamLeadership);
 
+tasksRouter.get('/by-wbs/:wbsNum', TasksController.getTasksByWbsNum);
+
 export default tasksRouter;

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

@@ -30,6 +30,9 @@ workPackagesRouter.post(
   WorkPackagesController.getManyWorkPackages
 );
 workPackagesRouter.get('/:wbsNum', WorkPackagesController.getSingleWorkPackage);
+
+workPackagesRouter.get('/by-project/:wbsNum', WorkPackagesController.getWorkPackagesByProject);
+
 workPackagesRouter.post(
   '/create',
   nonEmptyString(body('crId').optional()),

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

@@ -73,15 +73,25 @@ export default class TasksService {
             wbsElement: true,
             workPackages: { include: { wbsElement: true } }
           }
+        },
+        workPackage: {
+          include: {
+            project: {
+              include: {
+                teams: getTeamQueryArgs(organization.organizationId)
+              }
+            }
+          }
         }
       }
     });
     if (!requestedWbsElement) throw new NotFoundException('WBS Element', wbsPipe(wbsNum));
     if (requestedWbsElement.dateDeleted) throw new DeletedException('WBS Element', wbsPipe(wbsNum));
-    const { project } = requestedWbsElement;
-    if (!project) throw new HttpException(400, "This task's wbs element is not linked to a project!");
 
-    const { teams } = project;
+    if (!requestedWbsElement.project && !requestedWbsElement.workPackage)
+      throw new HttpException(400, "This task's wbs element is not linked to a project or work package!");
+
+    const teams = requestedWbsElement.project?.teams ?? requestedWbsElement.workPackage?.project?.teams;
     if (!teams || teams.length === 0)
       throw new HttpException(400, 'This project needs to be assigned to a team to create a task!');
 
@@ -136,7 +146,9 @@ export default class TasksService {
    * @param title the new title for the task
    * @param notes the new notes for the task
    * @param priority the new priority for the task
+   * @param startDate the new start date for the task
    * @param deadline the new deadline for the task
+   * @param wbsNum the new wbs element for the task
    * @returns the sucessfully edited task
    */
   static async editTask(
@@ -147,24 +159,56 @@ export default class TasksService {
     notes: string,
     priority: Task_Priority,
     startDate?: Date,
-    deadline?: Date
+    deadline?: Date,
+    wbsNum?: WbsNumber
   ) {
     const hasPermission = await userHasPermission(user.userId, organizationId, notGuest);
     if (!hasPermission) throw new AccessDeniedException('Guests cannot edit tasks');
 
     const originalTask = await prisma.task.findUnique({ where: { taskId }, include: { wbsElement: true } });
 
+    // error if there's a problem with the task
     if (!originalTask) throw new NotFoundException('Task', taskId);
     if (originalTask.wbsElement.organizationId !== organizationId) throw new InvalidOrganizationException('Task');
     if (originalTask.dateDeleted) throw new DeletedException('Task', taskId);
 
     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');
 
+    // if wbsNum passed, error if there's a problem with the wbs element
+    if (wbsNum) {
+      const newWbsElement = await prisma.wBS_Element.findUnique({
+        where: {
+          wbsNumber: {
+            ...wbsNum,
+            organizationId
+          }
+        }
+      });
+      if (!newWbsElement) throw new NotFoundException('WBS Element', wbsPipe(wbsNum));
+      if (newWbsElement.dateDeleted) throw new DeletedException('WBS Element', wbsPipe(wbsNum));
+    }
+
     const updatedTask = await prisma.task.update({
       where: { taskId },
-      data: { title, notes, priority, startDate, deadline },
+      data: {
+        title,
+        notes,
+        priority,
+        startDate,
+        deadline,
+        // if wbsNum passed, update prisma relation to connect task with wbs element
+        ...(wbsNum && {
+          wbsElement: {
+            connect: {
+              wbsNumber: {
+                ...wbsNum,
+                organizationId
+              }
+            }
+          }
+        })
+      },
       ...getTaskQueryArgs(originalTask.wbsElement.organizationId)
     });
     return taskTransformer(updatedTask);
@@ -173,13 +217,16 @@ export default class TasksService {
   /**
    * Edits the status of a task in the database
    * @param user the user editing the task
-   * @param organizationId the organizqtion Id
+   * @param organizationId the organization Id
    * @param taskId the id of the task
    * @param status the new status
    * @returns the updated task
    * @throws if the task does not exist, the task is already deleted, or if the user does not have permissions
    */
   static async editTaskStatus(user: User, organizationId: string, taskId: string, status: Task_Status) {
+    const hasPermission = await userHasPermission(user.userId, organizationId, notGuest);
+    if (!hasPermission) throw new AccessDeniedException('Guests cannot edit tasks');
+
     // Get the original task and check if it exists
     const originalTask = await prisma.task.findUnique({ where: { taskId }, include: { assignees: true, wbsElement: true } });
     if (!originalTask) throw new NotFoundException('Task', taskId);
@@ -190,9 +237,6 @@ export default class TasksService {
       throw new HttpException(400, 'A task in progress must have a deadline and assignees!');
     }
 
-    const hasPermission = await userHasPermission(user.userId, organizationId, notGuest);
-    if (!hasPermission) throw new AccessDeniedException('Guests cannot edit tasks');
-
     const updatedTask = await prisma.task.update({
       where: { taskId },
       data: { status },
@@ -216,6 +260,9 @@ export default class TasksService {
     assignees: string[],
     organization: Organization
   ): Promise<Task> {
+    const hasPermission = await userHasPermission(user.userId, organization.organizationId, notGuest);
+    if (!hasPermission) throw new AccessDeniedException('Guests cannot edit tasks');
+
     // Get the original task and check if it exists
     const originalTask = await prisma.task.findUnique({
       where: { taskId },
@@ -230,9 +277,6 @@ export default class TasksService {
     const originalAssigneeIds = originalTask.assignees.map((assignee) => assignee.userId);
     const newAssigneeIds = assignees.filter((userId) => !originalAssigneeIds.includes(userId));
 
-    const hasPermission = await userHasPermission(user.userId, organization.organizationId, notGuest);
-    if (!hasPermission) throw new AccessDeniedException('Guests cannot edit tasks');
-
     // this throws if any of the users aren't found
     const assigneeUsers = await getUsers(assignees);
 
@@ -391,4 +435,60 @@ export default class TasksService {
 
     return tasks.map(taskCardPreviewTransformer);
   }
+
+  /**
+   * Gets all tasks associated with a wbs element
+   * If the wbs number is a project (workPackageNumber === 0), returns the project's
+   * own tasks merged with all of its work packages' tasks
+   * If the wbs number is a work package, returns just that WP's tasks
+   * @param wbsNum the wbs number to fetch tasks for
+   * @param organization the organization that the user is currently in
+   * @returns array of tasks
+   */
+  static async getTasksByWbsNum(wbsNum: WbsNumber, organization: Organization): Promise<Task[]> {
+    const wbsElement = await prisma.wBS_Element.findUnique({
+      where: {
+        wbsNumber: {
+          ...wbsNum,
+          organizationId: organization.organizationId
+        }
+      }
+    });
+
+    if (!wbsElement) throw new NotFoundException('WBS Element', wbsPipe(wbsNum));
+    if (wbsElement.dateDeleted) throw new DeletedException('WBS Element', wbsPipe(wbsNum));
+
+    // project case, so return project's own tasks and all its wp's tasks
+    if (wbsNum.workPackageNumber === 0) {
+      const project = await prisma.project.findUnique({
+        where: { wbsElementId: wbsElement.wbsElementId },
+        include: { workPackages: { include: { wbsElement: true } } }
+      });
+
+      if (!project) throw new NotFoundException('Project', wbsPipe(wbsNum));
+
+      const wpWbsElementIds = project.workPackages.map((wp) => wp.wbsElementId);
+
+      const tasks = await prisma.task.findMany({
+        where: {
+          dateDeleted: null,
+          wbsElementId: { in: [wbsElement.wbsElementId, ...wpWbsElementIds] }
+        },
+        ...getTaskQueryArgs(organization.organizationId)
+      });
+
+      return tasks.map(taskTransformer);
+    }
+
+    // work package case, so return just that wp's tasks
+    const tasks = await prisma.task.findMany({
+      where: {
+        dateDeleted: null,
+        wbsElementId: wbsElement.wbsElementId
+      },
+      ...getTaskQueryArgs(organization.organizationId)
+    });
+
+    return tasks.map(taskTransformer);
+  }
 }

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

@@ -183,6 +183,39 @@ export default class WorkPackagesService {
     return workPackages.map(workPackageTransformer);
   }
 
+  /**
+   * Retrieve all work packages for a given project
+   * @param projectWbsNum the wbs number of the project
+   * @param organization the organization that the user is currently in
+   * @returns the work packages for the given project
+   * @throws if the project does not exist or is deleted
+   */
+  static async getWorkPackagesByProject(projectWbsNum: WbsNumber, organization: Organization): Promise<WorkPackage[]> {
+    const project = await prisma.project.findFirst({
+      where: {
+        wbsElement: {
+          carNumber: projectWbsNum.carNumber,
+          projectNumber: projectWbsNum.projectNumber,
+          workPackageNumber: 0,
+          organizationId: organization.organizationId,
+          dateDeleted: null
+        }
+      }
+    });
+
+    if (!project) throw new NotFoundException('Project', wbsPipe(projectWbsNum));
+
+    const workPackages = await prisma.work_Package.findMany({
+      where: {
+        projectId: project.projectId,
+        wbsElement: { dateDeleted: null }
+      },
+      ...getWorkPackageQueryArgs(organization.organizationId)
+    });
+
+    return workPackages.map(workPackageTransformer);
+  }
+
   /**
    * Creates a Work_Package in the database
    * @param user the user creating the work package

src/backend/src/transformers/tasks.transformer.ts

@@ -5,11 +5,12 @@ import { convertTaskPriority, convertTaskStatus } from '../utils/tasks.utils.js'
 import { userTransformer } from './user.transformer.js';
 import { CalendarTaskQueryArgs, TaskQueryArgs, TaskPreviewQueryArgs } from '../prisma-query-args/tasks.query-args.js';
 
-const taskTransformer = (task: Prisma.TaskGetPayload<TaskQueryArgs>): Task => {
+export const taskTransformer = (task: Prisma.TaskGetPayload<TaskQueryArgs>): Task => {
   const wbsNum = wbsNumOf(task.wbsElement);
   return {
     taskId: task.taskId,
     wbsNum,
+    wbsName: task.wbsElement.name,
     title: task.title,
     notes: task.notes,
     deadline: task.deadline ?? undefined,
@@ -45,6 +46,7 @@ export const calendarTaskTransformer = (task: Prisma.TaskGetPayload<CalendarTask
   return {
     taskId: task.taskId,
     wbsNum,
+    wbsName: task.wbsElement.name,
     title: task.title,
     notes: task.notes,
     deadline: task.deadline ?? undefined,