@things-factory/worksheet-base 8.0.0-beta.9 → 8.0.0

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

@@ -0,0 +1,236 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-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 { deductProductAmount, temporaryGetCurrentAmount, upsertInventory } from '../common-utils'
+import {
+  FeaturedInventoryInterface,
+  OperationGuideInterface,
+  PackingUnits,
+  RefOrderType,
+  RepackagingGuide,
+  RepackedInvInfo,
+  TemporaryPalletChangesInterface
+} from '../interfaces'
+
+export async function completeRepackaging(trxMgr: EntityManager, orderVas: OrderVas, user: User): Promise<void> {
+  orderVas = await trxMgr.getRepository(OrderVas).findOne({
+    where: { id: orderVas.id },
+    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
+  const stdAmount: number = operationGuideData.stdAmount
+  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
+  )
+
+  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: TemporaryPalletChangesInterface[] = ri.repackedFrom.filter(
+      (rf: TemporaryPalletChangesInterface) => rf.toPalletId === ri.palletId
+    )
+
+    const { qty, uomValue } = temporaryGetCurrentAmount(repackedFromList, ri.palletId, packingUnit, stdAmount)
+    /* const changedInv: Inventory =  */ await upsertInventory(
+      trxMgr,
+      domain,
+      bizplace,
+      user,
+      originInv,
+      refOrder,
+      ri.palletId,
+      ri.locationName,
+      toPackingType,
+      packingUnit == PackingUnits.QTY ? qty : ri.repackedPkgQty,
+      uomValue,
+      transactionType,
+      stdAmount,
+      packingUnit
+    )
+  }
+
+  for (const rf of repackedFroms) {
+    let foundInventory: Inventory = await trxMgr.getRepository(Inventory).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: bizplace.id },
+        palletId: rf.fromPalletId
+      }
+    })
+
+    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) => {
+        //@ts-ignore
+        const featuredInvs: FeaturedInventoryInterface[] = operationGuideData.featuredInvs || []
+        const foundFeaturedInv = featuredInvs.find(
+          (inv: FeaturedInventoryInterface) => inv.palletId === pc.fromPalletId
+        )
+
+        let originalQty: number
+        let originalUomValue: number
+
+        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 getRoundedAmount(value: number, decimalPlace: number = 100): number {
+  return Math.round((value + Number.EPSILON) * decimalPlace) / decimalPlace
+}

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

@@ -0,0 +1,3 @@
+export * from './complete-repackaging'
+export * from './repackaging'
+export * from './undo-repackaging'

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

@@ -0,0 +1,402 @@
+import { EntityManager } from 'typeorm'
+
+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 { Worksheet, WorksheetDetail } from '../../../../../entities'
+import { checkPalletDuplication, checkPalletIdenticallity } from '../../../../../utils'
+import { executeVas } from '../../vas/execute-vas'
+import {
+  assignInventory,
+  getWorksheetDetailByName,
+  temporaryGetRemainInventoryAmount,
+  updateRelatedOrderVas
+} from '../common-utils'
+import {
+  FeaturedInventoryInterface,
+  OperationGuideInterface,
+  PackingUnits,
+  RefOrderType,
+  RepackagingGuide,
+  RepackedInvInfo,
+  TemporaryPalletChangesInterface
+} from '../interfaces'
+
+export const repackagingResolver = {
+  async repackaging(
+    _: any,
+    { worksheetDetailName, fromPalletId, toPalletId, locationName, packageQty },
+    context: ResolverContext
+  ) {
+    const { tx, domain, user } = context.state
+    const location: Location = await tx.getRepository(Location).findOne({
+      where: { domain: { id: domain.id }, name: locationName },
+      relations: ['warehouse']
+    })
+    if (!location) throw new Error(`Couldn't find location by its name (${locationName})`)
+    const warehouse: Warehouse = location.warehouse
+    if (!warehouse) throw new Error(`Location (name: ${locationName}) doesn't have any relation with warehouse`)
+
+    // Find target worksheet detail & target order vas & bizplace
+    const wsd: WorksheetDetail = await getWorksheetDetailByName(tx, domain, worksheetDetailName)
+    let { bizplace, targetVas }: { bizplace: Bizplace; targetVas: OrderVas } = wsd
+
+    // Check whether from pallet has valid condition compared with customer's request
+    // Batch ID, product and packing type
+    const { identicallity, errorMessage } = await checkPalletIdenticallity(
+      domain,
+      bizplace,
+      fromPalletId,
+      targetVas.targetBatchId,
+      targetVas.targetProduct,
+      targetVas.packingType,
+      tx
+    )
+    if (!identicallity) throw new Error(errorMessage)
+
+    // Check whether there's duplicated inventory in warehouse.
+    if (await checkPalletDuplication(domain, bizplace, toPalletId, tx))
+      throw new Error(`The lot ID (${toPalletId}) is duplicated.`)
+
+    // Init refOrder
+    //@ts-ignore
+    const { arrivalNotice, releaseGood, vasOrder }: { [key: string]: RefOrderType } = targetVas
+    const refOrder: RefOrderType = arrivalNotice || releaseGood || vasOrder || null
+    if (!refOrder) throw new Error(`Couldn't find reference order with current order vas`)
+
+    // Assign inventory if specific inventory isn't assigned yet.
+    // This case is occured when the VAS order comes with Arrival Notice or Release Good
+    if (!targetVas.inventory) {
+      //@ts-ignore
+      targetVas = await assignInventory(tx, domain, bizplace, user, wsd, refOrder, targetVas, fromPalletId)
+    }
+
+    let originInv: Inventory = targetVas.inventory
+
+    let operationGuide: OperationGuideInterface<RepackagingGuide> = JSON.parse(targetVas.operationGuide)
+    let operationGuideData: RepackagingGuide = operationGuide.data
+    //@ts-ignore
+    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
+
+    if (packingUnit === PackingUnits.QTY) {
+      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'
+        )
+
+        //@ts-ignore
+        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 = repackedFroms
+      const totalPackedQty: number = repackedInv.repackedFrom.reduce(
+        (qty: number, rf: TemporaryPalletChangesInterface) => (qty += rf.reducedUnitQty),
+        0
+      )
+      repackedInv.repackedPkgQty = totalPackedQty / stdAmount
+      isCompleted = operationGuideData.requiredPackageQty == 0
+    } else if (packingUnit === PackingUnits.UOM) {
+      if (featuredInvs?.length && repackagingAmount > remainUomValue) {
+        const inventoriesChanges = deductedFeaturedInventories(
+          featuredInvs,
+          repackagingAmount,
+          remainUomValue,
+          toPalletId,
+          'currentUomValue'
+        )
+
+        //@ts-ignore
+        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 = repackedFroms
+      const totalPackedUomValue: number = repackedInv.repackedFrom.reduce(
+        (qty: number, rf: TemporaryPalletChangesInterface) => (qty += rf.reducedUomValue),
+        0
+      )
+      repackedInv.repackedPkgQty = totalPackedUomValue / stdAmount
+      // repackedInv.repackedPkgQty = getRoundedAmount(totalPackedUomValue / stdAmount)
+      isCompleted = operationGuideData.requiredPackageQty == 0
+    }
+
+    // Get total required package qty to complete this VAS Task
+    const requiredPackageQty: number = await getRequiredPackageQty(
+      tx,
+      domain,
+      bizplace,
+      wsd.worksheet,
+      targetVas,
+      packingUnit,
+      stdAmount,
+      operationGuideData?.remainder || 0
+    )
+    // Get total repacked package qty until this transaction
+    const repackedPackageQty: number = getRepackedPackageQty(operationGuideData.repackedInvs)
+    const remainRequiredPackageQty: number = getRoundedAmount(requiredPackageQty - repackedPackageQty)
+
+    // 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)
+    }
+  }
+}
+
+/**
+ * @description Get total qty of repacked.
+ *
+ * @param {RepackedInvInfo[]} repackedInvs
+ */
+function getRepackedPackageQty(repackedInvs: RepackedInvInfo[]): number {
+  return repackedInvs.reduce((repackedPkgQty: number, ri: RepackedInvInfo) => (repackedPkgQty += ri.repackedPkgQty), 0)
+}
+
+/**
+ * @description Get total required package qty to complete this Repackagine VAS Task.
+ *
+ * @param {EntityManager} tx
+ * @param {Domain} domain
+ * @param {Bizplace} bizplace
+ * @param {Worksheet} worksheet
+ * @param {String} packingUnit
+ * @param {Number} stdAmount
+ */
+async function getRequiredPackageQty(
+  tx: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  worksheet: Worksheet,
+  currentOV: OrderVas,
+  packingUnit: string,
+  stdAmount: number,
+  remainder: number
+): Promise<number> {
+  const relatedWSDs: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+    where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, worksheet: { id: worksheet.id } },
+    relations: ['targetVas', 'targetVas.vas', 'targetVas.inventory']
+  })
+
+  const orderVASs: OrderVas[] = relatedWSDs.map((wsd: WorksheetDetail) => wsd.targetVas)
+  const { qty, uomValue } = orderVASs
+    .filter((ov: OrderVas) => ov.set === currentOV.set && ov.vas.id === currentOV.vas.id)
+    .reduce(
+      (total: { qty: number; uomValue: number }, ov: OrderVas) => {
+        const inventory: Inventory = ov.inventory
+        const packingSize: number = inventory.packingSize
+
+        total.qty += ov.qty * packingSize
+        total.uomValue += ov.uomValue
+
+        return total
+      },
+      { qty: 0, uomValue: 0 }
+    )
+
+  if (packingUnit === PackingUnits.QTY) {
+    return (qty - remainder) / stdAmount
+  } else if (packingUnit === PackingUnits.UOM) {
+    return Math.floor(uomValue / stdAmount)
+  }
+}
+
+/**
+ * @description Find repacked pallet which has same pallet id with passed pallet id as param
+ * If there's no repacked pallet init new RepackedInvInfo object and return it
+ *
+ * @param {RepackagingGuide} operationGuideData
+ * @param {String} palletId
+ * @param {String} locationName
+ */
+function getRepackedInv(operationGuideData: RepackagingGuide, palletId: string, locationName: string): RepackedInvInfo {
+  let repackedInv: RepackedInvInfo = operationGuideData.repackedInvs.find(
+    (ri: RepackedInvInfo) => ri.palletId === palletId
+  )
+  if (!repackedInv) {
+    repackedInv = {
+      palletId,
+      locationName,
+      repackedPkgQty: 0,
+      repackedFrom: []
+    }
+    operationGuideData.repackedInvs.push(repackedInv)
+  }
+
+  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
+}