@infrab4a/connect-angular 5.8.3 → 5.8.4

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

@@ -0,0 +1,51 @@
+import { Injectable } from '@angular/core'
+import { Product, RepositoryCacheOptions, RepositoryFindResult, Shops, Where } from '@infrab4a/connect'
+
+import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces'
+import { CatalogHelpersService, CatalogRepositoryService } from '../services'
+
+@Injectable()
+export class ProfileSearchStrategy implements CatalogSearchStrategy {
+  constructor(
+    private readonly repositoryService: CatalogRepositoryService,
+    private readonly helpersService: CatalogHelpersService,
+  ) {}
+
+  async search(
+    params: CatalogSearchParams,
+    shop: Shops,
+    optionsCache?: { cache?: RepositoryCacheOptions },
+  ): Promise<RepositoryFindResult<Product>> {
+    const { profile, filters, limits, sort, mainGender } = params
+
+    if (!profile) {
+      throw new Error('Profile is required for ProfileSearchStrategy')
+    }
+
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+    const sortHelper = this.helpersService.getSortHelper()
+    const fieldsHelper = this.helpersService.getFieldsHelper()
+
+    const repoParams = {
+      fields: fieldsHelper.getStandardFields(),
+      filters: {
+        tagsProfile: { operator: Where.LIKE, value: profile },
+        ...filterHelper.buildFilterQuery(filters || {}),
+      },
+      ...(sort ? { orderBy: sortHelper.buildSortQuery(sort) } : {}),
+      limits,
+      options: {
+        minimal: ['price'],
+        maximum: ['price'],
+        distinct: ['brand'],
+      },
+    }
+
+    return productCatalog.productCatalogRepository.findCatalog(
+      repoParams,
+      mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'),
+      optionsCache,
+    )
+  }
+}

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

@@ -0,0 +1,163 @@
+import { Injectable } from '@angular/core'
+import {
+  isEmpty,
+  Product,
+  ProductSearch,
+  RepositoryCacheOptions,
+  RepositoryFindResult,
+  Shops,
+  Where,
+} 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,
+      sort,
+      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.productCatalogRepository.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, sort, shop, mainGender, fields } = params
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+    const sortHelper = this.helpersService.getSortHelper()
+
+    return productCatalog.productCatalogRepository.findCatalog(
+      {
+        fields,
+        filters: {
+          id: { operator: Where.IN, value: productIds },
+          published: { operator: Where.EQUALS, value: true },
+          ...filterHelper.buildFilterQuery(filters || {}),
+        },
+        limits,
+        ...(sort ? { orderBy: sortHelper.buildSortQuery(sort) } : {}),
+        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 productIdsStock = productIds.filter((product) => stockData.some((result: any) => result.id === product))
+    const productIdsStockOut = productIds.filter((product) => stockOut.some((result: any) => result.id === product))
+    const limitedProductId = productIdsStock
+      .concat(productIdsStockOut)
+      .slice(limits.offset, limits.offset + limits.limit)
+
+    return this.getDetailedProducts(limitedProductId, totalResult, fieldsHelper)
+  }
+
+  private async getDetailedProducts(orderedId: string[], totalResult: any, fieldsHelper: any) {
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const fields = fieldsHelper.getStandardFields()
+    const productResult = await productCatalog.productCatalogRepository.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,59 @@
+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
+  sort?: 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}`