@things-factory/worksheet-base 8.0.0-beta.1 → 8.0.0-beta.2

package/server/controllers/outbound/packing-worksheet-controller.ts

@@ -1,449 +0,0 @@
-import { Equal, Not } from 'typeorm'
-
-import { Product, ProductDetail } from '@things-factory/product-base'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
-import {
-  Inventory,
-  INVENTORY_ITEM_SOURCE,
-  INVENTORY_STATUS,
-  INVENTORY_TRANSACTION_TYPE,
-  InventoryItem,
-  InventoryNoGenerator
-} from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
-import { Worksheet, WorksheetDetail } from '../../entities'
-import { VasWorksheetController } from '../vas/vas-worksheet-controller'
-
-export class PackingWorksheetController extends VasWorksheetController {
-  async generatePackingWorksheet(releaseGoodNo: string): Promise<Worksheet> {
-    //@ts-ignore
-    let releaseGood: ReleaseGood = await this.findRefOrder(
-      //@ts-ignore
-      ReleaseGood,
-      {
-        domain: { id: this.domain.id },
-        name: releaseGoodNo
-      },
-      ['orderInventories', 'orderInventories.inventory']
-    )
-    let orderInventories: OrderInventory[] = releaseGood.orderInventories.filter(oi => {
-      return oi.inventory.status !== 'MISSING'
-    })
-
-    const existingPackingWorksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
-      where: {
-        domain: { id: this.domain.id },
-        releaseGood: { id: releaseGood.id },
-        type: WORKSHEET_TYPE.PACKING,
-        status: WORKSHEET_STATUS.DEACTIVATED
-      }
-    })
-
-    if (existingPackingWorksheet) throw new Error('There is existing packing worksheet that has been generated')
-    let worksheet: Worksheet = await this.createWorksheet(releaseGood, WORKSHEET_TYPE.PACKING)
-
-    if (orderInventories.every((oi: OrderInventory) => oi.inventory?.id) || releaseGood.crossDocking) {
-      worksheet.worksheetDetails = await this.createWorksheetDetails(
-        worksheet,
-        WORKSHEET_TYPE.PACKING,
-        orderInventories
-      )
-    }
-
-    orderInventories.forEach((oi: OrderInventory) => {
-      oi.status = ORDER_INVENTORY_STATUS.READY_TO_PACK
-      oi.updater = this.user
-    })
-    await this.updateOrderTargets(orderInventories)
-
-    return worksheet
-  }
-
-  async activatePacking(worksheetNo: string): Promise<Worksheet> {
-    let worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.PACKING, [
-      'releaseGood',
-      'releaseGood.bizplace',
-      'releaseGood.bizplace.domain',
-      'worksheetDetails',
-      'worksheetDetails.targetInventory'
-    ])
-
-    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED')
-    const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
-      let targetInventory: OrderInventory = wsd.targetInventory
-      targetInventory.status = ORDER_INVENTORY_STATUS.PACKING
-      targetInventory.updater = this.user
-      return targetInventory
-    })
-    this.updateOrderTargets(targetInventories)
-
-    let releaseGood: ReleaseGood = worksheet.releaseGood
-    releaseGood.status = ORDER_STATUS.PACKING
-    releaseGood.updater = this.user
-    this.updateRefOrder(releaseGood)
-
-    worksheet = await this.activateWorksheet(worksheet, worksheetDetails, [])
-
-    return worksheet
-  }
-
-  async packing(worksheetDetailName: string, packedQty: number, serialNumber?: string): Promise<WorksheetDetail> {
-    let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
-      worksheetDetailName,
-      WORKSHEET_TYPE.PACKING,
-      [
-        'worksheet',
-        'worksheet.bizplace',
-        'worksheet.bizplace.domain',
-        'targetInventory',
-        'targetInventory.releaseGood',
-        'targetInventory.inventory',
-        'targetInventory.inventory.location',
-        'targetInventory.product'
-      ]
-    )
-    const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    const product: Product = targetInventory.product
-    let inventory: Inventory = targetInventory.inventory
-    const pickedQty: number = targetInventory.releaseQty
-
-    if (packedQty > pickedQty) {
-      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`))
-    }
-
-    // Serial Number scanning for batch picking
-    if (targetInventory?.refWorksheetId) {
-      if (product?.isRequireSerialNumberScanningOutbound) {
-        if (!serialNumber || serialNumber == '') {
-          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('packing', `require serial number`))
-        }
-
-        let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
-          where: { domain: { id: this.domain.id }, serialNumber: serialNumber, product: { id: product.id } },
-          relations: ['product', 'inventory']
-        })
-
-        if (foundSerialNumber) {
-          if (foundSerialNumber.outboundOrderId) {
-            let releaseGood: ReleaseGood = await this.trxMgr
-              .getRepository(ReleaseGood)
-              .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
-            throw new Error(`Inventory Item is already picked/packed in ${releaseGood.name}`)
-          }
-
-          //@ts-ignore
-          foundSerialNumber.status = INVENTORY_STATUS.PACKING
-          foundSerialNumber.updater = this.user
-          foundSerialNumber.outboundOrderId = releaseGood.id
-
-          await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
-        } else {
-          let inventoryItem: InventoryItem = new InventoryItem()
-          inventoryItem.name = InventoryNoGenerator.inventoryItemName()
-          inventoryItem.serialNumber = serialNumber
-          //@ts-ignore
-          inventoryItem.status = INVENTORY_STATUS.PACKING
-          inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
-          inventoryItem.outboundOrderId = releaseGood.id
-          inventoryItem.product = product
-          inventoryItem.inventory = inventory
-          inventoryItem.domain = this.domain
-
-          foundSerialNumber = await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
-        }
-      }
-    }
-
-    targetInventory.packedQty = Boolean(targetInventory.packedQty) ? targetInventory.packedQty + packedQty : packedQty
-    if (targetInventory.packedQty == targetInventory.releaseQty) {
-      targetInventory.status = ORDER_INVENTORY_STATUS.PACKED
-
-      //@ts-ignore
-      let inventoryItems: InventoryItem = await this.trxMgr
-        .getRepository(InventoryItem)
-        .find({ where: { outboundOrderId: releaseGood.id } })
-
-      //@ts-ignore
-      if (inventoryItems.length > 0) {
-        //@ts-ignore
-        inventoryItems.forEach((itm: InventoryItem) => {
-          //@ts-ignore
-          itm.status = INVENTORY_STATUS.PACKED
-          itm.updater = this.user
-        })
-
-        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
-      }
-
-      await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
-
-      worksheetDetail.status = WORKSHEET_STATUS.DONE
-    }
-
-    await this.updateOrderTargets([targetInventory])
-
-    worksheetDetail.updater = this.user
-    worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
-    return worksheetDetail
-  }
-
-  async scanProductPacking(
-    worksheetDetailName: string,
-    productBarcode: string,
-    serialNumber?: string
-  ): Promise<WorksheetDetail> {
-    let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
-      worksheetDetailName,
-      WORKSHEET_TYPE.PACKING,
-      [
-        'worksheet',
-        'worksheet.bizplace',
-        'worksheet.bizplace.domain',
-        'targetInventory',
-        'targetInventory.releaseGood',
-        'targetInventory.inventory',
-        'targetInventory.inventory.product',
-        'targetInventory.inventory.product.productDetails',
-        'targetInventory.inventory.product.productDetails.childProductDetail',
-        'targetInventory.inventory.location'
-      ]
-    )
-    const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
-    const product: Product = worksheetDetail.targetInventory.inventory.product
-    const filterProductDetails: ProductDetail[] = product?.productDetails.filter(detail => !detail.deletedAt)
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    let inventory: Inventory = targetInventory.inventory
-    let packedQty: number = 1
-    let pickedQty: number = targetInventory.releaseQty
-
-    // search for matching product barcode
-    const productDetail: ProductDetail = product?.productDetails
-      .filter(detail => !detail.deletedAt)
-      .find(
-        detail =>
-          detail.gtin === productBarcode &&
-          detail.packingType === inventory.packingType &&
-          detail.packingSize === inventory.packingSize
-      )
-
-    if (!productDetail && !product?.isRequireSerialNumberScanningOutbound) {
-      let roProductDetail: ProductDetail = product?.productDetails.find(
-        (parentDetail: ProductDetail) =>
-          parentDetail.packingType === inventory.packingType && parentDetail.packingSize == inventory.packingSize
-      )
-
-      roProductDetail.product = product
-
-      let childQty = await this.getChildQty(filterProductDetails, productBarcode, roProductDetail)
-      packedQty *= childQty
-    } else if (!productDetail) {
-      throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
-    }
-
-    if (packedQty + targetInventory.packedQty > pickedQty) {
-      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
-    }
-
-    // Serial Number scanning for batch picking
-    if (targetInventory?.refWorksheetId) {
-      if (product?.isRequireSerialNumberScanningOutbound) {
-        if (!serialNumber || serialNumber == '') {
-          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('packing', `require serial number`))
-        }
-
-        let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
-          where: { domain: { id: this.domain.id }, serialNumber: serialNumber, product: { id: product.id } }
-        })
-
-        if (foundSerialNumber) {
-          if (foundSerialNumber.inventoryId !== inventory.id) {
-            throw new Error('Serial Number scanned is in another inventory')
-          }
-
-          if (foundSerialNumber.outboundOrderId) {
-            let releaseGood: ReleaseGood = await this.trxMgr
-              .getRepository(ReleaseGood)
-              .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
-            throw new Error(`Inventory Item is already picked/packed in ${releaseGood.name}`)
-          }
-
-          //@ts-ignore
-          foundSerialNumber.status = INVENTORY_STATUS.PACKING
-          foundSerialNumber.updater = this.user
-          foundSerialNumber.outboundOrderId = releaseGood.id
-
-          await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
-        } else {
-          let inventoryItem: InventoryItem = new InventoryItem()
-          inventoryItem.name = InventoryNoGenerator.inventoryItemName()
-          inventoryItem.serialNumber = serialNumber
-          //@ts-ignore
-          inventoryItem.status = INVENTORY_STATUS.PACKING
-          inventoryItem.outboundOrderId = releaseGood.id
-          inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
-          inventoryItem.product = product
-          inventoryItem.inventory = inventory
-          inventoryItem.domain = this.domain
-
-          await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
-        }
-      }
-    }
-
-    targetInventory.packedQty = Boolean(targetInventory?.packedQty) ? targetInventory.packedQty + packedQty : packedQty
-    if (targetInventory.packedQty > pickedQty) {
-      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`))
-    }
-
-    targetInventory.packedAt = new Date()
-    targetInventory.packedByUser = this.user
-
-    let packedBy: string[] = targetInventory.packedBy ? targetInventory.packedBy.split(',') : []
-    if (!packedBy.find(x => x == this.user.name)) {
-      packedBy.push(this.user.name)
-      targetInventory.packedBy = packedBy.join(',')
-    }
-
-    if (targetInventory.packedQty == pickedQty) {
-      targetInventory.status = ORDER_INVENTORY_STATUS.PACKED
-      await this.updateOrderTargets([targetInventory])
-      await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
-
-      worksheetDetail.status = WORKSHEET_STATUS.DONE
-      worksheetDetail.updater = this.user
-      await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
-
-      //@ts-ignore
-      let inventoryItems: InventoryItem = await this.trxMgr
-        .getRepository(InventoryItem)
-        .find({ where: { outboundOrderId: releaseGood.id } })
-
-      //@ts-ignore
-      if (inventoryItems.length > 0) {
-        //@ts-ignore
-        inventoryItems.forEach((itm: InventoryItem) => {
-          //@ts-ignore
-          itm.status = INVENTORY_STATUS.PACKED
-          itm.updater = this.user
-        })
-
-        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
-      }
-    } else {
-      await this.trxMgr.getRepository(OrderInventory).save(targetInventory)
-    }
-
-    return worksheetDetail
-  }
-
-  async completePacking(releaseGoodNo: string): Promise<Worksheet> {
-    //@ts-ignore
-    let releaseGood: ReleaseGood = await this.findRefOrder(ReleaseGood, {
-      domain: { id: this.domain.id },
-      name: releaseGoodNo,
-      status: ORDER_STATUS.PACKING
-    })
-
-    const worksheet: Worksheet = await this.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PACKING, [
-      'worksheetDetails',
-      'worksheetDetails.targetInventory'
-    ])
-    this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
-
-    //@ts-ignore
-    let inventoryItems: InventoryItem = await this.trxMgr
-      .getRepository(InventoryItem)
-      .find({ where: { outboundOrderId: releaseGood.id } })
-
-    //@ts-ignore
-    if (inventoryItems.length > 0) {
-      //@ts-ignore
-      inventoryItems.forEach((itm: InventoryItem) => {
-        itm.status = INVENTORY_STATUS.TERMINATED
-        itm.updater = this.user
-      })
-
-      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
-    }
-
-    let orderStatus: string
-    if (releaseGood?.courierOption) orderStatus = ORDER_STATUS.DONE
-    else orderStatus = ORDER_STATUS.LOADING
-
-    return await this.completeWorksheet(worksheet, orderStatus)
-  }
-
-  async undoSerialNumberPacking(worksheetDetailName: string, inventoryItemId: string): Promise<void> {
-    const worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
-      where: {
-        name: worksheetDetailName,
-        domain: { id: this.domain.id },
-        status: Not(Equal(WORKSHEET_STATUS.DEACTIVATED))
-      },
-      relations: [
-        'worksheet',
-        'worksheet.releaseGood',
-        'targetInventory',
-        'targetInventory.product',
-        'targetInventory.inventory'
-      ]
-    })
-
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    let releaseGood: ReleaseGood = worksheetDetail.worksheet.releaseGood
-
-    if (
-      targetInventory.releaseQty == targetInventory.packedQty &&
-      targetInventory.status == ORDER_INVENTORY_STATUS.PACKED
-    ) {
-      //@ts-ignore
-      targetInventory.status = INVENTORY_STATUS.PACKING
-
-      await this.trxMgr
-        .getRepository(WorksheetDetail)
-        .update({ id: worksheetDetail.id }, { status: WORKSHEET_STATUS.EXECUTING })
-    }
-
-    //@ts-ignore
-    let inventoryItems: InventoryItem = await this.trxMgr
-      .getRepository(InventoryItem)
-      .find({ where: { outboundOrderId: releaseGood.id } })
-
-    let removeInventoryItem: InventoryItem = await this.trxMgr
-      .getRepository(InventoryItem)
-      .findOne({ where: { id: inventoryItemId } })
-
-    //@ts-ignore
-    if (inventoryItems.length > 0) {
-      //@ts-ignore
-      inventoryItems.forEach((itm: InventoryItem) => {
-        //@ts-ignore
-        itm.status = INVENTORY_STATUS.PACKING
-        itm.updater = this.user
-      })
-
-      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
-    }
-
-    if (removeInventoryItem.source == INVENTORY_ITEM_SOURCE.OUTBOUND) {
-      await this.trxMgr.getRepository(InventoryItem).delete(removeInventoryItem.id)
-    } else {
-      await this.trxMgr.getRepository(InventoryItem).update(
-        {
-          id: inventoryItemId
-        },
-        {
-          status: INVENTORY_STATUS.STORED,
-          outboundOrderId: null,
-          updater: this.user as any
-        }
-      )
-    }
-
-    targetInventory.packedQty--
-    targetInventory.updater = this.user
-    await this.updateOrderTargets([targetInventory])
-  }
-}