@things-factory/worksheet-base 4.3.393 → 4.3.395

package/server/controllers/outbound/picking-worksheet-controller.ts

@@ -32,6 +32,8 @@ import {
   ORDER_TYPES,
   OrderInventory,
   OrderNoGenerator,
+  OrderPackage,
+  OrderPackageItem,
   OrderProduct,
   OrderTote,
   OrderToteItem,
@@ -252,11 +254,13 @@ export class PickingWorksheetController extends VasWorksheetController {
       'releaseGood.bizplace.domain',
       'releaseGood.orderProducts',
       'releaseGood.orderProducts.productDetail',
+      'releaseGood.orderProducts.product',
       'releaseGood.orderProducts.productDetail.product',
       'releaseGood.orderPackages',
       'releaseGood.orderPackages.orderPackageItems',
       'releaseGood.orderPackages.orderPackageItems.orderProduct',
       'releaseGood.orderPackages.orderPackageItems.orderProduct.product',
+      'releaseGood.orderPackages.orderPackageItems.orderProduct.productDetail',
       'domain',
       'bizplace',
       'bizplace.domain',
@@ -324,7 +328,7 @@ export class PickingWorksheetController extends VasWorksheetController {
               if (!releaseGood?.orderPackages?.length) {
                 const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
                   where: { releaseGood },
-                  relations: ['product', 'product.productDetails','productDetail']
+                  relations: ['product', 'product.productDetails', 'productDetail']
                 })
 
                 // asynchronously pack order
@@ -368,6 +372,21 @@ export class PickingWorksheetController extends VasWorksheetController {
           break
 
         default:
+          let orderPackage: OrderPackage = {
+            name: OrderNoGenerator.orderPackage(),
+            packageId: null,
+            trackingNo: null,
+            transporter: null,
+            airwayBill: releaseGood?.airwayBill,
+            invoice: releaseGood?.invoice,
+            status: ORDER_STATUS.PROCESSING,
+            releaseGood,
+            domain: releaseGood.domain,
+            bizplace: releaseGood.bizplace,
+            creator: releaseGood.creator,
+            updater: releaseGood.updater
+          }
+          await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
           break
       }
     } catch (error) {
@@ -388,6 +407,12 @@ export class PickingWorksheetController extends VasWorksheetController {
         .leftJoinAndSelect('w.worksheetDetails', 'wd')
         .leftJoinAndSelect('w.releaseGood', 'rg')
         .leftJoinAndSelect('rg.domain', 'rgd')
+        .leftJoinAndSelect('rg.lastMileDelivery', 'lmd')
+        .leftJoinAndSelect('rg.orderPackages', 'rgop')
+        .leftJoinAndSelect('rgop.orderPackageItems', 'rgopi')
+        .leftJoinAndSelect('rgopi.orderProduct', 'op2')
+        .leftJoinAndSelect('op2.product', 'p')
+        .leftJoinAndSelect('op2.productDetail', 'pd')
         .leftJoinAndSelect('rg.bizplace', 'rgbz')
         .leftJoinAndSelect('rgbz.domain', 'bzd')
         .leftJoinAndSelect('b.domain', 'bd')
@@ -416,11 +441,12 @@ export class PickingWorksheetController extends VasWorksheetController {
       }
 
       const groupedWsBiz = [...groupWs.entries()]
-      await Promise.all(
+      const updatedWs = await Promise.all(
         groupedWsBiz.map(async ([bizplaceId, worksheetIds]) => {
           return await this.activateBulkWorksheets(bizplaceId, worksheetIds)
         })
       )
+      worksheets = updatedWs.flat()
     } catch (error) {
       throw error
     } finally {
@@ -479,7 +505,11 @@ export class PickingWorksheetController extends VasWorksheetController {
         'releaseGood.orderPackages',
         'releaseGood.orderPackages.orderPackageItems',
         'releaseGood.orderPackages.orderPackageItems.orderProduct',
-        'releaseGood.orderPackages.orderPackageItems.orderProduct.product'
+        'releaseGood.orderPackages.orderPackageItems.orderProduct.product',
+        'releaseGood.orderPackages.orderPackageItems.orderProduct.productDetail',
+        'releaseGood.orderProducts',
+        'releaseGood.orderProducts.productDetail',
+        'releaseGood.orderProducts.product',
       ]
     })
 
@@ -550,7 +580,22 @@ export class PickingWorksheetController extends VasWorksheetController {
                 break
 
               default:
-                break
+                let orderPackage: OrderPackage = {
+                  name: OrderNoGenerator.orderPackage(),
+                  packageId: null,
+                  trackingNo: null,
+                  transporter: null,
+                  airwayBill: releaseGood?.airwayBill,
+                  invoice: releaseGood?.invoice,
+                  status: ORDER_STATUS.PROCESSING,
+                  releaseGood,
+                  domain: releaseGood.domain,
+                  bizplace: releaseGood.bizplace,
+                  creator: releaseGood.creator,
+                  updater: releaseGood.updater
+                }
+                await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
+              break
             }
           } catch (error) {
             logger.error(`picking-worksheet-controller[activateBatchPicking]: ${error}`)
@@ -733,8 +778,49 @@ export class PickingWorksheetController extends VasWorksheetController {
       }).join(' AND ')}
       `, worksheetDetailFilters.map((data, idx) => {
         return data.value
-      })
-      )
+      }))
+
+      // find directly without going through the materialized view
+      if ((worksheetDetailRaw.length < 1)) {
+        worksheetDetailRaw = await this.trxMgr.query(`
+          select
+          wd.id AS "worksheetDetailId",
+          wd.name as "worksheetDetailName",
+          w.id as "worksheetId",
+          w.domain_id as "domainId",
+          op.id as "targetProductId",
+          oi.product_id as "productId",
+          oi.product_detail_id as "productDetailId",
+          op.uom_value as "uomValue",
+          pb.id  as "productBarcodeId",
+          pb.gtin,
+          p.is_require_serial_number_scanning_outbound as "productIsRequireSerialNumberScanningOutbound",
+          oi.release_good_id as "releaseGoodId",
+          oi.id as "orderInventoryId",
+          oi.status as "orderInventoryStatus",
+          oi.bizplace_id as "bizplaceId",
+          i.id as "inventoryId",
+          i.carton_id as "inventoryCartonId",
+          i.status as "inventoryStatus",
+          ici.status as "inventoryCheckItemStatus",
+          rg.name as "releaseGoodName",
+          rg.ref_no as "refNo"
+          FROM worksheet_details wd
+          INNER JOIN worksheets w ON wd.worksheet_id = w.id
+          inner JOIN order_inventories oi ON oi.id = wd.target_inventory_id
+          inner JOIN order_products op ON op.id = oi.order_product_id
+          inner join inventories i on i.id = oi.inventory_id
+          inner join release_goods rg on rg.id = oi.release_good_id
+          left join inventory_check_items ici on ici.inventory_id = oi.inventory_id
+          inner join products p on p.id = oi.product_id
+          left join product_bundles pb2 on pb2.id = op.product_bundle_id
+          LEFT JOIN product_barcodes pb ON pb.product_detail_id = oi.product_detail_id 
+          left join product_bundle_settings pbs on pbs.product_bundle_id = pb2.id and pbs.product_id = oi.product_id and pbs.product_detail_id = oi.product_detail_id
+          WHERE w.type::text = 'PICKING'::text AND w.status::text = 'EXECUTING'::text
+          and wd.name = $1 and w.domain_id = $2 and i.carton_id = $3
+          ORDER BY w.domain_id, w.bizplace_id, wd.id
+        `, [worksheetDetailName, this.domain.id, cartonId])
+      }
 
       //validation to check matching worksheet detail based on name
       if ((worksheetDetailRaw.length < 1)) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName))
@@ -745,7 +831,7 @@ export class PickingWorksheetController extends VasWorksheetController {
 
       let targetProduct = { id: worksheetDetailInfos.targetProductId }
       let bizplace: Partial<Bizplace> = { id: worksheetDetailInfos.bizplaceId }
-      const releaseGood: Partial<ReleaseGood> = { id: worksheetDetailInfos.releaseGoodId , name: worksheetDetailInfos.releaseGoodName, refNo: worksheetDetailInfos.refNo }
+      const releaseGood: Partial<ReleaseGood> = { id: worksheetDetailInfos.releaseGoodId, name: worksheetDetailInfos.releaseGoodName, refNo: worksheetDetailInfos.refNo }
 
       let matchingProduct, pickedUomValue
 
@@ -2408,30 +2494,37 @@ export class PickingWorksheetController extends VasWorksheetController {
     return newWorksheetDetails
   }
 
-  async activateBulkWorksheets(bizplaceId, worksheetIds) {
+  async activateBulkWorksheets(bizplaceId, worksheetIds): Promise<Worksheet[]> {
+    const updatedWs: Worksheet[] = []
     try {
       for (const worksheetId of worksheetIds) {
         try {
           let releaseGood: ReleaseGood
           let domain: Domain
 
-          getManager().transaction(async (tx: EntityManager) => {
+          await getManager().transaction(async (tx: EntityManager) => {
             const worksheetRepo = tx.getRepository(Worksheet)
             let worksheet = await worksheetRepo
               .createQueryBuilder('w')
+              .leftJoinAndSelect('w.releaseGood', 'rg')
+              .leftJoinAndSelect('rg.bizplace', 'rg_b')
+              .leftJoinAndSelect('rg.domain', 'rg_d')
+              .leftJoinAndSelect('rg.lastMileDelivery', 'rg_lmd')
+              .leftJoinAndSelect('rg_b.domain', 'b_d')
+              .leftJoinAndSelect('rg.orderProducts', 'rg_op')
+              .leftJoinAndSelect('rg_op.product', 'op_p')
+              .leftJoinAndSelect('rg_op.productDetail', 'op_pd')
+              .leftJoinAndSelect('op_pd.product', 'pd_p')
+              .leftJoinAndSelect('rg.orderPackages', 'rg_opc')
+              .leftJoinAndSelect('rg_opc.orderPackageItems', 'opc_opi')
+              .leftJoinAndSelect('opc_opi.orderProduct', 'opi_op')
+              .leftJoinAndSelect('opi_op.product', 'op_p2')
+              .leftJoinAndSelect('opi_op.productDetail', 'op_pd2')
               .leftJoinAndSelect('w.domain', 'd')
               .leftJoinAndSelect('w.bizplace', 'b')
-              .leftJoinAndSelect('w.worksheetDetails', 'wd')
-              .leftJoinAndSelect('w.releaseGood', 'rg')
-              .leftJoinAndSelect('rg.domain', 'rgd')
-              .leftJoinAndSelect('rg.bizplace', 'rgbz')
-              .leftJoinAndSelect('rgbz.domain', 'bzd')
-              .leftJoinAndSelect('rg.orderProducts', 'op')
-              .leftJoinAndSelect('op.productDetail', 'pd')
-              .leftJoinAndSelect('pd.product', 'p')
-              .leftJoinAndSelect('b.domain', 'bd')
               .leftJoinAndSelect('b.company', 'c')
-              .leftJoinAndSelect('c.domain', 'cd')
+              .leftJoinAndSelect('c.domain', 'c_d')
+              .leftJoinAndSelect('w.worksheetDetails', 'wd')
               .leftJoinAndSelect('wd.targetInventory', 'ti')
               .leftJoinAndSelect('ti.product', 'tp')
               .where('w.id = :worksheetId', { worksheetId: worksheetId })
@@ -2471,6 +2564,8 @@ export class PickingWorksheetController extends VasWorksheetController {
             worksheet = await this.activateWorksheet(worksheet, worksheetDetails, [], tx)
             releaseGood = worksheet.releaseGood
             domain = worksheet.domain
+
+            updatedWs.push(worksheet)
           })
 
           const orderSource: string = releaseGood?.source
@@ -2535,6 +2630,21 @@ export class PickingWorksheetController extends VasWorksheetController {
               break
 
             default:
+              let orderPackage: OrderPackage = {
+                name: OrderNoGenerator.orderPackage(),
+                packageId: null,
+                trackingNo: null,
+                transporter: null,
+                airwayBill: releaseGood?.airwayBill,
+                invoice: releaseGood?.invoice,
+                status: ORDER_STATUS.PROCESSING,
+                releaseGood,
+                domain: releaseGood.domain,
+                bizplace: releaseGood.bizplace,
+                creator: releaseGood.creator,
+                updater: releaseGood.updater
+              }
+              await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
               break
           }
         } catch (e) {
@@ -2546,5 +2656,48 @@ export class PickingWorksheetController extends VasWorksheetController {
     } catch (e) {
       console.log(e)
     }
+
+    return updatedWs
   }
+
+}
+
+export async function createOrderPackageAndItems(tx: EntityManager, releaseGood: ReleaseGood, orderPackage: OrderPackage): Promise<void> {
+  let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
+
+  const orderPackageItems: OrderPackageItem[] = releaseGood.orderProducts.map(op => {
+    if (op.product){
+      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,
+        productDetail: op.productDetail
+      }
+    } else {
+      let productBundle = op.productBundle
+      return productBundle.productBundleSettings.map(pbs => ({
+        name: OrderNoGenerator.orderPackageItem(),
+        orderProduct: op,
+        status: ORDER_STATUS.PROCESSING,
+        releaseQty: op.releaseQty * pbs.bundleQty,
+        orderPackage: savedOrderPackage,
+        domain: releaseGood.domain,
+        bizplace: releaseGood.bizplace,
+        creator: releaseGood.creator,
+        updater: releaseGood.updater,
+        productDetail: pbs.productDetail
+      }))
+    }
+  }).flat()
+
+  await tx.getRepository(OrderPackageItem).save(orderPackageItems)
+  orderPackage.orderPackageItems = orderPackageItems
+  releaseGood.orderPackages = [orderPackage]
 }
+

package/server/graphql/resolvers/worksheet/picking/activate-batch-picking.ts

@@ -1,12 +1,25 @@
-import { EntityManager, getConnection } from 'typeorm'
+import {
+  EntityManager,
+  getConnection,
+  In
+} from 'typeorm'
 
-import { User } from '@things-factory/auth-base'
+import {
+  ApplicationType,
+  User
+} from '@things-factory/auth-base'
+import { logger } from '@things-factory/env'
 import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { MarketplaceOrder } from '@things-factory/marketplace-base'
+import { ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 
-import { EcommerceController, PickingWorksheetController } from '../../../../controllers'
+import {
+  EcommerceController,
+  PickingWorksheetController
+} from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
-import { logger } from '@things-factory/env'
+import { createLmdParcel } from '../../../../utils'
 
 export const activateBatchPickingResolver = {
   async activateBatchPicking(_: any, { worksheetNo }, context: any) {
@@ -23,17 +36,26 @@ export async function activateBatchPicking(
 ): Promise<Worksheet> {
   try {
     const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+    const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
     const worksheet = await worksheetController.activateBatchPicking(worksheetNo)
     const worksheetDetails = worksheet.worksheetDetails
     const companyDomain: Domain = worksheet?.bizplace.company.domain
 
+    let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+
     // find for any existing marketplace store connections
     const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
       where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
       relations: ['marketplaceDistributors']
     })
 
-    const updateMarketplaceProductVariationStock = async (worksheetDetails, domain, user, marketplaceStores, companyDomain) => {
+    const updateMarketplaceProductVariationStock = async (
+      worksheetDetails,
+      domain,
+      user,
+      marketplaceStores,
+      companyDomain
+    ) => {
       try {
         await getConnection().transaction(async (tx2: EntityManager) => {
           let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
@@ -49,8 +71,87 @@ export async function activateBatchPicking(
       updateMarketplaceProductVariationStock(worksheetDetails, domain, user, marketplaceStores, companyDomain)
     }
 
-    return worksheet
+    try {
+      let releaseGoods: ReleaseGood[] = []
+      let releaseGoodIds: ReleaseGood[] = orderInventories.reduce((data, orderInventory) => {
+        if (!data.find(x => x.id == orderInventory.releaseGood.id)) {
+          data.push(orderInventory.releaseGood.id)
+        }
+        return data
+      }, [])
+
+      releaseGoods = await tx.getRepository(ReleaseGood).find({
+        where: { id: In(releaseGoodIds) },
+        relations: [
+          'domain',
+          'lastMileDelivery',
+          'bizplace',
+          'bizplace.domain',
+          'orderPackages',
+          'orderPackages.orderPackageItems',
+          'orderPackages.orderPackageItems.orderProduct',
+          'orderPackages.orderPackageItems.orderProduct.product',
+          'orderPackages.orderPackageItems.orderProduct.productDetail',
+          'orderProducts',
+          'orderProducts.productDetail',
+          'orderProducts.product'
+        ]
+      })
+
+      if (releaseGoods?.length) {
+        for (const releaseGood of releaseGoods) {
+          const orderSource = releaseGood?.source
+          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+            where: { orderNo: releaseGood.refNo, domain: companyDomain },
+            relations: ['marketplaceStore']
+          })
+
+          switch (orderSource) {
+            case ApplicationType.MMS:
+              if (marketplaceStores?.length) {
+                if (marketplaceOrder) {
+                  const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+                  await ecommerceCtrl.createOrderPackage(
+                    tx,
+                    marketplaceOrder,
+                    companyDomain,
+                    marketplaceStore,
+                    releaseGood
+                  )
+                }
+              }
+              break
+            default:
+              break
+          }
 
+          if (
+            releaseGood?.orderPackages?.length &&
+            releaseGood.lmdOption &&
+            releaseGood.lastMileDelivery &&
+            releaseGood?.orderPackages?.some(op => op.parcelId == null)
+          ) {
+            await createLmdParcel([releaseGood], tx, domain, user, marketplaceOrder)
+
+            //where to trigger update parcel count
+            let countParcel = releaseGood?.countParcel ? releaseGood.countParcel : 0
+            const releaseGoodId = releaseGood?.id
+
+            await tx.getRepository(ReleaseGood).update(
+              { id: releaseGoodId },
+              {
+                countParcel: countParcel + 1,
+                updater: user.id
+              }
+            )
+          }
+        }
+      }
+    } catch (e) {
+      logger.error(e)
+    }
+
+    return worksheet
   } catch (error) {
     logger.error(`activate-batch-picking[activateBatchPicking]: ${worksheetNo + ':' + error}`)
     throw new Error('Something went wrong. Please contact support.')

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

@@ -1,13 +1,26 @@
 import { EntityManager } from 'typeorm'
 
-import { ApplicationType, User } from '@things-factory/auth-base'
+import {
+  ApplicationType,
+  User
+} from '@things-factory/auth-base'
 import { MarketplaceStore } from '@things-factory/integration-marketplace'
 import { MarketplaceOrder } from '@things-factory/marketplace-base'
-import { ORDER_STATUS, ReleaseGood } from '@things-factory/sales-base'
+import {
+  ORDER_STATUS,
+  ReleaseGood
+} from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 
-import { EcommerceController, PickingWorksheetController } from '../../../../controllers'
-import { ActiveWorksheetPickingView, Worksheet } from '../../../../entities'
+import {
+  EcommerceController,
+  PickingWorksheetController
+} from '../../../../controllers'
+import {
+  ActiveWorksheetPickingView,
+  Worksheet
+} from '../../../../entities'
+import { createLmdParcel } from '../../../../utils'
 
 export const activatePickingResolver = {
   async activatePicking(_: any, { worksheetNo }, context: any) {
@@ -24,81 +37,76 @@ export async function activatePicking(
 ): Promise<Worksheet> {
   try {
     const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
     const worksheet = await worksheetController.activatePicking(worksheetNo)
     const companyDomain: Domain = worksheet?.bizplace.company.domain
 
-    let releaseGood: ReleaseGood = worksheet.releaseGood
-
-    const orderSource: string = releaseGood.source
-    switch (orderSource) {
-      case ApplicationType.MMS:
-        // find for any existing marketplace store connections
-        const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-          where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
-          relations: ['marketplaceDistributors']
-        })
-
-        if (marketplaceStores?.length) {
-          if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-            const worksheetDetails = worksheet.worksheetDetails
-            let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
-            const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-            await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
-          }
-
-          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { orderNo: releaseGood.refNo, domain: companyDomain },
-            relations: ['marketplaceStore']
-          })
+  let releaseGood: ReleaseGood = worksheet.releaseGood
+  const orderSource: string = releaseGood.source
+
+  const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+    where: { orderNo: releaseGood.refNo, domain: companyDomain },
+    relations: ['marketplaceStore']
+  })
+
+  switch (orderSource) {
+    case ApplicationType.MMS:
+      // find for any existing marketplace store connections
+      const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+        where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+        relations: ['marketplaceDistributors']
+      })
+
+      if (marketplaceStores?.length) {
+        if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+          const worksheetDetails = worksheet.worksheetDetails
+          let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+          await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
+        }
 
           if (marketplaceOrder) {
             const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
 
-            if (marketplaceStore.isAutoUpdateShipment) {
-              const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-              await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
-            }
+          if (marketplaceStore.isAutoUpdateShipment) {
+            const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+            await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
           }
+
+          await ecommerceCtrl.createOrderPackage(tx, marketplaceOrder, companyDomain, marketplaceStore, releaseGood)
         }
-        break
+      }
+      break
 
       default:
         break
     }
 
-    // if (releaseGood.type === 'b2c') {
-    //   const sellercraft: Sellercraft = await tx
-    //     .getRepository(Sellercraft)
-    //     .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
-
-    //   if (marketplaceStores?.length && !sellercraft) {
-    //     if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-    //       const worksheetDetails = worksheet.worksheetDetails
-    //       let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
-    //       const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-    //       await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
-    //     }
-
-    //     const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-    //       where: { orderNo: releaseGood.refNo, domain: companyDomain },
-    //       relations: ['marketplaceStore']
-    //     })
-
-    //     if (marketplaceOrder) {
-    //       const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-
-    //       if (marketplaceStore.isAutoUpdateShipment) {
-    //         const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-    //         await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
-    //       }
-    //     }
-    //   }
-    // }
-    return worksheet
-  } catch (error) {
-    throw error
-  } finally {
-    ActiveWorksheetPickingView.refreshView()
+  if (
+    releaseGood?.orderPackages?.length &&
+    releaseGood.lmdOption &&
+    releaseGood.lastMileDelivery &&
+    releaseGood?.orderPackages?.some(op => op.parcelId == null)
+  ) {
+    await createLmdParcel([releaseGood], tx, domain, user, marketplaceOrder)
+
+    //where to trigger update parcel count
+    let countParcel = releaseGood?.countParcel ? releaseGood.countParcel : 0
+    const releaseGoodId = releaseGood?.id
+
+    await tx.getRepository(ReleaseGood).update(
+      { id: releaseGoodId },
+      {
+        countParcel: countParcel+1,
+        updater: user.id
+      }
+    )
   }
 
+  return worksheet
+} catch (error) {
+  throw error
+} finally {
+  ActiveWorksheetPickingView.refreshView()
+}
 }