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

package/server/graphql/resolvers/worksheet/check-inventory-release.ts

@@ -0,0 +1,37 @@
+import { In, Repository } from 'typeorm'
+
+import { ORDER_INVENTORY_STATUS, ORDER_TYPES, OrderInventory } from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+export const checkInventoryReleaseResolver = {
+  async checkInventoryRelease(_: any, { palletId }, context: ResolverContext) {
+    const { domain } = context.state
+    const invRepo: Repository<Inventory> = getRepository(Inventory)
+    const oiRepo: Repository<OrderInventory> = getRepository(OrderInventory)
+
+    const inventory: Inventory = await invRepo.findOne({
+      where: { domain: { id: domain.id }, palletId },
+      relations: ['bizplace']
+    })
+
+    const oiStatuses: string[] = [
+      ORDER_INVENTORY_STATUS.PENDING,
+      ORDER_INVENTORY_STATUS.PENDING_RECEIVE,
+      ORDER_INVENTORY_STATUS.READY_TO_PICK,
+      ORDER_INVENTORY_STATUS.PICKING,
+      ORDER_INVENTORY_STATUS.PENDING_CANCEL
+    ]
+
+    const orderInventories: OrderInventory[] = await oiRepo.find({
+      where: {
+        domain: { id: domain.id },
+        inventory: { id: inventory.id },
+        type: ORDER_TYPES.RELEASE_OF_GOODS,
+        status: In(oiStatuses)
+      }
+    })
+
+    return Boolean(orderInventories?.length > 0)
+  }
+}

package/server/graphql/resolvers/worksheet/check-stock-take-current-location.ts

