@things-factory/sales-base 8.0.0-beta.9 → 8.0.1

package/server/controllers/order-controller.ts

@@ -0,0 +1,296 @@
+import { EntityManager, EntitySchema, FindOneOptions } from 'typeorm'
+
+import { Role, User } from '@things-factory/auth-base'
+import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
+import { ProductDetail } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import {
+  ArrivalNotice,
+  DeliveryOrder,
+  InventoryCheck,
+  OrderInventory,
+  OrderProduct,
+  OrderVas,
+  ReleaseGood,
+  ReturnOrder,
+  VasOrder
+} from '../service'
+
+export type ReferenceOrderType = ArrivalNotice | ReleaseGood | VasOrder | InventoryCheck | DeliveryOrder | ReturnOrder
+export type OrderTargetTypes = OrderProduct | OrderInventory | OrderVas
+
+export enum ReferenceOrderFields {
+  ArrivalNotice = 'arrivalNotice',
+  ReleaseGood = 'releaseGood',
+  VasOrder = 'vasOrder',
+  InventoryCheck = 'inventoryCheck',
+  ReturnOrder = 'returnOrder'
+}
+
+export enum OrderTargetFields {
+  OrderProduct = 'targetProduct',
+  OrderInventory = 'targetInventory',
+  OrderVas = 'targetVas'
+}
+
+export interface BasicInterface {
+  domain: Domain
+  user: User
+}
+
+export type NotificationMsgInterface = {
+  title: string
+  body: string
+  url: string
+  data: any
+}
+
+export class OrderController {
+  public readonly ERROR_MSG = {
+    FIND: {
+      NO_RESULT: (condition: any) => `There's no results matched with condition ${condition}`,
+      NO_CHILD_RESULT: (condition: any) => `There's no child result matched with condition ${condition}`,
+      NOT_MATCH: (source: any, target: any) => `Unable to find matching ${target} using ${source}`
+    },
+    CREATE: {
+      ID_EXISTS: 'Target has ID already',
+      EMPTY_CREATOR: 'Cannot create without creator',
+      EMPTY_UPDATER: 'Cannot create without updater'
+    },
+    UPDATE: {
+      ID_NOT_EXISTS: `Target doesn't have ID`,
+      EMPTY_UPDATER: 'Cannot update without updater'
+    },
+    VALIDITY: {
+      UNEXPECTED_FIELD_VALUE: (field: string, expectedValue: any, actualValue: any) =>
+        `Expected ${field} value is ${expectedValue} but got ${actualValue}`,
+      DUPLICATED: (field: string, value: any) => `There is duplicated ${field} value (${value})`,
+      CANT_PROCEED_STEP_BY: (step: string, reason: string) => `Can't proceed to ${step} it because ${reason}`
+    }
+  }
+
+  private readonly ROLE_NAMES: Record<string, string> = {
+    OFFICE_ADMIN: 'Office Admin'
+  }
+
+  protected trxMgr: EntityManager
+  protected domain: Domain
+  protected user: User
+
+  constructor(trxMgr: EntityManager, domain: Domain, user: User) {
+    this.trxMgr = trxMgr
+    this.domain = domain
+    this.user = user
+  }
+
+  private getRefOrderField(refOrder: ReferenceOrderType): string {
+    if (refOrder instanceof ArrivalNotice) {
+      return ReferenceOrderFields.ArrivalNotice
+    } else if (refOrder instanceof ReleaseGood) {
+      return ReferenceOrderFields.ReleaseGood
+    } else if (refOrder instanceof VasOrder) {
+      return ReferenceOrderFields.VasOrder
+    } else if (refOrder instanceof InventoryCheck) {
+      return ReferenceOrderFields.InventoryCheck
+    } else if (refOrder instanceof ReturnOrder) {
+      return ReferenceOrderFields.ReturnOrder
+    } else {
+      throw new Error(
+        this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('refOrder', 'One of reference order type', refOrder)
+      )
+    }
+  }
+
+  private getOrderTargetField(orderTarget: OrderTargetTypes): string {
+    if (orderTarget instanceof OrderProduct) {
+      return OrderTargetFields.OrderProduct
+    } else if (orderTarget instanceof OrderInventory) {
+      return OrderTargetFields.OrderInventory
+    } else if (orderTarget instanceof OrderVas) {
+      return OrderTargetFields.OrderVas
+    } else {
+      this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('orderTarget', 'One of order target type', orderTarget)
+    }
+  }
+
+  /**
+   * @summary Find reference order (ArrivalNotice, ReleaseGood, VasOrder, etc...)
+   * @description
+   * Find and return reference order with its relations based on passed condition & reltaions
+   */
+  async findRefOrder(
+    entitySchema: EntitySchema,
+    condition: Partial<ReferenceOrderType>,
+    relations?: string[]
+  ): Promise<ReferenceOrderType> {
+    condition = this.tidyConditions(condition)
+    let findOption: FindOneOptions = { where: condition }
+    if (relations?.length > 0) findOption.relations = relations
+
+    const refOrder: ReferenceOrderType = await this.trxMgr.getRepository(entitySchema).findOne(findOption)
+    if (!refOrder) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(findOption))
+
+    return refOrder
+  }
+
+  /**
+   * @summary Valitiy checker
+   * @description It will try to check whether passed record has same properties with passed conditions
+   * Basically it will check equality of value
+   * If you want to check advanced validation you can pass function to customize the logic of validation
+   * Passed function will be call with actual value of record as parameter
+   */
+  checkRecordValidity(record: Record<string, any>, conditions: Record<string, any>): void {
+    for (let field in conditions) {
+      let isValid: boolean = false
+      if (typeof conditions[field] === 'function') {
+        isValid = conditions[field](record[field])
+      } else {
+        isValid = conditions[field] === record[field]
+      }
+
+      if (!isValid)
+        throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE(field, conditions[field], record[field]))
+    }
+  }
+
+  /**
+   * @summary Notify to passed users
+   * @description Passed notification message will be sent to passed users
+   */
+  async notifyToUsers(users: User[], message: NotificationMsgInterface): Promise<void> {
+    const receivers: any[] = users.map(user => user.id)
+    /**
+     * @notes Temporary off sendNotification due to suspect of causing wms down
+     */
+    // await sendNotification({
+    //   receivers,
+    //   message
+    // })
+  }
+
+  /**
+   * @summary Notify to office admin
+   * @description Passed notification message will be sent to office admin of current domain
+   * default role name is defiend as ROLE_NAME.OFFICE_ADMIn by default
+   * You can change role name by passing roleName as parameter
+   */
+  async notifyToOfficeAdmin(message: NotificationMsgInterface, roleName?: string): Promise<void> {
+    const users: User[] = await this.trxMgr
+      .getRepository('users_roles')
+      .createQueryBuilder('ur')
+      .select('ur.users_id', 'id')
+      .where(qb => {
+        const subQuery = qb
+          .subQuery()
+          .select('role.id')
+          .from(Role, 'role')
+          .where('role.name = :roleName', { roleName: roleName || this.ROLE_NAMES.OFFICE_ADMIN })
+          .andWhere('role.domain_id = :domainId', { domainId: this.domain.id })
+          .getQuery()
+        return 'ur.roles_id IN ' + subQuery
+      })
+      .getRawMany()
+
+    this.notifyToUsers(users, message)
+  }
+
+  /**
+   * @summary Notify to customer of passed bizplace
+   * @description Passed notification message will be sent to customer of passed bizplace
+   */
+  async notifyToCustomer(bizplace: Bizplace, message: NotificationMsgInterface): Promise<void> {
+    const users: any[] = await getDomainUsers(bizplace, this.trxMgr)
+
+    this.notifyToUsers(users, message)
+  }
+
+  async createInventory(inventory: Partial<Inventory> | Partial<Inventory>[]): Promise<Inventory | Inventory[]> {
+    inventory = this.setStamp(inventory)
+    return await this.trxMgr.getRepository(Inventory).save(inventory)
+  }
+
+  /**
+   * @summary Update inventory record
+   * @description It will update inventory after set a stamp (domain, updater)
+   * The special point of this function is that this changes won't generate inventory history
+   * If you want to generate inventory history automatically you would better to use transactionInventory function
+   */
+  async updateInventory(inventory: Partial<Inventory> | Partial<Inventory>[]): Promise<Inventory | Inventory[]> {
+    if (!(inventory as any).id) throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS)
+    inventory = this.setStamp(inventory)
+    return await this.trxMgr.getRepository(Inventory).save(inventory)
+  }
+
+  async getChildPackingSize(
+    productDetails: ProductDetail[],
+    defaultProductDetail: ProductDetail,
+    unmatchingProductDetail: ProductDetail
+  ): Promise<number> {
+    let hasChildRelation: boolean = Boolean(unmatchingProductDetail?.childProductDetail)
+    let hasMatchingChild: boolean
+    let packingSize: number = 1
+    let currentChildProductDetail: ProductDetail
+
+    if (hasChildRelation) {
+      currentChildProductDetail = productDetails.find(
+        (productDetail: ProductDetail) => productDetail.id === unmatchingProductDetail.childProductDetail.id
+      )
+
+      if (!currentChildProductDetail) {
+        throw new Error(this.ERROR_MSG.FIND.NOT_MATCH('packing type', `GTIN (${unmatchingProductDetail.gtin})`))
+      }
+
+      hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id)
+      if (hasMatchingChild) {
+        packingSize = unmatchingProductDetail.packingSize
+      } else {
+        packingSize = unmatchingProductDetail.packingSize * packingSize
+      }
+    } else {
+      throw new Error(this.ERROR_MSG.FIND.NO_CHILD_RESULT(`${unmatchingProductDetail.gtin}`))
+    }
+
+    while (hasChildRelation && !hasMatchingChild) {
+      if (hasMatchingChild) {
+        packingSize = currentChildProductDetail.packingSize * packingSize // 12 x 10
+      } else if (!hasMatchingChild && hasChildRelation) {
+        packingSize = currentChildProductDetail.packingSize * packingSize // 12 x 10
+        currentChildProductDetail = productDetails.find(
+          (productDetail: ProductDetail) => productDetail.id === currentChildProductDetail.childProductDetail.id
+        )
+
+        hasChildRelation = Boolean(currentChildProductDetail?.childProductDetail)
+        hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id)
+      } else if (!hasChildRelation && !hasMatchingChild) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(unmatchingProductDetail.gtin))
+      }
+    }
+
+    return packingSize
+  }
+
+  /**
+   * @summary set common stamp like domain, creator, updater
+   * @description Set common stamp to passed record
+   * If it doesn't have id it will handle it as creating one
+   * If it has id it will handle it as updating one
+   */
+  setStamp(record: Record<string, any>): Record<string, any> {
+    if (!record.domain) record.domain = this.domain
+    if (!record.id && !record.creator) record.creator = this.user
+    if (!record.updater) record.updater = this.user
+
+    return record
+  }
+
+  tidyConditions(record: Record<string, any>): Record<string, any> {
+    Object.keys(record).forEach((key: string) => {
+      if (record[key] === null || record[key] instanceof Date || Array.isArray(record[key])) delete record[key]
+    })
+
+    return record
+  }
+}

package/server/errors/index.ts

@@ -0,0 +1 @@
+export * from './validation-error'

package/server/errors/validation-error.ts

@@ -0,0 +1,25 @@
+import * as ERROR_CODES from '../constants/validation-error-code'
+
+type ValidationErrorArgument = {
+  errorCode: string
+  message: string
+  detail?: Object
+}
+
+export class ValidationError extends Error {
+  static get ERROR_CODES(): any {
+    return {
+      ...ERROR_CODES
+    }
+  }
+  
+  errorCode: any
+  detail: Object
+  constructor({ errorCode, message, detail }: ValidationErrorArgument) {
+    super(errorCode)
+    this.name = 'validation-error'
+    this.errorCode = errorCode,
+    this.message = message
+    this.detail = detail
+  }
+}

package/server/index.ts

@@ -0,0 +1,5 @@
+export * from './service'
+export * from './migrations'
+export * from './utils'
+export * from './constants'
+export * from './controllers/ecommerce/sellercraft-controller'

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})