@infrab4a/connect-angular 5.8.12 → 5.8.13

package/src/services/catalog/context/catalog-search.context.ts

@@ -1,59 +0,0 @@
-import { Product, RepositoryCacheOptions, RepositoryFindResult, Shops } from '@infrab4a/connect'
-
-import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces'
-
-export class CatalogSearchContext {
-  private strategies = new Map<string, CatalogSearchStrategy>()
-
-  constructor(
-    private readonly categoryStrategy: CatalogSearchStrategy,
-    private readonly termStrategy: CatalogSearchStrategy,
-    private readonly profileStrategy: CatalogSearchStrategy,
-  ) {
-    this.initializeStrategies()
-  }
-
-  async executeSearch(
-    params: CatalogSearchParams,
-    shop: Shops,
-    optionsCache?: { cache?: RepositoryCacheOptions },
-  ): Promise<RepositoryFindResult<Product>> {
-    const strategy = this.selectStrategy(params)
-
-    return strategy.search(params, shop, optionsCache)
-  }
-
-  private initializeStrategies(): void {
-    this.strategies.set('category', this.categoryStrategy)
-    this.strategies.set('term', this.termStrategy)
-    this.strategies.set('profile', this.profileStrategy)
-  }
-
-  private selectStrategy(params: CatalogSearchParams): CatalogSearchStrategy {
-    if (params.category) {
-      const strategy = this.strategies.get('category')
-
-      if (!strategy) throw new Error('Category strategy not found')
-
-      return strategy
-    }
-
-    if (params.term) {
-      const strategy = this.strategies.get('term')
-
-      if (!strategy) throw new Error('Term strategy not found')
-
-      return strategy
-    }
-
-    if (params.profile?.length) {
-      const strategy = this.strategies.get('profile')
-
-      if (!strategy) throw new Error('Profile strategy not found')
-
-      return strategy
-    }
-
-    throw new Error('No valid search strategy found for the given parameters')
-  }
-}

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

@@ -1 +0,0 @@
-export * from './product-sorts.enum'

package/src/services/catalog/enums/product-sorts.enum.ts

@@ -1,9 +0,0 @@
-export enum ProductSorts {
-  MOST_RELEVANT = 'most-relevant',
-  BEST_SELLER = 'best-sellers',
-  BIGGEST_PRICE = 'biggest-price',
-  LOWEST_PRICE = 'lowest-price',
-  BIGGEST_DISCOUNT = 'biggest-discount',
-  BEST_RATING = 'best-rating',
-  NEWS = 'news',
-}

package/src/services/catalog/facades/catalog-service.facade.ts

@@ -1,32 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { Shops } from '@infrab4a/connect'
-
-import { DEFAULT_SHOP } from '../../../consts'
-import { CatalogService } from '../catalog.service'
-import { CatalogSearchContext } from '../context/catalog-search.context'
-import { CatalogHelpersService } from '../services'
-
-import { CatalogStrategiesFacade } from './catalog-strategies.facade'
-
-@Injectable()
-export class CatalogServiceFacade {
-  private catalogService: CatalogService
-
-  constructor(
-    private readonly helpersService: CatalogHelpersService,
-    private readonly strategiesFacade: CatalogStrategiesFacade,
-    @Inject(DEFAULT_SHOP) private readonly shop: Shops,
-  ) {
-    const searchContext = new CatalogSearchContext(
-      this.strategiesFacade.categoryStrategy,
-      this.strategiesFacade.termStrategy,
-      this.strategiesFacade.profileStrategy,
-    )
-
-    this.catalogService = new CatalogService(searchContext, this.helpersService, this.shop)
-  }
-
-  getCatalogService(): CatalogService {
-    return this.catalogService
-  }
-}

package/src/services/catalog/facades/catalog-strategies.facade.ts

