@things-factory/worksheet-base 4.3.324 → 4.3.326

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

@@ -71,458 +71,459 @@ export async function completePicking(
   user: User,
   releaseGoodNo: string
 ): Promise<any> {
-  const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  const replenishmentPickingWSCtrl: ReplenishmentWorksheetController = new ReplenishmentWorksheetController(
-    tx,
-    domain,
-    user
-  )
-  let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name: releaseGoodNo },
-    relations: [
-      'domain',
-      'bizplace',
-      'bizplace.domain',
-      'bizplace.company',
-      'bizplace.company.domain',
-      'lastMileDelivery',
-      'orderPackages',
-      'orderPackages.orderPackageItems',
-      'orderPackages.orderPackageItems.orderProduct',
-      'orderPackages.orderPackageItems.orderProduct.product',
-      'orderPackages.orderPackageItems.orderProduct.productDetail',
-      'orderProducts',
-      'orderProducts.product',
-      'orderProducts.productDetail',
-      'creator',
-      'updater'
-    ]
-  })
-
-  const companyDomain: Domain = releaseGood.bizplace.company.domain
-
-  let marketplaceOrder: MarketplaceOrder
-  if (releaseGood.source == ApplicationType.MMS || releaseGood.lmdOption) {
-    marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-      where: { orderNo: releaseGood.refNo, domain: companyDomain },
+  try {
+    const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+    const replenishmentPickingWSCtrl: ReplenishmentWorksheetController = new ReplenishmentWorksheetController(
+      tx,
+      domain,
+      user
+    )
+    let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { domain, name: releaseGoodNo },
       relations: [
-        'marketplaceStore',
-        'marketplaceStore.marketplaceDistributors',
-        'marketplaceOrderItems',
-        'marketplaceOrderItems.marketplaceOrderShippingItems',
-        'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
+        'domain',
+        'bizplace',
+        'bizplace.domain',
+        'bizplace.company',
+        'bizplace.company.domain',
+        'lastMileDelivery',
+        'orderPackages',
+        'orderPackages.orderPackageItems',
+        'orderPackages.orderPackageItems.orderProduct',
+        'orderPackages.orderPackageItems.orderProduct.product',
+        'orderPackages.orderPackageItems.orderProduct.productDetail',
+        'orderProducts',
+        'orderProducts.product',
+        'orderProducts.productDetail',
+        'creator',
+        'updater'
       ]
     })
-  }
 
-  if (releaseGood) {
-    const worksheet: Worksheet = await pickingWSCtrl.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PICKING, [
-      'worksheetDetails',
-      'worksheetDetails.targetInventory',
-      'worksheetDetails.targetInventory.inventory'
-    ])
-
-    const warehouseContactPoint: ContactPoint = await tx.getRepository(ContactPoint).findOne({
-      where: {
-        domain,
-        type: 'WAREHOUSE'
+    const companyDomain: Domain = releaseGood.bizplace.company.domain
+
+    let marketplaceOrder: MarketplaceOrder
+    if (releaseGood.source == ApplicationType.MMS || releaseGood.lmdOption) {
+      marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { orderNo: releaseGood.refNo, domain: companyDomain },
+        relations: [
+          'marketplaceStore',
+          'marketplaceStore.marketplaceDistributors',
+          'marketplaceOrderItems',
+          'marketplaceOrderItems.marketplaceOrderShippingItems',
+          'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
+        ]
+      })
+    }
+
+    if (releaseGood) {
+      const worksheet: Worksheet = await pickingWSCtrl.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PICKING, [
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.inventory'
+      ])
+      const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+      const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+      const pickedTargetInventories: OrderInventory[] = targetInventories.filter(
+        targetInventory => targetInventory.status === ORDER_INVENTORY_STATUS.PICKED
+      )
+
+      if (pickedTargetInventories.length == 0) {
+        throw new Error('Something went wrong. Please contact support.')
       }
-    })
 
-    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
-    )
+      const inventories: Inventory[] = targetInventories.map((ti: OrderInventory) => ti.inventory)
 
-    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 })
-                }
+      const warehouseContactPoint: ContactPoint = await tx.getRepository(ContactPoint).findOne({
+        where: {
+          domain,
+          type: 'WAREHOUSE'
+        }
+      })
 
-                const rtsTriggerLevel: Setting = await txMgr.getRepository(Setting).findOne({
-                  where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
-                })
+      let foundObsoleteInventories = await pickingWSCtrl.completePicking(releaseGood, worksheet, inventories)
 
