@infrab4a/connect-angular 0.17.0-beta.2 → 0.17.0-beta.3

package/bundles/infrab4a-connect-angular.umd.js

@@ -414,17 +414,18 @@
     }(Error));
 
     var CouponService = /** @class */ (function () {
-        function CouponService(couponRepository, defaultShop, orderRepository) {
+        function CouponService(couponRepository, defaultShop, orderRepository, subscriptionRepository) {
             var _this = this;
             this.couponRepository = couponRepository;
             this.defaultShop = defaultShop;
             this.orderRepository = orderRepository;
+            this.subscriptionRepository = subscriptionRepository;
             this.emailIsFromCollaborator = function (userEmail) { return !!(userEmail === null || userEmail === void 0 ? void 0 : userEmail.match(/@b4a.com.br/g)); };
             this.separateValidCoupons = function (coupons, userEmail) { return coupons
                 .map(function (coupon) {
                 try {
                     if (!(coupon instanceof i2.Coupon))
-                        throw new InvalidCouponError('Coupon is not valid');
+                        throw new InvalidCouponError('Cupom inválido.');
                     if (_this.isValidCoupon(coupon, userEmail))
                         return coupon;
                 }
@@ -439,61 +440,67 @@
                 invalids: [],
             }); };
         }
-        CouponService.prototype.checkCoupon = function (nickname, userEmail, checkoutType, plan, checkout) {
+        CouponService.prototype.checkCoupon = function (nickname, userEmail, checkoutType, plan, checkout, isSubscription) {
             var _this = this;
             return rxjs.from(this.couponRepository.find([
                 {
                     nickname: { operator: i2.Where.EQUALS, value: nickname },
                 },
-            ])).pipe(operators.concatMap(function (coupons) { return _this.checkCouponRules(coupons, checkoutType, plan, checkout); }), operators.concatMap(function (coupon) { return _this.checkCouponUseLimit(coupon, userEmail); }), operators.map(function (coupon) { return _this.isValidCoupon(coupon, userEmail); }), operators.map(function (coupon) { return coupon; }));
+            ])).pipe(operators.concatMap(function (coupons) { return _this.checkCouponRules(coupons, checkoutType, plan, checkout, isSubscription); }), operators.concatMap(function (coupon) { return _this.checkCouponUseLimit(coupon, userEmail); }), operators.map(function (coupon) { return _this.isValidCoupon(coupon, userEmail); }), operators.map(function (coupon) { return coupon; }));
         };
         CouponService.prototype.isValidCoupon = function (coupon, userEmail) {
             // Verifica se o email do usuário é coorporativo
             if (!this.emailIsFromCollaborator(userEmail) && coupon.exclusivityType === i2.Exclusivities.COLLABORATORS)
-                throw new InvalidCouponError('User is not a collaborator');
+                throw new InvalidCouponError('Você não é colaborador.');
             // Verifica se o email do usuário é associado ao cupom de uso por usuario
             if (coupon.exclusivityType === i2.Exclusivities.SPECIFIC_USER && coupon.userExclusiveEmail !== userEmail)
-                throw new InvalidCouponError('Coupon is not valid for user');
+                throw new InvalidCouponError('Cupom não é válido para este usuário.');
             // Verifica a data de inicio de validade do cupom
             if ((coupon === null || coupon === void 0 ? void 0 : coupon.beginAt) > new Date())
-                throw new InvalidCouponError('Coupon not avaliable yet');
+                throw new InvalidCouponError('Cupom inválido.');
             // Verifica a data de validade do cupom
             if ((coupon === null || coupon === void 0 ? void 0 : coupon.expiresIn) < new Date())
-                throw new InvalidCouponError('Coupon is expired');
+                throw new InvalidCouponError('Cupom expirado.');
             return coupon;
         };
-        CouponService.prototype.checkCouponRules = function (coupons, checkoutType, plan, checkout) {
+        CouponService.prototype.checkCouponRules = function (coupons, checkoutType, plan, checkout, isSubscription) {
             // Caso não ache nenhum cupom, retorna erro
             if (coupons.count < 1)
-                return rxjs.throwError(function () { return new i2.NotFoundError('Coupon not found'); });
+                return rxjs.throwError('Cupom inválido.');
             // Get Primeiro Cupom (o find do repository retorna um array)
             var coupon = coupons.data.shift();
             // Verifica se o cupom é aplicavel na loja
             var isInShop = coupon.shopAvailability === i2.Shops.ALL || coupon.shopAvailability === this.defaultShop;
             // Cupon não aplicavel a loja retorna erro
             if (!isInShop)
-                return rxjs.throwError(function () { return new InvalidCouponError('Coupon not correct shop'); });
+                return rxjs.throwError('Cupom inválido.');
             // Verifica se o coupon é aplicado no checkout que está sendo realizado
             var isCheckoutType = coupon.checkoutType === i2.CheckoutTypes.ALL || coupon.checkoutType === checkoutType;
             // Cupon não aplicavel ao checkout retorna erro
             if (!isCheckoutType)
-                return rxjs.throwError(function () { return new InvalidCouponError('Coupon not correct checkout'); });
+                return rxjs.throwError('Cupom inválido.');
             // Verifica se o cupom é ou pode ser aplicado para subscription
             if (checkoutType === i2.CheckoutTypes.ALL || checkoutType === i2.CheckoutTypes.SUBSCRIPTION) {
                 // Se o cupom tiver um plano associado, verifica se é o mesmo plano do checkout da assinatura
+                console.log('1', coupon.plan, plan.toUpperCase());
                 if (coupon.plan && coupon.plan.toUpperCase() !== plan.toUpperCase())
-                    return rxjs.throwError(function () { return new InvalidCouponError('Coupon not valid for this plan'); });
+                    return rxjs.throwError('Cupom inválido.');
             }
+            if (isSubscription)
+                return rxjs.of(coupon);
             // Verifica se possui o valor minimo de compra para utilização do cupom
             var hasMinSubTotal = this.hasMinSubTotal(coupon, checkout);
             // Se não tem valor mínimo atingido, retorna erro
             if (!hasMinSubTotal)
-                return rxjs.throwError(function () { return new InvalidCouponError('Valor mínimo não atingido'); });
+                return rxjs.throwError('Valor mínimo não atingido');
             // Verifica se a compra possui produtos elegíveis para desconto
             var hasProductCategories = this.hasProductCategories(coupon, checkout);
             // Se não tem produtos elegíveis, retorna erro
             if (!hasProductCategories)
-                return rxjs.throwError(function () { return new InvalidCouponError('Checkout não possui produtos elegíveis para desconto'); });
+                return rxjs.throwError('Seu carrinho não possui produtos elegíveis para desconto.');
+            // const validUser = this.userSubscriberStatus(coupon, checkout)
+            // console.log(validUser)
+            // if (!validUser) return throwError('Usuário não elegível.')
             return rxjs.of(coupon);
         };
         CouponService.prototype.checkCouponUseLimit = function (coupon, userEmail) {
@@ -507,10 +514,10 @@
                             ordersUserCoupon = orders.data.filter(function (o) { return o.user.email == userEmail; });
                             // Verifica o limite de uso de cupom por usuario
                             if (coupon.useLimitPerUser && ordersUserCoupon.length)
-                                throw new InvalidCouponError('Coupon user use limit reached');
+                                throw new InvalidCouponError('Limite de uso por usuário atingido.');
                             // Verifica o limite de uso geral por usuario
                             if (coupon.useLimit && orders.data.length >= coupon.useLimit)
-                                throw new InvalidCouponError('Coupon use limit reached');
+                                throw new InvalidCouponError('Limite de uso atingido.');
                             return [2 /*return*/, coupon];
                     }
                 });
