@infrab4a/connect-angular 5.8.12 → 5.8.13

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

@@ -1,3 +0,0 @@
-export * from './category-search.strategy'
-export * from './profile-search.strategy'
-export * from './term-search.strategy'

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

@@ -1,51 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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