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

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

@@ -0,0 +1,166 @@
+import { EntityManager } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderVas, VasOrder } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { Worksheet, WorksheetDetail } from '../../../../../entities'
+import { getWorksheetDetailByName, updateRelatedOrderVas } from '../common-utils'
+import {
+  FeaturedInventoryInterface,
+  OperationGuideInterface,
+  PackingUnits,
+  RefOrderType,
+  RepackagingGuide,
+  RepackedInvInfo,
+  TemporaryPalletChangesInterface
+} from '../interfaces'
+
+/** STEPS TO UNDO REPACKAGING
+ *  1. get the pallet id to undo (pallet id must be the LV one and not the parent)
+ *  2. revert the qty of repackedFrom into the original inventory and featuredInv (if applicable)
+ *  3. remove the repackedInv for undo item
+ *  4. update the requiredPkgQty
+ *
+ */
+
+export const undoRepackagingResolver = {
+  async undoRepackaging(_: any, { worksheetDetailName, fromPalletId, toPalletId }, context: ResolverContext) {
+    /**
+     * Initialize required variables
+     */
+    const { tx, domain, user } = context.state
+    const wsd: WorksheetDetail = await getWorksheetDetailByName(tx, domain, worksheetDetailName)
+    const bizplace: Bizplace = wsd.bizplace
+    const targetVas: OrderVas = wsd.targetVas
+    const { arrivalNotice, releaseGood, vasOrder } = targetVas
+    const refOrder: RefOrderType = arrivalNotice || releaseGood || vasOrder
+
+    let operationGuide: OperationGuideInterface<RepackagingGuide> = JSON.parse(targetVas.operationGuide)
+    let operationGuideData: RepackagingGuide = operationGuide.data
+    let repackedInvs: RepackedInvInfo[] = operationGuideData.repackedInvs
+    //@ts-ignore
+    let featuredInvs: FeaturedInventoryInterface[] = operationGuideData.featuredInvs
+    let undoInventory: RepackedInvInfo = repackedInvs.find((ri: RepackedInvInfo) => ri.palletId === toPalletId)
+    if (!undoInventory) throw new Error(`Couldn't find pallet, using pallet id (${toPalletId})`)
+
+    const packingUnit: string = operationGuideData.packingUnit
+    const stdAmount: number = operationGuideData.stdAmount
+
+    // undoInventory.repackedFrom = undoInventory.repackedFrom.filter(
+    //   (rf: TemporaryPalletChangesInterface) => rf.fromPalletId !== fromPalletId
+    // )
+
+    // 완전히 Repacked 상태인 pallet count
+    // const repackedPkgQty: number =
+    //   undoInventory.repackedFrom.reduce((totalAmount: number, rf: TemporaryPalletChangesInterface) => {
+    //     const amount: number = packingUnit === PackingUnits.QTY ? rf.reducedUnitQty : rf.reducedUomValue
+    //     totalAmount += amount
+    //     return totalAmount
+    //   }, 0) / stdAmount
+
+    // Undo를 발생한 수량 차이를 계산
+    // undoInventory.repackedPkgQty = repackedPkgQty
+
+    const updatedRepackedInvs: RepackedInvInfo[] = repackedInvs.filter(
+      (ri: RepackedInvInfo) => ri.palletId !== toPalletId
+    )
+
+    const updatedFeaturedInvs: FeaturedInventoryInterface[] = featuredInvs.reduce(
+      (inventories: FeaturedInventoryInterface[], currInv: FeaturedInventoryInterface) => {
+        undoInventory.repackedFrom.forEach(undoInv => {
+          if (undoInv.fromPalletId == currInv.palletId) {
+            if (packingUnit == PackingUnits.QTY) {
+              currInv.currentUnitQty += undoInv.reducedUnitQty
+            } else if (packingUnit == PackingUnits.UOM) {
+              currInv.currentUomValue += undoInv.reducedUomValue
+            }
+          }
+        })
+
+        inventories.push(currInv)
+        return inventories
+      },
+      []
+    )
+
+    const requiredPackageQty: number = await getRequiredPackageQty(
+      tx,
+      domain,
+      bizplace,
+      wsd.worksheet,
+      targetVas,
+      packingUnit,
+      stdAmount
+    )
+    const repackedPackageQty: number = getRepackedPackageQty(updatedRepackedInvs)
+
+    operationGuide.data.requiredPackageQty = requiredPackageQty - repackedPackageQty
+    //@ts-ignore
+    operationGuide.data.featuredInvs = updatedFeaturedInvs
+    operationGuide.data.repackedInvs = updatedRepackedInvs
+
+    if (!(refOrder instanceof VasOrder)) {
+      // const palletChanges: TemporaryPalletChangesInterface[] = operationGuide.data.repackedInvs
+      //   .map((ri: RepackedInvInfo) => ri.repackedFrom)
+      //   .flat()
+
+      const palletChanges: TemporaryPalletChangesInterface[] = []
+      // await dismissInventory(tx, wsd, targetVas, palletChanges, fromPalletId)
+    }
+    // Update every order vas to share same operation guide
+    await updateRelatedOrderVas(tx, domain, bizplace, wsd, targetVas, operationGuide, user)
+  }
+}
+
+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
+): 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 / stdAmount
+  } else if (packingUnit === PackingUnits.UOM) {
+    return uomValue / stdAmount
+  }
+}

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

