@things-factory/worksheet-base 8.0.0-beta.9 → 8.0.0

package/server/controllers/worksheet-controller.ts

@@ -0,0 +1,1267 @@
+import { EntityManager, EntitySchema, Equal, FindOneOptions, In, Not } from 'typeorm'
+
+import { Role, User } from '@things-factory/auth-base'
+import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import {
+  ArrivalNotice,
+  DeliveryOrder,
+  InventoryCheck,
+  ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
+  ORDER_VAS_STATUS,
+  OrderInventory,
+  OrderProduct,
+  OrderVas,
+  ReleaseGood,
+  ReturnOrder,
+  VasOrder
+} from '@things-factory/sales-base'
+import { Domain, getRepository } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS, InventoryItem, Pallet } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../constants'
+import { Worksheet, WorksheetDetail } from '../entities'
+import { generateInventoryHistory, WorksheetNoGenerator } from '../utils'
+
+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 WorksheetController {
+  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}`
+    },
+    ORDER_ITEM: {
+      NO_MATCHING_RESULT: (condition: any, condition2: any) =>
+        `Current item with ${condition} (${condition2}) not belong to this order`,
+      EXCESS_QTY: (condition: any, condition2: any, condition3: any) =>
+        `Excess qty is scanned for item ${condition}, ${condition2} (${condition3})`
+    },
+    PRODUCT: {
+      NO_MATCHING_RESULT: (condition: any, condition2: any) =>
+        `Order packing type and packing size not match with product master, ${condition} (${condition2})`,
+      BARCODE_NOT_EXIST: (condition: any, condition2: any, condition3: any) =>
+        `Product barcode - ${condition} with ${condition2} ${condition3}, not exist in master data.`
+    },
+    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} 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 find worksheet by passed condition
+   * @description find worksheey based on passed condition
+   * It will return worksheetDetail as its relation by default
+   * If you want to get additional relations you need to define reltaions
+   * ex) findWorksheet(condition, ['arrivalNotice', 'releaseGood'])
+   */
+  async findWorksheet(condition: Record<string, any>, relations: string[] = ['worksheetDetails']): Promise<Worksheet> {
+    condition = this.tidyConditions(condition)
+    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: this.domain.id },
+        ...condition
+      },
+      relations
+    })
+
+    if (!worksheet) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(condition))
+    return worksheet
+  }
+
+  /**
+   * @summary Find worksheet by passed params
+   * @description Find and return worksheet based on passed ID
+   * It will return worksheetDetail as its relation by default
+   * If you want to get additional relations you need to define reltaions
+   * ex) findWorksheetById(id, ['arrivalNotice', 'releaseGood'])
+   */
+  async findWorksheetById(id: string, relations: string[] = ['worksheetDetails']): Promise<Worksheet> {
+    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({ where: { id }, relations })
+    if (!worksheet) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(id))
+
+    return worksheet
+  }
+
+  /**
+   * @summary Find worksheet by passed params
+   * @description Find and return worksheet based on worksheet no
+   * It will return worksheetDetail as its relation by default
+   * If you want to get additional relations you need to define reltaions
+   * ex) findWorksheetByNo(worksheetNo, ['arrivalNotice', 'releaseGood'])
+   */
+  async findWorksheetByNo(worksheetNo: string, relations: string[] = ['worksheetDetails']): Promise<Worksheet> {
+    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: { domain: { id: this.domain.id }, name: worksheetNo },
+      relations
+    })
+
+    if (!worksheet) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetNo))
+
+    return worksheet
+  }
+
+  /**
+   * @summary Find worksheet by passed params.
+   * @description Find and return worksheet based on worksheet no
+   * It will return worksheetDetail as its relation by default
+   * If you want to get additional relations you need to define reltaions
+   * ex) findWorksheetByNo(worksheetNo, ['arrivalNotice', 'releaseGood'])
+   */
+  async findWorksheetByRefOrder(
+    refOrder: ReferenceOrderType,
+    type: string,
+    relations: string[] = ['worksheetDetails']
+  ): Promise<Worksheet> {
+    const refOrderField: string = this.getRefOrderField(refOrder)
+    if (!refOrder.bizplace?.id) {
+      switch (refOrderField) {
+        case ReferenceOrderFields.ArrivalNotice:
+          //@ts-ignore
+          refOrder = await this.findRefOrder(ArrivalNotice, refOrder, ['bizplace'])
+          break
+
+        case ReferenceOrderFields.ReleaseGood:
+          //@ts-ignore
+          refOrder = await this.findRefOrder(ReleaseGood, refOrder, ['bizplace'])
+          break
+
+        case ReferenceOrderFields.VasOrder:
+          //@ts-ignore
+          refOrder = await this.findRefOrder(VasOrder, refOrder, ['bizplace'])
+          break
+
+        case ReferenceOrderFields.InventoryCheck:
+          //@ts-ignore
+          refOrder = await this.findRefOrder(InventoryCheck, refOrder, ['bizplace'])
+          break
+
+        case ReferenceOrderFields.ReturnOrder:
+          //@ts-ignore
+          refOrder = await this.findRefOrder(ReturnOrder, refOrder, ['bizplace'])
+          break
+      }
+    }
+
+    const bizplace: Bizplace = refOrder.bizplace
+    const condition: FindOneOptions = {
+      where: {
+        bizplace: { id: bizplace.id },
+        domain: { id: this.domain.id },
+        type,
+        [refOrderField]: { id: refOrder.id }
+      },
+      relations
+    }
+
+    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne(condition)
+    if (!worksheet) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(type))
+
+    return worksheet
+  }
+
+  /**
+   * @summary Find activatable worksheet by worksheet no and type
+   * @description Find worksheet by passed worksheet no
+   * and check validity by passed type and status (DEACTIVATED)
+   * It will return worksheetDetail as its relation by default
+   * If you want to get additional relations you need to define reltaions
+   * ex) findActivatableWorksheet(worksheetNo, type, ['arrivalNotice])
+   */
+  async findActivatableWorksheet(
+    worksheetNo: string,
+    type: string,
+    relations: string[] = ['worksheetDetails']
+  ): Promise<Worksheet> {
+    const worksheet: Worksheet = await this.findWorksheetByNo(worksheetNo, relations)
+    this.checkRecordValidity(worksheet, { type, status: WORKSHEET_STATUS.DEACTIVATED })
+
+    return worksheet
+  }
+
+  /**
+   * @summary Find executable worksheet detail by its name
+   * @description Find worksheet detail by passwd worksheet detail name
+   * and check validity by passed type and status (EXECUTING)
+   * If you want to get additional relations you need to define relations
+   * ex) findExecutableWorksheetDetailByName(worksheetDetailName, type, ['arrivalNotice'])
+   */
+  async findActivatableWorksheetDetailByName(
+    worksheetDetailName: string,
+    type: string,
+    relations: string[] = []
+  ): Promise<WorksheetDetail> {
+    const worksheetDetail: WorksheetDetail = await this.findWorksheetDetailByName(worksheetDetailName, relations)
+    this.checkRecordValidity(worksheetDetail, { type, status: WORKSHEET_STATUS.DEACTIVATED })
+
+    return worksheetDetail
+  }
+
+  /**
+   * @summary find worksheet detail by passed condition
+   * @description find worksheet detail based on passed condition
+   * If you want to get additional relations you need to define reltaions
+   * ex) findWorksheetDetail(condition, ['worksheet'])
+   */
+  async findWorksheetDetail(condition: Record<string, any>, relations?: string[]): Promise<WorksheetDetail> {
+    condition = this.tidyConditions(condition)
+    const worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
+      where: {
+        domain: { id: this.domain.id },
+        ...condition
+      },
+      relations
+    })
+
+    if (!worksheetDetail) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(condition))
+    return worksheetDetail
+  }
+
+  /**
+   * @summary find worksheet detail by passed worksheet detail name
+   * @description find worksheey based on passed name of worksheet detail
+   * If you want to get additional relations you need to define reltaions
+   * ex) findWorksheetDetail(condition, ['worksheet'])
+   */
+  async findWorksheetDetailByName(worksheetDetailName: string, relations?: string[]): Promise<WorksheetDetail> {
+    const worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
+      where: { domain: { id: this.domain.id }, name: worksheetDetailName },
+      relations
+    })
+
+    if (!worksheetDetail) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName))
+    return worksheetDetail
+  }
+
+  async findWorksheetDetailByNames(worksheetDetailNames: [string], relations?: string[]): Promise<WorksheetDetail[]> {
+    const worksheetDetails: WorksheetDetail[] = await this.trxMgr.getRepository(WorksheetDetail).find({
+      where: { domain: { id: this.domain.id }, name: In(worksheetDetailNames) },
+      relations
+    })
+
+    if (!worksheetDetails?.length) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailNames.toString()))
+    return worksheetDetails
+  }
+
+  /**
+   * @summary Find executable worksheet detail by its name
+   * @description Find worksheet detail by passwd worksheet detail name
+   * and check validity by passed type and status (EXECUTING)
+   * If you want to get additional relations you need to define relations
+   * ex) findExecutableWorksheetDetailByName(worksheetDetailName, type, ['arrivalNotice'])
+   */
+  async findExecutableWorksheetDetailByName(
+    worksheetDetailName: string,
+    type: string,
+    relations: string[] = []
+  ): Promise<WorksheetDetail> {
+    const worksheetDetail: WorksheetDetail = await this.findWorksheetDetailByName(worksheetDetailName, relations)
+    this.checkRecordValidity(worksheetDetail, { type, status: WORKSHEET_STATUS.EXECUTING })
+
+    return worksheetDetail
+  }
+
+  async findExecutableWorksheetDetailByNames(
+    worksheetDetailNames: [string],
+    type: string,
+    relations: string[] = []
+  ): Promise<WorksheetDetail[]> {
+    const worksheetDetails: WorksheetDetail[] = await this.findWorksheetDetailByNames(worksheetDetailNames, relations)
+    worksheetDetails.map(worksheetDetail => {
+      this.checkRecordValidity(worksheetDetail, { type, status: WORKSHEET_STATUS.EXECUTING })
+    })
+
+    return worksheetDetails
+  }
+
+  /**
+   * @summary Creating worksheet
+   * @description creating worksheet by passed params
+   * It will set status as DEACTIVATED by default
+   * If you want to define status by yourself, need to pass status in additionalProps
+   * ex) createWorksheet(refOrder, type, { status: WORKSHEET_STATUS.ACTIVATED })
+   */
+  async createWorksheet(
+    refOrder: ReferenceOrderType,
+    type: string,
+    additionalProps: Partial<Worksheet> = {}
+  ): Promise<Worksheet> {
+    let refOrderType: string = await this.getRefOrderField(refOrder)
+    const bizplace: Bizplace = await this.extractBizplaceFromRefOrder(refOrder)
+
+    let existingWorksheet: Worksheet
+    try {
+      existingWorksheet = await this.findWorksheetByRefOrder(refOrder, type)
+    } catch (e) {}
+
+    if (existingWorksheet)
+      throw new Error(
+        this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY(
+          `create ${type.toLocaleLowerCase()} worksheet`,
+          'existing worksheet is found'
+        )
+      )
+
+    const worksheet: Partial<Worksheet> = {
+      domain: this.domain,
+      bizplace,
+      name: WorksheetNoGenerator.generate(type),
+      type,
+      status: WORKSHEET_STATUS.DEACTIVATED,
+      creator: this.user,
+      updater: this.user,
+      [refOrderType]: refOrder,
+      ...additionalProps
+    }
+
+    if (worksheet.id) throw new Error(this.ERROR_MSG.CREATE.ID_EXISTS)
+
+    return await this.trxMgr.getRepository(Worksheet).save(worksheet)
+  }
+
+  async createBatchWorksheet(
+    taskNo: string,
+    bizplace: Bizplace,
+    type: string,
+    additionalProps: Partial<Worksheet> = {}
+  ): Promise<Worksheet> {
+    const worksheet: Partial<Worksheet> = {
+      domain: this.domain,
+      bizplace,
+      name: WorksheetNoGenerator.generate(type),
+      type,
+      taskNo,
+      status: WORKSHEET_STATUS.DEACTIVATED,
+      creator: this.user,
+      updater: this.user,
+      ...additionalProps
+    }
+
+    if (worksheet.id) throw new Error(this.ERROR_MSG.CREATE.ID_EXISTS)
+
+    return await this.trxMgr.getRepository(Worksheet).save(worksheet)
+  }
+
+  /**
+   * @summary Creating worksheet details
+   * @description creating worksheet details by passed params
+   * It will set status as DEACTIVATED by default
+   * If you want to define status by yourself, need to pass status in additionalProps
+   * ex) createWorksheetDetails(refOrder, type, { status: WORKSHEET_STATUS.ACTIVATED })
+   *
+   */
+  async createWorksheetDetails(
+    worksheet: Worksheet,
+    type: string,
+    orderTargets: OrderTargetTypes[],
+    additionalProps: Partial<WorksheetDetail> = {}
+  ): Promise<WorksheetDetail[]> {
+    if (!worksheet.bizplace?.id) {
+      worksheet = await this.findWorksheetById(worksheet.id, ['bizplace'])
+    }
+    const bizplace: Bizplace = worksheet.bizplace
+
+    const worksheetDetails: Partial<WorksheetDetail>[] = orderTargets.map((orderTarget: OrderTargetTypes) => {
+      const orderTargetField: string = this.getOrderTargetField(orderTarget)
+      return {
+        domain: this.domain,
+        bizplace,
+        worksheet,
+        name: WorksheetNoGenerator.generate(type, true),
+        type,
+        status: WORKSHEET_STATUS.DEACTIVATED,
+        [orderTargetField]: orderTarget,
+        creator: this.user,
+        updater: this.user,
+        ...additionalProps
+      }
+    })
+
+    if (worksheetDetails.some((wsd: Partial<WorksheetDetail>) => wsd.id))
+      throw new Error(this.ERROR_MSG.CREATE.ID_EXISTS)
+
+    return await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
+  }
+
+  /**
+   * @summary Update reference order (ArrivalNotice, ReleaseGood, VasOrder, InventoryCheck)
+   * @description
+   * Update reference order like (ArrivalNotice, ReleaseGood, VasOrder, InventoryCheck)
+   */
+  async updateRefOrder(
+    refOrder: ReferenceOrderType,
+    entitySchema?: EntitySchema,
+    currentStatus?: string
+  ): Promise<any> {
+    if (!entitySchema) {
+      if (refOrder instanceof ArrivalNotice) {
+        //@ts-ignore
+        entitySchema = ArrivalNotice
+      } else if (refOrder instanceof ReleaseGood) {
+        //@ts-ignore
+        entitySchema = ReleaseGood
+      } else if (refOrder instanceof VasOrder) {
+        //@ts-ignore
+        entitySchema = VasOrder
+      } else if (refOrder instanceof InventoryCheck) {
+        //@ts-ignore
+        entitySchema = InventoryCheck
+      } else if (refOrder instanceof ReturnOrder) {
+        //@ts-ignore
+        entitySchema = ReturnOrder
+      }
+    }
+
+    if (!refOrder.id) throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS)
+    //@ts-ignore
+    if (!refOrder.updater?.id) refOrder = this.setStamp(refOrder)
+
+    //@ts-ignore
+    if (currentStatus && entitySchema == ReleaseGood) {
+      let res = await getRepository(entitySchema).query(
+        `
+        update release_goods
+        set status = $1
+        where id = $2
+        and status = $3
+        returning id
+      `,
+        [refOrder.status, refOrder.id, currentStatus]
+      )
+
+      if (res[1] == 0) {
+        this.trxMgr.queryRunner.rollbackTransaction()
+        throw new Error('Worksheet has already been created')
+      }
+    }
+
+    return await this.trxMgr.getRepository(entitySchema).save(refOrder)
+  }
+
+  /**
+   * @summary Update order targets (OrderProduct, OrderInventory, OrderVas)
+   * @description
+   * Update order targets like (OrderProduct, OrderInventory, OrderVas)
+   */
+  async updateOrderTargets(orderTargets: OrderTargetTypes[], entitySchema?: EntitySchema): Promise<any> {
+    if (!entitySchema) {
+      if (orderTargets[0] instanceof OrderProduct) {
+        //@ts-ignore
+        entitySchema = OrderProduct
+      } else if (orderTargets[0] instanceof OrderInventory) {
+        //@ts-ignore
+        entitySchema = OrderInventory
+      } else if (orderTargets[0] instanceof OrderVas) {
+        //@ts-ignore
+        entitySchema = OrderVas
+      }
+    }
+
+    if (orderTargets.some((orderTarget: any) => !orderTarget.id)) throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS)
+    orderTargets.forEach((orderTarget: OrderTargetTypes) => {
+      //@ts-ignore
+      if (!orderTarget.updater?.id) orderTarget = this.setStamp(orderTarget)
+    })
+
+    return await this.trxMgr.getRepository(entitySchema).save(orderTargets)
+  }
+
+  /**
+   * @summary generate worksheet and worksheet details
+   * @description It will generate worksheet and worksheet details in onetime
+   * Step 1. Call createWorksheet to create worksheet
+   *  The status of worksheet will be DEACTIVATED by default
+   *  You can change it through passing additionalProps
+   * Step 2. Update status of order targets
+   *  Beacuse its status can be different based on type of worksheet
+   * Step 3. Call createWorksheetDetails to create worksheet details
+   * Step 4. Call updateRefOrder to change status of reference order
+   */
+  async generateWorksheet(
+    worksheetType: string,
+    refOrder: ReferenceOrderType,
+    orderTargets: OrderTargetTypes[],
+    refOrderStatus: string,
+    orderTargetStatus: string,
+    additionalProps: Partial<Worksheet> = {}
+  ): Promise<Worksheet> {
+    const worksheet: Worksheet = await this.createWorksheet(refOrder, worksheetType, additionalProps)
+
+    orderTargets.forEach((orderTarget: OrderTargetTypes) => {
+      orderTarget.status = orderTargetStatus
+    })
+    orderTargets = await this.updateOrderTargets(orderTargets)
+
+    worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, worksheetType, orderTargets)
+
+    refOrder.status = refOrderStatus
+    await this.updateRefOrder(refOrder)
+
+    return worksheet
+  }
+
+  // @chernhaoee I think the naming of this function is not proper. Seems like it should be something like "updateLoadingWorksheet" since the logic targets only Loading Order Target
+  async updateWorksheet(
+    worksheetType: string,
+    refOrder: ReferenceOrderType,
+    worksheet: Worksheet,
+    orderTargets: OrderTargetTypes[],
+    refOrderStatus: string,
+    orderTargetStatus: string
+  ): Promise<Worksheet> {
+    let newOrderTarget = []
+
+    orderTargets.forEach((orderTarget: OrderTargetTypes) => {
+      orderTarget.status = orderTargetStatus
+    })
+    orderTargets = await this.updateOrderTargets(orderTargets)
+
+    for (let orderTarget of orderTargets) {
+      try {
+        await this.findWorksheetDetail({
+          targetInventory: orderTarget.id,
+          type: WORKSHEET_TYPE.LOADING
+        })
+      } catch (e) {
+        newOrderTarget.push(orderTarget)
+      }
+    }
+
+    worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, worksheetType, newOrderTarget)
+
+    // find worksheet details that doesnt exist based on order inventory
+    //worksheet.worksheetDetails = await this.findWorksheetDetail(worksheet.id)
+
+    refOrder.status = refOrderStatus
+    await this.updateRefOrder(refOrder)
+
+    return worksheet
+  }
+
+  async generateBatchWorksheet(
+    worksheetType: string,
+    batchPickingWorksheet: Worksheet,
+    orderTargets: OrderTargetTypes[],
+    orderTargetStatus: string,
+    additionalProps: Partial<Worksheet> = {}
+  ): Promise<Worksheet> {
+    const worksheet: Worksheet = await this.createBatchWorksheet(
+      batchPickingWorksheet.taskNo,
+      batchPickingWorksheet.bizplace,
+      worksheetType,
+      additionalProps
+    )
+
+    orderTargets.forEach((orderTarget: OrderTargetTypes) => {
+      orderTarget.status = orderTargetStatus
+    })
+    orderTargets = await this.updateOrderTargets(orderTargets)
+
+    worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, worksheetType, orderTargets)
+
+    return worksheet
+  }
+
+  /**
+   * @summary Activate worksheet
+   * @description It will activate passed worksheet
+   * Every passed worksheet and worksheet details should have value on its id field
+   * Because this function has logic to update worksheet and worksheet details
+   * Step 1. Check whether every passed worksheet and worksheet details has id
+   * Step 2. Change worksheet properly and update it
+   * Step 3. Change worksheet details properly and update it
+   */
+  async activateWorksheet(
+    worksheet: Worksheet,
+    worksheetDetails: WorksheetDetail[],
+    changedWorksheetDetails: Partial<WorksheetDetail>[]
+  ): Promise<Worksheet> {
+    if (!worksheet.id || worksheetDetails.some((wsd: WorksheetDetail) => !wsd.id)) {
+      throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS)
+    }
+
+    worksheet.status = WORKSHEET_STATUS.EXECUTING
+    worksheet.startedAt = new Date()
+    worksheet.updater = this.user
+    worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
+
+    worksheetDetails = this.renewWorksheetDetails(worksheetDetails, changedWorksheetDetails, 'name', {
+      status: WORKSHEET_STATUS.EXECUTING,
+      updater: this.user
+    })
+    worksheet.worksheetDetails = await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
+
+    return worksheet
+  }
+
+  /**
+   * @summary Complete worksheet
+   * @description It will activate passed worksheet
+   * Passed worksheet should have value on its id field
+   * Because this function has logic to update worksheet
+   * Step 1. Check whether passed worksheet has id
+   * Step 2. Change worksheet properly and update it
+   * Step 3. Renew worksheet with relations which is needed to complete worksheet
+   * Step 4. Change order targets properly and update it based on type of worksheet
+   * Step 5. If passed updatedRefOrderStatus has value it update reference order status
+   */
+  async completeWorksheet(worksheet: Worksheet, updatedRefOrderStatus?: string): Promise<Worksheet> {
+    if (!worksheet.id) throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS)
+
+    worksheet.status = WORKSHEET_STATUS.DONE
+    worksheet.endedAt = new Date()
+    worksheet.updater = this.user
+    worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
+
+    const worksheetType: string = worksheet.type
+    worksheet = await this.findWorksheet(worksheet, [
+      'worksheetDetails',
+      'worksheetDetails.targetProduct',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetVas'
+    ])
+
+    let worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+
+    worksheetDetails
+      .filter((wsd: WorksheetDetail) => wsd.status !== ORDER_INVENTORY_STATUS.REPLACED)
+      .forEach((wsd: WorksheetDetail) => {
+        wsd.status = WORKSHEET_STATUS.DONE
+        wsd.updater = this.user
+      })
+    await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
+
+    if (worksheetType === WORKSHEET_TYPE.UNLOADING) {
+      let targetProducts: OrderProduct[] = worksheet.worksheetDetails.map((wsd: WorksheetDetail) => {
+        let targetProduct: OrderProduct = wsd.targetProduct
+        targetProduct.status = ORDER_PRODUCT_STATUS.TERMINATED
+        targetProduct.updater = this.user
+        return targetProduct
+      })
+
+      await this.updateOrderTargets(targetProducts)
+    } else if (worksheetType === WORKSHEET_TYPE.VAS) {
+      let targetVASs: OrderVas[] = worksheet.worksheetDetails.map((wsd: WorksheetDetail) => {
+        let targetVAS: OrderVas = wsd.targetVas
+        targetVAS.status = ORDER_VAS_STATUS.TERMINATED
+        targetVAS.updater = this.user
+        return targetVAS
+      })
+
+      await this.updateOrderTargets(targetVASs)
+    } else if (
+      worksheetType === WORKSHEET_TYPE.PUTAWAY ||
+      worksheetType === WORKSHEET_TYPE.PICKING ||
+      worksheetType === WORKSHEET_TYPE.PACKING ||
+      worksheetType === WORKSHEET_TYPE.LOADING ||
+      worksheetType === WORKSHEET_TYPE.WAREHOUSE_RETURN ||
+      worksheetType === WORKSHEET_TYPE.UNLOADING_RETURN
+    ) {
+      let targetInventories: OrderInventory[] = worksheet.worksheetDetails
+        .filter((wsd: WorksheetDetail) => wsd.status !== ORDER_INVENTORY_STATUS.REPLACED)
+        .map((wsd: WorksheetDetail) => {
+          let targetInventory: OrderInventory = wsd.targetInventory
+          targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
+          targetInventory.updater = this.user
+          return targetInventory
+        })
+
+      await this.updateOrderTargets(targetInventories)
+    }
+
+    if (updatedRefOrderStatus) {
+      const refOrder: ReferenceOrderType = await this.extractRefOrderFromWorksheet(worksheet)
+      refOrder.status = updatedRefOrderStatus
+      refOrder.updater = this.user
+      await this.updateRefOrder(refOrder)
+    }
+
+    return worksheet
+  }
+
+  /**
+   * @summary Renew worksheet details by changed worksheet details
+   * @description When you want to merge changed worksheet detail list into original worksheet detail list
+   * you can use this function
+   * it will loop through whole passed original worksheet details and find out matched changed one by value of 'ID' or its 'name'
+   * Because of this, every passed origin worksheet details and changed worksheet details should have one of those values
+   */
+  renewWorksheetDetails(
+    originWSDs: WorksheetDetail[],
+    changedWSDs: Partial<WorksheetDetail>[],
+    identifier: string,
+    additionalProps: Partial<WorksheetDetail> = {}
+  ): WorksheetDetail[] {
+    if (
+      originWSDs.some((wsd: WorksheetDetail) => !wsd[identifier]) ||
+      changedWSDs.some((wsd: Partial<WorksheetDetail>) => !wsd[identifier])
+    ) {
+      throw new Error(
+        this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY(
+          'renew worksheet details',
+          `some passed parameter doesn't have identifier (${identifier})`
+        )
+      )
+    }
+
+    return originWSDs.map((originWSD: WorksheetDetail) => {
+      const changedWSD: Partial<WorksheetDetail> = this.findMatchedWSD(originWSD[identifier], changedWSDs)
+
+      return {
+        ...originWSD,
+        ...changedWSD,
+        ...additionalProps
+      }
+    })
+  }
+
+  /**
+   * @summary Find out matched worksheet detail by identifier
+   * @description Find out matched worksheet detail by identifier
+   * identifier can be 'ID' or 'name' of worksheet detail
+   */
+  findMatchedWSD(identifier: string, candidates: any[]): any {
+    return candidates.find(
+      (candidate: Partial<WorksheetDetail>) => candidate.id === identifier || candidate.name === identifier
+    )
+  }
+
+  /**
+   * @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)
+  }
+
+  /**
+   * @summary extract out referenc order from given worksheet
+   * @description If it doesn't have any reference order
+   * find worksheet with every possible reference order once again
+   * and extract out reference order from found worksheet
+   */
+  async extractRefOrderFromWorksheet(worksheet: Worksheet): Promise<ReferenceOrderType> {
+    let refOrder: ReferenceOrderType =
+      worksheet.arrivalNotice ||
+      worksheet.releaseGood ||
+      worksheet.vasOrder ||
+      worksheet.inventoryCheck ||
+      worksheet.returnOrder ||
+      null
+    if (!refOrder) {
+      const wsWithRefOrd: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+        where: { id: worksheet.id },
+        relations: ['arrivalNotice', 'releaseGood', 'vasOrder', 'inventoryCheck', 'returnOrder']
+      })
+
+      refOrder =
+        wsWithRefOrd.arrivalNotice ||
+        wsWithRefOrd.releaseGood ||
+        wsWithRefOrd.vasOrder ||
+        wsWithRefOrd.inventoryCheck ||
+        wsWithRefOrd.returnOrder ||
+        null
+      if (!refOrder) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheet.id))
+    }
+
+    return refOrder
+  }
+
+  /**
+   * @summary extract out reference orders from given merged order worksheet
+   * @description If it doesn't have any reference order
+   * find worksheet with every possible reference order once again
+   * and extract out reference order from found worksheet
+   */
+  async extractMultipleRefOrderFromWorksheet(worksheet: Worksheet): Promise<ReferenceOrderType> {
+    const wsdWithRefOrd: WorksheetDetail[] = await this.trxMgr.getRepository(WorksheetDetail).find({
+      where: { domain: { id: this.domain.id }, worksheet: { id: worksheet.id } },
+      relations: ['targetInventory', 'targetInventory.releaseGood']
+    })
+
+    let refOrder: ReferenceOrderType[] = wsdWithRefOrd.map((ord: WorksheetDetail) => ord.targetInventory.releaseGood)
+
+    if (!refOrder) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheet.id))
+
+    //@ts-ignore
+    return refOrder
+  }
+
+  /**
+   * @summary Check whether passed pallet is existing alreay
+   * @description It will try to count inventories which has same domain and same pallet Id and not terminated one
+   * If there's positive result it will throw an error cause pallet is duplicated
+   */
+  async checkPalletDuplication(palletId: string): Promise<void> {
+    const duplicatedPalletCnt: number = await this.trxMgr.getRepository(Inventory).countBy({
+      domain: { id: this.domain.id },
+      palletId,
+      status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+    })
+
+    if (duplicatedPalletCnt) throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Pallet ID', palletId))
+
+    const duplicatedReusablePalletCnt: number = await this.trxMgr.getRepository(Pallet).count({
+      where: {
+        domain: { id: this.domain.id },
+        name: palletId
+      }
+    })
+
+    if (duplicatedReusablePalletCnt) throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Pallet ID', palletId))
+  }
+
+  /**
+   * @summary Check whether passed carton is existing alreay
+   * @description It will try to count inventories which has same domain and same carton Id and not terminated one
+   * If there's positive result it will throw an error cause carton is duplicated
+   */
+  async checkCartonDuplication(cartonId: string, orderId: string): Promise<void> {
+    const duplicatedCartonCnt: number = await this.trxMgr.getRepository(Inventory).countBy({
+      domain: { id: this.domain.id },
+      cartonId,
+      refOrderId: Not(Equal(orderId)),
+      status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+    })
+
+    if (duplicatedCartonCnt) throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Carton ID', cartonId))
+  }
+
+  /**
+   * @summary Check whether passed serial number is existing already
+   * @description It will try to count inventories which has same domain and same serial number and  and not terminated one
+   * If there's positive result it will throw an error cause serial number is duplicated
+   */
+  async checkSerialNumberDuplication(serialNumber: string, product: Product): Promise<void> {
+    const duplicatedSerialNumberCnt: number = await this.trxMgr.getRepository(InventoryItem).countBy({
+      domain: { id: this.domain.id },
+      product: { id: product.id },
+      serialNumber,
+      status: Not(Equal(INVENTORY_STATUS.DELETED))
+    })
+
+    if (duplicatedSerialNumberCnt) throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Serial Number', serialNumber))
+  }
+
+  /**
+   * @summary Check for product child qty at any scanned level
+   * @description It will check every level of product detail by comparing scanned level and GAN registered level.
+   * By getting the level that has relation, child qty will be retrieved
+   * 1st level: PALLET -> 2 CARTONS (scan), 2nd level: CARTON -> 6 BAGS, 3rd level: BAG -> 10 UNITS, lowest: UNIT (order registered packing type)
+   */
+  async getChildQty(
+    productDetails: ProductDetail[],
+    productBarcode: string,
+    orderProductDetail: ProductDetail
+  ): Promise<number> {
+    const scannedProductDetail: ProductDetail = productDetails.find(
+      (productDetail: ProductDetail) => productDetail.gtin === productBarcode
+    )
+    let hasChildRelation: boolean = Boolean(scannedProductDetail?.childProductDetail)
+    let hasMatchingChild: boolean
+    let childQty: number
+    let currentProductDetail: ProductDetail
+
+    if (hasChildRelation) {
+      hasMatchingChild = Boolean(orderProductDetail.id === scannedProductDetail.childProductDetail.id)
+      currentProductDetail = productDetails.find(
+        (productDetail: ProductDetail) => productDetail.id === scannedProductDetail.childProductDetail.id
+      )
+      if (!currentProductDetail)
+        throw new Error(this.ERROR_MSG.FIND.NOT_MATCH('inner pack', `GTIN (${productBarcode})`))
+      childQty = scannedProductDetail.packingSize
+    } else {
+      throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+    }
+
+    if (hasMatchingChild) {
+      childQty = scannedProductDetail.packingSize
+    } else {
+      while (hasChildRelation && !hasMatchingChild) {
+        hasChildRelation = Boolean(currentProductDetail?.childProductDetail)
+
+        if (hasChildRelation)
+          hasMatchingChild = Boolean(orderProductDetail.id === currentProductDetail.childProductDetail.id)
+
+        if (hasMatchingChild) {
+          childQty = currentProductDetail.packingSize * childQty
+        } else if (!hasMatchingChild && hasChildRelation) {
+          childQty = currentProductDetail.packingSize * childQty
+          currentProductDetail = productDetails.find(
+            (productDetail: ProductDetail) => productDetail.id === currentProductDetail.childProductDetail.id
+          )
+        } else if (!hasChildRelation && !hasMatchingChild) {
+          throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+        }
+      }
+    }
+
+    return childQty
+  }
+
+  public async getDirectQty(productDetail: ProductDetail, productBarcode: string, qty: number): Promise<any> {
+    try {
+      console.time('getDirectQty')
+      let results = await this.trxMgr.query(
+        `
+        WITH RECURSIVE cte as (
+          select * from (
+            select pd.product_id as "productId", id, pd.packing_size as "packingSize",
+            pd.packing_type as "packingType", pd.uom as "uom", (pd.uom_value * $2::float) as "uomValue", $2::float as "qty", pd.gtin            
+            from product_details pd 
+            where pd.id = $1
+          ) as dt
+          union all
+          select pd.product_id as "productId", pd.id, pd.packing_size as "packingSize",
+          pd.packing_type as "packingType", pd.uom,
+          dt1.qty * pd.packing_size * pd.uom_value as "uomValue", dt1.qty * pd.packing_size as "qty", pd.gtin
+          from product_details pd
+          inner join cte dt1 on dt1.id = pd.child_product_detail_id 
+          where pd.deleted_at is null
+        )
+        select * from cte where gtin = $3
+      `,
+        [productDetail.id, qty, productBarcode]
+      )
+
+      if (results.length <= 0) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+
+      console.timeEnd('getDirectQty')
+      return results[0]
+    } catch (error) {
+      throw error
+    }
+  }
+
+  /**
+   * @summary Check for product child qty at any scanned level
+   * @description It will check every level of product detail by comparing scanned level and GAN registered level.
+   * By getting the level that has relation, child qty will be retrieved
+   * 1st level: PALLET -> 2 CARTONS (scan), 2nd level: CARTON -> 6 BAGS, 3rd level: BAG -> 10 UNITS, lowest: UNIT (order registered packing type)
+   */
+  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
+  }
+
+  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[]> {
+    //@ts-ignore
+    if (!inventory.id) throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS)
+    inventory = this.setStamp(inventory)
+    return await this.trxMgr.getRepository(Inventory).save(inventory)
+  }
+
+  /**
+   * @summary Do transaction on inventory record
+   * @description It will update inventory after set a temp (domain, updater)
+   * and then generate inventory history based on current changes
+   */
+  async transactionInventory(
+    inventory: Partial<Inventory>,
+    referencOrder: ReferenceOrderType,
+    changedQty: number,
+    changedWeight: number,
+    transactionType: string
+  ): Promise<Inventory> {
+    if (inventory.id) {
+      //@ts-ignore
+      inventory = await this.updateInventory(inventory)
+    } else {
+      //@ts-ignore
+      inventory = await this.createInventory(inventory)
+    }
+
+    await generateInventoryHistory(
+      //@ts-ignore
+      inventory,
+      referencOrder,
+      transactionType,
+      changedQty,
+      changedWeight,
+      this.user,
+      this.trxMgr
+    )
+
+    //@ts-ignore
+    return inventory
+  }
+
+  /**
+   * @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
+  }
+
+  /**
+   * @summary Extract bizplace from reference order
+   * @description It will find reference order with bizplace and return only bizplace to extract it out
+   */
+  async extractBizplaceFromRefOrder(refOrder: ReferenceOrderType, entitySchema?: EntitySchema): Promise<Bizplace> {
+    if (!entitySchema) {
+      if (refOrder instanceof ArrivalNotice) {
+        //@ts-ignore
+        entitySchema = ArrivalNotice
+      } else if (refOrder instanceof ReleaseGood) {
+        //@ts-ignore
+        entitySchema = ReleaseGood
+      } else if (refOrder instanceof VasOrder) {
+        //@ts-ignore
+        entitySchema = VasOrder
+      } else if (refOrder instanceof InventoryCheck) {
+        //@ts-ignore
+        entitySchema = InventoryCheck
+      } else if (refOrder instanceof ReturnOrder) {
+        //@ts-ignore
+        entitySchema = ReturnOrder
+      }
+    }
+
+    const { bizplace }: { bizplace: Bizplace } = await this.findRefOrder(entitySchema, refOrder, ['bizplace'])
+    return bizplace
+  }
+
+  tidyConditions(record: Record<string, any>): Record<string, any> {
+    if ('id' in record) {
+      return { id: record.id }
+    } else {
+      Object.keys(record).forEach((key: string) => {
+        if (record[key] === null || record[key] instanceof Date || Array.isArray(record[key])) delete record[key]
+      })
+    }
+
+    return record
+  }
+}