@things-factory/worksheet-base 5.0.0-alpha.4 → 5.0.0-alpha.40

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,26 +446,69 @@ 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
         )
 
         pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
-        if (pickedQty > releaseQty) {
+        if (pickedQty + targetInventory.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(In([INVENTORY_STATUS.TERMINATED, INVENTORY_STATUS.PICKED]))
+          }
+        })
+
+        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 in ${releaseGood.name}`)
+          }
+
+          foundSerialNumber.status = INVENTORY_STATUS.PICKING
+          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.PICKING
+          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,17 +555,95 @@ 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)
         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,
+            status: Not(In([INVENTORY_STATUS.TERMINATED, INVENTORY_STATUS.PICKED]))
+          }
+        })
+
+        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.outboundOrderId) {
+            let releaseGood: ReleaseGood = await this.trxMgr
+              .getRepository(ReleaseGood)
+              .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
+            throw new Error(`Inventory Item is already picked in ${releaseGood.name}`)
+          }
+
+          foundSerialNumber.status = INVENTORY_STATUS.PICKING
+          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.PICKING
+          inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+          inventoryItem.outboundOrderId = releaseGood.id
+          inventoryItem.product = product
+          inventoryItem.inventory = scannedPalletIdInventory
+          inventoryItem.domain = this.domain
+
+          foundSerialNumber = await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+        }
+
+        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))
+          }
         }
       }
 
@@ -829,6 +953,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
@@ -979,6 +1125,19 @@ export class PickingWorksheetController extends VasWorksheetController {
       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.PICKED
+          itm.updater = this.user
+        })
+
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+      }
+
       if (leftQty === 0) {
         inventory.status = INVENTORY_STATUS.TERMINATED
         await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
@@ -989,4 +1148,294 @@ 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 = ORDER_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(WorksheetDetail).delete(worksheetDetail.ild)
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
+      }
+    } 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 = ORDER_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(WorksheetDetail).delete(worksheetDetail.id)
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.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
+    let releaseGood: ReleaseGood = worksheetDetail.worksheet.releaseGood
+
+    if (
+      targetInventory.releaseQty == targetInventory.pickedQty &&
+      targetInventory.status == ORDER_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 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.PICKING
+        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.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)
@@ -164,7 +167,13 @@ export class ReturningWorksheetController extends VasWorksheetController {
         where: {
           domain: this.domain,
           name: toLocationName,
-          type: In([LOCATION_TYPE.SHELF, LOCATION_TYPE.BUFFER, LOCATION_TYPE.FLOOR, LOCATION_TYPE.BIN])
+          type: In([
+            LOCATION_TYPE.SHELF,
+            LOCATION_TYPE.BUFFER,
+            LOCATION_TYPE.FLOOR,
+            LOCATION_TYPE.BIN,
+            LOCATION_TYPE.QUARANTINE
+          ])
         },
         relations: ['warehouse']
       })
@@ -189,6 +198,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