remove unused modules

src/modules/order/repositories/order.repository.ts

@@ -0,0 +1,184 @@
+import { Injectable } from '@nestjs/common';
+import { EntityManager, EntityRepository } from '@mikro-orm/postgresql';
+import { FilterQuery } from '@mikro-orm/core';
+import { Order } from '../entities/order.entity';
+import { PaginatedResult } from 'src/common/interfaces/pagination.interface';
+import { OrderStatus } from '../interface/order.interface';
+import { PaymentMethodEnum, PaymentStatusEnum } from '../../payment/interface/payment';
+import { Review } from '../../review/entities/review.entity';
+
+type FindOrdersOpts = {
+  page?: number;
+  limit?: number;
+  statuses?: OrderStatus[];
+  paymentStatus?: PaymentStatusEnum;
+  search?: string;
+  startDate?: string;
+  endDate?: string;
+  orderBy?: string;
+  order?: 'asc' | 'desc';
+  userId?: string;
+  excludeOnlinePendingPayment?: boolean;
+};
+
+@Injectable()
+export class OrderRepository extends EntityRepository<Order> {
+  constructor(readonly em: EntityManager) {
+    super(em, Order);
+  }
+
+  /**
+   * Find orders with pagination and optional filters.
+   * Supports: statuses, paymentStatus, search (orderNumber), date range, ordering.
+   */
+  async findAllPaginated(restId: string, opts: FindOrdersOpts = {}): Promise<PaginatedResult<Order>> {
+    const {
+      page = 1,
+      limit = 10,
+      statuses,
+      search,
+      startDate,
+      endDate,
+      orderBy = 'createdAt',
+      order = 'desc',
+      userId,
+      excludeOnlinePendingPayment = false,
+    } = opts;
+
+    const offset = (page - 1) * limit;
+
+    const where: FilterQuery<Order> = { restaurant: { id: restId } };
+
+    // Filter by statuses
+    if (statuses) {
+      // Ensure statuses is always an array and normalize it
+      const normalizedStatuses = Array.isArray(statuses) ? statuses : [statuses];
+      // Filter out any empty values
+      const validStatuses = normalizedStatuses.filter((s): s is OrderStatus => !!s);
+
+      if (validStatuses.length > 0) {
+        // Use direct equality for single value, $in for multiple values to avoid SQL generation issues
+        if (validStatuses.length === 1) {
+          where.status = validStatuses[0];
+        } else {
+          where.status = { $in: validStatuses };
+        }
+      }
+    }
+
+    if (userId) {
+      where.user = { id: userId };
+    }
+
+    // Filter by date range
+    if (startDate || endDate) {
+      where.createdAt = {};
+      if (startDate) {
+        where.createdAt.$gte = new Date(startDate);
+      }
+      if (endDate) {
+        where.createdAt.$lte = new Date(endDate);
+      }
+    }
+
+    // Search by order number or user information
+    if (search) {
+      const searchPattern = `%${search}%`;
+      const searchConditions: any[] = [
+        { user: { firstName: { $ilike: searchPattern } } },
+        { user: { lastName: { $ilike: searchPattern } } },
+        { user: { phone: { $ilike: searchPattern } } },
+      ];
+
+      // If search is numeric, also search by orderNumber
+      const numericSearch = Number(search);
+      if (!isNaN(numericSearch) && isFinite(numericSearch)) {
+        searchConditions.push({ orderNumber: numericSearch });
+      }
+
+      where.$or = searchConditions;
+    }
+
+    // Filter: Exclude orders with payment method Online and status pending_payment
+    if (excludeOnlinePendingPayment) {
+      const existingConditions = where.$and || [];
+      where.$and = [
+        ...existingConditions,
+        {
+          $or: [
+            { paymentMethod: { method: { $ne: PaymentMethodEnum.Online } } },
+            { status: { $ne: OrderStatus.PENDING_PAYMENT } },
+          ],
+        },
+      ];
+    }
+
+    // First, fetch orders without reviews
+    const [data, total] = await this.findAndCount(where, {
+      limit,
+      offset,
+      orderBy: { [orderBy]: order.toLowerCase() as 'asc' | 'desc' },
+      populate: ['user', 'restaurant', 'deliveryMethod', 'paymentMethod', 'items', 'items.product'] as never,
+    });
+
+    // Collect all (orderId, productId) pairs for efficient review lookup
+    const orderproductPairs: Array<{ orderId: string; productId: string }> = [];
+    for (const order of data) {
+      for (const item of order.items.getItems()) {
+        if (item.product?.id) {
+          orderproductPairs.push({ orderId: order.id, productId: item.product.id });
+        }
+      }
+    }
+
+    // Fetch all relevant reviews in a single query
+    const reviewsMap: Map<string, string> = new Map();
+    if (orderproductPairs.length > 0) {
+      const orderIds = [...new Set(orderproductPairs.map(p => p.orderId))];
+      const productIds = [...new Set(orderproductPairs.map(p => p.productId))];
+
+      const reviews = await this.em.find(
+        Review,
+        {
+          order: { id: { $in: orderIds } },
+          product: { id: { $in: productIds } },
+        },
+        {
+          fields: ['id', 'order', 'product'],
+          populate: ['order', 'product'],
+        },
+      );
+
+      // Create a map: key = `${orderId}-${productId}`, value = reviewId
+      for (const review of reviews) {
+        const key = `${review.order.id}-${review.product.id}`;
+        reviewsMap.set(key, review.id);
+      }
+    }
+
+    // Map reviewIds to products
+    for (const order of data) {
+      for (const item of order.items.getItems()) {
+        if (item.product) {
+          const key = `${order.id}-${item.product.id}`;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const product = item.product as any;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          product.reviewId = reviewsMap.get(key) || null;
+        }
+      }
+    }
+
+    const totalPages = Math.ceil(total / limit);
+
+    return {
+      data,
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages,
+      },
+    };
+  }
+}