@infrab4a/connect-angular 5.1.0 → 6.0.0-alpha.0

package/src/services/catalog/strategies/term-search.strategy.ts

@@ -0,0 +1,178 @@
+import { Injectable } from '@angular/core'
+import {
+  Product,
+  ProductSearch,
+  RepositoryCacheOptions,
+  RepositoryFindResult,
+  Shops,
+  Where,
+  isEmpty,
+} from '@infrab4a/connect'
+
+import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces'
+import { CatalogHelpersService, CatalogRepositoryService } from '../services'
+
+import {
+  SortByTermRelevanceParams,
+  TermSearchDefaultParams,
+  TermSearchMostRelevantParams,
+} from './types/strategy-params.type'
+
+@Injectable()
+export class TermSearchStrategy implements CatalogSearchStrategy {
+  private productsByTerm: Record<string, string[]> = {}
+
+  constructor(
+    private readonly repositoryService: CatalogRepositoryService,
+    private readonly helpersService: CatalogHelpersService,
+  ) {}
+
+  async search(
+    params: CatalogSearchParams,
+    shop: Shops,
+    _optionsCache?: { cache?: RepositoryCacheOptions },
+  ): Promise<RepositoryFindResult<Product>> {
+    const { term, filters, limits, sort, mainGender } = params
+
+    if (!term) {
+      throw new Error('Term is required for TermSearchStrategy')
+    }
+
+    const productIds = await this.findCatalogIdsBySearch(term, shop)
+
+    if (sort === 'most-relevant') {
+      return this.searchWithMostRelevant({
+        productIds,
+        filters,
+        limits,
+        shop,
+        mainGender,
+      })
+    }
+
+    return this.searchDefault({
+      productIds,
+      filters,
+      limits,
+      shop,
+      mainGender,
+      fields: this.helpersService.getFieldsHelper().getStandardFields(),
+    })
+  }
+
+  private async searchWithMostRelevant(params: TermSearchMostRelevantParams): Promise<RepositoryFindResult<Product>> {
+    const { productIds, filters, shop, mainGender } = params
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+
+    const totalResult = await productCatalog.productRepository.findCatalog(
+      {
+        fields: ['id', 'stock', 'gender'],
+        filters: {
+          id: { operator: Where.IN, value: productIds },
+          published: { operator: Where.EQUALS, value: true },
+          ...filterHelper.buildFilterQuery(filters || {}),
+        },
+        options: {
+          minimal: ['price'],
+          maximum: ['price'],
+          ...(isEmpty(filters?.brands) ? { distinct: ['brand'] } : {}),
+        },
+      },
+      mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'),
+    )
+
+    return this.sortByTermRelevance({
+      productIds,
+      totalResult,
+      limits: params.limits,
+      filters,
+      fieldsHelper: this.helpersService.getFieldsHelper(),
+    })
+  }
+
+  private async searchDefault(params: TermSearchDefaultParams): Promise<RepositoryFindResult<Product>> {
+    const { productIds, filters, limits, shop, mainGender, fields } = params
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+
+    return productCatalog.productRepository.findCatalog(
+      {
+        fields,
+        filters: {
+          id: { operator: Where.IN, value: productIds },
+          published: { operator: Where.EQUALS, value: true },
+          ...filterHelper.buildFilterQuery(filters || {}),
+        },
+        limits,
+        options: {
+          minimal: ['price'],
+          maximum: ['price'],
+          distinct: ['brand'],
+        },
+      },
+      mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'),
+    )
+  }
+
+  private sortByTermRelevance(params: SortByTermRelevanceParams) {
+    const { productIds, totalResult, limits, filters, fieldsHelper } = params
+    const defaultGender = filters?.gender?.at(0) || 'male'
+    const stockData = totalResult.data.filter((product: any) => product.stock.quantity > 0)
+    const stockOut = totalResult.data.filter((product: any) => product.stock.quantity <= 0)
+
+    const productIdsStockGender = productIds.filter((product) =>
+      stockData.some(
+        (result: any) =>
+          result.id === product && (result.gender?.includes(defaultGender) || result.gender?.includes('unisex')),
+      ),
+    )
+
+    const productIdsStockNotGender = productIds.filter((product) =>
+      stockData.some(
+        (result: any) =>
+          result.id === product && !result.gender?.includes(defaultGender) && !result.gender?.includes('unisex'),
+      ),
+    )
+
+    const productIdsStock = productIdsStockGender.concat(productIdsStockNotGender)
+    const productIdsStockOut = productIds.filter((product) => stockOut.some((result: any) => result.id === product))
+
+    const limitedProductId = productIdsStock
+      .concat(productIdsStockOut)
+      .slice(limits.offset, limits.offset + limits.limit)
+
+    const orderedId = productIds.filter((product) => limitedProductId.includes(product))
+
+    return this.getDetailedProducts(orderedId, totalResult, fieldsHelper)
+  }
+
+  private async getDetailedProducts(orderedId: string[], totalResult: any, fieldsHelper: any) {
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const fields = fieldsHelper.getStandardFields()
+    const productResult = await productCatalog.productRepository.findCatalog({
+      filters: {
+        id: { operator: Where.IN, value: orderedId },
+      },
+      fields,
+    })
+
+    return {
+      data: orderedId.map((id) => productResult.data.find((product) => product.id === id)).filter(Boolean),
+      count: totalResult.count,
+      maximum: totalResult.maximum,
+      minimal: totalResult.minimal,
+      distinct: totalResult.distinct,
+    }
+  }
+
+  private async findCatalogIdsBySearch(term: string, shop: Shops): Promise<string[]> {
+    if (this.productsByTerm[term]) return this.productsByTerm[term]
+
+    const productServices = this.repositoryService.getProductServices()
+
+    return (this.productsByTerm[term] = await productServices.productSearch
+      .search<ProductSearch>(term, 999, shop === Shops.GLAMSHOP ? 'female' : 'male')
+      .then((products) => [...new Set(products.map((product) => product.id))]))
+  }
+}

