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

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

@@ -0,0 +1,5 @@
+export * from './interfaces'
+export * from './relabeling'
+export * from './repackaging'
+export * from './repalletizing'
+export * from './unpacking'

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

@@ -0,0 +1,56 @@
+import {
+  ArrivalNotice,
+  ReleaseGood,
+  ShippingOrder,
+  VasOrder
+} from '@things-factory/sales-base'
+
+export * from './repalletizing'
+export * from './repackaging'
+export * from './relabeling'
+export * from './unpacking'
+
+export declare type RefOrderType = ArrivalNotice | ReleaseGood | VasOrder | ShippingOrder
+
+export interface OperationGuideInterface<T> {
+  data: T
+  transactions?: [any]
+}
+
+export interface PalletChangesInterface {
+  fromPalletId: string
+  toPalletId: string
+  reducedQty: number
+  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/relabeling.ts

@@ -0,0 +1,20 @@
+import { PalletChangesInterface } from '.'
+
+export interface RelabelingToProduct {
+  id: string
+  name: string
+  description: string
+}
+
+export interface RelabelingLabel {
+  id: string
+  namd: string
+  path: string
+}
+
+export interface RelabelingGuide {
+  toProduct?: RelabelingToProduct
+  toBatchId?: string
+  newLabel: RelabelingLabel
+  relabeledFrom: PalletChangesInterface[]
+}

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

@@ -0,0 +1,27 @@
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { TemporaryPalletChangesInterface } from './index'
+
+export interface RepackedInvInfo {
+  palletId: string
+  locationName: string
+  repackedPkgQty: number
+  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 {
+  UOM = 'UOM',
+  QTY = 'QTY'
+}

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

@@ -0,0 +1,14 @@
+import { PalletChangesInterface } from './index'
+
+export interface RepalletizedInvInfo {
+  palletId: string
+  locationName: string
+  repalletizedFrom: PalletChangesInterface[]
+}
+
+export interface RepalletizingGuide {
+  palletType: string
+  stdQty: number
+  requiredPalletQty: number
+  repalletizedInvs: RepalletizedInvInfo[]
+}

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

@@ -0,0 +1,14 @@
+import { PalletChangesInterface } from './index'
+
+export interface UnpackedInvInfo {
+  palletId: string
+  locationName: string
+  repalletizedFrom: PalletChangesInterface[]
+}
+
+export interface UnpackingGuide {
+  palletType: string
+  stdQty: number
+  requiredPalletQty: number
+  repalletizedInvs: UnpackedInvInfo[]
+}

package/server/graphql/resolvers/worksheet/vas-transactions/relabeling/check-relabelable.ts

@@ -0,0 +1,96 @@
+import { EntityManager, Equal, Not } from 'typeorm'
+
+import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
+
+export const checkRelabelableResolver = {
+  async checkRelabelable(
+    _: void,
+    {
+      batchId,
+      productId,
+      packingType,
+      unitUomValue
+    }: { batchId: string; productId: string; packingType: string; unitUomValue: number },
+    context: any
+  ): Promise<boolean> {
+    const { tx, domain, user } = context.state
+    //@ts-ignore
+    const bizplace: Bizplace = await getMyBizplace(user)
+    const product: Product = await tx.getRepository(Product).findOne({
+      where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, id: productId }
+    })
+    if (!product) throw new Error(`Couldn't find product by ID (${productId})`)
+
+    return await checkRelabelable(tx, domain, bizplace, batchId, product, packingType, unitUomValue)
+  }
+}
+
+/**
+ * @description Try to find whether current inventory information can be accepted for relabeling.
+ * The inventory should be exactly same with one of stored inventory
+ * or
+ * The inventory should be totally different with every single inventories stored.
+ *
+ * @param {EntityManager} tx
+ * @param {Domain} domain
+ * @param {Bizplace} bizplace
+ * @param {String} batchId
+ * @param {Product} product
+ * @param {String} packingType
+ * @param {Number} unitUomValue
+ */
+export async function checkRelabelable(
+  tx: EntityManager,
+  domain: Domain,
+  bizplace: Bizplace,
+  batchId: string,
+  product: Product,
+  packingType: string,
+  unitUomValue: number
+): Promise<boolean> {
+  // Try to find out identical inventory
+  // The condition is same batch id same product same packing type same uomValue
+  // If there *IS* identical inventory the target inventory for this vas can be executed
+  const identicalInvCnt: number = await tx
+    .getRepository(Inventory)
+    .createQueryBuilder('inv')
+    .where('inv.domain_id = :domainId')
+    .andWhere('inv.bizplace_id = :bizplaceId')
+    .andWhere('inv.batch_id = :batchId')
+    .andWhere('inv.product_id = :productId')
+    .andWhere('inv.packing_type = :packingType')
+    .andWhere('inv.status != :status')
+    .andWhere('(inv.uom_value / inv.qty) = :unitUomValue')
+    .setParameters({
+      domainId: domain.id,
+      bizplaceId: bizplace.id,
+      batchId,
+      productId: product.id,
+      packingType,
+      status: INVENTORY_STATUS.TERMINATED,
+      unitUomValue
+    })
+    .getCount()
+
+  if (identicalInvCnt) return true
+
+  // Try to find out duplicated invenetory
+  // The condition is same batch id same product same packing type
+  // If there's *NO* duplicated inventory the target inventory for this vas can be executed
+  const duplicatedInvCnt: number = await tx.getRepository(Inventory).count({
+    where: {
+      domain: { id: domain.id },
+      bizplace: { id: bizplace.id },
+      batchId,
+      product: { id: product.id },
+      packingType,
+      status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+    }
+  })
+  if (!duplicatedInvCnt) return true
+
+  return false
+}

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

@@ -0,0 +1,93 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import { 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,
+  getReducedAmount,
+  upsertInventory
+} from '../common-utils'
+import {
+  OperationGuideInterface,
+  PalletChangesInterface,
+  RefOrderType,
+  RelabelingGuide,
+  RelabelingToProduct
+} from '../interfaces'
+
+export async function completeRelabeling(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<RelabelingGuide> = JSON.parse(orderVas.operationGuide)
+  const operationGuideData: RelabelingGuide = operationGuide.data
+  const { toBatchId, toProduct }: { toBatchId?: string; toProduct?: RelabelingToProduct } = operationGuideData
+  const { arrivalNotice, releaseGood, vasOrder } = orderVas
+  const refOrder: RefOrderType = arrivalNotice || releaseGood || vasOrder
+  const palletChanges: PalletChangesInterface[] = extractRelabeledPallets(
+    operationGuideData.relabeledFrom,
+    orderVas.inventory.palletId
+  )
+
+  let copiedInv: Inventory = Object.assign({}, originInv)
+  if (toBatchId) copiedInv.batchId = toBatchId
+  if (toProduct) copiedInv.product = await trxMgr.getRepository(Product).findOneBy({ id: toProduct.id })
+
+  copiedInv.refInventory = originInv
+
+  for (const palletChange of palletChanges) {
+    const newInventory: Inventory = await upsertInventory(
+      trxMgr,
+      domain,
+      bizplace,
+      user,
+      copiedInv,
+      refOrder,
+      palletChange.toPalletId,
+      palletChange.locationName,
+      copiedInv.packingType,
+      palletChange.reducedQty,
+      palletChange.reducedUomValue,
+      INVENTORY_TRANSACTION_TYPE.RELABELING
+    )
+
+    const { reducedQty, reducedUomValue } = getReducedAmount(palletChanges, orderVas.inventory.palletId)
+    // 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)
+    originInv = await deductProductAmount(
+      trxMgr,
+      domain,
+      bizplace,
+      user,
+      refOrder,
+      originInv,
+      reducedQty,
+      reducedUomValue,
+      INVENTORY_TRANSACTION_TYPE.RELABELING
+    )
+
+    // Create worksheet if it's related with Arrival Notice or Release Order
+    if (refOrder instanceof ArrivalNotice) {
+      await createPutawayWorksheet(trxMgr, domain, bizplace, user, refOrder, originInv, newInventory)
+    } else if (refOrder instanceof ReleaseGood) {
+      //@ts-ignore
+      await createLoadingWorksheet(trxMgr, domain, bizplace, user, refOrder, originInv, newInventory)
+    }
+  }
+}
+
+function extractRelabeledPallets(palletChanges: PalletChangesInterface[], palletId: string): PalletChangesInterface[] {
+  return palletChanges.filter((pc: PalletChangesInterface) => pc.fromPalletId === palletId)
+}

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

@@ -0,0 +1,4 @@
+export * from './check-relabelable'
+export * from './complete-relabeling'
+export * from './relabeling'
+export * from './undo-relabeling'

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

@@ -0,0 +1,105 @@
+import { Equal, Not } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderVas } from '@things-factory/sales-base'
+import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
+
+import { WorksheetDetail } from '../../../../../entities'
+import { executeVas } from '../../vas/execute-vas'
+import {
+  assignInventory,
+  getRemainInventoryAmount,
+  getWorksheetDetailByName,
+  updateRelatedOrderVas
+} from '../common-utils'
+import { OperationGuideInterface, PalletChangesInterface, RefOrderType, RelabelingGuide } from '../interfaces'
+
+export const relabelingResolver = {
+  async relabeling(
+    _: any,
+    { worksheetDetailName, fromPalletId, toPalletId, locationName },
+    context: any
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
+
+    // Find target worksheet detail & target order vas & bizplace
+    const wsd: WorksheetDetail = await getWorksheetDetailByName(tx, domain, worksheetDetailName)
+    let { bizplace, targetVas }: { bizplace: Bizplace; targetVas: OrderVas } = wsd
+
+    // Check whether to pallet id is duplicated or not.
+    if (
+      await tx.getRepository(Inventory).count({
+        where: {
+          domain: { id: domain.id },
+          bizplace: { id: bizplace.id },
+          palletId: toPalletId,
+          status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+        }
+      })
+    ) {
+      throw new Error(`Pallet (${toPalletId}) is already exists`)
+    }
+
+    // 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<RelabelingGuide> = JSON.parse(targetVas.operationGuide)
+    let operationGuideData: RelabelingGuide = operationGuide.data
+    if (!operationGuideData.relabeledFrom) operationGuideData.relabeledFrom = []
+    const palletChanges: PalletChangesInterface[] = operationGuideData.relabeledFrom
+    const { remainQty, remainUomValue } = await getRemainInventoryAmount(
+      tx,
+      refOrder,
+      domain,
+      bizplace,
+      originInv,
+      palletChanges,
+      fromPalletId
+    )
+
+    const unitUomValue: number = remainUomValue / remainQty
+    let newPalletChange: PalletChangesInterface = {
+      fromPalletId,
+      toPalletId,
+      reducedQty: 0,
+      reducedUomValue: 0
+    }
+    if (locationName) {
+      newPalletChange.locationName = locationName
+    } else {
+      originInv = await tx.getRepository(Inventory).findOne({
+        where: { id: originInv.id },
+        relations: ['location']
+      })
+      newPalletChange.locationName = originInv.location.name
+    }
+
+    if (remainQty < targetVas.qty) {
+      // 남은 수량으로 전체 작업을 처리할 수 없는 경우
+      newPalletChange.reducedQty = remainQty
+      newPalletChange.reducedUomValue = remainQty * unitUomValue
+    } else {
+      // 남은 수량으로 전체 작업을 처리할 수 있는 경우
+      newPalletChange.reducedQty = targetVas.qty
+      newPalletChange.reducedUomValue = targetVas.uomValue
+    }
+
+    palletChanges.push(newPalletChange)
+    operationGuide.data.relabeledFrom = palletChanges
+
+    // Update every order vas to share same operation guide
+    await updateRelatedOrderVas<RelabelingGuide>(tx, domain, bizplace, wsd, targetVas, operationGuide, user)
+    await executeVas(tx, domain, user, wsd)
+  }
+}

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