@@ -1,12 +0,0 @@
-import { Injectable } from '@angular/core'
-
-import { CategorySearchStrategy, ProfileSearchStrategy, TermSearchStrategy } from '../strategies'
-
-@Injectable()
-export class CatalogStrategiesFacade {
-  constructor(
-    public readonly categoryStrategy: CategorySearchStrategy,
-    public readonly termStrategy: TermSearchStrategy,
-    public readonly profileStrategy: ProfileSearchStrategy,
-  ) {}
-}

package/src/services/catalog/facades/category-repository.facade.ts

@@ -1,10 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { CategoryFilterRepository, CategoryRepository } from '@infrab4a/connect'
-
-@Injectable()
-export class CategoryRepositoryFacade {
-  constructor(
-    @Inject('CategoryRepository') public readonly categoryRepository: CategoryRepository,
-    @Inject('CategoryFilterRepository') public readonly categoryFilterRepository: CategoryFilterRepository,
-  ) {}
-}

package/src/services/catalog/facades/category-service.facade.ts

@@ -1,25 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { Shops } from '@infrab4a/connect'
-
-import { DEFAULT_SHOP } from '../../../consts'
-import { CategoryService } from '../category.service'
-
-import { CategoryRepositoryFacade } from './category-repository.facade'
-import { ProductCatalogFacade } from './product-catalog.facade'
-
-@Injectable()
-export class CategoryServiceFacade {
-  private categoryService: CategoryService
-
-  constructor(
-    private readonly categoryRepositoryFacade: CategoryRepositoryFacade,
-    private readonly productCatalogFacade: ProductCatalogFacade,
-    @Inject(DEFAULT_SHOP) private readonly shop: Shops,
-  ) {
-    this.categoryService = new CategoryService(this.categoryRepositoryFacade, this.productCatalogFacade, this.shop)
-  }
-
-  getCategoryService(): CategoryService {
-    return this.categoryService
-  }
-}

package/src/services/catalog/facades/product-catalog.facade.ts

@@ -1,13 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { ProductCatalogRepository } from '@infrab4a/connect'
-
-import { CATEGORY_STRUCTURE } from '../../../consts'
-import { CategoryStructureAdapter } from '../adapters'
-
-@Injectable()
-export class ProductCatalogFacade {
-  constructor(
-    @Inject('ProductCatalogRepository') public readonly productCatalogRepository: ProductCatalogRepository,
-    @Inject(CATEGORY_STRUCTURE) public readonly categoryStructureAdapter: CategoryStructureAdapter,
-  ) {}
-}

package/src/services/catalog/helpers/brand-manager.helper.ts

@@ -1,69 +0,0 @@
-import { Injectable } from '@angular/core'
-import { isEmpty, Where } from '@infrab4a/connect'
-
-import { CatalogSearchParams } from '../../../interfaces'
-import { ProductCatalogFacade } from '../facades'
-
-@Injectable()
-export class BrandManagerHelper {
-  private brandsList: Record<string, string[]> = {}
-
-  constructor(private readonly productCatalog: ProductCatalogFacade) {}
-
-  async setBrandsList(options: CatalogSearchParams, brands: string[]): Promise<void> {
-    const filterBrands = options.filters?.brands
-    const indexKey = this.buildIndexBrands(options)
-
-    if (isEmpty(brands) && options.filters) {
-      delete options.filters.brands
-    }
-
-    this.brandsList[indexKey] = this.brandsList[indexKey] || brands || (await this.fetchBrandsOnly(options))
-    this.brandsList[indexKey] = this.brandsList[indexKey].filter(Boolean)
-
-    if (options.filters) {
-      options.filters = {
-        ...options.filters,
-        brands: filterBrands,
-      }
-    }
-  }
-
-  getBrandsList(indexKey: string): string[] {
-    return this.brandsList[indexKey]
-  }
-
-  buildIndexBrands(options: CatalogSearchParams): string {
-    if (options.category) return `category-${options.category.id}`
-
-    if (options.term) return `term-${options.term}`
-
-    if (options.profile) return `profile-${options.profile.join(',')}`
-
-    return ''
-  }
-
-  private async fetchBrandsOnly(options: CatalogSearchParams): Promise<string[]> {
-    let filters = {}
-
-    if (options.category) {
-      filters = await this.productCatalog.categoryStructureAdapter.buildProductFilterByCategory(options.category)
-    }
-
-    return this.productCatalog.productCatalogRepository
-      .findCatalog(
-        {
-          fields: ['id'],
-          filters: {
-            ...filters,
-            published: { operator: Where.EQUALS, value: true },
-          },
-          options: {
-            distinct: ['brand'],
-          },
-        },
-        options.mainGender,
-      )
-      .then((result) => result.distinct.brand)
-  }
-}

