@infrab4a/connect-angular 5.8.19 → 5.8.21-beta.0

package/src/services/checkout.service.ts

@@ -0,0 +1,236 @@
+import { Injectable } from '@angular/core'
+import {
+  Checkout,
+  CheckoutPayloadRequest,
+  CheckoutResponse,
+  CheckoutStockValidation,
+  CheckoutTypes,
+  Coupon,
+  isNil,
+  NotFoundError,
+  pick,
+  ShippingMethodResponse,
+  ShippingProductRequest,
+  User,
+  UserAddress,
+} from '@infrab4a/connect'
+import { from, Observable, of, throwError } from 'rxjs'
+import { concatMap, map } from 'rxjs/operators'
+
+import { CheckoutDependenciesFacade, CheckoutRepositoriesFacade } from './checkout'
+import { ConfigurationFacade } from './shared'
+import { RequiredCheckoutData } from './types'
+
+@Injectable()
+export class CheckoutService {
+  private checkoutUrl: string = null
+
+  constructor(
+    private readonly repositoriesFacade: CheckoutRepositoriesFacade,
+    private readonly dependenciesFacade: CheckoutDependenciesFacade,
+    private readonly configurationFacade: ConfigurationFacade,
+  ) {
+    this.checkoutUrl = this.configurationFacade.getCheckoutUrl()
+  }
+
+  getCheckout(checkoutData?: RequiredCheckoutData): Observable<Checkout> {
+    return this.dependenciesFacade.dataPersistence
+      .get('checkoutId')
+      .pipe(
+        concatMap((id) =>
+          !isNil(id) ? this.repositoriesFacade.checkoutRepository.get({ id }) : this.createCheckout(checkoutData),
+        ),
+      )
+  }
+
+  getUserByCheckout(checkoutId: string): Observable<User> {
+    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: Partial<Checkout>): Observable<Checkout> {
+    return from(
+      this.repositoriesFacade.checkoutRepository.update(
+        Checkout.toInstance({ id: checkout.id, lineItems: checkout.lineItems }),
+      ),
+    )
+  }
+
+  updateCheckoutUser(checkout: Partial<Checkout>): Observable<Checkout> {
+    return from(
+      this.repositoriesFacade.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, user: checkout.user })),
+    )
+  }
+
+  clearCheckoutFromSession(): Observable<void> {
+    return this.dependenciesFacade.dataPersistence.remove('checkoutId')
+  }
+
+  resetCheckoutValues(): Observable<Checkout> {
+    return this.getCheckout().pipe(
+      concatMap((checkout) =>
+        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutResetValues`, {
+          checkoutId: checkout.id,
+        }),
+      ),
+      concatMap(() => this.getCheckout()),
+    )
+  }
+
+  applyCouponDiscount(nickname: string, checkoutType: CheckoutTypes): Observable<Coupon> {
+    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(): Observable<Checkout> {
+    return this.getCheckout().pipe(
+      concatMap((checkout) =>
+        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutRemoveDiscount`, {
+          checkoutId: checkout.id,
+        }),
+      ),
+      concatMap(() => this.getCheckout()),
+    )
+  }
+
+  applyPointsDiscount(points: number): Observable<Checkout> {
+    return this.getCheckout().pipe(
+      concatMap((checkout) =>
+        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutApplyPointsDiscount`, {
+          checkoutId: checkout.id,
+          points,
+        }),
+      ),
+      concatMap(() => this.getCheckout()),
+    )
+  }
+
+  removePointsDiscount(): Observable<Checkout> {
+    return this.getCheckout().pipe(
+      concatMap((checkout) =>
+        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutRemovePointsDiscount`, {
+          checkoutId: checkout.id,
+        }),
+      ),
+      concatMap(() => this.getCheckout()),
+    )
+  }
+
+  validateStockProducts(): Observable<CheckoutStockValidation> {
+    return this.getCheckout().pipe(
+      concatMap((checkout) =>
+        this.dependenciesFacade.httpClient.post<{
+          valid: boolean
+          outOfStock: string[]
+          limitedStock: string[]
+        }>(`${this.checkoutUrl}/checkoutValidateProductStock`, {
+          checkoutId: checkout.id,
+        }),
+      ),
+    )
+  }
+
+  selectShippingAddress(address: UserAddress): Observable<Checkout> {
+    const formattedAddress: UserAddress = {
+      ...address,
+      zip: this.formatZip(address.zip),
+    } as UserAddress
+
+    return this.getCheckout().pipe(
+      concatMap((checkout) => {
+        return this.repositoriesFacade.checkoutRepository.update(
+          Checkout.toInstance({
+            id: checkout.id,
+            shippingAddress: formattedAddress,
+            billingAddress: formattedAddress,
+          }),
+        )
+      }),
+    )
+  }
+
+  private formatZip(zip?: string): string | undefined {
+    if (!zip) return zip
+
+    const digits = zip.replace(/\D/g, '')
+
+    return digits
+  }
+
+  getAvailableShippingForProduct(productShipping: ShippingProductRequest): Observable<ShippingMethodResponse[]> {
+    return this.dependenciesFacade.httpClient.post<ShippingMethodResponse[]>(
+      `${this.checkoutUrl}/checkoutGetAvailableShipping`,
+      {
+        checkoutId: null,
+        productShipping,
+      },
+    )
+  }
+
+  getAvailableShippingForCheckout(): Observable<ShippingMethodResponse[]> {
+    return this.getCheckout().pipe(
+      concatMap((checkout) =>
+        this.dependenciesFacade.httpClient.post<ShippingMethodResponse[]>(
+          `${this.checkoutUrl}/checkoutGetAvailableShipping`,
+          {
+            checkoutId: checkout.id,
+            productShipping: null,
+          },
+        ),
+      ),
+    )
+  }
+
+  selectShipping(option: string): Observable<Checkout> {
+    return this.getCheckout().pipe(
+      concatMap((checkout) =>
+        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutSelectShipping`, {
+          checkoutId: checkout.id,
+          shippingOption: option,
+        }),
+      ),
+      concatMap(() => this.getCheckout()),
+    )
+  }
+
+  createOrder(
+    checkoutPayload: CheckoutPayloadRequest,
+    paymentProvider: string,
+    applicationVersion: string,
+  ): Observable<CheckoutResponse> {
+    return this.dependenciesFacade.httpClient.post<CheckoutResponse>(`${this.checkoutUrl}/checkout`, {
+      data: {
+        ...checkoutPayload,
+        applicationVersion,
+        paymentProvider,
+      },
+    })
+  }
+
+  private async createCheckout(checkoutData?: RequiredCheckoutData): Promise<Checkout> {
+    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
+  }
+}

package/src/services/coupon/coupon-repositories.facade.ts

@@ -0,0 +1,11 @@
+import { Inject, Injectable } from '@angular/core'
+import { CategoryRepository, CouponRepository, OrderRepository } from '@infrab4a/connect'
+
+@Injectable()
+export class CouponRepositoriesFacade {
+  constructor(
+    @Inject('CouponRepository') public readonly couponRepository: CouponRepository,
+    @Inject('OrderRepository') public readonly orderRepository: OrderRepository,
+    @Inject('CategoryRepository') public readonly categoryRepository: CategoryRepository,
+  ) {}
+}

package/{services/coupon/index.d.ts → src/services/coupon/index.ts}

@@ -1 +1 @@
-export { CouponRepositoriesFacade } from './coupon-repositories.facade';
+export { CouponRepositoriesFacade } from './coupon-repositories.facade'

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/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,9 @@
+export * from './auth.service'
+export * from './cart.service'
+export * from './catalog'
+export * from './checkout.service'
+export * from './helpers'
+export * from './home-shop.service'
+export * from './order-product-review.service'
+export * from './order-recurrence.service'
+export * from './order.service'

package/src/services/order-product-review.service.ts

@@ -0,0 +1,135 @@
+import { Inject, Injectable } from '@angular/core'
+import {
+  LineItem,
+  Order,
+  OrderFirestoreRepository,
+  OrderStatus,
+  ProductReview,
+  ProductReviewRepository,
+  Shops,
+  VariantRepository,
+  Where,
+} from '@infrab4a/connect'
+
+import { DEFAULT_SHOP } from '../consts'
+
+import { PendingProductReview, ProductReviewCreate } from './types'
+
+@Injectable()
+export class OrderProductReviewService {
+  constructor(
+    @Inject('OrderRepository') private readonly orderRepository: OrderFirestoreRepository,
+    @Inject('ProductReviewRepository') private readonly productReviewRepository: ProductReviewRepository,
+    @Inject('VariantRepository') private readonly variantRepository: VariantRepository,
+    @Inject(DEFAULT_SHOP) public readonly defaultShop: Shops,
+  ) {}
+
+  async getPendingReviewsByEmail(email: string): Promise<PendingProductReview[]> {
+    const products: PendingProductReview[] = []
+    const orders = await this.getOrdersByEmail(email)
+
+    if (orders.length) {
+      for (const order of orders) {
+        const lineItems = order.lineItems.filter((item) => !item.isGift)
+
+        for (const item of lineItems) {
+          const productReview = await this.getProductReview(order, item)
+
+          if (productReview?.status != null) continue
+
+          products.push(this.buildProductReview(order, item, productReview))
+        }
+      }
+    }
+
+    return products
+  }
+
+  private async getOrdersByEmail(email: string): Promise<Order[]> {
+    const { data: orders } = await this.orderRepository.find({
+      filters: {
+        user: {
+          email: email,
+        },
+        shop: this.defaultShop,
+        status: OrderStatus.ENTREGUE,
+        createdAt: {
+          operator: Where.GTE,
+          value: new Date(2024, 0, 0, 0, 0, 0).getTime(),
+        },
+      },
+      orderBy: {
+        createdAt: 'desc',
+      },
+    })
+
+    return orders
+  }
+
+  private async getProductReview(order: Order, item: LineItem) {
+    const products: string[] = [item.id]
+    const isVariant = await this.variantRepository
+      .find({
+        filters: {
+          id: item.id,
+        },
+      })
+      .then((res) => res.data.at(0))
+
+    if (isVariant) products.push(isVariant.productId)
+    const productReview = await this.productReviewRepository
+      .find({
+        filters: {
+          orderId: { operator: Where.IN, value: [order.id, order.orderNumber].filter(Boolean) },
+          productId: { operator: Where.IN, value: products },
+        },
+      })
+      .then((res) => res.data.at(0))
+
+    return productReview
+  }
+
+  private buildProductReview(order: Order, item: LineItem, review: ProductReview) {
+    return {
+      id: item.id,
+      orderId: order.id,
+      orderNumber: order.orderNumber,
+      isEdition: false,
+      name: item.name,
+      image: item.image,
+      deliveryDate: order.deliveredAt || null,
+      evaluationInAnalysis: review ? true : false,
+      rating: review ? review.rate : null,
+      shopProductSlug: item.slug,
+    }
+  }
+
+  async createReview(review: ProductReviewCreate): Promise<ProductReview> {
+    return this.productReviewRepository.create(
+      ProductReview.toInstance({
+        productId: review.productId.toString(),
+        shop: review.shop,
+        rate: review.rate,
+        author: review.author,
+        email: review.email,
+        location: review.location,
+        review: review.comment,
+        title: review.title,
+        personId: review.personId,
+        points: review.points,
+        orderId: review.orderId,
+      }),
+    )
+  }
+
+  async verifyReviewProductAndOrder(orderId: string[], productId: string) {
+    return this.productReviewRepository
+      .find({
+        filters: {
+          orderId: { operator: Where.IN, value: orderId },
+          productId: productId,
+        },
+      })
+      .then((res) => res.data)
+  }
+}