@things-factory/worksheet-base 4.3.156 → 4.3.157

package/server/graphql/resolvers/worksheet/picking/complete-picking.ts

@@ -1,4 +1,4 @@
-import { EntityManager, getManager, In } from 'typeorm'
+import { EntityManager, getManager } from 'typeorm'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint, getMyBizplace } from '@things-factory/biz-base'
@@ -33,7 +33,6 @@ import {
   PickingWorksheetController,
   SellercraftController
 } from '../../../../controllers/'
-import { Inventory } from '@things-factory/warehouse-base'
 import { EcommerceController } from '../../../../controllers/ecommerce'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
@@ -60,7 +59,7 @@ export async function completePicking(
   domain: Domain,
   user: User,
   releaseGoodNo: string
-): Promise<any> {
+): Promise<void> {
   const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
     where: { domain, name: releaseGoodNo },
@@ -81,8 +80,7 @@ export async function completePicking(
 
   const worksheet: Worksheet = await pickingWSCtrl.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PICKING, [
     'worksheetDetails',
-    'worksheetDetails.targetInventory',
-    'worksheetDetails.targetInventory.inventory'
+    'worksheetDetails.targetInventory'
   ])
 
   const warehouseContactPoint: ContactPoint = await tx.getRepository(ContactPoint).findOne({
@@ -94,287 +92,267 @@ export async function completePicking(
 
   const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
   const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
-  const inventories: Inventory[] = targetInventories.map((ti: OrderInventory) => ti.inventory)
   const pickedTargetInventories: OrderInventory[] = targetInventories.filter(
     targetInventory => targetInventory.status === ORDER_INVENTORY_STATUS.PICKED
   )
 
-  let foundObsoleteInventories = await pickingWSCtrl.completePicking(releaseGood, worksheet, inventories)
-
-  if (foundObsoleteInventories?.type) {
-    const orderSource: string = releaseGood.source
-    switch (orderSource) {
-      case ApplicationType.SELLERCRAFT:
-        const sellercraft: Sellercraft = await tx
-          .getRepository(Sellercraft)
-          .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
-
-        if (sellercraft) {
-          const initSCOrderShipment = async sellercraft => {
-            await getManager().transaction(async txMgr => {
-              const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
-
-              if (!releaseGood?.orderPackages?.length && !releaseGood?.marketPackCallSuccess) {
-                const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
-                  where: { releaseGood },
-                  relations: ['product', 'product.productDetails']
-                })
-                await sellercraftCtrl.packOrder(sellercraft, { ...releaseGood, orderProducts })
-              }
+  await pickingWSCtrl.completePicking(releaseGoodNo)
+
+  const orderSource: string = releaseGood.source
+  switch (orderSource) {
+    case ApplicationType.SELLERCRAFT:
+      const sellercraft: Sellercraft = await tx
+        .getRepository(Sellercraft)
+        .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
-              const rtsTriggerLevel: Setting = await txMgr.getRepository(Setting).findOne({
-                where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
+      if (sellercraft) {
+        const initSCOrderShipment = async sellercraft => {
+          await getManager().transaction(async txMgr => {
+            const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
+
+            if (!releaseGood?.orderPackages?.length && !releaseGood?.marketPackCallSuccess) {
+              const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
+                where: { releaseGood },
+                relations: ['product', 'product.productDetails']
               })
+              await sellercraftCtrl.packOrder(sellercraft, { ...releaseGood, orderProducts })
+            }
 
-              if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-                await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
-              }
+            const rtsTriggerLevel: Setting = await txMgr.getRepository(Setting).findOne({
+              where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
             })
-          }
-          // asynchronouly call to initiate sellercraft order shipment/ RTS
-          initSCOrderShipment(sellercraft)
+
+            if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
+              await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+            }
+          })
         }
-        break
-
-      case ApplicationType.MMS:
-        const companyDomain: Domain = releaseGood.bizplace.company.domain
-        let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-          where: { orderNo: releaseGood.refNo, domain: companyDomain },
-          relations: [
-            'marketplaceStore',
-            'marketplaceStore.marketplaceDistributors',
-            'marketplaceOrderItems',
-            'marketplaceOrderItems.marketplaceOrderShippingItems',
-            'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
-          ]
-        })
-
-        if (marketplaceOrder) {
-          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-          const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-          let eTraxOption: boolean
-
-          if (marketplaceStore?.isAutoUpdateShipment) {
-            await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PACKING)
-
-            await ecommerceCtrl.createOrderShip(releaseGood, marketplaceStore, marketplaceOrder, companyDomain)
-          }
+        // asynchronouly call to initiate sellercraft order shipment/ RTS
+        initSCOrderShipment(sellercraft)
+      }
+      break
+
+    case ApplicationType.MMS:
+      const companyDomain: Domain = releaseGood.bizplace.company.domain
+      let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { orderNo: releaseGood.refNo, domain: companyDomain },
+        relations: [
+          'marketplaceStore',
+          'marketplaceStore.marketplaceDistributors',
+          'marketplaceOrderItems',
+          'marketplaceOrderItems.marketplaceOrderShippingItems',
+          'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
+        ]
+      })
 
-          if (!marketplaceOrder) {
-            throw new Error('Failed to find ecommerce order, kindly contact our support team regarding this issue')
-          }
+      if (marketplaceOrder) {
+        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+        const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+        let eTraxOption: boolean
 
-          eTraxOption = marketplaceOrder?.marketplaceStore.eTrax
-
-          // if eTrax option is true
-          if (eTraxOption) {
-            const marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
-
-            // access every marketplaceOrderItems for shipping information you need
-            // trigger the controller from integration-lmd that trigger the API, build the parameters needed
-            // for etrax didn't support multi awb per order
-            const marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] =
-              marketplaceOrderItems[0].marketplaceOrderShippingItems
-            const marketplaceOrderShipping: MarketplaceOrderShipping =
-              marketplaceOrderShippingItems[0].marketplaceOrderShipping
-            const lmd: LastMileDelivery = await tx.getRepository(LastMileDelivery).findOne({
-              where: {
-                domain,
-                platform: 'eTrax'
-              }
-            })
+        if (marketplaceStore?.isAutoUpdateShipment) {
+          await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PACKING)
 
-            //Get which transporter to use
-            const marketplaceTransporter: MarketplaceTransporter = await tx
-              .getRepository(MarketplaceTransporter)
-              .findOne({
-                where: { marketplaceStore: marketplaceOrder.marketplaceStore },
-                relations: ['pickupTransporter', 'deliveryTransporter']
-              })
+          await ecommerceCtrl.createOrderShip(releaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+        }
 
-            const resp = await LastMileAPI.createShipmentRequest(lmd, {
-              orderNo: marketplaceOrder.orderNo,
-              clientId: lmd.clientId,
-              clientType: lmd.clientType,
-              clientName: lmd.clientName,
-              transporterId: marketplaceTransporter.pickupTransporter.transporterId,
-              pickupName: warehouseContactPoint.name,
-              pickupAddress1: warehouseContactPoint.address,
-              pickupAddress2: warehouseContactPoint.address2,
-              pickupPostcode: warehouseContactPoint.postCode,
-              pickupState: warehouseContactPoint.state,
-              pickupCity: warehouseContactPoint.city,
-              pickupPhone: warehouseContactPoint.phone,
-              pickupEmail: warehouseContactPoint.email,
-              name: marketplaceOrderShipping?.attentionTo ? marketplaceOrderShipping.attentionTo.trim() : '',
-              address1: marketplaceOrderShipping?.address1 ? marketplaceOrderShipping?.address1.trim() : '-',
-              address2: marketplaceOrderShipping?.address2 ? marketplaceOrderShipping?.address2.trim() : '-',
-              postCode: marketplaceOrderShipping?.postCode ? marketplaceOrderShipping?.postCode.trim() : '',
-              city: marketplaceOrderShipping?.city ? marketplaceOrderShipping?.city.trim() : '',
-              state: marketplaceOrderShipping?.state ? marketplaceOrderShipping?.state.trim() : '',
-              phone: marketplaceOrderShipping.phone1 || '',
-              email: marketplaceOrderShipping.email || '',
-              attentionTo: marketplaceOrderShipping.attentionTo,
-              quantity: marketplaceOrderItems.length
-            })
+        if (!marketplaceOrder) {
+          throw new Error('Failed to find ecommerce order, kindly contact our support team regarding this issue')
+        }
 
-            const delay = (ms: number) => {
-              return new Promise(resolve => setTimeout(resolve, ms))
+        eTraxOption = marketplaceOrder?.marketplaceStore.eTrax
+
+        // if eTrax option is true
+        if (eTraxOption) {
+          const marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
+
+          // access every marketplaceOrderItems for shipping information you need
+          // trigger the controller from integration-lmd that trigger the API, build the parameters needed
+          // for etrax didn't support multi awb per order
+          const marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] =
+            marketplaceOrderItems[0].marketplaceOrderShippingItems
+          const marketplaceOrderShipping: MarketplaceOrderShipping =
+            marketplaceOrderShippingItems[0].marketplaceOrderShipping
+          const lmd: LastMileDelivery = await tx.getRepository(LastMileDelivery).findOne({
+            where: {
+              domain,
+              platform: 'eTrax'
             }
+          })
+
+          //Get which transporter to use
+          const marketplaceTransporter: MarketplaceTransporter = await tx
+            .getRepository(MarketplaceTransporter)
+            .findOne({
+              where: { marketplaceStore: marketplaceOrder.marketplaceStore },
+              relations: ['pickupTransporter', 'deliveryTransporter']
+            })
 
-            if (resp.Status === 'SUCCESS') {
-              //Success
-              let awbObtained = false
-              let retry = 0
-              while (!awbObtained) {
-                const marketplaceOrder2: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-                  where: { releaseOrderId: releaseGood.id },
-                  relations: [
-                    'marketplaceStore',
-                    'marketplaceOrderItems',
-                    'marketplaceOrderItems.marketplaceOrderShippingItems',
-                    'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
-                  ]
-                })
-                const orderShipping =
-                  marketplaceOrder2.marketplaceOrderItems[0].marketplaceOrderShippingItems[0].marketplaceOrderShipping
-                if (orderShipping?.airwayBill) {
-                  awbObtained = true
-                }
-                await delay(5000)
-                //Timeout after 15sec
-                if (++retry > 3) {
-                  break
-                }
+          const resp = await LastMileAPI.createShipmentRequest(lmd, {
+            orderNo: marketplaceOrder.orderNo,
+            clientId: lmd.clientId,
+            clientType: lmd.clientType,
+            clientName: lmd.clientName,
+            transporterId: marketplaceTransporter.pickupTransporter.transporterId,
+            pickupName: warehouseContactPoint.name,
+            pickupAddress1: warehouseContactPoint.address,
+            pickupAddress2: warehouseContactPoint.address2,
+            pickupPostcode: warehouseContactPoint.postCode,
+            pickupState: warehouseContactPoint.state,
+            pickupCity: warehouseContactPoint.city,
+            pickupPhone: warehouseContactPoint.phone,
+            pickupEmail: warehouseContactPoint.email,
+            name: marketplaceOrderShipping?.attentionTo ? marketplaceOrderShipping.attentionTo.trim() : '',
+            address1: marketplaceOrderShipping?.address1 ? marketplaceOrderShipping?.address1.trim() : '-',
+            address2: marketplaceOrderShipping?.address2 ? marketplaceOrderShipping?.address2.trim() : '-',
+            postCode: marketplaceOrderShipping?.postCode ? marketplaceOrderShipping?.postCode.trim() : '',
+            city: marketplaceOrderShipping?.city ? marketplaceOrderShipping?.city.trim() : '',
+            state: marketplaceOrderShipping?.state ? marketplaceOrderShipping?.state.trim() : '',
+            phone: marketplaceOrderShipping.phone1 || '',
+            email: marketplaceOrderShipping.email || '',
+            attentionTo: marketplaceOrderShipping.attentionTo,
+            quantity: marketplaceOrderItems.length
+          })
+
+          const delay = (ms: number) => {
+            return new Promise(resolve => setTimeout(resolve, ms))
+          }
+
+          if (resp.Status === 'SUCCESS') {
+            //Success
+            let awbObtained = false
+            let retry = 0
+            while (!awbObtained) {
+              const marketplaceOrder2: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+                where: { releaseOrderId: releaseGood.id },
+                relations: [
+                  'marketplaceStore',
+                  'marketplaceOrderItems',
+                  'marketplaceOrderItems.marketplaceOrderShippingItems',
+                  'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
+                ]
+              })
+              const orderShipping =
+                marketplaceOrder2.marketplaceOrderItems[0].marketplaceOrderShippingItems[0].marketplaceOrderShipping
+              if (orderShipping?.airwayBill) {
+                awbObtained = true
+              }
+              await delay(5000)
+              //Timeout after 15sec
+              if (++retry > 3) {
+                break
               }
-            } else {
-              if (resp?.AWBurl && resp?.TrackingNo)
-                await tx
-                  .getRepository(MarketplaceOrderShipping)
-                  .update({ id: marketplaceOrderShipping.id }, { airwayBill: resp.AWBurl, trackingNo: resp.TrackingNo })
-              else throw resp
             }
+          } else {
+            if (resp?.AWBurl && resp?.TrackingNo)
+              await tx
+                .getRepository(MarketplaceOrderShipping)
+                .update({ id: marketplaceOrderShipping.id }, { airwayBill: resp.AWBurl, trackingNo: resp.TrackingNo })
+            else throw resp
           }
-
-          await ecommerceCtrl.createOrderPackage(tx, marketplaceOrder, companyDomain, marketplaceStore, releaseGood)
         }
-        break
-
-      default:
-        const orderPackage: OrderPackage = {
-          name: OrderNoGenerator.orderPackage(),
-          packageId: null,
-          trackingNo: null,
-          transporter: null,
-          airwayBill: null,
+
+        await ecommerceCtrl.createOrderPackage(tx, marketplaceOrder, companyDomain, marketplaceStore, releaseGood)
+      }
+      break
+
+    default:
+      const orderPackage: OrderPackage = {
+        name: OrderNoGenerator.orderPackage(),
+        packageId: null,
+        trackingNo: null,
+        transporter: null,
+        airwayBill: null,
+        status: ORDER_STATUS.PROCESSING,
+        releaseGood,
+        domain: releaseGood.domain,
+        bizplace: releaseGood.bizplace,
+        creator: releaseGood.creator,
+        updater: releaseGood.updater
+      }
+
+      let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
+      const orderPackageItems: OrderPackageItem[] = releaseGood.orderProducts.map(op => {
+        return {
+          name: OrderNoGenerator.orderPackageItem(),
+          orderProduct: op,
           status: ORDER_STATUS.PROCESSING,
-          releaseGood,
+          releaseQty: op.releaseQty,
+          orderPackage: savedOrderPackage,
           domain: releaseGood.domain,
           bizplace: releaseGood.bizplace,
           creator: releaseGood.creator,
           updater: releaseGood.updater
         }
+      })
 
-        let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
-        const orderPackageItems: OrderPackageItem[] = releaseGood.orderProducts.map(op => {
-          return {
-            name: OrderNoGenerator.orderPackageItem(),
-            orderProduct: op,
-            status: ORDER_STATUS.PROCESSING,
-            releaseQty: op.releaseQty,
-            orderPackage: savedOrderPackage,
-            domain: releaseGood.domain,
-            bizplace: releaseGood.bizplace,
-            creator: releaseGood.creator,
-            updater: releaseGood.updater
-          }
-        })
-
-        await tx.getRepository(OrderPackageItem).save(orderPackageItems)
-        break
-    }
+      await tx.getRepository(OrderPackageItem).save(orderPackageItems)
+      break
+  }
 
