@infrab4a/connect-angular 5.8.16 → 5.8.20

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)
+  }
+}

package/src/services/order-recurrence.service.ts

@@ -0,0 +1,121 @@
+import { Inject, Injectable } from '@angular/core'
+import {
+  CancelShoppingRecurrencePayload,
+  CreateShoppingRecurrencyPayload,
+  EnableOrDisableShoppingRecurrencePayload,
+  GetShoppingRecurrenceAvailableShippingPayload,
+  LineItemRecurrence,
+  ShippingMethodResponse,
+  ShoppingRecurrence,
+  ShoppingRecurrenceCycle,
+  ShoppingRecurrenceFirestoreRepository,
+  Shops,
+  SkipShoppingRecurrenceEditionPayload,
+  UpdateShoppingRecurrenceFrequencyPayload,
+  UpdateShoppingRecurrenceLineItemsPayload,
+  UpdateShoppingRecurrencePaymentMethodPayload,
+  UpdateShoppingRecurrenceShippingAddressPayload,
+} from '@infrab4a/connect'
+import { from, Observable } from 'rxjs'
+
+import { DEFAULT_SHOP } from '../consts'
+
+import { CheckoutDependenciesFacade } from './checkout'
+import { ConfigurationFacade } from './shared'
+
+@Injectable()
+export class OrderRecurrenceService {
+  private checkoutUrl: string = null
+
+  constructor(
+    @Inject('ShoppingRecurrenceRepository')
+    private readonly shoppingRecurrenceRepository: ShoppingRecurrenceFirestoreRepository,
+    @Inject(DEFAULT_SHOP) public readonly defaultShop: Shops,
+    private readonly dependenciesFacade: CheckoutDependenciesFacade,
+    private readonly configurationFacade: ConfigurationFacade,
+  ) {
+    this.checkoutUrl = this.configurationFacade.getCheckoutUrl()
+  }
+
+  getRecurrenceOrder(recurrenceId: string): Observable<ShoppingRecurrence> {
+    return from(this.shoppingRecurrenceRepository.get({ id: recurrenceId }))
+  }
+
+  createRecurrenceOrder(recurrencePayload: CreateShoppingRecurrencyPayload): Observable<ShoppingRecurrence[]> {
+    return this.dependenciesFacade.httpClient.post<ShoppingRecurrence[]>(
+      `${this.checkoutUrl}/createShoppingRecurrence`,
+      {
+        data: recurrencePayload,
+      },
+    )
+  }
+
+  updatePaymentMethod(data: UpdateShoppingRecurrencePaymentMethodPayload) {
+    return this.dependenciesFacade.httpClient.post<ShoppingRecurrence>(
+      `${this.checkoutUrl}/updateShoppingRecurrencePaymentMethod`,
+      {
+        data,
+      },
+    )
+  }
+
+  getRecurrenceAvailableShipping(data: GetShoppingRecurrenceAvailableShippingPayload) {
+    return this.dependenciesFacade.httpClient.post<ShippingMethodResponse[]>(
+      `${this.checkoutUrl}/getShoppingRecurrenceAvailableShipping`,
+      {
+        data,
+      },
+    )
+  }
+
+  updateShippingAddress(data: UpdateShoppingRecurrenceShippingAddressPayload) {
+    return this.dependenciesFacade.httpClient.post<ShoppingRecurrence>(
+      `${this.checkoutUrl}/updateShoppingRecurrenceShippingAddress`,
+      {
+        data,
+      },
+    )
+  }
+
+  cancelRecurrenceOrder(data: CancelShoppingRecurrencePayload) {
+    return this.dependenciesFacade.httpClient.post<ShoppingRecurrence>(`${this.checkoutUrl}/cancelShoppingRecurrence`, {
+      data,
+    })
+  }
+
+  enableOrDisableRecurrenceOrder(recurrenceId: string, active: boolean) {
+    const payload: EnableOrDisableShoppingRecurrencePayload = { recurrenceId, active }
+
+    return this.dependenciesFacade.httpClient.post<ShoppingRecurrence>(
+      `${this.checkoutUrl}/enableOrDisableShoppingRecurrence`,
+      payload,
+    )
+  }
+
+  skipRecurrenceOrder(recurrenceEditionId: string) {
+    const payload: SkipShoppingRecurrenceEditionPayload = { recurrenceEditionId }
+
+    return this.dependenciesFacade.httpClient.post<ShoppingRecurrence>(
+      `${this.checkoutUrl}/skipShoppingRecurrenceEdition`,
+      payload,
+    )
+  }
+
+  updateFrequency(recurrenceId: string, frequency: ShoppingRecurrenceCycle) {
+    const payload: UpdateShoppingRecurrenceFrequencyPayload = { recurrenceId, frequency }
+
+    return this.dependenciesFacade.httpClient.post<ShoppingRecurrence>(
+      `${this.checkoutUrl}/updateShoppingRecurrenceFrequency`,
+      payload,
+    )
+  }
+
+  updateLineItems(recurrenceId: string, lineItems: LineItemRecurrence[]) {
+    const payload: UpdateShoppingRecurrenceLineItemsPayload = { recurrenceId, lineItems }
+
+    return this.dependenciesFacade.httpClient.post<ShoppingRecurrence>(
+      `${this.checkoutUrl}/updateShoppingRecurrenceLineItems`,
+      payload,
+    )
+  }
+}

