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

package/server/graphql/resolvers/worksheet/vas-transactions/common-utils.ts

@@ -0,0 +1,1182 @@
+import { EntityManager, Equal, In, IsNull, Not } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import {
+  ArrivalNotice,
+  ORDER_INVENTORY_STATUS,
+  ORDER_TYPES,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderVas,
+  ReleaseGood
+} from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import {
+  Inventory,
+  INVENTORY_STATUS,
+  INVENTORY_TRANSACTION_TYPE,
+  InventoryNoGenerator,
+  Location,
+  Pallet,
+  Warehouse
+} from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../../entities'
+import { generateInventoryHistory, WorksheetNoGenerator } from '../../../../utils'
+import {
+  OperationGuideInterface,
+  PackingUnits,
+  PalletChangesInterface,
+  RefOrderType,
+  TemporaryPalletChangesInterface
+} from './interfaces'
+
+/**
+ * @description Find worksheet detail by name
+ * this function will include every relations with worksheet detail for processing VAS
+ *
+ * @param {EntityManager} trxMgr
+ * @param {Domain} domain
+ * @param {String} name
+ */
+export async function getWorksheetDetailByName(
+  trxMgr: EntityManager,
+  domain: Domain,
+  name: string
+): Promise<WorksheetDetail> {
+  const worksheetDetail: WorksheetDetail = await trxMgr.getRepository(WorksheetDetail).findOne({
+    where: { domain: { id: domain.id }, name },
+    relations: [
+      'bizplace',
+      'targetVas',
+      'targetVas.inventory',
+      'targetVas.inventory.product',
+      'targetVas.vas',
+      'targetVas.arrivalNotice',
+      'targetVas.releaseGood',
+      'targetVas.shippingOrder',
+      'targetVas.vasOrder',
+      'targetVas.targetProduct',
+      'worksheet'
+    ]
+  })
+  if (!worksheetDetail) throw new Error(`Couldn't find target worksheet detail`)
+  if (!worksheetDetail.targetVas)
+    throw new Error(`Couldn't find any related target vas, using current worksheet detail`)
+  return worksheetDetail
+}
+
+/**
+ * @description Update every related order vas to share same operationGuide data
+ *
+ * @param {EntityManager} trxMgr
+ * @param {Domain} domain
+ * @param {Bizplace} bizplace
+ * @param {WorksheetDetail} wsd
+ * @param {OrderVas} targetVas
+ * @param {OperationGuideInterface<T>} operationGuide
+ * @param {User} user
+ */
+export async function updateRelatedOrderVas<T>(
+  trxMgr: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  wsd: WorksheetDetail,
+  targetVas: OrderVas,
+  operationGuide: OperationGuideInterface<T>,
+  user: User
+  //@ts-ignore
+): Promise<OrderVas> {
+  const worksheet: Worksheet = wsd.worksheet
+  const relatedWSDs: WorksheetDetail[] = await trxMgr.getRepository(WorksheetDetail).find({
+    where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, worksheet: { id: worksheet.id } },
+    relations: ['targetVas', 'targetVas.vas']
+  })
+
+  const relatedOVs: OrderVas[] = relatedWSDs
+    .map((wsd: WorksheetDetail) => wsd.targetVas)
+    .filter((ov: OrderVas) => ov.set === targetVas.set && ov.vas.id === targetVas.vas.id)
+    .map((ov: OrderVas) => {
+      return {
+        ...ov,
+        operationGuide: JSON.stringify(operationGuide),
+        updater: user
+      }
+    })
+
+  await trxMgr.getRepository(OrderVas).save(relatedOVs)
+}
+
+/**
+ * @description Return current amount of pallet
+ * @param {PalletChangesInterface[]} palletChanges
+ * @param {String} palletId
+ */
+export function getCurrentAmount(
+  palletChanges: PalletChangesInterface[],
+  palletId: string
+): { qty: number; uomValue: number } {
+  return palletChanges
+    .filter((pc: PalletChangesInterface) => pc.toPalletId === palletId)
+    .reduce(
+      (currentAmount: { qty: number; uomValue: number }, pc: PalletChangesInterface) => {
+        return {
+          qty: currentAmount.qty + pc.reducedQty,
+          uomValue: currentAmount.uomValue + pc.reducedUomValue
+        }
+      },
+      { qty: 0, uomValue: 0 }
+    )
+}
+
+/**
+ * @description Return reduced amount of pallet
+ * @param {PalletChangesInterface[]} palletChanges
+ * @param {String} palletId
+ */
+export function getReducedAmount(
+  palletChanges: PalletChangesInterface[],
+  palletId: string
+): { reducedQty: number; reducedUomValue: number } {
+  return palletChanges
+    .filter((pc: PalletChangesInterface) => pc.fromPalletId === palletId)
+    .reduce(
+      (reducedAmount: { reducedQty: number; reducedUomValue: number }, pc: PalletChangesInterface) => {
+        return {
+          reducedQty: reducedAmount.reducedQty + pc.reducedQty || 0,
+          reducedUomValue: reducedAmount.reducedUomValue + pc.reducedUomValue || 0
+        }
+      },
+      { reducedQty: 0, reducedUomValue: 0 }
+    )
+}
+
+/**
+ * @description Get remain qty of inventory or order inventory (For release good case)
+ *
+ * @param {EntityManager} trxMgr
+ * @param {ArrivalNotice | ReleaseGood | VasOrder} refOrder
+ * @param {Domain} domain
+ * @param {Bizplace} bizplace
+ * @param {Inventory} originInv
+ * @param {RepackedInvInfo[]} repackedInvs
+ * @param {String} palletId
+ */
+export async function getRemainInventoryAmount(
+  trxMgr: EntityManager,
+  refOrder: RefOrderType,
+  domain: Domain,
+  bizplace: Bizplace,
+  originInv: Inventory,
+  palletChanges: PalletChangesInterface[],
+  palletId: string
+): Promise<{ remainQty: number; remainUomValue: number }> {
+  let remainQty: number = 0
+  let remainUomValue: number = 0
+  const { reducedQty, reducedUomValue } = getReducedAmount(palletChanges, palletId)
+  if (refOrder instanceof ReleaseGood) {
+    // Find loading order inventory to figure out uomValue
+    const orderInv: OrderInventory = await trxMgr.getRepository(OrderInventory).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: bizplace.id },
+        inventory: { id: originInv.id },
+        releaseGood: { id: refOrder.id },
+        type: ORDER_TYPES.RELEASE_OF_GOODS
+      }
+    })
+
+    remainQty = orderInv.releaseQty - reducedQty
+    remainUomValue = orderInv.releaseUomValue - reducedUomValue
+  } else {
+    remainQty = originInv.qty - reducedQty
+    remainUomValue = originInv.uomValue - reducedUomValue
+  }
+
+  if (remainQty <= 0 || remainUomValue <= 0) throw new Error(`There's no more remaining product on the pallet`)
+  return { remainQty, remainUomValue }
+}
+
+/** REMARK
+ * @farishelmi created temporary function @temporaryGetReducedAmount and
+ * @temporaryGetRemainInventoryAmount specifically for @Repackaging
+ * - because in repackaging we need to calculate based on unit qty of a product
+ * - eg: Carton of 12 Cokes repack into Boxes of 6 Cokes
+ * - this function should be merged with its origin once the logic in other vas is updated
+ * */
+
+export function temporaryGetCurrentAmount(
+  palletChanges: TemporaryPalletChangesInterface[],
+  palletId: string,
+  packingUnit: string,
+  stdAmount: number
+): { qty: number; uomValue: number } {
+  return palletChanges
+    .filter((pc: TemporaryPalletChangesInterface) => pc.toPalletId === palletId)
+    .reduce(
+      (currentAmount: { qty: number; uomValue: number }, pc: TemporaryPalletChangesInterface) => {
+        if (packingUnit == PackingUnits.QTY) {
+          return {
+            qty: currentAmount.qty + pc.reducedUnitQty / stdAmount,
+            uomValue: currentAmount.uomValue + pc.reducedUomValue
+          }
+        } else if (packingUnit == PackingUnits.UOM) {
+          return {
+            qty: currentAmount.qty + pc.reducedQty,
+            uomValue: currentAmount.uomValue + pc.reducedUomValue
+          }
+        } else {
+          return { qty: 0, uomValue: 0 }
+        }
+      },
+      { qty: 0, uomValue: 0 }
+    )
+}
+
+/**
+ * @description need to consider unit amount because we have packingSize for each packingType
+ * @param palletChanges
+ * @param palletId
+ * @returns reducedUomValue: used for packingUnit == UOM
+ * @returns reducedUnitQty: used for packingUnit == QTY
+ */
+export function temporaryGetReducedAmount(
+  palletChanges: TemporaryPalletChangesInterface[],
+  palletId: string
+): { reducedUomValue: number; reducedUnitQty: number } {
+  return palletChanges
+    .filter((pc: TemporaryPalletChangesInterface) => pc.fromPalletId === palletId)
+    .reduce(
+      (
+        reducedAmount: {
+          reducedUomValue: number
+          reducedUnitQty: number
+        },
+        pc: TemporaryPalletChangesInterface
+      ) => {
+        return {
+          reducedUomValue: reducedAmount.reducedUomValue + pc.reducedUomValue || 0,
+          reducedUnitQty: reducedAmount.reducedUnitQty + pc.reducedUnitQty || 0
+        }
+      },
+      { reducedUomValue: 0, reducedUnitQty: 0 }
+    )
+}
+
+export async function temporaryGetRemainInventoryAmount(
+  trxMgr: EntityManager,
+  refOrder: RefOrderType,
+  domain: Domain,
+  bizplace: Bizplace,
+  originInv: Inventory,
+  palletChanges: TemporaryPalletChangesInterface[],
+  palletId: string
+): Promise<{ remainUomValue: number; remainUnitQty: number }> {
+  let remainUomValue: number = 0
+  let remainUnitQty: number = 0
+
+  const packingSize: number = originInv.packingSize
+  const { reducedUomValue, reducedUnitQty } = temporaryGetReducedAmount(palletChanges, palletId)
+  if (refOrder instanceof ReleaseGood) {
+    // Find loading order inventory to figure out uomValue
+    const orderInv: OrderInventory = await trxMgr.getRepository(OrderInventory).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: bizplace.id },
+        inventory: { id: originInv.id },
+        releaseGood: { id: refOrder.id },
+        type: ORDER_TYPES.RELEASE_OF_GOODS
+      }
+    })
+
+    remainUomValue = orderInv.releaseUomValue - reducedUomValue
+    remainUnitQty = orderInv.releaseQty * packingSize - reducedUnitQty
+  } else {
+    remainUomValue = originInv.uomValue - reducedUomValue
+    remainUnitQty = originInv.qty * packingSize - reducedUnitQty
+  }
+
+  if (remainUomValue <= 0 || remainUnitQty <= 0) throw new Error(`There's no more remaining product on the pallet`)
+  return { remainUomValue, remainUnitQty }
+}
+
+export async function updateOriginInventories(
+  trxMgr: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  user: User,
+  refOrder: RefOrderType,
+  repackedFroms: Partial<TemporaryPalletChangesInterface[]>,
+  packingUnit: string,
+  transactionType: string
+): Promise<Inventory[]> {
+  const inventories: Inventory[] = []
+
+  for (let inv of repackedFroms) {
+    let foundInventory: Inventory = await trxMgr.getRepository(Inventory).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: bizplace.id },
+        palletId: inv.fromPalletId,
+        status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+      }
+    })
+
+    if (foundInventory) {
+      let repackedPkgQty: number = 0
+      let repackedPkgUomValue: number = 0
+
+      switch (packingUnit) {
+        case PackingUnits.QTY:
+          repackedPkgQty = inv.reducedUnitQty / inv.packingSize
+          repackedPkgUomValue = inv.reducedUomValue // it should be called reducedUomValue instead. sbb dh kira smua dgn packingsize
+          break
+
+        case PackingUnits.UOM:
+          // repackedPkgQty = inv.reducedQty / inv.packingSize
+          // repackedPkgUomValue = rf.reducedUomValue
+          break
+      }
+
+      foundInventory = await trxMgr.getRepository(Inventory).save({
+        ...foundInventory,
+        qty: repackedPkgQty,
+        uomValue: repackedPkgUomValue,
+        creator: user,
+        updater: user
+      })
+
+      await generateInventoryHistory(
+        foundInventory,
+        refOrder,
+        transactionType,
+        repackedPkgQty,
+        repackedPkgUomValue,
+        user,
+        trxMgr
+      )
+
+      inventories.push(foundInventory)
+    } else {
+      throw new Error(`${inv.fromPalletId} is not exist in inventory. Hence, qty cannot be updated.`)
+    }
+  }
+
+  return inventories
+}
+
+//// @farishelmi What is the difference between upsertInventory vs temporaryUpsertInventory? If it is repeated function, kindly remove one of them.
+export async function temporaryUpsertInventory(
+  trxMgr: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  user: User,
+  originInv: Inventory,
+  refOrder: RefOrderType,
+  palletId: string,
+  locationName: string,
+  packingType: string,
+  addedQty: number,
+  addedUomValue: number,
+  transactionType: string,
+  stdAmount?: number,
+  packingUnit?: string
+): Promise<Inventory> {
+  const location: Location = await trxMgr.getRepository(Location).findOne({
+    where: { domain: { id: domain.id }, name: locationName },
+    relations: ['warehouse']
+  })
+  if (!location) throw new Error(`Location is not found by (${locationName})`)
+  const warehouse: Warehouse = location.warehouse
+  const zone: string = location.zone
+
+  let inv: Inventory = await trxMgr.getRepository(Inventory).findOne({
+    where: {
+      domain: { id: domain.id },
+      bizplace: { id: bizplace.id },
+      palletId,
+      batchId: originInv.batchId,
+      product: { id: originInv.product.id },
+      packingType,
+      packingSize: stdAmount,
+      refOrderId: originInv.refOrderId,
+      status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+    },
+    relations: ['product', 'refInventory']
+  })
+
+  // Create new inventory
+  if (!inv) {
+    let newInventory: Inventory = new Inventory()
+
+    inv = {
+      ...newInventory,
+      domain,
+      bizplace,
+      palletId,
+      name: InventoryNoGenerator.inventoryName(),
+      packingType,
+      qty: addedQty,
+      //@ts-ignore
+      weight: 0,
+      uomValue: addedUomValue,
+      lockedQty: 0,
+      lockedUomValue: 0,
+      packingSize: packingUnit == PackingUnits.QTY ? stdAmount : 1,
+      warehouse,
+      location,
+      zone,
+      creator: user,
+      updater: user
+    }
+
+    // Save changed inventory
+    inv = await trxMgr.getRepository(Inventory).save(inv)
+
+    // Check whether the pallet is resuable or not
+    const pallet: Pallet = await trxMgr.getRepository(Pallet).findOne({
+      where: { domain: { id: domain.id }, name: palletId, inventory: IsNull() }
+    })
+    // If it's exists => it's reusable pallet and need to update it's inventory field
+    if (pallet) {
+      pallet.inventory = inv
+      pallet.updater = user
+      await trxMgr.getRepository(Pallet).save(pallet)
+    }
+  } else {
+    // Update inventory
+    inv.qty += addedQty
+    inv.uomValue += addedUomValue
+    inv.warehouse = warehouse
+    inv.location = location
+    inv.zone = location.zone
+    inv.updater = user
+
+    // Save changed inventory
+    inv = await trxMgr.getRepository(Inventory).save(inv)
+  }
+
+  // Create inventory history
+  await generateInventoryHistory(inv, refOrder, transactionType, addedQty, addedUomValue, user, trxMgr)
+
+  return inv
+}
+
+//// @farishelmi What is the difference between deductProductAmount vs temporaryDeductProductAmount? If it is repeated function, kindly remove one of them.
+export async function temporaryDeductProductAmount(
+  trxMgr: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  user: User,
+  refOrder: RefOrderType,
+  originInv: Inventory,
+  reducedQty: number,
+  reducedUomValue: number,
+  transactionType: string,
+  originalQty?: number,
+  originalUomValue?: number,
+  currentUnitQty?: number,
+  currentUomValue?: number
+) {
+  if (refOrder instanceof ReleaseGood) {
+    const loadingWS: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: bizplace.id },
+        releaseGood: refOrder,
+        type: WORKSHEET_TYPE.LOADING
+      },
+      relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
+    })
+
+    if (!loadingWS)
+      throw new Error(
+        `Picking process is not finished yet. Please complete picking first before complete Repalletizing`
+      )
+
+    let orderInv: OrderInventory = loadingWS.worksheetDetails
+      .map((wsd: WorksheetDetail) => wsd.targetInventory)
+      .find((oi: OrderInventory) => oi.inventory.id === originInv.id)
+    if (!orderInv) {
+      throw new Error(`Failed to find order inventory (Pallet ID: ${originInv.palletId})`)
+    }
+
+    orderInv.releaseQty -= reducedQty
+    orderInv.releaseUomValue -= reducedUomValue
+    orderInv.updater = user
+
+    await trxMgr.getRepository(OrderInventory).save(orderInv)
+  } else {
+    // currentUnitQty > 0 only belongs to PackingUnits.QTY
+    if (currentUnitQty > 0) {
+      const unitUomValue: number = originInv.uomValue / originInv.qty
+
+      reducedQty = Math.floor((originalQty * originInv.packingSize - currentUnitQty) / originInv.packingSize)
+      reducedUomValue = unitUomValue * reducedQty
+
+      originInv.qty -= reducedQty
+      originInv.uomValue -= reducedUomValue
+      originInv.lockedQty -= originalQty
+      originInv.lockedUomValue -= originalUomValue
+      originInv.updater = user
+
+      originInv = await trxMgr.getRepository(Inventory).save(originInv)
+      await generateInventoryHistory(originInv, refOrder, transactionType, -reducedQty, -reducedUomValue, user, trxMgr)
+
+      // minus 1 because remain unit qty only exist if the unitQty < 1
+      if (originInv.qty - 1 == 0) {
+        originInv.status = INVENTORY_STATUS.TERMINATED
+        originInv.qty = 0
+        originInv.uomValue = 0
+        originInv = await trxMgr.getRepository(Inventory).save(originInv)
+        await generateInventoryHistory(originInv, refOrder, transactionType, -1, -unitUomValue, user, trxMgr)
+
+        const newQty: number = currentUnitQty
+        const newUomValue: number = (unitUomValue / originInv.packingSize) * newQty
+
+        originInv.qty = newQty
+        originInv.uomValue = newUomValue
+        originInv.packingSize = 1
+        originInv.status = INVENTORY_STATUS.STORED
+        originInv = await trxMgr.getRepository(Inventory).save(originInv)
+        await generateInventoryHistory(originInv, refOrder, transactionType, newQty, newUomValue, user, trxMgr)
+      }
+
+      // currentUnitUomValue > 0 only belongs to PackingUnits.QTY
+    } else if (currentUomValue > 0) {
+      reducedUomValue = Math.round((originalUomValue - currentUomValue + Number.EPSILON) * 100) / 100
+
+      originInv.qty -= reducedQty
+      originInv.uomValue -= reducedUomValue
+      originInv.lockedQty -= originalQty
+      originInv.lockedUomValue -= originalUomValue
+      originInv.updater = user
+
+      originInv = await trxMgr.getRepository(Inventory).save(originInv)
+      await generateInventoryHistory(originInv, refOrder, transactionType, -reducedQty, -reducedUomValue, user, trxMgr)
+    } else {
+      originInv.qty -= reducedQty
+      originInv.uomValue -= reducedUomValue
+      originInv.lockedQty -= originalQty
+      originInv.lockedUomValue -= originalUomValue
+      originInv.updater = user
+      originInv.status = originInv.qty > 0 ? INVENTORY_STATUS.STORED : INVENTORY_STATUS.TERMINATED
+
+      originInv = await trxMgr.getRepository(Inventory).save(originInv)
+      await generateInventoryHistory(originInv, refOrder, transactionType, -reducedQty, -reducedUomValue, user, trxMgr)
+
+      if (originInv.qty <= 0 || originInv.uomValue <= 0) {
+        originInv.status = INVENTORY_STATUS.TERMINATED
+        originInv = await trxMgr.getRepository(Inventory).save(originInv)
+        await generateInventoryHistory(originInv, refOrder, INVENTORY_TRANSACTION_TYPE.TERMINATED, 0, 0, user, trxMgr)
+      }
+    }
+  }
+
+  return originInv
+}
+
+/**
+ * @description Assign inventory to targetVas
+ * When Vas order comes together with Arrival Notice or Release Good
+ * The vas worksheet is activated automatically by to complete unloading/picking worksheet.
+ * As a result user can't activate it manually, which means no assignment for every specific vas tasks.
+ * For this case inventory should be assigned while processing the VAS Order.
+ */
+export async function assignInventory(
+  trxMgr: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  user: User,
+  wsd: WorksheetDetail,
+  refOrder: ArrivalNotice | ReleaseGood,
+  targetVas: OrderVas,
+  palletId: string
+): Promise<OrderVas> {
+  let inventory: Inventory
+
+  if (refOrder instanceof ArrivalNotice) {
+    // Case 1. When the VAS Order comes with Arrival Notice
+    inventory = await trxMgr.getRepository(Inventory).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: bizplace.id },
+        palletId,
+        status: In([INVENTORY_STATUS.UNLOADED, INVENTORY_STATUS.PUTTING_AWAY]),
+        refOrderId: refOrder.id
+      }
+    })
+    if (!inventory) throw new Error(`Counldn't find unloaded inventory by pallet ID: (${palletId})`)
+
+    // Check current inventory has enough qty of product to complete this target vas.
+    if (targetVas.qty > inventory.qty) {
+      // If it doesn't have enough, Need to create new worksheet detail and target vas without inventory assignment
+      // So the user can proceed it with another inventory
+      targetVas = await addNewVasTask(targetVas, inventory.qty, inventory.uomValue, domain, bizplace, user, trxMgr, wsd)
+    }
+  } else if (refOrder instanceof ReleaseGood) {
+    // Case 2. When the VAS Order comes with Release Good
+    // In this case, every available inventories are picked by picking worksheet.
+    // So target inventories should be found by relation with order inventory which has PICKED status
+    //@ts-ignore
+    let pickedOrdInv: OrderInventory = await trxMgr.getRepository(OrderInventory).find({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: bizplace.id },
+        releaseGood: { id: refOrder.id },
+        status: ORDER_INVENTORY_STATUS.PICKED
+      },
+      relations: ['inventory']
+    })
+    //@ts-ignore
+    pickedOrdInv = pickedOrdInv.find((oi: OrderInventory) => oi.inventory.palletId === palletId)
+    inventory = pickedOrdInv?.inventory
+    if (!inventory) throw new Error(`Couldn't find picked inventory by pallet ID: ${palletId}`)
+
+    // Check current target inventory (picked inventory) has enough qty of product to complete this target vas.
+    // And available qty of products also restriced by picking. (Because customer requests do some vas for Release Order)
+    if (targetVas.qty > pickedOrdInv.releaseQty) {
+      // If it doesn't have enough, Need to create new worksheet detail and target vas without inventory assignment
+      // So the user can proceed it with another inventory
+      targetVas = await addNewVasTask(
+        targetVas,
+        pickedOrdInv.releaseQty,
+        pickedOrdInv.releaseUomValue,
+        domain,
+        bizplace,
+        user,
+        trxMgr,
+        wsd
+      )
+    }
+  } else {
+    //@ts-ignore
+    throw new Error(`Reference Order (${refOrder.name}) is not expected.`)
+  }
+
+  targetVas.inventory = inventory
+  targetVas.updater = user
+  return await trxMgr.getRepository(OrderVas).save(targetVas)
+}
+
+/**
+ * Dismiss assigne inventory when user click undo to remove
+ * proceed pallet for relabel, repack, repack
+ *
+ * @param {EntityManager} trxMgr
+ * @param {WorksheetDetail} wsd
+ * @param {OrderVas} targetVas
+ * @param {PalletChangesInterface[]} palletChanges
+ * @param {String} palletId
+ */
+export async function dismissInventory(
+  trxMgr: EntityManager,
+  wsd: WorksheetDetail,
+  targetVas: OrderVas,
+  palletChanges: PalletChangesInterface[],
+  palletId: string
+) {
+  // If there's no more item assigned with current from pallet id
+  if (!palletChanges.find((rf: PalletChangesInterface) => rf.fromPalletId === palletId)) {
+    targetVas.inventory = null
+    const worksheet: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
+      where: { id: wsd.worksheet.id },
+      relations: [
+        'worksheetDetails',
+        'worksheetDetails.targetVas',
+        'worksheetDetails.targetVas.vas',
+        'worksheetDetails.targetVas.inventory'
+      ]
+    })
+
+    const nonFinishedWSD: WorksheetDetail = worksheet.worksheetDetails.find(
+      (otherWSD: WorksheetDetail) =>
+        otherWSD.id !== wsd.id &&
+        otherWSD.targetVas.set === wsd.targetVas.set &&
+        otherWSD.targetVas.vas.id === wsd.targetVas.vas.id &&
+        otherWSD.status !== WORKSHEET_STATUS.DONE
+    )
+
+    if (nonFinishedWSD) {
+      // If there non finished same VAS, delete undo target record (worksheet detail & order vas)
+      // Add qty and uomValue for non finished vas task
+      await trxMgr.getRepository(WorksheetDetail).delete(wsd.id)
+      await trxMgr.getRepository(OrderVas).delete(targetVas.id)
+
+      nonFinishedWSD.targetVas.qty += targetVas.qty
+      nonFinishedWSD.targetVas.uomValue += targetVas.uomValue
+      await trxMgr.getRepository(OrderVas).save(nonFinishedWSD.targetVas)
+    } else {
+      // If there no non finished same VAS, dismiss inventory for the record
+      targetVas.inventory = null
+      await trxMgr.getRepository(OrderVas).save(wsd.targetVas)
+    }
+  }
+}
+
+/**
+ * @description Create nw VAS Worksheet Detail & Order Vas
+ * Without inventory assignment
+ */
+export async function addNewVasTask(
+  targetVas: OrderVas,
+  currentOrderQty: number,
+  currentOrderUomValue: number,
+  domain: Domain,
+  bizplace: Bizplace,
+  user: User,
+  trxMgr: EntityManager,
+  wsd: WorksheetDetail
+): Promise<OrderVas> {
+  // Create new order vas & worksheet detail
+  const copiedTargetVas: OrderVas = Object.assign({}, targetVas)
+  //@ts-ignore
+  delete copiedTargetVas.id
+
+  let newTargetVas: OrderVas = {
+    ...copiedTargetVas,
+    domain,
+    bizplace,
+    name: OrderNoGenerator.orderVas(),
+    qty: targetVas.qty - currentOrderQty,
+    uomValue: targetVas.uomValue - currentOrderUomValue,
+    creator: user,
+    updater: user
+  }
+  newTargetVas = await trxMgr.getRepository(OrderVas).save(newTargetVas)
+
+  const copiedWSD: WorksheetDetail = Object.assign({}, wsd)
+  delete copiedWSD.id
+
+  const newWSD: WorksheetDetail = {
+    ...copiedWSD,
+    domain,
+    bizplace,
+    name: WorksheetNoGenerator.vasDetail(),
+    seq: wsd.seq++,
+    targetVas: newTargetVas,
+    creator: user,
+    updater: user
+  }
+  await trxMgr.getRepository(WorksheetDetail).save(newWSD)
+
+  targetVas.qty = currentOrderQty
+  targetVas.uomValue = currentOrderUomValue
+  return targetVas
+}
+
+export async function upsertInventory(
+  trxMgr: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  user: User,
+  originInv: Inventory,
+  refOrder: RefOrderType,
+  palletId: string,
+  locationName: string,
+  packingType: string,
+  addedQty: number,
+  addedUomValue: number,
+  transactionType: string,
+  stdAmount?: number,
+  packingUnit?: string
+): Promise<Inventory> {
+  const location: Location = await trxMgr.getRepository(Location).findOne({
+    where: { domain: { id: domain.id }, name: locationName },
+    relations: ['warehouse']
+  })
+  if (!location) throw new Error(`Location is not found by (${locationName})`)
+  const warehouse: Warehouse = location.warehouse
+  const zone: string = location.zone
+
+  let inv: Inventory = await trxMgr.getRepository(Inventory).findOne({
+    where: {
+      domain: { id: domain.id },
+      bizplace: { id: bizplace.id },
+      palletId,
+      batchId: originInv.batchId,
+      product: { id: originInv.product.id },
+      packingType,
+      packingSize: stdAmount,
+      refOrderId: originInv.refOrderId,
+      status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+    },
+    relations: ['product', 'refInventory']
+  })
+
+  // Create new inventory
+  if (!inv) {
+    const copiedInv: Inventory = Object.assign({}, originInv)
+    //@ts-ignore
+    delete copiedInv.id
+
+    inv = {
+      ...copiedInv,
+      domain,
+      bizplace,
+      palletId,
+      name: InventoryNoGenerator.inventoryName(),
+      packingType,
+      qty: addedQty,
+      //@ts-ignore
+      weight: 0,
+      uomValue: addedUomValue,
+      lockedQty: 0,
+      lockedUomValue: 0,
+      packingSize: packingUnit == PackingUnits.QTY ? stdAmount : 1,
+      warehouse,
+      location,
+      zone,
+      creator: user,
+      updater: user
+    }
+
+    // Save changed inventory
+    inv = await trxMgr.getRepository(Inventory).save(inv)
+
+    // Check whether the pallet is resuable or not
+    const pallet: Pallet = await trxMgr.getRepository(Pallet).findOne({
+      where: { domain: { id: domain.id }, name: palletId, inventory: IsNull() }
+    })
+    // If it's exists => it's reusable pallet and need to update it's inventory field
+    if (pallet) {
+      pallet.inventory = inv
+      pallet.updater = user
+      await trxMgr.getRepository(Pallet).save(pallet)
+    }
+  } else {
+    // Update inventory
+    inv.qty += addedQty
+    inv.uomValue += addedUomValue
+    inv.warehouse = warehouse
+    inv.location = location
+    inv.zone = location.zone
+    inv.updater = user
+
+    // Save changed inventory
+    inv = await trxMgr.getRepository(Inventory).save(inv)
+  }
+
+  // Create inventory history
+  await generateInventoryHistory(inv, refOrder, transactionType, addedQty, addedUomValue, user, trxMgr)
+
+  return inv
+}
+
+export async function deductProductAmount(
+  trxMgr: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  user: User,
+  refOrder: RefOrderType,
+  originInv: Inventory,
+  reducedQty: number,
+  reducedUomValue: number,
+  transactionType: string,
+  originalQty?: number,
+  originalUomValue?: number,
+  currentUnitQty?: number,
+  currentUomValue?: number
+) {
+  if (refOrder instanceof ReleaseGood) {
+    const loadingWS: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: bizplace.id },
+        releaseGood: { id: refOrder.id },
+        type: WORKSHEET_TYPE.LOADING
+      },
+      relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
+    })
+
+    if (!loadingWS)
+      throw new Error(
+        `Picking process is not finished yet. Please complete picking first before complete Repalletizing`
+      )
+
+    const orderInv: OrderInventory = loadingWS.worksheetDetails
+      .map((wsd: WorksheetDetail) => wsd.targetInventory)
+      .find((oi: OrderInventory) => oi.inventory.id === originInv.id)
+    if (!orderInv) {
+      throw new Error(`Failed to find order inventory (Pallet ID: ${originInv.palletId})`)
+    }
+
+    orderInv.releaseQty -= reducedQty
+    orderInv.releaseUomValue -= reducedUomValue
+    orderInv.updater = user
+
+    await trxMgr.getRepository(OrderInventory).save(orderInv)
+  } else {
+    // currentUnitQty > 0 only belongs to PackingUnits.QTY
+    if (currentUnitQty > 0) {
+      const unitUomValue: number = originInv.uomValue / originInv.qty
+
+      reducedQty = Math.floor((originalQty * originInv.packingSize - currentUnitQty) / originInv.packingSize)
+      reducedUomValue = unitUomValue * reducedQty
+
+      originInv.qty -= reducedQty
+      originInv.uomValue -= reducedUomValue
+      originInv.lockedQty -= reducedQty
+      originInv.lockedUomValue -= reducedUomValue
+      originInv.updater = user
+
+      originInv = await trxMgr.getRepository(Inventory).save(originInv)
+      await generateInventoryHistory(originInv, refOrder, transactionType, -reducedQty, -reducedUomValue, user, trxMgr)
+
+      // minus 1 because remain unit qty only exist if the unitQty < 1
+      if (originInv.qty - 1 == 0) {
+        originInv.status = INVENTORY_STATUS.TERMINATED
+        originInv.qty = 0
+        originInv.uomValue = 0
+        originInv = await trxMgr.getRepository(Inventory).save(originInv)
+        await generateInventoryHistory(originInv, refOrder, transactionType, -1, -unitUomValue, user, trxMgr)
+
+        const newQty: number = currentUnitQty
+        const newUomValue: number = (unitUomValue / originInv.packingSize) * newQty
+
+        originInv.qty = newQty
+        originInv.uomValue = newUomValue
+        originInv.packingSize = 1
+        originInv.status = INVENTORY_STATUS.STORED
+        originInv = await trxMgr.getRepository(Inventory).save(originInv)
+        await generateInventoryHistory(originInv, refOrder, transactionType, newQty, newUomValue, user, trxMgr)
+      }
+
+      // currentUnitUomValue > 0 only belongs to PackingUnits.UOM
+    } else if (currentUomValue > 0) {
+      reducedUomValue = Math.round((originalUomValue - currentUomValue + Number.EPSILON) * 100) / 100
+
+      originInv.qty -= reducedQty
+      originInv.uomValue -= reducedUomValue
+      originInv.lockedQty -= reducedQty
+      originInv.lockedUomValue -= reducedUomValue
+      originInv.updater = user
+
+      originInv = await trxMgr.getRepository(Inventory).save(originInv)
+      await generateInventoryHistory(originInv, refOrder, transactionType, -reducedQty, -reducedUomValue, user, trxMgr)
+    } else {
+      originInv.qty -= reducedQty
+      originInv.uomValue -= reducedUomValue
+      originInv.lockedQty -= reducedQty
+      originInv.lockedUomValue -= reducedUomValue
+      originInv.updater = user
+      originInv.status = originInv.qty > 0 ? INVENTORY_STATUS.STORED : INVENTORY_STATUS.TERMINATED
+
+      originInv = await trxMgr.getRepository(Inventory).save(originInv)
+      await generateInventoryHistory(originInv, refOrder, transactionType, -reducedQty, -reducedUomValue, user, trxMgr)
+
+      if (originInv.qty <= 0 || originInv.uomValue <= 0) {
+        originInv.status = INVENTORY_STATUS.TERMINATED
+        originInv = await trxMgr.getRepository(Inventory).save(originInv)
+        await generateInventoryHistory(originInv, refOrder, INVENTORY_TRANSACTION_TYPE.TERMINATED, 0, 0, user, trxMgr)
+      }
+    }
+  }
+
+  return originInv
+}
+
+export async function createPutawayWorksheet(
+  trxMgr: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  user: User,
+  refOrder: ArrivalNotice,
+  originInv: Inventory,
+  changedInv: Inventory
+): Promise<void> {
+  const putawayWS: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
+    where: {
+      domain: { id: domain.id },
+      bizplace: { id: bizplace.id },
+      arrivalNotice: { id: refOrder.id },
+      type: WORKSHEET_TYPE.PUTAWAY
+    },
+    relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
+  })
+
+  if (!putawayWS) {
+    throw new Error(
+      `Unloading process is not finished yet. Please complete unloading first before complete Repalletizing`
+    )
+  }
+  const putawayWSDs: WorksheetDetail[] = putawayWS.worksheetDetails
+
+  const originalWSD: WorksheetDetail = putawayWSDs.find(
+    (wsd: WorksheetDetail) => wsd.targetInventory.inventory.id === originInv.id
+  )
+  const originOrdInv: OrderInventory = originalWSD.targetInventory
+  const sameTargetWSD: WorksheetDetail = putawayWSDs.find(
+    (wsd: WorksheetDetail) => wsd.targetInventory.inventory.id === changedInv.id
+  )
+
+  if (!sameTargetWSD) {
+    // Create new order inventory
+    const copiedOrdInv: OrderInventory = Object.assign({}, originOrdInv)
+    //@ts-ignore
+    delete copiedOrdInv.id
+
+    let newOrdInv: OrderInventory = {
+      ...copiedOrdInv,
+      domain,
+      bizplace,
+      name: OrderNoGenerator.orderInventory(),
+      type: ORDER_TYPES.ARRIVAL_NOTICE,
+      arrivalNotice: refOrder,
+      inventory: changedInv,
+      creator: user,
+      updater: user
+    }
+    newOrdInv = await trxMgr.getRepository(OrderInventory).save(newOrdInv)
+
+    const copiedWSD: WorksheetDetail = Object.assign({}, originalWSD)
+    delete copiedWSD.id
+
+    let newWSD: WorksheetDetail = {
+      ...copiedWSD,
+      domain,
+      bizplace,
+      worksheet: putawayWS,
+      name: WorksheetNoGenerator.putawayDetail(),
+      targetInventory: newOrdInv,
+      type: WORKSHEET_TYPE.PUTAWAY,
+      creator: user,
+      updater: user
+    }
+    newWSD = await trxMgr.getRepository(WorksheetDetail).save(newWSD)
+  }
+
+  // Update origin order inventory
+  if (originInv.status === INVENTORY_STATUS.TERMINATED) {
+    await trxMgr.getRepository(WorksheetDetail).delete(originalWSD.id)
+
+    originOrdInv.status = ORDER_INVENTORY_STATUS.DONE
+    originOrdInv.updater = user
+    await trxMgr.getRepository(OrderInventory).save(originOrdInv)
+  }
+}
+
+export async function createLoadingWorksheet(
+  trxMgr: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  user: User,
+  refOrder: ReleaseGood,
+  originInv: OrderInventory,
+  changedInv: Inventory
+): Promise<void> {
+  const changedQty: number = changedInv.qty
+  const changedUomValue: number = changedInv.uomValue
+  const loadingWS: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
+    where: {
+      domain: { id: domain.id },
+      bizplace: { id: bizplace.id },
+      releaseGood: { id: refOrder.id },
+      type: WORKSHEET_TYPE.LOADING
+    },
+    relations: ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
+  })
+
+  if (!loadingWS) {
+    throw new Error(`Picking process is not finished yet. Please complete picking first before complete Repalletizing`)
+  }
+
+  const loadingWSDs: WorksheetDetail[] = loadingWS.worksheetDetails
+
+  const originalWSD: WorksheetDetail = loadingWSDs.find(
+    (wsd: WorksheetDetail) => wsd.targetInventory.inventory.id === originInv.id
+  )
+  const originOrdInv: OrderInventory = originalWSD.targetInventory
+  const sameTargetWSD: WorksheetDetail = loadingWSDs.find((wsd: WorksheetDetail) => {
+    const targetOI: OrderInventory = wsd.targetInventory
+    const targetInv: Inventory = targetOI.inventory
+    const targetUnitUomValue: number = targetOI.releaseUomValue / targetOI.releaseQty
+    const changeUnitUomValue: number = changedUomValue / changedQty
+
+    if (
+      targetInv.palletId === changedInv.palletId &&
+      targetInv.batchId === changedInv.batchId &&
+      targetInv.packingType === changedInv.packingType &&
+      targetUnitUomValue === changeUnitUomValue
+    ) {
+      return wsd
+    }
+  })
+
+  if (!sameTargetWSD) {
+    // Create new order inventory
+    const copiedOrderInv: OrderInventory = Object.assign({}, originOrdInv)
+    //@ts-ignore
+    delete copiedOrderInv.id
+
+    let newOrdInv: OrderInventory = await trxMgr.getRepository(OrderInventory).save({
+      ...copiedOrderInv,
+      domain,
+      bizplace,
+      releaseQty: changedQty,
+      releaseUomValue: changedUomValue,
+      name: OrderNoGenerator.orderInventory(),
+      type: ORDER_TYPES.RELEASE_OF_GOODS,
+      releaseGood: refOrder,
+      inventory: changedInv,
+      creator: user,
+      updater: user
+    })
+    newOrdInv = await trxMgr.getRepository(OrderInventory).save(newOrdInv)
+
+    const copiedWSD: WorksheetDetail = Object.assign({}, originalWSD)
+    delete copiedWSD.id
+
+    let newWSD: WorksheetDetail = {
+      ...copiedWSD,
+      domain,
+      bizplace,
+      worksheet: loadingWS,
+      name: WorksheetNoGenerator.loadingDetail(),
+      targetInventory: newOrdInv,
+      type: WORKSHEET_TYPE.LOADING,
+      creator: user,
+      updater: user
+    }
+    await trxMgr.getRepository(WorksheetDetail).save(newWSD)
+  } else {
+    let sameTargetInv: OrderInventory = sameTargetWSD.targetInventory
+    sameTargetInv.releaseQty += changedQty
+    sameTargetInv.releaseUomValue += changedUomValue
+    sameTargetInv.updater = user
+    await trxMgr.getRepository(OrderInventory).save(sameTargetInv)
+  }
+
+  // Update inventory to PICKED inventory
+  changedInv = await trxMgr.getRepository(Inventory).save({
+    ...changedInv,
+    qty: changedInv.qty - changedQty,
+    uomValue: changedInv.uomValue - changedUomValue,
+    updater: user
+  })
+
+  // Generate PICKING inventory history
+  await generateInventoryHistory(
+    changedInv,
+    refOrder,
+    INVENTORY_TRANSACTION_TYPE.PICKING,
+    -changedQty,
+    -changedUomValue,
+    user,
+    trxMgr
+  )
+
+  // Generate TERMINATED inventory history
+  await generateInventoryHistory(changedInv, refOrder, INVENTORY_TRANSACTION_TYPE.TERMINATED, 0, 0, user, trxMgr)
+
+  // Delete worksheet detail & order inventory
+  // If order inventory doesn't have release qty any more
+  if (originOrdInv.releaseQty <= 0) {
+    await trxMgr.getRepository(WorksheetDetail).delete(originalWSD.id)
+    originInv.status = ORDER_INVENTORY_STATUS.DONE
+    originInv.updater = user
+    await trxMgr.getRepository(OrderInventory).save(originInv)
+  }
+}