41 update get post and put endpoints for donateditem with full program and donor details

client-app/src/Components/DonorForm.tsx

@@ -191,9 +191,8 @@ const DonorForm: React.FC = () => {
                 )}
                 {renderFormField('State', 'state')}
                 {renderFormField('City', 'city')}
-                {renderFormField('Zip Code', 'zipcode')}*/ //
-                {/* Email Opt-In Field */}
-                /*
+                {renderFormField('Zip Code', 'zipcode')}
+
                 <div className="form-field">
                     <label
                         htmlFor="emailOptIn"

server/src/__mocks__/mockDonatedItem.ts

@@ -0,0 +1,14 @@
+export const updateItem = {
+    itemType: 'Updated Book',
+    currentStatus: 'Received',
+    programId: 1,
+    donorId: 1,
+    dateDonated: new Date().toISOString()
+};
+export const newItem = {
+    itemType: 'Book',
+    currentStatus: 'Received',
+    programId: 1,
+    donorId: 1,
+    dateDonated: new Date().toISOString()
+};

server/src/__mocks__/mockDonor.ts

@@ -0,0 +1,12 @@
+export const newDonor = {
+    id: 1,
+    firstName: 'John',
+    lastName: 'Doe',
+    email: '[email protected]',
+    contact: '1234567890',
+    addressLine1: '123 Main St',
+    state: 'Missouri',
+    city: 'St. Louis',
+    zipcode: '63108',
+    emailOptIn: false
+};

server/src/__mocks__/mockPrismaClient.ts

@@ -2,7 +2,20 @@ const mockPrismaClient = {
     donor: {
         create: jest.fn(),
         findMany: jest.fn(),
+        findUnique: jest.fn(),
+    },
+    program: {
+        findUnique: jest.fn(),
+    },
+    donatedItem: {
+        create: jest.fn(),
+        update: jest.fn(),
+        findUnique: jest.fn(),
+    },
+    donatedItemStatus: {
+        create: jest.fn(),
     },
 };
 
+
 export default mockPrismaClient;

server/src/__mocks__/mockProgram.ts

@@ -0,0 +1,7 @@
+export const newProgram = {
+    id: 1,
+    name: 'Valid Program',
+    description: 'Valid',
+    startDate: '2024-10-04',
+    aimAndCause: 'recycle'
+};

server/src/__tests__/donatedItem.test.ts

@@ -0,0 +1,71 @@
+import request from 'supertest';
+import express from 'express';
+import donatedItemRoutes from '../routes/donatedItemRoutes';
+import mockPrismaClient from '../__mocks__/mockPrismaClient';
+import { newProgram } from '../__mocks__/mockProgram';
+import { newDonor } from '../__mocks__/mockDonor';
+import { updateItem,newItem } from '../__mocks__/mockDonatedItem';
+
+const app = express();
+app.use(express.json());
+app.use('/donatedItem', donatedItemRoutes);
+
+describe('DonatedItem API Tests', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Setup mock responses
+        mockPrismaClient.program.findUnique.mockResolvedValue(newProgram);
+        mockPrismaClient.donor.findUnique.mockResolvedValue(newDonor);
+        mockPrismaClient.donatedItem.create.mockResolvedValue({ id: 1, ...newItem });
+        mockPrismaClient.donatedItem.update.mockResolvedValue({ id: 1, ...updateItem });
+    });
+
+    // Test POST /donatedItem
+    it('validates Program name and Donor email before creating a donated item', async () => {
+        const response = await request(app).post('/donatedItem').send(newItem);
+        expect(response.status).toBe(201);
+        expect(mockPrismaClient.donatedItem.create).toHaveBeenCalled();
+
+    });
+
+    it('handles errors when the provided Program or Donor does not exist', async () => {
+        const programId = 99; 
+        const donorId = 29;
+        mockPrismaClient.program.findUnique.mockResolvedValue(null);
+        mockPrismaClient.donor.findUnique.mockResolvedValue(null);
+
+        const response = await request(app).post('/donatedItem').send({
+            ...newItem,
+            programId,
+            donorId,
+            dateDonated: new Date().toISOString()
+        });
+        expect(response.status).toBe(400);
+        expect(response.body.error).toContain(`Donor with ID: ${donorId} does not exist.`);
+
+    });
+
+    // Test PUT /donatedItem/details/{id}
+    it('updates donated item details correctly', async () => {
+        const response = await request(app).put('/donatedItem/details/1').send(updateItem);
+        expect(response.status).toBe(200);
+        expect(mockPrismaClient.donatedItem.update).toHaveBeenCalled();
+        expect(response.body.itemType).toBe(updateItem.itemType);
+    });
+
+    it('returns error responses for invalid Program or Donor values', async () => {
+        mockPrismaClient.program.findUnique.mockResolvedValue(null);
+        mockPrismaClient.donor.findUnique.mockResolvedValue(null);
+
+        const donorId = 19;
+        const programId = 99;
+
+        const response = await request(app).put('/donatedItem/details/1').send({
+            ...updateItem,
+            donorId,
+            programId
+        });
+        expect(response.status).toBe(400);
+        expect(response.body.error).toContain(`Donor with ID: ${donorId} does not exist.`);
+    });
+});

server/src/routes/donatedItemRoutes.ts

@@ -1,15 +1,26 @@
 import { Router, Request, Response } from 'express';
 import prisma from '../prismaClient'; // Import Prisma client
 import { donatedItemValidator } from '../validators/donatedItemValidator'; // Import the validator
+import { validateDonor } from '../services/donorService';
+import { validateProgram } from '../services/programService';
 import { date } from 'joi';
 
 const router = Router();
 
 // POST /donatedItem - Create a new DonatedItem
 router.post('/', donatedItemValidator, async (req: Request, res: Response) => {
     try {
+
         const { dateDonated, ...rest } = req.body;
-
+
+        try {
+            await validateDonor(req.body.donorId);
+            await validateProgram(req.body.programId);
+        } catch (error) {
+            if (error instanceof Error) {
+                return res.status(400).json({ error: error.message });
+            }
+        }
         const dateDonatedDateTime = new Date(dateDonated);
         dateDonatedDateTime.setUTCHours(0, 0, 0, 0); // Set time to 00:00:00 UTC
 
@@ -21,8 +32,20 @@ router.post('/', donatedItemValidator, async (req: Request, res: Response) => {
                 // dateDonated: new Date(dateDonated).setUTCHours(0,0,0,0), // Set time to 00:00:00 UTC
             },
         });
-        console.log('New donated item created:', newItem);
-        res.status(201).json(newItem);
+        const newStatus = await prisma.donatedItemStatus.create({
+            data: {
+                statusType: 'Received',
+                dateModified: dateDonatedDateTime, // Use the same date as dateDonated
+                donatedItemId: newItem.id,
+            },
+        });
+
+        res.status(201).json({
+            donatedItem: newItem,
+            donatedItemStatus: newStatus,
+        });
+
+
     } catch (error) {
         console.error('Error creating donated item:', error);
         res.status(500).json({ message: 'Error creating donated item' });
@@ -35,6 +58,8 @@ router.get('/', async (req: Request, res: Response) => {
         const items = await prisma.donatedItem.findMany({
             include: {
                 statuses: true, // Include related status updates
+                program:true,
+                donor:true,
             },
         });
         res.json(items);
@@ -50,6 +75,15 @@ router.put(
     donatedItemValidator,
     async (req: Request, res: Response) => {
         try {
+            try {
+                await validateDonor(req.body.donorId);
+                await validateProgram(req.body.programId);
+            } catch (error) {
+                if (error instanceof Error) {
+                    return res.status(400).json({ error: error.message });
+                }
+            }
+
             const updatedItem = await prisma.donatedItem.update({
                 where: { id: Number(req.params.id) },
                 data: { ...req.body, lastUpdated: new Date() },
@@ -60,6 +94,7 @@ router.put(
             console.error('Error updating donated item details:', error);
             res.status(500).json({
                 message: 'Error updating donated item details',
+
             });
         }
     },

server/src/routes/donorRoutes.ts

@@ -21,6 +21,7 @@ router.get('/', async (req: Request, res: Response) => {
         const donors = await prisma.donor.findMany();
         res.json(donors);
     } catch (error) {
+        console.error('Error fetching donor:', error);
         res.status(500).json({ message: 'Error fetching donors' });
     }
 });

server/src/schemas/donatedItems.ts

@@ -5,8 +5,8 @@ export const donatedItemSchema = Joi.object({
     currentStatus: Joi.string()
         .valid('Received', 'Pending', 'Processed', 'Delivered')
         .required(),
-    donorEmail: Joi.string().email().required(),
-    program: Joi.string().required(),
+    donorId: Joi.number().integer().required(),
+    programId: Joi.number().integer().required(),
     dateDonated: Joi.date().required(), // Validates as a proper date
 });
 

server/src/services/donorService.ts

@@ -0,0 +1,11 @@
+import prisma from '../prismaClient'; // Adjust the import path as necessary
+
+export async function validateDonor(donorId: number) {
+    const donor = await prisma.donor.findUnique({
+        where: { id: donorId }
+    });
+    if (!donor) {
+        throw new Error(`Donor with ID: ${donorId} does not exist.`);
+    }
+    return donor;
+}

server/src/services/programService.ts

@@ -0,0 +1,11 @@
+import prisma from '../prismaClient'; // Adjust the import path as necessary
+
+export async function validateProgram(programId: number) {
+    const program = await prisma.program.findUnique({
+        where: { id: programId }
+    });
+    if (!program) {
+        throw new Error(`Program ID ${programId} is not valid or does not exist.`);
+    }
+    return program;
+}