-                if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-                  await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
-                }
-              })
-            }
-            // asynchronouly call to initiate sellercraft order shipment/ RTS
-            initSCOrderShipment(sellercraft)
-          }
-          break
-
-        case ApplicationType.POWRUP:
-          const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
+      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 (powrup) {
-            const initPowrupShipment = async powrup => {
-              await getManager().transaction(async txMgr => {
-                const powrupController: PowrupController = new PowrupController()
+            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', 'productDetail']
+                  const rtsTriggerLevel: Setting = await txMgr.getRepository(Setting).findOne({
+                    where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
                   })
-                  await powrupController.packOrder(powrup, { ...releaseGood, orderProducts }, domain, user, txMgr)
-                }
 
-                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 powrupController.initiateShipment(powrup, releaseGood, domain, user, txMgr)
-                }
-              })
+              }
+              // asynchronouly call to initiate sellercraft order shipment/ RTS
+              initSCOrderShipment(sellercraft)
             }
-            // asynchronouly call to initiate powrup order shipment/ RTS
-            initPowrupShipment(powrup)
-          }
-          break
+            break
 
-        case ApplicationType.MMS:
-          if (marketplaceOrder) {
-            const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-            const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-            let eTraxOption: boolean
+          case ApplicationType.POWRUP:
+            const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
 
-            if (marketplaceStore?.isAutoUpdateShipment) {
-              await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PACKING)
+            if (powrup) {
+              const initPowrupShipment = async powrup => {
+                await getManager().transaction(async txMgr => {
+                  const powrupController: PowrupController = new PowrupController()
+
+                  if (!releaseGood?.orderPackages?.length && !releaseGood?.marketPackCallSuccess) {
+                    const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
+                      where: { releaseGood },
+                      relations: ['product', 'productDetail']
+                    })
+                    await powrupController.packOrder(powrup, { ...releaseGood, orderProducts }, domain, user, txMgr)
+                  }
 
-              if (!releaseGood.lmdOption) {
-                await ecommerceCtrl.createOrderShip(releaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+                  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 powrupController.initiateShipment(powrup, releaseGood, domain, user, txMgr)
+                  }
+                })
               }
+              // asynchronouly call to initiate powrup order shipment/ RTS
+              initPowrupShipment(powrup)
             }
+            break
 
-            if (!marketplaceOrder) {
-              throw new Error('Failed to find ecommerce order, kindly contact our support team regarding this issue')
-            }
+          case ApplicationType.MMS:
+            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)
 
-            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 (!releaseGood.lmdOption) {
+                  await ecommerceCtrl.createOrderShip(releaseGood, marketplaceStore, marketplaceOrder, companyDomain)
                 }
-              })
+              }
 
-              //Get which transporter to use
-              const marketplaceTransporter: MarketplaceTransporter = await tx
-                .getRepository(MarketplaceTransporter)
-                .findOne({
-                  where: { marketplaceStore: marketplaceOrder.marketplaceStore },
-                  relations: ['pickupTransporter', 'deliveryTransporter']
+              if (!marketplaceOrder) {
+                throw new Error('Failed to find ecommerce order, kindly contact our support team regarding this issue')
+              }
+
+              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'
+                  }
                 })
 
-              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
-              })
+                //Get which transporter to use
+                const marketplaceTransporter: MarketplaceTransporter = await tx
+                  .getRepository(MarketplaceTransporter)
+                  .findOne({
+                    where: { marketplaceStore: marketplaceOrder.marketplaceStore },
+                    relations: ['pickupTransporter', 'deliveryTransporter']
+                  })
 
-              const delay = (ms: number) => {
-                return new Promise(resolve => setTimeout(resolve, ms))
-              }
+                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 (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 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:
-          let 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:
+            let 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)
-          orderPackage.orderPackageItems = orderPackageItems
-          releaseGood.orderPackages = [orderPackage]
-          break
-      }
 
