@infrab4a/connect-angular 5.5.0-alpha.2 → 5.5.0-alpha.3

package/esm2022/services/checkout-subscription.service.mjs

@@ -0,0 +1,55 @@
+import { Inject, Injectable } from '@angular/core';
+import { CheckoutSubscription, CheckoutTypes, isNil, pick, } from '@infrab4a/connect';
+import { concatMap } from 'rxjs/operators';
+import { PERSISTENCE_PROVIDER } from '../consts';
+import { CouponService } from './coupon.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./coupon.service";
+export class CheckoutSubscriptionService {
+    constructor(checkoutSubscriptionRepository, dataPersistence, couponService) {
+        this.checkoutSubscriptionRepository = checkoutSubscriptionRepository;
+        this.dataPersistence = dataPersistence;
+        this.couponService = couponService;
+    }
+    getCheckoutSubscription(checkoutData) {
+        return this.dataPersistence
+            .get('checkoutSubscriptionId')
+            .pipe(concatMap((id) => !isNil(id) ? this.checkoutSubscriptionRepository.get({ id }) : this.createCheckoutSubscription(checkoutData)));
+    }
+    clearCheckoutSubscriptionFromSession() {
+        return this.dataPersistence.remove('checkoutSubscriptionId');
+    }
+    checkCoupon(nickname, _userEmail) {
+        return this.getCheckoutSubscription().pipe(concatMap((checkout) => this.couponService
+            .checkCoupon({
+            nickname,
+            checkoutType: CheckoutTypes.SUBSCRIPTION,
+            checkout,
+            plan: checkout.subscriptionPlan.name,
+        })
+            .pipe()));
+    }
+    calcDiscountSubscription(coupon) {
+        return this.getCheckoutSubscription().pipe(concatMap((checkout) => this.couponService.calcDiscountSubscription(coupon, checkout).pipe()));
+    }
+    async createCheckoutSubscription(checkoutData) {
+        const checkout = await this.checkoutSubscriptionRepository.create({
+            createdAt: new Date(),
+            ...CheckoutSubscription.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain(),
+        });
+        await this.dataPersistence.set('checkoutSubscriptionId', checkout.id).toPromise();
+        return checkout;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CheckoutSubscriptionService, deps: [{ token: 'CheckoutSubscriptionRepository' }, { token: PERSISTENCE_PROVIDER }, { token: i1.CouponService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CheckoutSubscriptionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CheckoutSubscriptionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['CheckoutSubscriptionRepository']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PERSISTENCE_PROVIDER]
+                }] }, { type: i1.CouponService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/checkout.service.mjs

@@ -0,0 +1,106 @@
+import { Injectable } from '@angular/core';
+import { Checkout, isNil, NotFoundError, pick, } from '@infrab4a/connect';
+import { from, of, throwError } from 'rxjs';
+import { concatMap, map } from 'rxjs/operators';
+import { CheckoutDependenciesFacade, CheckoutRepositoriesFacade } from './checkout';
+import { ConfigurationFacade } from './shared';
+import * as i0 from "@angular/core";
+import * as i1 from "./checkout";
+import * as i2 from "./shared";
+export class CheckoutService {
+    constructor(repositoriesFacade, dependenciesFacade, configurationFacade) {
+        this.repositoriesFacade = repositoriesFacade;
+        this.dependenciesFacade = dependenciesFacade;
+        this.configurationFacade = configurationFacade;
+        this.checkoutUrl = null;
+        this.checkoutUrl = this.configurationFacade.getCheckoutUrl();
+    }
+    getCheckout(checkoutData) {
+        return this.dependenciesFacade.dataPersistence
+            .get('checkoutId')
+            .pipe(concatMap((id) => !isNil(id) ? this.repositoriesFacade.checkoutRepository.get({ id }) : this.createCheckout(checkoutData)));
+    }
+    getUserByCheckout(checkoutId) {
+        return from(this.repositoriesFacade.checkoutRepository.get({ id: checkoutId })).pipe(concatMap((checkout) => checkout?.user?.id
+            ? of(checkout.user)
+            : from(this.repositoriesFacade.userRepository.get({ id: checkout.user.id }))), concatMap((user) => of(user) || throwError(() => new NotFoundError('User is not found'))));
+    }
+    updateCheckoutLineItems(checkout) {
+        return from(this.repositoriesFacade.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, lineItems: checkout.lineItems })));
+    }
+    updateCheckoutUser(checkout) {
+        return from(this.repositoriesFacade.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, user: checkout.user })));
+    }
+    clearCheckoutFromSession() {
+        return this.dependenciesFacade.dataPersistence.remove('checkoutId');
+    }
+    resetCheckoutValues() {
+        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutResetValues`, {
+            checkoutId: checkout.id,
+        })), concatMap(() => this.getCheckout()));
+    }
+    applyCouponDiscount(nickname, checkoutType) {
+        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutApplyDiscount`, {
+            checkoutId: checkout.id,
+            coupon: nickname,
+            checkoutType,
+        })), concatMap(() => this.getCheckout()), map((checkout) => checkout.coupon));
+    }
+    removeCouponDiscount() {
+        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutRemoveDiscount`, {
+            checkoutId: checkout.id,
+        })), concatMap(() => this.getCheckout()));
+    }
+    validateStockProducts() {
+        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutValidateProductStock`, {
+            checkoutId: checkout.id,
+        })));
+    }
+    selectShippingAddress(address) {
+        return this.getCheckout().pipe(concatMap((checkout) => {
+            return this.repositoriesFacade.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, shippingAddress: address, billingAddress: address }));
+        }));
+    }
+    getAvailableShippingForProduct(productShipping) {
+        return this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutGetAvailableShipping`, {
+            checkoutId: null,
+            productShipping,
+        });
+    }
+    getAvailableShippingForCheckout() {
+        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutGetAvailableShipping`, {
+            checkoutId: checkout.id,
+            productShipping: null,
+        })));
+    }
+    selectShipping(option) {
+        return this.getCheckout().pipe(concatMap((checkout) => this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutSelectShipping`, {
+            checkoutId: checkout.id,
+            shippingOption: option,
+        })), concatMap(() => this.getCheckout()));
+    }
+    createOrder(checkoutPayload, paymentProvider, applicationVersion) {
+        return this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutV5`, {
+            data: {
+                ...checkoutPayload,
+                applicationVersion,
+                paymentProvider,
+            },
+        });
+    }
+    async createCheckout(checkoutData) {
+        const checkout = await this.repositoriesFacade.checkoutRepository.create({
+            createdAt: new Date(),
+            ...Checkout.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain(),
+            shop: checkoutData?.shop || this.configurationFacade.defaultShop,
+        });
+        await this.dependenciesFacade.dataPersistence.set('checkoutId', checkout.id).toPromise();
+        return checkout;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CheckoutService, deps: [{ token: i1.CheckoutRepositoriesFacade }, { token: i1.CheckoutDependenciesFacade }, { token: i2.ConfigurationFacade }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CheckoutService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CheckoutService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.CheckoutRepositoriesFacade }, { type: i1.CheckoutDependenciesFacade }, { type: i2.ConfigurationFacade }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkout.service.js","sourceRoot":"","sources":["../../../../projects/connect-angular/src/services/checkout.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport {\n  Checkout,\n  CheckoutPayloadRequest,\n  CheckoutResponse,\n  CheckoutStockValidation,\n  CheckoutTypes,\n  Coupon,\n  isNil,\n  NotFoundError,\n  pick,\n  ShippingMethodResponse,\n  ShippingProductRequest,\n  User,\n  UserAddress,\n} from '@infrab4a/connect'\nimport { from, Observable, of, throwError } from 'rxjs'\nimport { concatMap, map } from 'rxjs/operators'\n\nimport { CheckoutDependenciesFacade, CheckoutRepositoriesFacade } from './checkout'\nimport { ConfigurationFacade } from './shared'\nimport { RequiredCheckoutData } from './types'\n\n@Injectable()\nexport class CheckoutService {\n  private checkoutUrl: string = null\n\n  constructor(\n    private readonly repositoriesFacade: CheckoutRepositoriesFacade,\n    private readonly dependenciesFacade: CheckoutDependenciesFacade,\n    private readonly configurationFacade: ConfigurationFacade,\n  ) {\n    this.checkoutUrl = this.configurationFacade.getCheckoutUrl()\n  }\n\n  getCheckout(checkoutData?: RequiredCheckoutData): Observable<Checkout> {\n    return this.dependenciesFacade.dataPersistence\n      .get('checkoutId')\n      .pipe(\n        concatMap((id) =>\n          !isNil(id) ? this.repositoriesFacade.checkoutRepository.get({ id }) : this.createCheckout(checkoutData),\n        ),\n      )\n  }\n\n  getUserByCheckout(checkoutId: string): Observable<User> {\n    return from(this.repositoriesFacade.checkoutRepository.get({ id: checkoutId })).pipe(\n      concatMap((checkout) =>\n        checkout?.user?.id\n          ? of(checkout.user)\n          : from(this.repositoriesFacade.userRepository.get({ id: checkout.user.id })),\n      ),\n      concatMap((user) => of(user) || throwError(() => new NotFoundError('User is not found'))),\n    )\n  }\n\n  updateCheckoutLineItems(checkout: Partial<Checkout>): Observable<Checkout> {\n    return from(\n      this.repositoriesFacade.checkoutRepository.update(\n        Checkout.toInstance({ id: checkout.id, lineItems: checkout.lineItems }),\n      ),\n    )\n  }\n\n  updateCheckoutUser(checkout: Partial<Checkout>): Observable<Checkout> {\n    return from(\n      this.repositoriesFacade.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, user: checkout.user })),\n    )\n  }\n\n  clearCheckoutFromSession(): Observable<void> {\n    return this.dependenciesFacade.dataPersistence.remove('checkoutId')\n  }\n\n  resetCheckoutValues(): Observable<Checkout> {\n    return this.getCheckout().pipe(\n      concatMap((checkout) =>\n        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutResetValues`, {\n          checkoutId: checkout.id,\n        }),\n      ),\n      concatMap(() => this.getCheckout()),\n    )\n  }\n\n  applyCouponDiscount(nickname: string, checkoutType: CheckoutTypes): Observable<Coupon> {\n    return this.getCheckout().pipe(\n      concatMap((checkout) =>\n        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutApplyDiscount`, {\n          checkoutId: checkout.id,\n          coupon: nickname,\n          checkoutType,\n        }),\n      ),\n      concatMap(() => this.getCheckout()),\n      map((checkout) => checkout.coupon),\n    )\n  }\n\n  removeCouponDiscount(): Observable<Checkout> {\n    return this.getCheckout().pipe(\n      concatMap((checkout) =>\n        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutRemoveDiscount`, {\n          checkoutId: checkout.id,\n        }),\n      ),\n      concatMap(() => this.getCheckout()),\n    )\n  }\n\n  validateStockProducts(): Observable<CheckoutStockValidation> {\n    return this.getCheckout().pipe(\n      concatMap((checkout) =>\n        this.dependenciesFacade.httpClient.post<{\n          valid: boolean\n          outOfStock: string[]\n          limitedStock: string[]\n        }>(`${this.checkoutUrl}/checkoutValidateProductStock`, {\n          checkoutId: checkout.id,\n        }),\n      ),\n    )\n  }\n\n  selectShippingAddress(address: UserAddress): Observable<Checkout> {\n    return this.getCheckout().pipe(\n      concatMap((checkout) => {\n        return this.repositoriesFacade.checkoutRepository.update(\n          Checkout.toInstance({ id: checkout.id, shippingAddress: address, billingAddress: address }),\n        )\n      }),\n    )\n  }\n\n  getAvailableShippingForProduct(productShipping: ShippingProductRequest): Observable<ShippingMethodResponse[]> {\n    return this.dependenciesFacade.httpClient.post<ShippingMethodResponse[]>(\n      `${this.checkoutUrl}/checkoutGetAvailableShipping`,\n      {\n        checkoutId: null,\n        productShipping,\n      },\n    )\n  }\n\n  getAvailableShippingForCheckout(): Observable<ShippingMethodResponse[]> {\n    return this.getCheckout().pipe(\n      concatMap((checkout) =>\n        this.dependenciesFacade.httpClient.post<ShippingMethodResponse[]>(\n          `${this.checkoutUrl}/checkoutGetAvailableShipping`,\n          {\n            checkoutId: checkout.id,\n            productShipping: null,\n          },\n        ),\n      ),\n    )\n  }\n\n  selectShipping(option: string): Observable<Checkout> {\n    return this.getCheckout().pipe(\n      concatMap((checkout) =>\n        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutSelectShipping`, {\n          checkoutId: checkout.id,\n          shippingOption: option,\n        }),\n      ),\n      concatMap(() => this.getCheckout()),\n    )\n  }\n\n  createOrder(\n    checkoutPayload: CheckoutPayloadRequest,\n    paymentProvider: string,\n    applicationVersion: string,\n  ): Observable<CheckoutResponse> {\n    return this.dependenciesFacade.httpClient.post<CheckoutResponse>(`${this.checkoutUrl}/checkoutV5`, {\n      data: {\n        ...checkoutPayload,\n        applicationVersion,\n        paymentProvider,\n      },\n    })\n  }\n\n  private async createCheckout(checkoutData?: RequiredCheckoutData): Promise<Checkout> {\n    const checkout = await this.repositoriesFacade.checkoutRepository.create({\n      createdAt: new Date(),\n      ...Checkout.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain(),\n      shop: checkoutData?.shop || this.configurationFacade.defaultShop,\n    })\n\n    await this.dependenciesFacade.dataPersistence.set('checkoutId', checkout.id).toPromise()\n\n    return checkout\n  }\n}\n"]}

