@things-factory/worksheet-base 5.0.0-alpha.8 → 5.0.0-alpha.9

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

@@ -144,6 +144,15 @@ 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.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])

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

@@ -1,4 +1,4 @@
-import { In } from 'typeorm'
+import { Equal, In, Not } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
@@ -14,8 +14,11 @@ import {
 import { Setting } from '@things-factory/setting-base'
 import {
   Inventory,
+  INVENTORY_ITEM_SOURCE,
   INVENTORY_STATUS,
   INVENTORY_TRANSACTION_TYPE,
+  InventoryItem,
+  InventoryNoGenerator,
   Location,
   LOCATION_TYPE
 } from '@things-factory/warehouse-base'
@@ -443,7 +446,7 @@ export class PickingWorksheetController extends VasWorksheetController {
           detail.product?.id === product.id
       )
 
-      if (!foundProductDetail) {
+      if (!foundProductDetail && !product?.isRequireSerialNumberScanningOutbound) {
         const roProductDetail: ProductDetail = productDetails.find(
           (parentDetail: ProductDetail) =>
             parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
@@ -453,16 +456,56 @@ export class PickingWorksheetController extends VasWorksheetController {
         if (pickedQty > releaseQty) {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
         }
+      } else if (!foundProductDetail) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
       }
 
-      if (product?.isRequireSerialNumberScanning) {
-        if (!serialNumber || serialNumber == '')
+      if (product?.isRequireSerialNumberScanningOutbound) {
+        if (!serialNumber || serialNumber == '') {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
+        }
 
-        if (serialNumber) {
-          targetInventory.serialNumber = JSON.stringify(
-            targetInventory.serialNumber ? [...JSON.parse(targetInventory.serialNumber), serialNumber] : [serialNumber]
-          )
+        let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
+          where: {
+            inventory,
+            status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+          }
+        })
+
+        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.status !== INVENTORY_STATUS.STORED || foundSerialNumber.outboundOrderId) {
+            throw new Error('Inventory Item is not available')
+          }
+
+          foundSerialNumber.status = INVENTORY_STATUS.PICKED
+          foundSerialNumber.updater = this.user
+          foundSerialNumber.outboundOrderId = releaseGood.id
+
+          await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+        } else {
+          if (totalInventoryItems >= inventory.qty) {
+            throw new Error('Insufficient inventory quantity to scan new serial number')
+          }
+
+          let inventoryItem: InventoryItem = new InventoryItem()
+          inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+          inventoryItem.serialNumber = serialNumber
+          inventoryItem.status = INVENTORY_STATUS.PICKED
+          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)
         }
       }
 
@@ -509,24 +552,103 @@ export class PickingWorksheetController extends VasWorksheetController {
       //validation to prevent over release
       if (inventory.qty <= 0) throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
 
-      if (inventory.palletId !== palletId)
+      if (inventory.palletId !== palletId /*&& !product?.isRequireSerialNumberScanningOutbound*/)
+        //to be changed
         throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
 
-      if (product?.isRequireSerialNumberScanning) {
-        if (!serialNumber || serialNumber == '')
+      if (product?.isRequireSerialNumberScanningOutbound) {
+        if (!serialNumber || serialNumber == '') {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
+        }
 
-        if (serialNumber) {
-          targetInventory.serialNumber = JSON.stringify(
-            targetInventory.serialNumber ? [...JSON.parse(targetInventory.serialNumber), serialNumber] : [serialNumber]
-          )
+        let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
+          where: {
+            inventory
+          }
+        })
+
+        let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+          where: { domain: this.domain, serialNumber: serialNumber, product },
+          relations: ['product', 'inventory']
+        })
+
+        let scannedPalletIdInventory: Inventory = await this.trxMgr
+          .getRepository(Inventory)
+          .findOne({ where: { domain: this.domain, palletId }, relations: ['product'] })
+
+        if (foundSerialNumber) {
+          if (
+            foundSerialNumber.status !== INVENTORY_STATUS.STORED ||
+            foundSerialNumber.outboundOrderId ||
+            foundSerialNumber.inventory !== inventory
+            /*to be changed for replacement && inventory.palletId == palletId*/
+          ) {
+            throw new Error('Inventory Item is not available')
+          }
+
+          foundSerialNumber.status = INVENTORY_STATUS.PICKED
+          foundSerialNumber.updater = this.user
+          foundSerialNumber.outboundOrderId = releaseGood.id
+
+          await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+        } else {
+          if (totalInventoryItems >= inventory.qty) {
+            throw new Error('Insufficient inventory quantity to scan new serial number')
+          }
+
+          let inventoryItem: InventoryItem = new InventoryItem()
+          inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+          inventoryItem.serialNumber = serialNumber
+          inventoryItem.status = INVENTORY_STATUS.PICKED
+          inventoryItem.outboundOrderId = releaseGood.id
+          inventoryItem.product = product
+          inventoryItem.inventory = scannedPalletIdInventory
+          inventoryItem.domain = this.domain
+
+          await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
         }
