@things-factory/worksheet-base 4.3.185 → 4.3.187

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

@@ -21,7 +21,8 @@ import {
   OrderPackage,
   OrderPackageItem,
   OrderProduct,
-  ReleaseGood
+  ReleaseGood,
+  Replenishment
 } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
@@ -32,11 +33,13 @@ import {
   LoadingWorksheetController,
   PackingWorksheetController,
   PickingWorksheetController,
+  ReplenishmentWorksheetController,
   SellercraftController
 } from '../../../../controllers/'
 import { EcommerceController } from '../../../../controllers/ecommerce'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
+import { createLmdParcel } from '../../../../utils'
 
 export const completePickingResolver = {
   async completePicking(_: any, { releaseGoodNo }, context: any) {
@@ -64,6 +67,11 @@ export async function completePicking(
   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: [
@@ -72,7 +80,11 @@ export async function completePicking(
       'bizplace.domain',
       'bizplace.company',
       'bizplace.company.domain',
+      'lastMileDelivery',
       'orderPackages',
+      'orderPackages.orderPackageItems',
+      'orderPackages.orderPackageItems.orderProduct',
+      'orderPackages.orderPackageItems.orderProduct.product',
       'orderProducts',
       'orderProducts.product',
       'orderProducts.productDetail',
@@ -81,331 +93,354 @@ export async function completePicking(
     ]
   })
 
-  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'
-    }
-  })
+  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 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 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 })
+                }
 
-  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']
+                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:
+          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)
-        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
+            }
+          })
+          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, tx) => {
-      if (account) {
-        if (account.platform == 'xilnex') {
-          let integrationInfo: any = {
-            xilnex: {
-              accountId: account.accountId,
-              startTime: new Date()
+      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, tx) => {
+        if (account) {
+          if (account.platform == 'xilnex') {
+            let integrationInfo: any = {
+              xilnex: {
+                accountId: account.accountId,
+                startTime: new Date()
+              }
             }
-          }
 
-          try {
-            const salesOrder: any = await AccountingAPI.createSalesOrder(account, {
-              releaseGood,
-              orderProducts: releaseGood.orderProducts
-            })
+            try {
+              const salesOrder: any = await AccountingAPI.createSalesOrder(account, {
+                releaseGood,
+                orderProducts: releaseGood.orderProducts
+              })
 
-            if (salesOrder) {
-              integrationInfo.xilnex = {
-                ...integrationInfo.xilnex,
-                salesOrderId: salesOrder.id,
-                endTime: new Date()
-              }
+              if (salesOrder) {
+                integrationInfo.xilnex = {
+                  ...integrationInfo.xilnex,
+                  salesOrderId: salesOrder.id,
+                  endTime: new Date()
+                }
 
-              try {
-                const salesInvoice: any = await AccountingAPI.postSalesOrderToSalesInvoice(account, {
-                  orderId: salesOrder?.id || null
-                })
+                try {
+                  const salesInvoice: any = await AccountingAPI.postSalesOrderToSalesInvoice(account, {
+                    orderId: salesOrder?.id || null
+                  })
+
+                  if (salesInvoice) {
+                    integrationInfo.xilnex = {
+                      ...integrationInfo.xilnex,
+                      salesInvoiceId: salesInvoice.salesId,
+                      endTime: new Date()
+                    }
+
+                    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 (salesInvoice) {
+                    await tx
+                      .getRepository(ReleaseGood)
+                      .update(
+                        { id: releaseGood.id },
+                        { collectionOrderNo: salesInvoice.salesId, integrationInfo, updater: releaseGood.updater }
+                      )
+                  }
+                } catch (error) {
                   integrationInfo.xilnex = {
                     ...integrationInfo.xilnex,
-                    salesInvoiceId: salesInvoice.salesId,
                     endTime: new Date()
                   }
 
-                  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, integrationInfo, updater: releaseGood.updater }
+                      { integrationInfo, integrationFail: true, updater: releaseGood.updater }
                     )
+                  logger.error(`complete-picking[createSalesInvoice][${releaseGood.refNo}]: ${error}`)
                 }
-              } catch (error) {
-                integrationInfo.xilnex = {
-                  ...integrationInfo.xilnex,
-                  endTime: new Date()
-                }
-
-                await tx
-                  .getRepository(ReleaseGood)
-                  .update(
-                    { id: releaseGood.id },
-                    { integrationInfo, integrationFail: true, updater: releaseGood.updater }
-                  )
-                logger.error(`complete-picking[createSalesInvoice][${releaseGood.refNo}]: ${error}`)
               }
-            }
-          } catch (error) {
-            integrationInfo.xilnex = {
-              ...integrationInfo.xilnex,
-              endTime: new Date()
-            }
+            } catch (error) {
+              integrationInfo.xilnex = {
+                ...integrationInfo.xilnex,
+                endTime: new Date()
+              }
 
-            await tx
-              .getRepository(ReleaseGood)
-              .update({ id: releaseGood.id }, { integrationInfo, integrationFail: true, updater: releaseGood.updater })
-            logger.error(`complete-picking[createSalesOrder][${releaseGood.refNo}]: ${error}`)
+              await tx
+                .getRepository(ReleaseGood)
+                .update(
+                  { id: releaseGood.id },
+                  { integrationInfo, integrationFail: true, updater: releaseGood.updater }
+                )
+              logger.error(`complete-picking[createSalesOrder][${releaseGood.refNo}]: ${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) {
+        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)
+            }
+
+            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) {
@@ -415,41 +450,37 @@ 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)
+      // 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)
       }
-    }
-  } 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
@@ -457,6 +488,21 @@ export async function completePicking(
     and oi.inventory_id in (${foundObsoleteInventories})
     `)
 
-    return true
+      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']
+    )
+
+    await replenishmentPickingWSCtrl.completeReplenishmentPicking(replenishment, worksheet)
+
+    await replenishmentPickingWSCtrl.generatePutawayReplenishmentWorksheet(releaseGoodNo)
   }
 }