@@ -0,0 +1,63 @@
+import { Repository } from 'typeorm'
+
+import { InventoryCheck, OrderInventory } from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WorksheetDetail } from '../../../entities'
+
+export const checkStockTakeCurrentLocationResolver = {
+  async checkStockTakeCurrentLocation(_: any, { palletId, cycleCountNo }, context: ResolverContext) {
+    const { domain } = context.state
+    const invRepo: Repository<Inventory> = getRepository(Inventory)
+    const worksheetDetailRepo: Repository<WorksheetDetail> = getRepository(WorksheetDetail)
+    const inventoryCheckRepo: Repository<InventoryCheck> = getRepository(InventoryCheck)
+
+    const inventory: Inventory = await invRepo.findOne({
+      where: { domain: { id: domain.id }, palletId },
+      relations: ['bizplace']
+    })
+
+    const cycleCount: InventoryCheck = await inventoryCheckRepo.findOne({
+      where: { domain: { id: domain.id }, name: cycleCountNo },
+      relations: [
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.inventory.location',
+        'orderInventories.inventory.product'
+      ]
+    })
+
+    const orderInventories: OrderInventory[] = cycleCount.orderInventories
+
+    const foundInventory: Inventory = orderInventories.find(
+      (oi: OrderInventory) => oi.inventory.palletId === inventory.palletId
+    ).inventory
+
+    const foundWSD: any[] = await Promise.all(
+      orderInventories
+        .filter((oi: OrderInventory) => oi.inventory.palletId === inventory.palletId)
+        .map(async (oi: OrderInventory) => {
+          const matchingWSD = await worksheetDetailRepo.findOne({
+            where: { domain: { id: domain.id }, targetInventory: { id: oi.id } }
+          })
+
+          return matchingWSD
+        })
+    )
+
+    if (!foundInventory) throw new Error(`${inventory.palletId} is not in cycle count worksheet`)
+
+    return {
+      worksheetDetailName: foundWSD[0].name,
+      currentLocation: foundInventory.location.name,
+      palletId: foundInventory.palletId,
+      batchId: foundInventory.batchId,
+      qty: foundInventory.qty,
+      uomValue: foundInventory.uomValue,
+      uom: foundInventory.uom,
+      productName: foundInventory.product.name,
+      productDescription: foundInventory.product.description
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/confirm-cancellation-release-order.ts

@@ -0,0 +1,213 @@
+import { In } from 'typeorm'
+
+import {
+  DeliveryOrder,
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  ORDER_VAS_STATUS,
+  OrderInventory,
+  OrderVas,
+  ReleaseGood
+} from '@things-factory/sales-base'
+import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location } from '@things-factory/warehouse-base'
+
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { generateInventoryHistory } from '../../../utils'
+
+export const confirmCancellationReleaseOrder = {
+  async confirmCancellationReleaseOrder(_: any, { name }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_CANCEL },
+      relations: [
+        'bizplace',
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.inventory.location',
+        'orderVass'
+      ]
+    })
+
+    if (!releaseGood) throw new Error(`Release good order doesn't exists.`)
+    let targetOIs: OrderInventory[] = releaseGood.orderInventories
+    let foundOVs: OrderVas[] = releaseGood.orderVass
+
+    // 1. Check Order Inventory status
+    // 1a. separate into three groups, group 1: pending cancel, group 2: picked, group 3: replaced
+    let cancelOIs: OrderInventory[] = _filterOrderInventoriesByStatus(targetOIs, ORDER_INVENTORY_STATUS.PENDING_CANCEL)
+    let pickedOIs: OrderInventory[] = _filterOrderInventoriesByStatus(targetOIs, ORDER_INVENTORY_STATUS.PENDING_REVERSE)
+    let replacedOIs: OrderInventory[] = _filterOrderInventoriesByStatus(targetOIs, ORDER_INVENTORY_STATUS.REPLACED)
+
+    if (pickedOIs && pickedOIs.length) {
+      await Promise.all(
+        pickedOIs.map(async (orderInventory: OrderInventory) => {
+          let inventory: Inventory = orderInventory.inventory
+          let location: Location = inventory?.location
+
+          if (inventory && inventory.id) {
+            await tx
+              .createQueryBuilder()
+              .update(Inventory)
+              .set({
+                qty: () => `COALESCE("qty", 0) + ${orderInventory.releaseQty}`,
+                uomValue: () => `COALESCE("uom_value", 0) + ${orderInventory.releaseUomValue}`,
+                status: INVENTORY_STATUS.STORED,
+                updater: user
+              } as any)
+              .where('id = :id', { id: inventory.id })
+              .execute()
+
+            await generateInventoryHistory(
+              inventory,
+              releaseGood,
+              INVENTORY_TRANSACTION_TYPE.CANCEL_ORDER,
+              orderInventory.releaseQty,
+              orderInventory.releaseUomValue,
+              user,
+              tx
+            )
+          }
+
+          return orderInventory
+        })
+      )
+
+      await tx
+        .getRepository(OrderInventory)
+        //@ts-ignore
+        .update(pickedOIs, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: user } as any)
+    }
+
+    // change status to cancelled for order inventory that has not executed yet and remove locked qty
+    if (cancelOIs && cancelOIs.length) {
+      await Promise.all(
+        cancelOIs.map(async (orderInventory: OrderInventory) => {
+          let inventory: Inventory = orderInventory.inventory
+
+          if (inventory && inventory.id) {
+            await tx
+              .createQueryBuilder()
+              .update(Inventory)
+              .set({
+                lockedQty: () => `COALESCE("locked_qty", 0) - ${orderInventory.releaseQty}`,
+                lockedUomValue: () => `COALESCE("locked_uom_value", 0) - ${orderInventory.releaseUomValue}`,
+                updater: user
+              } as any)
+              .where('id = :id', { id: inventory.id })
+              .execute()
+
+            // @ChrisLim-git commented for further review as it causes qty to add into inventory
+            // await tx
+            //   .createQueryBuilder()
+            //   .update(Inventory)
+            //   .set({
+            //     qty: () => `COALESCE("qty", 0) + ${orderInventory.releaseQty}`,
+            //     uomValue: () => `COALESCE("uom_value", 0) + ${orderInventory.releaseUomValue}`,
+            //     status: INVENTORY_STATUS.STORED,
+            //     updater: user
+            //   })
+            //   .where('id = :id', { id: inventory.id })
+            //   .execute()
+          }
+
+          return orderInventory
+        })
+      )
+
+      await tx
+        .getRepository(OrderInventory)
+        //@ts-ignore
+        .update(cancelOIs, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: user } as any)
+    }
+
+    if (replacedOIs && replacedOIs.length) {
+      await tx
+        .getRepository(OrderInventory)
+        //@ts-ignore
+        .update(replacedOIs, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: user } as any)
+    }
+
+    if (foundOVs && foundOVs?.length) {
+      // update status of order vass to CANCELLED
+      foundOVs = foundOVs.map((orderVas: OrderVas) => {
+        return {
+          ...orderVas,
+          status: ORDER_VAS_STATUS.CANCELLED,
+          updater: user
+        }
+      })
+      await tx.getRepository(OrderVas).save(foundOVs)
+    }
+
+    // find worksheet and update status to CANCELLED
+    let foundWS: Worksheet[] = await tx
+      .getRepository(Worksheet)
+      .find({ where: { domain: { id: domain.id }, releaseGood: { id: releaseGood.id } } })
+
+    foundWS = foundWS.map((ws: Worksheet) => {
+      return {
+        ...ws,
+        status: ORDER_STATUS.CANCELLED,
+        updater: user
+      }
+    })
+    await tx.getRepository(Worksheet).save(foundWS)
+
+    // find worksheet detail and update status to CANCELLED
+    let foundWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+      where: {
+        domain: { id: domain.id },
+        targetInventory: { id: In(targetOIs.map((oi: OrderInventory) => oi.id)) }
+      }
+    })
+
+    if (foundWSD && foundWSD?.length) {
+      foundWSD = foundWSD.map((wsd: WorksheetDetail) => {
+        return {
+          ...wsd,
+          status: ORDER_STATUS.CANCELLED,
+          updater: user
+        }
+      })
+      await tx.getRepository(WorksheetDetail).save(foundWSD)
+    }
+
+    // find DO and change status to pending cancel
+    let foundDO: DeliveryOrder[] = await tx.getRepository(DeliveryOrder).find({
+      where: { domain: { id: domain.id }, releaseGood: { id: releaseGood.id }, status: ORDER_STATUS.PENDING_CANCEL },
+      relations: ['transportVehicle']
+    })
+
+    if (foundDO && foundDO?.length) {
+      foundDO = foundDO.map((deliveryOrder: DeliveryOrder) => {
+        return {
+          ...deliveryOrder,
+          status: ORDER_STATUS.CANCELLED,
+          updater: user
+        }
+      })
+      await tx.getRepository(DeliveryOrder).save(foundDO)
+    }
+
+    releaseGood.status = ORDER_STATUS.CANCELLED
+    releaseGood.updater = user
+    await tx.getRepository(ReleaseGood).save(releaseGood)
+
+    return
+  }
+}
+
+function _filterOrderInventoriesByStatus(orderInventories: OrderInventory[], status: string): OrderInventory[] {
+  return orderInventories
+    .filter((oi: OrderInventory) => oi.status === status)
+    .reduce((acc, oi) => {
+      let existingInvIdx = !oi.inventory ? -1 : acc.findIndex(i => i.inventory?.id == oi.inventory?.id)
+      if (existingInvIdx >= 0) {
+        acc[existingInvIdx].releaseQty += oi.releaseQty
+        acc[existingInvIdx].releaseUomValue += oi.releaseQty
+      } else {
+        acc.push(oi)
+      }
+      return acc
+    }, [])
+}

