@things-factory/worksheet-base 4.3.75 → 4.3.78

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

@@ -1,6 +1,7 @@
 import { EntityManager, In } from 'typeorm'
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
+import { logger } from '@things-factory/env'
 import {
   ORDER_INVENTORY_STATUS,
   ORDER_STATUS,
@@ -16,236 +17,120 @@ import { Worksheet, WorksheetDetail } from '../../../entities'
 export const rejectCancellationReleaseOrder = {
   async rejectCancellationReleaseOrder(_: any, { name }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    let foundRO: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: { domain, name, status: ORDER_STATUS.PENDING_CANCEL },
-      relations: [
-        'bizplace',
-        'orderInventories',
-        'orderInventories.inventory',
-        'orderInventories.inventory.location',
-        'orderInventories.deliveryOrder',
-        'orderVass'
-      ]
-    })
 
-    if (!foundRO) throw new Error(`Release order doesn't exists.`)
-    let targetOIs: OrderInventory[] = foundRO.orderInventories
-    let foundOVs: OrderVas[] = foundRO.orderVass
-    let isDeactivatedPicking = false
-
-    foundRO.status = ORDER_STATUS.PENDING_WORKSHEET
-    // get the worksheet based on RO number
-    let foundWS: Worksheet[] = await tx.getRepository(Worksheet).find({
-      where: {
-        domain,
-        releaseGood: foundRO
-      }
-    })
 
-    // check worksheet table if started_at is not null to indicate that the worksheet has been activated 
-    if (foundWS && foundWS?.length) {
-      foundWS = foundWS.map((ws: Worksheet) => {
-        if (ws.startedAt && !ws.endedAt) {
-          return {
-            ...ws,
-            status: WORKSHEET_STATUS.EXECUTING,
-            updater: user
-          }
-        }
-        else if (ws.startedAt && ws.endedAt) {
-          return {
-            ...ws,
-            status: WORKSHEET_STATUS.DONE,
-            updater: user
-          }
-        }
-        else if (!ws.startedAt && !ws.endedAt && ws.type === WORKSHEET_TYPE.PICKING) {
-          isDeactivatedPicking = true
-          return {
-            ...ws,
-            status: WORKSHEET_STATUS.DEACTIVATED,
-            updater: user
-          }
-        }
+    try {
+      // find release order
+      let foundRO: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: { domain, name, status: ORDER_STATUS.PENDING_CANCEL },
+        relations: [
+          'bizplace',
+          'orderInventories',
+          'orderInventories.inventory',
+          'orderInventories.inventory.location',
+          'orderInventories.deliveryOrder',
+          'orderVass'
+        ]
       })
-      await tx.getRepository(Worksheet).save(foundWS)
-    }
-
-    // check if the worksheet is in Loading stage
-    const isLoadingStage = foundWS.some((ws: Worksheet) => ws.type === WORKSHEET_TYPE.LOADING)
-
-    // change the order inventory status accordingly
-    let newOrderInventories: OrderInventory[] = targetOIs.map(
-      (oi: OrderInventory) => {
-        if (isLoadingStage && oi.deliveryOrder && oi.status === ORDER_INVENTORY_STATUS.PENDING_REVERSE)
-          oi.status = ORDER_INVENTORY_STATUS.LOADED
-
-        else if (isLoadingStage && !oi.deliveryOrder && oi.status === ORDER_INVENTORY_STATUS.PENDING_REVERSE)
-          oi.status = ORDER_INVENTORY_STATUS.LOADING
-
-        else if (!isLoadingStage && oi.inventory && isDeactivatedPicking && oi.status === ORDER_INVENTORY_STATUS.PENDING_CANCEL)
-          oi.status = ORDER_INVENTORY_STATUS.READY_TO_PICK
-
-        else if (!isLoadingStage && oi.inventory && !isDeactivatedPicking && oi.status === ORDER_INVENTORY_STATUS.PENDING_CANCEL)
-          oi.status = ORDER_INVENTORY_STATUS.PICKING
-
-        else if (!isLoadingStage && oi.inventory && !isDeactivatedPicking && oi.status === ORDER_INVENTORY_STATUS.PENDING_REVERSE)
-          oi.status = ORDER_INVENTORY_STATUS.PICKED
 
-        else if (!isLoadingStage && !oi.inventory && isDeactivatedPicking && oi.status === ORDER_INVENTORY_STATUS.PENDING_CANCEL)
-          oi.status = ORDER_INVENTORY_STATUS.PENDING_SPLIT
-
-        return {
-          ...oi,
-          updater: user
-        }
-      })
-    await tx.getRepository(OrderInventory).save(newOrderInventories)
-
-    // find the worksheet details based on order inventories
-    let foundWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-      where: {
-        domain,
-        targetInventory: In(newOrderInventories.map((oi: OrderInventory) => oi.id))
-      },
-      relations: ['targetInventory']
-    })
-
-    if (foundWSD && foundWSD?.length) {
-      foundWSD = foundWSD.map((wsd: WorksheetDetail) => {
-
-        //change the worksheet details status accordingly
-        newOrderInventories.forEach((oi: OrderInventory) => {
-
-          if (wsd.targetInventory?.id === oi.id && wsd.type === WORKSHEET_TYPE.PICKING) {
-            switch (oi.status) {
-              case ORDER_INVENTORY_STATUS.READY_TO_PICK:
-                wsd.status = WORKSHEET_STATUS.DEACTIVATED
-                break
-
-              case ORDER_INVENTORY_STATUS.PICKING:
-                wsd.status = WORKSHEET_STATUS.EXECUTING
-                break
-
-              case ORDER_INVENTORY_STATUS.REPLACED:
-                wsd.status = WORKSHEET_STATUS.REPLACED
-                break
-
-              case ORDER_INVENTORY_STATUS.PICKED:
-                wsd.status = WORKSHEET_STATUS.DONE
-                break
-
-              case ORDER_INVENTORY_STATUS.LOADING:
-                wsd.status = WORKSHEET_STATUS.DONE
-                break
-
-              case ORDER_INVENTORY_STATUS.LOADED:
-                wsd.status = WORKSHEET_STATUS.DONE
-                break
-            }
+      if (!foundRO) throw new Error(`Release order doesn't exists.`)
+
+      let targetOIs: OrderInventory[] = foundRO.orderInventories
+
+      // perform update on all order inventories and worksheet
+      let worksheetDetails = await Promise.all(targetOIs.map(async (orderInventory) => {
+        let existingWorksheetDetail: WorksheetDetail = await tx.getRepository(WorksheetDetail).createQueryBuilder('wd')
+          .innerJoinAndSelect('wd.worksheet', 'ws')
+          .where('wd.target_inventory_id = :orderInventoryId', { orderInventoryId: orderInventory.id })
+          .orderBy('ws.created_at', 'DESC')
+          .addOrderBy('wd.name')
+          .getOne()
+
+        if (existingWorksheetDetail) {
+          const startedAt = existingWorksheetDetail.worksheet.startedAt
+          const wdType = existingWorksheetDetail.worksheet.type
+          let wdStatus, oiStatus, roStatus, wStatus
+          switch (wdType) {
+            case 'PICKING':
+            case 'BATCH_PICKING':
+              wdStatus = !startedAt ? WORKSHEET_STATUS.DEACTIVATED : orderInventory.pickedQty == orderInventory.releaseQty ? WORKSHEET_STATUS.DONE : WORKSHEET_STATUS.EXECUTING
+              oiStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_PICK : orderInventory.pickedQty == orderInventory.releaseQty ? ORDER_INVENTORY_STATUS.PICKED : ORDER_INVENTORY_STATUS.PICKING
+              roStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_PICK : ORDER_INVENTORY_STATUS.PICKING
+              break;
+            case 'PACKING':
+              wdStatus = !startedAt ? WORKSHEET_STATUS.DEACTIVATED : orderInventory.packedQty == orderInventory.releaseQty ? WORKSHEET_STATUS.DONE : WORKSHEET_STATUS.EXECUTING
+              oiStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_PACK : orderInventory.packedQty == orderInventory.releaseQty ? ORDER_INVENTORY_STATUS.PACKED : ORDER_INVENTORY_STATUS.PACKING
+              roStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_PACK : ORDER_INVENTORY_STATUS.PACKING
+              break;
+            case 'SORTING':
+              wdStatus = !startedAt ? WORKSHEET_STATUS.DEACTIVATED : orderInventory.sortedQty == orderInventory.releaseQty ? WORKSHEET_STATUS.DONE : WORKSHEET_STATUS.EXECUTING
+              oiStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_SORT : orderInventory.sortedQty == orderInventory.releaseQty ? ORDER_INVENTORY_STATUS.PICKED : ORDER_INVENTORY_STATUS.SORTING
+              roStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_SORT : ORDER_INVENTORY_STATUS.SORTING
+              break;
+            case 'LOADING':
+              wdStatus = !startedAt ? WORKSHEET_STATUS.DEACTIVATED : orderInventory?.deliveryOrder ? WORKSHEET_STATUS.DONE : WORKSHEET_STATUS.EXECUTING
+              oiStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_LOAD : orderInventory?.deliveryOrder ? ORDER_INVENTORY_STATUS.LOADED : ORDER_INVENTORY_STATUS.LOADING
+              roStatus = !startedAt ? ORDER_INVENTORY_STATUS.READY_TO_LOAD : ORDER_INVENTORY_STATUS.LOADING
+              break;
+            default:
+              break;
           }
 
-          else if (wsd.targetInventory?.id === oi.id && wsd.type === WORKSHEET_TYPE.LOADING) {
-            switch (oi.status) {
-              case ORDER_INVENTORY_STATUS.LOADING:
-                wsd.status = WORKSHEET_STATUS.EXECUTING
-                break
+          wStatus = !startedAt ? WORKSHEET_STATUS.DEACTIVATED : WORKSHEET_STATUS.EXECUTING
 
-              case ORDER_INVENTORY_STATUS.LOADED:
-                wsd.status = WORKSHEET_STATUS.DONE
-                break
-            }
-          }
-        })
+          await tx.getRepository(WorksheetDetail).update({ id: existingWorksheetDetail.id }, { status: wdStatus, updatedAt: new Date(), updater: user })
+          await tx.getRepository(OrderInventory).update({ id: orderInventory.id }, { status: oiStatus, updatedAt: new Date(), updater: user })
 
-        return {
-          ...wsd,
-          updater: user
+          return { worksheet: existingWorksheetDetail.worksheet, wStatus, roStatus }
+        } else {
+          await tx.getRepository(OrderInventory).update({ id: orderInventory.id }, { status: ORDER_INVENTORY_STATUS.PENDING_WORKSHEET, updatedAt: new Date(), updater: user })
+          return { worksheet: null, wStatus: null, roStatus: ORDER_STATUS.PENDING_WORKSHEET }
         }
-      })
-
-      await tx.getRepository(WorksheetDetail).save(foundWSD)
-    }
+      }))
 
-    if (foundOVs && foundOVs?.length) {
-
-      // update status of order vass to accordingly
-      foundOVs = foundOVs.map((orderVas: OrderVas) => {
-        if (!isLoadingStage)
-          orderVas.status = ORDER_VAS_STATUS.READY_TO_PROCESS
-
-        else
-          orderVas.status = ORDER_VAS_STATUS.COMPLETED
-
-        return {
-          ...orderVas,
+      if (worksheetDetails[0].worksheet) {
+        await tx.getRepository(Worksheet).update({ id: worksheetDetails[0].worksheet.id }, {
+          status: worksheetDetails[0].wStatus,
+          updatedAt: new Date(),
           updater: user
-        }
-      })
-
-      await tx.getRepository(OrderVas).save(foundOVs)
-    }
-
-    // find DO and change status to previous status
-    let foundDO: DeliveryOrder[] = await tx.getRepository(DeliveryOrder).find({
-      where: { domain, releaseGood: foundRO, status: ORDER_STATUS.PENDING_CANCEL },
-      relations: ['transportVehicle']
-    })
+        })
+      }
 
-    if (foundDO && foundDO?.length) {
-      foundDO = foundDO.map((deliveryOrder: DeliveryOrder) => {
-        return {
-          ...deliveryOrder,
-          status: ORDER_STATUS.READY_TO_DISPATCH,
-          updater: user
-        }
+      await tx.getRepository(ReleaseGood).update({ id: foundRO.id }, {
+        status: worksheetDetails[0].roStatus,
+        updatedAt: new Date(),
+        updater: user
       })
-      await tx.getRepository(DeliveryOrder).save(foundDO)
-    }
-
-    const isLoadingRO = foundWS.some((ws: Worksheet) =>
-      ws.type === WORKSHEET_TYPE.LOADING &&
-      ws.status === WORKSHEET_STATUS.EXECUTING
-    )
-
-    if (isLoadingRO)
-      foundRO.status = ORDER_STATUS.LOADING
 
-    else {
-      var isReadyToLoadRO = foundWS.some((ws: Worksheet) =>
-        ws.type === WORKSHEET_TYPE.LOADING &&
-        ws.status === WORKSHEET_STATUS.DEACTIVATED
-      )
-    }
-
-    if (isReadyToLoadRO)
-      foundRO.status = ORDER_STATUS.READY_TO_LOAD
+      // reverse DO status
+      await reverseDO(foundRO, context)
 
-    else {
-      var isPickingRO = foundWS.some((ws: Worksheet) =>
-        ws.type === WORKSHEET_TYPE.PICKING &&
-        ws.status === WORKSHEET_STATUS.EXECUTING
-      )
+      return
+    } catch (error) {
+      logger.error(`reject-cancellation-release-order[rejectCancellationReleaseOrder]:(data:${JSON.stringify({ name, tx, domain, user })}) ${error}`)
+      throw new Error('Something went wrong. Please contact support.')
     }
+  }
+}
 
-    if (isPickingRO)
-      foundRO.status = ORDER_STATUS.PICKING
-
-    else {
-      var isReadyToPickRO = foundWS.some((ws: Worksheet) =>
-        ws.type === WORKSHEET_TYPE.PICKING &&
-        ws.status === WORKSHEET_STATUS.DEACTIVATED
-      )
-    }
-
-    if (isReadyToPickRO)
-      foundRO.status = ORDER_STATUS.READY_TO_PICK
-
-    await tx.getRepository(ReleaseGood).save({
-      ...foundRO,
-      updater: user
+async function reverseDO(releaseGood: ReleaseGood, context: any) {
+  const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+  // find DO and change status to previous status
+  let foundDO: DeliveryOrder[] = await tx.getRepository(DeliveryOrder).find({
+    where: { domain, releaseGood, status: ORDER_STATUS.PENDING_CANCEL },
+    relations: ['transportVehicle']
+  })
+  if (foundDO && foundDO?.length) {
+    foundDO = foundDO.map((deliveryOrder: DeliveryOrder) => {
+      return {
+        ...deliveryOrder,
+        status: ORDER_STATUS.READY_TO_DISPATCH,
+        updater: user
+      }
     })
 
-    return
+    await tx.getRepository(DeliveryOrder).save(foundDO)
   }
-}
+
+}

package/server/graphql/types/worksheet/index.ts

@@ -25,6 +25,7 @@ import { WorksheetList } from './worksheet-list'
 import { WorksheetPatch } from './worksheet-patch'
 import { WorksheetWithPagination } from './worksheet-with-pagination'
 import { GenerateBatchPickInfo } from './batch-pick-worksheet-info'
+import { MultipleReleaseGoodWorksheet } from './multiple-release-good-worksheet'
 
 export const Mutation = /* GraphQL */ `
   createWorksheet (
@@ -62,10 +63,11 @@ export const Mutation = /* GraphQL */ `
 
   generateReleaseGoodWorksheet (
     releaseGoodNo: String!
+    currentStatus: String
   ): ReleaseGoodWorksheet @privilege(category: "worksheet_control", privilege: "mutation") @transaction
 
   generateMultipleReleaseGoodWorksheet (
-    releaseGoodNos: [String!]
+    releaseGoods: [MultipleReleaseGoodWorksheet!]
   ): Boolean @privilege(category: "worksheet_control", privilege: "mutation") @transaction
 
   fetchSellercraftDocument (
@@ -743,5 +745,6 @@ export const Types = /* GraphQL */[
   MyPickingAssignmentStatus,
   FindReleaseOrdersByTaskNo,
   DeliveryOrderRO,
-  GenerateBatchPickInfo
+  GenerateBatchPickInfo,
+  MultipleReleaseGoodWorksheet
 ]

package/server/graphql/types/worksheet/multiple-release-good-worksheet.ts

@@ -0,0 +1,8 @@
+import { gql } from 'apollo-server-koa'
+
+export const MultipleReleaseGoodWorksheet = gql`
+  input MultipleReleaseGoodWorksheet {
+    name: String
+    status: String
+  }
+`

package/server/utils/worksheet-util.ts

@@ -41,7 +41,9 @@ export async function fetchExecutingWorksheet(
   } else if (worksheet.status === WORKSHEET_STATUS.DONE) {
     throw new Error(`Worksheet is completed already`)
   } else if (worksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
-    throw new Error(`Worksheet is not activated yet`)
+    //@oscarchuaweiwen-fsd this function is being used in quite some place, for packing worksheet you have handled the status DEACTIVATED, but for loading worksheet it's not being handled
+    //won't there be issue if it doesn't throw error for places that didnt handle the status DEACTIVATED?
+    return worksheet
   } else {
     throw new Error(`Current worksheet status (${worksheet.status}) is not proper to execute it.`)
   }