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

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

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

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

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

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

@@ -1,173 +0,0 @@
-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()
-}