Sa/mspca 2 get volunteer by id and update volunteer by

.yarnrc.yml

@@ -0,0 +1,6 @@
+approvedGitRepositories:
+  - "**"
+
+enableScripts: true
+
+nodeLinker: node-modules

apps/backend/src/volunteers/dto/update-volunteer.dto.ts

@@ -0,0 +1,88 @@
+import { Homebase } from '../../types';
+import { FosterType } from '../volunteers.types';
+import {
+  IsOptional,
+  IsString,
+  IsNumber,
+  IsEnum,
+  IsPositive,
+  IsNotEmpty,
+  MaxLength,
+  IsPhoneNumber,
+  IsEmail,
+} from 'class-validator';
+
+export class UpdateVolunteerDto {
+  @IsNumber()
+  @IsPositive()
+  volunteerId?: number;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  firstName?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  lastName?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(20)
+  @IsPhoneNumber('US')
+  phone?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(20)
+  @IsPhoneNumber('US')
+  secondaryPhone?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  @IsEmail()
+  email?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  address?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  city?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(10)
+  zipcode?: string;
+
+  @IsOptional()
+  @IsEnum(Homebase)
+  homebase?: Homebase;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  residentAnimals?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  notes?: string;
+
+  @IsOptional()
+  @IsEnum(FosterType)
+  fosterType?: FosterType;
+}

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

@@ -1,25 +1,117 @@
 import { Test, TestingModule } from '@nestjs/testing';
+import { NotFoundException, BadRequestException } from '@nestjs/common';
 import { VolunteersController } from './volunteers.controller';
 import { VolunteersService } from './volunteers.service';
+import { FosterVolunteer } from './volunteers.entity';
 
 describe('VolunteersController', () => {
   let controller: VolunteersController;
 
+  const mockVolunteer = {
+    volunteerId: 1,
+    firstName: 'Jane',
+    lastName: 'Doe',
+    notes: 'likes cats',
+  } as FosterVolunteer;
+
+  const mockVolunteersService = {
+    getVolunteerById: jest.fn(),
+    updateVolunteerById: jest.fn(),
+  };
+
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [VolunteersController],
       providers: [
-        {
-          provide: VolunteersService,
-          useValue: {},
-        },
+        { provide: VolunteersService, useValue: mockVolunteersService },
       ],
     }).compile();
 
     controller = module.get<VolunteersController>(VolunteersController);
   });
 
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
   it('should be defined', () => {
     expect(controller).toBeDefined();
   });
