SSF 97 pantry management backend

.gitignore

@@ -33,8 +33,7 @@ npm-debug.log
 yarn-error.log
 testem.log
 /typings
-.nx
-
+
 # System Files
 .DS_Store
 Thumbs.db

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

@@ -6,6 +6,7 @@ import { mock } from 'jest-mock-extended';
 import { PantryApplicationDto } from './dtos/pantry-application.dto';
 import { OrdersService } from '../orders/order.service';
 import { Order } from '../orders/order.entity';
+import { ApprovedPantryResponse } from './types';
 import {
   Activity,
   AllergensConfidence,
@@ -253,6 +254,95 @@ describe('PantriesController', () => {
     });
   });
 
+  describe('getApprovedPantries', () => {
+    it('should return approved pantries with volunteers', async () => {
+      const mockApprovedPantries: ApprovedPantryResponse[] = [
+        {
+          pantryId: 1,
+          pantryName: 'Community Food Pantry',
+
+          contactFirstName: 'John',
+          contactLastName: 'Smith',
+          contactEmail: 'john.smith@example.com',
+          contactPhone: '(508) 508-6789',
+
+          shipmentAddressLine1: '123 Main Street',
+          shipmentAddressCity: 'Boston',
+          shipmentAddressZip: '02101',
+          shipmentAddressState: 'MA',
+          shipmentAddressCountry: 'United States',
+
+          allergenClients: '10 to 20',
+          restrictions: ['Peanuts', 'Dairy'],
+
+          refrigeratedDonation: RefrigeratedDonation.YES,
+          reserveFoodForAllergic: ReserveFoodForAllergic.YES,
+          reservationExplanation:
+            'We regularly serve clients with severe allergies.',
+
+          dedicatedAllergyFriendly: true,
+
+          clientVisitFrequency: ClientVisitFrequency.FEW_TIMES_A_MONTH,
+          identifyAllergensConfidence: AllergensConfidence.VERY_CONFIDENT,
+          serveAllergicChildren: ServeAllergicChildren.YES_MANY,
+
+          activities: [
+            Activity.POST_RESOURCE_FLYERS,
+            Activity.CREATE_LABELED_SHELF,
+          ],
+          activitiesComments: 'Weekly food distribution events',
+
+          itemsInStock: 'Canned goods, rice, pasta',
+          needMoreOptions: 'Gluten-free and nut-free items',
+
+          newsletterSubscription: true,
+          volunteers: [
+            {
+              userId: 10,
+              name: 'Alice Johnson',
+              email: 'alice.johnson@example.com',
+              phone: '(617) 555-0100',
+              role: 'Volunteer Coordinator',
+            },
+            {
+              userId: 11,
+              name: 'Bob Williams',
+              email: 'bob.williams@example.com',
+              phone: '(617) 555-0101',
+              role: 'Food Distributor',
+            },
+          ],
+        },
+      ];
+
+      mockPantriesService.getApprovedPantriesWithVolunteers.mockResolvedValue(
+        mockApprovedPantries,
+      );
+
+      const result = await controller.getApprovedPantries();
+
+      expect(result).toEqual(mockApprovedPantries);
+      expect(
+        mockPantriesService.getApprovedPantriesWithVolunteers,
+      ).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('updatePantryVolunteers', () => {
+    it('should overwrite the set of volunteers assigned to a pantry', async () => {
+      const pantryId = 1;
+      const volunteerIds = [10, 11, 12];
+
+      mockPantriesService.updatePantryVolunteers.mockResolvedValue(undefined);
+
+      await controller.updatePantryVolunteers(pantryId, volunteerIds);
+
+      expect(mockPantriesService.updatePantryVolunteers).toHaveBeenCalledWith(
+        pantryId,
+        volunteerIds,
+      );
+    });
+  });
   describe('getCurrentUserPantryId', () => {
     it('returns pantryId when req.currentUser is present', async () => {
       const req = { user: { id: 1 } };

apps/backend/src/pantries/pantries.controller.ts

@@ -5,6 +5,7 @@ import {
   Param,
   ParseIntPipe,
   Patch,
+  Put,
   Post,
   Req,
   UnauthorizedException,
@@ -16,6 +17,7 @@ import { Roles } from '../auth/roles.decorator';
 import { ValidationPipe } from '@nestjs/common';
 import { PantryApplicationDto } from './dtos/pantry-application.dto';
 import { ApiBody } from '@nestjs/swagger';
+import { ApprovedPantryResponse } from './types';
 import {
   Activity,
   AllergensConfidence,
@@ -56,6 +58,11 @@ export class PantriesController {
     return this.pantriesService.getPendingPantries();
   }
 
+  @Get('/approved')
+  async getApprovedPantries(): Promise<ApprovedPantryResponse[]> {
+    return this.pantriesService.getApprovedPantriesWithVolunteers();
+  }
+
   @Roles(Role.PANTRY, Role.ADMIN)
   @Get('/:pantryId')
   async getPantry(
@@ -343,4 +350,12 @@ export class PantriesController {
       attachments,
     );
   }
+
+  @Put('/:pantryId/volunteers')
+  async updatePantryVolunteers(
+    @Param('pantryId', ParseIntPipe) pantryId: number,
+    @Body('volunteerIds') volunteerIds: number[],
+  ): Promise<void> {
+    return this.pantriesService.updatePantryVolunteers(pantryId, volunteerIds);
+  }
 }

apps/backend/src/pantries/pantries.entity.ts

@@ -108,7 +108,7 @@ export class Pantry {
     enum: ReserveFoodForAllergic,
     enumName: 'reserve_food_for_allergic_enum',
   })
-  reserveFoodForAllergic: string;
+  reserveFoodForAllergic: ReserveFoodForAllergic;
 
   @Column({ name: 'reservation_explanation', type: 'text', nullable: true })
   reservationExplanation?: string;
@@ -208,7 +208,7 @@ export class Pantry {
     name: 'status',
     type: 'enum',
     enum: ApplicationStatus,
-    enumName: 'application_status_enum',
+    enumName: 'pantries_status_enum',
   })
   status: ApplicationStatus;
 

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

@@ -15,8 +15,10 @@ import {
   AllergensConfidence,
 } from './types';
 import { ApplicationStatus } from '../shared/types';
+import { User } from '../users/user.entity';
 
 const mockRepository = mock<Repository<Pantry>>();
+const mockUserRepository = mock<Repository<User>>();
 
 describe('PantriesService', () => {
   let service: PantriesService;
@@ -79,6 +81,10 @@ describe('PantriesService', () => {
           provide: getRepositoryToken(Pantry),
           useValue: mockRepository,
         },
+        {
+          provide: getRepositoryToken(User),
+          useValue: mockUserRepository,
+        },
       ],
     }).compile();
 

apps/backend/src/pantries/pantries.service.ts

@@ -1,4 +1,8 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException,
+} from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { In, Repository } from 'typeorm';
 import { Pantry } from './pantries.entity';
@@ -7,10 +11,14 @@ import { validateId } from '../utils/validation.utils';
 import { ApplicationStatus } from '../shared/types';
 import { PantryApplicationDto } from './dtos/pantry-application.dto';
 import { Role } from '../users/types';
+import { ApprovedPantryResponse } from './types';
 
 @Injectable()
 export class PantriesService {
-  constructor(@InjectRepository(Pantry) private repo: Repository<Pantry>) {}
+  constructor(
+    @InjectRepository(Pantry) private repo: Repository<Pantry>,
+    @InjectRepository(User) private userRepo: Repository<User>,
+  ) {}
 
   async findOne(pantryId: number): Promise<Pantry> {
     validateId(pantryId, 'Pantry');
@@ -113,6 +121,84 @@ export class PantriesService {
     await this.repo.update(id, { status: ApplicationStatus.DENIED });
   }
 
+  async getApprovedPantriesWithVolunteers(): Promise<ApprovedPantryResponse[]> {
+    const pantries = await this.repo.find({
+      where: { status: ApplicationStatus.APPROVED },
+      relations: ['volunteers', 'pantryUser'],
+    });
+
+    return pantries.map((pantry) => ({
+      pantryId: pantry.pantryId,
+      pantryName: pantry.pantryName,
+      contactFirstName: pantry.pantryUser.firstName,
+      contactLastName: pantry.pantryUser.lastName,
+      contactEmail: pantry.pantryUser.email,
+      contactPhone: pantry.pantryUser.phone,
+      shipmentAddressLine1: pantry.shipmentAddressLine1,
+      shipmentAddressCity: pantry.shipmentAddressCity,
+      shipmentAddressZip: pantry.shipmentAddressZip,
+      shipmentAddressState: pantry.shipmentAddressState,
+      shipmentAddressCountry: pantry.shipmentAddressCountry,
+      allergenClients: pantry.allergenClients,
+      restrictions: pantry.restrictions,
+      refrigeratedDonation: pantry.refrigeratedDonation,
+      reserveFoodForAllergic: pantry.reserveFoodForAllergic,
+      reservationExplanation: pantry.reservationExplanation,
+      dedicatedAllergyFriendly: pantry.dedicatedAllergyFriendly,
+      clientVisitFrequency: pantry.clientVisitFrequency,
+      identifyAllergensConfidence: pantry.identifyAllergensConfidence,
+      serveAllergicChildren: pantry.serveAllergicChildren,
+      activities: pantry.activities,
+      activitiesComments: pantry.activitiesComments,
+      itemsInStock: pantry.itemsInStock,
+      needMoreOptions: pantry.needMoreOptions,
+      newsletterSubscription: pantry.newsletterSubscription ?? false,
+      volunteers: (pantry.volunteers || []).map((volunteer) => ({
+        userId: volunteer.id,
+        name: `${volunteer.firstName} ${volunteer.lastName}`,
+        email: volunteer.email,
+        phone: volunteer.phone,
+        role: volunteer.role,
+      })),
+    }));
+  }
+
+  async updatePantryVolunteers(
+    pantryId: number,
+    volunteerIds: number[],
+  ): Promise<void> {
+    validateId(pantryId, 'Pantry');
+    volunteerIds.forEach((id) => validateId(id, 'Volunteer'));
+
+    const pantry = await this.repo.findOne({
+      where: { pantryId },
+      relations: ['volunteers'],
+    });
+
+    if (!pantry) {
+      throw new NotFoundException(`Pantry with ID ${pantryId} not found`);
+    }
+
+    const users = await this.userRepo.findBy({ id: In(volunteerIds) });
+
+    if (users.length !== volunteerIds.length) {
+      throw new NotFoundException('One or more users not found');
+    }
+
+    const nonVolunteers = users.filter((user) => user.role !== Role.VOLUNTEER);
+
+    if (nonVolunteers.length > 0) {
+      throw new BadRequestException(
+        `Users ${nonVolunteers
+          .map((user) => user.id)
+          .join(', ')} are not volunteers`,
+      );
+    }
+
+    pantry.volunteers = users;
+    await this.repo.save(pantry);
+  }
+
   async findByIds(pantryIds: number[]): Promise<Pantry[]> {
     pantryIds.forEach((id) => validateId(id, 'Pantry'));
 

apps/backend/src/pantries/types.ts

@@ -1,3 +1,40 @@
+export interface ApprovedPantryResponse {
+  pantryId: number;
+  pantryName: string;
+  contactFirstName: string;
+  contactLastName: string;
+  contactEmail: string;
+  contactPhone: string;
+  shipmentAddressLine1: string;
+  shipmentAddressCity: string;
+  shipmentAddressZip: string;
+  shipmentAddressState: string;
+  shipmentAddressCountry?: string;
+  allergenClients: string;
+  restrictions: string[];
+  refrigeratedDonation: RefrigeratedDonation;
+  reserveFoodForAllergic: ReserveFoodForAllergic;
+  reservationExplanation?: string;
+  dedicatedAllergyFriendly: boolean;
+  clientVisitFrequency?: ClientVisitFrequency;
+  identifyAllergensConfidence?: AllergensConfidence;
+  serveAllergicChildren?: ServeAllergicChildren;
+  activities: Activity[];
+  activitiesComments?: string;
+  itemsInStock: string;
+  needMoreOptions: string;
+  newsletterSubscription: boolean;
+  volunteers: AssignedVolunteer[];
+}
+
+export interface AssignedVolunteer {
+  userId: number;
+  name: string;
+  email: string;
+  phone: string;
+  role: string;
+}
+
 export enum RefrigeratedDonation {
   YES = 'Yes, always',
   NO = 'No',