@infrab4a/connect-angular 5.8.3 → 5.8.4

package/src/services/coupon/types/coupon-params.type.ts

@@ -0,0 +1,15 @@
+import { Checkout, CheckoutTypes, Coupon } from '@infrab4a/connect'
+
+export type CheckCouponParams = {
+  nickname: string
+  checkoutType: CheckoutTypes
+  checkout: Partial<Checkout>
+  plan: string
+}
+
+export type CouponRulesValidationParams = {
+  coupon: Coupon
+  checkoutType: CheckoutTypes
+  checkout: Partial<Checkout>
+  plan: string
+}

package/src/services/coupon.service.ts

@@ -0,0 +1,347 @@
+import { Injectable } from '@angular/core'
+import {
+  Category,
+  Checkout,
+  CheckoutSubscription,
+  CheckoutTypes,
+  Coupon,
+  CouponTypes,
+  Exclusivities,
+  LineItem,
+  Order,
+  OrderStatus,
+  Shops,
+  User,
+  Where,
+} from '@infrab4a/connect'
+import { from, Observable, of } from 'rxjs'
+import { concatMap, map } from 'rxjs/operators'
+
+import { CouponRepositoriesFacade } from './coupon'
+import { CheckCouponParams, CouponRulesValidationParams } from './coupon/types/coupon-params.type'
+import { ConfigurationFacade } from './shared'
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CouponService {
+  constructor(
+    private readonly repositoriesFacade: CouponRepositoriesFacade,
+    private readonly configurationFacade: ConfigurationFacade,
+  ) {}
+
+  checkCoupon(params: CheckCouponParams): Observable<Coupon> {
+    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: Coupon) =>
+        this.couponRulesValidation({ coupon: couponValid, checkoutType, checkout, plan }),
+      ),
+      map((couponValidated: Coupon) => couponValidated as Coupon),
+    )
+  }
+
+  private async couponValidation(coupon: Coupon, checkoutType: CheckoutTypes) {
+    if (!coupon) throw 'Cupom inválido.'
+
+    if (coupon?.beginAt && coupon?.beginAt.getTime() > new Date().getTime()) throw 'Cupom inválido.'
+
+    if (coupon?.expiresIn && (coupon?.expiresIn as Date).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
+  }
+
+  private async couponRulesValidation(params: CouponRulesValidationParams) {
+    const { coupon, checkoutType, checkout, plan } = params
+
+    if (checkoutType == CheckoutTypes.SUBSCRIPTION) {
+      return this.validateSubscriptionCoupon(coupon, plan)
+    }
+
+    return this.validateEcommerceCoupon(coupon, checkoutType, checkout)
+  }
+
+  private validateSubscriptionCoupon(coupon: Coupon, plan: string): Coupon {
+    if (coupon.plan && coupon.plan.toUpperCase() !== plan.toUpperCase()) {
+      throw 'Cupom inválido para sua assinatura.'
+    }
+
+    return coupon
+  }
+
+  private async validateEcommerceCoupon(
+    coupon: Coupon,
+    checkoutType: CheckoutTypes,
+    checkout: Partial<Checkout>,
+  ): Promise<Coupon> {
+    this.validateUserEligibility(coupon, checkout?.user)
+    await this.validateUsageLimits(coupon, checkoutType, checkout)
+    await this.validateProductEligibility(coupon, checkout)
+
+    return coupon
+  }
+
+  private validateUserEligibility(coupon: Coupon, user: User): void {
+    const validUser = this.coupomUserValidation(coupon, user)
+
+    if (!validUser) throw 'Usuário não elegível.'
+  }
+
+  private async validateUsageLimits(
+    coupon: Coupon,
+    checkoutType: CheckoutTypes,
+    checkout: Partial<Checkout>,
+  ): Promise<void> {
+    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)
+    }
+  }
+
+  private async validateFirstOrderLimit(userEmail: string): Promise<void> {
+    const ordersUser = await this.getOrdersFromUser(userEmail.toLocaleLowerCase())
+
+    if (ordersUser.length >= 1) throw 'Limite de uso atingido'
+  }
+
+  private async validateCouponUsageLimits(coupon: Coupon, couponUseLimits: any, userEmail: string): Promise<void> {
+    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.'
+    }
+  }
+
+  private async validateProductEligibility(coupon: Coupon, checkout: Partial<Checkout>): Promise<void> {
+    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)
+    }
+  }
+
+  private throwMinSubTotalError(coupon: Coupon): void {
+    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.`
+  }
+
+  public calcDiscountSubscription(coupon: Coupon, checkout: Partial<CheckoutSubscription>): Observable<number> {
+    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)
+  }
+
+  private async hasMinSubTotal(coupon: Coupon, checkout: Partial<Checkout>): Promise<boolean> {
+    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
+  }
+
+  private async hasProductCategories(coupon: Coupon, checkout: Partial<Checkout>): Promise<boolean> {
+    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
+  }
+
+  private coupomUserValidation(coupon: Coupon, user: User) {
+    if (!user || coupon.exclusivityType.includes(Exclusivities.ALL_USERS)) return true
+
+    const userTypes: Exclusivities[] = []
+
+    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))
+  }
+
+  private async getCouponCategoriesId(productsCategories: string[]): Promise<Array<String>> {
+    const couponCategories: Array<String> = []
+
+    for (let index = 0; index < productsCategories.length; index++) {
+      const category: Category & { firestoreId?: string } = 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)]
+  }
+
+  private emailIsFromCollaborator = (userEmail: string): boolean => !!userEmail?.match(/@b4a.com.br/g)
+
+  private async getLineItensEligebleForDiscount(
+    productsCategories: string[],
+    checkout: Partial<Checkout>,
+  ): Promise<LineItem[]> {
+    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
+  }
+
+  private calcCheckoutSubtotal(lineItens: LineItem[], user: User): number {
+    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
+    )
+  }
+
+  private async getOrdersWithCoupon(coupon: Coupon): Promise<Order[]> {
+    return await this.repositoriesFacade.orderRepository
+      .find({
+        filters: {
+          coupon: { id: coupon.id },
+          status: { operator: Where.NOTEQUALS, value: OrderStatus.CANCELADO },
+        },
+      })
+      .then((result) => result.data)
+  }
+
+  private async getOrdersFromUser(email: string) {
+    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)
+  }
+
+  private countOrdersWithUser(orders: Order[], email: string): number {
+    return orders.filter((o) => o.user.email == email).length
+  }
+
+  private getCouponUseLimits(coupon: Coupon, checkoutType: CheckoutTypes, user: User) {
+    let couponUseLimits: { unlimited?: boolean; total?: number; limitedPerUser?: boolean; firstOrder?: boolean }
+
+    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
+  }
+}

package/src/services/errors/group-invalid-coupon.error.ts

@@ -0,0 +1,9 @@
+import { CustomError } from 'ts-custom-error'
+
+import { InvalidCouponError } from './invalid-coupon.error'
+
+export class GroupInvalidCouponError extends CustomError {
+  constructor(readonly errors: InvalidCouponError[]) {
+    super('Many coupon errors throw')
+  }
+}

package/src/services/errors/index.ts

@@ -0,0 +1,2 @@
+export * from './group-invalid-coupon.error'
+export * from './invalid-coupon.error'

package/src/services/errors/invalid-coupon.error.ts

@@ -0,0 +1,7 @@
+import { CustomError } from 'ts-custom-error'
+
+export class InvalidCouponError extends CustomError {
+  constructor(message: string) {
+    super(message)
+  }
+}

package/src/services/helpers/index.ts

@@ -0,0 +1 @@
+export * from './util.helper'

package/src/services/helpers/util.helper.ts

@@ -0,0 +1,17 @@
+export class UtilHelper {
+  static createSlug(name: string): string {
+    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, '-')
+  }
+}

package/src/services/home-shop/home-shop-repositories.facade.ts

@@ -0,0 +1,11 @@
+import { Inject, Injectable } from '@angular/core'
+import { CategoryRepository, HomeRepository, ProductRepository } from '@infrab4a/connect'
+
+@Injectable()
+export class HomeShopRepositoriesFacade {
+  constructor(
+    @Inject('CategoryRepository') public readonly categoryRepository: CategoryRepository,
+    @Inject('HomeRepository') public readonly homeRepository: HomeRepository,
+    @Inject('ProductRepository') public readonly productRepository: ProductRepository,
+  ) {}
+}

package/{services/home-shop/index.d.ts → src/services/home-shop/index.ts}

@@ -1 +1 @@
-export { HomeShopRepositoriesFacade } from './home-shop-repositories.facade';
+export { HomeShopRepositoriesFacade } from './home-shop-repositories.facade'

package/src/services/home-shop.service.ts

@@ -0,0 +1,210 @@
+import { Injectable } from '@angular/core'
+import {
+  add,
+  Banner,
+  Category,
+  Home,
+  HomeCategoryGroup,
+  HomeData,
+  pick,
+  Product,
+  RequiredArgumentError,
+  ShippingThresholds,
+  Shops,
+  Where,
+} from '@infrab4a/connect'
+import { forkJoin, from, Observable, of, throwError } from 'rxjs'
+import { concatMap, map, tap } from 'rxjs/operators'
+
+import { HomeShopRepositoriesFacade } from './home-shop'
+import { ConfigurationFacade } from './shared'
+
+type HomeConfigurationId = 'glamshop' | 'mens_market'
+type BannerType = 'brand' | 'buyToWin' | 'block' | 'blog'
+
+@Injectable()
+export class HomeShopService {
+  private homeConfiguration: Home
+
+  private get homeId(): HomeConfigurationId {
+    if (this.configurationFacade.defaultShop === Shops.GLAMSHOP) return 'glamshop'
+
+    if (this.configurationFacade.defaultShop === Shops.MENSMARKET) return 'mens_market'
+
+    return null
+  }
+
+  constructor(
+    private readonly repositoriesFacade: HomeShopRepositoriesFacade,
+    private readonly configurationFacade: ConfigurationFacade,
+  ) {}
+
+  getHomeData(): Observable<Home> {
+    return this.getHomeConfiguration().pipe(
+      map((home) => (home?.data?.expiresAt > new Date() ? home : null)),
+      concatMap((home) =>
+        home
+          ? of(home)
+          : forkJoin([
+              this.getDiscoverProducts(this.gender),
+              this.getFeaturedProducts(this.gender),
+              this.getVerticalProducts(this.gender),
+            ]).pipe(
+              map(([discoverProducts, featuredProducts, verticalProducts]) => ({
+                discoverProducts,
+                featuredProducts,
+                verticalProducts,
+              })),
+              concatMap((data) => this.saveHomeData(data)),
+            ),
+      ),
+    )
+  }
+
+  getBanners(type: BannerType): Observable<Banner[]> {
+    return this.getHomeConfiguration().pipe(
+      map((home) => {
+        if (type === 'brand') return home.brandsCarousel
+
+        if (type === 'buyToWin') return [home.buyToWinBanner]
+
+        if (type === 'block') return home.blockBanners
+
+        if (type === 'blog') return [home.blogBanner]
+
+        return []
+      }),
+    )
+  }
+
+  getMinValueForFreeShipping(): Observable<number> {
+    return this.getHomeConfiguration().pipe(map((home) => home.minValueForFreeShipping))
+  }
+
+  /**
+   * Retorna os thresholds de frete grátis estruturados configurados no documento
+   * Home (`shippingThresholds`). Quando o documento ainda não possui essa
+   * estrutura, retorna um default conservador equivalente à regra legada
+   * (edition: 50, avulsoSp: 99, avulsoOutro: null) para que consumidores não
+   * quebrem durante a migração.
+   */
+  getShippingThresholds(): Observable<ShippingThresholds> {
+    const conservativeDefault: ShippingThresholds = { edition: 50, avulsoSp: 99, avulsoOutro: null }
+
+    return this.getHomeConfiguration().pipe(map((home) => home.shippingThresholds ?? conservativeDefault))
+  }
+
+  private getDiscoverProducts(_gender?: string): Observable<{ category: Category; products: Product[] }[]> {
+    return this.getHomeConfiguration().pipe(
+      concatMap((home) =>
+        from(
+          this.repositoriesFacade.categoryRepository.getCategoriesForHome({
+            categoryIds: home.discoverCategories,
+            shop: this.configurationFacade.defaultShop,
+          }),
+        ).pipe(map((groups) => groups.map(this.buildCategoryGroupWithRequiredData))),
+      ),
+    )
+  }
+
+  private getFeaturedProducts(_gender?: string): Observable<{ category: Category; products: Product[] }[]> {
+    return this.getHomeConfiguration().pipe(
+      concatMap((home) =>
+        from(
+          this.repositoriesFacade.categoryRepository.getCategoriesForHome({
+            categoryIds: home.featuredCategories,
+            shop: this.configurationFacade.defaultShop,
+          }),
+        ).pipe(map((groups) => groups.map(this.buildCategoryGroupWithRequiredData))),
+      ),
+    )
+  }
+
+  private getVerticalProducts(gender?: string): Observable<{ category: Category; products: Product[] }[]> {
+    return this.getHomeConfiguration().pipe(
+      concatMap((home) =>
+        forkJoin(
+          home.verticalCarousels.filter(Boolean).map((id) =>
+            from(this.repositoriesFacade.categoryRepository.get({ id })).pipe(
+              concatMap((category) =>
+                from(
+                  this.repositoriesFacade.productRepository.find({
+                    filters: {
+                      categories: { operator: Where.IN, value: [category.id] },
+                      ...(gender ? { tags: { operator: Where.IN, value: [gender] } } : {}),
+                    },
+                    limits: { limit: 12 },
+                  }),
+                ).pipe(map((products) => ({ category, products }))),
+              ),
+              map(({ category, products }) => ({ category, products: products.data })),
+              map(this.buildCategoryGroupWithRequiredData),
+            ),
+          ),
+        ),
+      ),
+    )
+  }
+
+  private getHomeConfiguration(): Observable<Home> {
+    return of(this.homeConfiguration).pipe(
+      concatMap((home) =>
+        home
+          ? of(home)
+          : !this.homeId
+          ? throwError(() => new RequiredArgumentError(['homeId']))
+          : from(this.repositoriesFacade.homeRepository.get({ id: this.homeId })).pipe(
+              tap((homeLoaded) => (this.homeConfiguration = homeLoaded)),
+            ),
+      ),
+    )
+  }
+
+  private saveHomeData(homeData: HomeData): Observable<Home> {
+    const data = {
+      createdAt: new Date(),
+      expiresAt: add(new Date(), { hours: 1 }),
+      data: homeData,
+    }
+
+    return from(
+      this.repositoriesFacade.homeRepository.update({
+        id: this.homeId,
+        data,
+      }),
+    ).pipe(
+      tap(() => (this.homeConfiguration.data = data)),
+      map(() => this.homeConfiguration),
+    )
+  }
+
+  private buildCategoryGroupWithRequiredData = (group: HomeCategoryGroup): HomeCategoryGroup => ({
+    category: Category.toInstance(pick(group?.category?.toPlain() || {}, ['id', 'name', 'slug', 'conditions'])),
+    products:
+      group?.products?.map((product) =>
+        Product.toInstance(
+          pick(product?.toPlain() || {}, [
+            'id',
+            'price',
+            'reviews',
+            'hasVariants',
+            'slug',
+            'sku',
+            'stock',
+            'costPrice',
+            'images',
+            'miniatures',
+            'name',
+            'weight',
+            'rate',
+            'type',
+            'brand',
+          ]),
+        ),
+      ) || [],
+  })
+
+  private get gender() {
+    return this.homeId === 'mens_market' ? 'masculino' : undefined
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,12 @@
+export * from './auth.service'
+export * from './cart.service'
+export * from './catalog'
+export * from './checkout-subscription.service'
+export * from './checkout.service'
+export * from './coupon.service'
+export * from './helpers'
+export * from './home-shop.service'
+export * from './order-product-review.service'
+export * from './order-recurrence.service'
+export * from './order.service'
+