@things-factory/worksheet-base 4.3.186 → 4.3.188

package/server/controllers/replenishment/replenishment-worksheet-controller.ts

@@ -0,0 +1,632 @@
+import { In, Not, getConnection, EntityManager } from 'typeorm'
+
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderInventory,
+  Replenishment,
+  ORDER_TYPES,
+  ORDER_PRODUCT_STATUS
+} from '@things-factory/sales-base'
+
+import { generateId } from '@things-factory/id-rule-base'
+import { DateGenerator } from '../../utils'
+import { WORKSHEET_TYPE, WORKSHEET_STATUS, RULE_TYPE } from '../../constants'
+import { Worksheet, WorksheetDetail } from '../../entities'
+import { WorksheetController } from '../worksheet-controller'
+import { Product, ProductBarcode, ProductDetail } from '@things-factory/product-base'
+import {
+  Inventory,
+  LOCATION_TYPE,
+  InventoryItem,
+  INVENTORY_STATUS,
+  InventoryNoGenerator,
+  INVENTORY_ITEM_SOURCE,
+  generateInventoryHistory,
+  INVENTORY_TRANSACTION_TYPE,
+  Warehouse,
+  Location,
+  InventoryHistory
+} from '@things-factory/warehouse-base'
+
+export class ReplenishmentWorksheetController extends WorksheetController {
+  async generateReplenishmentWorksheet(replenishmentNo: string): Promise<Worksheet> {
+    let replenishment: Replenishment = await this.findRefOrder(
+      Replenishment,
+      {
+        domain: this.domain,
+        name: replenishmentNo,
+        status: ORDER_STATUS.PENDING_WORKSHEET
+      },
+      ['orderInventories', 'orderInventories.inventory', 'orderInventories.bizplace']
+    )
+    const orderInventories: OrderInventory[] = replenishment.orderInventories
+
+    let worksheet: Worksheet = await this.createWorksheet(replenishment, WORKSHEET_TYPE.PICKING_REPLENISHMENT)
+
+    if (orderInventories.every((oi: OrderInventory) => oi.inventory?.id)) {
+      worksheet.worksheetDetails = await this.createWorksheetDetails(
+        worksheet,
+        WORKSHEET_TYPE.PICKING_REPLENISHMENT,
+        orderInventories
+      )
+    }
+
+    await this.trxMgr
+      .getRepository(OrderInventory)
+      .update(
+        { id: In(orderInventories.map(oi => oi.id)) },
+        { status: ORDER_INVENTORY_STATUS.READY_TO_PICK, updater: this.user }
+      )
+
+    await this.trxMgr
+      .getRepository(Replenishment)
+      .update({ id: replenishment.id }, { status: ORDER_STATUS.READY_TO_PICK, updater: this.user })
+
+    return worksheet
+  }
+
+  async activatePickingReplenishment(worksheetNo: string): Promise<Worksheet> {
+    let worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.PICKING_REPLENISHMENT, [
+      'replenishment',
+      'worksheetDetails',
+      'worksheetDetails.targetInventory'
+    ])
+    let updater = this.user
+    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED')
+    const targetInventories: OrderInventory[] = worksheetDetails.map(wds => wds.targetInventory)
+
+    await this.trxMgr
+      .getRepository(OrderInventory)
+      .update({ id: In(targetInventories.map(itm => itm.id)) }, { status: ORDER_INVENTORY_STATUS.PICKING, updater })
+
+    let replenishment: Replenishment = worksheet.replenishment
+    await this.trxMgr
+      .getRepository(Replenishment)
+      .update({ id: replenishment.id }, { status: ORDER_STATUS.PICKING, updater })
+
+    worksheet = await this.activateWorksheet(worksheet, worksheetDetails, [])
+
+    return worksheet
+  }
+
+  async replenishmentPicking(
+    worksheetDetailName: string,
+    worksheetType: string,
+    productBarcode: string,
+    cartonId: string,
+    binLocation?: string,
+    serialNumber?: string,
+    pickedQty: number = 1
+  ): Promise<WorksheetDetail> {
+    try {
+      //find existing worksheet detail
+      let worksheetDetail: WorksheetDetail = await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .createQueryBuilder('wd')
+        .innerJoinAndSelect('wd.worksheet', 'ws')
+        .innerJoinAndSelect('wd.targetInventory', 'oi')
+        .innerJoinAndSelect('oi.replenishment', 'rp')
+        .innerJoinAndSelect('oi.inventory', 'inv')
+        .innerJoinAndSelect('oi.product', 'prd')
+        .innerJoinAndSelect('oi.productDetail', 'pd')
+        .innerJoinAndSelect('pd.productBarcodes', 'pb')
+        .where('wd.name = :name', { name: worksheetDetailName })
+        .andWhere('wd.domain_id = :domainId', { domainId: this.domain.id })
+        .andWhere('wd.type = :type', { type: worksheetType })
+        .andWhere('wd.status = :status', { status: WORKSHEET_STATUS.EXECUTING })
+        .andWhere('inv.carton_id = :cartonId', { cartonId: cartonId })
+        .getOne()
+
+      //validation to check matching worksheet detail based on name
+      if (!worksheetDetail) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName))
+
+      const replenishment: Replenishment = worksheetDetail.targetInventory.replenishment
+      let targetInventory: OrderInventory = worksheetDetail.targetInventory
+      const product: Product = targetInventory.product
+      const productDetail: ProductDetail = targetInventory.productDetail
+      const productBarcodes: [ProductBarcode] = productDetail.productBarcodes
+      let inventory: Inventory = targetInventory.inventory
+      let pickedUomValue = pickedQty * productDetail.uomValue
+      let matchingProduct
+
+      //validation to prevent duplicated picking
+      if (targetInventory?.status != ORDER_INVENTORY_STATUS.PICKING)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`))
+
+      if (!productBarcodes.find(itm => itm.gtin == productBarcode) && product?.isRequireSerialNumberScanningOutbound) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+      }
+
+      matchingProduct = await this.getDirectQty(
+        {
+          ...productDetail,
+          product: targetInventory?.product
+        },
+        productBarcode,
+        pickedQty
+      )
+
+      //validate matching product details based on scanned barcode
+      if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+
+      pickedQty = matchingProduct.qty
+      pickedUomValue = matchingProduct.uomValue
+
+      //validation to prevent over release
+      if (
+        !worksheetDetail?.targetInventory ||
+        worksheetDetail?.targetInventory.inventory.qty < 1 ||
+        pickedQty + (worksheetDetail.targetInventory?.pickedQty || 0) > worksheetDetail.targetInventory.releaseQty
+      )
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
+
+      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
+
+      // for required outbound serial number scanning
+      if (product?.isRequireSerialNumberScanningOutbound) {
+        if (!serialNumber || serialNumber == '') {
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
+        }
+
+        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 replenishment: Replenishment = await this.trxMgr
+              .getRepository(Replenishment)
+              .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
+            throw new Error(`Inventory Item is already picked in ${replenishment.name}`)
+          }
+
+          foundSerialNumber.status = INVENTORY_STATUS.PICKING
+          foundSerialNumber.updater = this.user
+          foundSerialNumber.outboundOrderId = replenishment.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 = replenishment.id
+          inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+          inventoryItem.product = product
+          inventoryItem.productDetail = productDetail
+          inventoryItem.inventory = inventory
+          inventoryItem.domain = this.domain
+
+          await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+        }
+      }
+
+      const releaseQty: number = targetInventory.releaseQty
+
+      targetInventory.pickedQty = (targetInventory?.pickedQty || 0) + pickedQty
+
+      let updateOiObj = {
+        pickedQty: () => `"picked_qty" + ${pickedQty}`,
+        updatedAt: new Date(),
+        updater: this.user,
+        pickedBy: this.user.name,
+        pickedByUser: this.user,
+        pickedAt: new Date()
+      }
+
+      if (targetInventory.pickedQty == releaseQty) {
+        updateOiObj['status'] = ORDER_INVENTORY_STATUS.PICKED
+      }
+
+      if (targetInventory.binLocation) {
+        updateOiObj['binLocation'] = targetInventory.binLocation
+      }
+
+      await this.trxMgr
+        .getRepository(OrderInventory)
+        .createQueryBuilder()
+        .update(OrderInventory)
+        .set(updateOiObj)
+        .where({ id: targetInventory.id })
+        .andWhere(`picked_qty + :pickedQty <= release_qty`, { pickedQty })
+        .execute()
+
+      if (targetInventory.pickedQty == releaseQty) {
+        //update worksheet details only when line item picking complete
+        await this.trxMgr
+          .getRepository(WorksheetDetail)
+          .createQueryBuilder()
+          .update(WorksheetDetail)
+          .set({
+            status: WORKSHEET_STATUS.DONE,
+            updater: this.user,
+            updatedAt: new Date()
+          })
+          .where('id = :id', { id: worksheetDetail.id })
+          .execute()
+
+        getConnection().transaction(async (tx: EntityManager) => {
+          let releaseUomValue = Math.round((pickedUomValue / pickedQty) * releaseQty * 100) / 100
+
+          let updateInvObj = {
+            qty: () => `"qty" - ${releaseQty}`,
+            uomValue: () => `"uom_value" - ${releaseUomValue}`,
+            updater: this.user,
+            updatedAt: new Date()
+          }
+
+          let remainingQty = await tx
+            .getRepository(Inventory)
+            .createQueryBuilder()
+            .update(Inventory)
+            .set(updateInvObj)
+            .where('id = :id', { id: targetInventory.inventory.id })
+            .returning(['qty'])
+            .execute()
+            .then(dt => {
+              return dt.raw[0].qty
+            })
+
+          await generateInventoryHistory(
+            inventory,
+            replenishment,
+            INVENTORY_TRANSACTION_TYPE.RELOCATE,
+            -releaseQty,
+            -releaseUomValue,
+            this.user,
+            tx
+          )
+
+          let inventoryItems: InventoryItem = await tx
+            .getRepository(InventoryItem)
+            .find({ where: { outboundOrderId: replenishment.id } })
+
+          if (inventoryItems.length > 0) {
+            inventoryItems.forEach((itm: InventoryItem) => {
+              itm.status = INVENTORY_STATUS.PICKED
+              itm.updater = this.user
+            })
+
+            await tx.getRepository(InventoryItem).save(inventoryItems)
+          }
+
+          if (remainingQty === 0) {
+            await tx
+              .getRepository(Inventory)
+              .createQueryBuilder()
+              .update(Inventory)
+              .set({ status: INVENTORY_STATUS.TERMINATED })
+              .where('id = :id', { id: targetInventory.inventory.id })
+              .execute()
+          }
+        })
+      }
+
+      // return worksheet details
+      worksheetDetail = await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .createQueryBuilder('wd')
+        .innerJoin('wd.targetInventory', 'oi')
+        .innerJoinAndSelect('oi.replenishment', 'rg')
+        .where('wd.id = :id', { id: worksheetDetail.id })
+        .getOne()
+
+      return worksheetDetail
+    } catch (error) {
+      throw error
+    }
+  }
+
+  private async checkAndSetBinPicking(orderInventory, binLocation) {
+    // bin picking validation
+    if (binLocation) {
+      const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+        where: { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN }
+      })
+
+      if (!foundBinLocation)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+
+      orderInventory.binLocation = foundBinLocation
+    }
+
+    return orderInventory
+  }
+
+  async completeReplenishmentPicking(replenishment: Replenishment, worksheet: Worksheet): Promise<any> {
+    await this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
+
+    let inventoryItems: InventoryItem = await this.trxMgr
+      .getRepository(InventoryItem)
+      .find({ where: { outboundOrderId: replenishment.id } })
+
+    if (inventoryItems.length > 0) {
+      inventoryItems.forEach((itm: InventoryItem) => {
+        itm.status = INVENTORY_STATUS.RELOCATE
+        itm.updater = this.user
+      })
+
+      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+    }
+
+    let orderStatus: string = ORDER_STATUS.PUTTING_AWAY
+
+    return await this.completeWorksheet(worksheet, orderStatus)
+  }
+
+  async generatePutawayReplenishmentWorksheet(replenishmentNo: string): Promise<Worksheet> {
+    let replenishment: Replenishment = await this.findRefOrder(
+      Replenishment,
+      {
+        domain: this.domain,
+        name: replenishmentNo
+      },
+      ['orderInventories', 'orderInventories.inventory']
+    )
+    let orderInventories: OrderInventory[] = replenishment.orderInventories
+
+    const existingPutawayReplenishmentWorksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: this.domain,
+        replenishment,
+        type: WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT
+      }
+    })
+
+    if (existingPutawayReplenishmentWorksheet)
+      throw new Error('There is existing putaway replenishment worksheet that has been generated')
+    let worksheet: Worksheet = await this.createWorksheet(replenishment, WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT)
+
+    if (orderInventories.every((oi: OrderInventory) => oi.inventory?.id)) {
+      worksheet.worksheetDetails = await this.createWorksheetDetails(
+        worksheet,
+        WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT,
+        orderInventories
+      )
+    }
+
+    orderInventories.forEach((oi: OrderInventory) => {
+      oi.status = ORDER_INVENTORY_STATUS.PUTTING_AWAY
+      oi.updater = this.user
+    })
+    await this.updateOrderTargets(orderInventories)
+
+    return worksheet
+  }
+
+  async replenishmentPutaway(worksheetDetailName: [string], cartonId: string, locationName: string): Promise<void> {
+    const worksheetDetails: WorksheetDetail[] = await this.findExecutableWorksheetDetailByNames(
+      worksheetDetailName,
+      WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT,
+      [
+        'worksheet',
+        'worksheet.replenishment',
+        'targetInventory',
+        'targetInventory.inventory',
+        'targetInventory.inventory.bizplace',
+        'targetInventory.inventory.product',
+        'targetInventory.inventory.productDetail'
+      ]
+    )
+
+    for (var i = 0; i < worksheetDetails.length; i++) {
+      const worksheetDetail = worksheetDetails[i]
+      const worksheet: Worksheet = worksheetDetail.worksheet
+      const replenishment: Replenishment = worksheet.replenishment
+      let targetInventory: OrderInventory = worksheetDetail.targetInventory
+      let inventory: Inventory = targetInventory.inventory
+
+      if (inventory.cartonId !== cartonId) {
+        throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('cartonId', cartonId, inventory.cartonId))
+      }
+
+      const location: Location = await this.trxMgr.getRepository(Location).findOne({
+        where: {
+          domain: this.domain,
+          name: locationName,
+          type: In([
+            LOCATION_TYPE.SHELF,
+            LOCATION_TYPE.BUFFER,
+            LOCATION_TYPE.FLOOR,
+            LOCATION_TYPE.BIN,
+            LOCATION_TYPE.QUARANTINE,
+            LOCATION_TYPE.RESERVE
+          ])
+        },
+        relations: ['warehouse']
+      })
+
+      if (!location) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName))
+      const warehouse: Warehouse = location.warehouse
+      const zone: string = location.zone
+
+      let updateInvObj = {
+        transferQty: () => `"transfer_qty" - ${targetInventory.releaseQty}`,
+        transferUomValue: () => `"transfer_uom_value" - ${targetInventory.releaseUomValue}`,
+        updater: this.user,
+        updatedAt: new Date()
+      }
+
+      await this.trxMgr
+        .getRepository(Inventory)
+        .createQueryBuilder()
+        .update(Inventory)
+        .set(updateInvObj)
+        .where('id = :id', { id: targetInventory.inventory.id })
+        .execute()
+
+      let newInventory = {
+        ...inventory,
+        palletId: await generateId({
+          domain: this.domain,
+          type: RULE_TYPE.LOT_NUMBER_ID,
+          seed: { date: DateGenerator.generateDate() }
+        }),
+        location: location,
+        status: INVENTORY_STATUS.STORED,
+        warehouse: warehouse,
+        zone: zone,
+        creator: this.user,
+        updater: this.user
+      }
+
+      delete newInventory.id
+      delete newInventory.updatedAt
+      delete newInventory.created_at
+      delete newInventory.adjustmentCode
+      delete newInventory.adjustmentNote
+
+      newInventory.cartonId = cartonId
+      newInventory.qty = targetInventory.releaseQty
+      newInventory.lockedQty = 0
+      newInventory.transferQty = 0
+      newInventory.uomValue = targetInventory.releaseUomValue
+      newInventory.lockedUomValue = 0
+      newInventory.transferUomValue = 0
+      newInventory.refOrderId = replenishment.id
+
+      await this.trxMgr.getRepository(Inventory).save(newInventory)
+
+      let inventoryItems: InventoryItem = await this.trxMgr
+        .getRepository(InventoryItem)
+        .find({ where: { outboundOrderId: replenishment.id, inventory, status: INVENTORY_STATUS.RELOCATE } })
+
+      if (inventoryItems.length > 0) {
+        inventoryItems.forEach((itm: InventoryItem) => {
+          itm.status = INVENTORY_STATUS.STORED
+          itm.source = INVENTORY_ITEM_SOURCE.RELOCATE
+          itm.updater = this.user
+          itm.inventory = newInventory
+        })
+
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+      }
+
+      await this.transactionInventory(
+        newInventory,
+        replenishment,
+        targetInventory.releaseQty,
+        targetInventory.releaseUomValue,
+        INVENTORY_TRANSACTION_TYPE.RELOCATE
+      )
+
+      targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
+      targetInventory.updater = this.user
+      await this.updateOrderTargets([targetInventory])
+
+      worksheetDetail.status = WORKSHEET_STATUS.DONE
+      worksheetDetail.updater = this.user
+      await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+    }
+  }
+
+  async undoReplenishmentPutaway(worksheetDetailName: [string], cartonId: string): Promise<void> {
+    let worksheetDetails: WorksheetDetail[] = await this.findWorksheetDetailByNames(worksheetDetailName, [
+      'worksheet',
+      'worksheet.replenishment',
+      'targetInventory',
+      'targetInventory.inventory',
+      'fromLocation'
+    ])
+
+    for (var i = 0; i < worksheetDetails?.length; i++) {
+      const worksheetDetail = worksheetDetails[i]
+      this.checkRecordValidity(worksheetDetail, { status: WORKSHEET_STATUS.DONE })
+      const worksheet: Worksheet = worksheetDetail.worksheet
+      const replenishment: Replenishment = worksheet.replenishment
+      const targetInventory: OrderInventory = worksheetDetail.targetInventory
+
+      let inventory: Inventory = await this.trxMgr.getRepository(Inventory).findOne({
+        where: { domain: this.domain, cartonId, refOrderId: replenishment.id }
+      })
+
+      let inventoryItems: InventoryItem = await this.trxMgr
+        .getRepository(InventoryItem)
+        .find({ where: { outboundOrderId: replenishment.id, inventory } })
+
+      if (inventoryItems.length > 0) {
+        inventoryItems.forEach((itm: InventoryItem) => {
+          itm.status = INVENTORY_STATUS.RELOCATE
+          itm.updater = this.user
+          itm.inventory = targetInventory.inventory
+        })
+
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+      }
+
+      let updateInvObj = {
+        transferQty: () => `"transfer_qty" + ${targetInventory.releaseQty}`,
+        transferUomValue: () => `"transfer_uom_value" + ${targetInventory.releaseUomValue}`,
+        updater: this.user,
+        updatedAt: new Date()
+      }
+
+      await this.trxMgr
+        .getRepository(Inventory)
+        .createQueryBuilder()
+        .update(Inventory)
+        .set(updateInvObj)
+        .where('id = :id', { id: targetInventory.inventory.id })
+        .execute()
+
+      await this.checkReleaseTarget(inventory)
+
+      await this.trxMgr.getRepository(InventoryHistory).delete({ inventory })
+
+      await this.trxMgr.getRepository(Inventory).delete(inventory.id)
+
+      targetInventory.status = ORDER_PRODUCT_STATUS.PUTTING_AWAY
+      targetInventory.updater = this.user
+      await this.updateOrderTargets([targetInventory])
+
+      worksheetDetail.status = WORKSHEET_STATUS.EXECUTING
+      worksheetDetail.updater = this.user
+      await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+    }
+  }
+
+  async completeReplenishmentPutaway(replenishmentNo: string): Promise<Worksheet> {
+    let replenishment: Replenishment = await this.findRefOrder(Replenishment, {
+      name: replenishmentNo,
+      status: ORDER_STATUS.PUTTING_AWAY
+    })
+
+    const putawayReplenishmentWorksheet: Worksheet = await this.findWorksheetByRefOrder(
+      replenishment,
+      WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT,
+      ['worksheetDetails', 'worksheetDetails.targetInventory']
+    )
+    return await this.completeWorksheet(putawayReplenishmentWorksheet, ORDER_STATUS.DONE)
+  }
+
+  private async checkReleaseTarget(inventory: Inventory): Promise<void> {
+    const releaseTargetInventory: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
+      where: {
+        domain: this.domain,
+        type: ORDER_TYPES.RELEASE_OF_GOODS,
+        inventory
+      }
+    })
+
+    if (releaseTargetInventory)
+      throw new Error(
+        this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('undo putaway', 'this pallet ID has been selected for releasing')
+      )
+  }
+}