@things-factory/worksheet-base 3.6.46 → 3.6.50

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

@@ -1,29 +1,37 @@
+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,
-  ORDER_INVENTORY_STATUS,
-  ORDER_TYPES,
   ReleaseGood
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import {
   Inventory,
-  InventoryNoGenerator,
   INVENTORY_STATUS,
   INVENTORY_TRANSACTION_TYPE,
+  InventoryNoGenerator,
   Location,
   Pallet,
   Warehouse
 } from '@things-factory/warehouse-base'
-import { EntityManager, Equal, In, IsNull, Not } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 import { generateInventoryHistory, WorksheetNoGenerator } from '../../../../utils'
-import { OperationGuideInterface, PalletChangesInterface, RefOrderType } from './interfaces'
+import {
+  OperationGuideInterface,
+  PackingUnits,
+  PalletChangesInterface,
+  RefOrderType,
+  TemporaryPalletChangesInterface
+} from './interfaces'
 
 /**
  * @description Find worksheet detail by name
@@ -184,6 +192,368 @@ export async function getRemainInventoryAmount(
   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, bizplace, inventory: originInv, releaseGood: refOrder, 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, bizplace, 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, 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,
+      bizplace,
+      palletId,
+      batchId: originInv.batchId,
+      product: originInv.product,
+      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,
+      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, 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, bizplace, 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
@@ -375,7 +745,9 @@ export async function upsertInventory(
   packingType: string,
   addedQty: number,
   addedUomValue: number,
-  transactionType: string
+  transactionType: string,
+  stdAmount?: number,
+  packingUnit?: string
 ): Promise<Inventory> {
   const location: Location = await trxMgr.getRepository(Location).findOne({
     where: { domain, name: locationName },
@@ -393,6 +765,7 @@ export async function upsertInventory(
       batchId: originInv.batchId,
       product: originInv.product,
       packingType,
+      packingSize: stdAmount,
       refOrderId: originInv.refOrderId,
       status: Not(Equal(INVENTORY_STATUS.TERMINATED))
     },
@@ -412,8 +785,11 @@ export async function upsertInventory(
       name: InventoryNoGenerator.inventoryName(),
       packingType,
       qty: addedQty,
-      weight:0,
+      weight: 0,
       uomValue: addedUomValue,
+      lockedQty: 0,
+      lockedUomValue: 0,
+      packingSize: packingUnit == PackingUnits.QTY ? stdAmount : 1,
       warehouse,
       location,
       zone,
@@ -462,7 +838,11 @@ export async function deductProductAmount(
   originInv: Inventory,
   reducedQty: number,
   reducedUomValue: number,
-  transactionType: string
+  transactionType: string,
+  originalQty?: number,
+  originalUomValue?: number,
+  currentUnitQty?: number,
+  currentUomValue?: number
 ) {
   if (refOrder instanceof ReleaseGood) {
     const loadingWS: Worksheet = await trxMgr.getRepository(Worksheet).findOne({
@@ -488,14 +868,72 @@ export async function deductProductAmount(
 
     await trxMgr.getRepository(OrderInventory).save(orderInv)
   } else {
-    originInv.qty -= reducedQty
-    originInv.uomValue -= reducedUomValue
-    originInv.updater = user
-    originInv.status = originInv.qty <= 0 || originInv.uomValue <= 0 ? INVENTORY_STATUS.TERMINATED : originInv.status
+    // 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 = await trxMgr.getRepository(Inventory).save(originInv)
-    await generateInventoryHistory(originInv, refOrder, transactionType, -reducedQty, -reducedUomValue, user, trxMgr)
+      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
 }
 

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

@@ -1,4 +1,9 @@
-import { ArrivalNotice, ReleaseGood, ShippingOrder, VasOrder } from '@things-factory/sales-base'
+import {
+  ArrivalNotice,
+  ReleaseGood,
+  ShippingOrder,
+  VasOrder
+} from '@things-factory/sales-base'
 
 export * from './repalletizing'
 export * from './repackaging'
@@ -19,3 +24,33 @@ export interface PalletChangesInterface {
   reducedUomValue: number
   locationName?: string
 }
+
+export interface FeaturedInventoryInterface {
+  palletId: string
+  originalQty: number
+  originalUomValue: number
+  currentUnitQty?: number
+  currentUomValue?: number
+  packingSize: number
+  uomValuePerQty: number
+}
+
+/** REMARK
+ * @farishelmi created this temporary interface solely 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 interface should be merged with its origin once the logic in other vas is updated
+ * */
+export interface TemporaryPalletChangesInterface {
+  fromPalletId: string
+  toPalletId: string
+  reducedQty?: number
+  reducedUomValue?: number
+  reducedUnitQty?: number
+  originalQty?: number
+  originalUomValue?: number
+  currentUnitQty?: number
+  currentUomValue?: number
+  locationName?: string
+  packingSize: number
+}

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

@@ -1,18 +1,24 @@
-import { PalletChangesInterface } from './index'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { TemporaryPalletChangesInterface } from './index'
 
 export interface RepackedInvInfo {
   palletId: string
   locationName: string
   repackedPkgQty: number
-  repackedFrom: PalletChangesInterface[]
+  repackedFrom: TemporaryPalletChangesInterface[]
 }
 
 export interface RepackagingGuide {
   packingUnit: string
+  toProduct?: string
+  toBatchId?: string
   toPackingType: string
   stdAmount: number
   requiredPackageQty: number
   repackedInvs: RepackedInvInfo[]
+  featuredInvs: Partial<Inventory[]>
+  remainder: number
 }
 
 export enum PackingUnits {