package/src/services/catalog/strategies/types/strategy-params.type.ts

@@ -0,0 +1,58 @@
+import { RepositoryCacheOptions, Shops } from '@infrab4a/connect'
+
+export type SearchWithMostRelevantParams = {
+  category: any
+  filters: any
+  limits: any
+  shop: Shops
+  mainGender: any
+  optionsCache: { cache?: RepositoryCacheOptions } | undefined
+  fields: any
+}
+
+export type SearchDefaultParams = {
+  category: any
+  filters: any
+  limits: any
+  shop: Shops
+  mainGender: any
+  sort: any
+  optionsCache: { cache?: RepositoryCacheOptions } | undefined
+  fields: any
+}
+
+export type FindAndSortByMostRelevantParams = {
+  mostRelevants: string[]
+  productIds: string[]
+  filters: any
+  limits: any
+  shop: Shops
+  mainGender: any
+  optionsCache: { cache?: RepositoryCacheOptions } | undefined
+  fields: any
+}
+
+export type TermSearchMostRelevantParams = {
+  productIds: string[]
+  filters: any
+  limits: any
+  mainGender: any
+  shop: Shops
+}
+
+export type TermSearchDefaultParams = {
+  productIds: string[]
+  filters: any
+  limits: any
+  mainGender: any
+  shop: Shops
+  fields: any
+}
+
+export type SortByTermRelevanceParams = {
+  productIds: string[]
+  totalResult: any
+  limits: any
+  filters: any
+  fieldsHelper: any
+}

package/src/services/catalog/types/fetch-products-options.type.ts

@@ -0,0 +1,10 @@
+import { ProductGender } from '@infrab4a/connect'
+
+import { ProductSort } from './product-sort.type'
+
+export type FetchProductsOptions = {
+  page?: number
+  perPage?: number
+  sort?: ProductSort
+  mainGender?: ProductGender
+}

package/src/services/catalog/types/fetch-products-params.type.ts

@@ -0,0 +1,27 @@
+import { Category } from '@infrab4a/connect'
+
+import { CatalogFilters } from '../../../interfaces'
+
+import { FetchProductsOptions } from './fetch-products-options.type'
+
+export type FetchProductsMainParams<T extends Category> = {
+  category?: T
+  profile?: string[]
+  term?: string
+}
+
+export type FetchProductsParams<T extends Category> = FetchProductsOptions &
+  (
+    | {
+        category: FetchProductsMainParams<T>['category']
+        filters?: CatalogFilters & { customOptions?: never }
+      }
+    | {
+        profile: FetchProductsMainParams<T>['profile']
+        filters?: CatalogFilters & { customOptions?: never; tags?: never }
+      }
+    | {
+        term: FetchProductsMainParams<T>['term']
+        filters?: CatalogFilters & { customOptions?: never }
+      }
+  )

