@things-factory/worksheet-base 8.0.0-beta.0 → 8.0.0-beta.2

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

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

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

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

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

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

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

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

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