@infrab4a/connect-angular 5.8.12 → 5.8.13

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,
-  ) {}
-}

package/src/services/checkout-subscription.service.ts

@@ -1,76 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import {
-  CheckoutSubscription,
-  CheckoutSubscriptionRepository,
-  CheckoutTypes,
-  Coupon,
-  isNil,
-  pick,
-} from '@infrab4a/connect'
-import { Observable } from 'rxjs'
-import { concatMap } from 'rxjs/operators'
-
-
-import { PERSISTENCE_PROVIDER } from '../consts'
-import { DataPersistence } from '../persistence'
-
-import { RequiredCheckoutSubscriptionData } from './types'
-import { CouponService } from './coupon.service'
-
-@Injectable()
-export class CheckoutSubscriptionService {
-  constructor(
-    @Inject('CheckoutSubscriptionRepository')
-    private readonly checkoutSubscriptionRepository: CheckoutSubscriptionRepository,
-    @Inject(PERSISTENCE_PROVIDER) private readonly dataPersistence: DataPersistence,
-    private readonly couponService: CouponService,
-  ) {}
-
-  getCheckoutSubscription(checkoutData?: RequiredCheckoutSubscriptionData): Observable<CheckoutSubscription> {
-    return this.dataPersistence
-      .get('checkoutSubscriptionId')
-      .pipe(
-        concatMap((id) =>
-          !isNil(id) ? this.checkoutSubscriptionRepository.get({ id }) : this.createCheckoutSubscription(checkoutData),
-        ),
-      )
-  }
-
-  clearCheckoutSubscriptionFromSession(): Observable<void> {
-    return this.dataPersistence.remove('checkoutSubscriptionId')
-  }
-
-  checkCoupon(nickname: string, _userEmail: string): Observable<Coupon> {
-    return this.getCheckoutSubscription().pipe(
-      concatMap((checkout) =>
-        this.couponService
-          .checkCoupon({
-            nickname,
-            checkoutType: CheckoutTypes.SUBSCRIPTION,
-            checkout,
-            plan: checkout.subscriptionPlan.name,
-          })
-          .pipe(),
-      ),
-    )
-  }
-
-  calcDiscountSubscription(coupon: Coupon) {
-    return this.getCheckoutSubscription().pipe(
-      concatMap((checkout) => this.couponService.calcDiscountSubscription(coupon, checkout).pipe()),
-    )
-  }
-
-  private async createCheckoutSubscription(
-    checkoutData?: RequiredCheckoutSubscriptionData,
-  ): Promise<CheckoutSubscription> {
-    const checkout = await this.checkoutSubscriptionRepository.create({
-      createdAt: new Date(),
-      ...CheckoutSubscription.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain(),
-    })
-
-    await this.dataPersistence.set('checkoutSubscriptionId', checkout.id).toPromise()
-
-    return checkout
-  }
-}

package/src/services/checkout.service.ts

