SSF-153 Volunteer Create Order Endpoint

apps/backend/src/allocations/allocations.controller.ts

@@ -1,6 +1,5 @@
-import { Controller, Get, Param, ParseIntPipe } from '@nestjs/common';
+import { Controller } from '@nestjs/common';
 import { AllocationsService } from './allocations.service';
-import { Allocation } from './allocations.entity';
 
 @Controller('allocations')
 export class AllocationsController {

apps/backend/src/allocations/allocations.module.ts

@@ -4,11 +4,14 @@ import { Allocation } from './allocations.entity';
 import { AllocationsController } from './allocations.controller';
 import { AllocationsService } from './allocations.service';
 import { AuthModule } from '../auth/auth.module';
+import { DonationItemsModule } from '../donationItems/donationItems.module';
+import { DonationItem } from '../donationItems/donationItems.entity';
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([Allocation]),
+    TypeOrmModule.forFeature([Allocation, DonationItem]),
     forwardRef(() => AuthModule),
+    DonationItemsModule,
   ],
   controllers: [AllocationsController],
   providers: [AllocationsService],

apps/backend/src/allocations/allocations.service.ts

@@ -1,12 +1,16 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { EntityManager, Repository } from 'typeorm';
 import { Allocation } from '../allocations/allocations.entity';
+import { validateId } from '../utils/validation.utils';
+import { DonationItem } from '../donationItems/donationItems.entity';
 
 @Injectable()
 export class AllocationsService {
   constructor(
     @InjectRepository(Allocation) private repo: Repository<Allocation>,
+    @InjectRepository(DonationItem)
+    private donationItemRepo: Repository<DonationItem>,
   ) {}
 
   async getAllAllocationsByOrder(
@@ -21,4 +25,38 @@ export class AllocationsService {
       },
     });
   }
+
+  async createMultiple(
+    orderId: number,
+    itemAllocations: Record<number, number>,
+    transactionManager?: EntityManager,
+  ): Promise<Allocation[]> {
+    const repo = transactionManager
+      ? transactionManager.getRepository(Allocation)
+      : this.repo;
+    const itemRepo = transactionManager
+      ? transactionManager.getRepository(DonationItem)
+      : this.donationItemRepo;
+
+    validateId(orderId, 'Order');
+
+    const allocations: Allocation[] = [];
+
+    for (const [itemIdStr, quantity] of Object.entries(itemAllocations)) {
+      const itemId = Number(itemIdStr);
+      validateId(itemId, 'Donation Item');
+
+      allocations.push(
+        repo.create({
+          orderId,
+          itemId,
+          allocatedQuantity: quantity,
+        }),
+      );
+
+      await itemRepo.increment({ itemId }, 'reservedQuantity', quantity);
+    }
+
+    return repo.save(allocations);
+  }
 }

apps/backend/src/donationItems/donationItems.module.ts

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { DonationItemsService } from './donationItems.service';
 import { DonationItem } from './donationItems.entity';
@@ -7,8 +7,12 @@ import { AuthModule } from '../auth/auth.module';
 import { Donation } from '../donations/donations.entity';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([DonationItem, Donation]), AuthModule],
+  imports: [
+    TypeOrmModule.forFeature([DonationItem, Donation]),
+    forwardRef(() => AuthModule),
+  ],
   controllers: [DonationItemsController],
   providers: [DonationItemsService],
+  exports: [DonationItemsService],
 })
 export class DonationItemsModule {}

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

@@ -1,6 +1,6 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { In, Repository } from 'typeorm';
 import { DonationItem } from './donationItems.entity';
 import { validateId } from '../utils/validation.utils';
 import { FoodType } from './types';
@@ -28,6 +28,49 @@ export class DonationItemsService {
     return this.repo.find({ where: { donation: { donationId } } });
   }
 
+  async getByIds(donationItemIds: number[]): Promise<DonationItem[]> {
+    donationItemIds.forEach((id) => validateId(id, 'Donation Item'));
+
+    const items = await this.repo.find({
+      where: { itemId: In(donationItemIds) },
+    });
+
+    const foundIds = new Set(items.map((item) => item.itemId));
+
+    const missingIds = donationItemIds.filter((id) => !foundIds.has(id));
+
+    if (missingIds.length > 0) {
+      throw new NotFoundException(
+        `Donation items not found for ID(s): ${missingIds.join(', ')}`,
+      );
+    }
+
+    return items;
+  }
+
+  async getAssociatedDonationIds(
+    donationItemIds: number[],
+  ): Promise<Set<number>> {
+    donationItemIds.forEach((id) => validateId(id, 'Donation Item'));
+
+    const items = await this.repo.find({
+      where: { itemId: In(donationItemIds) },
+      select: ['itemId', 'donationId'],
+    });
+
+    const foundIds = new Set(items.map((i) => i.itemId));
+
+    const missingIds = donationItemIds.filter((id) => !foundIds.has(id));
+
+    if (missingIds.length > 0) {
+      throw new NotFoundException(
+        `Donation items not found for ID(s): ${missingIds.join(', ')}`,
+      );
+    }
+
+    return new Set(items.map((i) => i.donationId));
+  }
+
   async create(
     donationId: number,
     itemName: string,

apps/backend/src/donations/donations.module.ts

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { Donation } from './donations.entity';
 import { DonationService } from './donations.service';
@@ -8,8 +8,12 @@ import { FoodManufacturer } from '../foodManufacturers/manufacturers.entity';
 import { DonationsSchedulerService } from './donations.scheduler';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Donation, FoodManufacturer]), AuthModule],
