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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,40 +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, 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)
-  }
-}