@@ -0,0 +1,116 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { ArrivalNotice, OrderVas, ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
+
+import {
+  createLoadingWorksheet,
+  createPutawayWorksheet,
+  deductProductAmount,
+  getCurrentAmount,
+  upsertInventory
+} from '../common-utils'
+import {
+  OperationGuideInterface,
+  PalletChangesInterface,
+  RefOrderType,
+  RepalletizedInvInfo,
+  RepalletizingGuide
+} from '../interfaces'
+
+export async function completeRepalletizing(trxMgr: EntityManager, orderVas: OrderVas, user: User): Promise<void> {
+  orderVas = await trxMgr.getRepository(OrderVas).findOne({
+    where: { id: orderVas.id },
+    relations: ['domain', 'bizplace', 'inventory', 'inventory.product', 'arrivalNotice', 'releaseGood', 'vasOrder']
+  })
+  const domain: Domain = orderVas.domain
+  const bizplace: Bizplace = orderVas.bizplace
+  let originInv: Inventory = orderVas.inventory
+  const operationGuide: OperationGuideInterface<RepalletizingGuide> = JSON.parse(orderVas.operationGuide)
+  const operationGuideData: RepalletizingGuide = operationGuide.data
+  const { arrivalNotice, releaseGood, vasOrder } = orderVas
+  const refOrder: RefOrderType = arrivalNotice || releaseGood || vasOrder
+
+  // Check completion of new pallets
+  if (!checkCompletion(operationGuideData)) {
+    throw new Error(`There's repalletized pallet which doesn't have as many as standard qty`)
+  }
+
+  // create repalletized inventories based on repalletizedInvs
+  const repalletizedInvs: RepalletizedInvInfo[] = extractRepackedInvs(operationGuideData, originInv)
+  for (const ri of repalletizedInvs) {
+    const repalletizedFromList: PalletChangesInterface[] = ri.repalletizedFrom.filter(
+      (rf: PalletChangesInterface) => rf.toPalletId === ri.palletId
+    )
+    const { qty, uomValue } = getCurrentAmount(repalletizedFromList, ri.palletId)
+    const changedInv: Inventory = await upsertInventory(
+      trxMgr,
+      domain,
+      bizplace,
+      user,
+      originInv,
+      refOrder,
+      ri.palletId,
+      ri.locationName,
+      originInv.packingType,
+      qty,
+      uomValue,
+      INVENTORY_TRANSACTION_TYPE.REPALLETIZING
+    )
+
+    // Deduct amount of product on original pallet or order inventory (Case for release order)
+    originInv = await deductProductAmount(
+      trxMgr,
+      domain,
+      bizplace,
+      user,
+      refOrder,
+      originInv,
+      qty,
+      uomValue,
+      INVENTORY_TRANSACTION_TYPE.REPALLETIZING
+    )
+
+    // Create worksheet if it's related with Arrival Notice or Release Order
+    if (refOrder instanceof ArrivalNotice) {
+      await createPutawayWorksheet(trxMgr, domain, bizplace, user, refOrder, originInv, changedInv)
+    } else if (refOrder instanceof ReleaseGood) {
+      //@ts-ignore
+      await createLoadingWorksheet(trxMgr, domain, bizplace, user, refOrder, originInv, changedInv)
+    }
+  }
+}
+
+/**
+ * @description Check whether every repalletized pallet has products as many as standard qty.
+ * @param operationGuideData
+ */
+function checkCompletion(operationGuideData: RepalletizingGuide): boolean {
+  const stdQty: number = operationGuideData.stdQty
+  return operationGuideData.repalletizedInvs.every((ri: RepalletizedInvInfo) => {
+    const totalQty: number = ri.repalletizedFrom.reduce(
+      (totalQty: number, rf: PalletChangesInterface) => (totalQty += rf.reducedQty),
+      0
+    )
+    return totalQty === stdQty
+  })
+}
+
+function extractRepackedInvs(operationGuideData: RepalletizingGuide, originInv: Inventory): RepalletizedInvInfo[] {
+  return operationGuideData.repalletizedInvs
+    .filter((ri: RepalletizedInvInfo) => {
+      const isPalletIncluded: boolean = Boolean(
+        ri.repalletizedFrom.find((rf: PalletChangesInterface) => rf.fromPalletId === originInv.palletId)
+      )
+      if (isPalletIncluded) return ri
+    })
+    .map((ri: RepalletizedInvInfo) => {
+      ri.repalletizedFrom = ri.repalletizedFrom.filter(
+        (rf: PalletChangesInterface) => rf.fromPalletId === originInv.palletId
+      )
+      return ri
+    })
+}

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

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

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

@@ -0,0 +1,167 @@
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderVas } from '@things-factory/sales-base'
+import { Inventory, Location, Pallet, PALLET_TYPES, Warehouse } from '@things-factory/warehouse-base'
+
+import { WorksheetDetail } from '../../../../../entities'
+import { checkPalletDuplication, checkPalletIdenticallity } from '../../../../../utils'
+import { executeVas } from '../../vas/execute-vas'
+import {
+  assignInventory,
+  getCurrentAmount,
+  getRemainInventoryAmount,
+  getWorksheetDetailByName,
+  updateRelatedOrderVas
+} from '../common-utils'
+import {
+  OperationGuideInterface,
+  PalletChangesInterface,
+  RefOrderType,
+  RepalletizedInvInfo,
+  RepalletizingGuide
+} from '../interfaces'
+
+export const repalletizingResolver = {
+  async repalletizing(
+    _: any,
+    { worksheetDetailName, fromPalletId, toPalletId, locationName },
+    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`)
+
+    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 Pallet 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<RepalletizingGuide> = JSON.parse(targetVas.operationGuide)
+    let operationGuideData: RepalletizingGuide = operationGuide.data
+
+    const palletType: string = operationGuideData.palletType
+    if (palletType === PALLET_TYPES.REUSABLE_PALLET) {
+      // Check whether the pallet is available
+      const pallet: Pallet = await tx.getRepository(Pallet).findOne({
+        where: { domain: { id: domain.id }, name: toPalletId },
+        relations: ['inventory']
+      })
+      if (!pallet) throw new Error(`Couldn't find reusable pallet by its ID (${toPalletId})`)
+      if (pallet.inventory) throw new Error(`The pallet (${toPalletId}) is located already.`)
+    }
+
+    if (!operationGuideData.repalletizedInvs) operationGuideData.repalletizedInvs = []
+    const repalletizedInvs: RepalletizedInvInfo[] = operationGuideData.repalletizedInvs
+    // const palletChanges: PalletChangesInterface[] = repalletizedInvs
+    //   .map((ri: RepalletizedInvInfo) => ri.repalletizedFrom)
+    //   .flat()
+
+    const palletChanges: PalletChangesInterface[] = []
+    const { remainQty, remainUomValue } = await getRemainInventoryAmount(
+      tx,
+      refOrder,
+      domain,
+      bizplace,
+      originInv,
+      palletChanges,
+      fromPalletId
+    )
+    const unitUomValue: number = remainUomValue / remainQty
+    const stdQty: number = operationGuideData.stdQty
+    const { qty } = getCurrentAmount(palletChanges, toPalletId)
+    const requiredQty: number = stdQty - qty
+    if (requiredQty === 0) throw new Error(`The pallet (${toPalletId}) is repalletized already.`)
+    const reducedQty: number = remainQty >= requiredQty ? requiredQty : remainQty
+
+    const repalletizedInv: RepalletizedInvInfo = getRepalletizedInv(operationGuideData, toPalletId, locationName)
+    const repalletizedFrom: PalletChangesInterface = {
+      fromPalletId,
+      toPalletId,
+      reducedQty,
+      reducedUomValue: reducedQty * unitUomValue
+    }
+    repalletizedInv.repalletizedFrom.push(repalletizedFrom)
+
+    const isCompleted: boolean = qty + reducedQty === stdQty
+    let requiredPalletQty: number = isCompleted
+      ? operationGuideData.requiredPalletQty - 1
+      : operationGuideData.requiredPalletQty
+
+    operationGuide.data = {
+      palletType: operationGuideData.palletType,
+      stdQty: operationGuideData.stdQty,
+      requiredPalletQty,
+      repalletizedInvs
+    }
+
+    // Update every order vas to share same operation guide
+    await updateRelatedOrderVas<RepalletizingGuide>(tx, domain, bizplace, wsd, targetVas, operationGuide, user)
+
+    // If pallet is created completely
+    // If there's no more products on from pallet
+    if (remainQty - reducedQty === 0 || requiredPalletQty === 0) {
+      await executeVas(tx, domain, user, wsd)
+    }
+  }
+}
+
+/**
+ * @description Find repalletized pallet which has same pallet id with passed pallet id as param
+ * If there's no repalletized pallet init new RepalletizedInvInfo object and return it
+ *
+ * @param {RepalletizedInvInfo} operationGuideData
+ * @param {String} palletId
+ * @param {String} locationName
+ */
+function getRepalletizedInv(
+  operationGuideData: RepalletizingGuide,
+  palletId: string,
+  locationName: string
+): RepalletizedInvInfo {
+  let repalletizedInv: RepalletizedInvInfo = operationGuideData.repalletizedInvs.find(
+    (ri: RepalletizedInvInfo) => ri.palletId === palletId
+  )
+
+  if (!repalletizedInv) {
+    repalletizedInv = {
+      palletId,
+      locationName,
+      repalletizedFrom: []
+    }
+    operationGuideData.repalletizedInvs.push(repalletizedInv)
+  }
+  return repalletizedInv
+}

