updated validation, id handling and added tests

Author: rbessin

src/backend/src/services/boms.services.ts

@@ -181,24 +181,21 @@ export default class BillOfMaterialsService {
       ...getMaterialQueryArgs(organization.organizationId)
     });
 
-    // Validate all materials were found
     if (materials.length !== materialIds.length) throw new NotFoundException('Material', 'Not all materials found');
 
-    // Validate all materials are from the current organization
-    const invalidMaterials = materials.filter((material) => material.unit?.organizationId !== organization.organizationId);
+    const invalidMaterials = materials.filter(
+      (material) => material.materialType.organizationId !== organization.organizationId
+    );
     if (invalidMaterials.length > 0) throw new HttpException(400, 'All materials must be from the current organization');
 
-    // Fetch destination project (validates project is in the user's organization)
     const destinationProject = await ProjectsService.getSingleProjectWithQueryArgs(destinationProjectId, organization);
 
-    // Check user has correct permissions
     const perms =
       (await userHasPermission(user.userId, organization.organizationId, isLeadership)) ||
       isUserPartOfTeams(destinationProject.teams, user);
 
     if (!perms) throw new AccessDeniedException('Permission to copy materials denied');
 
-    // Create copied materials (all or none)
     return await prisma.$transaction(async (tx) => {
       const newMaterialIds: string[] = [];
 
@@ -224,7 +221,6 @@ export default class BillOfMaterialsService {
           if (!unit) throw new NotFoundException('Unit', material.unitId);
         }
 
-        // Create the new material
         const newMaterial = await tx.material.create({
           data: {
             name: material.name,

src/backend/src/utils/validation.utils.ts

@@ -212,10 +212,14 @@ export const materialValidators = [
 export const copyMaterialsValidators = [
   body('materialIds').isArray({ min: 1 }),
   body('materialIds.*').isString().notEmpty(),
-  body('destinationWbsNum').custom((value) => {
-    validateWBS(value);
-    return true;
-  })
+  body('destinationWbsNum')
+    .custom((value) => {
+      validateWBS(value);
+      return true;
+    })
+    .customSanitizer((value) => {
+      return validateWBS(value);
+    })
 ];
 export const validateInputs = (req: Request, res: Response, next: Function): void => {
   const errors = validationResult(req);

src/backend/tests/unmocked/project.test.ts

@@ -1,3 +1,4 @@
+import prisma from '../../src/prisma/prisma.js';
 import { createTestReimbursementRequest, resetUsers } from '../test-utils.js';
 import { Organization, User } from '@prisma/client';
 import BillOfMaterials from '../../src/services/boms.services.js';
@@ -93,6 +94,119 @@ describe('Material Tests', () => {
     });
   });
 
+  describe('Copy materials to project', () => {
+    test('Successfully copies materials and resets key fields', async () => {
+      const materialType = await BillOfMaterials.createMaterialType('Capacitor', createdUser, org);
+      const manufacturer = await BillOfMaterials.createManufacturer(createdUser, 'Mouser', org);
+
+      const car = await prisma.car.findFirst({
+        where: {
+          wbsElement: {
+            organizationId: org.organizationId
+          }
+        }
+      });
+
+      const project2 = await prisma.project.create({
+        data: {
+          summary: 'Test destination project',
+          car: {
+            connect: { carId: car!.carId }
+          },
+          wbsElement: {
+            create: {
+              carNumber: 0,
+              projectNumber: 2,
+              workPackageNumber: 0,
+              name: 'Destination Project',
+              organizationId: org.organizationId
+            }
+          }
+        }
+      });
+
+      const material1 = await BillOfMaterials.createMaterial(
+        createdUser,
+        '100uF Capacitor',
+        MaterialStatus.Ordered,
+        materialType.name,
+        'https://example.com/mat1',
+        { carNumber: 0, projectNumber: 1, workPackageNumber: 0 },
+        org,
+        manufacturer.name,
+        'CAP-100UF',
+        new Decimal(10),
+        50,
+        500,
+        'Test notes',
+        undefined,
+        undefined,
+        undefined,
+        reimbursementRequest.reimbursementRequestId
+      );
+
+      const material2 = await BillOfMaterials.createMaterial(
+        createdUser,
+        '220uF Capacitor',
+        MaterialStatus.ReadyToOrder,
+        materialType.name,
+        'https://example.com/mat2',
+        { carNumber: 0, projectNumber: 1, workPackageNumber: 0 },
+        org,
+        manufacturer.name,
+        'CAP-220UF',
+        new Decimal(5),
+        75,
+        375
+      );
+
+      const newMaterialIds = await BillOfMaterials.copyMaterialsToProject(
+        createdUser,
+        [material1.materialId, material2.materialId],
+        { carNumber: 0, projectNumber: 2, workPackageNumber: 0 },
+        org
+      );
+
+      expect(newMaterialIds.length).toBe(2);
+
+      const copiedMaterials = await prisma.material.findMany({
+        where: { materialId: { in: newMaterialIds } },
+        include: { wbsElement: true }
+      });
+
+      const copiedMat1 = copiedMaterials.find((m) => m.name === '100uF Capacitor')!;
+      const copiedMat2 = copiedMaterials.find((m) => m.name === '220uF Capacitor')!;
+
+      expect(copiedMat1.wbsElement.projectNumber).toBe(2);
+      expect(copiedMat2.wbsElement.projectNumber).toBe(2);
+
+      expect(copiedMat1.status).toBe('NOT_READY_TO_ORDER');
+      expect(copiedMat1.userCreatedId).toBe(createdUser.userId);
+      expect(copiedMat1.reimbursementRequestId).toBeNull();
+      expect(copiedMat1.assemblyId).toBeNull();
+
+      expect(copiedMat1.name).toBe('100uF Capacitor');
+      expect(copiedMat1.price).toBe(50);
+      expect(copiedMat1.quantity?.toString()).toBe('10');
+      expect(copiedMat1.manufacturerPartNumber).toBe('CAP-100UF');
+      expect(copiedMat1.notes).toBe('Test notes');
+
+      expect(copiedMat2.status).toBe('NOT_READY_TO_ORDER');
+      expect(copiedMat2.reimbursementRequestId).toBeNull();
+    });
+
+    test('Fails when material does not exist', async () => {
+      await expect(
+        BillOfMaterials.copyMaterialsToProject(
+          createdUser,
+          ['non-existent-id'],
+          { carNumber: 0, projectNumber: 1, workPackageNumber: 0 },
+          org
+        )
+      ).rejects.toThrow(NotFoundException);
+    });
+  });
+
   describe('Edit a material', () => {
     test('Updates the reimbursement request when originally undefined', async () => {
       const materialType = await BillOfMaterials.createMaterialType('Resistor', createdUser, org);