package/src/services/catalog/types/fetch-products-response.type.ts

@@ -0,0 +1,11 @@
+import { Product } from '@infrab4a/connect'
+
+export type FetchProductsResponse = {
+  products: { data: Product[]; total: number }
+  pages: number
+  prices: {
+    price: { min: number; max: number }
+    subscriberPrice: { min: number; max: number }
+  }
+  brands?: string[]
+}

package/src/services/catalog/types/index.ts

@@ -0,0 +1,5 @@
+export * from './fetch-products-options.type'
+export * from './fetch-products-params.type'
+export * from './fetch-products-response.type'
+export * from './method-params.type'
+export * from './product-sort.type'

package/src/services/catalog/types/method-params.type.ts

@@ -0,0 +1,21 @@
+import { Category, Product, Shops } from '@infrab4a/connect'
+
+import { CatalogSearchParams } from '../../../interfaces'
+
+import { FetchProductsParams } from './fetch-products-params.type'
+
+export type StockNotificationParams = {
+  shop: Shops
+  productId: string
+  name: string
+  email: string
+}
+
+export type BuildResponseParams<T extends Category = Category> = {
+  data: Product[]
+  total: number
+  maximum: any
+  minimal: any
+  searchParams: CatalogSearchParams
+  options: FetchProductsParams<T>
+}

package/src/services/catalog/types/product-sort.type.ts

@@ -0,0 +1,3 @@
+import { ProductSorts } from '../enums'
+
+export type ProductSort = `${ProductSorts}`

package/src/services/catalog/wishlist.service.ts

