@things-factory/sales-base 4.3.523 → 4.3.524

package/server/controllers/ecommerce/powrup-controller.ts

@@ -1,5 +1,5 @@
 import { EntityManager, getConnection, getRepository } from 'typeorm'
-
+import { v4 as uuidv4 } from 'uuid'
 import { Bizplace } from '@things-factory/biz-base'
 import { logger } from '@things-factory/env'
 import { Platform, Powrup, PowrupAPI } from '@things-factory/integration-powrup'
@@ -14,6 +14,7 @@ import { OrderProduct } from '../../service/order-product/order-product'
 import { ReleaseGood } from '../../service/release-good/release-good'
 import { OrderNoGenerator } from '../../utils'
 import { DateTimeDifference } from '../../utils/datetime-util'
+import { OrderConsignment } from '../../service/order-consignment/order-consignment'
 
 const { PerformanceObserver, performance } = require('node:perf_hooks')
 
@@ -35,9 +36,7 @@ export class PowrupController {
 
     try {
       const orderProducts: OrderProduct[] = releaseGood.orderProducts
-      const orderInformation: any = {
-        refOrderId: releaseGood.refOrderId
-      }
+      const orderInformation: any = { refOrderId: releaseGood.refOrderId }
 
       if (
         releaseGood?.lastMarketPackCall &&
@@ -56,47 +55,57 @@ export class PowrupController {
         context: { state: { domain: domain || null, user: user || null } }
       })
       performance.mark(`end:${releaseGood.refOrderId}`)
+
       if (orderPack?.packages) {
         const packages: any[] = orderPack.packages
-
         await Promise.all(
           packages.map(async pkg => {
             const items = pkg.items
-            const orderPackage: any = {
-              name: OrderNoGenerator.orderPackage(),
-              packageId: pkg.packageId,
-              status: ORDER_STATUS.PROCESSING,
-              releaseGood,
-              domain: releaseGood.domain,
-              bizplace: releaseGood.bizplace,
-              creator: releaseGood.creator,
-              updater: releaseGood.updater
-            }
-
-            let savedOrderPackage: OrderPackage = await trxMgr.getRepository(OrderPackage).save(orderPackage)
 
-            const orderPackageItems: OrderPackageItem[] = items.map(itm => {
-              const { refCode, qty } = itm
-              if (!refCode) {
-                throw new Error(`universalIdentifier missing`)
-              }
-              const matchedOrderProduct: OrderProduct = orderProducts.find(op => op.productDetail.refCode == refCode)
+            const isMps = releaseGood?.lastMileDelivery?.mps
 
-              return {
-                name: OrderNoGenerator.orderPackageItem(),
-                orderProduct: matchedOrderProduct,
+            if (isMps) {
+              let newReleaseGood = await splitOrderConsignment(trxMgr, releaseGood, items, user)
+              await updatePackageId(packages, releaseGood, trxMgr)
+            } else {
+              let orderConsignment = await createOrderConsignment(trxMgr, releaseGood, user)
+              const orderPackage: any = {
+                name: OrderNoGenerator.orderPackage(),
+                packageId: pkg.packageId,
                 status: ORDER_STATUS.PROCESSING,
-                releaseQty: qty,
-                orderPackage: savedOrderPackage,
+                releaseGood,
+                orderConsignment,
                 domain: releaseGood.domain,
                 bizplace: releaseGood.bizplace,
                 creator: releaseGood.creator,
-                updater: releaseGood.updater,
-                productDetail: matchedOrderProduct?.productDetail
+                updater: releaseGood.updater
               }
-            })
 
-            await trxMgr.getRepository(OrderPackageItem).save(orderPackageItems)
+              let savedOrderPackage: OrderPackage = await trxMgr.getRepository(OrderPackage).save(orderPackage)
+
+              const orderPackageItems: OrderPackageItem[] = items.map(itm => {
+                const { refCode, qty } = itm
+                if (!refCode) {
+                  throw new Error(`universalIdentifier missing`)
+                }
+                const matchedOrderProduct: OrderProduct = orderProducts.find(op => op.productDetail.refCode == refCode)
+
+                return {
+                  name: OrderNoGenerator.orderPackageItem(),
+                  orderProduct: matchedOrderProduct,
+                  status: ORDER_STATUS.PROCESSING,
+                  releaseQty: qty,
+                  orderPackage: savedOrderPackage,
+                  domain: releaseGood.domain,
+                  bizplace: releaseGood.bizplace,
+                  creator: releaseGood.creator,
+                  updater: releaseGood.updater,
+                  productDetail: matchedOrderProduct?.productDetail
+                }
+              })
+
+              await trxMgr.getRepository(OrderPackageItem).save(orderPackageItems)
+            }
           })
         )
 
@@ -230,8 +239,9 @@ export class PowrupController {
     }
 
     try {
-      let orderPackages: OrderPackage[] = await (trxMgr?.getRepository(OrderPackage) || getRepository(OrderPackage))
-        .find({ where: { releaseGood } })
+      let orderPackages: OrderPackage[] = await (
+        trxMgr?.getRepository(OrderPackage) || getRepository(OrderPackage)
+      ).find({ where: { releaseGood } })
 
       if (orderPackages?.length) {
         await Promise.all(
@@ -270,7 +280,10 @@ export class PowrupController {
                   updater: user
                 }
 
-                await (trxMgr?.getRepository(OrderPackage) || getRepository(OrderPackage)).update({ id: op.id }, { ...updateInfo })
+                await (trxMgr?.getRepository(OrderPackage) || getRepository(OrderPackage)).update(
+                  { id: op.id },
+                  { ...updateInfo }
+                )
               }
             } catch (error) {
               performance.mark(`end:${releaseGood.refOrderId} - ${op.packageId}`)
@@ -285,7 +298,9 @@ export class PowrupController {
           })
         )
 
-        releaseGood = await (trxMgr?.getRepository(ReleaseGood) || getRepository(ReleaseGood)).findOne({ id: releaseGood.id })
+        releaseGood = await (trxMgr?.getRepository(ReleaseGood) || getRepository(ReleaseGood)).findOne({
+          id: releaseGood.id
+        })
       }
 
       return releaseGood
@@ -369,3 +384,359 @@ export class PowrupController {
     }
   }
 }
+
+export async function createOrderConsignment(
+  tx: EntityManager,
+  releaseGood: ReleaseGood,
+  user?: User,
+  orderCons?: OrderConsignment
+): 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
+    }
+
+    return tx.getRepository(OrderConsignment).save(orderConsignment)
+  } catch (e) {
+    logger.error(`[lmd-create-order-consignment]: ${e} `)
+  }
+}
+
+export async function sortingProduct(items, releaseGood): Promise<any> {
+  try {
+    let orderProducts: OrderProduct[] = releaseGood.orderProducts
+
+    const sortedMatchedOrderProducts = items
+      .map(itm => {
+        const { refCode, qty } = itm
+        if (!refCode) {
+          throw new Error(`universalIdentifier missing`)
+        }
+        // Find matched order product for each item
+        return orderProducts.find(op => op.productDetail.refCode === refCode) || null
+      })
+      .filter(item => item) // Filter out any null values
+      .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 sortedMatchedOrderProducts
+  } catch (e) {
+    logger.error(`[lmd-sort-product]: ${e} `)
+  }
+}
+
+export async function splitOrderConsignment(
+  tx: EntityManager,
+  releaseGood: ReleaseGood,
+  items: any,
+  user: User
+): Promise<any> {
+  try {
+    let currentConsignment = { id: uuidv4(), totalWeight: 0, orderPackages: [] }
+    let totalConsignments = []
+    let currOrderProducts = []
+    let totalConsignmentWeight = 0
+
+    let orderProducts = releaseGood.orderProducts
+    let maxConsignmentWeight = releaseGood.lastMileDelivery.consignmentWeight
+
+    //sort items from packOrder API
+    let sortItems = await sortingProduct(items, releaseGood)
+
+    //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 + packageWeight >= 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)
+      }
+    }
+
+    sortItems.forEach(item => {
+      let productDetail: ProductDetail = item.productDetail
+      if (productDetail.packingType.toLowerCase() === 'carton') {
+        for (let i = 0; i < item.releaseQty; i++) {
+          createPackage(item)
+        }
+      } else {
+        createPackage(item)
+      }
+    })
+
+    // 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,
+              orderProducts: 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,
+              orderProduct: 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)
+          }
+        }
+      }
+    }
+
+    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)
+
+    return newReleaseGood
+  } catch (e) {
+    logger.error(e)
+  }
+}
+
+export async function createConsignmentWithMultipackage(
+  tx: EntityManager,
+  orderConsList: OrderConsignment[],
+  releaseGood: ReleaseGood,
+  user: User
+): Promise<any> {
+  try {
+    let newOrderPackages = []
+    let newOrderConsignments: OrderConsignment[] = []
+
+    for (const orderCons of orderConsList) {
+      const savedOrderConsignment = await createOrderConsignment(tx, releaseGood, user, orderCons)
+
+      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 createConsignmentPackage(
+  tx: EntityManager,
+  orderPackageData: any,
+  releaseGood: ReleaseGood,
+  user: User,
+  orderConsignment: OrderConsignment
+): Promise<OrderPackage> {
+  try {
+    const orderPackage: any = {
+      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 = 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
+    }))
+
+    let savedOrderPackageItems: OrderPackageItem[] = await tx.getRepository(OrderPackageItem).save(orderPackageItems)
+
+    return savedOrderPackageItems
+  } catch (e) {
+    logger.error(`[lmd-create-order-package]: ${e} `)
+  }
+}
+
+export async function updatePackageId(packages, releaseGood, trxMgr) {
+  try {
+    const orderPackage = await trxMgr.getRepository(OrderPackage).findOne({
+      where: { releaseGood: { id: releaseGood.id } },
+      relations: ['releaseGood']
+    })
+    if (orderPackage) {
+      await trxMgr.getRepository(OrderPackage).update(
+        { name: orderPackage.name },
+        {
+          packageId: packages[0].packageId
+        }
+      )
+    }
+  } catch (e) {
+    logger.error('unable-to-update-package-id-powrup')
+  }
+}

package/server/controllers/ecommerce/webspert-controller.ts

@@ -2,22 +2,29 @@ import { EntityManager, getConnection, getRepository } from 'typeorm'
 
 import { logger } from '@things-factory/env'
 import { Domain, User } from '@things-factory/shell'
-import { sleep } from '@things-factory/utils'
+import { config } from '@things-factory/env'
+
 import { WebspertController as BaseWebspertController } from '@things-factory/warehouse-base'
 
 import { ORDER_STATUS } from '../../constants'
-import { OrderPackage, OrderPackageItem, OrderProduct, ReleaseGood } from '../../service'
+import { ReleaseGood, OrderProduct, OrderPackageItem, OrderPackage } from '../../service'
+
+import { sleep } from '@things-factory/utils'
 import { OrderNoGenerator } from '../../utils'
 
 export class WebspertController {
-  public static async packOrder(releaseGood: ReleaseGood, domain: Domain, user: User) {
+  public static async packOrder(
+    releaseGood: ReleaseGood,
+    domain: Domain,
+    user: User
+  ) {
     await getConnection().transaction(async trx => {
       releaseGood = await trx.getRepository(ReleaseGood).findOne({ where: { id: releaseGood.id, domain } })
 
       // let releaseOrder = await trx.getRepository(ReleaseGood).findOne({ refNo: releaseGood.refNo, refNo2: releaseGood.refNo2, refNo3: releaseGood.refNo3, domain })
 
       // // only recall if releaseGood exists and pack Order fail
-      if (!releaseGood && !releaseGood?.marketPackCallSuccess) return false
+      if (!releaseGood && (releaseGood.packOrderFail == false)) return false
 
       try {
         let results = await BaseWebspertController.sendRequestToAPI(
@@ -44,22 +51,20 @@ export class WebspertController {
     })
   }
 
-  public static async fetchPackageAndDocument(releaseGood: ReleaseGood, domain: Domain, user: User) {
+  public static async fetchPackageAndDocument(
+    releaseGood: ReleaseGood,
+    domain: Domain,
+    user: User
+  ) {
     await getConnection().transaction(async trx => {
       let roUpdateFields: Partial<ReleaseGood> = null
 
       let releaseOrder = await trx.getRepository(ReleaseGood).findOne({
         where: { id: releaseGood.id, domain },
-        relations: [
-          'bizplace',
-          'domain',
-          'orderProducts',
-          'orderProducts.productDetail',
-          'orderProducts.productDetail.product'
-        ]
+        relations: ['bizplace', 'domain', 'orderProducts', 'orderProducts.productDetail', 'orderProducts.productDetail.product']
       })
 
-      if (releaseOrder && releaseOrder.marketPackCallSuccess) {
+      if (releaseOrder) {
         try {
           // capture update fields
           roUpdateFields = {
@@ -98,12 +103,13 @@ export class WebspertController {
     releaseGood: ReleaseGood,
     orderPackages: OrderPackage[],
     domain: Domain,
-    user: User
+    user: User,
   ) {
     if (orderPackages == null || orderPackages.length == 0) {
       if (releaseGood) {
         orderPackages = await getRepository(OrderPackage).find({ where: { releaseGood } })
-      } else {
+      }
+      else {
         console.error('webspert-controller[initiateShipment]: releaseGood is not found')
         return false
       }
@@ -137,13 +143,18 @@ export class WebspertController {
     })
   }
 
-  public static async triggerOrderProcesses(releaseGood: ReleaseGood, domain: Domain, user: User, triggerRTS: false) {
+  public static async triggerOrderProcesses(
+    releaseGood: ReleaseGood,
+    domain: Domain,
+    user: User,
+    triggerRTS: false
+  ) {
     try {
       const waitTime = 200
 
       releaseGood = await getRepository(ReleaseGood).findOne({ where: { id: releaseGood.id, domain } })
       // // only recall if fail
-      if (!releaseGood?.marketPackCallSuccess) {
+      if (releaseGood.packOrderFail == false || releaseGood.packOrderFail === null) {
         await this.packOrder(releaseGood, domain, user)
         await sleep(waitTime)
       }
@@ -156,6 +167,7 @@ export class WebspertController {
       }
 
       return true
+
     } catch (error) {
       logger.error(error)
     }
@@ -168,17 +180,16 @@ async function updateRO(releaseGoodId, roUpdateFields, trxMgr) {
   }
 }
 
-async function generatePackage(releaseGood: ReleaseGood, packages: any[], user: User, trxMgr: EntityManager) {
+async function generatePackage(
+  releaseGood: ReleaseGood,
+  packages: any[],
+  user: User,
+  trxMgr: EntityManager
+) {
   if (packages.length > 0) {
     packages = await Promise.all(
       packages.map(async pkg => {
-        const [items, awbUrl, packageId, trackingNo, transporter] = [
-          pkg.products,
-          pkg.awb_link,
-          pkg.package_id,
-          pkg.tracking_number,
-          pkg.transporter
-        ]
+        const [items, awbUrl, packageId, trackingNo, transporter] = [pkg.products, pkg.awb_link, pkg.package_id, pkg.tracking_number, pkg.transporter]
 
         if (items.length < 1) {
           throw new Error('No items found in package')
@@ -224,16 +235,12 @@ async function generatePackage(releaseGood: ReleaseGood, packages: any[], user:
             if (!sku) {
               throw new Error(`universalIdentifier missing`)
             }
-            const matchedOrderPackageItem: OrderPackageItem = orderPackageItems.find(
-              op => op.productDetail.product.sku == sku && op.releaseQty == qty
-            )
+            const matchedOrderPackageItem: OrderPackageItem = orderPackageItems.find(op => op.productDetail.product.sku == sku && op.releaseQty == qty)
 
             if (matchedOrderPackageItem) {
               return matchedOrderPackageItem
             } else {
-              const matchedOrderProduct: OrderProduct = releaseGood.orderProducts.find(
-                op => op.productDetail.product.sku == sku
-              )
+              const matchedOrderProduct: OrderProduct = releaseGood.orderProducts.find(op => op.productDetail.product.sku == sku)
               return {
                 name: OrderNoGenerator.orderPackageItem(),
                 orderProduct: matchedOrderProduct,
@@ -275,8 +282,6 @@ async function generatePackage(releaseGood: ReleaseGood, packages: any[], user:
 }
 
 async function updatePackOrderStatus(trx, releaseOrder, status: Boolean = false) {
-  await trx
-    .getRepository(ReleaseGood)
-    .update({ id: releaseOrder.id }, { lastMarketPackCall: new Date(), packOrderFail: status })
+  await trx.getRepository(ReleaseGood).update({ id: releaseOrder.id }, { lastMarketPackCall: new Date(), packOrderFail: status })
   return true
-}
+}