package/server/graphql/resolvers/worksheet/create-worksheet.ts

@@ -0,0 +1,21 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { Worksheet } from '../../../entities'
+
+export const createWorksheet = {
+  async createWorksheet(_: any, { worksheet }, context: ResolverContext) {
+    const { tx, domain, bizplace, user } = context.state
+
+    return await tx.getRepository(Worksheet).save({
+      ...worksheet,
+      domain: domain,
+      bizplace: bizplace[0],
+      creator: user,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/worksheet/cross-dock-picking.ts

@@ -0,0 +1,173 @@
+import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderInventory, OrderNoGenerator, ReleaseGood } from '@things-factory/sales-base'
+import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { WorksheetController } from '../../../controllers/worksheet-controller'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { picking } from './picking/picking'
+
+export const crossDockPickingResolver = {
+  async crossDockPicking(
+    _: any,
+    {
+      worksheetDetailName,
+      worksheetType,
+      palletId,
+      releaseQty
+    }: { worksheetDetailName: string; worksheetType: string; palletId: string; releaseQty: number },
+    context: any
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
+    const wsd: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
+      where: { domain: { id: domain.id }, name: worksheetDetailName },
+      relations: [
+        'targetInventory',
+        'targetInventory.domain',
+        'targetInventory.bizplace',
+        'targetInventory.releaseGood',
+        'targetInventory.product',
+        'worksheet',
+        'worksheet.releaseGood',
+        'worksheet.releaseGood.arrivalNotice'
+      ]
+    })
+
+    if (!wsd) throw new Error(`Failed to find picking worksheet detail by passed worksheet detail name`)
+    const worksheet: Worksheet = wsd.worksheet
+    const releaseGood: ReleaseGood = worksheet.releaseGood
+
+    let targetInv: OrderInventory = wsd.targetInventory
+    const bizplace: Bizplace = targetInv.bizplace
+    let inventory: Inventory = await tx.getRepository(Inventory).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: bizplace.id },
+        palletId,
+        status: In([INVENTORY_STATUS.STORED, INVENTORY_STATUS.PARTIALLY_UNLOADED, INVENTORY_STATUS.UNLOADED])
+      },
+      relations: ['product', 'location']
+    })
+
+    if (!inventory) throw new Error(`Failed to find inventory by passed pallet ID (${palletId})`)
+    const hasSameCondition: boolean =
+      inventory.batchId === targetInv.batchId &&
+      inventory.product.id === targetInv.product.id &&
+      inventory.packingType === targetInv.packingType
+    if (!hasSameCondition) throw new Error(`Pallet (${palletId}) doesn't have same condition compared with order has`)
+    if (inventory.qty < releaseQty) throw new Error(`Release qty is bigger than what pallet has`)
+    if (targetInv.releaseQty < releaseQty) throw new Error(`Release qty is bigger than required qty`)
+
+    const unitUomValue: number = inventory.uomValue / inventory.qty
+    const releaseUomValue: number = releaseQty * unitUomValue
+    const remainQty: number = targetInv.releaseQty - releaseQty
+    const remainUomValue: number = targetInv.releaseUomValue - releaseUomValue
+
+    const originWSD: WorksheetDetail = await fetchOriginalWSD(
+      tx,
+      domain.id,
+      releaseGood.id,
+      targetInv.batchId,
+      targetInv.packingType,
+      targetInv.product.id,
+      inventory.id
+    )
+
+    if (!originWSD) {
+      // Update target inventory information
+      // 1. update release amount
+      // 2. assign inventory
+      targetInv.releaseQty = releaseQty
+      targetInv.releaseUomValue = releaseUomValue
+
+      targetInv.inventory = inventory
+      targetInv = await tx.getRepository(OrderInventory).save(targetInv)
+
+      if (remainQty > 0 || remainUomValue > 0) {
+        // Need to create order inventory and worksheet detail without inventory assignment
+        let targetInventory: OrderInventory = tx.getRepository(OrderInventory).create(targetInv)
+        //@ts-ignore
+        delete targetInventory.id
+        targetInventory.name = OrderNoGenerator.orderInventory()
+        targetInventory.releaseQty = remainQty
+        targetInventory.releaseUomValue = remainUomValue
+        targetInventory.inventory = null
+        targetInventory.creator = user
+        targetInventory.updater = user
+        targetInventory = await tx.getRepository(OrderInventory).save(targetInventory)
+
+        const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
+        await worksheetController.createWorksheetDetails(worksheet, WORKSHEET_TYPE.PICKING, [targetInventory], {
+          status: WORKSHEET_STATUS.EXECUTING
+        })
+      }
+    } else {
+      let { targetInventory: originOrdInv } = await tx.getRepository(WorksheetDetail).findOne({
+        where: { id: originWSD.id },
+        relations: ['targetInventory']
+      })
+      originOrdInv.releaseQty += releaseQty
+      originOrdInv.releaseUomValue += releaseUomValue
+      originOrdInv.updater = user
+      await tx.getRepository(OrderInventory).save(originOrdInv)
+
+      targetInv.releaseQty -= releaseQty
+      targetInv.releaseUomValue -= releaseUomValue
+      targetInv.updater = user
+
+      if (targetInv.releaseQty === 0 || targetInv.releaseUomValue === 0) {
+        // Delete worksheet detail
+        await tx.getRepository(WorksheetDetail).delete(wsd.id)
+        // Delete order inventory
+        await tx.getRepository(OrderInventory).delete(targetInv.id)
+      } else {
+        await tx.getRepository(OrderInventory).save(targetInv)
+      }
+    }
+
+    await picking(
+      tx,
+      domain,
+      user,
+      worksheetDetailName,
+      worksheetType,
+      inventory.palletId,
+      inventory.location.name,
+      releaseQty
+    )
+  }
+}
+
+export async function fetchOriginalWSD(
+  tx: EntityManager,
+  domainId: string,
+  releaseGoodId: string,
+  batchId: string,
+  packingType: string,
+  productId: string,
+  inventoryId: string
+): Promise<WorksheetDetail> {
+  let qb: SelectQueryBuilder<WorksheetDetail> = tx.createQueryBuilder(WorksheetDetail, 'wsd')
+  return qb
+    .leftJoin(OrderInventory, 'oi', 'wsd.target_inventory_id = oi.id')
+    .leftJoin(Inventory, 'inv', 'oi.inventory_id = inv.id')
+    .andWhere('wsd.domain_id = :domainId')
+    .andWhere('wsd.status = :status')
+    .andWhere('oi.release_good_id = :releaseGoodId')
+    .andWhere('oi.batch_id = :batchId')
+    .andWhere('oi.packing_type = :packingType')
+    .andWhere('oi.product_id = :productId')
+    .andWhere('inv.id = :inventoryId')
+    .setParameters({
+      domainId,
+      status: WORKSHEET_STATUS.DONE,
+      releaseGoodId,
+      batchId,
+      packingType,
+      productId,
+      inventoryId
+    })
+    .getOne()
+}