[SSF 195] - FM Required Actions Frontend

apps/backend/src/donationItems/donationItems.service.spec.ts

@@ -8,7 +8,7 @@ import { FoodType } from './types';
 import { BadRequestException, NotFoundException } from '@nestjs/common';
 import { testDataSource } from '../config/typeormTestDataSource';
 import { CreateDonationItemDto } from './dtos/create-donation-items.dto';
-import { ConfirmDonationItemDetailsDto } from './dtos/confirm-donation-item-details.dto';
+import { UpdateDonationItemDetailsDto } from './dtos/update-donation-item-details.dto';
 
 jest.setTimeout(60000);
 
@@ -297,8 +297,8 @@ describe('DonationItemsService', () => {
     });
   });
 
-  describe('confirmItemDetails', () => {
-    const makeDto = (itemId: number): ConfirmDonationItemDetailsDto => ({
+  describe('updateItemDetails', () => {
+    const makeDto = (itemId: number): UpdateDonationItemDetailsDto => ({
       itemId,
       ozPerItem: 5.0,
       estimatedValue: 10.0,
@@ -339,7 +339,7 @@ describe('DonationItemsService', () => {
       const donationId = await insertMatchedDonation();
       await expect(
         testDataSource.transaction((tm) =>
-          service.confirmItemDetails(donationId, [makeDto(99999)], tm),
+          service.updateItemDetails(donationId, [makeDto(99999)], tm),
         ),
       ).rejects.toThrow(new NotFoundException('Donation item 99999 not found'));
     });
@@ -349,7 +349,7 @@ describe('DonationItemsService', () => {
       // Item 1 belongs to donation 1, not the new donation
       await expect(
         testDataSource.transaction((tm) =>
-          service.confirmItemDetails(donationId, [makeDto(1)], tm),
+          service.updateItemDetails(donationId, [makeDto(1)], tm),
         ),
       ).rejects.toThrow(
         new BadRequestException(
@@ -358,38 +358,19 @@ describe('DonationItemsService', () => {
       );
     });
 
-    it('throws BadRequestException when an item in the body is already confirmed', async () => {
-      const donationId = await insertMatchedDonation();
-      const itemId = await insertDonationItem(donationId, 10, 10);
-      await testDataSource.query(
-        `UPDATE donation_items SET details_confirmed = true WHERE item_id = $1`,
-        [itemId],
-      );
-
-      await expect(
-        testDataSource.transaction((tm) =>
-          service.confirmItemDetails(donationId, [makeDto(itemId)], tm),
-        ),
-      ).rejects.toThrow(
-        new BadRequestException(
-          `Donation item ${itemId} has already been confirmed`,
-        ),
-      );
-    });
-
     it('updates fields and sets detailsConfirmed to true for a single item', async () => {
       const donationId = await insertMatchedDonation();
       const itemId = await insertDonationItem(donationId, 10, 5);
 
-      const dto: ConfirmDonationItemDetailsDto = {
+      const dto: UpdateDonationItemDetailsDto = {
         itemId,
         ozPerItem: 8.5,
         estimatedValue: 12.0,
         foodRescue: false,
       };
 
       await testDataSource.transaction((tm) =>
-        service.confirmItemDetails(donationId, [dto], tm),
+        service.updateItemDetails(donationId, [dto], tm),
       );
 
       const item = await testDataSource
@@ -407,7 +388,7 @@ describe('DonationItemsService', () => {
       const itemId2 = await insertDonationItem(donationId, 20, 10);
 
       await testDataSource.transaction((tm) =>
-        service.confirmItemDetails(
+        service.updateItemDetails(
           donationId,
           [
             {
@@ -452,7 +433,7 @@ describe('DonationItemsService', () => {
       // Second dto references item 1 which belongs to donation 1, not ours
       await expect(
         testDataSource.transaction((tm) =>
-          service.confirmItemDetails(
+          service.updateItemDetails(
             donationId,
             [makeDto(itemId), makeDto(1)],
             tm,
@@ -470,5 +451,71 @@ describe('DonationItemsService', () => {
       expect(item?.detailsConfirmed).toBe(false);
       expect(item?.ozPerItem).toBeNull();
     });
+
+    it('returns false and does not confirm when only some fields are provided', async () => {
+      const donationId = await insertMatchedDonation();
+      const itemId = await insertDonationItem(donationId, 10, 5);
+
+      const result = await testDataSource.transaction((tm) =>
+        service.updateItemDetails(donationId, [{ itemId, ozPerItem: 8.5 }], tm),
+      );
+
+      expect(result).toBe(false);
+      const item = await testDataSource
+        .getRepository(DonationItem)
+        .findOneBy({ itemId });
+      expect(Number(item?.ozPerItem)).toBe(8.5);
+      expect(item?.estimatedValue).toBeNull();
+      expect(item?.detailsConfirmed).toBe(false);
+    });
+
+    it('confirms item on a second call that supplies the remaining fields', async () => {
+      const donationId = await insertMatchedDonation();
+      const itemId = await insertDonationItem(donationId, 10, 5);
+
+      const firstResult = await testDataSource.transaction((tm) =>
+        service.updateItemDetails(donationId, [{ itemId, ozPerItem: 8.5 }], tm),
+      );
+      expect(firstResult).toBe(false);
+
+      const secondResult = await testDataSource.transaction((tm) =>
+        service.updateItemDetails(
+          donationId,
+          [{ itemId, estimatedValue: 12.0, foodRescue: true }],
+          tm,
+        ),
+      );
+      expect(secondResult).toBe(true);
+
+      const item = await testDataSource
+        .getRepository(DonationItem)
+        .findOneBy({ itemId });
+      expect(Number(item?.ozPerItem)).toBe(8.5);
+      expect(Number(item?.estimatedValue)).toBe(12.0);
+      expect(item?.foodRescue).toBe(true);
+      expect(item?.detailsConfirmed).toBe(true);
+    });
+
+    it('allows updating an already-confirmed item without throwing', async () => {
+      const donationId = await insertMatchedDonation();
+      const itemId = await insertDonationItem(donationId, 10, 5);
+      await testDataSource.query(
+        `UPDATE donation_items
+         SET details_confirmed = true, oz_per_item = 5.0, estimated_value = 10.0
+         WHERE item_id = $1`,
+        [itemId],
+      );
+
+      const result = await testDataSource.transaction((tm) =>
+        service.updateItemDetails(donationId, [{ itemId, ozPerItem: 9.0 }], tm),
+      );
+
+      expect(result).toBe(true);
+      const item = await testDataSource
+        .getRepository(DonationItem)
+        .findOneBy({ itemId });
+      expect(Number(item?.ozPerItem)).toBe(9.0);
+      expect(item?.detailsConfirmed).toBe(true);
+    });
   });
 });

apps/backend/src/donationItems/donationItems.service.ts

@@ -9,9 +9,8 @@ import { DonationItem } from './donationItems.entity';
 import { validateId } from '../utils/validation.utils';
 import { FoodType } from './types';
 import { Donation } from '../donations/donations.entity';
-import { DonationStatus } from '../donations/types';
 import { CreateDonationItemDto } from './dtos/create-donation-items.dto';
-import { ConfirmDonationItemDetailsDto } from './dtos/confirm-donation-item-details.dto';
+import { UpdateDonationItemDetailsDto } from './dtos/update-donation-item-details.dto';
 
 @Injectable()
 export class DonationItemsService {
@@ -103,14 +102,16 @@ export class DonationItemsService {
     return this.repo.save(donationItem);
   }
 
-  async confirmItemDetails(
+  async updateItemDetails(
     donationId: number,
-    body: ConfirmDonationItemDetailsDto[],
+    body: UpdateDonationItemDetailsDto[],
     transactionManager: EntityManager,
-  ): Promise<void> {
+  ): Promise<boolean> {
     const donationItemTransactionRepo =
       transactionManager.getRepository(DonationItem);
 
+    let confirmedDetailsForAnItem = false;
+
     for (const dto of body) {
       const item = await donationItemTransactionRepo.findOneBy({
         itemId: dto.itemId,
@@ -126,19 +127,31 @@ export class DonationItemsService {
         );
       }
 
-      if (item.detailsConfirmed) {
-        throw new BadRequestException(
-          `Donation item ${dto.itemId} has already been confirmed`,
-        );
+      const updateData: Partial<DonationItem> = {};
+      if (dto.ozPerItem !== undefined) updateData.ozPerItem = dto.ozPerItem;
+      if (dto.estimatedValue !== undefined)
+        updateData.estimatedValue = dto.estimatedValue;
+      if (dto.foodRescue !== undefined) updateData.foodRescue = dto.foodRescue;
+
+      // If included in DTO, keep it, otherwise use whatever is in the DB (could be null)
+      const resultingOzPerItem =
+        updateData.ozPerItem !== undefined
+          ? updateData.ozPerItem
+          : item.ozPerItem;
+      const resultingEstimatedValue =
+        updateData.estimatedValue !== undefined
+          ? updateData.estimatedValue
+          : item.estimatedValue;
+
+      if (resultingOzPerItem != null && resultingEstimatedValue != null) {
+        updateData.detailsConfirmed = true;
+        confirmedDetailsForAnItem = true;
       }
 
-      await donationItemTransactionRepo.update(dto.itemId, {
-        ozPerItem: dto.ozPerItem,
-        estimatedValue: dto.estimatedValue,
-        foodRescue: dto.foodRescue,
-        detailsConfirmed: true,
-      });
+      await donationItemTransactionRepo.update(dto.itemId, updateData);
     }
+
+    return confirmedDetailsForAnItem;
   }
 
   async createMultiple(

apps/backend/src/donationItems/dtos/confirm-donation-item-details.dto.ts → apps/backend/src/donationItems/dtos/update-donation-item-details.dto.ts

@@ -1,23 +1,27 @@
-import { IsNumber, Min, IsBoolean, IsInt } from 'class-validator';
+import { IsNumber, Min, IsBoolean, IsInt, IsOptional } from 'class-validator';
 
-export class ConfirmDonationItemDetailsDto {
+export class UpdateDonationItemDetailsDto {
   @IsInt()
+  @Min(1)
   itemId!: number;
 
+  @IsOptional()
   @IsNumber(
     { maxDecimalPlaces: 2 },
     { message: 'Oz per item must have at most 2 decimal places' },
   )
   @Min(0.01, { message: 'Oz per item must be at least 0.01' })
-  ozPerItem!: number;
+  ozPerItem?: number;
 
+  @IsOptional()
   @IsNumber(
     { maxDecimalPlaces: 2 },
     { message: 'Estimated value must have at most 2 decimal places' },
   )
   @Min(0.01, { message: 'Estimated value must be at least 0.01' })
-  estimatedValue!: number;
+  estimatedValue?: number;
 
+  @IsOptional()
   @IsBoolean()
-  foodRescue!: boolean;
+  foodRescue?: boolean;
 }

apps/backend/src/donations/donations.controller.spec.ts

@@ -6,8 +6,7 @@ import { Donation } from './donations.entity';
 import { CreateDonationDto } from './dtos/create-donation.dto';
 import { CreateDonationItemDto } from '../donationItems/dtos/create-donation-items.dto';
 import { DonationStatus, RecurrenceEnum } from './types';
-import { ConfirmDonationItemDetailsDto } from '../donationItems/dtos/confirm-donation-item-details.dto';
-import { DonationItem } from '../donationItems/donationItems.entity';
+import { UpdateDonationItemDetailsDto } from '../donationItems/dtos/update-donation-item-details.dto';
 import { ReplaceDonationItemsDto } from '../donationItems/dtos/create-donation-items.dto';
 import { FoodType } from '../donationItems/types';
 
@@ -122,22 +121,21 @@ describe('DonationsController', () => {
   });
 
   describe('PATCH /:donationId/fulfill', () => {
-    it('should call donationService.fulfill and return updated donation', async () => {
+    it('should call donationService.fulfill', async () => {
       const donationId = 1;
 
-      mockDonationService.fulfill.mockResolvedValueOnce(donation1 as Donation);
+      mockDonationService.fulfill.mockResolvedValueOnce(undefined);
 
-      const result = await controller.fulfillDonation(donationId);
+      await controller.fulfillDonation(donationId);
 
-      expect(result).toEqual(donation1);
       expect(mockDonationService.fulfill).toHaveBeenCalledWith(donationId);
     });
   });
 
   describe('PATCH /:donationId/item-details', () => {
-    it('calls confirmDonationItemDetails with the correct donationId and body, returns result', async () => {
+    it('calls updateDonationItemDetails with the correct donationId and body, returns result', async () => {
       const donationId = 1;
-      const body: ConfirmDonationItemDetailsDto[] = [
+      const body: UpdateDonationItemDetailsDto[] = [
         {
           itemId: 1,
           ozPerItem: 5.0,
@@ -152,24 +150,16 @@ describe('DonationsController', () => {
         },
       ];
 
-      mockDonationService.confirmDonationItemDetails.mockResolvedValueOnce(
-        donation1 as Donation,
-      );
+      await controller.updateDonationItemDetails(donationId, body);
 
-      const result = await controller.confirmDonationItemDetails(
-        donationId,
-        body,
-      );
-
-      expect(result).toEqual(donation1);
       expect(
-        mockDonationService.confirmDonationItemDetails,
+        mockDonationService.updateDonationItemDetails,
       ).toHaveBeenCalledWith(donationId, body);
     });
   });
 
   describe('PUT /:donationId/items', () => {
-    it('should call donationService.replaceDonationItems and return updated donation', async () => {
+    it('should call donationService.replaceDonationItems', async () => {
       const donationId = 1;
 
       const replaceBody = {
@@ -188,25 +178,13 @@ describe('DonationsController', () => {
         ],
       };
 
-      const updatedDonation: Partial<Donation> = {
-        donationId,
-        donationItems: [
-          { itemId: 1, itemName: 'Apples', quantity: 10 } as DonationItem,
-          { itemId: 2, itemName: 'Oranges', quantity: 5 } as DonationItem,
-        ],
-        status: DonationStatus.AVAILABLE,
-      };
-
-      mockDonationService.replaceDonationItems.mockResolvedValueOnce(
-        updatedDonation as Donation,
-      );
+      mockDonationService.replaceDonationItems.mockResolvedValueOnce(undefined);
 
-      const result = await controller.replaceDonationItems(
+      await controller.replaceDonationItems(
         donationId,
         replaceBody as ReplaceDonationItemsDto,
       );
 
-      expect(result).toEqual(updatedDonation);
       expect(mockDonationService.replaceDonationItems).toHaveBeenCalledWith(
         donationId,
         replaceBody,