Merge pull request #289 from map-of-pi/dev

Automated PR to merge dev to main

Author: adisa39

src/controllers/orderController.ts

@@ -48,13 +48,24 @@ export const getSingleOrder = async (req: Request, res: Response) => {
   }
 };
 
+// TODO: To be removed once payment service is fully integrated
 export const createOrder = async (req: Request, res: Response) => {
-  const { orderId, orderData, orderItems } = req.body;
+  const buyer = req.currentUser as IUser;
+  const { orderData, orderItems } = req.body;
   try {
-    const updatedOrder = await orderService.createOrder(orderData, orderItems);
-    return res.status(201).json(updatedOrder);
+    // Ensure no payment ID is attached
+    const sanitizedOrderData = { ...orderData, paymentId: null };
+    const order = await orderService.createOrder(sanitizedOrderData, orderItems, buyer);
+    if (!order) {
+      logger.error(`Failed to create order with provided data: ${JSON.stringify(sanitizedOrderData)}`);
+      return res.status(400).json({ message: "Invalid order data" });
+    }
+
+    // Mark the order as paid (temporary behavior)
+    const paidOrder = await orderService.markAsPaidOrder(order._id as string);
+    return res.status(200).json(paidOrder);
   } catch (error) {
-    logger.error(`Failed to create order for orderID ${ orderId }:`, error);
+    logger.error(`Failed to create order:`, error);
     return res.status(500).json({ 
       message: 'An error occurred while creating order; please try again later'
     });

src/helpers/payment.ts

@@ -96,13 +96,13 @@ const checkoutProcess = async (
 
   // Construct order data object
   const orderData = buildOrderData(
-    buyer._id as string,
-    seller._id as string,
+    authUser.pi_uid as string,
+    OrderPayment.seller as string,
     newPayment._id as string,
     currentPayment
   )
   // Create a new order along with its items
-  const newOrder = await createOrder(orderData as NewOrder, OrderPayment.items);
+  const newOrder = await createOrder(orderData as NewOrder, OrderPayment.items, authUser);
 
   logger.info('order created successfully', { orderId: newOrder._id });
   return newOrder;

src/models/Order.ts

@@ -8,7 +8,7 @@ const orderSchema = new Schema<IOrder>(
   {
     payment_id: {
       type: SchemaTypes.ObjectId,
-      required: true,
+      required: false, // To change to true once payment integration is complete
       default: null,
       ref: "Payment",
     },

src/routes/order.routes.ts

@@ -169,7 +169,7 @@ orderRoutes.get("/:order_id", verifyToken, orderController.getSingleOrder);
  *       401:
  *         description: Unauthorized
  *       400:
- *         description: Bad request
+ *         description: Bad request | Invalid order data
  *       500:
  *         description: Internal server error
  */  

src/services/order.service.ts

@@ -11,22 +11,32 @@ import SellerItem from "../models/SellerItem";
 import User from "../models/User";
 import { OrderStatusType } from "../models/enums/orderStatusType";
 import { OrderItemStatusType } from "../models/enums/orderItemStatusType";
-import { IOrder, NewOrder, PickedItems } from "../types";
+import { IOrder, IUser, NewOrder, PickedItems } from "../types";
 import logger from "../config/loggingConfig";
 
 export const createOrder = async (
   orderData: NewOrder,
-  orderItems: PickedItems[]
+  orderItems: PickedItems[],
+  authUser: IUser
 ): Promise<IOrder> => {
   const session = await mongoose.startSession();
 
   try {
     session.startTransaction();
 
+    // Look up the seller and buyer in the database
+    const seller = await Seller.findOne({ seller_id: orderData.sellerId });
+    const buyer = await User.findOne({ pi_uid: authUser?.pi_uid });
+
+    if (!buyer || !seller) {
+      logger.error("Seller or buyer not found", { sellerId: orderData.sellerId, buyerId: authUser?.pi_uid });
+      throw new Error("Seller or buyer not found");
+    }
+
     /* Step 1: Create a new Order record */
     const order = new Order({
-      buyer_id: orderData.buyerId,
-      seller_id: orderData.sellerId,
+      buyer_id: buyer._id,
+      seller_id: seller._id,
       payment_id: orderData.paymentId,
       total_amount: orderData.totalAmount,
       status: orderData.status,
@@ -128,6 +138,32 @@ export const updatePaidOrder = async (paymentId: string): Promise<IOrder> => {
   }  
 };
 
+// TODO: To be removed once payment service is fully integrated
+export const markAsPaidOrder = async (orderId: string): Promise<IOrder> => {
+  try {
+    const updatedOrder = await Order.findByIdAndUpdate(
+      orderId, 
+      { 
+        $set: {
+          is_paid: true,
+          status: OrderStatusType.Pending
+        }
+      },
+      { new: true }
+    ).exec();
+    
+    if (!updatedOrder) {
+      logger.error(`Failed to update paid order for order ID ${ orderId }`);
+      throw new Error('Failed to update paid order');
+    }
+    return updatedOrder;
+
+  } catch (error: any) {
+    logger.error(`Failed to update paid order for order ${ orderId }: ${ error }`);
+    throw error;
+  }  
+};
+
 export const getSellerOrdersById = async (piUid: string) => {
   try {
     const seller = await Seller.exists({ seller_id: piUid });

test/controllers/orderController.spec.ts

@@ -20,6 +20,7 @@ jest.mock('../../src/services/order.service', () => ({
   getOrderItems: jest.fn(),
   updateOrderStatus: jest.fn(),
   updateOrderItemStatus: jest.fn(),
+  markAsPaidOrder: jest.fn()
 }));
 
 describe('orderController', () => {
@@ -152,39 +153,68 @@ describe('orderController', () => {
 
   describe('createOrder function', () => {
     const mockOrderId = '24f5a0f2a86d1f9f3b7e4e82';
+    const mockUser = { pi_uid: '0a0a0a-0a0a-0a0a' };
+    const mockOrderData = { payment_id: '0d367ba3a2e8438086c3ab7c0b7890c0' };
 
     beforeEach(() => {
       req = { 
         body: {
-          orderId: mockOrderId,
-          pi_username: 'testuser',
+          orderData: mockOrderData,
           orderItems: [{ itemId: 'item-1' }],
-        }      
+        },
+        currentUser: mockUser      
       };
       res = {
         status: jest.fn().mockReturnThis(),
         json: jest.fn(),
       };
     });
 
-    it('should return [201] and created/ updated order on success', async () => {
-      const mockOrder = { id: mockOrderId, status: OrderStatusType.Initialized };
+    it('should return [200] and created/ updated order on success', async () => {
+      const mockOrder = { _id: mockOrderId, status: OrderStatusType.Initialized };
+      const mockPaidOrder = { ...mockOrder, status: OrderStatusType.Pending };
       (orderService.createOrder as jest.Mock).mockResolvedValue(mockOrder);
+      (orderService.markAsPaidOrder as jest.Mock).mockResolvedValue(mockPaidOrder);
 
       await createOrder(req, res);
 
-      expect(orderService.createOrder).toHaveBeenCalledWith(req.body.orderData, req.body.orderItems);
-      expect(res.status).toHaveBeenCalledWith(201);
-      expect(res.json).toHaveBeenCalledWith(mockOrder);
+      expect(orderService.createOrder).toHaveBeenCalledWith(
+        { ...mockOrderData, paymentId: null },
+        req.body.orderItems,
+        req.currentUser 
+      );
+      expect(orderService.markAsPaidOrder).toHaveBeenCalledWith(mockOrderId);
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith(mockPaidOrder);
     });
 
-    it('should return [500] if order service throws error', async () => {
+    it('should return [400] if createOrder service returns null', async () => {
+      (orderService.createOrder as jest.Mock).mockResolvedValue(null);
+  
+      await createOrder(req, res);
+  
+      expect(orderService.createOrder).toHaveBeenCalledWith(
+        { ...mockOrderData, paymentId: null },
+        req.body.orderItems,
+        req.currentUser 
+      );
+      expect(orderService.markAsPaidOrder).not.toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith({ message: 'Invalid order data' });
+    });
+
+    it('should return [500] if createOrder service throws error', async () => {
       const mockError = new Error('An error occurred while creating order; please try again later');
       (orderService.createOrder as jest.Mock).mockRejectedValue(mockError);
 
       await createOrder(req, res);
 
-      expect(orderService.createOrder).toHaveBeenCalledWith(req.body.orderData, req.body.orderItems);
+      expect(orderService.createOrder).toHaveBeenCalledWith(
+        { ...mockOrderData, paymentId: null },
+        req.body.orderItems,
+        req.currentUser
+      );
+      expect(orderService.markAsPaidOrder).not.toHaveBeenCalled();
       expect(res.status).toHaveBeenCalledWith(500);
       expect(res.json).toHaveBeenCalledWith({ message: mockError.message });
     });

test/helpers/payment.spec.ts

@@ -316,7 +316,7 @@ describe('processPaymentApproval function', () => {
       paymentType: PaymentType.BuyerCheckout
     });
     expect(createOrder).toHaveBeenCalledWith({
-      buyerId: mockBuyer._id,
+      buyerId: mockUser.pi_uid,
       sellerId: mockSeller._id,
       paymentId: mockPayment._id,
       totalAmount: mockPayment.amount,
@@ -325,7 +325,8 @@ describe('processPaymentApproval function', () => {
       sellerFulfillmentDescription: currentPayment.metadata.OrderPayment?.seller_fulfillment_description,
       buyerFulfillmentDescription: currentPayment.metadata.OrderPayment?.buyer_fulfillment_description,
     },
-      currentPayment.metadata.OrderPayment?.items
+      currentPayment.metadata.OrderPayment?.items,
+      mockUser
     );
     expect(platformAPIClient.post).toHaveBeenCalledWith(`/v2/payments/${ mockPiPaymentId }/approve`);
     expect(result).toEqual({