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

package/server/graphql/resolvers/worksheet/vas/undo-vas-inventory.ts

@@ -1,24 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { VasWorksheetController } from '../../../../controllers'
-
-export const undoVasInventoryResolver = {
-  async undoVasInventory(_: any, { worksheetDetailName, palletId }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    await undoVasInventory(tx, domain, user, worksheetDetailName, palletId)
-  }
-}
-
-async function undoVasInventory(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  worksheetDetailName: string,
-  palletId: string
-): Promise<void> {
-  const worksheetController: VasWorksheetController = new VasWorksheetController(tx, domain, user)
-  await worksheetController.undoVasInventory(worksheetDetailName, palletId)
-}

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

@@ -1,24 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { VasWorksheetController } from '../../../../controllers'
-import { WorksheetDetail } from '../../../../entities'
-
-export const undoVasResolver = {
-  async undoVas(_: any, { worksheetDetail }, context: ResolverContext) {
-    const { tx, domain, user } = context.state
-    await undoVas(tx, domain, user, worksheetDetail)
-  }
-}
-
-export async function undoVas(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  worksheetDetail: Partial<WorksheetDetail>
-): Promise<void> {
-  const worksheetController: VasWorksheetController = new VasWorksheetController(tx, domain, user)
-  await worksheetController.undoVAS(worksheetDetail)
-}

package/server/graphql/resolvers/worksheet/vas-candidates.ts

@@ -1,177 +0,0 @@
-import { EntityManager, FindOperator, In } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import {
-  ORDER_INVENTORY_STATUS,
-  ORDER_PRODUCT_STATUS,
-  OrderInventory,
-  OrderProduct,
-  OrderVas
-} from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-
-import { Worksheet, WorksheetDetail } from '../../../entities'
-
-enum OrderType {
-  ArrivalNotice,
-  ReleaseGood,
-  VasOrder
-}
-interface IInventoryCondition {
-  id?: FindOperator<any>
-  domain: Domain
-  bizplace: Bizplace
-  batchId?: string
-  product?: Product
-  packingType?: string
-  orderProduct?: FindOperator<any>
-  status?: FindOperator<any>
-}
-
-export const vasCandidatesResolver = {
-  async vasCandidates(_: any, { worksheetDetailId }, context: ResolverContext) {
-    const { tx, domain } = context.state
-    const worksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-      where: { id: worksheetDetailId },
-      relations: [
-        'bizplace',
-        'worksheet',
-        'worksheet.arrivalNotice',
-        'worksheet.releaseGood',
-        'worksheet.vasOrder',
-        'targetVas',
-        'targetVas.targetProduct'
-      ]
-    })
-
-    const worksheet: Worksheet = worksheetDetail.worksheet
-    if (!worksheet) throw new Error(`Can't find worksheet.`)
-
-    const bizplace: Bizplace = worksheetDetail.bizplace
-    const orderVas: OrderVas = worksheetDetail.targetVas
-    const orderType: OrderType = worksheet.arrivalNotice
-      ? OrderType.ArrivalNotice
-      : worksheet.releaseGood
-      ? OrderType.ReleaseGood
-      : OrderType.VasOrder
-
-    const inventoryCondition: IInventoryCondition = await buildInventoryCondition(
-      tx,
-      domain,
-      bizplace,
-      worksheet,
-      orderType,
-      orderVas
-    )
-
-    let inventories: Inventory[] = await tx.getRepository(Inventory).find({
-      where: inventoryCondition,
-      relations: ['product', 'location']
-    })
-
-    /**
-     * @description
-     * If current worksheet is comes together with release good.
-     * VAS order should be done before processing loading.
-     * And qty and uomValue information for target inventories should be originated from orderInventories
-     */
-
-    if (orderType === OrderType.ReleaseGood) {
-      inventories = await Promise.all(
-        inventories.map(async (inventory: Inventory) => {
-          const orderInv: OrderInventory = await tx.getRepository(OrderInventory).findOne({
-            where: {
-              domain: { id: domain.id },
-              bizplace: { id: bizplace.id },
-              inventory: { id: inventory.id },
-              releaseGood: { id: worksheet.releaseGood.id },
-              status: In([ORDER_INVENTORY_STATUS.PICKED])
-            }
-          })
-          return {
-            ...inventory,
-            qty: orderInv.releaseQty,
-            uomValue: orderInv.releaseUomValue
-          }
-        })
-      )
-    }
-
-    // only return inventories with available qty
-    return inventories
-      .map((inventory: Inventory) => {
-        return {
-          ...inventory,
-          qty: inventory.qty - inventory.lockedQty,
-          uomValue: inventory.uomValue - inventory.lockedUomValue
-        }
-      })
-      .filter((inventory: Inventory) => inventory.qty > 0)
-  }
-}
-
-async function buildInventoryCondition(
-  tx: EntityManager,
-  domain: Domain,
-  bizplace: Bizplace,
-  worksheet: Worksheet,
-  orderType: OrderType,
-  orderVas: OrderVas
-): Promise<IInventoryCondition> {
-  let condition: IInventoryCondition = { domain, bizplace }
-
-  if (orderVas.targetBatchId) condition.batchId = orderVas.targetBatchId
-  if (orderVas.targetProduct) condition.product = orderVas.targetProduct
-  if (orderVas.packingType) condition.packingType = orderVas.packingType
-
-  switch (orderType) {
-    case OrderType.ArrivalNotice:
-      const orderProducts: OrderProduct[] = await tx.getRepository(OrderProduct).find({
-        where: {
-          domain: { id: domain.id },
-          bizplace: { id: bizplace.id },
-          arrivalNotice: { id: worksheet.arrivalNotice.id },
-          status: In([
-            ORDER_PRODUCT_STATUS.READY_TO_UNLOAD,
-            ORDER_PRODUCT_STATUS.UNLOADING,
-            ORDER_PRODUCT_STATUS.PARTIALLY_UNLOADED,
-            ORDER_PRODUCT_STATUS.UNLOADED,
-            ORDER_PRODUCT_STATUS.PUTTING_AWAY,
-            ORDER_PRODUCT_STATUS.STORED
-          ])
-        }
-      })
-
-      condition.orderProduct = In(orderProducts.map((ordProd: OrderProduct) => ordProd.id))
-      condition.status = In([
-        INVENTORY_STATUS.UNLOADED,
-        INVENTORY_STATUS.PARTIALLY_UNLOADED,
-        INVENTORY_STATUS.PUTTING_AWAY,
-        INVENTORY_STATUS.STORED
-      ])
-      break
-
-    case OrderType.ReleaseGood:
-      const orderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-        where: {
-          domain: { id: domain.id },
-          bizplace: { id: bizplace.id },
-          releaseGood: { id: worksheet.releaseGood.id },
-          status: In([ORDER_INVENTORY_STATUS.PICKED])
-        },
-        relations: ['inventory']
-      })
-
-      const inventoryIds: string[] = orderInventories.map((ordInv: OrderInventory) => ordInv.inventory.id)
-      condition.id = inventoryIds?.length ? In(inventoryIds) : In([null])
-      condition.status = In([INVENTORY_STATUS.PICKED, INVENTORY_STATUS.TERMINATED, INVENTORY_STATUS.STORED])
-      break
-
-    case OrderType.VasOrder:
-      condition.status = In([INVENTORY_STATUS.STORED])
-  }
-
-  return condition
-}