package/src/services/order.service.ts

@@ -0,0 +1,23 @@
+import { Injectable, Inject } from '@angular/core'
+import { doc, Firestore, docSnapshots } from '@angular/fire/firestore'
+import { Order, OrderFirestoreRepository } from '@infrab4a/connect'
+import { Subject } from 'rxjs'
+import { map } from 'rxjs/operators'
+
+@Injectable()
+export class OrderService {
+  orderSubject = new Subject<Order>()
+
+  constructor(
+    private readonly angularFirestore: Firestore,
+    @Inject('OrderRepository') private readonly orderRepository: OrderFirestoreRepository,
+  ) {}
+
+  getOrder(id: string): Subject<Order> {
+    docSnapshots(doc(this.angularFirestore, `${this.orderRepository.collectionName}/${id}`))
+      .pipe(map((doc) => Order.toInstance(doc.data())))
+      .subscribe((doc) => this.orderSubject.next(doc))
+
+    return this.orderSubject
+  }
+}

package/src/services/shared/configuration.facade.ts

@@ -0,0 +1,21 @@
+import { Inject, Injectable } from '@angular/core'
+import { FirebaseOptions } from '@angular/fire/app'
+import { Shops } from '@infrab4a/connect'
+
+import { DEFAULT_SHOP, FIREBASE_OPTIONS } from '../../consts'
+
+@Injectable()
+export class ConfigurationFacade {
+  constructor(
+    @Inject(DEFAULT_SHOP) public readonly defaultShop: Shops,
+    @Inject(FIREBASE_OPTIONS) public readonly firebaseOptions: FirebaseOptions,
+  ) {}
+
+  getCheckoutUrl(): string {
+    return `https://southamerica-east1-${this.firebaseOptions.projectId}.cloudfunctions.net`
+  }
+
+  getProjectId(): string {
+    return this.firebaseOptions.projectId
+  }
+}

package/src/services/shared/index.ts

@@ -0,0 +1 @@
+export { ConfigurationFacade } from './configuration.facade'

package/src/services/types/index.ts

@@ -0,0 +1,4 @@
+export * from './pending-product-review.type'
+export * from './product-review-create.type'
+export * from './required-checkout-data.type'
+export * from './required-checkout-subscription-data.type'

package/src/services/types/pending-product-review.type.ts

@@ -0,0 +1,12 @@
+export type PendingProductReview = {
+  id: string
+  isEdition: boolean
+  orderId: string
+  orderNumber: string
+  name: string
+  image: string
+  deliveryDate: string
+  evaluationInAnalysis: boolean
+  rating?: number
+  shopProductSlug: string
+}

package/src/services/types/product-review-create.type.ts

@@ -0,0 +1,15 @@
+import { Shops } from '@infrab4a/connect/src'
+
+export type ProductReviewCreate = {
+  productId: string
+  shop: Shops
+  rate: number
+  author: string
+  email: string
+  location: string
+  comment: string
+  title: string
+  personId: number
+  points: number
+  orderId: string
+}

package/src/services/types/required-checkout-data.type.ts

@@ -0,0 +1,3 @@
+import { Checkout } from '@infrab4a/connect'
+
+export type RequiredCheckoutData = Partial<Pick<Checkout, 'id' | 'user' | 'shop' | 'lineItems'>>

package/src/services/types/required-checkout-subscription-data.type.ts

@@ -0,0 +1,3 @@
+import { CheckoutSubscription } from '@infrab4a/connect'
+
+export type RequiredCheckoutSubscriptionData = Partial<Pick<CheckoutSubscription, 'id'>>

package/src/test.ts

@@ -0,0 +1,2 @@
+// Karma entry required by tsconfig.spec.json. Specs in this package are Jasmine-only.
+export {}

package/src/types/firebase-app-config.type.ts

@@ -0,0 +1 @@
+export type FirebaseAppConfig = Record<string, any>

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './firebase-app-config.type'

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declarationMap": true,
+    "inlineSources": true,
+    "noEmit": true,
+    "composite": false,
+    "lib": ["es2018", "dom"]
+  },
+  "exclude": [
+    "**/*.spec.ts"
+  ],
+  "references": [
+    { "path": "../connect" }
+  ],
+  "include": ["./src"]
+}

package/tsconfig.lib.json

@@ -0,0 +1,13 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "composite": false
+  },
+  "angularCompilerOptions": {
+    "skipTemplateCodegen": true,
+    "strictMetadataEmit": true,
+    "enableResourceInlining": true,
+  }
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,13 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false,
+    "importHelpers": true,
+    "target": "es2017",
+    "module": "es2020"
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,17 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "files": [
+    "src/test.ts"
+  ],
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}