@@ -0,0 +1,40 @@
+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, RelabelingGuide } from '../interfaces'
+
+export const undoRelabelingResolver = {
+  async undoRelabeling(
+    _: any,
+    { worksheetDetailName, toPalletId }: { worksheetDetailName: string; fromPalletId: string; toPalletId: string },
+    context: any
+  ): Promise<void> {
+    /** Initialize required variables */
+    const { tx, domain, user } = context.state
+    const wsd: WorksheetDetail = await getWorksheetDetailByName(tx, domain, worksheetDetailName)
+    const { bizplace, targetVas }: { bizplace: Bizplace; targetVas: OrderVas } = wsd
+
+    if (!targetVas) throw new Error(`Couldn't find any related target vas, using current worksheet detail`)
+    const { arrivalNotice, releaseGood, vasOrder } = targetVas
+    const refOrder: RefOrderType = arrivalNotice || releaseGood || vasOrder
+
+    let operationGuide: OperationGuideInterface<RelabelingGuide> = JSON.parse(targetVas.operationGuide)
+    let operationGuideData: RelabelingGuide = operationGuide.data
+
+    const fromPalletId: string = targetVas.inventory.palletId
+    // Filter out pallets which has same id with undoPalletId
+    operationGuide.data.relabeledFrom = operationGuideData.relabeledFrom.filter(
+      (pc: PalletChangesInterface) =>
+        pc.fromPalletId !== fromPalletId || (pc.fromPalletId === fromPalletId && pc.toPalletId !== toPalletId)
+    )
+
+    if (!(refOrder instanceof VasOrder)) {
+      await dismissInventory(tx, wsd, targetVas, operationGuide.data.relabeledFrom, fromPalletId)
+    }
+
+    // Update every related operation guide to share same data
+    await updateRelatedOrderVas(tx, domain, bizplace, wsd, targetVas, operationGuide, user)
+  }
+}