@@ -544,8 +551,14 @@
             var discount = 0;
             var shop = checkout.shop;
             var lineItensDiscount = [];
-            if (coupon.productsCategories) {
-                lineItensDiscount = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.filter(function (i) { return i.categories.some(function (c) { return coupon.productsCategories.includes(c); }); });
+            if (coupon.productsCategories && coupon.productsCategories.length) {
+                lineItensDiscount = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.filter(function (i) {
+                    var _a;
+                    if ((_a = i.categories) === null || _a === void 0 ? void 0 : _a.length) {
+                        return i.categories.some(function (c) { return coupon.productsCategories.includes(c); });
+                    }
+                    return true;
+                });
             }
             else {
                 lineItensDiscount = checkout.lineItems;
@@ -576,17 +589,56 @@
         };
         CouponService.prototype.hasProductCategories = function (coupon, checkout) {
             var _a;
-            if (coupon.productsCategories) {
-                var hasCategories = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.filter(function (i) { return i.categories.some(function (c) { return coupon.productsCategories.includes(c); }); });
-                return hasCategories ? true : false;
+            if (coupon.productsCategories && coupon.productsCategories.length) {
+                var hasCategories = (_a = checkout.lineItems) === null || _a === void 0 ? void 0 : _a.filter(function (i) {
+                    var _a;
+                    if ((_a = i.categories) === null || _a === void 0 ? void 0 : _a.length) {
+                        return i.categories.some(function (c) { return coupon.productsCategories.includes(c); });
+                    }
+                    return true;
+                });
+                return hasCategories.length ? true : false;
             }
             else {
                 return true;
             }
         };
+        CouponService.prototype.userSubscriberStatus = function (coupon, checkout) {
+            return __awaiter(this, void 0, void 0, function () {
+                var sub, active;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0: return [4 /*yield*/, this.subscriptionRepository
+                                .find([
+                                {
+                                    user: {
+                                        email: { operator: i2.Where.EQUALS, value: checkout.user.email },
+                                    },
+                                },
+                            ])
+                                .then(function (sub) { return sub.data; })];
+                        case 1:
+                            sub = _d.sent();
+                            active = sub === null || sub === void 0 ? void 0 : sub.filter(function (s) { return s.status === i2.Status.ACTIVE; });
+                            console.log("active", active, active.length, sub);
+                            switch (coupon.exclusivityType) {
+                                case i2.Exclusivities.ACTIVE_SUBSCRIBER:
+                                    return [2 /*return*/, active.length > 0];
+                                case i2.Exclusivities.INACTIVE_SUBSCRIBER:
+                                    return [2 /*return*/, active.length === 0];
+                                case i2.Exclusivities.NON_SUBSCRIBER:
+                                    return [2 /*return*/, sub.length === 0];
+                                default:
+                                    return [2 /*return*/, false];
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
         return CouponService;
     }());
-    CouponService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.12", ngImport: i0__namespace, type: CouponService, deps: [{ token: 'CouponRepository' }, { token: DEFAULT_SHOP }, { token: 'OrderRepository' }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
+    CouponService.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.12", ngImport: i0__namespace, type: CouponService, deps: [{ token: 'CouponRepository' }, { token: DEFAULT_SHOP }, { token: 'OrderRepository' }, { token: 'SubscriptionRepository' }], target: i0__namespace.ɵɵFactoryTarget.Injectable });
     CouponService.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.12", ngImport: i0__namespace, type: CouponService, providedIn: 'root' });
     i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.12", ngImport: i0__namespace, type: CouponService, decorators: [{
                 type: i0.Injectable,
@@ -603,6 +655,9 @@
                         }] }, { type: undefined, decorators: [{
                             type: i0.Inject,
                             args: ['OrderRepository']
+                        }] }, { type: undefined, decorators: [{
+                            type: i0.Inject,
+                            args: ['SubscriptionRepository']
                         }] }];
         } });
 
