@infrab4a/connect-angular 5.8.19 → 5.8.21-beta.0

package/src/services/catalog/types/fetch-products-options.type.ts

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

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

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

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

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

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

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

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

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

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

package/{services/checkout/index.d.ts → src/services/checkout/index.ts}

@@ -1,2 +1,2 @@
-export { CheckoutRepositoriesFacade } from './checkout-repositories.facade';
-export { CheckoutDependenciesFacade } from './checkout-dependencies.facade';
+export { CheckoutRepositoriesFacade } from './checkout-repositories.facade'
+export { CheckoutDependenciesFacade } from './checkout-dependencies.facade'