@lyxa.ai/marketing 1.0.31 → 1.0.34

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

@@ -67,6 +67,7 @@ let CouponService = class CouponService {
     referralRewardModel;
     punchHistoryService;
     _coreUserModel = null;
+    couponHelper;
     constructor() {
         this.model = models_1.CouponModel;
         this.baseCouponModel = models_2.BaseCouponModel;
@@ -75,6 +76,7 @@ let CouponService = class CouponService {
         this.shopModel = models_1.ShopModel;
         this.referralRewardModel = models_1.ReferralRewardCouponModel;
         this.punchHistoryService = services_1.punchMarketingHistoryService;
+        this.couponHelper = helper_service_1.couponHelperService;
     }
     get coreUserModel() {
         if (!this._coreUserModel) {
@@ -84,6 +86,11 @@ let CouponService = class CouponService {
     }
     async create(data) {
         let coupon;
+        if (data.couponType != enum_1.CouponType.REFERRAL_CODE &&
+            data?.duration &&
+            !this.couponHelper.isDurationValid((0, dayjs_1.dayjs)(data?.duration?.start), (0, dayjs_1.dayjs)(data?.duration?.end))) {
+            (0, error_common_1.conflictError)(`Start date/time cannot be in the past `);
+        }
         const checkCoupon = await this.model.findOne({
             code: data.code,
             deletedAt: null,
@@ -262,18 +269,18 @@ let CouponService = class CouponService {
     }
     async update(id, data) {
         let coupon;
-        const [oldCoupon, oldOrders, checkCouponCode] = await Promise.all([
-            this.model.findById(id),
-            this.orderModel
-                .find({
-                'finance.coupon.coupon': id,
-            })
-                .select(['user', 'finance']),
+        const [oldCoupon, checkCouponCode, usersWithOldCoupon] = await Promise.all([
+            this.baseCouponModel.findById(id),
             this.model.findOne({
                 code: data.code,
                 _id: { $ne: id },
                 updatedVersion: { $exists: false },
             }),
+            this.userModel
+                .find({
+                coupons: new typegoose_1.mongoose.Types.ObjectId(id),
+            })
+                .select(['_id', 'coupons']),
         ]);
         if (!oldCoupon) {
             throw new server_1.TRPCError({
@@ -281,23 +288,35 @@ let CouponService = class CouponService {
                 message: `Coupon not found`,
             });
         }
+        if (data.couponType != enum_1.CouponType.REFERRAL_CODE &&
+            oldCoupon?.duration &&
+            (0, dayjs_1.dayjs)(oldCoupon?.duration?.start) > (0, dayjs_1.dayjs)(data?.duration.start)) {
+            throw new server_1.TRPCError({
+                code: 'BAD_REQUEST',
+                message: `Don't allow updating coupon to have earlier start date/time than the original coupon`,
+            });
+        }
+        if (data.couponType != enum_1.CouponType.REFERRAL_CODE &&
+            data?.duration &&
+            (0, dayjs_1.dayjs)(data?.duration?.start) > (0, dayjs_1.dayjs)(data?.duration.end)) {
+            throw new server_1.TRPCError({
+                code: 'BAD_REQUEST',
+                message: `End date/time must be after start date/time`,
+            });
+        }
         if (checkCouponCode) {
             throw new server_1.TRPCError({
                 code: 'CONFLICT',
                 message: `Coupon code already exists`,
             });
         }
-        const oldCouponUsers = oldOrders.map(order => order.user);
         switch (data.couponType) {
             case enum_1.CouponType.GLOBAL: {
                 coupon = await _1.globalCouponService.create(data);
                 if (coupon) {
                     const globalCoupon = coupon;
                     if (!globalCoupon.forNewUserOnly) {
-                        await this.exchangeCouponForMultipleUser({ _id: { $nin: oldCouponUsers } }, oldCoupon._id, coupon._id);
-                    }
-                    else {
-                        await this.removeCouponFromMultipleUser({ _id: { $nin: oldCouponUsers } }, oldCoupon._id);
+                        await this.exchangeCouponForMultipleUser({ _id: { $in: usersWithOldCoupon?.map(u => u._id) } }, oldCoupon._id, coupon._id);
                     }
                 }
                 break;
@@ -307,10 +326,7 @@ let CouponService = class CouponService {
                 if (coupon) {
                     const shopsCategoriesCoupon = coupon;
                     if (!shopsCategoriesCoupon.forNewUserOnly) {
-                        await this.exchangeCouponForMultipleUser({ _id: { $nin: oldCouponUsers } }, oldCoupon._id, coupon._id);
-                    }
-                    else {
-                        await this.removeCouponFromMultipleUser({ _id: { $nin: oldCouponUsers } }, oldCoupon._id);
+                        await this.exchangeCouponForMultipleUser({ _id: { $in: usersWithOldCoupon?.map(u => u._id) } }, oldCoupon._id, shopsCategoriesCoupon._id);
                     }
                 }
                 break;
@@ -320,10 +336,7 @@ let CouponService = class CouponService {
                 if (coupon) {
                     const individualStoreCoupon = coupon;
                     if (!individualStoreCoupon.forNewUserOnly) {
-                        await this.exchangeCouponForMultipleUser({ _id: { $nin: oldCouponUsers } }, oldCoupon._id, coupon._id);
-                    }
-                    else {
-                        await this.removeCouponFromMultipleUser({ _id: { $nin: oldCouponUsers } }, oldCoupon._id);
+                        await this.exchangeCouponForMultipleUser({ _id: { $in: usersWithOldCoupon?.map(u => u._id) } }, oldCoupon._id, individualStoreCoupon._id);
                     }
                 }
                 break;
@@ -332,15 +345,19 @@ let CouponService = class CouponService {
                 coupon = await _1.individualUserCouponService.create(data);
                 if (coupon) {
                     const individualUserCoupon = coupon;
-                    await this.removeCouponFromMultipleUser({ _id: { $nin: oldCouponUsers } }, oldCoupon._id);
-                    if (!individualUserCoupon.forNewUserOnly) {
-                        await this.assignCouponToMultipleUser({ _id: { $in: individualUserCoupon.users } }, oldCoupon._id);
-                    }
+                    await this.removeCouponFromMultipleUser({ _id: { $in: usersWithOldCoupon?.map(u => u._id) } }, oldCoupon._id);
+                    await this.assignCouponToMultipleUser({ _id: { $in: individualUserCoupon.users } }, individualUserCoupon._id);
                 }
                 break;
             }
             case enum_1.CouponType.CUSTOM_COUPON: {
                 coupon = await _1.customCouponService.create(data);
+                if (coupon) {
+                    const customCoupon = coupon;
+                    if (!customCoupon.forNewUserOnly) {
+                        await this.exchangeCouponForMultipleUser({ _id: { $in: usersWithOldCoupon?.map(u => u._id) } }, oldCoupon._id, coupon._id);
+                    }
+                }
                 break;
             }
             default: {
@@ -358,7 +375,7 @@ let CouponService = class CouponService {
         }
         const previousVersions = oldCoupon?.previousVersions || [];
         previousVersions.push(oldCoupon._id);
-        const updatedCoupon = await this.model.findByIdAndUpdate(coupon._id, {
+        const updatedCoupon = await this.baseCouponModel.findByIdAndUpdate(coupon._id, {
             $set: {
                 previousVersions,
             },
@@ -372,9 +389,10 @@ let CouponService = class CouponService {
                 message: `Could not set previous versions of coupon`,
             });
         }
-        const updatedOldCoupon = await this.model.findByIdAndUpdate(oldCoupon._id, {
+        const updatedOldCoupon = await this.baseCouponModel.findByIdAndUpdate(oldCoupon._id, {
             $set: {
                 updatedVersion: coupon._id,
+                'duration.end': coupon.duration.end,
             },
         }, {
             new: true,
@@ -395,10 +413,20 @@ let CouponService = class CouponService {
                 message: 'Coupon not found',
             });
         }
+        const previousVersions = coupon.previousVersions;
+        if (previousVersions && previousVersions.length > 0) {
+            await this.baseCouponModel.updateMany({ _id: { $in: previousVersions } }, {
+                $set: { status },
+            });
+        }
         return coupon;
     }
     async deleteById(data) {
         const { _id, softDelete } = data;
+        const coupon = await this.model.findById(_id);
+        if (!coupon) {
+            (0, error_common_1.notFoundError)('Coupon not found');
+        }
         const result = await this.model.deleteRecord({ _id, deletedAt: null }, softDelete);
         if (!result) {
             throw new server_1.TRPCError({
@@ -407,6 +435,10 @@ let CouponService = class CouponService {
             });
         }
         this.removeCouponFromMultipleUser({}, _id);
+        const previousVersions = coupon.previousVersions;
+        if (previousVersions && previousVersions.length > 0) {
+            await this.model.deleteRecord({ _id: { $in: previousVersions }, deletedAt: null }, softDelete);
+        }
         return 'Record deleted successfully';
     }
     async getUserCoupons(user, shop, page = 0, size = 0) {
@@ -420,7 +452,7 @@ let CouponService = class CouponService {
         if (shop && user) {
             const punch = await this.punchHistoryService.getPunchCoupon(user, shop);
             if (punch) {
-                coupons.available.unshift(punch);
+                coupons.available.push(punch);
             }
         }
         return couponRepository.addLabelsToAllCoupons(coupons);
@@ -429,19 +461,30 @@ let CouponService = class CouponService {
         if (data.coupon === 'punch') {
             return await services_1.punchMarketingHistoryService.getPunchDiscount(data);
         }
-        const [user, coupon] = await Promise.all([
-            this.userModel.findById(data.user),
-            this.model.findOne({ code: data.coupon, updatedVersion: { $exists: false } }),
-        ]);
+        const user = await this.userModel.findById(data.user);
         if (!user)
             (0, error_common_1.notFoundError)('User not found');
-        if (!coupon)
-            (0, error_common_1.notFoundError)('Coupon not found');
+        let coupon = await this.model.findOne({
+            code: data.coupon,
+            _id: { $in: user.coupons ?? [] },
+            status: { $in: [enum_1.Status.ACTIVE, null] },
+        });
+        if (!coupon) {
+            coupon = await this.model.findOne({
+                code: data.coupon,
+                status: { $in: [enum_1.Status.ACTIVE, null] },
+                couponType: { $in: [enum_1.CouponType.REFERRAL_CODE, enum_1.CouponType.CUSTOM_COUPON] },
+                updatedVersion: { $exists: false },
+            });
+            if (!coupon) {
+                (0, error_common_1.notFoundError)('Coupon not found');
+            }
+        }
         if (coupon.couponType == enum_1.CouponType.REFERRAL_CODE) {
-            return await _1.referralCodeCouponService.validateCoupon(data);
+            return await _1.referralCodeCouponService.validateCoupon(data, coupon);
         }
         const baseCoupon = coupon;
-        const { isValid, invalidMessage } = await this.validateBaseCoupon(baseCoupon, user._id, data.amountBeforeCoupon);
+        const { isValid, invalidMessage } = await this.validateBaseCoupon(baseCoupon, user._id, data.amountBeforeCoupon, Boolean(data.scheduledAt) ? (0, dayjs_1.dayjs)(data.scheduledAt) : undefined);
         if (!isValid) {
             return {
                 isValid,
@@ -471,15 +514,16 @@ let CouponService = class CouponService {
         }
         return false;
     }
-    async validateBaseCoupon(coupon, user, orderAmount) {
+    async validateBaseCoupon(coupon, user, orderAmount, scheduledAt = undefined) {
         const invalidConditions = [
             this.isCouponExpired(coupon),
-            coupon.duration.start > new Date(),
+            coupon.duration.start > (0, dayjs_1.dayjs)().toDate(),
             coupon.isMinOrderValueEnabled && coupon.minOrderValue && orderAmount < coupon.minOrderValue,
-            coupon.forNewUserOnly && !(await helper_service_1.couponHelperService.isNewUser(user)),
+            coupon.forNewUserOnly && !(await this.verifyNewUserConditions(coupon, user)),
             coupon.isOrderLimitPerUserEnabled &&
                 coupon.orderLimitPerUser &&
                 (await this.getCouponOrdersForUser(user, coupon.code)) >= coupon.orderLimitPerUser,
+            scheduledAt && Boolean(coupon.duration.end) && (0, dayjs_1.dayjs)(coupon.duration.end).isBefore(scheduledAt),
         ];
         const invalidMessages = [
             'This coupon is expired',
@@ -487,11 +531,25 @@ let CouponService = class CouponService {
             'The minimum order amount for this coupon is not met',
             'This coupon is for new users only',
             'You have reached the order limit for this coupon',
+            'This coupon is not valid for this scheduled orders',
         ];
         const isValid = invalidConditions.every(value => Boolean(value) == false);
         const invalidMessage = invalidMessages.filter((_, index) => invalidConditions[index])?.[0];
         return { isValid, invalidMessage };
     }
+    async verifyNewUserConditions(coupon, user) {
+        const forNewUserOnly = coupon.forNewUserOnly;
+        const isOrderLimitPerUserEnabled = coupon.isOrderLimitPerUserEnabled;
+        const orderLimitPerUser = coupon.orderLimitPerUser;
+        if (forNewUserOnly) {
+            if (isOrderLimitPerUserEnabled && orderLimitPerUser) {
+                const orderCount = await helper_service_1.couponHelperService.getSameDeviceOrders(user);
+                return orderLimitPerUser > orderCount;
+            }
+            return await helper_service_1.couponHelperService.isNewUser(user);
+        }
+        return true;
+    }
     async getCouponOrdersForUser(user, couponCode) {
         const orders = (await this.orderModel
             .find({
@@ -503,11 +561,9 @@ let CouponService = class CouponService {
         const count = orders.filter(order => order.cart.couponCode == couponCode).length;
         return count;
     }
-    async handleCouponExpiry(couponCode) {
-        const coupon = await this.model.findOne({ code: couponCode, updatedVersion: { $exists: false } });
-        if (!coupon ||
-            coupon.couponType == enum_1.CouponType.REFERRAL_CODE ||
-            coupon.couponType == enum_1.CouponType.REFERRAL_REWARD) {
+    async handleCouponExpiry(couponId) {
+        const coupon = await this.model.findById(couponId);
+        if (!coupon || coupon.couponType == enum_1.CouponType.REFERRAL_CODE) {
             return;
         }
         const typedCoupon = coupon;
@@ -542,7 +598,7 @@ let CouponService = class CouponService {
             ];
             const result = await this.orderModel.aggregate(pipeline);
             const orderCount = result[0]?.orderCount ?? 0;
-            if (orderCount > typedCoupon.totalOrderLimit) {
+            if (orderCount >= typedCoupon.totalOrderLimit) {
                 expirationReason = enum_1.CouponExpirationReason.TOTAL_ORDER_LIMIT;
             }
         }
@@ -562,7 +618,7 @@ let CouponService = class CouponService {
         });
     }
     async findCouponByCode(code) {
-        const coupon = await this.model.findOne({ code: code });
+        const coupon = await this.model.findOne({ code: code, updatedVersion: { $exists: false } });
         if (!coupon) {
             throw new server_1.TRPCError({
                 code: 'NOT_FOUND',
@@ -601,14 +657,14 @@ let CouponService = class CouponService {
                     totalCouponDiscount: {
                         $sum: {
                             $toDouble: {
-                                $ifNull: ['$finance.pricing.couponDiscount', 0],
+                                $ifNull: ['$adjustedFinance.pricing.couponDiscount', 0],
                             },
                         },
                     },
                     totalSecondaryCouponDiscount: {
                         $sum: {
                             $toDouble: {
-                                $ifNull: ['$finance.pricing.secondaryCouponDiscount', 0],
+                                $ifNull: ['$adjustedFinance.pricing.secondaryCouponDiscount', 0],
                             },
                         },
                     },
@@ -680,6 +736,11 @@ let CouponService = class CouponService {
         if (coupon.couponType == enum_1.CouponType.REFERRAL_CODE && !isNewUser) {
             this.throwBadRequest('This coupon is valid for new users only');
         }
+        if (coupon.couponType == enum_1.CouponType.REFERRAL_CODE) {
+            if (coupon.referralUser.toString() == user) {
+                this.throwBadRequest('You cannot add your own referral code');
+            }
+        }
         const typedCoupon = coupon;
         if (this.isCouponExpired(typedCoupon)) {
             this.throwBadRequest('This coupon has expired and cannot be added');
@@ -687,7 +748,7 @@ let CouponService = class CouponService {
         if (typedCoupon.forNewUserOnly && !isNewUser) {
             this.throwBadRequest('This coupon is valid for new users only');
         }
-        const alreadyApplied = await this.hasUserAlreadyAppliedCoupon(user, typedCoupon._id);
+        const alreadyApplied = await this.hasUserAlreadyAppliedCoupon(user, typedCoupon);
         if (alreadyApplied) {
             this.throwBadRequest('Coupon already applied to user');
         }
@@ -699,18 +760,13 @@ let CouponService = class CouponService {
         await this.userModel.findByIdAndUpdate(user, { $push: { coupons: typedCoupon._id } }, { new: true, runValidators: true });
         return coupon;
     }
-    async hasUserAlreadyAppliedCoupon(userId, couponId) {
-        const user = await this.userModel.findById(userId).select('coupons');
-        if (!user) {
-            throw new server_1.TRPCError({
-                code: 'NOT_FOUND',
-                message: 'User not found',
-            });
-        }
-        return (user.coupons?.some((c) => {
-            const id = (c?._id ?? c)?.toString();
-            return id === couponId.toString();
-        }) ?? false);
+    async hasUserAlreadyAppliedCoupon(userId, coupon) {
+        const couponIds = [coupon._id, ...(coupon.previousVersions ?? []).map(v => v._id)];
+        const user = await this.userModel.exists({
+            _id: userId,
+            coupons: { $in: couponIds },
+        });
+        return !!user;
     }
     async exchangeCouponForMultipleUser(query, oldCoupon, newCoupon) {
         await this.removeCouponFromMultipleUser(query, oldCoupon);
@@ -738,6 +794,7 @@ let CouponService = class CouponService {
                 code: 1,
                 status: 1,
                 createdAt: 1,
+                couponType: 1,
             };
             let isExpiredField = null;
             if (query.status) {
@@ -779,7 +836,15 @@ let CouponService = class CouponService {
                         isExpired: {
                             $cond: {
                                 if: {
-                                    $or: [{ $lt: ['$duration.end', new Date()] }, { $ifNull: ['$expirationReason', false] }],
+                                    $or: [
+                                        {
+                                            $and: [
+                                                { $ifNull: ['$duration.end', false] },
+                                                { $lt: ['$duration.end', (0, dayjs_1.dayjs)().toDate()] },
+                                            ],
+                                        },
+                                        { $ifNull: ['$expirationReason', false] },
+                                    ],
                                 },
                                 then: true,
                                 else: false,
@@ -830,17 +895,22 @@ let CouponService = class CouponService {
         }
     }
     async addExistingCouponsToNewUser(userId) {
-        const coupons = await this.baseCouponModel.find({
+        const isNewUser = await helper_service_1.couponHelperService.isNewUser(userId);
+        const query = {
             couponType: { $in: [enum_1.CouponType.GLOBAL, enum_1.CouponType.INDIVIDUAL_STORE, enum_1.CouponType.SHOPS_CATEGORIES] },
             deletedAt: null,
             expirationReason: null,
             $or: [
-                { 'duration.end': { $gt: new Date() } },
+                { 'duration.end': { $gt: (0, dayjs_1.dayjs)().toDate() } },
                 { 'duration.end': { $exists: false } },
                 { 'duration.end': null },
             ],
             updatedVersion: { $exists: false },
-        });
+        };
+        if (!isNewUser) {
+            query.forNewUserOnly = { $ne: true };
+        }
+        const coupons = await this.baseCouponModel.find(query);
         const couponIds = coupons.map(coupon => coupon._id);
         await this.userModel.findByIdAndUpdate(userId, {
             $addToSet: {