@things-factory/worksheet-base 4.3.155 → 4.3.156

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

@@ -1,4 +1,4 @@
-import { EntityManager, getManager } from 'typeorm'
+import { EntityManager, getManager, In } from 'typeorm'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint, getMyBizplace } from '@things-factory/biz-base'
@@ -33,6 +33,7 @@ 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'
@@ -59,7 +60,7 @@ export async function completePicking(
   domain: Domain,
   user: User,
   releaseGoodNo: string
-): Promise<void> {
+): Promise<any> {
   const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
     where: { domain, name: releaseGoodNo },
@@ -80,7 +81,8 @@ export async function completePicking(
 
   const worksheet: Worksheet = await pickingWSCtrl.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PICKING, [
     'worksheetDetails',
-    'worksheetDetails.targetInventory'
+    'worksheetDetails.targetInventory',
+    'worksheetDetails.targetInventory.inventory'
   ])
 
   const warehouseContactPoint: ContactPoint = await tx.getRepository(ContactPoint).findOne({
@@ -92,267 +94,287 @@ 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
   )
 
-  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 })
-
-      if (sellercraft) {
-        const initSCOrderShipment = async sellercraft => {
-          await getManager().transaction(async txMgr => {
-            const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
+  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 })
+              }
 
-            if (!releaseGood?.orderPackages?.length && !releaseGood?.marketPackCallSuccess) {
-              const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
-                where: { releaseGood },
-                relations: ['product', 'product.productDetails']
+              const rtsTriggerLevel: Setting = await txMgr.getRepository(Setting).findOne({
+                where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
               })
-              await sellercraftCtrl.packOrder(sellercraft, { ...releaseGood, orderProducts })
-            }
 
-            const rtsTriggerLevel: Setting = await txMgr.getRepository(Setting).findOne({
-              where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
+              if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
+                await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+              }
             })
-
-            if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-              await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
-            }
-          })
+          }
+          // asynchronouly call to initiate sellercraft order shipment/ RTS
+          initSCOrderShipment(sellercraft)
         }
-        // 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) {
-        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-        const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-        let eTraxOption: boolean
+        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)
+          }
 
-        if (marketplaceStore?.isAutoUpdateShipment) {
-          await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PACKING)
+          if (!marketplaceOrder) {
+            throw new Error('Failed to find ecommerce order, kindly contact our support team regarding this issue')
+          }
 
-          await ecommerceCtrl.createOrderShip(releaseGood, marketplaceStore, marketplaceOrder, companyDomain)
-        }
+          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 (!marketplaceOrder) {
-          throw new Error('Failed to find ecommerce order, kindly contact our support team regarding this issue')
-        }
+            //Get which transporter to use
+            const marketplaceTransporter: MarketplaceTransporter = await tx
+              .getRepository(MarketplaceTransporter)
+              .findOne({
+                where: { marketplaceStore: marketplaceOrder.marketplaceStore },
+                relations: ['pickupTransporter', 'deliveryTransporter']
+              })
 
-        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']
+            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 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))
-          }
+            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
+            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,
-        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,
+          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,
-          releaseQty: op.releaseQty,
-          orderPackage: savedOrderPackage,
+          releaseGood,
           domain: releaseGood.domain,
           bizplace: releaseGood.bizplace,
           creator: releaseGood.creator,
           updater: releaseGood.updater
         }
-      })
 
-      await tx.getRepository(OrderPackageItem).save(orderPackageItems)
-      break
-  }
+        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
+          }
+        })
 
-  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
+        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 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 })
-                }
+            if (salesOrder) {
+              const salesInvoice: any = await AccountingAPI.postSalesOrderToSalesInvoice(account, {
+                orderId: salesOrder?.id || null
               })
-            )
 
-            await tx
-              .getRepository(ReleaseGood)
-              .update({ id: releaseGood.id }, { collectionOrderNo: salesInvoice.salesId, updater: releaseGood.updater })
+              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 }
+                )
+            }
           }
+        } 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.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 (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 (!loadingWorksheet.worksheetDetails?.length) {
+            loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+          }
 
-    if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
-      if (pickedTargetInventories.length > 0) {
+          const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+          await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
+        }
+      } else {
         const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-        let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
+        let loadingWorksheet: Worksheet = await loadingWSCtrl.updateLoadingWorksheet(
           releaseGoodNo,
-          pickedTargetInventories
+          pickedTargetInventories,
+          existLoadingWorksheet
         )
 
         if (!loadingWorksheet.worksheetDetails?.length) {
@@ -362,20 +384,33 @@ export async function completePicking(
         const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
         await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
       }
-    } 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)
-      }
-
-      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 })
+
+    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
   }
 }

package/server/graphql/resolvers/worksheet/putaway-return/complete-putaway-return.ts

@@ -1,13 +1,40 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ReturnOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { PutawayReturningWorksheetController } from '../../../../controllers'
+import { SellercraftController } from '../../../../controllers/ecommerce'
 import { Worksheet } from '../../../../entities'
 
 export const completePutawayReturnResolver = {
   async completePutawayReturn(_: any, { returnOrderNo }, context: any) {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-      await completePutawayReturn(tx, domain, user, returnOrderNo)
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await completePutawayReturn(tx, domain, user, returnOrderNo)
+
+    const returnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
+      where: { domain, name: returnOrderNo },
+      relations: [
+        'bizplace',
+        'bizplace.domain',
+        'orderInventories',
+        'orderInventories.inventory',
+        'orderInventories.product',
+        'orderInventories.product.productDetails'
+      ]
+    })
+
+    const customerDomain: Domain = returnOrder.bizplace.domain
+    const sellercraft: Sellercraft = await tx
+      .getRepository(Sellercraft)
+      .findOne({ domain: customerDomain, status: SellercraftStatus.ACTIVE })
+
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.registerProductReturn(sellercraft, returnOrder)
+    }
   }
 }
 
@@ -17,7 +44,11 @@ export async function completePutawayReturn(
   user: User,
   returnOrderNo: string
 ): Promise<void> {
-  const worksheetController: PutawayReturningWorksheetController = new PutawayReturningWorksheetController(tx, domain, user)
+  const worksheetController: PutawayReturningWorksheetController = new PutawayReturningWorksheetController(
+    tx,
+    domain,
+    user
+  )
   let worksheet: Worksheet = await worksheetController.completePutawayReturn(returnOrderNo)
 
   /**