-      const account: Account = await tx
-        .getRepository(Account)
-        .findOne({ where: { domain: releaseGood.bizplace.domain, status: 'active' }, relations: ['domain'] })
-
-      // Xilnex Create Sales Order and Post Sales Order to Sales Invoice
-      const createSalesOrder = async (account, releaseGood, tx) => {
-        if (account) {
-          if (account.platform == 'xilnex') {
-            try {
-              delete releaseGood.orderPackages
-              delete releaseGood.creator
-              delete releaseGood.updater
-
-              const body = {
-                accessToken: account.accessToken,
-                appId: account.accountId,
-                accountInfo: account.accountInfo,
-                req: JSON.stringify({
-                  releaseGood,
-                  orderProducts: releaseGood.orderProducts
-                })
+            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)
+            orderPackage.orderPackageItems = orderPackageItems
+            releaseGood.orderPackages = [orderPackage]
+            break
+        }
 
-              await sqsSendMessage({
-                body,
-                deduplicationId: releaseGood.refNo,
-                groupId: releaseGood.refNo,
-                queueName: 'prototypeQueue.fifo'
-              })
-            } catch (e) {
-              console.log(`[Create Sales Order] SQS Send Message: ${e}`)
+        const account: Account = await tx
+          .getRepository(Account)
+          .findOne({ where: { domain: releaseGood.bizplace.domain, status: 'active' }, relations: ['domain'] })
+
+        // Xilnex Create Sales Order and Post Sales Order to Sales Invoice
+        const createSalesOrder = async (account, releaseGood, tx) => {
+          if (account) {
+            if (account.platform == 'xilnex') {
+              try {
+                delete releaseGood.orderPackages
+                delete releaseGood.creator
+                delete releaseGood.updater
+
+                const body = {
+                  accessToken: account.accessToken,
+                  appId: account.accountId,
+                  accountInfo: account.accountInfo,
+                  req: JSON.stringify({
+                    releaseGood,
+                    orderProducts: releaseGood.orderProducts
+                  })
+                }
+
+                await sqsSendMessage({
+                  body,
+                  deduplicationId: releaseGood.refNo,
+                  groupId: releaseGood.refNo,
+                  queueName: 'prototypeQueue.fifo'
+                })
+              } catch (e) {
+                console.log(`[Create Sales Order] SQS Send Message: ${e}`)
+              }
             }
           }
         }
-      }
 
-      if (releaseGood.type == 'b2c') {
-        createSalesOrder(account, releaseGood, tx)
-      }
+        if (releaseGood.type == 'b2c') {
+          createSalesOrder(account, releaseGood, 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
 
-        let orderVas: OrderVas[] = await tx.getRepository(OrderVas).find({ where: { domain: domain, releaseGood } })
-        if (orderVas) {
-          try {
-            const vasWorksheet: Worksheet = await tx
-              .getRepository(Worksheet)
-              .findOne({ where: { releaseGood, type: WORKSHEET_TYPE.VAS } })
+          let orderVas: OrderVas[] = await tx.getRepository(OrderVas).find({ where: { domain: domain, releaseGood } })
+          if (orderVas?.length > 0) {
+            const wSCtrl: WorksheetController = new WorksheetController(tx, domain, user)
 
-            const vasWorksheetDetails: WorksheetDetail[] = await tx
-              .getRepository(WorksheetDetail)
-              .find({ where: { domain: domain, worksheet: vasWorksheet.id } })
+            let vasWorksheet = await wSCtrl.createWorksheet(releaseGood, WORKSHEET_TYPE.VAS)
+            let vasWorksheetDetails = await wSCtrl.createWorksheetDetails(vasWorksheet, WORKSHEET_TYPE.VAS, orderVas)
 
             if (vasWorksheet) {
               await activateVas(tx, domain, user, vasWorksheet.name, vasWorksheetDetails)
             }
-          } catch (e) {}
-        }
-        // Can improve by applying "Else" since if got VAS user has to complete then only we generate loading worksheet
-        if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
-          if (pickedTargetInventories.length > 0 && orderVas.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)
-            }
+          } else {
+            existLoadingWorksheet = 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 {
-          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)
-          }
+            if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
+              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)
+              }
 
-          const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
-          await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
+              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)
+            }
+          }
         }
-      }
 
