@lyxa.ai/marketing 1.0.37 → 1.0.40

package/dist/lib/modules/marketing/services/marketing.service.js

@@ -56,14 +56,17 @@ const _1 = require(".");
 const enum_2 = require("@lyxa.ai/core/dist/utilities/enum");
 const error_common_1 = require("@lyxa.ai/core/dist/utilities/error-common");
 const mongo_stream_changes_batch_process_shops_event_1 = require("@lyxa.ai/core/dist/libraries/event/events/mongo-stream-changes-batch-process-shops-event");
+const MarketingMetricsRepository_1 = require("../patterns/repository/MarketingMetricsRepository");
 let MarketingService = class MarketingService {
     model;
     shopModel;
     orderModel;
+    marketingMetricsRepository;
     constructor() {
         this.model = models_1.MarketingModel;
         this.shopModel = models_1.ShopModel;
         this.orderModel = models_1.RegularOrderModel;
+        this.marketingMetricsRepository = MarketingMetricsRepository_1.marketingMetricsRepository;
     }
     async create(data, admin) {
         const now = (0, dayjs_1.dayjs)().toDate();
@@ -358,333 +361,6 @@ let MarketingService = class MarketingService {
         }
         return 'Product handled successfully';
     }
-    async evaluateMarketingSpendLimits(marketings) {
-        this.evaluateItemBasedMarketings(marketings);
-        this.evalulateFreeDeliveryMarketings(marketings);
-        return 'Evaluated spend limits';
-    }
-    async evaluateItemBasedMarketings(marketings) {
-        const pipeline = [
-            {
-                $match: {
-                    $and: [{ marketings: { $exists: true } }, { marketings: { $ne: null } }],
-                    status: { $ne: enum_1.RegularOrderStatus.CANCELLED },
-                    $expr: {
-                        $gt: [
-                            {
-                                $size: {
-                                    $setIntersection: ['$marketings', marketings],
-                                },
-                            },
-                            0,
-                        ],
-                    },
-                },
-            },
-            {
-                $lookup: {
-                    from: 'lineItems',
-                    localField: 'cart',
-                    foreignField: 'cart',
-                    as: 'lineItems',
-                },
-            },
-            {
-                $unwind: '$lineItems',
-            },
-            {
-                $lookup: {
-                    from: 'marketings',
-                    localField: 'lineItems.marketings',
-                    foreignField: '_id',
-                    as: 'marketing',
-                },
-            },
-            {
-                $unwind: '$marketing',
-            },
-            {
-                $group: {
-                    _id: '$marketing._id',
-                    marketingType: { $first: '$marketing.marketingType' },
-                    spendLimit: { $first: '$marketing.spendLimit' },
-                    isSpendLimitEnabled: { $first: '$marketing.isSpendLimitEnabled' },
-                    totalCompanyDiscount: {
-                        $sum: {
-                            $cond: [
-                                { $eq: ['$marketing.marketingType', enum_2.MarketingType.DISCOUNT] },
-                                '$lineItems.calculationSnap.itemDiscountByCompany',
-                                0,
-                            ],
-                        },
-                    },
-                    totalShopDiscount: {
-                        $sum: {
-                            $cond: [
-                                { $eq: ['$marketing.marketingType', enum_2.MarketingType.DISCOUNT] },
-                                '$lineItems.calculationSnap.itemDiscountByShop',
-                                0,
-                            ],
-                        },
-                    },
-                    totalB1G1Company: {
-                        $sum: {
-                            $cond: [
-                                { $eq: ['$marketing.marketingType', enum_2.MarketingType.BUY1GET1] },
-                                '$lineItems.calculationSnap.b1g1DiscountByCompany',
-                                0,
-                            ],
-                        },
-                    },
-                    totalB1G1Shop: {
-                        $sum: {
-                            $cond: [
-                                { $eq: ['$marketing.marketingType', enum_2.MarketingType.BUY1GET1] },
-                                '$lineItems.calculationSnap.b1g1DiscountByShop',
-                                0,
-                            ],
-                        },
-                    },
-                },
-            },
-        ];
-        const result = await this.orderModel.aggregate(pipeline);
-        const promises = [];
-        result?.forEach(async (marketing) => {
-            if (marketing.isSpendLimitEnabled) {
-                const totalSpent = marketing.totalCompanyDiscount +
-                    marketing.totalShopDiscount +
-                    marketing.totalB1G1Company +
-                    marketing.totalB1G1Shop;
-                if (totalSpent >= marketing.spendLimit) {
-                    await this.model.findByIdAndUpdate(marketing._id, {
-                        status: enum_1.MarketingStatus.EXPIRED,
-                    });
-                    promises.push(_1.productMarketingService.syncProductMarketingInfo(marketing._id));
-                }
-            }
-        });
-        await Promise.all(promises);
-    }
-    async evalulateFreeDeliveryMarketings(marketings) {
-        const pipeline = [
-            {
-                $match: {
-                    $and: [{ marketings: { $exists: true } }, { marketings: { $ne: null } }],
-                    status: { $ne: enum_1.RegularOrderStatus.CANCELLED },
-                    $expr: {
-                        $gt: [
-                            {
-                                $size: {
-                                    $setIntersection: ['$marketings', marketings],
-                                },
-                            },
-                            0,
-                        ],
-                    },
-                },
-            },
-            {
-                $lookup: {
-                    from: 'marketings',
-                    localField: 'marketings',
-                    foreignField: '_id',
-                    as: 'marketing',
-                },
-            },
-            {
-                $unwind: '$marketing',
-            },
-            {
-                $match: {
-                    'marketing.marketingType': enum_2.MarketingType.FREE_DELIVERY,
-                },
-            },
-            {
-                $group: {
-                    _id: '$marketing._id',
-                    marketingType: { $first: '$marketing.marketingType' },
-                    spendLimit: { $first: '$marketing.spendLimit' },
-                    isSpendLimitEnabled: { $first: '$marketing.isSpendLimitEnabled' },
-                    totalFreeDeliveryCompany: {
-                        $sum: {
-                            $cond: [
-                                { $eq: ['$marketing.marketingType', enum_2.MarketingType.FREE_DELIVERY] },
-                                '$adjustedFinance.freeDelivery.companyCut',
-                                0,
-                            ],
-                        },
-                    },
-                    totalFreeDeliveryShop: {
-                        $sum: {
-                            $cond: [
-                                { $eq: ['$marketing.marketingType', enum_2.MarketingType.FREE_DELIVERY] },
-                                '$adjustedFinance.freeDelivery.shopCut',
-                                0,
-                            ],
-                        },
-                    },
-                },
-            },
-        ];
-        const result = await this.orderModel.aggregate(pipeline);
-        const promises = [];
-        result?.forEach(marketing => {
-            if (marketing.isSpendLimitEnabled) {
-                const totalSpent = marketing.totalFreeDeliveryCompany + marketing.totalFreeDeliveryShop;
-                if (totalSpent >= marketing.spendLimit) {
-                    promises.push(this.model.findByIdAndUpdate(marketing._id, {
-                        status: enum_1.MarketingStatus.EXPIRED,
-                    }));
-                }
-            }
-        });
-        await Promise.all(promises);
-    }
-    async calculateMarketingSpent(marketingId) {
-        const marketing = await this.model.findById(marketingId).lean();
-        if (!marketing) {
-            throw new Error('Marketing not found');
-        }
-        let amount = 0;
-        switch (marketing.marketingType) {
-            case enum_2.MarketingType.FREE_DELIVERY:
-                amount = await this.calculateFreeDeliverySpent(marketingId);
-                break;
-            case enum_2.MarketingType.DISCOUNT:
-            case enum_2.MarketingType.BUY1GET1:
-                amount = await this.calculateItemBasedSpent(marketingId);
-                break;
-            case enum_2.MarketingType.PUNCH_MARKETING:
-                amount = await this.calculatePunchMarketingSpent(marketingId);
-                break;
-            default:
-                amount = 0;
-        }
-        return {
-            amount,
-            marketingType: marketing.marketingType,
-        };
-    }
-    async calculateItemBasedSpent(marketingId) {
-        const pipeline = [
-            {
-                $match: {
-                    $and: [{ marketings: { $exists: true } }, { marketings: { $ne: null } }],
-                    status: { $ne: enum_1.RegularOrderStatus.CANCELLED },
-                    marketings: marketingId,
-                },
-            },
-            {
-                $lookup: {
-                    from: 'lineItems',
-                    localField: 'cart',
-                    foreignField: 'cart',
-                    as: 'lineItems',
-                },
-            },
-            { $unwind: '$lineItems' },
-            {
-                $lookup: {
-                    from: 'marketings',
-                    localField: 'lineItems.marketings',
-                    foreignField: '_id',
-                    as: 'marketing',
-                },
-            },
-            { $unwind: '$marketing' },
-            {
-                $match: {
-                    'marketing._id': marketingId,
-                },
-            },
-            {
-                $group: {
-                    _id: null,
-                    totalCompanyDiscount: {
-                        $sum: '$lineItems.calculationSnap.itemDiscountByCompany',
-                    },
-                    totalShopDiscount: {
-                        $sum: '$lineItems.calculationSnap.itemDiscountByShop',
-                    },
-                    totalB1G1Company: {
-                        $sum: '$lineItems.calculationSnap.b1g1DiscountByCompany',
-                    },
-                    totalB1G1Shop: {
-                        $sum: '$lineItems.calculationSnap.b1g1DiscountByShop',
-                    },
-                },
-            },
-        ];
-        const [result] = await this.orderModel.aggregate(pipeline);
-        if (!result)
-            return 0;
-        return (result.totalCompanyDiscount + result.totalShopDiscount + result.totalB1G1Company + result.totalB1G1Shop);
-    }
-    async calculateFreeDeliverySpent(marketingId) {
-        const pipeline = [
-            {
-                $match: {
-                    $and: [{ marketings: { $exists: true } }, { marketings: { $ne: null } }],
-                    status: { $ne: enum_1.RegularOrderStatus.CANCELLED },
-                    marketings: marketingId,
-                },
-            },
-            {
-                $lookup: {
-                    from: 'marketings',
-                    localField: 'marketings',
-                    foreignField: '_id',
-                    as: 'marketing',
-                },
-            },
-            { $unwind: '$marketing' },
-            {
-                $match: {
-                    'marketing._id': marketingId,
-                    'marketing.marketingType': enum_2.MarketingType.FREE_DELIVERY,
-                },
-            },
-            {
-                $group: {
-                    _id: null,
-                    totalFreeDeliveryCompany: {
-                        $sum: '$adjustedFinance.freeDelivery.companyCut',
-                    },
-                    totalFreeDeliveryShop: {
-                        $sum: '$adjustedFinance.freeDelivery.shopCut',
-                    },
-                },
-            },
-        ];
-        const [result] = await this.orderModel.aggregate(pipeline);
-        if (!result)
-            return 0;
-        return result.totalFreeDeliveryCompany + result.totalFreeDeliveryShop;
-    }
-    async calculatePunchMarketingSpent(marketingId) {
-        const pipeline = [
-            {
-                $match: {
-                    $and: [{ marketings: { $exists: true } }, { marketings: { $ne: null } }],
-                    status: { $ne: enum_1.RegularOrderStatus.CANCELLED },
-                    marketings: marketingId,
-                },
-            },
-            {
-                $group: {
-                    _id: null,
-                    totalPunchDiscount: {
-                        $sum: {
-                            $ifNull: ['$adjustedFinance.pricing.punchMarketingDiscount', 0],
-                        },
-                    },
-                },
-            },
-        ];
-        const [result] = await this.orderModel.aggregate(pipeline);
-        return result?.totalPunchDiscount ?? 0;
-    }
     async incrementMarketingSpentFromOrder(orderId) {
         const order = (await this.orderModel
             .findById(orderId)
@@ -692,7 +368,7 @@ let MarketingService = class MarketingService {
         if (!order || !order.marketings?.length) {
             return;
         }
-        const marketingSpendMap = this.calculateMarketingSpendPerOrder(order);
+        const marketingSpendMap = this.marketingMetricsRepository.calculateMarketingSpendPerOrder(order);
         const bulkOps = [...marketingSpendMap.entries()].map(([marketingId, amountSpent]) => ({
             updateOne: {
                 filter: { _id: marketingId },
@@ -702,44 +378,78 @@ let MarketingService = class MarketingService {
         if (bulkOps.length) {
             await this.model.bulkWrite(bulkOps);
         }
-        await this.expireMarketingsExceedingSpendLimits();
+        await this.expireMarketingsExceedingSpendLimits(Array.from(marketingSpendMap.keys()));
         return 'Marketing amount spent incremented successfully';
     }
-    async expireMarketingsExceedingSpendLimits() {
+    async decrementMarketingSpentFromOrder(orderId) {
+        const order = (await this.orderModel
+            .findById(orderId)
+            .populate('lineItems'));
+        if (!order || !order.marketings?.length) {
+            return;
+        }
+        const marketingSpendMap = this.marketingMetricsRepository.calculateMarketingSpendPerOrder(order);
+        const bulkOps = [...marketingSpendMap.entries()].map(([marketingId, amountSpent]) => ({
+            updateOne: {
+                filter: { _id: marketingId },
+                update: { $inc: { amountSpent: -amountSpent } },
+            },
+        }));
+        if (bulkOps.length) {
+            await this.model.bulkWrite(bulkOps);
+        }
+        await this.unExpireMarketingsBelowSpendLimits(Array.from(marketingSpendMap.keys()));
+        return 'Marketing amount spent decremented successfully';
+    }
+    async expireMarketingsExceedingSpendLimits(marketingIds) {
         await this.model.updateMany({
+            _id: { $in: marketingIds },
             isSpendLimitEnabled: true,
             status: { $ne: enum_1.MarketingStatus.EXPIRED },
             $expr: { $gte: ['$amountSpent', '$spendLimit'] },
         }, { $set: { status: enum_1.MarketingStatus.EXPIRED } });
     }
-    calculateMarketingSpendPerOrder(order) {
-        const spendMap = new Map();
-        const addSpend = (marketingId, amount) => {
-            if (!amount || amount <= 0)
-                return;
-            spendMap.set(marketingId, (spendMap.get(marketingId) ?? 0) + amount);
-        };
-        for (const lineItem of order.lineItems ?? []) {
-            for (const marketingId of lineItem.marketings ?? []) {
-                const snap = lineItem.calculationSnap ?? {};
-                addSpend(marketingId._id, (Number(snap.itemDiscountByCompany) || 0) +
-                    (Number(snap.itemDiscountByShop) || 0) +
-                    (Number(snap.b1g1DiscountByCompany) || 0) +
-                    (Number(snap.b1g1DiscountByShop) || 0));
-            }
-        }
-        if (order.adjustedFinance?.freeDelivery) {
-            for (const marketingId of order.marketings ?? []) {
-                addSpend(marketingId._id, (order.adjustedFinance.freeDelivery.companyCut ?? 0) +
-                    (order.adjustedFinance.freeDelivery.shopCut ?? 0));
+    async unExpireMarketingsBelowSpendLimits(marketingIds) {
+        await this.model.updateMany({
+            _id: { $in: marketingIds },
+            isSpendLimitEnabled: true,
+            status: enum_1.MarketingStatus.EXPIRED,
+            $expr: { $lt: ['$amountSpent', '$spendLimit'] },
+        }, { $set: { status: enum_1.MarketingStatus.ACTIVE } });
+    }
+    async recomputeAndSyncAllMarketingSpent() {
+        console.time('Recomputing all marketing spend');
+        const cursor = this.model
+            .find({ marketingType: { $ne: enum_2.MarketingType.FEATURED } }, { _id: 1 })
+            .lean()
+            .cursor();
+        const bulkOps = [];
+        const marketingIds = [];
+        for await (const marketing of cursor) {
+            console.log(`Recomputing marketing spend for marketing ID: ${marketing._id}`);
+            const { amount } = await this.marketingMetricsRepository.calculateMarketingSpent(marketing._id);
+            bulkOps.push({
+                updateOne: {
+                    filter: { _id: marketing._id },
+                    update: {
+                        $set: { amountSpent: amount },
+                    },
+                },
+            });
+            marketingIds.push(marketing._id);
+            if (bulkOps.length >= 500) {
+                console.log(`Flushing 500 marketing spend updates...`);
+                await this.model.bulkWrite(bulkOps);
+                bulkOps.length = 0;
             }
         }
-        if (order.adjustedFinance?.pricing?.punchMarketingDiscount) {
-            for (const marketingId of order.marketings ?? []) {
-                addSpend(marketingId._id, order.adjustedFinance.pricing.punchMarketingDiscount);
-            }
+        if (bulkOps.length) {
+            console.log(`Flushing remaining ${bulkOps.length} marketing spend updates...`);
+            await this.model.bulkWrite(bulkOps);
         }
-        return spendMap;
+        await this.expireMarketingsExceedingSpendLimits(marketingIds);
+        await this.unExpireMarketingsBelowSpendLimits(marketingIds);
+        console.timeEnd('Recomputing all marketing spend');
     }
 };
 exports.MarketingService = MarketingService;