@infrab4a/connect-angular 5.0.0-alpha.14 → 5.0.0-alpha.2

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

@@ -0,0 +1,25 @@
+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/{services/catalog/facades/index.d.ts → src/services/catalog/facades/index.ts}

@@ -1,5 +1,5 @@
-export { CatalogServiceFacade } from './catalog-service.facade';
-export { CatalogStrategiesFacade } from './catalog-strategies.facade';
-export { CategoryRepositoryFacade } from './category-repository.facade';
-export { CategoryServiceFacade } from './category-service.facade';
-export { ProductCatalogFacade } from './product-catalog.facade';
+export { CatalogServiceFacade } from './catalog-service.facade'
+export { CatalogStrategiesFacade } from './catalog-strategies.facade'
+export { CategoryRepositoryFacade } from './category-repository.facade'
+export { CategoryServiceFacade } from './category-service.facade'
+export { ProductCatalogFacade } from './product-catalog.facade'

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

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

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

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core'
+import { Where, isEmpty } 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[]> {
+    return this.productCatalog.productRepository
+      .findCatalog(
+        {
+          fields: ['id'],
+          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

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core'
+import { Product, RepositoryFindFielters, Where, set } 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.tags = { 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

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

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

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

package/src/services/catalog/index.ts

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

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

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

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

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

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

@@ -0,0 +1,20 @@
+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/{services/catalog/services/index.d.ts → src/services/catalog/services/index.ts}

@@ -1,4 +1,4 @@
-export { CatalogHelpersService } from './catalog-helpers.service';
-export { CatalogOperationsFacade } from './catalog-operations.facade';
-export * from './catalog-repository.service';
-export { ProductManagementFacade } from './product-management.facade';
+export { CatalogHelpersService } from './catalog-helpers.service'
+export { CatalogOperationsFacade } from './catalog-operations.facade'
+export * from './catalog-repository.service'
+export { ProductManagementFacade } from './product-management.facade'

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

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

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

@@ -0,0 +1,172 @@
+import { Injectable } from '@angular/core'
+import { Product, RepositoryCacheOptions, RepositoryFindResult, Shops, Where, isEmpty } 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, shop, mainGender, 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.productRepository.findCatalog(
+      repoParams,
+      mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'),
+      optionsCache,
+    )
+  }
+
+  private async getProductIds(category: any, filters: any, optionsCache: any): Promise<string[]> {
+    const productCatalog = this.repositoryService.getProductCatalog()
+    const filterHelper = this.helpersService.getFilterHelper()
+
+    return productCatalog.productRepository
+      .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.productRepository.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,
+    }
+  }
+}

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

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

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: {
+        tags: { operator: Where.LIKE, value: profile },
+        ...filterHelper.buildFilterQuery(filters || {}),
+      },
+      ...(sort ? { orderBy: sortHelper.buildSortQuery(sort) } : {}),
+      limits,
+      options: {
+        minimal: ['price'],
+        maximum: ['price'],
+        distinct: ['brand'],
+      },
+    }
+
+    return productCatalog.productRepository.findCatalog(
+      repoParams,
+      mainGender || (shop === Shops.MENSMARKET ? 'male' : 'female'),
+      optionsCache,
+    )
+  }
+}