@@ -1,236 +0,0 @@
-import { Injectable } from '@angular/core'
-import {
-  Checkout,
-  CheckoutPayloadRequest,
-  CheckoutResponse,
-  CheckoutStockValidation,
-  CheckoutTypes,
-  Coupon,
-  isNil,
-  NotFoundError,
-  pick,
-  ShippingMethodResponse,
-  ShippingProductRequest,
-  User,
-  UserAddress,
-} from '@infrab4a/connect'
-import { from, Observable, of, throwError } from 'rxjs'
-import { concatMap, map } from 'rxjs/operators'
-
-import { CheckoutDependenciesFacade, CheckoutRepositoriesFacade } from './checkout'
-import { ConfigurationFacade } from './shared'
-import { RequiredCheckoutData } from './types'
-
-@Injectable()
-export class CheckoutService {
-  private checkoutUrl: string = null
-
-  constructor(
-    private readonly repositoriesFacade: CheckoutRepositoriesFacade,
-    private readonly dependenciesFacade: CheckoutDependenciesFacade,
-    private readonly configurationFacade: ConfigurationFacade,
-  ) {
-    this.checkoutUrl = this.configurationFacade.getCheckoutUrl()
-  }
-
-  getCheckout(checkoutData?: RequiredCheckoutData): Observable<Checkout> {
-    return this.dependenciesFacade.dataPersistence
-      .get('checkoutId')
-      .pipe(
-        concatMap((id) =>
-          !isNil(id) ? this.repositoriesFacade.checkoutRepository.get({ id }) : this.createCheckout(checkoutData),
-        ),
-      )
-  }
-
-  getUserByCheckout(checkoutId: string): Observable<User> {
-    return from(this.repositoriesFacade.checkoutRepository.get({ id: checkoutId })).pipe(
-      concatMap((checkout) =>
-        checkout?.user?.id
-          ? of(checkout.user)
-          : from(this.repositoriesFacade.userRepository.get({ id: checkout.user.id })),
-      ),
-      concatMap((user) => of(user) || throwError(() => new NotFoundError('User is not found'))),
-    )
-  }
-
-  updateCheckoutLineItems(checkout: Partial<Checkout>): Observable<Checkout> {
-    return from(
-      this.repositoriesFacade.checkoutRepository.update(
-        Checkout.toInstance({ id: checkout.id, lineItems: checkout.lineItems }),
-      ),
-    )
-  }
-
-  updateCheckoutUser(checkout: Partial<Checkout>): Observable<Checkout> {
-    return from(
-      this.repositoriesFacade.checkoutRepository.update(Checkout.toInstance({ id: checkout.id, user: checkout.user })),
-    )
-  }
-
-  clearCheckoutFromSession(): Observable<void> {
-    return this.dependenciesFacade.dataPersistence.remove('checkoutId')
-  }
-
-  resetCheckoutValues(): Observable<Checkout> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutResetValues`, {
-          checkoutId: checkout.id,
-        }),
-      ),
-      concatMap(() => this.getCheckout()),
-    )
-  }
-
-  applyCouponDiscount(nickname: string, checkoutType: CheckoutTypes): Observable<Coupon> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutApplyDiscount`, {
-          checkoutId: checkout.id,
-          coupon: nickname,
-          checkoutType,
-        }),
-      ),
-      concatMap(() => this.getCheckout()),
-      map((checkout) => checkout.coupon),
-    )
-  }
-
-  removeCouponDiscount(): Observable<Checkout> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutRemoveDiscount`, {
-          checkoutId: checkout.id,
-        }),
-      ),
-      concatMap(() => this.getCheckout()),
-    )
-  }
-
-  applyPointsDiscount(points: number): Observable<Checkout> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutApplyPointsDiscount`, {
-          checkoutId: checkout.id,
-          points,
-        }),
-      ),
-      concatMap(() => this.getCheckout()),
-    )
-  }
-
-  removePointsDiscount(): Observable<Checkout> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutRemovePointsDiscount`, {
-          checkoutId: checkout.id,
-        }),
-      ),
-      concatMap(() => this.getCheckout()),
-    )
-  }
-
-  validateStockProducts(): Observable<CheckoutStockValidation> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post<{
-          valid: boolean
-          outOfStock: string[]
-          limitedStock: string[]
-        }>(`${this.checkoutUrl}/checkoutValidateProductStock`, {
-          checkoutId: checkout.id,
-        }),
-      ),
-    )
-  }
-
-  selectShippingAddress(address: UserAddress): Observable<Checkout> {
-    const formattedAddress: UserAddress = {
-      ...address,
-      zip: this.formatZip(address.zip),
-    } as UserAddress
-
-    return this.getCheckout().pipe(
-      concatMap((checkout) => {
-        return this.repositoriesFacade.checkoutRepository.update(
-          Checkout.toInstance({
-            id: checkout.id,
-            shippingAddress: formattedAddress,
-            billingAddress: formattedAddress,
-          }),
-        )
-      }),
-    )
-  }
-
-  private formatZip(zip?: string): string | undefined {
-    if (!zip) return zip
-
-    const digits = zip.replace(/\D/g, '')
-
-    return digits
-  }
-
-  getAvailableShippingForProduct(productShipping: ShippingProductRequest): Observable<ShippingMethodResponse[]> {
-    return this.dependenciesFacade.httpClient.post<ShippingMethodResponse[]>(
-      `${this.checkoutUrl}/checkoutGetAvailableShipping`,
-      {
-        checkoutId: null,
-        productShipping,
-      },
-    )
-  }
-
-  getAvailableShippingForCheckout(): Observable<ShippingMethodResponse[]> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post<ShippingMethodResponse[]>(
-          `${this.checkoutUrl}/checkoutGetAvailableShipping`,
-          {
-            checkoutId: checkout.id,
-            productShipping: null,
-          },
-        ),
-      ),
-    )
-  }
-
-  selectShipping(option: string): Observable<Checkout> {
-    return this.getCheckout().pipe(
-      concatMap((checkout) =>
-        this.dependenciesFacade.httpClient.post(`${this.checkoutUrl}/checkoutSelectShipping`, {
-          checkoutId: checkout.id,
-          shippingOption: option,
-        }),
-      ),
-      concatMap(() => this.getCheckout()),
-    )
-  }
-
-  createOrder(
-    checkoutPayload: CheckoutPayloadRequest,
-    paymentProvider: string,
-    applicationVersion: string,
-  ): Observable<CheckoutResponse> {
-    return this.dependenciesFacade.httpClient.post<CheckoutResponse>(`${this.checkoutUrl}/checkout`, {
-      data: {
-        ...checkoutPayload,
-        applicationVersion,
-        paymentProvider,
-      },
-    })
-  }
-
-  private async createCheckout(checkoutData?: RequiredCheckoutData): Promise<Checkout> {
-    const checkout = await this.repositoriesFacade.checkoutRepository.create({
-      createdAt: new Date(),
-      ...Checkout.toInstance(pick(checkoutData, ['user', 'shop'])).toPlain(),
-      shop: checkoutData?.shop || this.configurationFacade.defaultShop,
-    })
-
-    await this.dependenciesFacade.dataPersistence.set('checkoutId', checkout.id).toPromise()
-
-    return checkout
-  }
-}

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

@@ -1,11 +0,0 @@
-import { Inject, Injectable } from '@angular/core'
-import { CategoryRepository, CouponRepository, OrderRepository } from '@infrab4a/connect'
-
-@Injectable()
-export class CouponRepositoriesFacade {
-  constructor(
-    @Inject('CouponRepository') public readonly couponRepository: CouponRepository,
-    @Inject('OrderRepository') public readonly orderRepository: OrderRepository,
-    @Inject('CategoryRepository') public readonly categoryRepository: CategoryRepository,
-  ) {}
-}