+  imports: [
+    TypeOrmModule.forFeature([Donation, FoodManufacturer]),
+    forwardRef(() => AuthModule),
+  ],
   controllers: [DonationsController],
   providers: [DonationService, DonationsSchedulerService],
+  exports: [DonationService],
 })
 export class DonationModule {}

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

@@ -173,6 +173,38 @@ describe('DonationService', () => {
     });
   });
 
+  describe('matchAll', () => {
+    it('updates all given donations to have status MATCHED', async () => {
+      const donationId1 = 1;
+      const donationId2 = 2;
+      const donationIds = [donationId1, donationId2];
+
+      const donation1 = await service.findOne(donationId1);
+      const donation2 = await service.findOne(donationId2);
+      expect(donation1.status).toEqual(DonationStatus.AVAILABLE);
+      expect(donation2.status).toEqual(DonationStatus.MATCHED);
+
+      await service.matchAll(donationIds);
+
+      const updatedDonation1 = await service.findOne(donationId1);
+      const updatedDonation2 = await service.findOne(donationId2);
+
+      expect(updatedDonation1.status).toEqual(DonationStatus.MATCHED);
+      expect(updatedDonation2.status).toEqual(DonationStatus.MATCHED);
+    });
+
+    it('throws an error if one or more donationIds do not exist', async () => {
+      const existingDonationId = 1;
+      const nonExistingDonationId = 999;
+
+      const donationIds = [existingDonationId, nonExistingDonationId];
+
+      await expect(service.matchAll(donationIds)).rejects.toThrow(
+        `Donations not found for ID(s): ${nonExistingDonationId}`,
+      );
+    });
+  });
+
   describe('handleRecurringDonations', () => {
     describe('no-op cases', () => {
       it('skips donation with no nextDonationDates', async () => {

apps/backend/src/donations/donations.service.ts

@@ -5,7 +5,7 @@ import {
   NotFoundException,
 } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { EntityManager, In, Repository } from 'typeorm';
 import { Donation } from './donations.entity';
 import { validateId } from '../utils/validation.utils';
 import { DayOfWeek, DonationStatus, RecurrenceEnum } from './types';
@@ -98,6 +98,37 @@ export class DonationService {
     return this.repo.save(donation);
   }
 
+  async matchAll(
+    donationIds: number[],
+    transactionManager?: EntityManager,
+  ): Promise<void> {
+    donationIds.forEach((id) => validateId(id, 'Donation'));
+
+    const repo = transactionManager
+      ? transactionManager.getRepository(Donation)
+      : this.repo;
+
+    const donations = await repo.find({
+      where: { donationId: In(donationIds) },
+      select: ['donationId'],
+    });
+
+    const foundIds = donations.map((d) => d.donationId);
+
+    const missingIds = donationIds.filter((id) => !foundIds.includes(id));
+
+    if (missingIds.length > 0) {
+      throw new NotFoundException(
+        `Donations not found for ID(s): ${missingIds.join(', ')}`,
+      );
+    }
+
+    await repo.update(
+      { donationId: In(donationIds) },
+      { status: DonationStatus.MATCHED },
+    );
+  }
+
   async handleRecurringDonations(): Promise<void> {
     const donations = await this.getAll();
     const today = new Date();

apps/backend/src/foodManufacturers/manufacturers.module.ts

@@ -13,5 +13,6 @@ import { Donation } from '../donations/donations.entity';
   ],
   controllers: [FoodManufacturersController],
   providers: [FoodManufacturersService],
+  exports: [FoodManufacturersService],
 })
 export class ManufacturerModule {}

apps/backend/src/orders/dtos/create-order.dto.ts

@@ -0,0 +1,17 @@
+import { IsInt, IsNotEmptyObject, IsObject, Min } from 'class-validator';
+
+export class CreateOrderDto {
+  @IsInt()
+  @Min(1)
+  foodRequestId!: number;
+
+  @IsInt()
+  @Min(1)
+  manufacturerId!: number;
+
+  // This object is not fully validated, the validation is handled in the controller where the DTO is used.
+  // We would like this type to be Record<string, number> where the key is the donationItemId and the value is reserved quantity
+  @IsObject()
+  @IsNotEmptyObject()
+  itemAllocations!: Record<string, unknown>;
+}