farsi messages

src/modules/orders/providers/orders.service.ts

@@ -22,6 +22,7 @@ import { BulkReserveFoodDto } from 'src/modules/inventory/dto/bulk-reserve-food.
 import { StatusTransitionRef } from '../interface/order.interface';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 import { OrderCreatedEvent, OrderStatusChangedEvent } from '../events/order.events';
+import { OrderMessage } from 'src/common/enums/message.enum';
 type OrderItemData = { food: Food; quantity: number; unitPrice: number; discount: number };
 
 type ValidatedCartForOrder = {
@@ -224,7 +225,7 @@ export class OrdersService {
       },
     );
     if (!order) {
-      throw new NotFoundException('Order not found');
+      throw new NotFoundException(OrderMessage.NOT_FOUND);
     }
     return order;
   }
@@ -291,11 +292,11 @@ export class OrdersService {
   private assertStatusTransitionAllowed(order: Order, to: OrderStatus, ref: StatusTransitionRef) {
     const paymentMethod = order.paymentMethod?.method;
     if (!paymentMethod) {
-      throw new BadRequestException('Order payment method is missing');
+      throw new BadRequestException(OrderMessage.PAYMENT_METHOD_MISSING);
     }
 
     if (!this.canTransition(order.status, to, paymentMethod, ref)) {
-      throw new BadRequestException(`Invalid status transition: ${order.status} -> ${to}`);
+      throw new BadRequestException(OrderMessage.INVALID_STATUS_TRANSITION);
     }
   }
 
@@ -336,70 +337,66 @@ export class OrdersService {
       { id: orderId, restaurant: { id: restId } },
       { populate: ['paymentMethod'] },
     );
-    if (!order) throw new NotFoundException('Order not found');
+    if (!order) throw new NotFoundException(OrderMessage.NOT_FOUND);
     return order;
   }
 
   private assertCartHasItems(cart: Cart) {
     if (!cart.items || cart.items.length === 0) {
-      throw new BadRequestException('Cart is empty. Add items to cart before creating an order.');
+      throw new BadRequestException(OrderMessage.CART_EMPTY);
     }
   }
 
   private assertCartHasDeliveryMethod(cart: Cart) {
     if (!cart.deliveryMethodId) {
-      throw new NotFoundException('Delivery method not found');
+      throw new NotFoundException(OrderMessage.DELIVERY_METHOD_NOT_FOUND);
     }
   }
 
   private assertCartHasPaymentMethod(cart: Cart) {
     if (!cart.paymentMethodId) {
-      throw new BadRequestException(
-        'Payment method is required. Please set a payment method before creating an order.',
-      );
+      throw new BadRequestException(OrderMessage.PAYMENT_METHOD_REQUIRED);
     }
   }
 
   private async getUserOrFail(userId: string): Promise<User> {
     const user = await this.em.findOne(User, { id: userId });
-    if (!user) throw new NotFoundException('User not found');
+    if (!user) throw new NotFoundException(OrderMessage.USER_NOT_FOUND);
     return user;
   }
 
   private async getRestaurantOrFail(restaurantId: string): Promise<Restaurant> {
     const restaurant = await this.em.findOne(Restaurant, { id: restaurantId });
-    if (!restaurant) throw new NotFoundException('Restaurant not found');
+    if (!restaurant) throw new NotFoundException(OrderMessage.RESTAURANT_NOT_FOUND);
     return restaurant;
   }
 
   private async getDeliveryOrFail(deliveryId: string): Promise<Delivery> {
     const delivery = await this.em.findOne(Delivery, { id: deliveryId });
-    if (!delivery) throw new NotFoundException('Delivery not found');
+    if (!delivery) throw new NotFoundException(OrderMessage.DELIVERY_NOT_FOUND);
     return delivery;
   }
 
   private assertMeetsMinOrderForDelivery(cart: Cart, delivery: Delivery) {
     const minOrderPrice = Number(delivery.minOrderPrice) || 0;
     if (minOrderPrice > 0 && cart.total < minOrderPrice) {
-      throw new BadRequestException(
-        `Minimum order amount for this delivery method is ${minOrderPrice}. Current total is ${cart.total}.`,
-      );
+      throw new BadRequestException(OrderMessage.MIN_ORDER_AMOUNT_NOT_MET);
     }
   }
 
   private assertDeliveryMethodRequirements(cart: Cart, delivery: Delivery) {
     if (delivery.method === DeliveryMethodEnum.DineIn) {
       if (!cart.tableNumber || cart.tableNumber.trim() === '') {
-        throw new BadRequestException('Table number is required when delivery method is DineIn');
+        throw new BadRequestException(OrderMessage.TABLE_NUMBER_REQUIRED);
       }
     }
 
     if (delivery.method === DeliveryMethodEnum.DeliveryCourier && !cart.userAddress) {
-      throw new BadRequestException('Address is required. Please set a delivery address before creating an order.');
+      throw new BadRequestException(OrderMessage.ADDRESS_REQUIRED);
     }
 
     if (delivery.method === DeliveryMethodEnum.DeliveryCar && !cart.carAddress) {
-      throw new BadRequestException('Car address is required. Please set a car address before creating an order.');
+      throw new BadRequestException(OrderMessage.CAR_ADDRESS_REQUIRED);
     }
   }
 
@@ -422,7 +419,7 @@ export class OrdersService {
 
   private assertPaymentMethodEnabled(paymentMethod: PaymentMethod) {
     if (!paymentMethod.enabled) {
-      throw new BadRequestException('Payment method is not enabled for this restaurant');
+      throw new BadRequestException(OrderMessage.PAYMENT_METHOD_NOT_ENABLED);
     }
   }
 
@@ -431,10 +428,10 @@ export class OrdersService {
 
     for (const cartItem of cart.items) {
       const food = await this.em.findOne(Food, { id: cartItem.foodId }, { populate: ['restaurant', 'inventory'] });
-      if (!food) throw new NotFoundException(`Food with ID ${cartItem.foodId} not found`);
+      if (!food) throw new NotFoundException(OrderMessage.FOOD_NOT_FOUND);
 
       if (food.restaurant.id !== restaurantId) {
-        throw new BadRequestException(`Food ${food.title || food.id} does not belong to restaurant ${restaurantId}`);
+        throw new BadRequestException(OrderMessage.FOOD_NOT_BELONGS_TO_RESTAURANT);
       }
 
       this.assertFoodHasSufficientStock(food, cartItem.quantity);
@@ -453,9 +450,7 @@ export class OrdersService {
   private assertFoodHasSufficientStock(food: Food, quantity: number) {
     const availableStock = food.inventory?.availableStock ?? 0;
     if (availableStock < quantity) {
-      throw new BadRequestException(
-        `Insufficient stock for food ${food.title || food.id}. Available: ${availableStock}, Requested: ${quantity}`,
-      );
+      throw new BadRequestException(OrderMessage.FOOD_NOT_FOUND);
     }
   }