@infrab4a/connect-angular 5.8.13 → 5.8.14

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

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

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

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

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

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

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

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

@@ -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 { 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

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

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

@@ -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,39 @@
+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

@@ -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 { 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
+  }
+}