package/server/graphql/resolvers/worksheet/vas-inventories.ts

@@ -1,41 +0,0 @@
-import { Equal, Not } from 'typeorm'
-
-//@ts-ignore
-import { ArrivalNotice, Bizplace } from '@things-factory/sales-base'
-import { getRepository } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
-import { WorksheetDetail } from '../../../entities'
-
-export const vasInventories = {
-  async vasInventories(_: any, { worksheetDetailName }, context: ResolverContext) {
-    const { domain } = context.state
-
-    const foundWorksheetDetail: WorksheetDetail = await getRepository(WorksheetDetail).findOne({
-      where: {
-        domain: { id: domain.id },
-        name: worksheetDetailName,
-        type: WORKSHEET_TYPE.VAS,
-        status: WORKSHEET_STATUS.EXECUTING
-      },
-      relations: ['bizplace', 'targetVas', 'worksheet', 'worksheet.vasOrder']
-    })
-
-    if (!foundWorksheetDetail) return []
-
-    //@ts-ignore
-    const vasOrder: ArrivalNotice = foundWorksheetDetail.worksheet.vasOrder
-    const customerBizplace: Bizplace = foundWorksheetDetail.bizplace
-    return await getRepository(Inventory).find({
-      where: {
-        domain: { id: domain.id },
-        bizplace: { id: customerBizplace.id },
-        refOrderId: vasOrder.id,
-        orderVasId: foundWorksheetDetail.targetVas.id,
-        status: Not(Equal(INVENTORY_STATUS.DELETED))
-      },
-      relations: ['product', 'location']
-    })
-  }
-}