package/src/services/catalog/helpers/catalog-filter.helper.ts

@@ -1,50 +0,0 @@
-import { Injectable } from '@angular/core'
-import { Product, RepositoryFindFielters, set, Where } from '@infrab4a/connect'
-
-import { CatalogFilters } from '../../../interfaces'
-
-@Injectable()
-export class CatalogFilterHelper {
-  buildFilterQuery(filters: CatalogFilters): RepositoryFindFielters<Product> {
-    const filterQuery = {} as RepositoryFindFielters<Product>
-
-    if (filters.clubDiscount?.length) {
-      set(filterQuery, 'price.subscriberDiscountPercentage', {
-        operator: Where.IN,
-        value: filters.clubDiscount,
-      })
-    }
-
-    if (filters.brands?.length) {
-      filterQuery.brand = { operator: Where.IN, value: filters.brands }
-    }
-
-    if (filters.gender?.length) {
-      filterQuery.gender = { operator: Where.IN, value: filters.gender }
-    }
-
-    if (filters.prices?.min || filters.prices?.max) {
-      const priceField = filters.prices.subscriberPrice ? 'price.subscriberPrice' : 'price.price'
-      const priceFilters = [
-        ...(filters.prices.min ? [{ operator: Where.GTE, value: Math.floor(filters.prices.min) }] : []),
-        ...(filters.prices.max ? [{ operator: Where.LTE, value: Math.ceil(filters.prices.max) }] : []),
-      ]
-
-      set(filterQuery, priceField, priceFilters)
-    }
-
-    if (filters.rate) {
-      filterQuery.rate = { operator: Where.GTE, value: filters.rate }
-    }
-
-    if (filters.tags?.length) {
-      filterQuery.tagsProfile = { operator: Where.LIKE, value: filters.tags }
-    }
-
-    if (filters.customOptions?.length) {
-      filterQuery.filters = { operator: Where.LIKE, value: filters.customOptions }
-    }
-
-    return filterQuery
-  }
-}

package/src/services/catalog/helpers/catalog-sort.helper.ts

@@ -1,54 +0,0 @@
-import { Injectable } from '@angular/core'
-import { Product, RepositoryOrderBy } from '@infrab4a/connect'
-
-@Injectable()
-export class CatalogSortHelper {
-  buildSortQuery(sort: string): RepositoryOrderBy<Product> {
-    if (!sort || sort === 'most-relevant') return {}
-
-    switch (sort) {
-      case 'best-sellers':
-        return {
-          shoppingCount: 'desc',
-          rate: 'desc',
-          stock: 'desc',
-          name: 'asc',
-        }
-
-      case 'biggest-price':
-        return {
-          subscriberPrice: 'desc',
-          rate: 'desc',
-          shoppingCount: 'desc',
-        } as any
-
-      case 'lowest-price':
-        return {
-          subscriberPrice: 'asc',
-          rate: 'desc',
-          shoppingCount: 'desc',
-        } as any
-
-      case 'best-rating':
-        return {
-          rate: 'desc',
-          shoppingCount: 'desc',
-          stock: 'desc',
-          name: 'asc',
-        }
-
-      case 'news':
-        return { createdAt: 'desc' }
-
-      case 'biggest-discount':
-        return {
-          subscriberDiscountPercentage: 'desc',
-          rate: 'desc',
-          shoppingCount: 'desc',
-        } as any
-
-      default:
-        return {}
-    }
-  }
-}

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