package/server/graphql/resolvers/worksheet/vas-transactions/repalletizing/undo-repalletizing.ts

@@ -0,0 +1,74 @@
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderVas, VasOrder } from '@things-factory/sales-base'
+
+import { WorksheetDetail } from '../../../../../entities'
+import { dismissInventory, getWorksheetDetailByName, updateRelatedOrderVas } from '../common-utils'
+import {
+  OperationGuideInterface,
+  PalletChangesInterface,
+  RefOrderType,
+  RepalletizedInvInfo,
+  RepalletizingGuide
+} from '../interfaces'
+
+export const undoRepalletizingResolver = {
+  async undoRepalletizing(_: any, { worksheetDetailName, fromPalletId, toPalletId }, context: ResolverContext) {
+    /**
+     * Initialize required variables
+     */
+    const { tx, domain, user } = context.state
+    const wsd: WorksheetDetail = await getWorksheetDetailByName(tx, domain, worksheetDetailName)
+    const bizplace: Bizplace = wsd.bizplace
+    const targetVas: OrderVas = wsd.targetVas
+    const { arrivalNotice, releaseGood, vasOrder } = targetVas
+    const refOrder: RefOrderType = arrivalNotice || releaseGood || vasOrder
+
+    let operationGuide: OperationGuideInterface<RepalletizingGuide> = JSON.parse(targetVas.operationGuide)
+    let operationGuideData: RepalletizingGuide = operationGuide.data
+    let repalletizedInvs: RepalletizedInvInfo[] = operationGuideData.repalletizedInvs
+    let undoInventory: RepalletizedInvInfo = repalletizedInvs.find(
+      (ri: RepalletizedInvInfo) => ri.palletId === toPalletId
+    )
+    if (!undoInventory) throw new Error(`Couldn't find pallet, using pallet id (${toPalletId})`)
+
+    const stdQty: number = operationGuideData.stdQty
+
+    // If current undo pallet is completed pallet, plus 1 required pallet qty
+    const totalQty: number = undoInventory.repalletizedFrom.reduce(
+      (totalQty: number, rf: PalletChangesInterface) => (totalQty += rf.reducedQty),
+      0
+    )
+
+    if (totalQty === stdQty) {
+      operationGuideData.requiredPalletQty++
+    }
+
+    undoInventory.repalletizedFrom = undoInventory.repalletizedFrom.filter(
+      (rf: PalletChangesInterface) => rf.fromPalletId !== fromPalletId
+    )
+
+    let updatedRepalletizedInvs: RepalletizedInvInfo[]
+    if (!undoInventory.repalletizedFrom?.length) {
+      updatedRepalletizedInvs = repalletizedInvs.filter((ri: RepalletizedInvInfo) => ri.palletId !== toPalletId)
+    } else {
+      updatedRepalletizedInvs = repalletizedInvs.map((ri: RepalletizedInvInfo) => {
+        if (ri.palletId === toPalletId) {
+          ri = undoInventory
+        }
+        return ri
+      })
+    }
+    operationGuide.data.repalletizedInvs = updatedRepalletizedInvs
+
+    if (!(refOrder instanceof VasOrder)) {
+      // const palletChanges: PalletChangesInterface[] = operationGuide.data.repalletizedInvs
+      //   .map((ri: RepalletizedInvInfo) => ri.repalletizedFrom)
+      //   .flat()
+      const palletChanges: PalletChangesInterface[] = []
+      await dismissInventory(tx, wsd, targetVas, palletChanges, toPalletId)
+    }
+
+    // Update every order vas to share same operation guide
+    await updateRelatedOrderVas<RepalletizingGuide>(tx, domain, bizplace, wsd, targetVas, operationGuide, user)
+  }
+}

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

@@ -0,0 +1,20 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderVas } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { RefOrderType } from '../interfaces'
+
+export async function completeUnpacking(trxMgr: EntityManager, orderVas: OrderVas, user: User): Promise<void> {
+  orderVas = await trxMgr.getRepository(OrderVas).findOne({
+    where: { id: orderVas.id },
+    relations: ['domain', 'bizplace', 'inventory', 'inventory.product', 'arrivalNotice', 'releaseGood', 'vasOrder']
+  })
+
+  const domain: Domain = orderVas.domain
+  const bizplace: Bizplace = orderVas.bizplace
+  const { arrivalNotice, releaseGood, vasOrder } = orderVas
+  const refOrder: RefOrderType = arrivalNotice || releaseGood || vasOrder
+}

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

@@ -0,0 +1,2 @@
+export * from './complete-unpacking'
+export * from './unpacking'