@things-factory/sales-base 4.3.524 → 4.3.526

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,7 +14,6 @@ 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')
 
@@ -36,7 +35,9 @@ export class PowrupController {
 
     try {
       const orderProducts: OrderProduct[] = releaseGood.orderProducts
-      const orderInformation: any = { refOrderId: releaseGood.refOrderId }
+      const orderInformation: any = {
+        refOrderId: releaseGood.refOrderId
+      }
 
       if (
         releaseGood?.lastMarketPackCall &&
@@ -55,57 +56,47 @@ 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 isMps = releaseGood?.lastMileDelivery?.mps
+            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)
 
-            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,
+              return {
+                name: OrderNoGenerator.orderPackageItem(),
+                orderProduct: matchedOrderProduct,
                 status: ORDER_STATUS.PROCESSING,
-                releaseGood,
-                orderConsignment,
+                releaseQty: qty,
+                orderPackage: savedOrderPackage,
                 domain: releaseGood.domain,
                 bizplace: releaseGood.bizplace,
                 creator: releaseGood.creator,
-                updater: releaseGood.updater
+                updater: releaseGood.updater,
+                productDetail: matchedOrderProduct?.productDetail
               }
+            })
 
-              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)
-            }
+            await trxMgr.getRepository(OrderPackageItem).save(orderPackageItems)
           })
         )
 
@@ -239,9 +230,8 @@ 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(
@@ -280,10 +270,7 @@ 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}`)
@@ -298,9 +285,7 @@ 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
@@ -384,359 +369,3 @@ 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,29 +2,22 @@ import { EntityManager, getConnection, getRepository } from 'typeorm'
 
 import { logger } from '@things-factory/env'
 import { Domain, User } from '@things-factory/shell'
-import { config } from '@things-factory/env'
-
+import { sleep } from '@things-factory/utils'
 import { WebspertController as BaseWebspertController } from '@things-factory/warehouse-base'
 
 import { ORDER_STATUS } from '../../constants'
-import { ReleaseGood, OrderProduct, OrderPackageItem, OrderPackage } from '../../service'
-
-import { sleep } from '@things-factory/utils'
+import { OrderPackage, OrderPackageItem, OrderProduct, ReleaseGood } from '../../service'
 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.packOrderFail == false)) return false
+      if (!releaseGood || releaseGood?.marketPackCallSuccess) return false
 
       try {
         let results = await BaseWebspertController.sendRequestToAPI(
@@ -39,10 +32,11 @@ export class WebspertController {
           throw new Error(results.statusText)
         }
 
-        if (results?.data?.code === 200) {
+        if (results?.data?.code === 0) {
           await updatePackOrderStatus(trx, releaseGood)
           return true
         }
+        throw results?.data
       } catch (error) {
         logger.error(`webspert-controller[packOrder]: ${error}`)
         await updatePackOrderStatus(trx, releaseGood, true)
@@ -51,20 +45,22 @@ 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) {
+      if (releaseOrder && releaseOrder.marketPackCallSuccess) {
         try {
           // capture update fields
           roUpdateFields = {
@@ -103,13 +99,12 @@ 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
       }
@@ -143,18 +138,13 @@ 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.packOrderFail == false || releaseGood.packOrderFail === null) {
+      if (!releaseGood?.marketPackCallSuccess) {
         await this.packOrder(releaseGood, domain, user)
         await sleep(waitTime)
       }
@@ -167,7 +157,6 @@ export class WebspertController {
       }
 
       return true
-
     } catch (error) {
       logger.error(error)
     }
@@ -180,16 +169,17 @@ 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')
@@ -235,12 +225,16 @@ async function generatePackage(
             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,
@@ -268,20 +262,32 @@ async function generatePackage(
     if (packages.length == packages.filter(pkg => pkg.packageId).length) {
       return {
         packageId: packages[0].packageId,
-        marketPackCallSuccess: new Date(),
+        packOrderFail: false,
         lastMarketPackCall: new Date(),
         updatedAt: new Date()
       }
     } else {
       return {
         lastMarketPackCall: new Date(),
-        updatedAt: new Date()
+        packOrderFail: true,
+        updatedAt: new Date(),
       }
     }
   }
 }
 
 async function updatePackOrderStatus(trx, releaseOrder, status: Boolean = false) {
-  await trx.getRepository(ReleaseGood).update({ id: releaseOrder.id }, { lastMarketPackCall: new Date(), packOrderFail: status })
+  let updateValues: any = {
+    lastMarketPackCall: new Date()
+  }
+
+  if (status == false) {
+    updateValues = {
+      ...updateValues,
+      marketPackCallSuccess: new Date()
+    }
+  }
+
+  await trx.getRepository(ReleaseGood).update({ id: releaseOrder.id }, updateValues)
   return true
-}
+}