-    const account: Account = await tx
-      .getRepository(Account)
-      .findOne({ domain: releaseGood.bizplace.domain, status: 'active' })
-
-    // Xilnex Create Sales Order and Post Sales Order to Sales Invoice
-    const createSalesOrder = async (account, tx) => {
-      if (account) {
-        try {
-          if (account.platform == 'xilnex') {
-            const salesOrder: any = await AccountingAPI.createSalesOrder(account, {
-              releaseGood,
-              orderProducts: releaseGood.orderProducts
+  const account: Account = await tx
+    .getRepository(Account)
+    .findOne({ domain: releaseGood.bizplace.domain, status: 'active' })
+
+  // Xilnex Create Sales Order and Post Sales Order to Sales Invoice
+  const createSalesOrder = async (account, tx) => {
+    if (account) {
+      try {
+        if (account.platform == 'xilnex') {
+          const salesOrder: any = await AccountingAPI.createSalesOrder(account, {
+            releaseGood,
+            orderProducts: releaseGood.orderProducts
+          })
+
+          if (salesOrder) {
+            const salesInvoice: any = await AccountingAPI.postSalesOrderToSalesInvoice(account, {
+              orderId: salesOrder?.id || null
             })
 
-            if (salesOrder) {
-              const salesInvoice: any = await AccountingAPI.postSalesOrderToSalesInvoice(account, {
-                orderId: salesOrder?.id || null
+            const salesOrderItems: any = salesInvoice.sale.items
+            await Promise.all(
+              releaseGood.orderProducts.map(async op => {
+                const matchedProduct: any = salesOrderItems.find(soi => soi.itemId == op.productDetail.refCode)
+                if (matchedProduct) {
+                  await tx.getRepository(OrderProduct).update({ id: op.id }, { refItemId: matchedProduct.id })
+                }
               })
+            )
 
-              const salesOrderItems: any = salesInvoice.sale.items
-              await Promise.all(
-                releaseGood.orderProducts.map(async op => {
-                  const matchedProduct: any = salesOrderItems.find(soi => soi.itemId == op.productDetail.refCode)
-                  if (matchedProduct) {
-                    await tx.getRepository(OrderProduct).update({ id: op.id }, { refItemId: matchedProduct.id })
-                  }
-                })
-              )
-
-              await tx
-                .getRepository(ReleaseGood)
-                .update(
-                  { id: releaseGood.id },
-                  { collectionOrderNo: salesInvoice.salesId, updater: releaseGood.updater }
-                )
-            }
+            await tx
+              .getRepository(ReleaseGood)
+              .update({ id: releaseGood.id }, { collectionOrderNo: salesInvoice.salesId, updater: releaseGood.updater })
           }
-        } catch (error) {
-          logger.error(`complete-picking[createSalesOrder]: ${error}`)
         }
+      } catch (error) {
+        logger.error(`complete-picking[createSalesOrder]: ${error}`)
       }
     }
+  }
 
-    if (releaseGood.type == 'b2c') {
-      await createSalesOrder(account, tx)
-    }
-
-    if (releaseGood.packingOption) {
-      const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-      await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
-    } else {
-      // Find Existing Loading Worksheet if any
-      let existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-        where: {
-          releaseGood,
-          type: WORKSHEET_TYPE.LOADING,
-          status: WORKSHEET_STATUS.DEACTIVATED
-        }
-      })
-
-      if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
-        if (pickedTargetInventories.length > 0) {
-          const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-          let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
-            releaseGoodNo,
-            pickedTargetInventories
-          )
+  if (releaseGood.type == 'b2c') {
+    await createSalesOrder(account, tx)
+  }
 
-          if (!loadingWorksheet.worksheetDetails?.length) {
-            loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
-          }
+  if (releaseGood.packingOption) {
+    const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+    await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+  } else {
+    // Find Existing Loading Worksheet if any
+    let existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        releaseGood,
+        type: WORKSHEET_TYPE.LOADING,
+        status: WORKSHEET_STATUS.DEACTIVATED
+      }
+    })
 
-          const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
-          await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
-        }
-      } else {
+    if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
+      if (pickedTargetInventories.length > 0) {
         const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-        let loadingWorksheet: Worksheet = await loadingWSCtrl.updateLoadingWorksheet(
+        let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
           releaseGoodNo,
-          pickedTargetInventories,
-          existLoadingWorksheet
+          pickedTargetInventories
         )
 
         if (!loadingWorksheet.worksheetDetails?.length) {
@@ -384,33 +362,20 @@ export async function completePicking(
         const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
         await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
       }
-    }
-  } else {
-    //update inventories obsolete to true
-    await tx.getRepository(Inventory).update({ id: In(foundObsoleteInventories) }, { obsolete: true })
+    } else {
+      const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+      let loadingWorksheet: Worksheet = await loadingWSCtrl.updateLoadingWorksheet(
+        releaseGoodNo,
+        pickedTargetInventories,
+        existLoadingWorksheet
+      )
+
+      if (!loadingWorksheet.worksheetDetails?.length) {
+        loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+      }
 
-    foundObsoleteInventories = foundObsoleteInventories
-      .map(inv => {
-        return "'" + inv.trim() + "'"
-      })
-      .join(',')
-
-    //update any orders that is assigned with obsolete inventories
-    await tx.getRepository(ReleaseGood).query(`
-    update release_goods rg set status = 'OBSOLETE' 
-    from order_inventories oi
-    where oi.release_good_id = rg.id
-    and oi.inventory_id in (${foundObsoleteInventories})
-    and rg.status in ('PICKING', 'PENDING_WORKSHEET', 'READY_TO_PICK')`)
-
-    await tx.getRepository(Worksheet).query(`
-    update worksheets w set status = 'DEACTIVATED', updater_id = '${user.id}', assignee_id = null
-    from worksheet_details wd
-    inner join order_inventories oi on oi.id = wd.target_inventory_id
-    where wd.worksheet_id = w.id
-    and oi.inventory_id in (${foundObsoleteInventories})
-    `)
-
-    return false
+      const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
+    }
   }
 }

package/server/graphql/resolvers/worksheet-detail/regenerate-release-good-worksheet-details.ts

@@ -81,23 +81,13 @@ export async function regenerateReleaseGoodWorksheetDetails(
     await Promise.all(
       prevOrderInventories.map(async prevOI => {
         if (prevOI?.inventory) {
-          if (prevOI.pickedQty == prevOI.releaseQty) {
-            await tx.getRepository(Inventory).update(
-              { id: prevOI.inventory.id },
-              {
-                qty: prevOI.inventory.qty + prevOI.pickedQty,
-                uomValue: prevOI.inventory.uomValue + prevOI.pickedUomValue
-              }
-            )
-          } else {
-            await tx.getRepository(Inventory).update(
-              { id: prevOI.inventory.id },
-              {
-                lockedQty: prevOI.inventory.lockedQty - prevOI.releaseQty,
-                lockedUomValue: prevOI.inventory.lockedUomValue - prevOI.releaseUomValue
-              }
-            )
-          }
+          await tx.getRepository(Inventory).update(
+            { id: prevOI.inventory.id },
+            {
+              lockedQty: prevOI.inventory.lockedQty - prevOI.releaseQty,
+              lockedUomValue: prevOI.inventory.lockedUomValue - prevOI.releaseUomValue
+            }
+          )
         }
       })
     )