@infrab4a/connect-angular 5.8.4 → 5.8.5

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}`

package/src/services/catalog/wishlist.service.ts

@@ -1,364 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import {
-  LogRepository,
-  PersonType,
-  PersonTypes,
-  Product,
-  ProductCatalogRepository,
-  ProductRepository,
-  Shops,
-  Wishlist,
-  WishlistLogType,
-  WishlistRepository,
-} from '@infrab4a/connect'
-
-import { DEFAULT_SHOP } from '../../consts'
-
-import { CatalogService } from './catalog.service'
-import { CategoryService } from './category.service'
-import { CatalogServiceFacade, CategoryServiceFacade } from './facades'
-
-@Injectable()
-export class WishlistService {
-  private catalogService: CatalogService
-  private categoryService: CategoryService
-
-  constructor(
-    @Inject('WishlistRepository') private readonly wishlistRepository: WishlistRepository,
-    @Inject('ProductRepository') private readonly productRepository: ProductRepository,
-    @Inject('ProductCatalogRepository') private readonly productCatalogRepository: ProductCatalogRepository,
-    @Inject('LogRepository') private readonly logRepository: LogRepository,
-    @Inject(DEFAULT_SHOP) private readonly shop: Shops,
-  ) {}
-
-  initializeServices(catalogServiceFacade: CatalogServiceFacade, categoryServiceFacade: CategoryServiceFacade): void {
-    this.catalogService = catalogServiceFacade.getCatalogService()
-    this.categoryService = categoryServiceFacade.getCategoryService()
-  }
-
-  getCatalogService() {
-    return this.catalogService
-  }
-
-  getCategoryService() {
-    return this.categoryService
-  }
-
-  async create({
-    personId,
-    title,
-    description,
-    published,
-    userFullName,
-    userPhoto,
-    theme,
-    bannerUrl,
-    personType,
-    personIsSubscriber,
-  }: {
-    personId: string
-    title: string
-    description: string
-    published: boolean
-    userFullName: string
-    userPhoto?: string
-    theme?: string
-    bannerUrl?: string
-    personType?: PersonType
-    personIsSubscriber?: boolean
-  }): Promise<Wishlist> {
-    const wishlistData = this.buildWishlistData({
-      title,
-      description,
-      published,
-      userFullName,
-      userPhoto,
-      theme,
-      bannerUrl,
-      personType,
-      personIsSubscriber,
-      personId,
-    })
-
-    const existingWishlist = await this.findExistingWishlistByPersonId(personId)
-
-    await this.createWishlistLog(WishlistLogType.CREATE, wishlistData as Wishlist)
-
-    if (existingWishlist) return existingWishlist
-
-    return this.createNewWishlist(wishlistData)
-  }
-
-  private buildWishlistData({
-    title,
-    description,
-    published,
-    userFullName,
-    userPhoto,
-    theme,
-    bannerUrl,
-    personType,
-    personIsSubscriber,
-    personId,
-  }: {
-    title: string
-    description: string
-    published: boolean
-    userFullName: string
-    userPhoto?: string
-    theme?: string
-    bannerUrl?: string
-    personType?: PersonType
-    personIsSubscriber?: boolean
-    personId: string
-  }) {
-    return {
-      slug: '',
-      name: title,
-      description,
-      metadatas: [
-        {
-          shop: this.shop,
-          title: `${userFullName} - ${title}`,
-          description: `${userFullName} - ${description}`,
-        },
-      ],
-      shop: this.shop,
-      shops: [this.shop],
-      personId,
-      personName: userFullName,
-      personPhoto: userPhoto,
-      brandCategory: false,
-      published,
-      theme,
-      bannerUrl,
-      personType: personType ?? PersonTypes.NONE,
-      personIsSubscriber: personIsSubscriber ?? false,
-    }
-  }
-
-  private async findExistingWishlistByPersonId(personId: string): Promise<Wishlist | null> {
-    const hasWishlist = await this.wishlistRepository
-      .find({
-        filters: {
-          personId,
-        },
-        options: {
-          enableCount: false,
-        },
-        orderBy: {
-          id: 'asc',
-        },
-      })
-      .then((res) => res.data)
-
-    return hasWishlist.length ? hasWishlist.at(0) : null
-  }
-
-  private async createNewWishlist(data: any): Promise<Wishlist> {
-    const newWishlist = await this.wishlistRepository.create(data)
-
-    await this.wishlistRepository.update({ id: newWishlist.id, slug: newWishlist.id })
-
-    return Wishlist.toInstance({ ...newWishlist.toPlain(), slug: newWishlist.id })
-  }
-
-  async update({
-    id,
-    title,
-    description,
-    published,
-    userFullName,
-    userPhoto,
-    theme,
-    bannerUrl,
-    personType,
-    personIsSubscriber,
-  }: {
-    id: string
-    title: string
-    description: string
-    published: boolean
-    userFullName: string
-    userPhoto?: string
-    theme?: string
-    bannerUrl?: string
-    personType?: PersonType
-    personIsSubscriber?: boolean
-  }): Promise<Wishlist> {
-    const data = {
-      id,
-      name: title,
-      description,
-      published,
-      metadatas: [
-        {
-          shop: this.shop,
-          title: `${userFullName} - ${title}`,
-          description: `${userFullName} - ${description}`,
-        },
-      ],
-      personName: userFullName,
-      personPhoto: userPhoto,
-      theme,
-      bannerUrl,
-      personType: personType ?? PersonTypes.NONE,
-      personIsSubscriber: personIsSubscriber ?? false,
-    }
-
-    await this.createWishlistLog(WishlistLogType.UPDATE, data as Wishlist)
-
-    return this.wishlistRepository.update(data)
-  }
-
-  async delete(wishlistId: string): Promise<void> {
-    const wishlist = await this.findById(wishlistId)
-
-    await this.createWishlistLog(WishlistLogType.DELETE, wishlist)
-
-    return this.wishlistRepository.delete({ id: wishlistId })
-  }
-
-  getWishlistBySlug(slug: string): Promise<Wishlist> {
-    const [id] = slug.split('-')
-
-    if (+id) return this.wishlistRepository.get({ id })
-
-    return this.wishlistRepository.getWishlistBySlug(slug)
-  }
-
-  getWishlistsByPerson(personId: string): Promise<Wishlist[]> {
-    return this.wishlistRepository.getWishlistByPerson(personId)
-  }
-
-  async addProduct(wishlistId: string, productId: string): Promise<Wishlist> {
-    const wishlist = await this.wishlistRepository.get({ id: wishlistId })
-    const hasProduct = wishlist.products.some((p) => p == productId)
-
-    const wishlistData = await this.findById(wishlistId)
-    const productData = await this.findProductById(productId)
-
-    await this.createWishlistLog(WishlistLogType.ADD_PRODUCT, wishlistData, productData)
-
-    if (!hasProduct) {
-      wishlist.products = [...wishlist.products, productId]
-      await this.wishlistRepository.addProduct(wishlistId, productId)
-    }
-
-    return wishlist
-  }
-
-  async removeProduct(wishlistId: string, productId: string): Promise<Wishlist> {
-    const wishlist = await this.wishlistRepository.get({ id: wishlistId })
-    const productIndex = wishlist.products.findIndex((p) => p == productId)
-
-    if (productIndex != -1) {
-      wishlist.products.splice(productIndex, 1)
-      const wishlistData = await this.findById(wishlistId)
-      const productData = await this.findProductById(productId)
-
-      await this.createWishlistLog(WishlistLogType.REMOVE_PRODUCT, wishlistData, productData)
-      await this.wishlistRepository.removeProduct(wishlistId, productId)
-    }
-
-    return wishlist
-  }
-
-  private async findById(id: string): Promise<Wishlist> {
-    return this.wishlistRepository
-      .find({
-        fields: ['id', 'name', 'description', 'personId', 'personIsSubscriber', 'personType', 'personName'],
-        filters: {
-          id,
-        },
-      })
-      .then((res) => res.data.at(0))
-  }
-
-  private async findProductById(id: string): Promise<Product> {
-    return this.productCatalogRepository
-      .find({
-        fields: ['id', 'sku', 'EAN', 'name', 'brand'],
-        filters: {
-          id,
-        },
-      })
-      .then((res) => res.data.at(0))
-  }
-
-  private async createWishlistLog(type: WishlistLogType, wishlist: Wishlist, product?: Product) {
-    switch (type) {
-      case WishlistLogType.CREATE:
-      case WishlistLogType.UPDATE:
-      case WishlistLogType.DELETE:
-        await this.createWishlistOperationLog(type, wishlist)
-        break
-
-      case WishlistLogType.ADD_PRODUCT:
-      case WishlistLogType.REMOVE_PRODUCT:
-        await this.createWishlistProductLog(type, wishlist, product)
-        break
-
-      default:
-        break
-    }
-  }
-
-  private async createWishlistOperationLog(type: WishlistLogType, wishlist: Wishlist): Promise<void> {
-    const operation = this.getOperationTypeFromWishlistLogType(type)
-
-    await this.logRepository.create({
-      collection: 'wishlist',
-      date: new Date(),
-      operation,
-      documentId: wishlist.id,
-      document: this.buildWishlistLogDocument(wishlist, type),
-    })
-  }
-
-  private async createWishlistProductLog(type: WishlistLogType, wishlist: Wishlist, product: Product): Promise<void> {
-    await this.logRepository.create({
-      collection: 'wishlist',
-      date: new Date(),
-      operation: 'UPDATE',
-      documentId: wishlist.id,
-      document: {
-        ...this.buildWishlistLogDocument(wishlist, type),
-        ...this.buildProductLogData(product),
-      },
-    })
-  }
-
-  private getOperationTypeFromWishlistLogType(type: WishlistLogType): 'CREATE' | 'UPDATE' | 'DELETE' {
-    if (type === WishlistLogType.CREATE) return 'CREATE'
-
-    if (type === WishlistLogType.UPDATE) return 'UPDATE'
-
-    return 'DELETE'
-  }
-
-  private buildWishlistLogDocument(wishlist: Wishlist, type: WishlistLogType) {
-    return {
-      id: wishlist.id,
-      shop: this.shop,
-      name: wishlist.name,
-      description: wishlist.description,
-      published: wishlist.published,
-      type: type,
-      personType: wishlist.personType,
-      personId: wishlist.personId,
-      personName: wishlist.personName,
-      personIsSubscriber: wishlist.personIsSubscriber,
-    }
-  }
-
-  private buildProductLogData(product: Product) {
-    return {
-      productId: product.id,
-      productEAN: product.EAN,
-      productSKU: product.sku,
-      productName: product.name,
-      productBrand: product.brand,
-    }
-  }
-}

package/src/services/checkout/checkout-dependencies.facade.ts

@@ -1,13 +0,0 @@
-import { HttpClient } from '@angular/common/http'
-import { Inject, Injectable } from '@angular/core'
-
-import { PERSISTENCE_PROVIDER } from '../../consts'
-import { DataPersistence } from '../../persistence'
-
-@Injectable()
-export class CheckoutDependenciesFacade {
-  constructor(
-    @Inject(PERSISTENCE_PROVIDER) public readonly dataPersistence: DataPersistence,
-    public readonly httpClient: HttpClient,
-  ) {}
-}

package/src/services/checkout/checkout-repositories.facade.ts

@@ -1,10 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { CheckoutRepository, UserRepository } from '@infrab4a/connect'
-
-@Injectable()
-export class CheckoutRepositoriesFacade {
-  constructor(
-    @Inject('CheckoutRepository') public readonly checkoutRepository: CheckoutRepository,
-    @Inject('UserRepository') public readonly userRepository: UserRepository,
-  ) {}
-}