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

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

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

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

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

@@ -0,0 +1,41 @@
+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']
+    })
+  }
+}