morteza-mortezai
2585 lines
70 KiB
TypeScript
2585 lines
70 KiB
TypeScript
import { Types } from "mongoose";
|
|
|
|
import { IOrder } from "./models/Abstraction/IOrder";
|
|
import { IOrderItem } from "./models/Abstraction/IOrderItem";
|
|
import { OrderModel } from "./models/order.model";
|
|
import { OrderItemModel } from "./models/orderItem.model";
|
|
import { BaseRepository } from "../../common/base/repository";
|
|
import { OrderItemsStatus, OrdersStatus } from "../../common/enums/order.enum";
|
|
import { OrderStatusQuery, SellerOrdersQueries } from "../../common/types/query.type";
|
|
import { TimeService } from "../../utils/time.service";
|
|
export type Gran = "daily" | "weekly" | "monthly";
|
|
|
|
class OrderRepository extends BaseRepository<IOrder> {
|
|
constructor() {
|
|
super(OrderModel);
|
|
}
|
|
|
|
async getUserOrderCount(userId: string) {
|
|
const pipeline = [
|
|
{
|
|
$match: {
|
|
user: new Types.ObjectId(userId),
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "orderitems",
|
|
localField: "_id",
|
|
foreignField: "order",
|
|
as: "orderItems",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$orderItems",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: {
|
|
orderId: "$_id",
|
|
orderStatus: "$orderStatus",
|
|
itemStatus: "$orderItems.status",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
processing: {
|
|
$sum: {
|
|
$cond: [
|
|
{
|
|
$or: [
|
|
{ $eq: ["$_id.orderStatus", OrdersStatus.process_by_seller] },
|
|
{ $eq: ["$_id.orderStatus", OrdersStatus.wait_payment] },
|
|
],
|
|
},
|
|
{
|
|
$cond: [
|
|
{
|
|
$or: [
|
|
{ $eq: ["$_id.itemStatus", OrderItemsStatus.Processing] },
|
|
{ $eq: ["$_id.itemStatus", OrderItemsStatus.Shipped] },
|
|
],
|
|
},
|
|
1,
|
|
0,
|
|
],
|
|
},
|
|
0,
|
|
],
|
|
},
|
|
},
|
|
delivered: {
|
|
$sum: {
|
|
$cond: [
|
|
{
|
|
$and: [
|
|
{ $eq: ["$_id.orderStatus", OrdersStatus.process_by_seller] },
|
|
{ $eq: ["$_id.itemStatus", OrderItemsStatus.Delivered] },
|
|
],
|
|
},
|
|
1,
|
|
0,
|
|
],
|
|
},
|
|
},
|
|
cancelled: {
|
|
$sum: {
|
|
$cond: [
|
|
{
|
|
$and: [
|
|
{ $eq: ["$_id.orderStatus", OrdersStatus.cancelled_system] },
|
|
{ $eq: ["$_id.itemStatus", OrderItemsStatus.cancelled_system] },
|
|
],
|
|
},
|
|
1,
|
|
0,
|
|
],
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
processing: 1,
|
|
delivered: 1,
|
|
cancelled: 1,
|
|
},
|
|
},
|
|
];
|
|
|
|
const result = await this.model.aggregate(pipeline);
|
|
return result[0] || { processing: 0, delivered: 0, cancelled: 0 };
|
|
}
|
|
|
|
async getUserOrders(userId: string, statusQuery: OrderStatusQuery) {
|
|
const matchQuery: { [k: string]: unknown } = {
|
|
user: new Types.ObjectId(userId),
|
|
$or: [],
|
|
};
|
|
const orderItemsMatchQuery: { [k: string]: unknown } = {};
|
|
|
|
switch (statusQuery) {
|
|
case "Cancelled":
|
|
matchQuery.$or = [{ orderStatus: OrdersStatus.cancelled_system }, { orderStatus: OrdersStatus.Cancelled }];
|
|
orderItemsMatchQuery.$or = [
|
|
{ "orderItems.status": OrderItemsStatus.cancelled_system },
|
|
{ "orderItems.status": OrderItemsStatus.cancelled_shop },
|
|
{ "orderItems.status": OrderItemsStatus.cancelled_user },
|
|
];
|
|
break;
|
|
case "Processing":
|
|
matchQuery.$or = [{ orderStatus: OrdersStatus.process_by_seller }, { orderStatus: OrdersStatus.wait_payment }];
|
|
orderItemsMatchQuery.$or = [
|
|
{ "orderItems.status": OrderItemsStatus.Processing },
|
|
{ "orderItems.status": OrderItemsStatus.Shipped },
|
|
];
|
|
break;
|
|
case "Delivered":
|
|
matchQuery.orderStatus = OrdersStatus.process_by_seller;
|
|
orderItemsMatchQuery["orderItems.status"] = OrderItemsStatus.Delivered;
|
|
break;
|
|
case "Returned":
|
|
matchQuery.orderStatus = OrdersStatus.process_by_seller;
|
|
orderItemsMatchQuery["orderItems.status"] = OrderItemsStatus.Returned;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return this.model.aggregate([
|
|
{
|
|
$match: matchQuery,
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "cartpayments",
|
|
localField: "payment",
|
|
foreignField: "_id",
|
|
as: "payment",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$payment",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "paymentmethods",
|
|
localField: "payment.payment_method",
|
|
foreignField: "_id",
|
|
as: "payment.payment_method",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$payment.payment_method",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "orderitems",
|
|
localField: "_id",
|
|
foreignField: "order",
|
|
as: "orderItems",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$orderItems",
|
|
},
|
|
{
|
|
$match: orderItemsMatchQuery,
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shipments",
|
|
localField: "orderItems.shipper",
|
|
foreignField: "_id",
|
|
as: "orderItems.shipper",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$orderItems.shipper",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shops",
|
|
localField: "orderItems.shop",
|
|
foreignField: "_id",
|
|
as: "orderItems.shop",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$orderItems.shop",
|
|
},
|
|
{
|
|
$unwind: "$orderItems.shipmentItems",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "products",
|
|
localField: "orderItems.shipmentItems.product",
|
|
foreignField: "_id",
|
|
as: "shipmentItemProduct",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItemProduct",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "productvariants",
|
|
localField: "orderItems.shipmentItems.variant",
|
|
foreignField: "_id",
|
|
as: "shipmentItemVariant",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItemVariant",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$orderItems._id",
|
|
shop: { $first: "$orderItems.shop" },
|
|
shipper: { $first: "$orderItems.shipper" },
|
|
totalSellingPrice: { $first: "$orderItems.totalSellingPrice" },
|
|
totalRetailPrice: { $first: "$orderItems.totalRetailPrice" },
|
|
totalShipmentCost: { $first: "$orderItems.totalShipmentCost" },
|
|
totalPaymentPrice: { $first: "$orderItems.totalPaymentPrice" },
|
|
itemsCount: { $first: "$orderItems.itemsCount" },
|
|
trackCode: { $first: "$orderItems.trackCode" },
|
|
postingDate: { $first: "$orderItems.postingDate" },
|
|
postingReceipt: { $first: "$orderItems.postingReceipt" },
|
|
status: { $first: "$orderItems.status" },
|
|
shipmentItems: {
|
|
$push: {
|
|
product: "$shipmentItemProduct",
|
|
variant: "$shipmentItemVariant",
|
|
quantity: "$orderItems.shipmentItems.quantity",
|
|
cancelled_quantity: "$orderItems.shipmentItems.cancelled_quantity",
|
|
returned_quantity: "$orderItems.shipmentItems.returned_quantity",
|
|
selling_price: "$orderItems.shipmentItems.selling_price",
|
|
retail_price: "$orderItems.shipmentItems.retail_price",
|
|
discount_percent: "$orderItems.shipmentItems.discount_percent",
|
|
shipmentCost: "$orderItems.shipmentItems.shipmentCost",
|
|
},
|
|
},
|
|
|
|
orderId: { $first: "$_id" },
|
|
payment: { $first: "$payment" },
|
|
shipmentAddress: { $first: "$shipmentAddress" },
|
|
orderStatus: { $first: "$orderStatus" },
|
|
createdAt: { $first: "$createdAt" },
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$orderId",
|
|
payment: { $first: "$payment" },
|
|
shipmentAddress: { $first: "$shipmentAddress" },
|
|
orderStatus: { $first: "$orderStatus" },
|
|
createdAt: { $first: "$createdAt" },
|
|
orderItems: {
|
|
$push: {
|
|
_id: "$_id", // orderItem `_id`
|
|
shop: "$shop",
|
|
shipper: "$shipper",
|
|
totalSellingPrice: "$totalSellingPrice",
|
|
totalRetailPrice: "$totalRetailPrice",
|
|
totalShipmentCost: "$totalShipmentCost",
|
|
totalPaymentPrice: "$totalPaymentPrice",
|
|
itemsCount: "$itemsCount",
|
|
trackCode: "$trackCode",
|
|
postingDate: "$postingDate",
|
|
postingReceipt: "$postingReceipt",
|
|
status: "$status",
|
|
shipmentItems: "$shipmentItems",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$sort: {
|
|
createdAt: -1,
|
|
},
|
|
},
|
|
]);
|
|
}
|
|
|
|
async getUserOrderDetail(orderId: number, userId: string) {
|
|
return this.model.aggregate([
|
|
{
|
|
$match: {
|
|
_id: orderId,
|
|
user: new Types.ObjectId(userId),
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "cartpayments",
|
|
localField: "payment",
|
|
foreignField: "_id",
|
|
as: "payment",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$payment",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "paymentmethods",
|
|
localField: "payment.payment_method",
|
|
foreignField: "_id",
|
|
as: "payment.payment_method",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$payment.payment_method",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
localField: "user",
|
|
foreignField: "_id",
|
|
as: "user",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$user",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "orderitems",
|
|
localField: "_id",
|
|
foreignField: "order",
|
|
as: "orderItems",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$orderItems",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shipments",
|
|
localField: "orderItems.shipper",
|
|
foreignField: "_id",
|
|
as: "orderItems.shipper",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$orderItems.shipper",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shops",
|
|
localField: "orderItems.shop",
|
|
foreignField: "_id",
|
|
as: "orderItems.shop",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$orderItems.shop",
|
|
},
|
|
{
|
|
$unwind: "$orderItems.shipmentItems",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "products",
|
|
localField: "orderItems.shipmentItems.product",
|
|
foreignField: "_id",
|
|
as: "orderItems.shipmentItems.product",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$orderItems.shipmentItems.product",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "productvariants",
|
|
localField: "orderItems.shipmentItems.variant",
|
|
foreignField: "_id",
|
|
as: "orderItems.shipmentItems.variant",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$orderItems.shipmentItems.variant",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "warranties",
|
|
localField: "orderItems.shipmentItems.variant.warranty",
|
|
foreignField: "_id",
|
|
as: "orderItems.shipmentItems.variant.warranty",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$orderItems.shipmentItems.variant.warranty",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "colors",
|
|
localField: "orderItems.shipmentItems.variant.color",
|
|
foreignField: "_id",
|
|
as: "orderItems.shipmentItems.variant.color",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$orderItems.shipmentItems.variant.color",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "sizes",
|
|
localField: "orderItems.shipmentItems.variant.size",
|
|
foreignField: "_id",
|
|
as: "orderItems.shipmentItems.variant.size",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$orderItems.shipmentItems.variant.size",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "meterages",
|
|
localField: "orderItems.shipmentItems.variant.meterage",
|
|
foreignField: "_id",
|
|
as: "orderItems.shipmentItems.variant.meterage",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$orderItems.shipmentItems.variant.meterage",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$orderItems._id",
|
|
shop: { $first: "$orderItems.shop" },
|
|
shipper: { $first: "$orderItems.shipper" },
|
|
status: { $first: "$orderItems.status" },
|
|
totalSellingPrice: { $first: "$orderItems.totalSellingPrice" },
|
|
totalRetailPrice: { $first: "$orderItems.totalRetailPrice" },
|
|
totalShipmentCost: { $first: "$orderItems.totalShipmentCost" },
|
|
totalPaymentPrice: { $first: "$orderItems.totalPaymentPrice" },
|
|
itemsCount: { $first: "$orderItems.itemsCount" },
|
|
trackCode: { $first: "$orderItems.trackCode" },
|
|
postingDate: { $first: "$orderItems.postingDate" },
|
|
postingReceipt: { $first: "$orderItems.postingReceipt" },
|
|
shipmentItems: { $push: "$orderItems.shipmentItems" },
|
|
orderId: { $first: "$_id" },
|
|
user: { $first: "$user" },
|
|
payment: { $first: "$payment" },
|
|
shipmentAddress: { $first: "$shipmentAddress" },
|
|
orderStatus: { $first: "$orderStatus" },
|
|
createdAt: { $first: "$createdAt" },
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$orderId",
|
|
user: { $first: "$user" },
|
|
payment: { $first: "$payment" },
|
|
shipmentAddress: { $first: "$shipmentAddress" },
|
|
orderStatus: { $first: "$orderStatus" },
|
|
createdAt: { $first: "$createdAt" },
|
|
orderItems: {
|
|
$push: {
|
|
_id: "$_id",
|
|
order_id: "$orderId",
|
|
shop: "$shop",
|
|
shipper: "$shipper",
|
|
totalSellingPrice: "$totalSellingPrice",
|
|
totalRetailPrice: "$totalRetailPrice",
|
|
totalShipmentCost: "$totalShipmentCost",
|
|
totalPaymentPrice: "$totalPaymentPrice",
|
|
itemsCount: "$itemsCount",
|
|
trackCode: "$trackCode",
|
|
postingDate: "$postingDate",
|
|
postingReceipt: "$postingReceipt",
|
|
status: "$status",
|
|
shipmentItems: "$shipmentItems",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
]);
|
|
}
|
|
}
|
|
|
|
class OrderItemRepo extends BaseRepository<IOrderItem> {
|
|
constructor() {
|
|
super(OrderItemModel);
|
|
}
|
|
|
|
async getOrderTrackingDetails(orderId: number) {
|
|
return this.model.find({ order: orderId, trackCode: { $exists: true } }).populate([{ path: "shipper" }]);
|
|
}
|
|
|
|
async getUserOrderItemsDetail(orderId: number, orderItemId: string) {
|
|
return this.model.aggregate([
|
|
{
|
|
$match: {
|
|
_id: new Types.ObjectId(orderItemId),
|
|
order: orderId,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
localField: "order.user",
|
|
foreignField: "_id",
|
|
as: "order.user",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.user",
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "products",
|
|
localField: "shipmentItems.product",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.product",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.product",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "productvariants",
|
|
localField: "shipmentItems.variant",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.variant",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "warranties",
|
|
localField: "shipmentItems.variant.warranty",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.warranty",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.warranty",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "colors",
|
|
localField: "shipmentItems.variant.color",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.color",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.color",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "sizes",
|
|
localField: "shipmentItems.variant.size",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.size",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.size",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "meterages",
|
|
localField: "shipmentItems.variant.meterage",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.meterage",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.meterage",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shipments",
|
|
localField: "shipper",
|
|
foreignField: "_id",
|
|
as: "shipper",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipper",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$order._id",
|
|
user: { $first: "$order.user" },
|
|
// payment: { $first: "$order.payment" },
|
|
shipmentAddress: { $first: "$order.shipmentAddress" },
|
|
orderStatus: { $first: "$order.orderStatus" },
|
|
createdAt: { $first: "$order.createdAt" },
|
|
orderItems: {
|
|
$first: {
|
|
_id: "$_id",
|
|
order_id: "$order._id",
|
|
shop: "$shop",
|
|
shipper: "$shipper",
|
|
totalSellingPrice: "$totalSellingPrice",
|
|
totalRetailPrice: "$totalRetailPrice",
|
|
totalShipmentCost: "$totalShipmentCost",
|
|
totalPaymentPrice: "$totalPaymentPrice",
|
|
itemsCount: "$itemsCount",
|
|
trackCode: "$trackCode",
|
|
postingDate: "$postingDate",
|
|
postingReceipt: "$postingReceipt",
|
|
status: "$status",
|
|
},
|
|
},
|
|
shipmentItems: {
|
|
$push: {
|
|
_id: "$shipmentItems._id",
|
|
product: "$shipmentItems.product",
|
|
variant: "$shipmentItems.variant",
|
|
quantity: "$shipmentItems.quantity",
|
|
cancelled_quantity: "$shipmentItems.cancelled_quantity",
|
|
returned_quantity: "$shipmentItems.returned_quantity",
|
|
selling_price: "$shipmentItems.selling_price",
|
|
retail_price: "$shipmentItems.retail_price",
|
|
discount_percent: "$shipmentItems.discount_percent",
|
|
shipmentCost: "$shipmentItems.shipmentCost",
|
|
},
|
|
},
|
|
// totalSellingPrice: { $sum: { $multiply: ["$shipmentItems.selling_price", "$shipmentItems.quantity"] } },
|
|
// totalRetailPrice: { $sum: { $multiply: ["$shipmentItems.retail_price", "$shipmentItems.quantity"] } },
|
|
// totalShipmentCost: { $sum: "$shipmentItems.shipmentCost" },
|
|
// itemsCount: { $sum: "$shipmentItems.quantity" },
|
|
},
|
|
},
|
|
{
|
|
$addFields: {
|
|
"orderItems.shipmentItems": "$shipmentItems",
|
|
// totalPaymentPrice: { $add: ["$totalSellingPrice", "$totalShipmentCost"] },
|
|
},
|
|
},
|
|
]);
|
|
}
|
|
|
|
async getOrdersForSellerPanel(shopId: string, queries: SellerOrdersQueries, orderIds?: string[] | string) {
|
|
const page = queries.page || 1;
|
|
const limit = queries.limit || 10;
|
|
const skip = (page - 1) * limit;
|
|
|
|
const priceQuery: { [k: string]: { [op: string]: number } } = {};
|
|
const orderMatchQuery: any = {};
|
|
|
|
if (queries.minPrice) {
|
|
priceQuery.totalPaymentPrice = { $gte: queries.minPrice };
|
|
}
|
|
|
|
if (queries.maxPrice) {
|
|
if (priceQuery.totalPaymentPrice) {
|
|
priceQuery.totalPaymentPrice.$lte = queries.maxPrice;
|
|
} else {
|
|
priceQuery.totalPaymentPrice = { $lte: queries.maxPrice };
|
|
}
|
|
}
|
|
|
|
if (typeof orderIds === "string") {
|
|
orderMatchQuery.order = +orderIds;
|
|
} else if (orderIds && orderIds.length > 0) {
|
|
orderMatchQuery.order = { $in: orderIds.map((id) => +id) };
|
|
}
|
|
|
|
const docs = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
shop: new Types.ObjectId(shopId),
|
|
...orderMatchQuery,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "cartpayments",
|
|
localField: "order.payment",
|
|
foreignField: "_id",
|
|
as: "order.payment",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.payment",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "paymentmethods",
|
|
localField: "order.payment.payment_method",
|
|
foreignField: "_id",
|
|
as: "order.payment.payment_method",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.payment.payment_method",
|
|
},
|
|
{
|
|
$match: {
|
|
...(queries.status && {
|
|
"order.payment.paymentStatus": queries.status,
|
|
}),
|
|
...(queries.shipperId && {
|
|
shipper: +queries.shipperId,
|
|
}),
|
|
...(queries.since && {
|
|
"order.createdAt": { $gte: new Date(queries.since) },
|
|
}),
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
localField: "order.user",
|
|
foreignField: "_id",
|
|
as: "order.user",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.user",
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "products",
|
|
localField: "shipmentItems.product",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.product",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.product",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "productvariants",
|
|
localField: "shipmentItems.variant",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.variant",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shipments",
|
|
localField: "shipper",
|
|
foreignField: "_id",
|
|
as: "shipper",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipper",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$order._id",
|
|
user: { $first: "$order.user" },
|
|
payment: { $first: "$order.payment" },
|
|
shipmentAddress: { $first: "$order.shipmentAddress" },
|
|
orderStatus: { $first: "$order.orderStatus" },
|
|
createdAt: { $first: "$order.createdAt" },
|
|
orderItems: {
|
|
$first: {
|
|
_id: "$_id",
|
|
order_id: "$order._id",
|
|
shop: "$shop",
|
|
shipper: "$shipper",
|
|
totalSellingPrice: "$totalSellingPrice",
|
|
totalRetailPrice: "$totalRetailPrice",
|
|
totalShipmentCost: "$totalShipmentCost",
|
|
totalPaymentPrice: "$totalPaymentPrice",
|
|
itemsCount: "$itemsCount",
|
|
trackCode: "$trackCode",
|
|
postingDate: "$postingDate",
|
|
postingReceipt: "$postingReceipt",
|
|
status: "$status",
|
|
},
|
|
},
|
|
shipmentItems: {
|
|
$push: {
|
|
_id: "$shipmentItems._id",
|
|
product: "$shipmentItems.product",
|
|
variant: "$shipmentItems.variant",
|
|
quantity: "$shipmentItems.quantity",
|
|
cancelled_quantity: "$shipmentItems.cancelled_quantity",
|
|
returned_quantity: "$shipmentItems.returned_quantity",
|
|
selling_price: "$shipmentItems.selling_price",
|
|
retail_price: "$shipmentItems.retail_price",
|
|
discount_percent: "$shipmentItems.discount_percent",
|
|
shipmentCost: "$shipmentItems.shipmentCost",
|
|
},
|
|
},
|
|
// totalSellingPrice: { $sum: { $multiply: ["$shipmentItems.selling_price", "$shipmentItems.quantity"] } },
|
|
// totalRetailPrice: { $sum: { $multiply: ["$shipmentItems.retail_price", "$shipmentItems.quantity"] } },
|
|
// totalShipmentCost: { $sum: "$shipmentItems.shipmentCost" },
|
|
// itemsCount: { $sum: "$shipmentItems.quantity" },
|
|
},
|
|
},
|
|
|
|
{
|
|
$addFields: {
|
|
"orderItems.shipmentItems": "$shipmentItems",
|
|
// totalPaymentPrice: { $add: ["$totalSellingPrice", "$totalShipmentCost"] },
|
|
},
|
|
},
|
|
{
|
|
$match: priceQuery,
|
|
},
|
|
{
|
|
$sort: {
|
|
"order.createdAt": -1,
|
|
},
|
|
},
|
|
{
|
|
$facet: {
|
|
data: [{ $skip: skip }, { $limit: limit }],
|
|
totalCount: [{ $count: "count" }],
|
|
},
|
|
},
|
|
{
|
|
$addFields: {
|
|
totalCount: { $arrayElemAt: ["$totalCount.count", 0] },
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
shipmentItems: 0,
|
|
},
|
|
},
|
|
]);
|
|
|
|
return {
|
|
count: (docs[0]?.totalCount as number) || 0,
|
|
docs: docs[0]?.data || [],
|
|
};
|
|
}
|
|
|
|
async getOrdersForAdminPanel(queries: SellerOrdersQueries) {
|
|
const page = queries.page || 1;
|
|
const limit = queries.limit || 10;
|
|
const skip = (page - 1) * limit;
|
|
|
|
const priceQuery: { [k: string]: { [op: string]: number } } = {};
|
|
|
|
if (queries.minPrice) {
|
|
priceQuery.totalPaymentPrice = { $gte: queries.minPrice };
|
|
}
|
|
|
|
if (queries.maxPrice) {
|
|
if (priceQuery.totalPaymentPrice) {
|
|
priceQuery.totalPaymentPrice.$lte = queries.maxPrice;
|
|
} else {
|
|
priceQuery.totalPaymentPrice = { $lte: queries.maxPrice };
|
|
}
|
|
}
|
|
|
|
const docs = await this.model.aggregate([
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "cartpayments",
|
|
localField: "order.payment",
|
|
foreignField: "_id",
|
|
as: "order.payment",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.payment",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "paymentmethods",
|
|
localField: "order.payment.payment_method",
|
|
foreignField: "_id",
|
|
as: "order.payment.payment_method",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.payment.payment_method",
|
|
},
|
|
{
|
|
$match: {
|
|
...(queries.status && {
|
|
"order.payment.paymentStatus": queries.status,
|
|
}),
|
|
...(queries.shipperId && {
|
|
shipper: +queries.shipperId,
|
|
}),
|
|
...(queries.since && {
|
|
"order.createdAt": { $gte: new Date(queries.since) },
|
|
}),
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
localField: "order.user",
|
|
foreignField: "_id",
|
|
as: "order.user",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.user",
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "products",
|
|
localField: "shipmentItems.product",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.product",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.product",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "productvariants",
|
|
localField: "shipmentItems.variant",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.variant",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shipments",
|
|
localField: "shipper",
|
|
foreignField: "_id",
|
|
as: "shipper",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipper",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$order._id",
|
|
user: { $first: "$order.user" },
|
|
payment: { $first: "$order.payment" },
|
|
shipmentAddress: { $first: "$order.shipmentAddress" },
|
|
orderStatus: { $first: "$order.orderStatus" },
|
|
createdAt: { $first: "$order.createdAt" },
|
|
orderItems: {
|
|
$first: {
|
|
_id: "$_id",
|
|
order_id: "$order._id",
|
|
shop: "$shop",
|
|
shipper: "$shipper",
|
|
totalSellingPrice: "$totalSellingPrice",
|
|
totalRetailPrice: "$totalRetailPrice",
|
|
totalShipmentCost: "$totalShipmentCost",
|
|
totalPaymentPrice: "$totalPaymentPrice",
|
|
itemsCount: "$itemsCount",
|
|
trackCode: "$trackCode",
|
|
postingDate: "$postingDate",
|
|
postingReceipt: "$postingReceipt",
|
|
status: "$status",
|
|
},
|
|
},
|
|
shipmentItems: {
|
|
$push: {
|
|
product: "$shipmentItems.product",
|
|
variant: "$shipmentItems.variant",
|
|
quantity: "$shipmentItems.quantity",
|
|
cancelled_quantity: "$shipmentItems.cancelled_quantity",
|
|
returned_quantity: "$shipmentItems.returned_quantity",
|
|
selling_price: "$shipmentItems.selling_price",
|
|
retail_price: "$shipmentItems.retail_price",
|
|
discount_percent: "$shipmentItems.discount_percent",
|
|
shipmentCost: "$shipmentItems.shipmentCost",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
|
|
{
|
|
$addFields: {
|
|
"orderItems.shipmentItems": "$shipmentItems",
|
|
// totalPaymentPrice: { $add: ["$totalSellingPrice", "$totalShipmentCost"] },
|
|
},
|
|
},
|
|
{
|
|
$match: priceQuery,
|
|
},
|
|
{
|
|
$sort: {
|
|
"order.createdAt": -1,
|
|
},
|
|
},
|
|
{
|
|
$facet: {
|
|
data: [{ $skip: skip }, { $limit: limit }],
|
|
totalCount: [{ $count: "count" }],
|
|
},
|
|
},
|
|
{
|
|
$addFields: {
|
|
totalCount: { $arrayElemAt: ["$totalCount.count", 0] },
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
shipmentItems: 0,
|
|
},
|
|
},
|
|
]);
|
|
|
|
return {
|
|
count: (docs[0]?.totalCount as number) || 0,
|
|
docs: docs[0]?.data || [],
|
|
};
|
|
}
|
|
|
|
async getSellerOrdersForAdminPanel(shopIds: Types.ObjectId[], queries: SellerOrdersQueries) {
|
|
const page = queries.page || 1;
|
|
const limit = queries.limit || 10;
|
|
const skip = (page - 1) * limit;
|
|
|
|
const priceQuery: { [k: string]: { [op: string]: number } } = {};
|
|
|
|
if (queries.minPrice) {
|
|
priceQuery.totalPaymentPrice = { $gte: queries.minPrice };
|
|
}
|
|
|
|
if (queries.maxPrice) {
|
|
if (priceQuery.totalPaymentPrice) {
|
|
priceQuery.totalPaymentPrice.$lte = queries.maxPrice;
|
|
} else {
|
|
priceQuery.totalPaymentPrice = { $lte: queries.maxPrice };
|
|
}
|
|
}
|
|
|
|
const docs = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
shop: { $in: shopIds },
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shops",
|
|
foreignField: "_id",
|
|
localField: "shop",
|
|
as: "shop",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shop",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "cartpayments",
|
|
localField: "order.payment",
|
|
foreignField: "_id",
|
|
as: "order.payment",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.payment",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "paymentmethods",
|
|
localField: "order.payment.payment_method",
|
|
foreignField: "_id",
|
|
as: "order.payment.payment_method",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.payment.payment_method",
|
|
},
|
|
{
|
|
$match: {
|
|
...(queries.status && {
|
|
"order.payment.paymentStatus": queries.status,
|
|
}),
|
|
...(queries.shipperId && {
|
|
shipper: +queries.shipperId,
|
|
}),
|
|
...(queries.since && {
|
|
"order.createdAt": { $gte: new Date(queries.since) },
|
|
}),
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
localField: "order.user",
|
|
foreignField: "_id",
|
|
as: "order.user",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.user",
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "products",
|
|
localField: "shipmentItems.product",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.product",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.product",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "productvariants",
|
|
localField: "shipmentItems.variant",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.variant",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shipments",
|
|
localField: "shipper",
|
|
foreignField: "_id",
|
|
as: "shipper",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipper",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$order._id",
|
|
user: { $first: "$order.user" },
|
|
payment: { $first: "$order.payment" },
|
|
shipmentAddress: { $first: "$order.shipmentAddress" },
|
|
orderStatus: { $first: "$order.orderStatus" },
|
|
createdAt: { $first: "$order.createdAt" },
|
|
orderItems: {
|
|
$first: {
|
|
_id: "$_id",
|
|
order_id: "$order._id",
|
|
shop: "$shop",
|
|
shipper: "$shipper",
|
|
totalSellingPrice: "$totalSellingPrice",
|
|
totalRetailPrice: "$totalRetailPrice",
|
|
totalShipmentCost: "$totalShipmentCost",
|
|
totalPaymentPrice: "$totalPaymentPrice",
|
|
itemsCount: "$itemsCount",
|
|
trackCode: "$trackCode",
|
|
postingDate: "$postingDate",
|
|
postingReceipt: "$postingReceipt",
|
|
status: "$status",
|
|
},
|
|
},
|
|
shipmentItems: {
|
|
$push: {
|
|
product: "$shipmentItems.product",
|
|
variant: "$shipmentItems.variant",
|
|
quantity: "$shipmentItems.quantity",
|
|
cancelled_quantity: "$shipmentItems.cancelled_quantity",
|
|
returned_quantity: "$shipmentItems.returned_quantity",
|
|
selling_price: "$shipmentItems.selling_price",
|
|
retail_price: "$shipmentItems.retail_price",
|
|
discount_percent: "$shipmentItems.discount_percent",
|
|
shipmentCost: "$shipmentItems.shipmentCost",
|
|
},
|
|
},
|
|
// totalSellingPrice: { $sum: { $multiply: ["$shipmentItems.selling_price", "$shipmentItems.quantity"] } },
|
|
// totalRetailPrice: { $sum: { $multiply: ["$shipmentItems.retail_price", "$shipmentItems.quantity"] } },
|
|
// totalShipmentCost: { $sum: "$shipmentItems.shipmentCost" },
|
|
// itemsCount: { $sum: "$shipmentItems.quantity" },
|
|
},
|
|
},
|
|
|
|
{
|
|
$addFields: {
|
|
"orderItems.shipmentItems": "$shipmentItems",
|
|
// totalPaymentPrice: { $add: ["$totalSellingPrice", "$totalShipmentCost"] },
|
|
},
|
|
},
|
|
{
|
|
$match: priceQuery,
|
|
},
|
|
{
|
|
$sort: {
|
|
"order.createdAt": -1,
|
|
},
|
|
},
|
|
{
|
|
$facet: {
|
|
data: [{ $skip: skip }, { $limit: limit }],
|
|
totalCount: [{ $count: "count" }],
|
|
},
|
|
},
|
|
{
|
|
$addFields: {
|
|
totalCount: { $arrayElemAt: ["$totalCount.count", 0] },
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
shipmentItems: 0,
|
|
},
|
|
},
|
|
]);
|
|
|
|
return {
|
|
count: (docs[0]?.totalCount as number) || 0,
|
|
docs: docs[0]?.data || [],
|
|
};
|
|
}
|
|
|
|
async getOrderPriceRangeForAdminPanel() {
|
|
const docs = await this.model.aggregate([
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order",
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$order._id",
|
|
totalSellingPrice: { $sum: { $multiply: ["$shipmentItems.selling_price", "$shipmentItems.quantity"] } },
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
minPrice: { $min: "$totalSellingPrice" },
|
|
maxPrice: { $max: "$totalSellingPrice" },
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
minPrice: 1,
|
|
maxPrice: 1,
|
|
},
|
|
},
|
|
]);
|
|
return docs[0];
|
|
}
|
|
|
|
async getOrderPriceRange(shopId: string) {
|
|
const docs = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
shop: new Types.ObjectId(shopId),
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order",
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$order._id",
|
|
totalSellingPrice: { $sum: { $multiply: ["$shipmentItems.selling_price", "$shipmentItems.quantity"] } },
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
minPrice: { $min: "$totalSellingPrice" },
|
|
maxPrice: { $max: "$totalSellingPrice" },
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
minPrice: 1,
|
|
maxPrice: 1,
|
|
},
|
|
},
|
|
]);
|
|
return docs[0];
|
|
}
|
|
async getSellerOrderPriceRange(shopIds: Types.ObjectId[]) {
|
|
const docs = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
shop: { $in: shopIds },
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shops",
|
|
foreignField: "_id",
|
|
localField: "shop",
|
|
as: "shop",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shop",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order",
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$order._id",
|
|
totalSellingPrice: { $sum: { $multiply: ["$shipmentItems.selling_price", "$shipmentItems.quantity"] } },
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
minPrice: { $min: "$totalSellingPrice" },
|
|
maxPrice: { $max: "$totalSellingPrice" },
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
minPrice: 1,
|
|
maxPrice: 1,
|
|
},
|
|
},
|
|
]);
|
|
return docs[0];
|
|
}
|
|
|
|
async getSellerOrderDetail(orderId: number, shopId: string) {
|
|
return this.model.aggregate([
|
|
{
|
|
$match: {
|
|
order: orderId,
|
|
shop: new Types.ObjectId(shopId),
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "cartpayments",
|
|
localField: "order.payment",
|
|
foreignField: "_id",
|
|
as: "order.payment",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.payment",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "paymentmethods",
|
|
localField: "order.payment.payment_method",
|
|
foreignField: "_id",
|
|
as: "order.payment.payment_method",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.payment.payment_method",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
localField: "order.user",
|
|
foreignField: "_id",
|
|
as: "order.user",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.user",
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "products",
|
|
localField: "shipmentItems.product",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.product",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.product",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "productvariants",
|
|
localField: "shipmentItems.variant",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.variant",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "warranties",
|
|
localField: "shipmentItems.variant.warranty",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.warranty",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.warranty",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "colors",
|
|
localField: "shipmentItems.variant.color",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.color",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.color",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "sizes",
|
|
localField: "shipmentItems.variant.size",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.size",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.size",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "meterages",
|
|
localField: "shipmentItems.variant.meterage",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.meterage",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.meterage",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shipments",
|
|
localField: "shipper",
|
|
foreignField: "_id",
|
|
as: "shipper",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipper",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$order._id",
|
|
user: { $first: "$order.user" },
|
|
payment: { $first: "$order.payment" },
|
|
shipmentAddress: { $first: "$order.shipmentAddress" },
|
|
orderStatus: { $first: "$order.orderStatus" },
|
|
createdAt: { $first: "$order.createdAt" },
|
|
orderItems: {
|
|
$first: {
|
|
_id: "$_id",
|
|
order_id: "$order._id",
|
|
shop: "$shop",
|
|
shipper: "$shipper",
|
|
totalSellingPrice: "$totalSellingPrice",
|
|
totalRetailPrice: "$totalRetailPrice",
|
|
totalShipmentCost: "$totalShipmentCost",
|
|
totalPaymentPrice: "$totalPaymentPrice",
|
|
itemsCount: "$itemsCount",
|
|
trackCode: "$trackCode",
|
|
postingDate: "$postingDate",
|
|
postingReceipt: "$postingReceipt",
|
|
status: "$status",
|
|
},
|
|
},
|
|
shipmentItems: {
|
|
$push: {
|
|
_id: "$shipmentItems._id",
|
|
product: "$shipmentItems.product",
|
|
variant: "$shipmentItems.variant",
|
|
quantity: "$shipmentItems.quantity",
|
|
cancelled_quantity: "$shipmentItems.cancelled_quantity",
|
|
returned_quantity: "$shipmentItems.returned_quantity",
|
|
selling_price: "$shipmentItems.selling_price",
|
|
retail_price: "$shipmentItems.retail_price",
|
|
discount_percent: "$shipmentItems.discount_percent",
|
|
shipmentCost: "$shipmentItems.shipmentCost",
|
|
},
|
|
},
|
|
// totalSellingPrice: { $sum: { $multiply: ["$shipmentItems.selling_price", "$shipmentItems.quantity"] } },
|
|
// totalRetailPrice: { $sum: { $multiply: ["$shipmentItems.retail_price", "$shipmentItems.quantity"] } },
|
|
// totalShipmentCost: { $sum: "$shipmentItems.shipmentCost" },
|
|
// itemsCount: { $sum: "$shipmentItems.quantity" },
|
|
},
|
|
},
|
|
{
|
|
$addFields: {
|
|
"orderItems.shipmentItems": "$shipmentItems",
|
|
// totalPaymentPrice: { $add: ["$totalSellingPrice", "$totalShipmentCost"] },
|
|
},
|
|
},
|
|
]);
|
|
}
|
|
|
|
async getSellerOrderDetailForAdminPanel(orderId: number, shopIds: Types.ObjectId[]) {
|
|
return this.model.aggregate([
|
|
{
|
|
$match: {
|
|
order: orderId,
|
|
shop: { $in: shopIds },
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shops",
|
|
localField: "shop",
|
|
foreignField: "_id",
|
|
as: "shop",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shop",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "cartpayments",
|
|
localField: "order.payment",
|
|
foreignField: "_id",
|
|
as: "order.payment",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.payment",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "paymentmethods",
|
|
localField: "order.payment.payment_method",
|
|
foreignField: "_id",
|
|
as: "order.payment.payment_method",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.payment.payment_method",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "users",
|
|
localField: "order.user",
|
|
foreignField: "_id",
|
|
as: "order.user",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$order.user",
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "products",
|
|
localField: "shipmentItems.product",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.product",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.product",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "productvariants",
|
|
localField: "shipmentItems.variant",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipmentItems.variant",
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "warranties",
|
|
localField: "shipmentItems.variant.warranty",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.warranty",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.warranty",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "colors",
|
|
localField: "shipmentItems.variant.color",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.color",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.color",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "sizes",
|
|
localField: "shipmentItems.variant.size",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.size",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.size",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "meterages",
|
|
localField: "shipmentItems.variant.meterage",
|
|
foreignField: "_id",
|
|
as: "shipmentItems.variant.meterage",
|
|
},
|
|
},
|
|
{
|
|
$unwind: {
|
|
path: "$shipmentItems.variant.meterage",
|
|
preserveNullAndEmptyArrays: true,
|
|
},
|
|
},
|
|
{
|
|
$lookup: {
|
|
from: "shipments",
|
|
localField: "shipper",
|
|
foreignField: "_id",
|
|
as: "shipper",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$shipper",
|
|
},
|
|
{
|
|
$group: {
|
|
_id: "$order._id",
|
|
user: { $first: "$order.user" },
|
|
payment: { $first: "$order.payment" },
|
|
shipmentAddress: { $first: "$order.shipmentAddress" },
|
|
orderStatus: { $first: "$order.orderStatus" },
|
|
createdAt: { $first: "$order.createdAt" },
|
|
orderItems: {
|
|
$first: {
|
|
_id: "$_id",
|
|
order_id: "$order._id",
|
|
shop: "$shop",
|
|
shipper: "$shipper",
|
|
totalSellingPrice: "$totalSellingPrice",
|
|
totalRetailPrice: "$totalRetailPrice",
|
|
totalShipmentCost: "$totalShipmentCost",
|
|
totalPaymentPrice: "$totalPaymentPrice",
|
|
itemsCount: "$itemsCount",
|
|
trackCode: "$trackCode",
|
|
postingDate: "$postingDate",
|
|
postingReceipt: "$postingReceipt",
|
|
status: "$status",
|
|
},
|
|
},
|
|
shipmentItems: {
|
|
$push: {
|
|
_id: "$shipmentItems._id",
|
|
product: "$shipmentItems.product",
|
|
variant: "$shipmentItems.variant",
|
|
quantity: "$shipmentItems.quantity",
|
|
cancelled_quantity: "$shipmentItems.cancelled_quantity",
|
|
returned_quantity: "$shipmentItems.returned_quantity",
|
|
selling_price: "$shipmentItems.selling_price",
|
|
retail_price: "$shipmentItems.retail_price",
|
|
discount_percent: "$shipmentItems.discount_percent",
|
|
shipmentCost: "$shipmentItems.shipmentCost",
|
|
},
|
|
},
|
|
// totalSellingPrice: { $sum: { $multiply: ["$shipmentItems.selling_price", "$shipmentItems.quantity"] } },
|
|
// totalRetailPrice: { $sum: { $multiply: ["$shipmentItems.retail_price", "$shipmentItems.quantity"] } },
|
|
// totalShipmentCost: { $sum: "$shipmentItems.shipmentCost" },
|
|
// itemsCount: { $sum: "$shipmentItems.quantity" },
|
|
},
|
|
},
|
|
{
|
|
$addFields: {
|
|
"orderItems.shipmentItems": "$shipmentItems",
|
|
// totalPaymentPrice: { $add: ["$totalSellingPrice", "$totalShipmentCost"] },
|
|
},
|
|
},
|
|
]);
|
|
}
|
|
|
|
async getSellerSalesStats(shopId: string, queries: { start?: string; end?: string }) {
|
|
// Parse the date range from queries, converting from Persian to Gregorian if necessary
|
|
const startDate = queries.start ? new Date(TimeService.convertPersianToGregorian(queries.start)) : null;
|
|
const endDate = queries.end ? new Date(TimeService.convertPersianToGregorian(queries.end)) : new Date();
|
|
|
|
// Build the match query to filter data within the date range and for the specific shop
|
|
const matchQuery: any = {
|
|
shop: new Types.ObjectId(shopId),
|
|
createdAt: {
|
|
...(startDate ? { $gte: startDate } : {}),
|
|
$lte: endDate,
|
|
},
|
|
};
|
|
|
|
const salesData = await this.model.aggregate([
|
|
{ $match: matchQuery },
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{ $unwind: "$order" },
|
|
{
|
|
$group: {
|
|
_id: {
|
|
year: { $year: "$createdAt" },
|
|
month: { $month: "$createdAt" },
|
|
},
|
|
totalSales: { $sum: "$totalSellingPrice" },
|
|
totalNetSales: { $sum: "$totalRetailPrice" },
|
|
itemsSold: { $sum: "$itemsCount" },
|
|
totalOrders: { $sum: 1 },
|
|
},
|
|
},
|
|
{ $sort: { "_id.year": 1, "_id.month": 1 } },
|
|
]);
|
|
|
|
// Format the aggregated sales data
|
|
const formattedSalesData = salesData.map((item) => {
|
|
const monthString = `${item._id.year}-${String(item._id.month).padStart(2, "0")}`;
|
|
return {
|
|
month: TimeService.PersianMonthName(monthString),
|
|
totalSales: item.totalSales,
|
|
totalNetSales: item.totalNetSales,
|
|
itemsSold: item.itemsSold,
|
|
averageSales: item.totalSales / (item.totalOrders || 1),
|
|
totalOrders: item.totalOrders,
|
|
};
|
|
});
|
|
|
|
// Calculate overall stats
|
|
const totalSales = formattedSalesData.reduce((acc, curr) => acc + curr.totalSales, 0);
|
|
const totalNetSales = formattedSalesData.reduce((acc, curr) => acc + curr.totalNetSales, 0);
|
|
const totalOrders = formattedSalesData.reduce((acc, curr) => acc + curr.totalOrders, 0);
|
|
const itemsSold = formattedSalesData.reduce((acc, curr) => acc + curr.itemsSold, 0);
|
|
|
|
return {
|
|
averageDailySales: totalSales / (formattedSalesData.length * 30 || 1),
|
|
totalSales,
|
|
totalNetSales,
|
|
totalOrders,
|
|
itemsSold,
|
|
startDate: startDate ? TimeService.convertGregorianToPersian(startDate) : null,
|
|
endDate: TimeService.convertGregorianToPersian(endDate),
|
|
totalMonths: formattedSalesData.length,
|
|
statsByMonth: formattedSalesData,
|
|
};
|
|
}
|
|
|
|
async getAllProcessingOrders() {
|
|
return await this.model.find({ status: "Processing" }).countDocuments();
|
|
}
|
|
|
|
async getDailyShipmentSalesReport() {
|
|
const today = new Date();
|
|
today.setHours(0, 0, 0, 0);
|
|
const startOfDay = new Date(today.getFullYear(), today.getMonth(), today.getDate());
|
|
const endOfDay = new Date(today.getFullYear(), today.getMonth(), today.getDate(), 23, 59, 59, 999);
|
|
const salesData = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
createdAt: {
|
|
$gte: startOfDay,
|
|
$lte: endOfDay,
|
|
},
|
|
status: {
|
|
$nin: ["cancelled_shop", "cancelled_system", "Returned", OrdersStatus.wait_payment],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null, // Since we only want today's stats, grouping by date isn't necessary
|
|
totalShipmentCost: { $sum: "$totalShipmentCost" },
|
|
itemsSold: { $sum: "$itemsCount" },
|
|
totalOrders: { $sum: 1 },
|
|
},
|
|
},
|
|
]);
|
|
|
|
const defaultData = {
|
|
_id: null,
|
|
totalShipmentCost: 0,
|
|
itemsSold: 0,
|
|
totalOrders: 0,
|
|
};
|
|
return salesData.length > 0 ? salesData[0] : defaultData;
|
|
}
|
|
|
|
async getWeeklyShipmentSalesReport() {
|
|
const today = new Date();
|
|
today.setHours(0, 0, 0, 0);
|
|
const startOfWeek = new Date(today);
|
|
startOfWeek.setDate(today.getDate() - 6); // 7 days ago
|
|
const endOfWeek = new Date(today.getFullYear(), today.getMonth(), today.getDate(), 23, 59, 59, 999);
|
|
|
|
const salesData = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
createdAt: {
|
|
$gte: startOfWeek,
|
|
$lte: endOfWeek,
|
|
},
|
|
status: {
|
|
$nin: ["cancelled_shop", "cancelled_system", "Returned", OrdersStatus.wait_payment],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null, // Since we only want today's stats, grouping by date isn't necessary
|
|
totalShipmentCost: { $sum: "$totalShipmentCost" },
|
|
itemsSold: { $sum: "$itemsCount" },
|
|
totalOrders: { $sum: 1 },
|
|
},
|
|
},
|
|
]);
|
|
|
|
const defaultData = {
|
|
_id: null,
|
|
totalShipmentCost: 0,
|
|
itemsSold: 0,
|
|
totalOrders: 0,
|
|
};
|
|
return salesData.length > 0 ? salesData[0] : defaultData;
|
|
}
|
|
|
|
async getMonthlyShipmentSalesReport() {
|
|
const today = new Date();
|
|
const startOfMonth = new Date(today.getFullYear(), today.getMonth(), 1);
|
|
const endOfMonth = new Date(today.getFullYear(), today.getMonth() + 1, 1);
|
|
|
|
const salesData = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
createdAt: {
|
|
$gte: startOfMonth,
|
|
$lte: endOfMonth,
|
|
},
|
|
status: {
|
|
$nin: ["cancelled_shop", "cancelled_system", "Returned", OrdersStatus.wait_payment],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null, // Since we only want today's stats, grouping by date isn't necessary
|
|
totalShipmentCost: { $sum: "$totalShipmentCost" },
|
|
itemsSold: { $sum: "$itemsCount" },
|
|
totalOrders: { $sum: 1 },
|
|
},
|
|
},
|
|
]);
|
|
|
|
const defaultData = {
|
|
_id: null,
|
|
totalShipmentCost: 0,
|
|
itemsSold: 0,
|
|
totalOrders: 0,
|
|
};
|
|
return salesData.length > 0 ? salesData[0] : defaultData;
|
|
}
|
|
|
|
async getAnnualShipmentSalesReport() {
|
|
const today = new Date();
|
|
const startOfYear = new Date(today.getFullYear(), 0, 1);
|
|
const endOfYear = new Date(today.getFullYear() + 1, 0, 1);
|
|
|
|
const salesData = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
createdAt: {
|
|
$gte: startOfYear,
|
|
$lte: endOfYear,
|
|
},
|
|
status: {
|
|
$nin: ["cancelled_shop", "cancelled_system", "Returned", OrdersStatus.wait_payment],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null, // Since we only want today's stats, grouping by date isn't necessary
|
|
totalShipmentCost: { $sum: "$totalShipmentCost" },
|
|
itemsSold: { $sum: "$itemsCount" },
|
|
totalOrders: { $sum: 1 },
|
|
},
|
|
},
|
|
]);
|
|
|
|
const defaultData = {
|
|
_id: null,
|
|
totalShipmentCost: 0,
|
|
itemsSold: 0,
|
|
totalOrders: 0,
|
|
};
|
|
return salesData.length > 0 ? salesData[0] : defaultData;
|
|
}
|
|
|
|
async getDailySalesReport() {
|
|
const today = new Date();
|
|
today.setHours(0, 0, 0, 0);
|
|
const startOfDay = new Date(today.getFullYear(), today.getMonth(), today.getDate());
|
|
const endOfDay = new Date(today.getFullYear(), today.getMonth(), today.getDate(), 23, 59, 59, 999);
|
|
const salesData = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
createdAt: {
|
|
$gte: startOfDay,
|
|
$lte: endOfDay,
|
|
},
|
|
status: {
|
|
$nin: ["cancelled_shop", "cancelled_system", OrderItemsStatus.cancelled_user, "Returned"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null, // Since we only want today's stats, grouping by date isn't necessary
|
|
totalSales: { $sum: "$totalSellingPrice" },
|
|
totalNetSales: { $sum: "$totalRetailPrice" },
|
|
itemsSold: { $sum: "$itemsCount" },
|
|
totalOrders: { $sum: 1 },
|
|
},
|
|
},
|
|
]);
|
|
|
|
const defaultData = {
|
|
_id: null,
|
|
totalSales: 0,
|
|
totalNetSales: 0,
|
|
itemsSold: 0,
|
|
totalOrders: 0,
|
|
};
|
|
return salesData.length > 0 ? salesData[0] : defaultData;
|
|
}
|
|
|
|
async getWeeklySalesReport() {
|
|
const today = new Date();
|
|
today.setHours(0, 0, 0, 0);
|
|
const startOfWeek = new Date(today);
|
|
startOfWeek.setDate(today.getDate() - 6); // 7 days ago
|
|
const endOfWeek = new Date(today.getFullYear(), today.getMonth(), today.getDate(), 23, 59, 59, 999);
|
|
|
|
const salesData = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
createdAt: {
|
|
$gte: startOfWeek,
|
|
$lte: endOfWeek,
|
|
},
|
|
status: {
|
|
$nin: ["cancelled_shop", "cancelled_system", "Returned"],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null, // Grouping by week
|
|
totalSales: { $sum: "$totalSellingPrice" },
|
|
totalNetSales: { $sum: "$totalRetailPrice" },
|
|
itemsSold: { $sum: "$itemsCount" },
|
|
totalOrders: { $sum: 1 },
|
|
},
|
|
},
|
|
]);
|
|
|
|
const defaultData = {
|
|
_id: null,
|
|
totalSales: 0,
|
|
totalNetSales: 0,
|
|
itemsSold: 0,
|
|
totalOrders: 0,
|
|
};
|
|
return salesData.length > 0 ? salesData[0] : defaultData;
|
|
}
|
|
|
|
async getFiveDaysAgoSalesReport() {
|
|
const today = new Date();
|
|
today.setHours(0, 0, 0, 0); // Reset time to the start of the day
|
|
|
|
const fiveDaysAgo = new Date(today);
|
|
fiveDaysAgo.setDate(today.getDate() - 4); // 5 days ago
|
|
|
|
const salesData = await this.model.aggregate([
|
|
{
|
|
$match: {
|
|
createdAt: {
|
|
$gte: fiveDaysAgo,
|
|
$lt: new Date(today.getTime() + 24 * 60 * 60 * 1000), // Include today
|
|
},
|
|
status: {
|
|
$nin: [
|
|
OrderItemsStatus.cancelled_shop,
|
|
OrderItemsStatus.cancelled_system,
|
|
OrderItemsStatus.Returned,
|
|
OrdersStatus.wait_payment,
|
|
],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: {
|
|
$dateToString: { format: "%Y-%m-%d", date: "$createdAt" },
|
|
},
|
|
totalSales: { $sum: "$totalSellingPrice" },
|
|
},
|
|
},
|
|
{
|
|
$sort: { _id: 1 }, // Sort by date in ascending order
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
date: "$_id",
|
|
price: "$totalSales",
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
dates: { $push: "$date" },
|
|
prices: { $push: "$price" },
|
|
},
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
data: {
|
|
$map: {
|
|
input: { $range: [0, 5] },
|
|
as: "day",
|
|
in: {
|
|
date: {
|
|
$dateToString: {
|
|
format: "%Y-%m-%d",
|
|
date: {
|
|
$dateSubtract: {
|
|
startDate: today,
|
|
unit: "day",
|
|
amount: "$$day",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
price: {
|
|
$let: {
|
|
vars: {
|
|
index: {
|
|
$indexOfArray: [
|
|
"$dates",
|
|
{
|
|
$dateToString: {
|
|
format: "%Y-%m-%d",
|
|
date: { $dateSubtract: { startDate: today, unit: "day", amount: "$$day" } },
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
in: {
|
|
$cond: {
|
|
if: { $gte: ["$$index", 0] },
|
|
then: { $arrayElemAt: ["$prices", "$$index"] },
|
|
else: 0,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$data",
|
|
},
|
|
{
|
|
$replaceRoot: { newRoot: "$data" },
|
|
},
|
|
]);
|
|
|
|
return salesData;
|
|
}
|
|
// Shared constants (place near top of file)
|
|
|
|
async getMonthlySalesReport() {
|
|
const EXCLUDED_ORDER_ITEM_STATUSES = [
|
|
OrderItemsStatus.cancelled_shop,
|
|
OrderItemsStatus.cancelled_system,
|
|
OrderItemsStatus.cancelled_user,
|
|
OrderItemsStatus.Returned,
|
|
];
|
|
|
|
const EXCLUDED_ORDER_STATUSES = [OrdersStatus.wait_payment, OrdersStatus.cancelled_system, OrdersStatus.Cancelled];
|
|
|
|
const today = new Date();
|
|
const startOfMonth = new Date(today.getFullYear(), today.getMonth(), 1);
|
|
const endOfMonth = new Date(today.getFullYear(), today.getMonth() + 1, 1);
|
|
|
|
const salesData = await this.model.aggregate([
|
|
// filter items by month & item status first
|
|
{
|
|
$match: {
|
|
createdAt: { $gte: startOfMonth, $lt: endOfMonth },
|
|
status: { $nin: EXCLUDED_ORDER_ITEM_STATUSES },
|
|
},
|
|
},
|
|
|
|
// join the parent order
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{ $unwind: "$order" },
|
|
|
|
// filter by parent order status
|
|
{
|
|
$match: {
|
|
"order.orderStatus": { $nin: EXCLUDED_ORDER_STATUSES },
|
|
},
|
|
},
|
|
|
|
// aggregate totals and collect distinct order ids
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
totalSales: { $sum: "$totalSellingPrice" },
|
|
totalNetSales: { $sum: "$totalRetailPrice" },
|
|
itemsSold: { $sum: "$itemsCount" },
|
|
orderIds: { $addToSet: "$order._id" },
|
|
},
|
|
},
|
|
|
|
// convert orderIds into a number
|
|
{
|
|
$addFields: {
|
|
totalOrders: { $size: "$orderIds" },
|
|
},
|
|
},
|
|
|
|
// optionally remove the array from results
|
|
{
|
|
$project: { orderIds: 0 },
|
|
},
|
|
]);
|
|
|
|
return salesData.length > 0 ? salesData[0] : null;
|
|
}
|
|
|
|
async getOrderChart(granularity: Gran = "daily", from?: string, to?: string) {
|
|
const EXCLUDED_ORDER_ITEM_STATUSES = [
|
|
OrderItemsStatus.cancelled_shop,
|
|
OrderItemsStatus.cancelled_system,
|
|
OrderItemsStatus.cancelled_user,
|
|
OrderItemsStatus.Returned,
|
|
];
|
|
|
|
const EXCLUDED_ORDER_STATUSES = [OrdersStatus.wait_payment, OrdersStatus.cancelled_system, OrdersStatus.Cancelled];
|
|
|
|
const DATE_TRUNC_TIMEZONE = "Asia/Tehran";
|
|
const MS_PER_DAY = 24 * 60 * 60 * 1000;
|
|
const today = new Date();
|
|
|
|
// if user asked for monthly and did not give from/to, use calendar month
|
|
let startDate: Date;
|
|
let endDate: Date;
|
|
|
|
if (granularity === "monthly" && !from && !to) {
|
|
startDate = new Date(today.getFullYear(), today.getMonth(), 1);
|
|
endDate = new Date(today.getFullYear(), today.getMonth() + 1, 1);
|
|
} else {
|
|
endDate = to ? new Date(to) : new Date();
|
|
endDate.setHours(23, 59, 59, 999);
|
|
const defaultStart = new Date(Date.now() - 30 * MS_PER_DAY);
|
|
startDate = from ? new Date(from) : defaultStart;
|
|
startDate.setHours(0, 0, 0, 0);
|
|
}
|
|
|
|
if (isNaN(startDate.getTime()) || isNaN(endDate.getTime())) {
|
|
throw new Error("Invalid date format. Expected YYYY-MM-DD or ISO date.");
|
|
}
|
|
|
|
if (startDate > endDate) {
|
|
const tmp = startDate;
|
|
startDate = endDate;
|
|
endDate = tmp;
|
|
}
|
|
|
|
const allowed: Record<Gran, "day" | "week" | "month"> = {
|
|
daily: "day",
|
|
weekly: "week",
|
|
monthly: "month",
|
|
};
|
|
const unit = allowed[granularity] ?? "day";
|
|
|
|
const pipeline: any[] = [
|
|
// 1. filter order items by date and item-status
|
|
{
|
|
$match: {
|
|
createdAt: { $gte: startDate, $lte: endDate },
|
|
status: { $nin: EXCLUDED_ORDER_ITEM_STATUSES },
|
|
},
|
|
},
|
|
|
|
// 2. join parent order and filter by order status
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{ $unwind: "$order" },
|
|
{
|
|
$match: {
|
|
"order.orderStatus": { $nin: EXCLUDED_ORDER_STATUSES },
|
|
},
|
|
},
|
|
|
|
// 3. group by truncated period (include timezone)
|
|
{
|
|
$group: {
|
|
_id: {
|
|
period: {
|
|
$dateTrunc: {
|
|
date: "$createdAt",
|
|
unit: unit,
|
|
binSize: 1,
|
|
timezone: DATE_TRUNC_TIMEZONE,
|
|
},
|
|
},
|
|
},
|
|
periodTotal: { $sum: "$totalSellingPrice" },
|
|
},
|
|
},
|
|
|
|
{ $sort: { "_id.period": 1 } },
|
|
];
|
|
|
|
const aggResults: Array<{ _id: { period: Date }; periodTotal: number }> = await this.model.aggregate(pipeline).exec();
|
|
|
|
// build map and x/y arrays (same logic as you had)
|
|
const map = new Map<string, number>();
|
|
for (const r of aggResults) {
|
|
const d: Date = r._id.period;
|
|
const key = unit === "month" ? d.toISOString().slice(0, 7) : d.toISOString().slice(0, 10);
|
|
map.set(key, r.periodTotal ?? 0);
|
|
}
|
|
|
|
function formatKey(d: Date) {
|
|
return unit === "month" ? d.toISOString().slice(0, 7) : d.toISOString().slice(0, 10);
|
|
}
|
|
function addPeriod(d: Date) {
|
|
const nd = new Date(d);
|
|
if (unit === "day") nd.setDate(nd.getDate() + 1);
|
|
else if (unit === "week") nd.setDate(nd.getDate() + 7);
|
|
else nd.setMonth(nd.getMonth() + 1);
|
|
return nd;
|
|
}
|
|
|
|
const xAxis: string[] = [];
|
|
const yAxis: number[] = [];
|
|
|
|
let cursor = new Date(startDate);
|
|
if (unit === "month") cursor.setDate(1);
|
|
|
|
while (cursor <= endDate) {
|
|
const key = formatKey(cursor);
|
|
xAxis.push(key);
|
|
yAxis.push(map.get(key) ?? 0);
|
|
cursor = addPeriod(cursor);
|
|
}
|
|
|
|
const totalSales = yAxis.reduce((s, v) => s + v, 0);
|
|
|
|
return {
|
|
chartType: "line",
|
|
title: "نمودار کل فروش",
|
|
unit: "تومان",
|
|
granularity,
|
|
xAxis,
|
|
yAxis,
|
|
totalSales,
|
|
_debug: { aggregatedPeriods: aggResults.length },
|
|
};
|
|
}
|
|
|
|
async getAnnualSalesReport() {
|
|
const today = new Date();
|
|
const startOfYear = new Date(today.getFullYear(), 0, 1);
|
|
const endOfYear = new Date(today.getFullYear() + 1, 0, 1);
|
|
|
|
const salesData = await this.model.aggregate([
|
|
{
|
|
$lookup: {
|
|
from: "orders",
|
|
localField: "order",
|
|
foreignField: "_id",
|
|
as: "order",
|
|
},
|
|
},
|
|
{
|
|
$match: {
|
|
createdAt: {
|
|
$gte: startOfYear,
|
|
$lt: endOfYear,
|
|
},
|
|
status: {
|
|
$nin: ["cancelled_shop", "cancelled_system", "Returned", OrdersStatus.wait_payment],
|
|
},
|
|
},
|
|
},
|
|
{
|
|
$group: {
|
|
_id: null,
|
|
totalSales: { $sum: "$totalSellingPrice" },
|
|
totalNetSales: { $sum: "$totalRetailPrice" },
|
|
itemsSold: { $sum: "$itemsCount" },
|
|
totalOrders: { $sum: 1 },
|
|
},
|
|
},
|
|
]);
|
|
|
|
return salesData.length > 0 ? salesData[0] : null;
|
|
}
|
|
|
|
async getTopSellingProducts(limit = 5) {
|
|
const topProducts = await this.model.aggregate([
|
|
{ $unwind: "$shipmentItems" },
|
|
{
|
|
$group: {
|
|
_id: "$shipmentItems.product",
|
|
totalSold: { $sum: "$shipmentItems.quantity" },
|
|
},
|
|
},
|
|
{ $sort: { totalSold: -1 } },
|
|
{ $limit: limit },
|
|
{
|
|
$lookup: {
|
|
from: "products",
|
|
localField: "_id",
|
|
foreignField: "_id",
|
|
as: "productDetails",
|
|
},
|
|
},
|
|
{ $unwind: "$productDetails" },
|
|
{
|
|
$lookup: {
|
|
from: "shops",
|
|
localField: "productDetails.shop",
|
|
foreignField: "_id",
|
|
as: "productDetails.shop",
|
|
},
|
|
},
|
|
{
|
|
$unwind: "$productDetails.shop",
|
|
},
|
|
{
|
|
$project: {
|
|
_id: 0,
|
|
productId: "$_id",
|
|
totalSold: 1,
|
|
productDetails: {
|
|
_id: 1,
|
|
title_fa: 1,
|
|
title_en: 1,
|
|
model: 1,
|
|
description: 1,
|
|
shop: {
|
|
_id: 1,
|
|
shopName: 1,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
]);
|
|
|
|
return topProducts;
|
|
}
|
|
}
|
|
//**************************************************** */
|
|
//**************************************************** */
|
|
|
|
function createOrderItemRepo(): OrderItemRepo {
|
|
return new OrderItemRepo();
|
|
}
|
|
|
|
function createOrderRepo(): OrderRepository {
|
|
return new OrderRepository();
|
|
}
|
|
|
|
export { OrderRepository, createOrderRepo, createOrderItemRepo, OrderItemRepo };
|