@things-factory/worksheet-base 4.3.524 → 4.3.525

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

@@ -1,7 +1,6 @@
 import { EntityManager, Equal, getConnection, getManager, In, IsNull, Not } from 'typeorm'
-import { v4 as uuidv4 } from 'uuid'
 
-import { ApplicationType, User } from '@things-factory/auth-base'
+import { ApplicationType } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { logger } from '@things-factory/env'
 import { generateId } from '@things-factory/id-rule-base'
@@ -27,7 +26,6 @@ import {
   OrderToteItem,
   OrderToteSeal,
   OrderVas,
-  OrderConsignment,
   PowrupController,
   ReleaseGood,
   WebspertController
@@ -54,7 +52,6 @@ import { SellercraftController } from '../../controllers'
 import { ActiveWorksheetPickingView, Worksheet, WorksheetDetail } from '../../entities'
 import { inventoriesByStrategy, isInventoryObsolete, WorksheetNoGenerator } from '../../utils'
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
-import { sortingProductResolver } from 'server/graphql/resolvers/worksheet/sorting/sorting-product'
 
 export class PickingWorksheetController extends VasWorksheetController {
   async generatePickingWorksheet(releaseGoodNo: string, currentStatus: string = null): Promise<Worksheet> {
@@ -230,24 +227,6 @@ export class PickingWorksheetController extends VasWorksheetController {
       'releaseGood.domain',
       'releaseGood.lastMileDelivery',
       'releaseGood.bizplace.domain',
-      'releaseGood.orderProducts',
-      'releaseGood.orderProducts.productDetail',
-      'releaseGood.orderProducts.product',
-      'releaseGood.orderProducts.productDetail.product',
-      'releaseGood.orderProducts.productBundle',
-      'releaseGood.orderProducts.productBundle.productBundleSettings',
-      'releaseGood.orderProducts.productBundle.productBundleSettings.productDetail',
-      'releaseGood.orderPackages',
-      'releaseGood.orderPackages.orderPackageItems',
-      'releaseGood.orderPackages.orderPackageItems.orderProduct',
-      'releaseGood.orderPackages.orderPackageItems.orderProduct.product',
-      'releaseGood.orderPackages.orderPackageItems.orderProduct.productDetail',
-      'releaseGood.orderConsignments',
-      'releaseGood.orderConsignments.orderPackages',
-      'releaseGood.orderConsignments.orderPackages.orderPackageItems',
-      'releaseGood.orderConsignments.orderPackages.orderPackageItems.orderProduct',
-      'releaseGood.orderConsignments.orderPackages.orderPackageItems.orderProduct.product',
-      'releaseGood.orderConsignments.orderPackages.orderPackageItems.orderProduct.productDetail',
       'domain',
       'bizplace',
       'bizplace.domain',
@@ -284,7 +263,6 @@ export class PickingWorksheetController extends VasWorksheetController {
     worksheet.releaseGood = { ...worksheet.releaseGood, orderProducts, orderPackages }
 
     let releaseGood: ReleaseGood = Object.assign(new ReleaseGood(), worksheet.releaseGood)
-    let newReleaseGood: ReleaseGood
 
     // assign inventory if unassigned
     if (!releaseGood.assignedInventory) {
@@ -390,37 +368,22 @@ export class PickingWorksheetController extends VasWorksheetController {
 
         default:
           if (!releaseGood?.orderPackages?.length) {
-            let mps = releaseGood?.lastMileDelivery?.mps
-            switch (mps) {
-              case true:
-                newReleaseGood = await splitOrderConsignment(this.trxMgr, releaseGood, this.user, this.domain)
-                break
-              case false:
-              case undefined:
-                let orderConsignment: OrderConsignment = await createOrderConsignment(
-                  this.trxMgr,
-                  {},
-                  releaseGood,
-                  this.user
-                )
-                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: this.user,
-                  updater: this.user,
-                  orderConsignment: orderConsignment
-                }
-                newReleaseGood = await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
-                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: this.user,
+              updater: this.user
             }
+            worksheet.releaseGood = await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
+            //worksheet.releaseGood = releaseGood
           }
           break
       }
@@ -428,10 +391,6 @@ export class PickingWorksheetController extends VasWorksheetController {
       logger.error(`picking-worksheet-controller[activatePicking]: ${error}`)
     }
 
-    if (newReleaseGood) {
-      worksheet.releaseGood = newReleaseGood
-    }
-
     return worksheet
   }
 
@@ -447,19 +406,13 @@ export class PickingWorksheetController extends VasWorksheetController {
         .leftJoinAndSelect('w.releaseGood', 'rg')
         .leftJoinAndSelect('rg.domain', 'rgd')
         .leftJoinAndSelect('rg.lastMileDelivery', 'lmd')
-        .leftJoinAndSelect('rg.orderPackages', 'op')
-        .leftJoinAndSelect('op.orderPackageItems', 'opi')
-        .leftJoinAndSelect('opi.orderProduct', 'op2')
+        .leftJoinAndSelect('rg.orderPackages', 'rgop')
+        .leftJoinAndSelect('rgop.orderPackageItems', 'rgopi')
+        .leftJoinAndSelect('rgopi.orderProduct', 'op2')
         .leftJoinAndSelect('op2.product', 'p')
         .leftJoinAndSelect('op2.productDetail', 'pd')
-        .leftJoinAndSelect('rg.orderConsignments', 'oc')
-        .leftJoinAndSelect('oc.orderPackages', 'ocop')
-        .leftJoinAndSelect('ocop.orderPackageItems', 'ocpi')
-        .leftJoinAndSelect('ocpi.orderProduct', 'ocp2')
-        .leftJoinAndSelect('ocp2.product', 'ocp')
-        .leftJoinAndSelect('ocp2.productDetail', 'ocpd')
-        .leftJoinAndSelect('rg.bizplace', 'rgb')
-        .leftJoinAndSelect('rgb.domain', 'rgbd')
+        .leftJoinAndSelect('rg.bizplace', 'rgbz')
+        .leftJoinAndSelect('rgbz.domain', 'bzd')
         .leftJoinAndSelect('b.domain', 'bd')
         .leftJoinAndSelect('b.company', 'c')
         .leftJoinAndSelect('c.domain', 'cd')
@@ -530,7 +483,8 @@ export class PickingWorksheetController extends VasWorksheetController {
     } else {
       const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
         let targetInventory: OrderInventory = wsd.targetInventory
-        targetInventory.status = ORDER_INVENTORY_STATUS.PICKING
+        targetInventory.status =
+          targetInventory.status != 'PENDING_CANCEL' ? ORDER_INVENTORY_STATUS.PICKING : targetInventory.status
         targetInventory.updater = this.user
 
         return targetInventory
@@ -555,13 +509,7 @@ export class PickingWorksheetController extends VasWorksheetController {
         'releaseGood.orderPackages.orderPackageItems.orderProduct.productDetail',
         'releaseGood.orderProducts',
         'releaseGood.orderProducts.productDetail',
-        'releaseGood.orderProducts.product',
-        'releaseGood.orderConsignments',
-        'releaseGood.orderConsignments.orderPackages',
-        'releaseGood.orderConsignments.orderPackages.orderPackageItems',
-        'releaseGood.orderConsignments.orderPackages.orderPackageItems.orderProduct',
-        'releaseGood.orderConsignments.orderPackages.orderPackageItems.orderProduct.product',
-        'releaseGood.orderConsignments.orderPackages.orderPackageItems.orderProduct.productDetail'
+        'releaseGood.orderProducts.product'
       ]
     })
 
@@ -638,37 +586,21 @@ export class PickingWorksheetController extends VasWorksheetController {
 
               default:
                 if (!releaseGood?.orderPackages?.length) {
-                  let mps = releaseGood?.lastMileDelivery?.mps
-                  switch (mps) {
-                    case true:
-                      await splitOrderConsignment(this.trxMgr, releaseGood, this.user, this.domain)
-                      break
-                    case false:
-                    case undefined:
-                      let orderConsignment: OrderConsignment = await createOrderConsignment(
-                        this.trxMgr,
-                        {},
-                        releaseGood,
-                        this.user
-                      )
-                      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: this.user,
-                        updater: this.user,
-                        orderConsignment: orderConsignment
-                      }
-                      await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
-                      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: this.user,
+                    updater: this.user
                   }
+                  releaseGood = await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
                 }
                 break
             }
@@ -678,7 +610,7 @@ export class PickingWorksheetController extends VasWorksheetController {
 
           return {
             ...releaseGood,
-            status: ORDER_STATUS.PICKING,
+            status: releaseGood.status != 'PENDING_CANCEL' ? ORDER_STATUS.PICKING : releaseGood.status,
             updater: this.user,
             assignedInventory: true
           }
@@ -2622,12 +2554,6 @@ export class PickingWorksheetController extends VasWorksheetController {
               .leftJoinAndSelect('opc_opi.orderProduct', 'opi_op')
               .leftJoinAndSelect('opi_op.product', 'op_p2')
               .leftJoinAndSelect('opi_op.productDetail', 'op_pd2')
-              .leftJoinAndSelect('rg.orderConsignments', 'rg_oc')
-              .leftJoinAndSelect('rg_oc.orderPackages', 'oc_op')
-              .leftJoinAndSelect('oc_op.orderPackageItems', 'oc_opi')
-              .leftJoinAndSelect('oc_opi.orderProduct', 'opi_op2')
-              .leftJoinAndSelect('opi_op2.product', 'op_p3')
-              .leftJoinAndSelect('opi_op2.productDetail', 'op_pd3')
               .leftJoinAndSelect('w.domain', 'd')
               .leftJoinAndSelect('w.bizplace', 'b')
               .leftJoinAndSelect('b.company', 'c')
@@ -2737,42 +2663,28 @@ export class PickingWorksheetController extends VasWorksheetController {
               })
               break
 
-            case ApplicationType.MMS:
+            case ApplicationType.WEBSPERT:
+              // Trigger Whole Order Process
+              WebspertController.triggerOrderProcesses(releaseGood, this.domain, this.user)
               break
 
             default:
               if (!releaseGood?.orderPackages?.length) {
-                let mps = releaseGood?.lastMileDelivery?.mps
-                switch (mps) {
-                  case true:
-                    await splitOrderConsignment(this.trxMgr, releaseGood, this.user, this.domain)
-                    break
-                  case false:
-                  case undefined:
-                    let orderConsignment: OrderConsignment = await createOrderConsignment(
-                      this.trxMgr,
-                      {},
-                      releaseGood,
-                      this.user
-                    )
-                    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: this.user,
-                      updater: this.user,
-                      orderConsignment: orderConsignment
-                    }
-                    await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
-                    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: this.user,
+                  updater: this.user
                 }
+                await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
               }
               break
           }
@@ -2795,374 +2707,44 @@ export async function createOrderPackageAndItems(
   releaseGood: ReleaseGood,
   orderPackage: OrderPackage
 ): Promise<ReleaseGood> {
-  try {
-    let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
-
-    const orderPackageItems: OrderPackageItem[] = releaseGood.orderProducts
-      .map(op => {
-        if (op.product) {
-          return {
-            id: uuidv4(),
-            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]
-
-    return releaseGood
-  } catch (e) {
-    logger.error(`error:${e}`)
-  }
-}
-
-export async function splitOrderConsignment(
-  tx: EntityManager,
-  releaseGood: ReleaseGood,
-  user: User,
-  domain: Domain
-): Promise<any> {
-  try {
-    let currentConsignment = { id: uuidv4(), totalWeight: 0, orderPackages: [] }
-    let totalConsignments = []
-    let currOrderProducts = []
-    let totalConsignmentWeight = 0
-
-    let orderProducts: OrderProduct = releaseGood.orderProducts
-    let maxConsignmentWeight = releaseGood.lastMileDelivery.consignmentWeight
-
-    //sort product according to packingType
-    let sortOrderProducts = await sortingProduct(orderProducts)
-
-    //initialise new orderConsignment created
-    const createdNewConsignment = () => ({
-      id: uuidv4(),
-      totalWeight: 0,
-      orderPackages: []
-    })
-
-    //push orderPackage & packageItems into consigment
-    const createPackageConsignment = (consignment, packageWeight, releaseGood, orderProduct, releaseQty, user) => {
-      consignment.totalWeight += packageWeight
-
-      currentConsignment.orderPackages.push({
-        id: uuidv4(),
-        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: user,
-        updater: user,
-        orderPackageItems: [
-          {
-            id: uuidv4(),
-            name: OrderNoGenerator.orderPackageItem(),
-            releaseQty: releaseQty,
-            orderProduct: orderProduct,
-            domain: releaseGood.domain,
-            bizplace: releaseGood.bizplace,
-            creator: releaseGood.creator,
-            updater: releaseGood.updater,
-            productDetail: orderProduct.productDetail
-          }
-        ]
-      })
-    }
-
-    const createPackage = op => {
-      let releaseQty = op.productDetail.packingType.toLowerCase() === 'carton' ? 1 : op.releaseQty
-      let packageWeight =
-        op.productDetail.packingType.toLowerCase() === 'carton'
-          ? op.productDetail.grossWeight
-          : op.productDetail.grossWeight * releaseQty
-
-      const isCarton = op.productDetail.packingType.toLowerCase() === 'carton'
-      totalConsignmentWeight += packageWeight
-      const requiresNewConsignment = totalConsignmentWeight >= maxConsignmentWeight
-
-      if (isCarton || op.releaseQty > 1) {
-        if (requiresNewConsignment) {
-          //push the current consignment to create new consignment
-          totalConsignments.push(currentConsignment)
-
-          //Initialise the totalConsignment weight to the new data
-          totalConsignmentWeight = packageWeight + 0
-          currentConsignment = createdNewConsignment()
-        }
-        createPackageConsignment(currentConsignment, packageWeight, releaseGood, op, releaseQty, user)
-      } else {
-        currOrderProducts.push(op)
-      }
-    }
+  let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
 
-    sortOrderProducts.forEach(item => {
-      if (item.packingType.toLowerCase() === 'carton') {
-        for (let i = 0; i < item.releaseQty; i++) {
-          createPackage(item)
+  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 {
-        createPackage(item)
+        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()
 
-    // Add any remaining items to the last orderPackage
-    if (currOrderProducts.length > 0) {
-      let availableConsignment
-
-      for (let i = 0; i < currOrderProducts.length; i++) {
-        let op = currOrderProducts[i]
-        let releaseQty = op.releaseQty
-        let currProductWeight = op.productDetail.grossWeight * op.releaseQty
-        let lastOrderPackage = currentConsignment.orderPackages[currentConsignment.orderPackages.length - 1]
-
-        //push the product into last current consignment orderPackage
-        if (currentConsignment.totalWeight + currProductWeight < maxConsignmentWeight) {
-          if (lastOrderPackage) {
-            lastOrderPackage.orderPackageItems.push({
-              id: uuidv4(),
-              name: OrderNoGenerator.orderPackageItem(),
-              releaseQty: op.releaseQty,
-              orderProduct: op,
-              domain: releaseGood.domain,
-              bizplace: releaseGood.bizplace,
-              creator: releaseGood.creator,
-              updater: releaseGood.updater,
-              productDetail: op.productDetail
-            })
-          } else {
-            await createPackageConsignment(currentConsignment, currProductWeight, releaseGood, op, releaseQty, user)
-          }
-        } else {
-          //push the currentConsignment into list of all the consignments
-          if (!totalConsignments.some(tc => tc.id === currentConsignment.id)) {
-            totalConsignments.push(currentConsignment)
-          }
-
-          //find one  order consignment to include the product
-          availableConsignment = totalConsignments.find(tc => {
-            tc.totalWeight += currProductWeight < maxConsignmentWeight
-          })
-
-          if (availableConsignment) {
-            let lastOrderPackage = availableConsignment.orderPackages[currentConsignment.orderPackages.length - 1]
-            lastOrderPackage.orderPackageItems.push({
-              id: uuidv4(),
-              name: OrderNoGenerator.orderPackageItem(),
-              releaseQty: op.releaseQty,
-              orderProducts: op,
-              domain: releaseGood.domain,
-              bizplace: releaseGood.bizplace,
-              creator: releaseGood.creator,
-              updater: releaseGood.updater,
-              productDetail: op.productDetail
-            })
-
-            //update the totalConsignment data
-            totalConsignments = totalConsignments.map(tc => {
-              tc.id === availableConsignment.id ? availableConsignment : tc
-            })
-          } else {
-            //create new consignment if no consignment available
-            currentConsignment = createdNewConsignment()
-            createPackageConsignment(currentConsignment, currProductWeight, releaseGood, op, releaseQty, user)
-
-            totalConsignments.push(currentConsignment)
-          }
-        }
-      }
-    }
-
-    //totalConsignments.length < 1 ? totalConsignments.push(currentConsignment) : totalConsignments
-
-    const existingConsignment = totalConsignments.find(tc => tc.id === currentConsignment.id)
-
-    if (!existingConsignment) {
-      totalConsignments.push(currentConsignment)
-    }
-
-    let orderConsignment = totalConsignments
-    let newReleaseGood = await createConsignmentWithMultipackage(tx, orderConsignment, releaseGood, user, domain)
-
-    return newReleaseGood
-  } catch (e) {
-    logger.error(`[lmd-create-consignment-notes]: ${e} `)
-  }
-}
-
-export async function createOrderConsignment(
-  tx: EntityManager,
-  orderCons: OrderConsignment,
-  releaseGood: ReleaseGood,
-  user: User
-): Promise<OrderConsignment> {
-  try {
-    const orderConsignment: OrderConsignment = {
-      id: uuidv4(),
-      name: OrderNoGenerator.orderConsignment(),
-      noOfPackages: orderCons?.orderPackages?.length ? orderCons.orderPackages.length : 1,
-      domain: releaseGood.domain,
-      bizplace: releaseGood.bizplace,
-      releaseGood: releaseGood,
-      orderPackages: [],
-      creator: user,
-      updater: user
-    }
+  await tx.getRepository(OrderPackageItem).save(orderPackageItems)
+  orderPackage.orderPackageItems = orderPackageItems
+  releaseGood.orderPackages = [orderPackage]
 
-    return tx.getRepository(OrderConsignment).save(orderConsignment)
-  } catch (e) {
-    logger.error(`[lmd-create-order-consignment]: ${e} `)
-  }
-}
-
-export async function createConsignmentPackage(
-  tx: EntityManager,
-  orderPackageData: any,
-  releaseGood: ReleaseGood,
-  user: User,
-  orderConsignment: OrderConsignment
-): Promise<OrderPackage> {
-  try {
-    const orderPackage: OrderPackage = {
-      id: uuidv4(),
-      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: user,
-      updater: user,
-      orderConsignment
-    }
-    return tx.getRepository(OrderPackage).save(orderPackage)
-  } catch (e) {
-    logger.error(`[lmd-create-order-package]: ${e} `)
-  }
-}
-
-export async function createConsignmentPackageItem(
-  tx: EntityManager,
-  orderPackageItemsData: any[],
-  savedOrderPackage: OrderPackage,
-  releaseGood: ReleaseGood
-): Promise<OrderPackageItem[]> {
-  try {
-    const orderPackageItems: OrderPackageItem[] = orderPackageItemsData.map(opi => ({
-      id: opi.id,
-      name: opi.name,
-      orderProduct: opi.orderProduct,
-      status: ORDER_STATUS.PROCESSING,
-      releaseQty: opi.releaseQty,
-      orderPackage: savedOrderPackage,
-      domain: releaseGood.domain,
-      bizplace: releaseGood.bizplace,
-      creator: releaseGood.creator,
-      updater: releaseGood.updater,
-      productDetail: opi.productDetail
-    }))
-
-    await tx.getRepository(OrderPackageItem).save(orderPackageItems)
-    return orderPackageItems
-  } catch (e) {
-    logger.error(`[lmd-create-order-package]: ${e} `)
-  }
-}
-
-export async function createConsignmentWithMultipackage(
-  tx: EntityManager,
-  orderConsList: OrderConsignment[],
-  releaseGood: ReleaseGood,
-  user: User,
-  domain: Domain
-): Promise<any> {
-  try {
-    let newOrderPackages = []
-    let newOrderConsignments: OrderConsignment = []
-
-    for (const orderCons of orderConsList) {
-      const savedOrderConsignment = await createOrderConsignment(tx, orderCons, releaseGood, user)
-
-      for (const currentPackage of orderCons.orderPackages) {
-        const savedOrderPackage = await createConsignmentPackage(
-          tx,
-          currentPackage,
-          releaseGood,
-          user,
-          savedOrderConsignment
-        )
-        const orderPackageItems = await createConsignmentPackageItem(
-          tx,
-          currentPackage.orderPackageItems,
-          savedOrderPackage,
-          releaseGood
-        )
-
-        savedOrderPackage.orderPackageItems = orderPackageItems
-        savedOrderConsignment.orderPackages.push(savedOrderPackage)
-        newOrderPackages.push(savedOrderPackage)
-      }
-      newOrderConsignments.push(savedOrderConsignment)
-    }
-
-    releaseGood.orderConsignments = newOrderConsignments
-    releaseGood.orderPackages = newOrderPackages
-
-    return releaseGood
-  } catch (error) {
-    console.error('Error creating consignment with multiple packages:', error)
-    throw error
-  }
-}
-
-export async function sortingProduct(orderProducts): Promise<any> {
-  try {
-    orderProducts.sort((a, b) => {
-      if (a.product.packingType !== b.product.packingType) {
-        return a.product.packingType < b.product.packingType ? -1 : 1
-      }
-      if (a.product.sku !== b.product.sku) {
-        return a.product.sku < b.product.sku ? -1 : 1
-      }
-      return 0
-    })
-    return orderProducts
-  } catch (e) {
-    logger.error(`[lmd-sort-product]: ${e} `)
-  }
+  return releaseGood
 }