@things-factory/worksheet-base 3.6.46 → 3.6.50

package/server/graphql/resolvers/worksheet/vas-transactions/repackaging/complete-repackaging.ts

@@ -1,32 +1,41 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { ArrivalNotice, OrderVas, ReleaseGood } from '@things-factory/sales-base'
+import { Product } from '@things-factory/product-base'
+import { OrderVas } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
-import {
-  createLoadingWorksheet,
-  createPutawayWorksheet,
-  deductProductAmount,
-  getCurrentAmount,
-  upsertInventory
-} from '../common-utils'
+
+import { deductProductAmount, temporaryGetCurrentAmount, upsertInventory } from '../common-utils'
 import {
+  FeaturedInventoryInterface,
   OperationGuideInterface,
   PackingUnits,
-  PalletChangesInterface,
   RefOrderType,
   RepackagingGuide,
-  RepackedInvInfo
+  RepackedInvInfo,
+  TemporaryPalletChangesInterface
 } from '../interfaces'
 
 export async function completeRepackaging(trxMgr: EntityManager, orderVas: OrderVas, user: User): Promise<void> {
   orderVas = await trxMgr.getRepository(OrderVas).findOne(orderVas.id, {
-    relations: ['domain', 'bizplace', 'inventory', 'inventory.product', 'arrivalNotice', 'releaseGood', 'vasOrder']
+    relations: [
+      'domain',
+      'bizplace',
+      'inventory',
+      'inventory.product',
+      'inventory.productDetail',
+      'arrivalNotice',
+      'releaseGood',
+      'vasOrder',
+      'vas'
+    ]
   })
   const domain: Domain = orderVas.domain
   const bizplace: Bizplace = orderVas.bizplace
   let originInv: Inventory = orderVas.inventory
+  let transactionType: string = INVENTORY_TRANSACTION_TYPE.REPACKAGING
   const operationGuide: OperationGuideInterface<RepackagingGuide> = JSON.parse(orderVas.operationGuide)
   const operationGuideData: RepackagingGuide = operationGuide.data
   const packingUnit: string = operationGuideData.packingUnit
@@ -34,20 +43,43 @@ export async function completeRepackaging(trxMgr: EntityManager, orderVas: Order
   const toPackingType: string = operationGuideData.toPackingType
   const { arrivalNotice, releaseGood, vasOrder } = orderVas
   const refOrder: RefOrderType = arrivalNotice || releaseGood || vasOrder
+  const repackedInvs: RepackedInvInfo[] = operationGuideData.repackedInvs
+  const repackedFroms: TemporaryPalletChangesInterface[] = extractRepackedFroms(
+    operationGuideData,
+    orderVas,
+    packingUnit
+  )
 
-  const repackedInvs: RepackedInvInfo[] = extractRepackedInvs(operationGuideData, originInv)
-  let originQty: number = 0
-  let originUomValue: number = 0
+  if (orderVas.vas && orderVas.vas.operationGuide === 'vas-repack-relabel') {
+    transactionType = INVENTORY_TRANSACTION_TYPE.REPACKAGING_RELABELING
+    const toProduct: any = operationGuideData.toProduct
+
+    // please add domain filter as well
+    const foundProduct: Product = await trxMgr.getRepository(Product).findOne({
+      where: {
+        id: toProduct.product.id,
+        sku: toProduct.product.sku,
+        name: toProduct.product.name
+      }
+    })
+
+    if (!foundProduct) {
+      throw new Error(`Cannot find product with SKU ${toProduct.product.sku}`)
+    }
+
+    originInv.product = foundProduct
+    originInv.batchId = operationGuideData.toBatchId
+    originInv.productDetail = toProduct.productDetailId
+  }
 
   // create repacked inventories based on repackedInvs
   for (const ri of repackedInvs) {
-    const repackedFromList: PalletChangesInterface[] = ri.repackedFrom.filter(
-      (rf: PalletChangesInterface) => rf.toPalletId === ri.palletId
+    const repackedFromList: TemporaryPalletChangesInterface[] = ri.repackedFrom.filter(
+      (rf: TemporaryPalletChangesInterface) => rf.toPalletId === ri.palletId
     )
-    const { qty, uomValue } = getCurrentAmount(repackedFromList, ri.palletId)
-    const repackedPkgQty: number = packingUnit === PackingUnits.QTY ? qty / stdAmount : uomValue / stdAmount
 
-    const changedInv: Inventory = await upsertInventory(
+    const { qty, uomValue } = temporaryGetCurrentAmount(repackedFromList, ri.palletId, packingUnit, stdAmount)
+    /* const changedInv: Inventory =  */ await upsertInventory(
       trxMgr,
       domain,
       bizplace,
@@ -57,49 +89,146 @@ export async function completeRepackaging(trxMgr: EntityManager, orderVas: Order
       ri.palletId,
       ri.locationName,
       toPackingType,
-      repackedPkgQty,
+      packingUnit == PackingUnits.QTY ? qty : ri.repackedPkgQty,
       uomValue,
-      INVENTORY_TRANSACTION_TYPE.REPACKAGING
+      transactionType,
+      stdAmount,
+      packingUnit
     )
+  }
+
+  for (const rf of repackedFroms) {
+    let foundInventory: Inventory = await trxMgr.getRepository(Inventory).findOne({
+      where: {
+        domain,
+        bizplace,
+        palletId: rf.fromPalletId
+      }
+    })
 
-    // accumulate qty and uomValue to update originInv in one shot
-    originQty += qty
-    originUomValue += uomValue
-
-    // Create worksheet if it's related with Arrival Notice or Release Order
-    if (refOrder instanceof ArrivalNotice) {
-      // await createPutawayWorksheet(trxMgr, domain, bizplace, refOrder, originInv, changedInv, user)
-      await createPutawayWorksheet(trxMgr, domain, bizplace, user, refOrder, originInv, changedInv)
-    } else if (refOrder instanceof ReleaseGood) {
-      // await createLoadingWorksheet(trxMgr, domain, bizplace, refOrder, originInv, changedInv, user)
-      await createLoadingWorksheet(trxMgr, domain, bizplace, user, refOrder, originInv, changedInv)
+    if (foundInventory) {
+      let reducedQty: number
+      let reducedUomValue: number
+
+      if (packingUnit == PackingUnits.QTY) {
+        reducedQty = rf.reducedUnitQty / rf.packingSize
+        reducedUomValue = rf.reducedUomValue
+      } else if (packingUnit == PackingUnits.UOM) {
+        // reducedQty will remain 0 if there is remaining uomValue
+        reducedQty = foundInventory.uomValue - rf.reducedUomValue == 0 ? 1 : 0
+        reducedUomValue = rf.reducedUomValue
+      }
+
+      foundInventory = await deductProductAmount(
+        trxMgr,
+        domain,
+        bizplace,
+        user,
+        refOrder,
+        foundInventory,
+        reducedQty,
+        getRoundedAmount(reducedUomValue, 1000),
+        transactionType,
+        rf.originalQty,
+        getRoundedAmount(rf.originalUomValue, 1000),
+        rf.currentUnitQty,
+        rf.currentUomValue
+      )
     }
   }
+}
+
+function extractRepackedFroms(
+  operationGuideData: RepackagingGuide,
+  orderVas: OrderVas,
+  packingUnit: string
+): Partial<TemporaryPalletChangesInterface[]> {
+  return (
+    operationGuideData.repackedInvs
+      .reduce((acc, ri: RepackedInvInfo) => {
+        acc = [...acc, ...ri.repackedFrom]
+        return acc
+      }, [])
+      // .flat()
+      .reduce((acc, inv) => {
+        let foundInv = acc.find(a => a.fromPalletId == inv.fromPalletId)
+        if (foundInv) {
+          if (packingUnit == PackingUnits.QTY) {
+            foundInv.reducedUnitQty += inv.reducedUnitQty
+            foundInv.reducedUomValue += inv.reducedUomValue
+          } else if (packingUnit == PackingUnits.UOM) {
+            foundInv.reducedQty += inv.reducedQty
+            foundInv.reducedUomValue += inv.reducedUomValue
+          }
+        } else {
+          if (packingUnit == PackingUnits.QTY) {
+            acc.push({
+              fromPalletId: inv.fromPalletId,
+              reducedUnitQty: inv.reducedUnitQty,
+              reducedUomValue: inv.reducedUomValue,
+              packingSize: inv.packingSize
+            })
+          } else if (packingUnit == PackingUnits.UOM) {
+            acc.push({
+              fromPalletId: inv.fromPalletId,
+              reducedQty: inv.reducedQty,
+              reducedUomValue: inv.reducedUomValue,
+              packingSize: inv.packingSize
+            })
+          }
+        }
+
+        return acc
+      }, [])
+      .map((pc: TemporaryPalletChangesInterface) => {
+        const featuredInvs: FeaturedInventoryInterface[] = operationGuideData.featuredInvs || []
+        const foundFeaturedInv = featuredInvs.find(
+          (inv: FeaturedInventoryInterface) => inv.palletId === pc.fromPalletId
+        )
+
+        let originalQty: number
+        let originalUomValue: number
 
-  // Deduct amount of product on original pallet or order inventory (Case for release order)
-  originInv = await deductProductAmount(
-    trxMgr,
-    domain,
-    bizplace,
-    user,
-    refOrder,
-    originInv,
-    originQty,
-    originUomValue,
-    INVENTORY_TRANSACTION_TYPE.REPACKAGING
+        if (foundFeaturedInv) {
+          originalQty = foundFeaturedInv.originalQty
+          originalUomValue = foundFeaturedInv.originalUomValue
+
+          if (packingUnit == PackingUnits.QTY) {
+            pc.currentUnitQty = foundFeaturedInv.currentUnitQty
+          } else if (packingUnit == PackingUnits.UOM) {
+            pc.currentUomValue = foundFeaturedInv.currentUomValue
+          }
+        } else {
+          originalQty =
+            packingUnit == PackingUnits.UOM
+              ? orderVas.qty
+              : orderVas.qty -
+                featuredInvs.reduce((qty: number, inv: FeaturedInventoryInterface) => {
+                  return qty + inv.originalQty
+                }, 0)
+
+          originalUomValue =
+            orderVas.uomValue -
+            featuredInvs.reduce((uomValue: number, inv: FeaturedInventoryInterface) => {
+              return uomValue + inv.originalUomValue
+            }, 0)
+
+          if (packingUnit == PackingUnits.QTY) {
+            pc.currentUnitQty = originalQty - pc.reducedUnitQty / pc.packingSize
+          } else if (packingUnit == PackingUnits.UOM) {
+            pc.currentUomValue = getRoundedAmount(originalUomValue - pc.reducedUomValue)
+          }
+        }
+
+        return {
+          ...pc,
+          originalQty,
+          originalUomValue
+        }
+      })
   )
 }
 
-function extractRepackedInvs(operationGuideData: RepackagingGuide, originInv: Inventory): RepackedInvInfo[] {
-  return operationGuideData.repackedInvs
-    .filter((ri: RepackedInvInfo) => {
-      const isPalletIncluded: boolean = Boolean(
-        ri.repackedFrom.find((rf: PalletChangesInterface) => rf.fromPalletId === originInv.palletId)
-      )
-      if (isPalletIncluded) return ri
-    })
-    .map((ri: RepackedInvInfo) => {
-      ri.repackedFrom = ri.repackedFrom.filter((rf: PalletChangesInterface) => rf.fromPalletId === originInv.palletId)
-      return ri
-    })
+function getRoundedAmount(value: number, decimalPlace: number = 100): number {
+  return Math.round((value + Number.EPSILON) * decimalPlace) / decimalPlace
 }

package/server/graphql/resolvers/worksheet/vas-transactions/repackaging/repackaging.ts

@@ -1,25 +1,28 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { OrderVas } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location, Warehouse } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
+
 import { Worksheet, WorksheetDetail } from '../../../../../entities'
 import { checkPalletDuplication, checkPalletIdenticallity } from '../../../../../utils'
 import { executeVas } from '../../vas/execute-vas'
 import {
   assignInventory,
-  getRemainInventoryAmount,
   getWorksheetDetailByName,
+  temporaryGetRemainInventoryAmount,
   updateRelatedOrderVas
 } from '../common-utils'
 import {
+  FeaturedInventoryInterface,
   OperationGuideInterface,
   PackingUnits,
-  PalletChangesInterface,
   RefOrderType,
   RepackagingGuide,
-  RepackedInvInfo
+  RepackedInvInfo,
+  TemporaryPalletChangesInterface
 } from '../interfaces'
 
 export const repackagingResolver = {
@@ -52,7 +55,7 @@ export const repackagingResolver = {
 
     // Check whether there's duplicated inventory in warehouse.
     if (await checkPalletDuplication(domain, bizplace, toPalletId, tx))
-      throw new Error(`The Pallet ID (${toPalletId}) is duplicated.`)
+      throw new Error(`The lot ID (${toPalletId}) is duplicated.`)
 
     // Init refOrder
     const { arrivalNotice, releaseGood, vasOrder }: { [key: string]: RefOrderType } = targetVas
@@ -69,65 +72,142 @@ export const repackagingResolver = {
 
     let operationGuide: OperationGuideInterface<RepackagingGuide> = JSON.parse(targetVas.operationGuide)
     let operationGuideData: RepackagingGuide = operationGuide.data
-    if (!operationGuideData.repackedInvs) operationGuideData.repackedInvs = []
-    // const palletChanges: PalletChangesInterface[] = operationGuideData.repackedInvs
-    //   .map((ri: RepackedInvInfo) => ri.repackedFrom)
-    //   .flat()
-
-    const palletChanges: PalletChangesInterface[] = []
-
-    const { remainQty, remainUomValue } = await getRemainInventoryAmount(
-      tx,
-      refOrder,
-      domain,
-      bizplace,
-      originInv,
-      palletChanges,
-      fromPalletId
-    )
-    const unitUomValue: number = remainUomValue / remainQty
+    let featuredInvs: FeaturedInventoryInterface[] = operationGuideData.featuredInvs
     const packingUnit: string = operationGuideData.packingUnit
     const stdAmount: number = operationGuideData.stdAmount
+
+    let repackedInvs: RepackedInvInfo[] = operationGuideData.repackedInvs
+
+    if (repackedInvs?.length && repackedInvs.some((inv: RepackedInvInfo) => inv.palletId == toPalletId))
+      throw new Error(`Unable to repack into the same lot ID ${toPalletId}`)
+
+    let palletChanges: TemporaryPalletChangesInterface[] = []
+
+    if (repackedInvs && repackedInvs.length) {
+      palletChanges = repackedInvs.reduce((acc, ri: RepackedInvInfo) => {
+        acc = [...acc, ...ri.repackedFrom]
+        return acc
+      }, [])
+      // .map((ri: RepackedInvInfo) => ri.repackedFrom).flat()
+    } else if (!repackedInvs) {
+      operationGuideData.repackedInvs = []
+    }
+
+    // get remainUnitQty of originInv (from previous repackaging actions)
+    let remainOriginInv: { remainUomValue: number; remainUnitQty: number } = {
+      remainUomValue: 0,
+      remainUnitQty: 0
+    }
+    let remainUomValue: number = 0
+    let remainUnitQty: number = 0
+
+    try {
+      remainOriginInv = await temporaryGetRemainInventoryAmount(
+        tx,
+        refOrder,
+        domain,
+        bizplace,
+        originInv,
+        palletChanges,
+        fromPalletId
+      )
+
+      remainUomValue = remainOriginInv.remainUomValue
+      remainUnitQty = remainOriginInv.remainUnitQty
+    } catch (err) {}
+
+    let repackedFroms: TemporaryPalletChangesInterface[] = []
     let repackedInv: RepackedInvInfo = getRepackedInv(operationGuideData, toPalletId, locationName)
+    let isCompleted: boolean = false
+    const repackagingAmount: number = stdAmount * packageQty
 
-    let isCompleted: boolean = false // Flag for calling executeVas function to change status of worksheet detail
     if (packingUnit === PackingUnits.QTY) {
-      const packingSize: number = originInv.packingSize
-      const reducedQty: number =
-        remainQty >= (stdAmount * packageQty) / packingSize ? (stdAmount * packageQty) / packingSize : remainQty
-      const repackedFrom: PalletChangesInterface = {
-        fromPalletId,
-        toPalletId,
-        reducedQty,
-        reducedUomValue: reducedQty * unitUomValue
+      const singleUnitUomValue: number = originInv.uomValue / (originInv.qty * originInv.packingSize)
+      // const singleUnitUomValue: number = getRoundedAmount(
+      //   originInv.uomValue / (originInv.qty * originInv.packingSize),
+      //   10000
+      // )
+
+      if (featuredInvs?.length && repackagingAmount > remainUnitQty) {
+        const inventoriesChanges = deductedFeaturedInventories(
+          featuredInvs,
+          repackagingAmount,
+          remainUnitQty,
+          toPalletId,
+          'currentUnitQty'
+        )
+
+        operationGuideData.featuredInvs = inventoriesChanges.featuredInvs
+        repackedFroms = [...repackedFroms, ...inventoriesChanges.repackedFroms]
+
+        if (remainUnitQty > 0) {
+          repackedFroms.push({
+            fromPalletId,
+            toPalletId,
+            reducedUnitQty: remainUnitQty,
+            reducedUomValue: remainUnitQty * singleUnitUomValue,
+            packingSize: originInv.packingSize
+          })
+        }
+      } else if (remainUnitQty >= repackagingAmount) {
+        repackedFroms.push({
+          fromPalletId,
+          toPalletId,
+          reducedUnitQty: repackagingAmount,
+          reducedUomValue: repackagingAmount * singleUnitUomValue,
+          packingSize: originInv.packingSize
+        })
       }
 
-      repackedInv.repackedFrom.push(repackedFrom)
+      repackedInv.repackedFrom = repackedFroms
       const totalPackedQty: number = repackedInv.repackedFrom.reduce(
-        (qty: number, rf: PalletChangesInterface) => (qty += rf.reducedQty),
+        (qty: number, rf: TemporaryPalletChangesInterface) => (qty += rf.reducedUnitQty),
         0
       )
-      repackedInv.repackedPkgQty = (totalPackedQty * packingSize) / stdAmount
-      isCompleted = remainQty <= stdAmount * packageQty
+      repackedInv.repackedPkgQty = totalPackedQty / stdAmount
+      isCompleted = operationGuideData.requiredPackageQty == 0
     } else if (packingUnit === PackingUnits.UOM) {
-      // Case 1. When batchProcess is true => Reduce as much as remainUomValue to complete this repackaging task
-      // Case 2. When from pallet has more products than std amount => Reduce as much as stdAmount
-      // Case 3. When from pallet has less products than std amount => Reduce as much as remainUomValue
-      const reducedUomValue: number = remainUomValue >= stdAmount * packageQty ? stdAmount * packageQty : remainUomValue
-      const repackedFrom: PalletChangesInterface = {
-        fromPalletId,
-        toPalletId,
-        reducedUomValue,
-        reducedQty: reducedUomValue / unitUomValue
+      if (featuredInvs?.length && repackagingAmount > remainUomValue) {
+        const inventoriesChanges = deductedFeaturedInventories(
+          featuredInvs,
+          repackagingAmount,
+          remainUomValue,
+          toPalletId,
+          'currentUomValue'
+        )
+
+        operationGuideData.featuredInvs = inventoriesChanges.featuredInvs
+        repackedFroms = [...repackedFroms, ...inventoriesChanges.repackedFroms]
+
+        if (remainUomValue > 0) {
+          repackedFroms.push({
+            fromPalletId,
+            toPalletId,
+            reducedQty: 0,
+            reducedUomValue: remainUomValue,
+            // reducedUomValue: getRoundedAmount(remainUomValue),
+            packingSize: originInv.packingSize
+          })
+        }
+      } else if (remainUomValue >= repackagingAmount) {
+        repackedFroms.push({
+          fromPalletId,
+          toPalletId,
+          reducedQty: 0,
+          reducedUomValue: repackagingAmount,
+          // reducedUomValue: getRoundedAmount(repackagingAmount),
+          packingSize: originInv.packingSize
+        })
       }
 
-      repackedInv.repackedFrom.push(repackedFrom)
+      repackedInv.repackedFrom = repackedFroms
       const totalPackedUomValue: number = repackedInv.repackedFrom.reduce(
-        (uomValue: number, rf: PalletChangesInterface) => (uomValue += rf.reducedUomValue),
+        (qty: number, rf: TemporaryPalletChangesInterface) => (qty += rf.reducedUomValue),
         0
       )
       repackedInv.repackedPkgQty = totalPackedUomValue / stdAmount
-      isCompleted = remainUomValue <= stdAmount * packageQty
+      // repackedInv.repackedPkgQty = getRoundedAmount(totalPackedUomValue / stdAmount)
+      isCompleted = operationGuideData.requiredPackageQty == 0
     }
 
     // Get total required package qty to complete this VAS Task
@@ -138,18 +218,24 @@ export const repackagingResolver = {
       wsd.worksheet,
       targetVas,
       packingUnit,
-      stdAmount
+      stdAmount,
+      operationGuideData?.remainder || 0
     )
     // Get total repacked package qty until this transaction
     const repackedPackageQty: number = getRepackedPackageQty(operationGuideData.repackedInvs)
-    const remainRequiredPackageQty: number = requiredPackageQty - repackedPackageQty
+    const remainRequiredPackageQty: number = getRoundedAmount(requiredPackageQty - repackedPackageQty)
 
-    operationGuide.data.requiredPackageQty = remainRequiredPackageQty
-    operationGuide.data.repackedInvs = operationGuideData.repackedInvs
+    // const requiredPackageQty: number = operationGuideData.requiredPackageQty - repackedPackageQty
+
+    operationGuide.data = {
+      ...operationGuideData,
+      requiredPackageQty: remainRequiredPackageQty
+    }
 
     // Update every order vas to share same operation guide
     await updateRelatedOrderVas<RepackagingGuide>(tx, domain, bizplace, wsd, targetVas, operationGuide, user)
 
+    // #########################  KIV DULU YANG NI  #########################
     if (isCompleted || remainRequiredPackageQty === 0) {
       await executeVas(tx, domain, user, wsd)
     }
@@ -182,7 +268,8 @@ async function getRequiredPackageQty(
   worksheet: Worksheet,
   currentOV: OrderVas,
   packingUnit: string,
-  stdAmount: number
+  stdAmount: number,
+  remainder: number
 ): Promise<number> {
   const relatedWSDs: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
     where: { domain, bizplace, worksheet },
@@ -206,9 +293,9 @@ async function getRequiredPackageQty(
     )
 
   if (packingUnit === PackingUnits.QTY) {
-    return qty / stdAmount
+    return (qty - remainder) / stdAmount
   } else if (packingUnit === PackingUnits.UOM) {
-    return uomValue / stdAmount
+    return Math.floor(uomValue / stdAmount)
   }
 }
 
@@ -236,3 +323,72 @@ function getRepackedInv(operationGuideData: RepackagingGuide, palletId: string,
 
   return repackedInv
 }
+
+/**
+ * @description To transfer qty or uom value from featured inventories into origin inventory
+ * If and only if the origin inventory has insufficient amount
+ *
+ * @param {FeaturedInventoryInterface} featuredInvs
+ * @param {Number} repackagingAmount
+ * @param {Number} remainingAmount
+ * @param {String} packingUnit -- value is strictly for qty / uomValue
+ */
+function deductedFeaturedInventories(
+  featuredInvs: FeaturedInventoryInterface[],
+  repackagingAmount: number,
+  remainingAmount: number,
+  toPalletId: string,
+  packingUnit: string
+): { featuredInvs: FeaturedInventoryInterface[]; repackedFroms: TemporaryPalletChangesInterface[] } {
+  let requiredAmount: number = getRoundedAmount(repackagingAmount - remainingAmount)
+  const repackedFroms: TemporaryPalletChangesInterface[] = []
+
+  featuredInvs = featuredInvs.map(inv => {
+    if (requiredAmount > 0 && inv[packingUnit] > 0) {
+      let reducedAmount: number = requiredAmount
+
+      if (inv[packingUnit] >= requiredAmount) {
+        inv[packingUnit] = inv[packingUnit] - requiredAmount
+        // inv[packingUnit] = getRoundedAmount(inv[packingUnit] - requiredAmount)
+        requiredAmount = 0
+      } else {
+        requiredAmount = requiredAmount - inv[packingUnit]
+        // requiredAmount = getRoundedAmount(requiredAmount - inv[packingUnit])
+        reducedAmount = inv[packingUnit]
+        inv[packingUnit] = 0
+      }
+
+      switch (packingUnit) {
+        case 'currentUnitQty':
+          repackedFroms.push({
+            fromPalletId: inv.palletId,
+            toPalletId,
+            reducedUnitQty: reducedAmount,
+            reducedUomValue: reducedAmount * inv.uomValuePerQty,
+            // reducedUomValue: getRoundedAmount(reducedAmount * inv.uomValuePerQty),
+            packingSize: featuredInvs.find(inv => inv.palletId == inv.palletId).packingSize
+          })
+          break
+
+        case 'currentUomValue':
+          repackedFroms.push({
+            fromPalletId: inv.palletId,
+            toPalletId,
+            reducedQty: 0,
+            reducedUomValue: reducedAmount,
+            // reducedUomValue: getRoundedAmount(reducedAmount),
+            packingSize: featuredInvs.find(inv => inv.palletId == inv.palletId).packingSize
+          })
+          break
+      }
+    }
+
+    return inv
+  })
+
+  return { featuredInvs, repackedFroms }
+}
+
+function getRoundedAmount(value, decimalPlace = 100) {
+  return Math.round((value + Number.EPSILON) * decimalPlace) / decimalPlace
+}