SSF-143 Reusable Order Details Modal

apps/backend/src/foodRequests/dtos/food-request-summary.dto.ts

@@ -0,0 +1,12 @@
+import { FoodRequestStatus, RequestSize } from '../../foodRequests/types';
+
+export class FoodRequestSummaryDto {
+  requestId!: number;
+  pantryId!: number;
+  pantryName!: string;
+  requestedSize!: RequestSize;
+  requestedItems!: string[];
+  additionalInformation!: string | null;
+  requestedAt!: Date;
+  status!: FoodRequestStatus;
+}

apps/backend/src/foodRequests/request.controller.spec.ts

@@ -6,7 +6,7 @@ import { FoodRequest } from './request.entity';
 import { RequestSize } from './types';
 import { OrderStatus } from '../orders/types';
 import { FoodType } from '../donationItems/types';
-import { OrderDetailsDto } from './dtos/order-details.dto';
+import { OrderDetailsDto } from '../orders/dtos/order-details.dto';
 import { CreateRequestDto } from './dtos/create-request.dto';
 import { Order } from '../orders/order.entity';
 
@@ -80,20 +80,23 @@ describe('RequestsController', () => {
     });
   });
 
-  describe('GET /all-order-details/:requestId', () => {
+  describe('GET /:requestId/order-details', () => {
     it('should call requestsService.getOrderDetails and return all associated orders and their details', async () => {
       const mockOrderDetails: OrderDetailsDto[] = [
         {
           orderId: 10,
           status: OrderStatus.DELIVERED,
           foodManufacturerName: 'Test Manufacturer',
+          trackingLink: 'examplelink.com',
           items: [
             {
+              id: 1,
               name: 'Rice',
               quantity: 5,
               foodType: FoodType.GRANOLA,
             },
             {
+              id: 2,
               name: 'Beans',
               quantity: 3,
               foodType: FoodType.DRIED_BEANS,
@@ -104,8 +107,10 @@ describe('RequestsController', () => {
           orderId: 11,
           status: OrderStatus.PENDING,
           foodManufacturerName: 'Another Manufacturer',
+          trackingLink: 'examplelink.com',
           items: [
             {
+              id: 1,
               name: 'Milk',
               quantity: 2,
               foodType: FoodType.DAIRY_FREE_ALTERNATIVES,

apps/backend/src/foodRequests/request.controller.ts

@@ -17,7 +17,7 @@ import { FoodRequest } from './request.entity';
 import { Roles } from '../auth/roles.decorator';
 import { Role } from '../users/types';
 import { RequestSize } from './types';
-import { OrderDetailsDto } from './dtos/order-details.dto';
+import { OrderDetailsDto } from '../orders/dtos/order-details.dto';
 import { CreateRequestDto } from './dtos/create-request.dto';
 
 @Controller('requests')

apps/backend/src/foodRequests/request.service.ts

@@ -6,7 +6,7 @@ import { validateId } from '../utils/validation.utils';
 import { FoodRequestStatus, RequestSize } from './types';
 import { Pantry } from '../pantries/pantries.entity';
 import { Order } from '../orders/order.entity';
-import { OrderDetailsDto } from './dtos/order-details.dto';
+import { OrderDetailsDto } from '../orders/dtos/order-details.dto';
 import { OrderStatus } from '../orders/types';
 
 @Injectable()
@@ -66,7 +66,9 @@ export class RequestsService {
       orderId: order.orderId,
       status: order.status,
       foodManufacturerName: order.foodManufacturer.foodManufacturerName,
+      trackingLink: order.trackingLink,
       items: order.allocations.map((allocation) => ({
+        id: allocation.item.itemId,
         name: allocation.item.itemName,
         quantity: allocation.allocatedQuantity,
         foodType: allocation.item.foodType,

apps/backend/src/foodRequests/dtos/order-details.dto.ts → apps/backend/src/orders/dtos/order-details.dto.ts

@@ -1,7 +1,8 @@
 import { FoodType } from '../../donationItems/types';
-import { OrderStatus } from '../../orders/types';
+import { OrderStatus } from '../types';
 
 export class OrderItemDetailsDto {
+  id!: number;
   name!: string;
   quantity!: number;
   foodType!: FoodType;
@@ -11,5 +12,6 @@ export class OrderDetailsDto {
   orderId!: number;
   status!: OrderStatus;
   foodManufacturerName!: string;
+  trackingLink!: string | null;
   items!: OrderItemDetailsDto[];
 }

apps/backend/src/orders/order.controller.spec.ts

@@ -10,8 +10,11 @@ import { FoodRequest } from '../foodRequests/request.entity';
 import { Pantry } from '../pantries/pantries.entity';
 import { AWSS3Service } from '../aws/aws-s3.service';
 import { TrackingCostDto } from './dtos/tracking-cost.dto';
+import { OrderDetailsDto } from './dtos/order-details.dto';
+import { FoodType } from '../donationItems/types';
 import { BadRequestException, NotFoundException } from '@nestjs/common';
 import { FoodManufacturer } from '../foodManufacturers/manufacturers.entity';
+import { FoodRequestSummaryDto } from '../foodRequests/dtos/food-request-summary.dto';
 import { ConfirmDeliveryDto } from './dtos/confirm-delivery.dto';
 
 const mockOrdersService = mock<OrdersService>();
@@ -33,6 +36,11 @@ describe('OrdersController', () => {
     { requestId: 3, pantry: mockPantries[2] as Pantry },
   ];
 
+  const mockRequestSummary: Partial<FoodRequestSummaryDto> = {
+    requestId: 4,
+    pantryName: 'Example Pantry',
+  };
+
   const mockFoodManufacturer: Partial<FoodManufacturer> = {
     foodManufacturerId: 1,
     foodManufacturerName: 'Test FM',
@@ -65,6 +73,21 @@ describe('OrdersController', () => {
     { allocationId: 3, orderId: 2 },
   ];
 
+  const mockOrderDetails: Partial<OrderDetailsDto> = {
+    orderId: 1,
+    status: OrderStatus.DELIVERED,
+    foodManufacturerName: 'food manufacturer 1',
+    trackingLink: 'example-link.com',
+    items: [
+      {
+        id: 1,
+        name: 'item1',
+        quantity: 10,
+        foodType: FoodType.DAIRY_FREE_ALTERNATIVES,
+      },
+    ],
+  };
+
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [OrdersController],
@@ -82,6 +105,21 @@ describe('OrdersController', () => {
     expect(controller).toBeDefined();
   });
 
+  describe('getOrder', () => {
+    it('should call ordersService.findOrderDetails and return order details', async () => {
+      mockOrdersService.findOrderDetails.mockResolvedValueOnce(
+        mockOrderDetails as OrderDetailsDto,
+      );
+
+      const orderId = 1;
+
+      const result = await controller.getOrder(orderId);
+
+      expect(result).toEqual(mockOrderDetails as OrderDetailsDto);
+      expect(mockOrdersService.findOrderDetails).toHaveBeenCalledWith(orderId);
+    });
+  });
+
   describe('getAllOrders', () => {
     it('should call ordersService.getAll and return orders', async () => {
       const status = 'pending';
@@ -159,12 +197,12 @@ describe('OrdersController', () => {
     it('should call ordersService.findOrderFoodRequest and return food request', async () => {
       const orderId = 1;
       mockOrdersService.findOrderFoodRequest.mockResolvedValueOnce(
-        mockRequests[0] as FoodRequest,
+        mockRequestSummary as FoodRequestSummaryDto,
       );
 
       const result = await controller.getRequestFromOrder(orderId);
 
-      expect(result).toEqual(mockRequests[0] as FoodRequest);
+      expect(result).toEqual(mockRequestSummary as FoodRequestSummaryDto);
       expect(mockOrdersService.findOrderFoodRequest).toHaveBeenCalledWith(
         orderId,
       );
@@ -215,30 +253,6 @@ describe('OrdersController', () => {
     });
   });
 
-  describe('getOrder', () => {
-    it('should call ordersService.findOne and return order', async () => {
-      const orderId = 1;
-      mockOrdersService.findOne.mockResolvedValueOnce(mockOrders[0] as Order);
-
-      const result = await controller.getOrder(orderId);
-
-      expect(result).toEqual(mockOrders[0] as Order);
-      expect(mockOrdersService.findOne).toHaveBeenCalledWith(orderId);
-    });
-
-    it('should propagate NotFoundException when order not found', async () => {
-      const orderId = 999;
-      mockOrdersService.findOne.mockRejectedValueOnce(
-        new NotFoundException(`Order ${orderId} not found`),
-      );
-
-      const promise = controller.getOrder(orderId);
-      await expect(promise).rejects.toBeInstanceOf(NotFoundException);
-      await expect(promise).rejects.toThrow(`Order ${orderId} not found`);
-      expect(mockOrdersService.findOne).toHaveBeenCalledWith(orderId);
-    });
-  });
-
   describe('getOrderByRequestId', () => {
     it('should call ordersService.findOrderByRequest and return order', async () => {
       const requestId = 1;

apps/backend/src/orders/order.controller.ts

@@ -1,7 +1,6 @@
 import {
   Controller,
   Get,
-  Post,
   Patch,
   Param,
   ParseIntPipe,
@@ -17,10 +16,11 @@ import { OrdersService } from './order.service';
 import { Order } from './order.entity';
 import { Pantry } from '../pantries/pantries.entity';
 import { FoodManufacturer } from '../foodManufacturers/manufacturers.entity';
-import { FoodRequest } from '../foodRequests/request.entity';
 import { AllocationsService } from '../allocations/allocations.service';
 import { OrderStatus } from './types';
 import { TrackingCostDto } from './dtos/tracking-cost.dto';
+import { OrderDetailsDto } from './dtos/order-details.dto';
+import { FoodRequestSummaryDto } from '../foodRequests/dtos/food-request-summary.dto';
 import { AWSS3Service } from '../aws/aws-s3.service';
 import { FilesInterceptor } from '@nestjs/platform-express';
 import * as multer from 'multer';
@@ -68,7 +68,7 @@ export class OrdersController {
   @Get('/:orderId/request')
   async getRequestFromOrder(
     @Param('orderId', ParseIntPipe) orderId: number,
-  ): Promise<FoodRequest> {
+  ): Promise<FoodRequestSummaryDto> {
     return this.ordersService.findOrderFoodRequest(orderId);
   }
 
@@ -82,8 +82,8 @@ export class OrdersController {
   @Get('/:orderId')
   async getOrder(
     @Param('orderId', ParseIntPipe) orderId: number,
-  ): Promise<Order> {
-    return this.ordersService.findOne(orderId);
+  ): Promise<OrderDetailsDto> {
+    return this.ordersService.findOrderDetails(orderId);
   }
 
   @Get('/order/:requestId')

apps/backend/src/orders/order.service.spec.ts

@@ -5,8 +5,10 @@ import { Order } from './order.entity';
 import { testDataSource } from '../config/typeormTestDataSource';
 import { OrderStatus } from './types';
 import { Pantry } from '../pantries/pantries.entity';
+import { OrderDetailsDto } from './dtos/order-details.dto';
 import { BadRequestException, NotFoundException } from '@nestjs/common';
 import { TrackingCostDto } from './dtos/tracking-cost.dto';
+import { FoodType } from '../donationItems/types';
 import { FoodRequest } from '../foodRequests/request.entity';
 import 'multer';
 import { FoodRequestStatus } from '../foodRequests/types';
@@ -134,6 +136,62 @@ describe('OrdersService', () => {
     });
   });
 
+  describe('findOrderDetails', () => {
+    it('returns mapped OrderDetailsDto including allocations and manufacturer', async () => {
+      const orderId = 1;
+
+      const result = await service.findOrderDetails(orderId);
+
+      const expected: OrderDetailsDto = {
+        orderId: 1,
+        status: OrderStatus.DELIVERED,
+        foodManufacturerName: 'FoodCorp Industries',
+        trackingLink: 'www.samplelink/samplelink',
+        items: [
+          {
+            id: 1,
+            foodType: FoodType.SEED_BUTTERS,
+            name: 'Peanut Butter (16oz)',
+            quantity: 10,
+          },
+          {
+            id: 2,
+            foodType: FoodType.GLUTEN_FREE_BREAD,
+            name: 'Whole Wheat Bread',
+            quantity: 25,
+          },
+          {
+            id: 3,
+            foodType: FoodType.REFRIGERATED_MEALS,
+            name: 'Canned Green Beans',
+            quantity: 5,
+          },
+        ],
+      };
+
+      expect(result).toMatchObject({
+        orderId: expected.orderId,
+        status: expected.status,
+        foodManufacturerName: expected.foodManufacturerName,
+        trackingLink: expected.trackingLink,
+      });
+
+      expect(result.items).toHaveLength(expected.items.length);
+      expect(result.items).toEqual(expect.arrayContaining(expected.items));
+    });
+
+    it('throws NotFoundException when order does not exist', async () => {
+      const missingOrderId = 99999999;
+
+      await expect(service.findOrderDetails(missingOrderId)).rejects.toThrow(
+        NotFoundException,
+      );
+      await expect(service.findOrderDetails(missingOrderId)).rejects.toThrow(
+        `Order ${missingOrderId} not found`,
+      );
+    });
+  });
+
   describe('getCurrentOrders', () => {
     it(`returns only orders with status 'pending' or 'shipped'`, async () => {
       const orders = await service.getCurrentOrders();