@@ -1,4 +0,0 @@
-export * from './brand-manager.helper'
-export * from './catalog-filter.helper'
-export * from './catalog-sort.helper'
-export * from './product-fields.helper'

package/src/services/catalog/helpers/product-fields.helper.ts

@@ -1,39 +0,0 @@
-import { Injectable } from '@angular/core'
-import { NonFunctionPropertyNames, Product } from '@infrab4a/connect'
-
-@Injectable()
-export class ProductFieldsHelper {
-  getStandardFields(): NonFunctionPropertyNames<Product>[] {
-    return [
-      'id',
-      'name',
-      'slug',
-      'images',
-      'imagesCard',
-      'miniatures',
-      'price',
-      'stock',
-      'published',
-      'CEST',
-      'EAN',
-      'NCM',
-      'brand',
-      'costPrice',
-      'hasVariants',
-      'isKit',
-      'sku',
-      'rate',
-      'tagsProfile',
-      'tagsCollection',
-      'type',
-      'shoppingCount',
-      'gender',
-      'createdAt',
-      'label',
-      'outlet',
-      'group',
-      'variantSlug',
-      'filters',
-    ]
-  }
-}

package/src/services/catalog/index.ts

@@ -1,7 +0,0 @@
-export * from './adapters'
-export * from './catalog.service'
-export * from './category.service'
-export * from './enums'
-export * from './models'
-export * from './types'
-export * from './wishlist.service'

package/src/services/catalog/models/category-with-tree.model.ts

@@ -1,7 +0,0 @@
-import { Type } from 'class-transformer'
-import { Category } from '@infrab4a/connect'
-
-export class CategoryWithTree extends Category {
-  @Type(() => CategoryWithTree)
-  children?: CategoryWithTree[]
-}

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

@@ -1 +0,0 @@
-export * from './category-with-tree.model'

package/src/services/catalog/services/catalog-helpers.service.ts

@@ -1,35 +0,0 @@
-import { Injectable } from '@angular/core'
-
-import { ProductServicesFacade } from '../../../interfaces'
-import { BrandManagerHelper, CatalogFilterHelper, CatalogSortHelper, ProductFieldsHelper } from '../helpers'
-
-import { CatalogOperationsFacade } from './catalog-operations.facade'
-import { ProductManagementFacade } from './product-management.facade'
-
-@Injectable()
-export class CatalogHelpersService {
-  constructor(
-    private readonly catalogOperations: CatalogOperationsFacade,
-    private readonly productManagement: ProductManagementFacade,
-  ) {}
-
-  getFilterHelper(): CatalogFilterHelper {
-    return this.catalogOperations.getFilterHelper()
-  }
-
-  getSortHelper(): CatalogSortHelper {
-    return this.catalogOperations.getSortHelper()
-  }
-
-  getFieldsHelper(): ProductFieldsHelper {
-    return this.catalogOperations.getFieldsHelper()
-  }
-
-  getBrandManager(): BrandManagerHelper {
-    return this.productManagement.getBrandManager()
-  }
-
-  getProductServices(): ProductServicesFacade {
-    return this.productManagement.getProductServices()
-  }
-}

package/src/services/catalog/services/catalog-operations.facade.ts

@@ -1,24 +0,0 @@
-import { Injectable } from '@angular/core'
-
-import { CatalogFilterHelper, CatalogSortHelper, ProductFieldsHelper } from '../helpers'
-
-@Injectable()
-export class CatalogOperationsFacade {
-  constructor(
-    private readonly filterHelper: CatalogFilterHelper,
-    private readonly sortHelper: CatalogSortHelper,
-    private readonly fieldsHelper: ProductFieldsHelper,
-  ) {}
-
-  getFilterHelper(): CatalogFilterHelper {
-    return this.filterHelper
-  }
-
-  getSortHelper(): CatalogSortHelper {
-    return this.sortHelper
-  }
-
-  getFieldsHelper(): ProductFieldsHelper {
-    return this.fieldsHelper
-  }
-}