-      // trigger LMD API to create parcel
-      if (
-        releaseGood?.orderPackages?.length &&
-        releaseGood.lmdOption &&
-        releaseGood.lastMileDelivery &&
-        releaseGood?.orderPackages?.some(op => op.parcelId == null)
-      ) {
-        await createLmdParcel([releaseGood], tx, domain, user, marketplaceOrder)
-        // trigger RTS
-        try {
-          const orderSource: string = releaseGood.source
-
-          if (orderSource == ApplicationType.SELLERCRAFT) {
-            const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-              domain: releaseGood.bizplace.domain,
-              status: SellercraftStatus.ACTIVE
-            })
-            if (sellercraft) {
-              const sellercraftCtrl: SellercraftController = new SellercraftController(tx, null, null)
-              const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
-                where: { domain: releaseGood.domain, category: 'id-rule', name: 'rts-trigger-level' }
+        // trigger LMD API to create parcel
+        if (
+          releaseGood?.orderPackages?.length &&
+          releaseGood.lmdOption &&
+          releaseGood.lastMileDelivery &&
+          releaseGood?.orderPackages?.some(op => op.parcelId == null)
+        ) {
+          await createLmdParcel([releaseGood], tx, domain, user, marketplaceOrder)
+          // trigger RTS
+          try {
+            const orderSource: string = releaseGood.source
+
+            if (orderSource == ApplicationType.SELLERCRAFT) {
+              const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
+                domain: releaseGood.bizplace.domain,
+                status: SellercraftStatus.ACTIVE
               })
+              if (sellercraft) {
+                const sellercraftCtrl: SellercraftController = new SellercraftController(tx, null, null)
+                const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
+                  where: { domain: releaseGood.domain, category: 'id-rule', name: 'rts-trigger-level' }
+                })
 
-              if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-                sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+                if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
+                  sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+                }
               }
-            }
-          } else if (orderSource == ApplicationType.POWRUP) {
-            const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
+            } else if (orderSource == ApplicationType.POWRUP) {
+              const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
 
-            if (powrup) {
-              const powrupController: PowrupController = new PowrupController()
-              const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
-                where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
-              })
+              if (powrup) {
+                const powrupController: PowrupController = new PowrupController()
+                const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
+                  where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
+                })
 
-              if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-                powrupController.initiateShipment(powrup, releaseGood, domain, user, tx)
+                if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
+                  powrupController.initiateShipment(powrup, releaseGood, domain, user, tx)
+                }
               }
             }
+          } catch (e) {
+            logger.error(`[get-lmd-awb-sof-trigger]: ${e}`)
           }
-        } catch (e) {
-          logger.error(`[get-lmd-awb-sof-trigger]: ${e}`)
+          //
         }
         //
-      }
-      //
-    } else {
-      //update inventories obsolete to true
-      await tx.getRepository(Inventory).update({ id: In(foundObsoleteInventories) }, { obsolete: true })
+      } else {
+        //update inventories obsolete to true
+        await tx.getRepository(Inventory).update({ id: In(foundObsoleteInventories) }, { obsolete: true })
 
-      foundObsoleteInventories = foundObsoleteInventories
-        .map(inv => {
-          return "'" + inv.trim() + "'"
-        })
-        .join(',')
+        foundObsoleteInventories = foundObsoleteInventories
+          .map(inv => {
+            return "'" + inv.trim() + "'"
+          })
+          .join(',')
 
-      //update any orders that is assigned with obsolete inventories
-      await tx.getRepository(ReleaseGood).query(`
+        //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(`
+        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
@@ -530,21 +531,24 @@ export async function completePicking(
     and oi.inventory_id in (${foundObsoleteInventories})
     `)
 
-      return true
-    }
-  } else {
-    let replenishment: Replenishment = await tx.getRepository(Replenishment).findOne({
-      where: { domain, name: releaseGoodNo }
-    })
+        return true
+      }
+    } else {
+      let replenishment: Replenishment = await tx.getRepository(Replenishment).findOne({
+        where: { domain, name: releaseGoodNo }
+      })
 
-    const worksheet: Worksheet = await pickingWSCtrl.findWorksheetByRefOrder(
-      replenishment,
-      WORKSHEET_TYPE.PICKING_REPLENISHMENT,
-      ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
-    )
+      const worksheet: Worksheet = await pickingWSCtrl.findWorksheetByRefOrder(
+        replenishment,
+        WORKSHEET_TYPE.PICKING_REPLENISHMENT,
+        ['worksheetDetails', 'worksheetDetails.targetInventory', 'worksheetDetails.targetInventory.inventory']
+      )
 
-    await replenishmentPickingWSCtrl.completeReplenishmentPicking(replenishment, worksheet)
+      await replenishmentPickingWSCtrl.completeReplenishmentPicking(replenishment, worksheet)
 
-    await replenishmentPickingWSCtrl.generatePutawayReplenishmentWorksheet(releaseGoodNo)
+      await replenishmentPickingWSCtrl.generatePutawayReplenishmentWorksheet(releaseGoodNo)
+    }
+  } catch (error) {
+    throw error
   }
 }