@lyxa.ai/marketing 1.0.14 → 1.0.16

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

@@ -0,0 +1,686 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.couponService = exports.CouponService = void 0;
+const typedi_1 = __importStar(require("typedi"));
+const server_1 = require("@trpc/server");
+const models_1 = require("@lyxa.ai/core/dist/libraries/mongo/models");
+const pagination_1 = require("@lyxa.ai/core/dist/utilities/pagination");
+const _1 = require(".");
+const enum_1 = require("@lyxa.ai/core/dist/utilities/enum");
+const services_1 = require("../../punch-marketing-history/services");
+const core_1 = require("@lyxa.ai/core");
+const CouponRepository_1 = require("./patterns/repository/CouponRepository");
+const normalize_1 = require("@lyxa.ai/core/dist/utilities/normalize");
+const error_common_1 = require("@lyxa.ai/core/dist/utilities/error-common");
+let CouponService = class CouponService {
+    model;
+    userModel;
+    orderModel;
+    referralRewardModel;
+    constructor() {
+        this.model = models_1.CouponModel;
+        this.userModel = models_1.UserModel;
+        this.orderModel = models_1.RegularOrderModel;
+        this.referralRewardModel = models_1.ReferralRewardCouponModel;
+    }
+    async create(data) {
+        let coupon;
+        const checkCoupon = await this.model.findOne({
+            code: data.code,
+            deletedAt: null,
+        });
+        if (checkCoupon) {
+            throw new server_1.TRPCError({
+                code: 'CONFLICT',
+                message: 'Coupon code already exists',
+            });
+        }
+        switch (data.couponType) {
+            case enum_1.CouponType.GLOBAL: {
+                coupon = await _1.globalCouponService.create(data);
+                if (coupon) {
+                    const globalCoupon = coupon;
+                    if (!globalCoupon.forNewUserOnly) {
+                        await this.assignCouponToMultipleUser({}, coupon._id);
+                    }
+                }
+                break;
+            }
+            case enum_1.CouponType.REFERRAL_CODE: {
+                coupon = await _1.referralCodeCouponService.create(data);
+                break;
+            }
+            case enum_1.CouponType.REFERRAL_REWARD: {
+                coupon = await _1.referralRewardCouponService.create(data);
+                break;
+            }
+            case enum_1.CouponType.INDIVIDUAL_STORE: {
+                coupon = await _1.individualStoreCouponService.create(data);
+                if (coupon) {
+                    const individualStoreCoupon = coupon;
+                    if (!individualStoreCoupon.forNewUserOnly) {
+                        await this.assignCouponToMultipleUser({}, coupon._id);
+                    }
+                }
+                break;
+            }
+            case enum_1.CouponType.INDIVIDUAL_USER: {
+                coupon = await _1.individualUserCouponService.create(data);
+                if (coupon) {
+                    const individualUserCoupon = coupon;
+                    const users = individualUserCoupon.users;
+                    await this.assignCouponToMultipleUser({ _id: { $in: users } }, coupon._id);
+                }
+                break;
+            }
+            case enum_1.CouponType.CUSTOM_COUPON: {
+                coupon = await _1.customCouponService.create(data);
+                break;
+            }
+            default: {
+                throw new server_1.TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: 'Coupon type is not valid',
+                });
+            }
+        }
+        if (!coupon) {
+            throw new server_1.TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: 'Could not create coupon',
+            });
+        }
+        const dispatcher = (0, core_1.getLibraries)().getMicroServiceDispatcher();
+        const notificationRouter = await dispatcher.getMicroService('notification');
+        await notificationRouter.notificationRouter.sendPushNotificationForCoupon.mutate(coupon._id);
+        return coupon;
+    }
+    async findById(id) {
+        const result = await this.model
+            .findOne({
+            _id: id,
+            deletedAt: null,
+        })
+            .populate([
+            {
+                path: 'previousVersions',
+            },
+        ]);
+        if (!result) {
+            throw new server_1.TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Record not found',
+            });
+        }
+        return result;
+    }
+    async find(data) {
+        try {
+            let query = data?.query || {};
+            const select = data?.select || {
+                _id: 1,
+                'createdBy.name': 1,
+                'duration.start': 1,
+                'duration.end': 1,
+                code: 1,
+                status: 1,
+                createdAt: 1,
+            };
+            let isExpiredField = null;
+            if (query.status) {
+                if (query.status === 'expired') {
+                    isExpiredField = true;
+                    delete query.status;
+                }
+            }
+            const pipeline = [
+                { $match: { ...query, deletedAt: null } },
+                {
+                    $lookup: {
+                        from: 'admins',
+                        localField: 'createdBy',
+                        foreignField: '_id',
+                        as: 'createdBy',
+                    },
+                },
+                { $unwind: { path: '$createdBy', preserveNullAndEmptyArrays: true } },
+                {
+                    $project: select,
+                },
+                {
+                    $addFields: {
+                        isExpired: {
+                            $cond: {
+                                if: {
+                                    $or: [{ $lt: ['$duration.end', new Date()] }, { $ifNull: ['$expirationReason', false] }],
+                                },
+                                then: true,
+                                else: false,
+                            },
+                        },
+                    },
+                },
+                {
+                    $match: isExpiredField
+                        ? { isExpired: true }
+                        : query.status === 'active'
+                            ? { isExpired: false }
+                            : {},
+                },
+            ];
+            if (data?.search?.searchKey) {
+                const searchKey = (0, normalize_1.normalizeName)(data.search.searchKey);
+                const regex = new RegExp(searchKey, 'i');
+                const fields = data.search.searchFields?.length ? data.search.searchFields : ['code'];
+                pipeline.push({
+                    $match: {
+                        $or: fields.map(field => ({ [field]: { $regex: regex } })),
+                    },
+                });
+            }
+            const results = await (0, pagination_1.paginateAggregation)(this.model, pipeline, data?.page, data?.size, data?.sort);
+            return results;
+        }
+        catch (err) {
+            throw new server_1.TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `err: ${err}`,
+            });
+        }
+    }
+    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']),
+            this.model.findOne({
+                code: data.code,
+                _id: { $ne: id },
+            }),
+        ]);
+        if (!oldCoupon) {
+            throw new server_1.TRPCError({
+                code: 'NOT_FOUND',
+                message: `Coupon not found`,
+            });
+        }
+        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);
+                    }
+                }
+                break;
+            }
+            case enum_1.CouponType.INDIVIDUAL_STORE: {
+                coupon = await _1.individualStoreCouponService.create(data);
+                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);
+                    }
+                }
+                break;
+            }
+            case enum_1.CouponType.INDIVIDUAL_USER: {
+                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);
+                    }
+                }
+                break;
+            }
+            case enum_1.CouponType.CUSTOM_COUPON: {
+                coupon = await _1.customCouponService.create(data);
+                break;
+            }
+            default: {
+                throw new server_1.TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: `Invalid coupon type`,
+                });
+            }
+        }
+        if (!coupon) {
+            throw new server_1.TRPCError({
+                code: 'BAD_REQUEST',
+                message: `Could create updated coupon`,
+            });
+        }
+        const previousVersions = oldCoupon?.previousVersions || [];
+        previousVersions.push(oldCoupon._id);
+        const updatedCoupon = await this.model.findByIdAndUpdate(coupon._id, {
+            $set: {
+                previousVersions,
+            },
+        }, {
+            new: true,
+            runValidators: true,
+        });
+        if (!updatedCoupon) {
+            throw new server_1.TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Could not set previous versions of coupon`,
+            });
+        }
+        const updatedOldCoupon = await this.model.findByIdAndUpdate(oldCoupon._id, {
+            $set: {
+                updatedVersion: coupon._id,
+            },
+        }, {
+            new: true,
+            runValidators: true,
+        });
+        return updatedCoupon;
+    }
+    async deleteById(data) {
+        const { _id, softDelete } = data;
+        const result = await this.model.deleteRecord({ _id, deletedAt: null }, softDelete);
+        if (!result) {
+            throw new server_1.TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Record not found',
+            });
+        }
+        this.removeCouponFromMultipleUser({}, _id);
+        return 'Record deleted successfully';
+    }
+    async getUserCoupons(user, page = 0, size = 0) {
+        const couponRepository = new CouponRepository_1.CouponRepository();
+        return await couponRepository.getUserCoupons(user, page, size);
+    }
+    async validateCoupon(data) {
+        if (!data.coupon) {
+            return await services_1.punchMarketingHistoryService.getPunchDiscount(data);
+        }
+        const [user, coupon] = await Promise.all([
+            this.userModel.findById(data.user),
+            this.model.findOne({ code: data.coupon }),
+        ]);
+        if (!user) {
+            throw new server_1.TRPCError({
+                code: 'NOT_FOUND',
+                message: 'User not found',
+            });
+        }
+        if (!coupon) {
+            throw new server_1.TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Coupon not found',
+            });
+        }
+        if (coupon.couponType == enum_1.CouponType.REFERRAL_CODE) {
+            return await _1.referralCodeCouponService.validateCoupon(data);
+        }
+        const baseCoupon = coupon;
+        const isValid = await this.validateBaseCoupon(baseCoupon, user._id, data.amountBeforeCoupon);
+        if (!isValid) {
+            return {
+                isValid,
+            };
+        }
+        switch (coupon.couponType) {
+            case enum_1.CouponType.REFERRAL_REWARD:
+                return await _1.referralRewardCouponService.validateCoupon(data, coupon);
+            case enum_1.CouponType.GLOBAL:
+                return await _1.globalCouponService.validateCoupon(data, coupon);
+            case enum_1.CouponType.INDIVIDUAL_STORE:
+                return await _1.individualStoreCouponService.validateCoupon(data, coupon);
+            case enum_1.CouponType.INDIVIDUAL_USER:
+                return await _1.individualUserCouponService.validateCoupon(data, coupon);
+            case enum_1.CouponType.CUSTOM_COUPON:
+                return await _1.customCouponService.validateCoupon(data, coupon);
+            default:
+                throw new server_1.TRPCError({
+                    code: 'NOT_IMPLEMENTED',
+                    message: `Validation not implemented for ${coupon.couponType} coupons`,
+                });
+        }
+    }
+    isCouponExpired(coupon) {
+        if (coupon.expirationReason || (coupon?.duration?.end && new Date(coupon?.duration?.end) < new Date())) {
+            return true;
+        }
+        return false;
+    }
+    async validateBaseCoupon(coupon, user, orderAmount) {
+        const invalidConditions = [
+            this.isCouponExpired(coupon),
+            coupon.duration.start > new Date(),
+            coupon.minOrderValue && orderAmount < coupon.minOrderValue,
+            coupon.forNewUserOnly && !(await this.checkIfNewUser(user)),
+            coupon.orderLimitPerUser &&
+                (await this.getCouponOrdersForUser(user, coupon._id)) >= coupon.orderLimitPerUser,
+        ];
+        return invalidConditions.every(value => value == false);
+    }
+    async checkIfNewUser(user) {
+        const order = await this.orderModel.findOne({
+            user,
+            status: { ne: enum_1.RegularOrderStatus.CANCELLED },
+        });
+        return order ? false : true;
+    }
+    async getCouponOrdersForUser(user, coupon) {
+        return await this.orderModel.countDocuments({
+            status: { $ne: enum_1.RegularOrderStatus.CANCELLED },
+            'finance.coupon.coupon': coupon,
+        });
+    }
+    async updateCouponExpiry(coupon) {
+        if (coupon.totalOrderLimit) {
+            const orderCount = await this.orderModel.countDocuments({
+                status: { $ne: enum_1.RegularOrderStatus.CANCELLED },
+                'finance.coupon.coupon': coupon._id,
+            });
+            if (orderCount > coupon.totalOrderLimit) {
+                await this.model.findByIdAndUpdate(coupon._id, {
+                    $set: {
+                        expirationReason: enum_1.CouponExpirationReason.TOTAL_ORDER_LIMIT,
+                    },
+                }, {
+                    new: true,
+                    runValidators: true,
+                });
+            }
+        }
+        if (coupon.spendLimit) {
+            const { totalCouponDiscount, totalSecondaryCouponDiscount } = await this.getCouponDiscountTotals(coupon._id);
+            if (totalCouponDiscount >= coupon.spendLimit) {
+                await this.model.findByIdAndUpdate(coupon._id, {
+                    $set: {
+                        expirationReason: enum_1.CouponExpirationReason.SPEND_LIMIT,
+                    },
+                }, {
+                    new: true,
+                    runValidators: true,
+                });
+            }
+        }
+    }
+    async findCouponByCode(code) {
+        const coupon = await this.model.findOne({ code: code });
+        if (!coupon) {
+            throw new server_1.TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Coupon not found',
+            });
+        }
+        return coupon;
+    }
+    async getCouponDiscountTotals(coupon) {
+        const pipeline = [
+            {
+                $match: {
+                    status: { $ne: enum_1.RegularOrderStatus.CANCELLED },
+                    'finance.coupon.coupon': coupon,
+                },
+            },
+            {
+                $group: {
+                    _id: null,
+                    totalCouponDiscount: {
+                        $sum: {
+                            $toDouble: {
+                                $ifNull: ['$finance.pricing.couponDiscount', 0],
+                            },
+                        },
+                    },
+                    totalSecondaryCouponDiscount: {
+                        $sum: {
+                            $toDouble: {
+                                $ifNull: ['$finance.pricing.secondaryCouponDiscount', 0],
+                            },
+                        },
+                    },
+                },
+            },
+        ];
+        const result = await this.orderModel.aggregate(pipeline);
+        return {
+            totalCouponDiscount: result[0]?.totalCouponDiscount ?? 0,
+            totalSecondaryCouponDiscount: result[0]?.totalSecondaryCouponDiscount ?? 0,
+        };
+    }
+    async assignCouponToUser(user, coupon) {
+        const updatedUser = await this.userModel.findByIdAndUpdate(user, {
+            $push: {
+                coupons: coupon,
+            },
+        }, {
+            new: true,
+            runValidators: true,
+        });
+    }
+    async assignCouponToMultipleUser(query, coupon) {
+        const updatedUsers = await this.userModel.updateMany(query, {
+            $push: {
+                coupons: coupon,
+            },
+        });
+    }
+    async removeCouponFromUser(user, coupon) {
+        const updatedUser = await this.userModel.findByIdAndUpdate(user, {
+            $pull: {
+                coupons: coupon,
+            },
+        }, {
+            new: true,
+            runValidators: true,
+        });
+    }
+    async removeCouponFromMultipleUser(query, coupon) {
+        const updatedUsers = await this.userModel.updateMany(query, {
+            $pull: {
+                coupons: coupon,
+            },
+        });
+    }
+    async newUserCheck(userId) {
+        const user = await this.userModel.findById(userId).select('orderCompleted');
+        return (user?.orderCompleted ?? 0) < 1;
+    }
+    throwBadRequest(message) {
+        throw new server_1.TRPCError({
+            code: 'BAD_REQUEST',
+            message,
+        });
+    }
+    async addCouponToUser(user, couponCode) {
+        const coupon = await this.findCouponByCode(couponCode);
+        if (!coupon) {
+            this.throwBadRequest('Coupon not found');
+        }
+        const typedCoupon = coupon;
+        if (this.isCouponExpired(typedCoupon)) {
+            this.throwBadRequest('This coupon has expired and cannot be added');
+        }
+        const isNewUser = await this.newUserCheck(user);
+        if (typedCoupon.forNewUserOnly && !isNewUser) {
+            this.throwBadRequest('This coupon is valid for new users only');
+        }
+        const alreadyApplied = await this.hasUserAlreadyAppliedCoupon(user, typedCoupon._id);
+        if (alreadyApplied) {
+            this.throwBadRequest('Coupon already applied to user');
+        }
+        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 exchangeCouponForMultipleUser(query, oldCoupon, newCoupon) {
+        await this.removeCouponFromMultipleUser(query, oldCoupon);
+        await this.assignCouponToMultipleUser(query, newCoupon);
+    }
+    getShareableLink = async (code) => {
+        const secretsService = (0, core_1.getLibraries)().getSecretsService();
+        const deepLinkUrl = (await secretsService.getKey('DEEP_LINK_URL')) ?? 'https://link.lyxa.ai';
+        const link = `${deepLinkUrl}/invite/${code}`;
+        const message = `Download Lyxa and explore the wide variety of offerings and benefits! Use my code at checkout to claim a special coupon : ${code}.
+		${link}`;
+        return { link, message };
+    };
+    async getUserCouponList(data) {
+        try {
+            let query = data?.query || {};
+            if (!query.user) {
+                (0, error_common_1.badRequestError)("User ID is required in query");
+            }
+            const select = data?.select || {
+                _id: 1,
+                'createdBy.name': 1,
+                'duration.start': 1,
+                'duration.end': 1,
+                code: 1,
+                status: 1,
+                createdAt: 1,
+            };
+            let isExpiredField = null;
+            if (query.status) {
+                if (query.status === 'expired') {
+                    isExpiredField = true;
+                    delete query.status;
+                }
+            }
+            const user = await this.userModel.findById(query.user).select('coupons');
+            query._id = { $in: user?.coupons ?? [] };
+            delete query.user;
+            const pipeline = [
+                { $match: { ...query, deletedAt: null } },
+                {
+                    $lookup: {
+                        from: 'admins',
+                        localField: 'createdBy',
+                        foreignField: '_id',
+                        as: 'createdBy',
+                    },
+                },
+                { $unwind: { path: '$createdBy', preserveNullAndEmptyArrays: true } },
+                {
+                    $project: select,
+                },
+                {
+                    $addFields: {
+                        isExpired: {
+                            $cond: {
+                                if: {
+                                    $or: [{ $lt: ['$duration.end', new Date()] }, { $ifNull: ['$expirationReason', false] }],
+                                },
+                                then: true,
+                                else: false,
+                            },
+                        },
+                    },
+                },
+                {
+                    $match: isExpiredField
+                        ? { isExpired: true }
+                        : query.status === 'active'
+                            ? { isExpired: false }
+                            : {},
+                },
+            ];
+            if (data?.search?.searchKey) {
+                const searchKey = (0, normalize_1.normalizeName)(data.search.searchKey);
+                const regex = new RegExp(searchKey, 'i');
+                const fields = data.search.searchFields?.length ? data.search.searchFields : ['code'];
+                pipeline.push({
+                    $match: {
+                        $or: fields.map(field => ({ [field]: { $regex: regex } })),
+                    },
+                });
+            }
+            const results = await (0, pagination_1.paginateAggregation)(this.model, pipeline, data?.page, data?.size, data?.sort);
+            return results;
+        }
+        catch (err) {
+            throw new server_1.TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `err: ${err}`,
+            });
+        }
+    }
+};
+exports.CouponService = CouponService;
+exports.CouponService = CouponService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], CouponService);
+exports.couponService = typedi_1.default.get(CouponService);
+//# sourceMappingURL=coupon.service.js.map