@infrab4a/connect-angular 5.8.3 → 5.8.4

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'

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

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

@@ -0,0 +1,213 @@
+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()),
+    )
+  }
+
+  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

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

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

@@ -1 +1 @@
-export { CouponRepositoriesFacade } from './coupon-repositories.facade';
+export { CouponRepositoriesFacade } from './coupon-repositories.facade'