@things-factory/worksheet-base 4.3.539 → 4.3.541

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

@@ -1,6 +1,7 @@
 import { EntityManager, Equal, getConnection, getManager, In, IsNull, Not } from 'typeorm'
+import { v4 as uuidv4 } from 'uuid'
 
-import { ApplicationType } from '@things-factory/auth-base'
+import { ApplicationType, User } 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'
@@ -26,6 +27,7 @@ import {
   OrderToteItem,
   OrderToteSeal,
   OrderVas,
+  OrderConsignment,
   PowrupController,
   ReleaseGood,
   WebspertController
@@ -52,6 +54,7 @@ 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> {
@@ -260,9 +263,21 @@ export class PickingWorksheetController extends VasWorksheetController {
       ]
     })
 
-    worksheet.releaseGood = { ...worksheet.releaseGood, orderProducts, orderPackages }
+    let orderConsignments: OrderConsignment[] = await this.trxMgr.getRepository(OrderConsignment).find({
+      where: { releaseGood: worksheet.releaseGood },
+      relations: [
+        'orderPackages',
+        'orderPackages.orderPackageItems',
+        'orderPackages.orderPackageItems.orderProduct',
+        'orderPackages.orderPackageItems.orderProduct.product',
+        'orderPackages.orderPackageItems.orderProduct.productDetail'
+      ]
+    })
+
+    worksheet.releaseGood = { ...worksheet.releaseGood, orderProducts, orderPackages, orderConsignments }
 
     let releaseGood: ReleaseGood = Object.assign(new ReleaseGood(), worksheet.releaseGood)
+    let newReleaseGood: ReleaseGood
 
     // assign inventory if unassigned
     if (!releaseGood.assignedInventory) {
@@ -370,22 +385,37 @@ export class PickingWorksheetController extends VasWorksheetController {
 
         default:
           if (!releaseGood?.orderPackages?.length) {
-            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
+            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
             }
-            worksheet.releaseGood = await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
-            //worksheet.releaseGood = releaseGood
           }
           break
       }
@@ -393,6 +423,10 @@ export class PickingWorksheetController extends VasWorksheetController {
       logger.error(`picking-worksheet-controller[activatePicking]: ${error}`)
     }
 
+    if (newReleaseGood) {
+      worksheet.releaseGood = newReleaseGood
+    }
+
     return worksheet
   }
 
@@ -408,13 +442,19 @@ export class PickingWorksheetController extends VasWorksheetController {
         .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('rg.orderPackages', 'op')
+        .leftJoinAndSelect('op.orderPackageItems', 'opi')
+        .leftJoinAndSelect('opi.orderProduct', 'op2')
         .leftJoinAndSelect('op2.product', 'p')
         .leftJoinAndSelect('op2.productDetail', 'pd')
-        .leftJoinAndSelect('rg.bizplace', 'rgbz')
-        .leftJoinAndSelect('rgbz.domain', 'bzd')
+        .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('b.domain', 'bd')
         .leftJoinAndSelect('b.company', 'c')
         .leftJoinAndSelect('c.domain', 'cd')
@@ -498,30 +538,52 @@ export class PickingWorksheetController extends VasWorksheetController {
     // retrieve order inventory
     const pickingOrderInventory: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
       where: { domain: this.domain, refWorksheetId: worksheet.id, status: ORDER_STATUS.PICKING },
-      relations: [
-        'releaseGood',
-        'releaseGood.domain',
-        'releaseGood.lastMileDelivery',
-        'releaseGood.bizplace',
-        'releaseGood.bizplace.domain',
-        'releaseGood.orderPackages',
-        'releaseGood.orderPackages.orderPackageItems',
-        'releaseGood.orderPackages.orderPackageItems.orderProduct',
-        'releaseGood.orderPackages.orderPackageItems.orderProduct.product',
-        'releaseGood.orderPackages.orderPackageItems.orderProduct.productDetail',
-        'releaseGood.orderProducts',
-        'releaseGood.orderProducts.productDetail',
-        'releaseGood.orderProducts.product'
-      ]
+      relations: ['releaseGood']
     })
 
-    let releaseGoods: ReleaseGood[] = pickingOrderInventory.reduce((data, oi: OrderInventory) => {
-      if (!data.find(x => x.id == oi.releaseGood.id)) {
-        data.push(oi.releaseGood)
+    const releaseGoodIds = pickingOrderInventory.reduce((data, order) => {
+      const id = order.releaseGood.id
+      if (!data.includes(id)) {
+        data.push(id)
       }
       return data
     }, [])
 
+    let releaseGoods: ReleaseGood[] = await this.trxMgr.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',
+        'orderConsignments',
+        'orderConsignments.orderPackages',
+        'orderConsignments.orderPackages.orderPackageItems',
+        'orderConsignments.orderPackages.orderPackageItems.orderProduct',
+        'orderConsignments.orderPackages.orderPackageItems.orderProduct.product',
+        'orderConsignments.orderPackages.orderPackageItems.orderProduct.productDetail'
+      ]
+    })
+
+    pickingOrderInventory.forEach(order => {
+      order.releaseGood = releaseGoods.find(rg => rg.id === order.releaseGood.id)
+    })
+
+    // let releaseGoodss: ReleaseGood[] = pickingOrderInventory.reduce((data, oi: OrderInventory) => {
+    //   if (!data.find(x => x.id == oi.releaseGood.id)) {
+    //     data.push(oi.releaseGood)
+    //   }
+    //   return data
+    // }, [])
+
     // massage data and trigger SC pack order asynchronously
     if (releaseGoods?.length) {
       releaseGoods = await Promise.all(
@@ -588,21 +650,37 @@ export class PickingWorksheetController extends VasWorksheetController {
 
               default:
                 if (!releaseGood?.orderPackages?.length) {
-                  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
+                  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
                   }
-                  releaseGood = await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
                 }
                 break
             }
@@ -618,7 +696,17 @@ export class PickingWorksheetController extends VasWorksheetController {
           }
         })
       )
