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

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

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