@@ -640,7 +695,12 @@
         };
         CheckoutService.prototype.checkCoupon = function (nickname, checkoutType) {
             var _this = this;
-            return this.getCheckout().pipe(operators.concatMap(function (checkout) { var _a; return _this.couponService.checkCoupon(nickname, (_a = checkout.user) === null || _a === void 0 ? void 0 : _a.email, i2.CheckoutTypes.ECOMMERCE).pipe(); }));
+            return this.getCheckout().pipe(operators.concatMap(function (checkout) {
+                var _a;
+                return _this.couponService
+                    .checkCoupon(nickname, (_a = checkout.user) === null || _a === void 0 ? void 0 : _a.email, i2.CheckoutTypes.ECOMMERCE, checkout.user.subscriptionPlan, checkout, false)
+                    .pipe();
+            }));
         };
         CheckoutService.prototype.createCheckout = function (checkoutData) {
             return __awaiter(this, void 0, void 0, function () {
@@ -866,22 +926,7 @@
         };
         CheckoutSubscriptionService.prototype.checkCoupon = function (nickname, userEmail) {
             var _this = this;
-            return this.getCheckoutSubscription().pipe(operators.concatMap(function (checkout) { return _this.couponService.checkCoupon(nickname, userEmail, i2.CheckoutTypes.SUBSCRIPTION, checkout.subscriptionPlan.name).pipe(); }
-            // .pipe(
-            //   concatMap((coupon: Coupon) => {
-            //     const couponsWithSamePlan = coupons.filter((coupon) => checkout.subscriptionPlan.name === coupon.plan)
-            //     const couponsWithNoPlan = coupons.filter((coupon) => !coupon.plan)
-            //     if (couponsWithSamePlan.length > 0) return of(couponsWithSamePlan)
-            //     if (couponsWithNoPlan.length > 0) return of(couponsWithNoPlan)
-            //     throw new Error(`Coupon subscription plan is invalid.`)
-            //   })
-            //   ,
-            //   concatMap((coupons) =>
-            //     !!checkout.user?.email ? this.checkCouponsWithCheckout(coupons, checkout) : of(coupons),
-            //   )
-            //   map((validatedCoupons) => validatedCoupons.shift()),
-            // ),
-            ));
+            return this.getCheckoutSubscription().pipe(operators.concatMap(function (checkout) { return _this.couponService.checkCoupon(nickname, userEmail, i2.CheckoutTypes.SUBSCRIPTION, checkout.subscriptionPlan.name, null, true).pipe(); }));
         };
         CheckoutSubscriptionService.prototype.calcDiscountSubscription = function (coupon) {
             var _this = this;