@things-factory/sales-base 8.0.0-beta.0 → 8.0.0-beta.2

package/server/controllers/order-controller.ts

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

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

package/server/errors/validation-error.ts

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

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

package/server/migrations/index.ts

@@ -1,9 +0,0 @@
-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))) || [])
-})