@things-factory/worksheet-base 5.0.0-alpha.3 → 5.0.0-alpha.30

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

@@ -1,6 +1,15 @@
+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_TRANSACTION_TYPE } from '@things-factory/warehouse-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'
@@ -70,7 +79,7 @@ export class PackingWorksheetController extends VasWorksheetController {
     return worksheet
   }
 
-  async packing(worksheetDetailName: string, packedQty: number): Promise<WorksheetDetail> {
+  async packing(worksheetDetailName: string, packedQty: number, serialNumber: string): Promise<WorksheetDetail> {
     let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
       worksheetDetailName,
       WORKSHEET_TYPE.PACKING,
@@ -81,11 +90,13 @@ export class PackingWorksheetController extends VasWorksheetController {
         'targetInventory',
         'targetInventory.releaseGood',
         'targetInventory.inventory',
-        'targetInventory.inventory.location'
+        '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
 
@@ -93,19 +104,81 @@ export class PackingWorksheetController extends VasWorksheetController {
       throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`))
     }
 
-    targetInventory.packedQty = packedQty
-    targetInventory.status = ORDER_INVENTORY_STATUS.PACKED
-    await this.updateOrderTargets([targetInventory])
+    // 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: this.domain, serialNumber: serialNumber, product },
+          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}`)
+          }
+
+          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
+          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
+
+      let inventoryItems: InventoryItem = await this.trxMgr
+        .getRepository(InventoryItem)
+        .find({ where: { outboundOrderId: releaseGood.id } })
+
+      if (inventoryItems.length > 0) {
+        inventoryItems.forEach((itm: InventoryItem) => {
+          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.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
+    await this.updateOrderTargets([targetInventory])
 
-    worksheetDetail.status = WORKSHEET_STATUS.DONE
     worksheetDetail.updater = this.user
     worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
     return worksheetDetail
   }
 
-  async scanProductPacking(worksheetDetailName: string, productBarcode: string): Promise<WorksheetDetail> {
+  async scanProductPacking(
+    worksheetDetailName: string,
+    productBarcode: string,
+    serialNumber?: string
+  ): Promise<WorksheetDetail> {
     let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
       worksheetDetailName,
       WORKSHEET_TYPE.PACKING,
@@ -139,11 +212,64 @@ export class PackingWorksheetController extends VasWorksheetController {
       )
     if (!productDetail) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
+    // 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: this.domain, serialNumber: serialNumber, product } })
+
+        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}`)
+          }
+
+          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
+          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])
@@ -152,6 +278,19 @@ export class PackingWorksheetController extends VasWorksheetController {
       worksheetDetail.status = WORKSHEET_STATUS.DONE
       worksheetDetail.updater = this.user
       await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+      let inventoryItems: InventoryItem = await this.trxMgr
+        .getRepository(InventoryItem)
+        .find({ where: { outboundOrderId: releaseGood.id } })
+
+      if (inventoryItems.length > 0) {
+        inventoryItems.forEach((itm: InventoryItem) => {
+          itm.status = INVENTORY_STATUS.PACKED
+          itm.updater = this.user
+        })
+
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+      }
     } else {
       await this.trxMgr.getRepository(OrderInventory).save(targetInventory)
     }
@@ -172,10 +311,86 @@ export class PackingWorksheetController extends VasWorksheetController {
     ])
     this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
 
+    let inventoryItems: InventoryItem = await this.trxMgr
+      .getRepository(InventoryItem)
+      .find({ where: { outboundOrderId: releaseGood.id } })
+
+    if (inventoryItems.length > 0) {
+      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: this.domain, 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
+    ) {
+      targetInventory.status = INVENTORY_STATUS.PACKING
+
+      await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .update({ id: worksheetDetail.id }, { status: WORKSHEET_STATUS.EXECUTING })
+    }
+
+    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 } })
+
+    if (inventoryItems.length > 0) {
+      inventoryItems.forEach((itm: InventoryItem) => {
+        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
+        }
+      )
+    }
+
+    targetInventory.packedQty--
+    targetInventory.updater = this.user
+    await this.updateOrderTargets([targetInventory])
+  }
 }