-      }
 
-      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
+        if (inventory.palletId !== palletId) {
+          let existingOrderInv = await this.trxMgr.getRepository(OrderInventory).findOne({
+            where: {
+              domain: this.domain,
+              inventory: scannedPalletIdInventory,
+              releaseGood: releaseGood
+            }
+          })
+
+          if (existingOrderInv) {
+            //if replacement order inventory already existed in worksheet detail
+            await this.serialNumberReplacementForExistingOrderInv(
+              existingOrderInv,
+              targetInventory,
+              worksheetDetail,
+              foundSerialNumber
+            )
+          } else if (
+            scannedPalletIdInventory.batchId == inventory.batchId &&
+            scannedPalletIdInventory.product.id == product.id &&
+            scannedPalletIdInventory.product.packingType == product.packingType
+          ) {
+            //if replacement order inventory does not exist
+            await this.serialNumberReplacement(
+              targetInventory,
+              scannedPalletIdInventory,
+              releaseGood,
+              product,
+              worksheetDetail,
+              foundSerialNumber
+            )
+          } else {
+            throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
+          }
+        }
+      }
 
       await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
 
+      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
+
       const fromLocation: Location = targetInventory.inventory.location
       if (locationName) {
         const toLocation: Location = await this.trxMgr.getRepository(Location).findOne({
@@ -829,6 +951,28 @@ export class PickingWorksheetController extends VasWorksheetController {
     ])
     await 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
+      })
+
+      // let inventoryLists = InventoryItems.filter(
+      //   (value, index, self) => index === self.findIndex(itm => itm.inventory.id === value.inventory.id)
+      // )
+
+      // inventoryLists.forEach((itm: Inventory) => {
+      //   if (itm.inventory.qty - itm.releaseQty == 0)
+      //     this.transactionInventory(itm, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+      // })
+
+      await this.trxMgr.getRepository(InventoryItem).save(InventoryItems)
+    }
+
     let orderStatus: string
     if (releaseGood?.packingOption) {
       orderStatus = ORDER_STATUS.READY_TO_PACK
@@ -989,4 +1133,277 @@ export class PickingWorksheetController extends VasWorksheetController {
 
     return orderInventory
   }
+
+  private async serialNumberReplacementForExistingOrderInv(
+    existingOrderInv,
+    targetInventory,
+    worksheetDetail,
+    foundSerialNumber
+  ) {
+    try {
+      //1. update replacement inventory, order inventory, old inventory, old order inventory quantity
+      let newInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { domain: this.domain, id: existingOrderInv?.inventoryId } })
+
+      let newOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: this.domain, id: existingOrderInv?.id } })
+
+      let oldInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.inventory.id } })
+
+      let oldOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.id } })
+
+      //if replacement inventory quantity insufficient
+      if (newInventory.qty - newInventory.lockedQty < targetInventory.releaseQty - targetInventory.pickedQty) {
+        newOrderInventory.releaseQty += newInventory.qty - newInventory.lockedQty
+        newOrderInventory.releaseUomValue += newInventory.uomValue - newInventory.lockedUomValue
+
+        oldOrderInventory.releaseQty -= newOrderInventory.releaseQty
+        oldOrderInventory.releaseUomValue -= newOrderInventory.releaseUomValue
+
+        oldInventory.lockedQty -= newOrderInventory.releaseQty
+        oldInventory.lockedUomValue -= newOrderInventory.releaseUomValue
+
+        newInventory.lockedQty = newInventory.qty
+        newInventory.lockedUomValue = newInventory.uomValue
+      } else {
+        newOrderInventory.releaseQty += targetInventory.releaseQty - targetInventory.pickedQty
+        newOrderInventory.releaseUomValue +=
+          newOrderInventory.releaseQty * (targetInventory.releaseUomValue / targetInventory.releaseQty)
+
+        oldOrderInventory.releaseQty = targetInventory.pickedQty
+        oldOrderInventory.status = INVENTORY_STATUS.PICKED
+        oldOrderInventory.releaseUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * oldOrderInventory.releaseQty
+
+        oldInventory.lockedQty -= targetInventory.releaseQty - targetInventory.pickedQty
+        oldInventory.lockedUomValue =
+          oldInventory.lockedQty * (targetInventory.releaseUomValue / targetInventory.releaseQty)
+
+        newInventory.lockedQty = newInventory.lockedQty + (targetInventory.releaseQty - targetInventory.pickedQty)
+        newInventory.lockedUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * newInventory.lockedQty
+      }
+
+      newInventory = await this.trxMgr.getRepository(Inventory).save({ ...newInventory, updater: this.user })
+
+      newOrderInventory = await this.trxMgr.getRepository(OrderInventory).save({
+        ...newOrderInventory,
+        status: INVENTORY_STATUS.PICKING,
+        pickedQty: existingOrderInv.pickedQty++,
+        updater: this.user
+      })
+
+      oldInventory = await this.trxMgr.getRepository(Inventory).save({ ...oldInventory, updater: this.user })
+
+      foundSerialNumber = await this.trxMgr
+        .getRepository(InventoryItem)
+        .save({ ...foundSerialNumber, inventory: newInventory })
+
+      //2. update replacement worksheet detail
+      await this.trxMgr.getRepository(WorksheetDetail).update(
+        {
+          targetInventory: existingOrderInv
+        },
+        {
+          status: WORKSHEET_STATUS.EXECUTING,
+          updater: this.user
+        }
+      )
+
+      if (oldOrderInventory.releaseQty !== 0) {
+        oldOrderInventory = await this.trxMgr
+          .getRepository(OrderInventory)
+          .save({ ...oldOrderInventory, updater: this.user })
+
+        await this.trxMgr.getRepository(WorksheetDetail).update(
+          {
+            name: worksheetDetail.name
+          },
+          {
+            status: WORKSHEET_STATUS.DONE,
+            updater: this.user
+          }
+        )
+      } else {
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
+        await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.ild)
+      }
+    } catch (e) {}
+  }
+
+  private async serialNumberReplacement(
+    targetInventory,
+    scannedPalletIdInventory,
+    releaseGood,
+    product,
+    worksheetDetail,
+    foundSerialNumber
+  ) {
+    try {
+      //1. create new inventory, new order inventory, update old inventory, old order inventory quantity
+      let newInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { id: scannedPalletIdInventory?.id } })
+
+      let oldInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.inventory.id } })
+
+      let oldOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.id } })
+
+      let newOrderInventoryReleaseQty = 0
+      let newOrderInventoryReleaseUomValue = 0
+
+      //if replacement inventory quantity insufficient
+      if (newInventory.qty - newInventory.lockedQty < targetInventory.releaseQty - targetInventory.pickedQty) {
+        newOrderInventoryReleaseQty = newInventory.qty - newInventory.lockedQty
+        newOrderInventoryReleaseUomValue = newInventory.uomValue - newInventory.lockedUomValue
+
+        oldOrderInventory.releaseQty -= newOrderInventoryReleaseQty
+        oldOrderInventory.releaseUomValue -= newOrderInventoryReleaseUomValue
+
+        oldInventory.lockedQty -= newOrderInventoryReleaseQty
+        oldInventory.lockedUomValue -= newOrderInventoryReleaseUomValue
+
+        newInventory.lockedQty = newInventory.qty
+        newInventory.lockedUomValue = newInventory.uomValue
+      } else {
+        newOrderInventoryReleaseQty = targetInventory.releaseQty - targetInventory.pickedQty
+        newOrderInventoryReleaseUomValue =
+          newOrderInventoryReleaseQty * (targetInventory.releaseUomValue / targetInventory.releaseQty)
+
+        oldOrderInventory.releaseQty = targetInventory.pickedQty
+        oldOrderInventory.status = INVENTORY_STATUS.PICKED
+        oldOrderInventory.releaseUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * oldOrderInventory.releaseQty
+
+        oldInventory.lockedQty -= newOrderInventoryReleaseQty
+        oldInventory.lockedUomValue -= newOrderInventoryReleaseUomValue
+
+        newInventory.lockedQty = newInventory.lockedQty + (targetInventory.releaseQty - targetInventory.pickedQty)
+        newInventory.lockedUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * newInventory.lockedQty
+      }
+
+      newInventory = await this.trxMgr.getRepository(Inventory).save({ ...newInventory, updater: this.user })
+
+      let newTargetInventory = (({ id, ...targetInventory }) => targetInventory)(targetInventory)
+
+      let newOrderInventory = await this.trxMgr.getRepository(OrderInventory).save({
+        ...newTargetInventory,
+        domain: this.domain,
+        name: OrderNoGenerator.orderInventory(),
+        releaseGood,
+        releaseQty: newOrderInventoryReleaseQty,
+        releaseUomValue: newOrderInventoryReleaseUomValue,
+        pickedQty: 1,
+        product,
+        inventory: scannedPalletIdInventory,
+        creator: this.user,
+        updater: this.user
+      })
+
+      oldInventory = await this.trxMgr.getRepository(Inventory).save({ ...oldInventory, updater: this.user })
+
+      foundSerialNumber = await this.trxMgr
+        .getRepository(InventoryItem)
+        .save({ ...foundSerialNumber, inventory: newInventory })
+
+      //3. create new worksheet detail
+      let NewWorksheetDetail = (({ id, ...worksheetDetail }) => worksheetDetail)(worksheetDetail)
+      await this.trxMgr.getRepository(WorksheetDetail).save({
+        ...NewWorksheetDetail,
+        domain: this.domain,
+        name: WorksheetNoGenerator.pickingDetail(),
+        targetInventory: newOrderInventory,
+        status: WORKSHEET_STATUS.EXECUTING,
+        creator: this.user,
+        updater: this.user
+      })
+
+      //if old order inventory release quantity is 0 then delete
+      if (oldOrderInventory.releaseQty !== 0) {
+        oldOrderInventory = await this.trxMgr
+          .getRepository(OrderInventory)
+          .save({ ...oldOrderInventory, updater: this.user })
+
+        //4. update old worksheet detail
+        worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).update(
+          {
+            name: worksheetDetail.name
+          },
+          {
+            status: WORKSHEET_STATUS.DONE,
+            updater: this.user
+          }
+        )
+      } else {
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
+        await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.id)
+      }
+    } catch (e) {}
+  }
+
+  async undoSerialNumberPicking(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
+
+    if (targetInventory.releaseQty == targetInventory.pickedQty && targetInventory.status == INVENTORY_STATUS.PICKED) {
+      targetInventory.status = INVENTORY_STATUS.PICKING
+
+      await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .update({ id: worksheetDetail.id }, { status: WORKSHEET_STATUS.EXECUTING })
+
+      targetInventory.inventory.qty += targetInventory.releaseQty
+      targetInventory.inventory.uomValue =
+        Math.round((targetInventory.inventory.uomValue + targetInventory.releaseUomValue) * 100) / 100
+      targetInventory.inventory.lockedQty = targetInventory.inventory.lockedQty + targetInventory.releaseQty
+      targetInventory.inventory.lockedUomValue =
+        Math.round((targetInventory.inventory.lockedUomValue + targetInventory.releaseUomValue) * 100) / 100
+
+      await this.trxMgr.getRepository(Inventory).save(targetInventory.inventory)
+    }
+
+    let removeInventoryItem: InventoryItem = await this.trxMgr
+      .getRepository(InventoryItem)
+      .findOne({ where: { id: inventoryItemId } })
+
+    if (removeInventoryItem.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.pickedQty--
+    targetInventory.updater = this.user
+    await this.updateOrderTargets([targetInventory])
+  }
 }

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

@@ -124,6 +124,9 @@ export class ReturningWorksheetController extends VasWorksheetController {
     // update status of order inventory
     targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
     targetInventory.updater = this.user
+    targetInventory.returnToLocationQty = targetInventory.releaseQty
+    targetInventory.returnToLocationUomValue = targetInventory.releaseUomValue
+
     await this.updateOrderTargets([targetInventory])
 
     // update status of worksheet detail (EXECUTING => DONE)
@@ -189,6 +192,8 @@ export class ReturningWorksheetController extends VasWorksheetController {
 
       targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
       targetInventory.updater = this.user
+      targetInventory.returnToLocationQty = targetInventory.releaseQty
+      targetInventory.returnToLocationUomValue = targetInventory.releaseUomValue
       await this.updateOrderTargets([targetInventory])
 
       worksheetDetail.status = WORKSHEET_STATUS.DONE