-      await this.trxMgr.getRepository(ReleaseGood).save(releaseGoods)
+
+      await Promise.all(
+        releaseGoods.map(rg =>
+          this.trxMgr.getRepository(ReleaseGood).update(rg.id, {
+            status: rg.status,
+            updater: this.user,
+            assignedInventory: true,
+            updatedAt: () => 'CURRENT_TIMESTAMP'
+          })
+        )
+      )
     }
 
     for (const releaseGood of releaseGoods) {
@@ -2550,38 +2638,62 @@ export class PickingWorksheetController extends VasWorksheetController {
 
           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('rg_op.productBundle', 'op_pb')
-              .leftJoinAndSelect('op_pb.productBundleSettings', 'pb_ps')
-              .leftJoinAndSelect('pb_ps.productDetail', 'ps_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('b.company', 'c')
-              .leftJoinAndSelect('c.domain', 'c_d')
-              .leftJoinAndSelect('w.worksheetDetails', 'wd')
-              .leftJoinAndSelect('wd.targetInventory', 'ti')
-              .leftJoinAndSelect('ti.product', 'tp')
-              .where('w.id = :worksheetId', { worksheetId: worksheetId })
-              .andWhere('w.bizplace_id = :bizplaceId', { bizplaceId: bizplaceId })
-              .getOne()
+
+            let worksheet: Worksheet = await worksheetRepo.findOne({
+              where: { id: worksheetId, bizplace: bizplaceId },
+              relations: [
+                'domain',
+                'bizplace',
+                'bizplace.company',
+                'bizplace.company.domain',
+                'releaseGood',
+                'releaseGood.bizplace',
+                'releaseGood.domain',
+                'releaseGood.lastMileDelivery',
+                'releaseGood.bizplace.domain',
+                'worksheetDetails',
+                'worksheetDetails.targetInventory',
+                'worksheetDetails.targetInventory.product'
+              ]
+            })
 
             let worksheetDetails: WorksheetDetail[]
 
+            let orderProducts: OrderProduct[] = await tx.getRepository(OrderProduct).find({
+              where: { releaseGood: worksheet.releaseGood },
+              relations: [
+                'product',
+                'productDetail',
+                'productBundle',
+                'productBundle.productBundleSettings',
+                'productBundle.productBundleSettings.productDetail',
+                'productDetail.product'
+              ]
+            })
+
+            let orderPackages: OrderPackage[] = await tx.getRepository(OrderPackage).find({
+              where: { releaseGood: worksheet.releaseGood },
+              relations: [
+                'orderPackageItems',
+                'orderPackageItems.orderProduct',
+                'orderPackageItems.orderProduct.product',
+                'orderPackageItems.orderProduct.product.productDetails'
+              ]
+            })
+
+            let orderConsignments: OrderConsignment[] = await tx.getRepository(OrderConsignment).find({
+              where: { releaseGood: worksheet.releaseGood },
+              relations: [
+                'orderPackages',
+                'orderPackages.orderPackageItems',
+                'orderPackages.orderPackageItems.orderProduct',
+                'orderPackages.orderPackageItems.orderProduct.product',
+                'orderPackages.orderPackageItems.orderProduct.product.productDetails'
+              ]
+            })
+
+            worksheet.releaseGood = { ...worksheet.releaseGood, orderProducts, orderPackages, orderConsignments }
+
             if (worksheet.releaseGood?.assignedInventory == false) {
               worksheetDetails = await this.assignInventoriesForUnassignedOrder(worksheet, tx)
               worksheet.worksheetDetails = worksheetDetails
@@ -2683,23 +2795,42 @@ export class PickingWorksheetController extends VasWorksheetController {
               WebspertController.triggerOrderProcesses(releaseGood, this.domain, this.user)
               break
 
+            case ApplicationType.MMS:
+              break
+
             default:
               if (!releaseGood?.orderPackages?.length) {
-                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
+                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
                 }
-                await createOrderPackageAndItems(this.trxMgr, releaseGood, orderPackage)
               }
               break
           }
@@ -2722,44 +2853,375 @@ export async function createOrderPackageAndItems(
   releaseGood: ReleaseGood,
   orderPackage: OrderPackage
 ): Promise<ReleaseGood> {
-  let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
+  try {
+    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
+    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 {
-        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
-        }))
+        currOrderProducts.push(op)
+      }
+    }
+
+    sortOrderProducts.forEach(item => {
+      if (item.packingType.toLowerCase() === 'carton') {
+        for (let i = 0; i < item.releaseQty; i++) {
+          createPackage(item)
+        }
+      } else {
+        createPackage(item)
       }
     })
-    .flat()
 
-  await tx.getRepository(OrderPackageItem).save(orderPackageItems)
-  orderPackage.orderPackageItems = orderPackageItems
-  releaseGood.orderPackages = [orderPackage]
+    // 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
 
-  return releaseGood
+    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 {
+    let 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
+    }
+
+    orderConsignment = await tx.getRepository(OrderConsignment).save(orderConsignment)
+    return 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} `)
+  }
 }