@things-factory/sales-base 4.3.622 → 4.3.629

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

@@ -29,14 +29,19 @@ export class PowrupController {
     let roUpdateFields: Partial<ReleaseGood> = null
 
     const updateRO = async (releaseGoodId, roUpdateFields, trxMgr) => {
-      if (roUpdateFields) {
-        await trxMgr.getRepository(ReleaseGood).update({ id: releaseGoodId }, roUpdateFields)
+      try {
+        if (roUpdateFields) {
+          const result = await trxMgr.getRepository(ReleaseGood).save({ id: releaseGoodId }, roUpdateFields)
+        }
+      } catch (e) {
+        logger.error(e)
       }
     }
 
     try {
       const orderProducts: OrderProduct[] = releaseGood.orderProducts
       const orderInformation: any = { refOrderId: releaseGood.refOrderId }
+      const lmdOption = releaseGood?.lmdOption
 
       if (
         releaseGood?.lastMarketPackCall &&
@@ -49,112 +54,43 @@ export class PowrupController {
       roUpdateFields = {
         lastMarketPackCall: new Date()
       }
-      performance.mark(`start:${releaseGood.refOrderId}`)
-      const orderPack: any = await PowrupAPI.packOrder(powrup, {
-        ...orderInformation,
-        context: { state: { domain: domain || null, user: user || null } }
-      })
-      performance.mark(`end:${releaseGood.refOrderId}`)
-
-      if (orderPack?.packages) {
-        const packages: any[] = orderPack.packages
-
-        const createOrderPackageItems = (
-          orderProducts: OrderProduct[],
-          orderPackage: OrderPackage,
-          items: any[],
-          unassignedItems?: Boolean
-        ) => {
-          return items
-            .map(itm => {
-              const { refCode, qty, productDetail, releaseQty } = itm
-              if (!refCode && !unassignedItems) {
-                throw new Error(`universalIdentifier missing`)
-              }
-              const idx = orderProducts.findIndex(
-                op => op.productDetail?.refCode == refCode || op.productDetail?.refCode == productDetail?.refCode
-              )
-
-              const matchedOrderProduct: OrderProduct = idx !== -1 ? { ...orderProducts[idx] } : undefined
-
-              const matchedOrderPackageItem: OrderPackageItem = orderPackage?.orderPackageItems?.find(
-                itm => itm.orderProductId == matchedOrderProduct?.id
-              )
 
-              if (!matchedOrderProduct || orderProducts[idx].releaseQty <= 0) {
-                return null
-              }
+      // non-sof orders will trigger packOrder - create consignment - order package
+      if (!lmdOption) {
+        performance.mark(`start:${releaseGood.refOrderId}`)
+        const orderPack: any = await PowrupAPI.packOrder(powrup, {
+          ...orderInformation,
+          context: { state: { domain: domain || null, user: user || null } }
+        })
+        performance.mark(`end:${releaseGood.refOrderId}`)
 
-              const commonProperties = {
-                orderProduct: matchedOrderProduct,
-                status: ORDER_STATUS.PROCESSING,
-                orderPackage: orderPackage,
-                domain: releaseGood.domain,
-                bizplace: releaseGood.bizplace,
-                creator: user?.id,
-                updater: user?.id,
-                productDetail: matchedOrderProduct.productDetail
-              }
+        if (orderPack?.packages) {
+          const packages: any[] = orderPack.packages
 
-              // If an existing order package item is found, update its release quantity
-              if (matchedOrderPackageItem) {
-                return {
-                  ...commonProperties,
-                  id: matchedOrderPackageItem.id,
-                  name: matchedOrderPackageItem.name,
-                  releaseQty: (matchedOrderPackageItem.releaseQty || 0) + (releaseQty || 0)
-                }
-              }
+          await Promise.all(
+            packages.map(async pkg => {
+              const items = pkg.items
 
-              // Update release quantity of the matched order product
-              orderProducts[idx].releaseQty = (orderProducts[idx].releaseQty || 0) - (qty || 0)
-
-              // Return a new order package item if no existing item was found
-              return {
-                ...commonProperties,
-                name: OrderNoGenerator.orderPackageItem(),
-                releaseQty: releaseQty
-                  ? releaseQty
-                  : qty > matchedOrderProduct.releaseQty
-                  ? matchedOrderProduct.releaseQty
-                  : qty
-              }
-            })
-            .filter(item => item != null)
-        }
-        //
-
-        await Promise.all(
-          packages.map(async pkg => {
-            const items = pkg.items
-            const isMps = releaseGood?.lastMileDelivery?.mps
-
-            if (isMps) {
-              let newReleaseGood = await splitOrderConsignment(trxMgr, releaseGood, items, user)
-              await updatePackageId(packages, newReleaseGood, trxMgr)
-            } else {
               let orderConsignment = await createOrderConsignment(trxMgr, releaseGood, user)
-              const orderPackage: any = {
-                name: OrderNoGenerator.orderPackage(),
-                packageId: pkg.packageId,
-                status: ORDER_STATUS.PROCESSING,
+              let savedOrderPackage: OrderPackage = await this.createOrderPackage(
+                trxMgr,
                 releaseGood,
                 orderConsignment,
-                domain: releaseGood.domain,
-                bizplace: releaseGood.bizplace,
-                creator: user,
-                updater: user,
-                originalPackResponse: JSON.stringify(pkg)
-              }
-
-              let savedOrderPackage: OrderPackage = await trxMgr.getRepository(OrderPackage).save(orderPackage)
-              const orderPackageItems = createOrderPackageItems(orderProducts, savedOrderPackage, items, false)
+                user,
+                pkg
+              )
+              const orderPackageItems: OrderPackageItem[] = await this.createOrderPackageItems(
+                orderProducts,
+                savedOrderPackage,
+                items,
+                user,
+                false,
+                releaseGood
+              )
               await trxMgr.getRepository(OrderPackageItem).save(orderPackageItems)
-            }
-          })
-        )
+            })
+          )
 
-        if (!releaseGood?.lastMileDelivery?.mps) {
           const unassignedOrderProducts: OrderProduct[] = orderProducts.filter(op => {
             return (
               op.releaseQty > 0 ||
@@ -162,33 +98,83 @@ export class PowrupController {
             )
           })
 
-          if (unassignedOrderProducts?.length > 0) {
-            const orderPackages: OrderPackage[] = await trxMgr.getRepository(OrderPackage).find({
-              where: { releaseGood: releaseGood.id },
-              relations: ['orderPackageItems']
-            })
+          if (unassignedOrderProducts?.length > 0)
+            await this.unassignedOrderProducts(unassignedOrderProducts, releaseGood, user, trxMgr)
 
-            let selectedOrderPackage = orderPackages.reduce((minOrderPackage, currentOrderPackage) => {
-              return currentOrderPackage?.orderPackageItems.length < minOrderPackage?.orderPackageItems.length
-                ? currentOrderPackage
-                : minOrderPackage
-            }, orderPackages[0])
-
-            const unassignedPackageItems = createOrderPackageItems(
-              unassignedOrderProducts,
-              selectedOrderPackage,
-              unassignedOrderProducts,
-              true
-            )
-            await trxMgr.getRepository(OrderPackageItem).save(unassignedPackageItems)
+          roUpdateFields = {
+            packageId: packages[0].packageId,
+            marketPackCallSuccess: new Date(),
+            lastMarketPackCall: new Date(),
+            updatedAt: new Date()
           }
         }
+        await updateRO(releaseGood.id, roUpdateFields, trxMgr)
+      } else {
+        //sof orders will create consignment - order package - trigger packOrder
+
+        let newReleaseGood
+        let orderPackages: OrderPackage[] = []
 
-        roUpdateFields = {
-          packageId: packages[0].packageId,
-          marketPackCallSuccess: new Date(),
-          lastMarketPackCall: new Date(),
-          updatedAt: new Date()
+        const isMps = releaseGood?.lastMileDelivery?.mps
+        const orderInformation: any = { refOrderId: releaseGood.refOrderId, isSof: true }
+
+        if (isMps) {
+          newReleaseGood = await splitOrderConsignment(trxMgr, releaseGood, user)
+          orderPackages = newReleaseGood.orderPackages
+          releaseGood.orderPackages = orderPackages
+        } else {
+          //create package like normal non sof orders
+          let orderConsignment = await createOrderConsignment(trxMgr, releaseGood, user)
+          let savedOrderPackage: OrderPackage = await this.createOrderPackage(
+            trxMgr,
+            releaseGood,
+            orderConsignment,
+            user
+          )
+          let orderPackageItems: OrderPackageItem[] = await createSofOrderPackageItem(
+            trxMgr,
+            [],
+            savedOrderPackage,
+            releaseGood
+          )
+          savedOrderPackage.orderPackageItems = orderPackageItems
+          orderPackages.push(savedOrderPackage)
+          releaseGood.orderPackages = orderPackages
+
+          newReleaseGood = releaseGood
+        }
+
+        const packages = orderPackages.map(op => {
+          const items = op.orderPackageItems.map(opi => {
+            return {
+              universalIdentifier: opi.productDetail.refCode,
+              sku: opi.orderProduct.product.sku,
+              quantity: opi.releaseQty
+            }
+          })
+          return {
+            packageId: op.id,
+            items: items
+          }
+        })
+
+        performance.mark(`start:${newReleaseGood?.refOrderId}`)
+        const orderPack: any = await PowrupAPI.packOrder(powrup, {
+          ...orderInformation,
+          packages,
+          context: { state: { domain: domain || null, user: user || null } }
+        })
+        performance.mark(`end:${newReleaseGood.refOrderId}`)
+
+        if (orderPack?.packages) {
+          roUpdateFields = {
+            marketPackCallSuccess: new Date(),
+            lastMarketPackCall: new Date(),
+            updatedAt: new Date()
+          }
+
+          let packages = orderPack.packages
+          await updatePackageId(packages, releaseGood, trxMgr)
         }
       }
     } catch (error) {
@@ -207,8 +193,6 @@ export class PowrupController {
       console.info(perf.toJSON())
     }
 
-    await updateRO(releaseGood.id, roUpdateFields, trxMgr)
-
     return releaseGood
   }
 
@@ -253,13 +237,10 @@ export class PowrupController {
 
               let orderInformation: any = {
                 refOrderId: releaseGood.refOrderId,
-                packageId: op.packageId
+                packageId: op.packageId,
+                platform: releaseGood?.platformCode
               }
               if (op?.releaseGood?.lmdOption) {
-                // let releaseGoodQuery: ReleaseGood = await releaseGoodRepo.findOne({
-                //   where: { id: releaseGood.id },
-                //   relations: ['lastMileDelivery']
-                // })
                 orderInformation = {
                   ...orderInformation,
                   awb: op.airwayBill,
@@ -458,6 +439,135 @@ export class PowrupController {
       }
     }
   }
+
+  //create orderPackage for non-sof / sof- non mps orders
+  async createOrderPackage(
+    tx: EntityManager,
+    releaseGood: ReleaseGood,
+    orderConsignment?: OrderConsignment,
+    user?: User,
+    pkg?: any
+  ) {
+    try {
+      const orderPackage: any = {
+        id: uuidv4(),
+        name: OrderNoGenerator.orderPackage(),
+        packageId: pkg ? pkg.packageId : null,
+        status: ORDER_STATUS.PROCESSING,
+        releaseGood,
+        orderConsignment,
+        domain: releaseGood.domain,
+        bizplace: releaseGood.bizplace,
+        creator: user.id,
+        updater: user.id,
+        originalPackResponse: pkg ? JSON.stringify(pkg) : null
+      }
+      let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
+      return savedOrderPackage
+    } catch (e) {
+      logger.error(`[lmd-create-order-consignment]: ${e} `)
+    }
+  }
+
+  async createOrderPackageItems(
+    orderProducts: OrderProduct[],
+    orderPackage: OrderPackage,
+    items: any[],
+    user: User,
+    unassignedItems?: Boolean,
+    releaseGood?: any
+  ): Promise<any[]> {
+    try {
+      const processedItems = items.map(itm => {
+        const { refCode, qty, productDetail, releaseQty } = itm
+
+        if (!refCode && !unassignedItems) {
+          throw new Error(`universalIdentifier missing`)
+        }
+
+        const idx = orderProducts.findIndex(
+          op => op.productDetail?.refCode === refCode || op.productDetail?.refCode === productDetail?.refCode
+        )
+
+        const matchedOrderProduct: OrderProduct = idx !== -1 ? { ...orderProducts[idx] } : undefined
+
+        if (!matchedOrderProduct || matchedOrderProduct.releaseQty <= 0) {
+          return null // No matched product or no remaining quantity to release
+        }
+
+        const matchedOrderPackageItem: OrderPackageItem = orderPackage?.orderPackageItems?.find(
+          itm => itm.orderProductId === matchedOrderProduct.id
+        )
+
+        const commonProperties = {
+          orderProduct: matchedOrderProduct,
+          status: ORDER_STATUS.PROCESSING,
+          orderPackage: orderPackage,
+          domain: releaseGood.domain,
+          bizplace: releaseGood.bizplace,
+          creator: user.id,
+          updater: user.id,
+          productDetail: matchedOrderProduct.productDetail
+        }
+
+        let result = {}
+
+        if (matchedOrderPackageItem) {
+          result = {
+            ...commonProperties,
+            id: matchedOrderPackageItem.id,
+            name: matchedOrderPackageItem.name,
+            releaseQty: (matchedOrderPackageItem.releaseQty || 0) + (releaseQty || 0)
+          }
+        } else {
+          orderProducts[idx].releaseQty = (orderProducts[idx].releaseQty || 0) - (qty || 0)
+          result = {
+            ...commonProperties,
+            name: OrderNoGenerator.orderPackageItem(),
+            releaseQty: releaseQty
+              ? releaseQty
+              : qty > matchedOrderProduct.releaseQty
+                ? matchedOrderProduct.releaseQty
+                : qty
+          }
+        }
+
+        return result
+      })
+
+      return processedItems.filter(item => item != null)
+    } catch (e) {
+      logger.error(`unable-to-create-opi-powrup: ${e}`)
+    }
+  }
+
+  async unassignedOrderProducts(
+    unassignedOrderProducts: OrderProduct[],
+    releaseGood: ReleaseGood,
+    user: User,
+    trxMgr: EntityManager
+  ) {
+    const orderPackages: OrderPackage[] = await trxMgr.getRepository(OrderPackage).find({
+      where: { releaseGood: releaseGood.id },
+      relations: ['orderPackageItems']
+    })
+
+    let selectedOrderPackage = orderPackages.reduce((minOrderPackage, currentOrderPackage) => {
+      return currentOrderPackage?.orderPackageItems.length < minOrderPackage?.orderPackageItems.length
+        ? currentOrderPackage
+        : minOrderPackage
+    }, orderPackages[0])
+
+    const unassignedPackageItems = await this.createOrderPackageItems(
+      unassignedOrderProducts,
+      selectedOrderPackage,
+      unassignedOrderProducts,
+      user,
+      true,
+      releaseGood
+    )
+    await trxMgr.getRepository(OrderPackageItem).save(unassignedPackageItems)
+  }
 }
 
 export async function createOrderConsignment(
@@ -485,42 +595,24 @@ export async function createOrderConsignment(
   }
 }
 
-export async function sortingProduct(items, releaseGood): Promise<any> {
+export async function sortingProduct(orderProducts): 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
-      })
-
+    const sortedMatchedOrderProducts = 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 sortedMatchedOrderProducts
   } catch (e) {
     logger.error(`[lmd-sort-product]: ${e} `)
   }
 }
 
-export async function splitOrderConsignment(
-  tx: EntityManager,
-  releaseGood: ReleaseGood,
-  items: any,
-  user: User
-): Promise<any> {
+export async function splitOrderConsignment(tx: EntityManager, releaseGood: ReleaseGood, user: User): Promise<any> {
   try {
     let currentConsignment = { id: uuidv4(), totalWeight: 0, orderPackages: [] }
     let totalConsignments = []
@@ -530,8 +622,8 @@ export async function splitOrderConsignment(
     let orderProducts = releaseGood.orderProducts
     let maxConsignmentWeight = releaseGood.lastMileDelivery.consignmentWeight
 
-    //sort items from packOrder API
-    let sortItems = await sortingProduct(items, releaseGood)
+    //sort products according to the packingType
+    let sortItems = await sortingProduct(orderProducts)
 
     //initialise new orderConsignment created
     const createdNewConsignment = () => ({
@@ -628,7 +720,7 @@ export async function splitOrderConsignment(
               id: uuidv4(),
               name: OrderNoGenerator.orderPackageItem(),
               releaseQty: op.releaseQty,
-              orderProducts: op,
+              orderProduct: op,
               domain: releaseGood.domain,
               bizplace: releaseGood.bizplace,
               creator: releaseGood.creator,
@@ -707,14 +799,14 @@ export async function createConsignmentWithMultipackage(
       const savedOrderConsignment = await createOrderConsignment(tx, releaseGood, user, orderCons)
 
       for (const currentPackage of orderCons.orderPackages) {
-        const savedOrderPackage = await createConsignmentPackage(
+        const savedOrderPackage = await createSofOrderPackage(
           tx,
           currentPackage,
           releaseGood,
           user,
           savedOrderConsignment
         )
-        const orderPackageItems = await createConsignmentPackageItem(
+        const orderPackageItems = await createSofOrderPackageItem(
           tx,
           currentPackage.orderPackageItems,
           savedOrderPackage,
@@ -738,7 +830,7 @@ export async function createConsignmentWithMultipackage(
   }
 }
 
-export async function createConsignmentPackage(
+export async function createSofOrderPackage(
   tx: EntityManager,
   orderPackageData: any,
   releaseGood: ReleaseGood,
@@ -768,26 +860,36 @@ export async function createConsignmentPackage(
   }
 }
 
-export async function createConsignmentPackageItem(
+export async function createSofOrderPackageItem(
   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
-    }))
+    const orderPackageItems = (
+      orderPackageItemsData.length > 0 ? orderPackageItemsData : releaseGood.orderProducts
+    ).map(item => {
+      const isOrderPackageItemData = orderPackageItemsData.length > 0
+      const id = isOrderPackageItemData ? item.id : uuidv4()
+      const name = isOrderPackageItemData ? item.name : OrderNoGenerator.orderPackageItem()
+      const orderProduct = isOrderPackageItemData ? item.orderProduct : item
+      const releaseQty = isOrderPackageItemData ? item.releaseQty : item.releaseQty
+
+      return {
+        id,
+        name,
+        orderProduct,
+        status: ORDER_STATUS.PROCESSING,
+        releaseQty,
+        orderPackage: savedOrderPackage,
+        domain: releaseGood.domain,
+        bizplace: releaseGood.bizplace,
+        creator: releaseGood.creator,
+        updater: releaseGood.updater,
+        productDetail: isOrderPackageItemData ? item.productDetail : item.productDetail
+      }
+    })
 
     let savedOrderPackageItems: OrderPackageItem[] = await tx.getRepository(OrderPackageItem).save(orderPackageItems)
 
@@ -799,19 +901,42 @@ export async function createConsignmentPackageItem(
 
 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
+    //open new transactiion - same transaction will cause blocking
+    await getConnection().transaction(async tx2 => {
+      const orderPackages: OrderPackage[] = await tx2.getRepository(OrderPackage).find({
+        where: { releaseGood: { id: releaseGood.id } },
+        relations: ['releaseGood']
+      })
+
+      for (let orderPackage of orderPackages) {
+        let matchedPackage = packages.find(p => {
+          return p.orderPackageId == orderPackage.id
+        })
+
+        if (matchedPackage) {
+          await tx2.getRepository(OrderPackage).update(
+            { id: orderPackage.id },
+            {
+              packageId: matchedPackage.packageId
+            }
+          )
         }
-      )
-    }
+      }
+
+      let rg = await tx2.getRepository(ReleaseGood).findOne({ id: releaseGood.id })
+
+      if (rg) {
+        await tx2.getRepository(ReleaseGood).update(
+          { id: releaseGood.id },
+          {
+            marketPackCallSuccess: new Date(),
+            lastMarketPackCall: new Date(),
+            updatedAt: new Date()
+          }
+        )
+      }
+    })
   } catch (e) {
-    logger.error('unable-to-update-package-id-powrup')
+    logger.error('unable-to-update-package-id-mps')
   }
 }

package/server/service/release-good/release-good.ts

@@ -1,8 +1,4 @@
-import {
-  Field,
-  ID,
-  ObjectType
-} from 'type-graphql'
+import { Field, ID, ObjectType } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -19,10 +15,7 @@ import {
 
 import { Attachment } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
-import {
-  Bizplace,
-  ContactPoint
-} from '@things-factory/biz-base'
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
 import { config } from '@things-factory/env'
 import { LastMileDelivery } from '@things-factory/integration-lmd'
 import { Domain } from '@things-factory/shell'
@@ -63,13 +56,11 @@ export enum DispatchmentStatus {
 @Index('ix_release-good_2', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.refNo2])
 @Index('ix_release-good_3', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.remark])
 @Index('ix_release-good_4', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.bizplace])
-@Index(
-  'ix_release-good_5',
-  (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.bizplace, releaseGood.refOrderId],
-  {
-    unique: true
-  }
-)
+@Index('ix_release-good_5', (releaseGood: ReleaseGood) => [
+  releaseGood.domain,
+  releaseGood.bizplace,
+  releaseGood.refOrderId
+])
 @ObjectType()
 export class ReleaseGood {
   @PrimaryGeneratedColumn('uuid')
@@ -667,4 +658,4 @@ export class ReleaseGood {
   })
   @Field({ nullable: true })
   sourceData: string
-}
+}