@@ -0,0 +1,368 @@
+import { Inject, Injectable } from '@angular/core'
+import {
+  LogRepository,
+  PersonType,
+  PersonTypes,
+  Product,
+  Shops,
+  Wishlist,
+  WishlistLogType,
+  WishlistRepository,
+} from '@infrab4a/connect'
+
+import { DEFAULT_SHOP } from '../../consts'
+
+import { CatalogService } from './catalog.service'
+import { CategoryService } from './category.service'
+import { CatalogServiceFacade, CategoryServiceFacade } from './facades'
+
+@Injectable()
+export class WishlistService {
+  private catalogService: CatalogService
+  private categoryService: CategoryService
+
+  constructor(
+    @Inject('WishlistRepository') private readonly wishlistRepository: WishlistRepository,
+    @Inject(DEFAULT_SHOP) private readonly shop: Shops,
+    @Inject('LogRepository') private readonly logRepository: LogRepository,
+  ) {}
+
+  initializeServices(catalogServiceFacade: CatalogServiceFacade, categoryServiceFacade: CategoryServiceFacade): void {
+    this.catalogService = catalogServiceFacade.getCatalogService()
+    this.categoryService = categoryServiceFacade.getCategoryService()
+  }
+
+  getCatalogService() {
+    return this.catalogService
+  }
+
+  getCategoryService() {
+    return this.categoryService
+  }
+
+  async create({
+    personId,
+    title,
+    description,
+    published,
+    userFullName,
+    userPhoto,
+    theme,
+    bannerUrl,
+    personType,
+    personIsSubscriber,
+  }: {
+    personId: string
+    title: string
+    description: string
+    published: boolean
+    userFullName: string
+    userPhoto?: string
+    theme?: string
+    bannerUrl?: string
+    personType?: PersonType
+    personIsSubscriber?: boolean
+  }): Promise<Wishlist> {
+    const wishlistData = this.buildWishlistData({
+      title,
+      description,
+      published,
+      userFullName,
+      userPhoto,
+      theme,
+      bannerUrl,
+      personType,
+      personIsSubscriber,
+      personId,
+    })
+
+    const existingWishlist = await this.findExistingWishlistByPersonId(personId)
+
+    await this.createWishlistLog(WishlistLogType.CREATE, wishlistData as Wishlist)
+
+    if (existingWishlist) return existingWishlist
+
+    return this.createNewWishlist(wishlistData)
+  }
+
+  private buildWishlistData({
+    title,
+    description,
+    published,
+    userFullName,
+    userPhoto,
+    theme,
+    bannerUrl,
+    personType,
+    personIsSubscriber,
+    personId,
+  }: {
+    title: string
+    description: string
+    published: boolean
+    userFullName: string
+    userPhoto?: string
+    theme?: string
+    bannerUrl?: string
+    personType?: PersonType
+    personIsSubscriber?: boolean
+    personId: string
+  }) {
+    return {
+      slug: '',
+      name: title,
+      description,
+      metadatas: [
+        {
+          shop: this.shop,
+          title: `${userFullName} - ${title}`,
+          description: `${userFullName} - ${description}`,
+        },
+      ],
+      shop: this.shop,
+      shops: [this.shop],
+      personId,
+      personName: userFullName,
+      personPhoto: userPhoto,
+      brandCategory: false,
+      published,
+      theme,
+      bannerUrl,
+      personType: personType ?? PersonTypes.NONE,
+      personIsSubscriber: personIsSubscriber ?? false,
+    }
+  }
+
+  private async findExistingWishlistByPersonId(personId: string): Promise<Wishlist | null> {
+    const hasWishlist = await this.wishlistRepository
+      .find({
+        filters: {
+          personId,
+        },
+        options: {
+          enableCount: false,
+        },
+        orderBy: {
+          id: 'asc',
+        },
+      })
+      .then((res) => res.data)
+
+    return hasWishlist.length ? hasWishlist.at(0) : null
+  }
+
+  private async createNewWishlist(data: any): Promise<Wishlist> {
+    const newWishlist = await this.wishlistRepository.create(data)
+
+    await this.wishlistRepository.update({ id: newWishlist.id, slug: newWishlist.id })
+
+    return Wishlist.toInstance({ ...newWishlist.toPlain(), slug: newWishlist.id })
+  }
+
+  async update({
+    id,
+    title,
+    description,
+    published,
+    userFullName,
+    userPhoto,
+    theme,
+    bannerUrl,
+    personType,
+    personIsSubscriber,
+  }: {
+    id: string
+    title: string
+    description: string
+    published: boolean
+    userFullName: string
+    userPhoto?: string
+    theme?: string
+    bannerUrl?: string
+    personType?: PersonType
+    personIsSubscriber?: boolean
+  }): Promise<Wishlist> {
+    const data = {
+      id,
+      name: title,
+      description,
+      published,
+      metadatas: [
+        {
+          shop: this.shop,
+          title: `${userFullName} - ${title}`,
+          description: `${userFullName} - ${description}`,
+        },
+      ],
+      personName: userFullName,
+      personPhoto: userPhoto,
+      theme,
+      bannerUrl,
+      personType: personType ?? PersonTypes.NONE,
+      personIsSubscriber: personIsSubscriber ?? false,
+    }
+
+    await this.createWishlistLog(WishlistLogType.UPDATE, data as Wishlist)
+
+    return this.wishlistRepository.update(data)
+  }
+
+  async delete(wishlistId: string): Promise<void> {
+    const wishlist = await this.findById(wishlistId)
+
+    await this.createWishlistLog(WishlistLogType.DELETE, wishlist)
+
+    return this.wishlistRepository.delete({ id: wishlistId })
+  }
+
+  getWishlistBySlug(slug: string): Promise<Wishlist> {
+    const [id] = slug.split('-')
+
+    if (+id) return this.wishlistRepository.get({ id })
+
+    return this.wishlistRepository.getWishlistBySlug(slug)
+  }
+
+  getWishlistsByPerson(personId: string): Promise<Wishlist[]> {
+    return this.wishlistRepository.getWishlistByPerson(personId)
+  }
+
+  async addProduct(wishlistId: string, productId: string): Promise<Wishlist> {
+    const wishlist = await this.wishlistRepository.get({ id: wishlistId })
+    const hasProduct = wishlist.products.some((p) => p == productId)
+
+    const wishlistData = await this.findById(wishlistId)
+    const productData = await this.findProductById(productId)
+
+    await this.createWishlistLog(WishlistLogType.ADD_PRODUCT, wishlistData, productData)
+
+    if (!hasProduct) {
+      wishlist.products = [...wishlist.products, productId]
+      await this.wishlistRepository.addProduct(wishlistId, productId)
+    }
+
+    return wishlist
+  }
+
+  async removeProduct(wishlistId: string, productId: string): Promise<Wishlist> {
+    const wishlist = await this.wishlistRepository.get({ id: wishlistId })
+    const productIndex = wishlist.products.findIndex((p) => p == productId)
+
+    if (productIndex != -1) {
+      wishlist.products.splice(productIndex, 1)
+      const wishlistData = await this.findById(wishlistId)
+      const productData = await this.findProductById(productId)
+
+      await this.createWishlistLog(WishlistLogType.REMOVE_PRODUCT, wishlistData, productData)
+      await this.wishlistRepository.removeProduct(wishlistId, productId)
+    }
+
+    return wishlist
+  }
+
+  private async findById(id: string): Promise<Wishlist> {
+    return this.wishlistRepository
+      .find({
+        fields: ['id', 'name', 'description', 'personId', 'personIsSubscriber', 'personType', 'personName'],
+        filters: {
+          id,
+        },
+      })
+      .then((res) => res.data.at(0))
+  }
+
+  private async findProductById(id: string): Promise<Product> {
+    if (!this.catalogService) {
+      throw new Error('CatalogService not initialized. Call initializeServices first.')
+    }
+
+    // Acessar o ProductRepository através do CatalogHelpersService
+    const helpersService = this.catalogService['helpersService'] as any
+    const productServices = helpersService.getProductServices()
+
+    return productServices.productRepository
+      .find({
+        fields: ['id', 'sku', 'EAN', 'name', 'brand'],
+        filters: {
+          id,
+        },
+      })
+      .then((res) => res.data.at(0))
+  }
+
+  private async createWishlistLog(type: WishlistLogType, wishlist: Wishlist, product?: Product) {
+    switch (type) {
+      case WishlistLogType.CREATE:
+      case WishlistLogType.UPDATE:
+      case WishlistLogType.DELETE:
+        await this.createWishlistOperationLog(type, wishlist)
+        break
+
+      case WishlistLogType.ADD_PRODUCT:
+      case WishlistLogType.REMOVE_PRODUCT:
+        await this.createWishlistProductLog(type, wishlist, product)
+        break
+
+      default:
+        break
+    }
+  }
+
+  private async createWishlistOperationLog(type: WishlistLogType, wishlist: Wishlist): Promise<void> {
+    const operation = this.getOperationTypeFromWishlistLogType(type)
+
+    await this.logRepository.create({
+      collection: 'wishlist',
+      date: new Date(),
+      operation,
+      documentId: wishlist.id,
+      document: this.buildWishlistLogDocument(wishlist, type),
+    })
+  }
+
+  private async createWishlistProductLog(type: WishlistLogType, wishlist: Wishlist, product: Product): Promise<void> {
+    await this.logRepository.create({
+      collection: 'wishlist',
+      date: new Date(),
+      operation: 'UPDATE',
+      documentId: wishlist.id,
+      document: {
+        ...this.buildWishlistLogDocument(wishlist, type),
+        ...this.buildProductLogData(product),
+      },
+    })
+  }
+
+  private getOperationTypeFromWishlistLogType(type: WishlistLogType): 'CREATE' | 'UPDATE' | 'DELETE' {
+    if (type === WishlistLogType.CREATE) return 'CREATE'
+
+    if (type === WishlistLogType.UPDATE) return 'UPDATE'
+
+    return 'DELETE'
+  }
+
+  private buildWishlistLogDocument(wishlist: Wishlist, type: WishlistLogType) {
+    return {
+      id: wishlist.id,
+      shop: this.shop,
+      name: wishlist.name,
+      description: wishlist.description,
+      published: wishlist.published,
+      type: type,
+      personType: wishlist.personType,
+      personId: wishlist.personId,
+      personName: wishlist.personName,
+      personIsSubscriber: wishlist.personIsSubscriber,
+    }
+  }
+
+  private buildProductLogData(product: Product) {
+    return {
+      productId: product.id,
+      productEAN: product.EAN,
+      productSKU: product.sku,
+      productName: product.name,
+      productBrand: product.brand,
+    }
+  }
+}

package/src/services/checkout/checkout-dependencies.facade.ts

@@ -0,0 +1,13 @@
+import { HttpClient } from '@angular/common/http'
+import { Inject, Injectable } from '@angular/core'
+
+import { PERSISTENCE_PROVIDER } from '../../consts'
+import { DataPersistence } from '../../persistence'
+
+@Injectable()
+export class CheckoutDependenciesFacade {
+  constructor(
+    @Inject(PERSISTENCE_PROVIDER) public readonly dataPersistence: DataPersistence,
+    public readonly httpClient: HttpClient,
+  ) {}
+}