package/esm2022/services/coupon/coupon-repositories.facade.mjs

@@ -0,0 +1,24 @@
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CouponRepositoriesFacade {
+    constructor(couponRepository, orderRepository, categoryRepository) {
+        this.couponRepository = couponRepository;
+        this.orderRepository = orderRepository;
+        this.categoryRepository = categoryRepository;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CouponRepositoriesFacade, deps: [{ token: 'CouponRepository' }, { token: 'OrderRepository' }, { token: 'CategoryRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CouponRepositoriesFacade }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CouponRepositoriesFacade, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['CouponRepository']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['OrderRepository']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['CategoryRepository']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291cG9uLXJlcG9zaXRvcmllcy5mYWNhZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0LWFuZ3VsYXIvc3JjL3NlcnZpY2VzL2NvdXBvbi9jb3Vwb24tcmVwb3NpdG9yaWVzLmZhY2FkZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQTs7QUFJbEQsTUFBTSxPQUFPLHdCQUF3QjtJQUNuQyxZQUM4QyxnQkFBa0MsRUFDbkMsZUFBZ0MsRUFDN0Isa0JBQXNDO1FBRnhDLHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBa0I7UUFDbkMsb0JBQWUsR0FBZixlQUFlLENBQWlCO1FBQzdCLHVCQUFrQixHQUFsQixrQkFBa0IsQ0FBb0I7SUFDbkYsQ0FBQzsrR0FMTyx3QkFBd0Isa0JBRXpCLGtCQUFrQixhQUNsQixpQkFBaUIsYUFDakIsb0JBQW9CO21IQUpuQix3QkFBd0I7OzRGQUF4Qix3QkFBd0I7a0JBRHBDLFVBQVU7OzBCQUdOLE1BQU07MkJBQUMsa0JBQWtCOzswQkFDekIsTUFBTTsyQkFBQyxpQkFBaUI7OzBCQUN4QixNQUFNOzJCQUFDLG9CQUFvQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5pbXBvcnQgeyBDYXRlZ29yeVJlcG9zaXRvcnksIENvdXBvblJlcG9zaXRvcnksIE9yZGVyUmVwb3NpdG9yeSB9IGZyb20gJ0BpbmZyYWI0YS9jb25uZWN0J1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgQ291cG9uUmVwb3NpdG9yaWVzRmFjYWRlIHtcbiAgY29uc3RydWN0b3IoXG4gICAgQEluamVjdCgnQ291cG9uUmVwb3NpdG9yeScpIHB1YmxpYyByZWFkb25seSBjb3Vwb25SZXBvc2l0b3J5OiBDb3Vwb25SZXBvc2l0b3J5LFxuICAgIEBJbmplY3QoJ09yZGVyUmVwb3NpdG9yeScpIHB1YmxpYyByZWFkb25seSBvcmRlclJlcG9zaXRvcnk6IE9yZGVyUmVwb3NpdG9yeSxcbiAgICBASW5qZWN0KCdDYXRlZ29yeVJlcG9zaXRvcnknKSBwdWJsaWMgcmVhZG9ubHkgY2F0ZWdvcnlSZXBvc2l0b3J5OiBDYXRlZ29yeVJlcG9zaXRvcnksXG4gICkge31cbn1cbiJdfQ==

package/esm2022/services/coupon/index.mjs

@@ -0,0 +1,2 @@
+export { CouponRepositoriesFacade } from './coupon-repositories.facade';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0LWFuZ3VsYXIvc3JjL3NlcnZpY2VzL2NvdXBvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IENvdXBvblJlcG9zaXRvcmllc0ZhY2FkZSB9IGZyb20gJy4vY291cG9uLXJlcG9zaXRvcmllcy5mYWNhZGUnXG4iXX0=

package/esm2022/services/coupon/types/coupon-params.type.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291cG9uLXBhcmFtcy50eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29ubmVjdC1hbmd1bGFyL3NyYy9zZXJ2aWNlcy9jb3Vwb24vdHlwZXMvY291cG9uLXBhcmFtcy50eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGVja291dCwgQ2hlY2tvdXRUeXBlcywgQ291cG9uIH0gZnJvbSAnQGluZnJhYjRhL2Nvbm5lY3QnXG5cbmV4cG9ydCB0eXBlIENoZWNrQ291cG9uUGFyYW1zID0ge1xuICBuaWNrbmFtZTogc3RyaW5nXG4gIGNoZWNrb3V0VHlwZTogQ2hlY2tvdXRUeXBlc1xuICBjaGVja291dDogUGFydGlhbDxDaGVja291dD5cbiAgcGxhbjogc3RyaW5nXG59XG5cbmV4cG9ydCB0eXBlIENvdXBvblJ1bGVzVmFsaWRhdGlvblBhcmFtcyA9IHtcbiAgY291cG9uOiBDb3Vwb25cbiAgY2hlY2tvdXRUeXBlOiBDaGVja291dFR5cGVzXG4gIGNoZWNrb3V0OiBQYXJ0aWFsPENoZWNrb3V0PlxuICBwbGFuOiBzdHJpbmdcbn1cbiJdfQ==

package/esm2022/services/coupon.service.mjs

@@ -0,0 +1,248 @@
+import { Injectable } from '@angular/core';
+import { CheckoutTypes, CouponTypes, Exclusivities, OrderStatus, Shops, Where, } from '@infrab4a/connect';
+import { from, of } from 'rxjs';
+import { concatMap, map } from 'rxjs/operators';
+import { CouponRepositoriesFacade } from './coupon';
+import { ConfigurationFacade } from './shared';
+import * as i0 from "@angular/core";
+import * as i1 from "./coupon";
+import * as i2 from "./shared";
+export class CouponService {
+    constructor(repositoriesFacade, configurationFacade) {
+        this.repositoriesFacade = repositoriesFacade;
+        this.configurationFacade = configurationFacade;
+        this.emailIsFromCollaborator = (userEmail) => !!userEmail?.match(/@b4a.com.br/g);
+    }
+    checkCoupon(params) {
+        const { nickname, checkoutType, checkout, plan } = params;
+        return from(this.repositoriesFacade.couponRepository
+            .find({
+            filters: {
+                nickname: { operator: Where.EQUALS, value: nickname },
+                active: { operator: Where.EQUALS, value: true },
+            },
+        })
+            .then((result) => result.data[0])).pipe(concatMap((coupon) => this.couponValidation(coupon, checkoutType)), concatMap((couponValid) => this.couponRulesValidation({ coupon: couponValid, checkoutType, checkout, plan })), map((couponValidated) => couponValidated));
+    }
+    async couponValidation(coupon, checkoutType) {
+        if (!coupon)
+            throw 'Cupom inválido.';
+        if (coupon?.beginAt && coupon?.beginAt.getTime() > new Date().getTime())
+            throw 'Cupom inválido.';
+        if (coupon?.expiresIn && (coupon?.expiresIn).getTime() < new Date().getTime())
+            throw 'Cupom expirado.';
+        const isInShop = coupon.shopAvailability === Shops.ALL || coupon.shopAvailability === this.configurationFacade.defaultShop;
+        if (!isInShop)
+            throw 'Cupom inválido para loja.';
+        const isCheckoutType = coupon.checkoutType === CheckoutTypes.ALL || coupon.checkoutType === checkoutType;
+        if (!isCheckoutType)
+            throw 'Cupom inválido. Erro de checkout.';
+        return coupon;
+    }
+    async couponRulesValidation(params) {
+        const { coupon, checkoutType, checkout, plan } = params;
+        if (checkoutType == CheckoutTypes.SUBSCRIPTION) {
+            return this.validateSubscriptionCoupon(coupon, plan);
+        }
+        return this.validateEcommerceCoupon(coupon, checkoutType, checkout);
+    }
+    validateSubscriptionCoupon(coupon, plan) {
+        if (coupon.plan && coupon.plan.toUpperCase() !== plan.toUpperCase()) {
+            throw 'Cupom inválido para sua assinatura.';
+        }
+        return coupon;
+    }
+    async validateEcommerceCoupon(coupon, checkoutType, checkout) {
+        this.validateUserEligibility(coupon, checkout?.user);
+        await this.validateUsageLimits(coupon, checkoutType, checkout);
+        await this.validateProductEligibility(coupon, checkout);
+        return coupon;
+    }
+    validateUserEligibility(coupon, user) {
+        const validUser = this.coupomUserValidation(coupon, user);
+        if (!validUser)
+            throw 'Usuário não elegível.';
+    }
+    async validateUsageLimits(coupon, checkoutType, checkout) {
+        const couponUseLimits = this.getCouponUseLimits(coupon, checkoutType, checkout.user);
+        if (couponUseLimits.firstOrder) {
+            await this.validateFirstOrderLimit(checkout.user.email);
+        }
+        if (!couponUseLimits.unlimited || couponUseLimits.limitedPerUser) {
+            await this.validateCouponUsageLimits(coupon, couponUseLimits, checkout.user.email);
+        }
+    }
+    async validateFirstOrderLimit(userEmail) {
+        const ordersUser = await this.getOrdersFromUser(userEmail.toLocaleLowerCase());
+        if (ordersUser.length >= 1)
+            throw 'Limite de uso atingido';
+    }
+    async validateCouponUsageLimits(coupon, couponUseLimits, userEmail) {
+        const ordersCoupon = await this.getOrdersWithCoupon(coupon);
+        if (!couponUseLimits.unlimited && couponUseLimits.total && ordersCoupon.length >= couponUseLimits.total) {
+            throw 'Limite de uso atingido.';
+        }
+        if (couponUseLimits.limitedPerUser) {
+            const ordersWithUser = this.countOrdersWithUser(ordersCoupon, userEmail);
+            if (ordersWithUser > 0)
+                throw 'Limite de uso por usuário atingido.';
+        }
+    }
+    async validateProductEligibility(coupon, checkout) {
+        const hasProductCategories = await this.hasProductCategories(coupon, checkout);
+        if (!hasProductCategories)
+            throw 'Seu carrinho não possui produtos elegíveis para desconto.';
+        const hasMinSubTotal = await this.hasMinSubTotal(coupon, checkout);
+        if (!hasMinSubTotal) {
+            this.throwMinSubTotalError(coupon);
+        }
+    }
+    throwMinSubTotalError(coupon) {
+        const formattedValue = Intl.NumberFormat('pt-BR', {
+            style: 'currency',
+            currency: 'BRL',
+        }).format(coupon.minSubTotalValue);
+        if (coupon.productsCategories?.length) {
+            throw `Valor mínimo de ${formattedValue} não atingido na(s) categoria(s) elegíveis para o desconto.`;
+        }
+        throw `Valor mínimo de ${formattedValue} não atingido.`;
+    }
+    calcDiscountSubscription(coupon, checkout) {
+        let discount = 0;
+        if (coupon.discount.subscription.type == CouponTypes.ABSOLUTE)
+            discount = coupon.discount.subscription.value;
+        else
+            discount = checkout.subscriptionPlan.recurrencePrice * (coupon.discount.subscription.value / 100);
+        return of(discount);
+    }
+    async hasMinSubTotal(coupon, checkout) {
+        if (!coupon.minSubTotalValue)
+            return true;
+        const lineItensDiscount = await this.getLineItensEligebleForDiscount(coupon.productsCategories, checkout);
+        const subTotal = this.calcCheckoutSubtotal(lineItensDiscount, checkout.user);
+        if (coupon.minSubTotalValue <= subTotal)
+            return true;
+        return false;
+    }
+    async hasProductCategories(coupon, checkout) {
+        if (!coupon.productsCategories?.length) {
+            return true;
+        }
+        const couponCategories = await this.getCouponCategoriesId(coupon.productsCategories);
+        const hasCategories = checkout.lineItems?.filter((item) => {
+            if (item.isGift)
+                return false;
+            if (!item.categories?.length)
+                return true;
+            return item.categories.some((c) => couponCategories.some((cat) => cat == c));
+        });
+        return hasCategories?.length ? true : false;
+    }
+    coupomUserValidation(coupon, user) {
+        if (!user || coupon.exclusivityType.includes(Exclusivities.ALL_USERS))
+            return true;
+        const userTypes = [];
+        if (coupon.exclusivityType.includes(Exclusivities.COLLABORATORS) &&
+            this.emailIsFromCollaborator(user.email.toLocaleLowerCase()))
+            userTypes.push(Exclusivities.COLLABORATORS);
+        if (coupon.exclusivityType.includes(Exclusivities.SPECIFIC_USER) &&
+            coupon.userExclusiveEmail.includes(user.email.toLocaleLowerCase()))
+            userTypes.push(Exclusivities.SPECIFIC_USER);
+        if (coupon.exclusivityType.includes(Exclusivities.ACTIVE_SUBSCRIBER) &&
+            user.isSubscriber &&
+            user.subscriptionPlan != '')
+            userTypes.push(Exclusivities.ACTIVE_SUBSCRIBER);
+        if (user.isSubscriber &&
+            user.subscriptionPlan == '' &&
+            coupon.exclusivityType.includes(Exclusivities.INACTIVE_SUBSCRIBER))
+            userTypes.push(Exclusivities.INACTIVE_SUBSCRIBER);
+        if (coupon.exclusivityType.includes(Exclusivities.NON_SUBSCRIBER) && !user.isSubscriber)
+            userTypes.push(Exclusivities.NON_SUBSCRIBER);
+        return coupon.exclusivityType.some((r) => userTypes.includes(r));
+    }
+    async getCouponCategoriesId(productsCategories) {
+        const couponCategories = [];
+        for (let index = 0; index < productsCategories.length; index++) {
+            const category = await this.repositoriesFacade.categoryRepository.get({
+                id: productsCategories[index],
+            });
+            if (category) {
+                const children = await this.repositoriesFacade.categoryRepository.getChildren(parseInt(productsCategories[index]));
+                couponCategories.push(category.id, ...children.map((c) => c.id.toString()));
+            }
+        }
+        return [...new Set(couponCategories)];
+    }
+    async getLineItensEligebleForDiscount(productsCategories, checkout) {
+        let lineItensDiscount = [];
+        const couponCategories = await this.getCouponCategoriesId(productsCategories);
+        if (productsCategories?.length) {
+            lineItensDiscount = checkout.lineItems?.filter((item) => {
+                if (item.isGift)
+                    return false;
+                if (item.categories?.length) {
+                    return item.categories.some((c) => couponCategories.some((cat) => cat == c));
+                }
+                return true;
+            });
+        }
+        else {
+            lineItensDiscount = checkout.lineItems.filter((item) => !item.isGift);
+        }
+        return lineItensDiscount;
+    }
+    calcCheckoutSubtotal(lineItens, user) {
+        return (lineItens
+            ?.filter((item) => !item.isGift)
+            .reduce((acc, curr) => user?.isSubscriber && curr.price?.subscriberPrice
+            ? acc + curr.price?.subscriberPrice * curr.quantity
+            : acc + curr.pricePaid * curr.quantity, 0) || 0);
+    }
+    async getOrdersWithCoupon(coupon) {
+        return await this.repositoriesFacade.orderRepository
+            .find({
+            filters: {
+                coupon: { id: coupon.id },
+                status: { operator: Where.NOTEQUALS, value: OrderStatus.CANCELADO },
+            },
+        })
+            .then((result) => result.data);
+    }
+    async getOrdersFromUser(email) {
+        return await this.repositoriesFacade.orderRepository
+            .find({
+            filters: {
+                user: { email: { operator: Where.EQUALS, value: email } },
+                status: { operator: Where.NOTEQUALS, value: OrderStatus.CANCELADO },
+            },
+        })
+            .then((result) => result.data);
+    }
+    countOrdersWithUser(orders, email) {
+        return orders.filter((o) => o.user.email == email).length;
+    }
+    getCouponUseLimits(coupon, checkoutType, user) {
+        let couponUseLimits;
+        if (checkoutType == CheckoutTypes.ECOMMERCE || checkoutType == CheckoutTypes.ALL) {
+            if (coupon.exclusivityType.length === 1 &&
+                (coupon.exclusivityType.at(0) === Exclusivities.SPECIFIC_USER ||
+                    coupon.exclusivityType.at(0) === Exclusivities.COLLABORATORS))
+                couponUseLimits = coupon.useLimits.non_subscriber;
+            else
+                couponUseLimits = user?.isSubscriber ? coupon.useLimits.subscriber : coupon.useLimits.non_subscriber;
+        }
+        else {
+            couponUseLimits = coupon.useLimits.subscription;
+        }
+        return couponUseLimits;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CouponService, deps: [{ token: i1.CouponRepositoriesFacade }, { token: i2.ConfigurationFacade }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CouponService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CouponService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.CouponRepositoriesFacade }, { type: i2.ConfigurationFacade }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"coupon.service.js","sourceRoot":"","sources":["../../../../projects/connect-angular/src/services/coupon.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport {\n  Category,\n  Checkout,\n  CheckoutSubscription,\n  CheckoutTypes,\n  Coupon,\n  CouponTypes,\n  Exclusivities,\n  LineItem,\n  Order,\n  OrderStatus,\n  Shops,\n  User,\n  Where,\n} from '@infrab4a/connect'\nimport { from, Observable, of } from 'rxjs'\nimport { concatMap, map } from 'rxjs/operators'\n\nimport { CouponRepositoriesFacade } from './coupon'\nimport { CheckCouponParams, CouponRulesValidationParams } from './coupon/types/coupon-params.type'\nimport { ConfigurationFacade } from './shared'\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CouponService {\n  constructor(\n    private readonly repositoriesFacade: CouponRepositoriesFacade,\n    private readonly configurationFacade: ConfigurationFacade,\n  ) {}\n\n  checkCoupon(params: CheckCouponParams): Observable<Coupon> {\n    const { nickname, checkoutType, checkout, plan } = params\n\n    return from(\n      this.repositoriesFacade.couponRepository\n        .find({\n          filters: {\n            nickname: { operator: Where.EQUALS, value: nickname },\n            active: { operator: Where.EQUALS, value: true },\n          },\n        })\n        .then((result) => result.data[0]),\n    ).pipe(\n      concatMap((coupon) => this.couponValidation(coupon, checkoutType)),\n      concatMap((couponValid: Coupon) =>\n        this.couponRulesValidation({ coupon: couponValid, checkoutType, checkout, plan }),\n      ),\n      map((couponValidated: Coupon) => couponValidated as Coupon),\n    )\n  }\n\n  private async couponValidation(coupon: Coupon, checkoutType: CheckoutTypes) {\n    if (!coupon) throw 'Cupom inválido.'\n\n    if (coupon?.beginAt && coupon?.beginAt.getTime() > new Date().getTime()) throw 'Cupom inválido.'\n\n    if (coupon?.expiresIn && (coupon?.expiresIn as Date).getTime() < new Date().getTime()) throw 'Cupom expirado.'\n\n    const isInShop =\n      coupon.shopAvailability === Shops.ALL || coupon.shopAvailability === this.configurationFacade.defaultShop\n\n    if (!isInShop) throw 'Cupom inválido para loja.'\n\n    const isCheckoutType = coupon.checkoutType === CheckoutTypes.ALL || coupon.checkoutType === checkoutType\n\n    if (!isCheckoutType) throw 'Cupom inválido. Erro de checkout.'\n\n    return coupon\n  }\n\n  private async couponRulesValidation(params: CouponRulesValidationParams) {\n    const { coupon, checkoutType, checkout, plan } = params\n\n    if (checkoutType == CheckoutTypes.SUBSCRIPTION) {\n      return this.validateSubscriptionCoupon(coupon, plan)\n    }\n\n    return this.validateEcommerceCoupon(coupon, checkoutType, checkout)\n  }\n\n  private validateSubscriptionCoupon(coupon: Coupon, plan: string): Coupon {\n    if (coupon.plan && coupon.plan.toUpperCase() !== plan.toUpperCase()) {\n      throw 'Cupom inválido para sua assinatura.'\n    }\n\n    return coupon\n  }\n\n  private async validateEcommerceCoupon(\n    coupon: Coupon,\n    checkoutType: CheckoutTypes,\n    checkout: Partial<Checkout>,\n  ): Promise<Coupon> {\n    this.validateUserEligibility(coupon, checkout?.user)\n    await this.validateUsageLimits(coupon, checkoutType, checkout)\n    await this.validateProductEligibility(coupon, checkout)\n\n    return coupon\n  }\n\n  private validateUserEligibility(coupon: Coupon, user: User): void {\n    const validUser = this.coupomUserValidation(coupon, user)\n\n    if (!validUser) throw 'Usuário não elegível.'\n  }\n\n  private async validateUsageLimits(\n    coupon: Coupon,\n    checkoutType: CheckoutTypes,\n    checkout: Partial<Checkout>,\n  ): Promise<void> {\n    const couponUseLimits = this.getCouponUseLimits(coupon, checkoutType, checkout.user)\n\n    if (couponUseLimits.firstOrder) {\n      await this.validateFirstOrderLimit(checkout.user.email)\n    }\n\n    if (!couponUseLimits.unlimited || couponUseLimits.limitedPerUser) {\n      await this.validateCouponUsageLimits(coupon, couponUseLimits, checkout.user.email)\n    }\n  }\n\n  private async validateFirstOrderLimit(userEmail: string): Promise<void> {\n    const ordersUser = await this.getOrdersFromUser(userEmail.toLocaleLowerCase())\n\n    if (ordersUser.length >= 1) throw 'Limite de uso atingido'\n  }\n\n  private async validateCouponUsageLimits(coupon: Coupon, couponUseLimits: any, userEmail: string): Promise<void> {\n    const ordersCoupon = await this.getOrdersWithCoupon(coupon)\n\n    if (!couponUseLimits.unlimited && couponUseLimits.total && ordersCoupon.length >= couponUseLimits.total) {\n      throw 'Limite de uso atingido.'\n    }\n\n    if (couponUseLimits.limitedPerUser) {\n      const ordersWithUser = this.countOrdersWithUser(ordersCoupon, userEmail)\n\n      if (ordersWithUser > 0) throw 'Limite de uso por usuário atingido.'\n    }\n  }\n\n  private async validateProductEligibility(coupon: Coupon, checkout: Partial<Checkout>): Promise<void> {\n    const hasProductCategories = await this.hasProductCategories(coupon, checkout)\n\n    if (!hasProductCategories) throw 'Seu carrinho não possui produtos elegíveis para desconto.'\n\n    const hasMinSubTotal = await this.hasMinSubTotal(coupon, checkout)\n\n    if (!hasMinSubTotal) {\n      this.throwMinSubTotalError(coupon)\n    }\n  }\n\n  private throwMinSubTotalError(coupon: Coupon): void {\n    const formattedValue = Intl.NumberFormat('pt-BR', {\n      style: 'currency',\n      currency: 'BRL',\n    }).format(coupon.minSubTotalValue)\n\n    if (coupon.productsCategories?.length) {\n      throw `Valor mínimo de ${formattedValue} não atingido na(s) categoria(s) elegíveis para o desconto.`\n    }\n\n    throw `Valor mínimo de ${formattedValue} não atingido.`\n  }\n\n  public calcDiscountSubscription(coupon: Coupon, checkout: Partial<CheckoutSubscription>): Observable<number> {\n    let discount = 0\n\n    if (coupon.discount.subscription.type == CouponTypes.ABSOLUTE) discount = coupon.discount.subscription.value\n    else discount = checkout.subscriptionPlan.recurrencePrice * (coupon.discount.subscription.value / 100)\n\n    return of(discount)\n  }\n\n  private async hasMinSubTotal(coupon: Coupon, checkout: Partial<Checkout>): Promise<boolean> {\n    if (!coupon.minSubTotalValue) return true\n\n    const lineItensDiscount = await this.getLineItensEligebleForDiscount(coupon.productsCategories, checkout)\n    const subTotal = this.calcCheckoutSubtotal(lineItensDiscount, checkout.user)\n\n    if (coupon.minSubTotalValue <= subTotal) return true\n\n    return false\n  }\n\n  private async hasProductCategories(coupon: Coupon, checkout: Partial<Checkout>): Promise<boolean> {\n    if (!coupon.productsCategories?.length) {\n      return true\n    }\n\n    const couponCategories = await this.getCouponCategoriesId(coupon.productsCategories)\n    const hasCategories = checkout.lineItems?.filter((item) => {\n      if (item.isGift) return false\n\n      if (!item.categories?.length) return true\n\n      return item.categories.some((c) => couponCategories.some((cat) => cat == c))\n    })\n\n    return hasCategories?.length ? true : false\n  }\n\n  private coupomUserValidation(coupon: Coupon, user: User) {\n    if (!user || coupon.exclusivityType.includes(Exclusivities.ALL_USERS)) return true\n\n    const userTypes: Exclusivities[] = []\n\n    if (\n      coupon.exclusivityType.includes(Exclusivities.COLLABORATORS) &&\n      this.emailIsFromCollaborator(user.email.toLocaleLowerCase())\n    )\n      userTypes.push(Exclusivities.COLLABORATORS)\n\n    if (\n      coupon.exclusivityType.includes(Exclusivities.SPECIFIC_USER) &&\n      coupon.userExclusiveEmail.includes(user.email.toLocaleLowerCase())\n    )\n      userTypes.push(Exclusivities.SPECIFIC_USER)\n\n    if (\n      coupon.exclusivityType.includes(Exclusivities.ACTIVE_SUBSCRIBER) &&\n      user.isSubscriber &&\n      user.subscriptionPlan != ''\n    )\n      userTypes.push(Exclusivities.ACTIVE_SUBSCRIBER)\n\n    if (\n      user.isSubscriber &&\n      user.subscriptionPlan == '' &&\n      coupon.exclusivityType.includes(Exclusivities.INACTIVE_SUBSCRIBER)\n    )\n      userTypes.push(Exclusivities.INACTIVE_SUBSCRIBER)\n\n    if (coupon.exclusivityType.includes(Exclusivities.NON_SUBSCRIBER) && !user.isSubscriber)\n      userTypes.push(Exclusivities.NON_SUBSCRIBER)\n\n    return coupon.exclusivityType.some((r) => userTypes.includes(r))\n  }\n\n  private async getCouponCategoriesId(productsCategories: string[]): Promise<Array<String>> {\n    const couponCategories: Array<String> = []\n\n    for (let index = 0; index < productsCategories.length; index++) {\n      const category: Category & { firestoreId?: string } = await this.repositoriesFacade.categoryRepository.get({\n        id: productsCategories[index],\n      })\n\n      if (category) {\n        const children = await this.repositoriesFacade.categoryRepository.getChildren(\n          parseInt(productsCategories[index]),\n        )\n\n        couponCategories.push(category.id, ...children.map((c) => c.id.toString()))\n      }\n    }\n\n    return [...new Set(couponCategories)]\n  }\n\n  private emailIsFromCollaborator = (userEmail: string): boolean => !!userEmail?.match(/@b4a.com.br/g)\n\n  private async getLineItensEligebleForDiscount(\n    productsCategories: string[],\n    checkout: Partial<Checkout>,\n  ): Promise<LineItem[]> {\n    let lineItensDiscount = []\n    const couponCategories = await this.getCouponCategoriesId(productsCategories)\n\n    if (productsCategories?.length) {\n      lineItensDiscount = checkout.lineItems?.filter((item) => {\n        if (item.isGift) return false\n\n        if (item.categories?.length) {\n          return item.categories.some((c) => couponCategories.some((cat) => cat == c))\n        }\n\n        return true\n      })\n    } else {\n      lineItensDiscount = checkout.lineItems.filter((item) => !item.isGift)\n    }\n\n    return lineItensDiscount\n  }\n\n  private calcCheckoutSubtotal(lineItens: LineItem[], user: User): number {\n    return (\n      lineItens\n        ?.filter((item) => !item.isGift)\n        .reduce(\n          (acc, curr) =>\n            user?.isSubscriber && curr.price?.subscriberPrice\n              ? acc + curr.price?.subscriberPrice * curr.quantity\n              : acc + curr.pricePaid * curr.quantity,\n          0,\n        ) || 0\n    )\n  }\n\n  private async getOrdersWithCoupon(coupon: Coupon): Promise<Order[]> {\n    return await this.repositoriesFacade.orderRepository\n      .find({\n        filters: {\n          coupon: { id: coupon.id },\n          status: { operator: Where.NOTEQUALS, value: OrderStatus.CANCELADO },\n        },\n      })\n      .then((result) => result.data)\n  }\n\n  private async getOrdersFromUser(email: string) {\n    return await this.repositoriesFacade.orderRepository\n      .find({\n        filters: {\n          user: { email: { operator: Where.EQUALS, value: email } },\n          status: { operator: Where.NOTEQUALS, value: OrderStatus.CANCELADO },\n        },\n      })\n      .then((result) => result.data)\n  }\n\n  private countOrdersWithUser(orders: Order[], email: string): number {\n    return orders.filter((o) => o.user.email == email).length\n  }\n\n  private getCouponUseLimits(coupon: Coupon, checkoutType: CheckoutTypes, user: User) {\n    let couponUseLimits: { unlimited?: boolean; total?: number; limitedPerUser?: boolean; firstOrder?: boolean }\n\n    if (checkoutType == CheckoutTypes.ECOMMERCE || checkoutType == CheckoutTypes.ALL) {\n      if (\n        coupon.exclusivityType.length === 1 &&\n        (coupon.exclusivityType.at(0) === Exclusivities.SPECIFIC_USER ||\n          coupon.exclusivityType.at(0) === Exclusivities.COLLABORATORS)\n      )\n        couponUseLimits = coupon.useLimits.non_subscriber\n      else couponUseLimits = user?.isSubscriber ? coupon.useLimits.subscriber : coupon.useLimits.non_subscriber\n    } else {\n      couponUseLimits = coupon.useLimits.subscription\n    }\n\n    return couponUseLimits\n  }\n}\n"]}

package/esm2022/services/helpers/index.mjs

@@ -0,0 +1,2 @@
+export * from './util.helper';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0LWFuZ3VsYXIvc3JjL3NlcnZpY2VzL2hlbHBlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3V0aWwuaGVscGVyJ1xuIl19

package/esm2022/services/helpers/util.helper.mjs

@@ -0,0 +1,18 @@
+export class UtilHelper {
+    static createSlug(name) {
+        return name
+            .toLowerCase()
+            .replace(/\s+/g, '-')
+            .replace(/[ãàáäâ]/g, 'a')
+            .replace(/[ẽèéëê]/g, 'e')
+            .replace(/[ìíïî]/g, 'i')
+            .replace(/[õòóöô]/g, 'o')
+            .replace(/[ùúüû]/g, 'u')
+            .replace(/[ñ]/g, 'n')
+            .replace(/[ç]/g, 'c')
+            .replace(/[&]/g, 'and')
+            .replace(/[^\w-]+/g, '')
+            .replace(/--+/g, '-');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5oZWxwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0LWFuZ3VsYXIvc3JjL3NlcnZpY2VzL2hlbHBlcnMvdXRpbC5oZWxwZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFVBQVU7SUFDckIsTUFBTSxDQUFDLFVBQVUsQ0FBQyxJQUFZO1FBQzVCLE9BQU8sSUFBSTthQUNSLFdBQVcsRUFBRTthQUNiLE9BQU8sQ0FBQyxNQUFNLEVBQUUsR0FBRyxDQUFDO2FBQ3BCLE9BQU8sQ0FBQyxVQUFVLEVBQUUsR0FBRyxDQUFDO2FBQ3hCLE9BQU8sQ0FBQyxVQUFVLEVBQUUsR0FBRyxDQUFDO2FBQ3hCLE9BQU8sQ0FBQyxTQUFTLEVBQUUsR0FBRyxDQUFDO2FBQ3ZCLE9BQU8sQ0FBQyxVQUFVLEVBQUUsR0FBRyxDQUFDO2FBQ3hCLE9BQU8sQ0FBQyxTQUFTLEVBQUUsR0FBRyxDQUFDO2FBQ3ZCLE9BQU8sQ0FBQyxNQUFNLEVBQUUsR0FBRyxDQUFDO2FBQ3BCLE9BQU8sQ0FBQyxNQUFNLEVBQUUsR0FBRyxDQUFDO2FBQ3BCLE9BQU8sQ0FBQyxNQUFNLEVBQUUsS0FBSyxDQUFDO2FBQ3RCLE9BQU8sQ0FBQyxVQUFVLEVBQUUsRUFBRSxDQUFDO2FBQ3ZCLE9BQU8sQ0FBQyxNQUFNLEVBQUUsR0FBRyxDQUFDLENBQUE7SUFDekIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFV0aWxIZWxwZXIge1xuICBzdGF0aWMgY3JlYXRlU2x1ZyhuYW1lOiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIHJldHVybiBuYW1lXG4gICAgICAudG9Mb3dlckNhc2UoKVxuICAgICAgLnJlcGxhY2UoL1xccysvZywgJy0nKVxuICAgICAgLnJlcGxhY2UoL1vDo8Ogw6HDpMOiXS9nLCAnYScpXG4gICAgICAucmVwbGFjZSgvW+G6vcOow6nDq8OqXS9nLCAnZScpXG4gICAgICAucmVwbGFjZSgvW8Osw63Dr8OuXS9nLCAnaScpXG4gICAgICAucmVwbGFjZSgvW8O1w7LDs8O2w7RdL2csICdvJylcbiAgICAgIC5yZXBsYWNlKC9bw7nDusO8w7tdL2csICd1JylcbiAgICAgIC5yZXBsYWNlKC9bw7FdL2csICduJylcbiAgICAgIC5yZXBsYWNlKC9bw6ddL2csICdjJylcbiAgICAgIC5yZXBsYWNlKC9bJl0vZywgJ2FuZCcpXG4gICAgICAucmVwbGFjZSgvW15cXHctXSsvZywgJycpXG4gICAgICAucmVwbGFjZSgvLS0rL2csICctJylcbiAgfVxufVxuIl19

package/esm2022/services/home-shop/home-shop-repositories.facade.mjs

@@ -0,0 +1,24 @@
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HomeShopRepositoriesFacade {
+    constructor(categoryRepository, homeRepository, productRepository) {
+        this.categoryRepository = categoryRepository;
+        this.homeRepository = homeRepository;
+        this.productRepository = productRepository;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HomeShopRepositoriesFacade, deps: [{ token: 'CategoryRepository' }, { token: 'HomeRepository' }, { token: 'ProductRepository' }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HomeShopRepositoriesFacade }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HomeShopRepositoriesFacade, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['CategoryRepository']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['HomeRepository']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['ProductRepository']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaG9tZS1zaG9wLXJlcG9zaXRvcmllcy5mYWNhZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0LWFuZ3VsYXIvc3JjL3NlcnZpY2VzL2hvbWUtc2hvcC9ob21lLXNob3AtcmVwb3NpdG9yaWVzLmZhY2FkZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQTs7QUFJbEQsTUFBTSxPQUFPLDBCQUEwQjtJQUNyQyxZQUNnRCxrQkFBc0MsRUFDMUMsY0FBOEIsRUFDM0IsaUJBQW9DO1FBRm5DLHVCQUFrQixHQUFsQixrQkFBa0IsQ0FBb0I7UUFDMUMsbUJBQWMsR0FBZCxjQUFjLENBQWdCO1FBQzNCLHNCQUFpQixHQUFqQixpQkFBaUIsQ0FBbUI7SUFDaEYsQ0FBQzsrR0FMTywwQkFBMEIsa0JBRTNCLG9CQUFvQixhQUNwQixnQkFBZ0IsYUFDaEIsbUJBQW1CO21IQUpsQiwwQkFBMEI7OzRGQUExQiwwQkFBMEI7a0JBRHRDLFVBQVU7OzBCQUdOLE1BQU07MkJBQUMsb0JBQW9COzswQkFDM0IsTUFBTTsyQkFBQyxnQkFBZ0I7OzBCQUN2QixNQUFNOzJCQUFDLG1CQUFtQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5pbXBvcnQgeyBDYXRlZ29yeVJlcG9zaXRvcnksIEhvbWVSZXBvc2l0b3J5LCBQcm9kdWN0UmVwb3NpdG9yeSB9IGZyb20gJ0BpbmZyYWI0YS9jb25uZWN0J1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgSG9tZVNob3BSZXBvc2l0b3JpZXNGYWNhZGUge1xuICBjb25zdHJ1Y3RvcihcbiAgICBASW5qZWN0KCdDYXRlZ29yeVJlcG9zaXRvcnknKSBwdWJsaWMgcmVhZG9ubHkgY2F0ZWdvcnlSZXBvc2l0b3J5OiBDYXRlZ29yeVJlcG9zaXRvcnksXG4gICAgQEluamVjdCgnSG9tZVJlcG9zaXRvcnknKSBwdWJsaWMgcmVhZG9ubHkgaG9tZVJlcG9zaXRvcnk6IEhvbWVSZXBvc2l0b3J5LFxuICAgIEBJbmplY3QoJ1Byb2R1Y3RSZXBvc2l0b3J5JykgcHVibGljIHJlYWRvbmx5IHByb2R1Y3RSZXBvc2l0b3J5OiBQcm9kdWN0UmVwb3NpdG9yeSxcbiAgKSB7fVxufVxuIl19

package/esm2022/services/home-shop/index.mjs

@@ -0,0 +1,2 @@
+export { HomeShopRepositoriesFacade } from './home-shop-repositories.facade';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25uZWN0LWFuZ3VsYXIvc3JjL3NlcnZpY2VzL2hvbWUtc2hvcC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IEhvbWVTaG9wUmVwb3NpdG9yaWVzRmFjYWRlIH0gZnJvbSAnLi9ob21lLXNob3AtcmVwb3NpdG9yaWVzLmZhY2FkZSdcbiJdfQ==