@things-factory/worksheet-base 8.0.0-beta.1 → 8.0.0-beta.4

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

@@ -1,236 +0,0 @@
-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

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

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

@@ -1,402 +0,0 @@
-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
-}