+
+  describe('getVolunteerById', () => {
+    it('should return a volunteer when found', async () => {
+      mockVolunteersService.getVolunteerById.mockResolvedValue(mockVolunteer);
+
+      const result = await controller.getVolunteerById(1);
+
+      expect(result).toEqual(mockVolunteer);
+      expect(mockVolunteersService.getVolunteerById).toHaveBeenCalledWith(1);
+    });
+
+    it('should throw NotFoundException when volunteer does not exist', async () => {
+      mockVolunteersService.getVolunteerById.mockRejectedValue(
+        new NotFoundException('Volunteer with id 999 not found'),
+      );
+
+      await expect(controller.getVolunteerById(999)).rejects.toThrow(
+        NotFoundException,
+      );
+    });
+
+    it('should throw BadRequestException when id is invalid', async () => {
+      await expect(controller.getVolunteerById(0)).rejects.toThrow(
+        BadRequestException,
+      );
+      expect(mockVolunteersService.getVolunteerById).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('updateVolunteerById', () => {
+    it('should update and return the volunteer when found', async () => {
+      const dto = { volunteerId: 1, notes: 'updated notes' };
+      const updatedVolunteer = { ...mockVolunteer, ...dto } as FosterVolunteer;
+      mockVolunteersService.updateVolunteerById.mockResolvedValue(
+        updatedVolunteer,
+      );
+
+      const result = await controller.updateVolunteerById(1, dto);
+
+      expect(result).toEqual(updatedVolunteer);
+      expect(mockVolunteersService.updateVolunteerById).toHaveBeenCalledWith(
+        1,
+        dto,
+      );
+    });
+
+    it('should throw NotFoundException when volunteer does not exist', async () => {
+      mockVolunteersService.updateVolunteerById.mockRejectedValue(
+        new NotFoundException('Volunteer with id 999 not found'),
+      );
+
+      await expect(
+        controller.updateVolunteerById(999, { volunteerId: 999, notes: 'x' }),
+      ).rejects.toThrow(NotFoundException);
+    });
+
+    it('should throw BadRequestException when id is invalid', async () => {
+      await expect(
+        controller.updateVolunteerById(0, { volunteerId: 0, notes: 'x' }),
+      ).rejects.toThrow(BadRequestException);
+      expect(mockVolunteersService.updateVolunteerById).not.toHaveBeenCalled();
+    });
+
+    it('should throw BadRequestException when path and body ids do not match', async () => {
+      await expect(
+        controller.updateVolunteerById(1, { volunteerId: 2, notes: 'x' }),
+      ).rejects.toThrow(BadRequestException);
+      expect(mockVolunteersService.updateVolunteerById).not.toHaveBeenCalled();
+    });
+
+    it('should throw BadRequestException when no fields besides volunteerId are provided', async () => {
+      await expect(
+        controller.updateVolunteerById(1, { volunteerId: 1 }),
+      ).rejects.toThrow(BadRequestException);
+      expect(mockVolunteersService.updateVolunteerById).not.toHaveBeenCalled();
+    });
+  });
 });

apps/backend/src/volunteers/volunteers.controller.ts

@@ -1,15 +1,67 @@
-import { Controller } from '@nestjs/common';
+import {
+  Controller,
+  Patch,
+  Get,
+  Param,
+  Body,
+  ParseIntPipe,
+  BadRequestException,
+} from '@nestjs/common';
+import { ApiOperation, ApiParam, ApiResponse } from '@nestjs/swagger';
 import { VolunteersService } from './volunteers.service';
+import { validateId } from '../utils/validation.utils';
+import { UpdateVolunteerDto } from './dto/update-volunteer.dto';
+import { FosterVolunteer } from './volunteers.entity';
 
 // @ApiTags('Volunteers')
 // @ApiBearerAuth()
 @Controller('volunteers')
 export class VolunteersController {
   constructor(private volunteersService: VolunteersService) {}
 
-  // Example endpoint
-  // @Get('/:userId')
-  // async getUser(@Param('userId', ParseIntPipe) userId: number): Promise<User> {
-  //   return this.usersService.findOne(userId);
-  // }
+  @Get('/:volunteerId')
+  @ApiOperation({ summary: 'Get a volunteer by ID' })
+  @ApiParam({
+    name: 'volunteerId',
+    type: Number,
+    description: 'ID of the volunteer',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'The volunteer was found',
+    type: FosterVolunteer,
+  })
+  async getVolunteerById(
+    @Param('volunteerId', ParseIntPipe) volunteerId: number,
+  ): Promise<FosterVolunteer> {
+    validateId(volunteerId, 'FosterVolunteer');
+    return this.volunteersService.getVolunteerById(volunteerId);
+  }
+
+  @Patch('/:volunteerId')
+  @ApiOperation({ summary: 'Update a volunteer by ID' })
+  @ApiParam({
+    name: 'volunteerId',
+    type: Number,
+    description: 'ID of the volunteer',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'The volunteer was updated',
+    type: FosterVolunteer,
+  })
+  async updateVolunteerById(
+    @Param('volunteerId', ParseIntPipe) volunteerId: number,
+    @Body() dto: UpdateVolunteerDto,
+  ): Promise<FosterVolunteer> {
+    validateId(volunteerId, 'FosterVolunteer');
+    if (dto.volunteerId !== volunteerId) {
+      throw new BadRequestException('volunteerId in path and body must match');
+    }
+    const fields = Object.keys(dto).filter((key) => key !== 'volunteerId');
+    if (fields.length === 0) {
+      throw new BadRequestException('At least one field must be provided');
+    }
+    return this.volunteersService.updateVolunteerById(volunteerId, dto);
+  }
 }

apps/backend/src/volunteers/volunteers.module.ts

@@ -3,9 +3,10 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { FosterVolunteer } from './volunteers.entity';
 import { VolunteersController } from './volunteers.controller';
 import { VolunteersService } from './volunteers.service';
+import { FosterCoordinator } from '../coordinators/coordinators.entity';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([FosterVolunteer])],
+  imports: [TypeOrmModule.forFeature([FosterVolunteer, FosterCoordinator])],
   controllers: [VolunteersController],
   providers: [VolunteersService],
   exports: [VolunteersService],