package/src/services/catalog/services/catalog-repository.service.ts

@@ -1,20 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-
-import { ProductServicesFacade } from '../../../interfaces'
-import { ProductCatalogFacade } from '../facades'
-
-@Injectable()
-export class CatalogRepositoryService {
-  constructor(
-    private readonly productCatalog: ProductCatalogFacade,
-    @Inject('ProductServicesFacade') private readonly productServices: ProductServicesFacade,
-  ) {}
-
-  getProductCatalog(): ProductCatalogFacade {
-    return this.productCatalog
-  }
-
-  getProductServices(): ProductServicesFacade {
-    return this.productServices
-  }
-}

package/src/services/catalog/services/product-management.facade.ts

@@ -1,20 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-
-import { ProductServicesFacade } from '../../../interfaces'
-import { BrandManagerHelper } from '../helpers'
-
-@Injectable()
-export class ProductManagementFacade {
-  constructor(
-    private readonly brandManager: BrandManagerHelper,
-    @Inject('ProductServicesFacade') private readonly productServices: ProductServicesFacade,
-  ) {}
-
-  getBrandManager(): BrandManagerHelper {
-    return this.brandManager
-  }
-
-  getProductServices(): ProductServicesFacade {
-    return this.productServices
-  }
-}

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

@@ -1,168 +0,0 @@
-import { Injectable } from '@angular/core'
-import { isEmpty, Product, RepositoryCacheOptions, RepositoryFindResult, Shops, Where } from '@infrab4a/connect'
-
-import { CatalogSearchParams, CatalogSearchStrategy } from '../../../interfaces'
-import { CatalogHelpersService, CatalogRepositoryService } from '../services'
-
-import {
-  FindAndSortByMostRelevantParams,
-  SearchDefaultParams,
-  SearchWithMostRelevantParams,
-} from './types/strategy-params.type'
-
-@Injectable()
-export class CategorySearchStrategy implements CatalogSearchStrategy {
-  constructor(
-    private readonly repositoryService: CatalogRepositoryService,
-    private readonly helpersService: CatalogHelpersService,
-  ) {}
-
-  async search(
-    params: CatalogSearchParams,
-    shop: Shops,
-    optionsCache?: { cache?: RepositoryCacheOptions },
-  ): Promise<RepositoryFindResult<Product>> {
-    const { category, filters, limits, sort, mainGender } = params
-
-    if (!category) {
-      throw new Error('Category is required for CategorySearchStrategy')
-    }
-
-    const fields = this.helpersService.getFieldsHelper().getStandardFields()
-
-    if (sort === 'most-relevant') {
-      return this.searchWithMostRelevant({
-        category,
-        filters,
-        limits,
-        shop,
-        mainGender,
-        optionsCache,
-        fields,
-      })
-    }
-
-    return this.searchDefault({
-      category,
-      filters,
-      limits,
-      shop,
-      mainGender,
-      sort,
-      optionsCache,
-      fields,
-    })
-  }
-
-  private async searchWithMostRelevant(params: SearchWithMostRelevantParams) {
-    const { category, filters, shop, optionsCache } = params
-    const mostRelevant = category.isWishlist ? [] : category.getMostRelevantByShop(shop)
-    const productsIds = await this.getProductIds(category, filters, optionsCache)
-
-    return this.findAndSortByMostRelevant({
-      mostRelevants: mostRelevant,
-      productIds: productsIds,
-      filters: params.filters,
-      limits: params.limits,
-      shop: params.shop,
-      mainGender: params.mainGender,
-      optionsCache: params.optionsCache,
-      fields: params.fields,
-    })
-  }
-
-  private async searchDefault(params: SearchDefaultParams) {
-    const { category, filters, limits, sort, optionsCache, fields } = params
-    const productCatalog = this.repositoryService.getProductCatalog()
-    const filterHelper = this.helpersService.getFilterHelper()
-    const sortHelper = this.helpersService.getSortHelper()
-
-    const repoParams = {
-      fields,
-      filters: {
-        ...(await productCatalog.categoryStructureAdapter.buildProductFilterByCategory(category)),
-        ...filterHelper.buildFilterQuery(filters || {}),
-      },
-      ...(sort ? { orderBy: sortHelper.buildSortQuery(sort) } : {}),
-      limits,
-      options: {
-        minimal: ['price'],
-        maximum: ['price'],
-        distinct: ['brand'],
-      },
-    }
-
-    return productCatalog.productCatalogRepository.findCatalog(repoParams, null, optionsCache)
-  }
-
-  private async getProductIds(category: any, filters: any, optionsCache: any): Promise<string[]> {
-    const productCatalog = this.repositoryService.getProductCatalog()
-    const filterHelper = this.helpersService.getFilterHelper()
-
-    return productCatalog.productCatalogRepository
-      .findCatalog(
-        {
-          fields: ['id'],
-          filters: {
-            ...(await productCatalog.categoryStructureAdapter.buildProductFilterByCategory(category)),
-            ...filterHelper.buildFilterQuery(filters || {}),
-          },
-        },
-        undefined,
-        optionsCache,
-      )
-      .then((products) => products.data.map((product) => product.id))
-  }
-
-  private async findAndSortByMostRelevant(
-    params: FindAndSortByMostRelevantParams,
-  ): Promise<RepositoryFindResult<Product>> {
-    const { mostRelevants, productIds, filters, shop, mainGender, optionsCache, fields, limits } = params
-    const productCatalog = this.repositoryService.getProductCatalog()
-    const filterHelper = this.helpersService.getFilterHelper()
-    const sortHelper = this.helpersService.getSortHelper()
-
-    const mostRelevantProductsIds = [...new Set(mostRelevants.concat(productIds))]
-    const totalResult = await productCatalog.productCatalogRepository.findCatalog(
-      {
-        fields,
-        filters: {
-          id: { operator: Where.IN, value: mostRelevantProductsIds },
-          ...filterHelper.buildFilterQuery(filters || {}),
-        },
-        orderBy: sortHelper.buildSortQuery('best-sellers'),
-        options: {
-          minimal: ['price'],
-          maximum: ['price'],
-          ...(isEmpty(filters?.brands) ? { distinct: ['brand'] } : {}),
-        },
-      },
-      mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'),
-      optionsCache,
-    )
-
-    return this.sortProductsByRelevance(totalResult, mostRelevants, limits)
-  }
-
-  private sortProductsByRelevance(totalResult: any, mostRelevants: string[], limits: any) {
-    const mostRelevantWithoutStock = totalResult.data.filter(
-      (product: any) => mostRelevants.includes(product.id) && product.stock.quantity <= 0,
-    )
-    const firstProducts = totalResult.data
-      .filter((product: any) => mostRelevants.includes(product.id) && product.stock.quantity > 0)
-      .sort((a: any, b: any) => mostRelevants.indexOf(a.id) - mostRelevants.indexOf(b.id))
-    const lastProducts = totalResult.data
-      .filter((product: any) => !mostRelevants.includes(product.id))
-      .concat(mostRelevantWithoutStock)
-    const categoryMostRelevants = firstProducts.concat(lastProducts)
-    const resultFinal = categoryMostRelevants.slice(limits.offset, limits.offset + limits.limit)
-
-    return {
-      data: resultFinal,
-      count: totalResult.count,
-      maximum: totalResult.maximum,
-      minimal: totalResult.minimal,
-      distinct: totalResult.distinct,
-    }
-  }
-}