@things-factory/worksheet-base 4.3.150 → 4.3.152

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

@@ -1,5 +1,6 @@
 import { Bizplace } from '@things-factory/biz-base'
 import { Sellercraft, SellercraftAPI } from '@things-factory/integration-sellercraft'
+import { logger } from '@things-factory/env'
 import { Product, ProductDetail } from '@things-factory/product-base'
 import {
   ArrivalNotice,
@@ -17,6 +18,8 @@ import { Inventory, INVENTORY_STATUS, LOCATION_TYPE } from '@things-factory/ware
 
 import { WorksheetController } from '../worksheet-controller'
 
+import { getRepository } from 'typeorm'
+
 export class SellercraftController extends WorksheetController {
   async packOrder(sellercraft: Sellercraft, releaseGood: ReleaseGood): Promise<ReleaseGood> {
     let sellercraftSetting: any = sellercraft.sellercraftSetting
@@ -37,63 +40,68 @@ export class SellercraftController extends WorksheetController {
         }
       })
 
-      const orderInformation: any = {
-        accountId: sellercraft.accountId,
-        orderId: releaseGood.refNo2,
-        sellercraftOPs
-      }
-      const orderPack: any = await SellercraftAPI.packMarketplaceOrder(sellercraft, {
-        ...orderInformation,
-        context: { state: { domain: this?.domain, user: this?.user } }
-      })
-
-      if (orderPack?.packages) {
-        const packages: any[] = orderPack.packages
-
-        await this.trxMgr
-          .getRepository(ReleaseGood)
-          .update({ id: releaseGood.id }, { packageId: packages[0].packageId, updatedAt: new Date() })
-
-        await Promise.all(
-          packages.map(async pkg => {
-            const items = pkg.items
-            const orderPackage: OrderPackage = {
-              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 this.trxMgr.getRepository(OrderPackage).save(orderPackage)
+      try {
+        const orderInformation: any = {
+          accountId: sellercraft.accountId,
+          orderId: releaseGood.refNo2,
+          sellercraftOPs
+        }
+        const orderPack: any = await SellercraftAPI.packMarketplaceOrder(sellercraft, {
+          ...orderInformation,
+          context: { state: { domain: this?.domain, user: this?.user } }
+        })
 
-            const orderPackageItems: OrderPackageItem[] = items.map(itm => {
-              const { sku, qty } = itm
-              const matchedOrderProduct: OrderProduct = orderProducts.find(op => op.product.sku == sku)
+        if (orderPack?.packages) {
+          const packages: any[] = orderPack.packages
 
-              return {
-                name: OrderNoGenerator.orderPackageItem(),
-                orderProduct: matchedOrderProduct,
+          await Promise.all(
+            packages.map(async pkg => {
+              const items = pkg.items
+              const orderPackage: OrderPackage = {
+                name: OrderNoGenerator.orderPackage(),
+                packageId: pkg.packageId,
                 status: ORDER_STATUS.PROCESSING,
-                releaseQty: qty,
-                orderPackage: savedOrderPackage,
+                releaseGood,
                 domain: releaseGood.domain,
                 bizplace: releaseGood.bizplace,
                 creator: releaseGood.creator,
                 updater: releaseGood.updater
               }
+
+              let savedOrderPackage: OrderPackage = await this.trxMgr.getRepository(OrderPackage).save(orderPackage)
+
+              const orderPackageItems: OrderPackageItem[] = items.map(itm => {
+                const { sku, qty } = itm
+                const matchedOrderProduct: OrderProduct = orderProducts.find(op => op.product.sku == sku)
+
+                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
+                }
+              })
+
+              await this.trxMgr.getRepository(OrderPackageItem).save(orderPackageItems)
             })
+          )
 
-            await this.trxMgr.getRepository(OrderPackageItem).save(orderPackageItems)
-          })
-        )
+          await this.trxMgr
+            .getRepository(ReleaseGood)
+            .update({ id: releaseGood.id }, { packageId: packages[0].packageId, marketPackCallSuccess: new Date(), updatedAt: new Date() })
+        }
+      } catch (error) {
+        logger.error(`sellercraft-controller[packOrder]: ${error}`)
+        throw error
       }
-    }
 
-    return releaseGood
+      return releaseGood
+    }
   }
 
   async registerProductInbound(sellercraft: Sellercraft, arrivalNotice: ArrivalNotice): Promise<void> {
@@ -307,36 +315,50 @@ export class SellercraftController extends WorksheetController {
   }
 
   async initiateOrderShipment(sellercraft: Sellercraft, releaseGood: ReleaseGood): Promise<void> {
-    let sellercraftSetting: any = sellercraft.sellercraftSetting
-    let disableInitiateOrderShipment: boolean =
-      sellercraftSetting?.disableInitiateOrderShipment && sellercraftSetting?.disableInitiateOrderShipment == 1
-        ? true
-        : false
+    try {
+      let sellercraftSetting: any = sellercraft.sellercraftSetting
+      let disableInitiateOrderShipment: boolean =
+        sellercraftSetting?.disableInitiateOrderShipment && sellercraftSetting?.disableInitiateOrderShipment == 1
+          ? true
+          : false
 
-    if (!disableInitiateOrderShipment) {
-      let orderPackages: OrderPackage[] = await this.trxMgr
-        .getRepository(OrderPackage)
-        .find({ where: { releaseGood, bizplace: releaseGood.bizplace } })
+      if (!disableInitiateOrderShipment) {
+        let orderPackages: OrderPackage[] = await this.trxMgr
+          .getRepository(OrderPackage)
+          .find({ where: { releaseGood, bizplace: releaseGood.bizplace } })
 
-      if (orderPackages?.length) {
-        await Promise.all(
-          orderPackages.map(async op => {
-            if (!op?.packageId) throw new Error('Order package id is not found')
+        if (orderPackages?.length) {
+          await Promise.all(
+            orderPackages.filter(op => op?.marketRtsCallSuccess == undefined).map(async op => {
+              if (!op?.packageId) throw new Error('Order package id is not found')
 
-            const orderInformation: any = {
-              accountId: sellercraft.accountId,
-              orderId: releaseGood.refNo2,
-              packageId: op.packageId
-            }
+              const orderInformation: any = {
+                accountId: sellercraft.accountId,
+                orderId: releaseGood.refNo2,
+                packageId: op.packageId
+              }
 
-            await SellercraftAPI.initiateOrderShipment(sellercraft, {
-              ...orderInformation,
-              context: { state: { domain: this?.domain, user: this?.user } }
+              try {
+                await SellercraftAPI.initiateOrderShipment(sellercraft, {
+                  ...orderInformation,
+                  context: { state: { domain: this?.domain, user: this?.user } }
+                })
+                await getRepository(OrderPackage).update({ id: op.id }, { marketRtsCallSuccess: new Date() })
+              } catch (error) {
+                logger.error(`sellercraft-controller[initiateOrderShipment]: ${JSON.stringify({
+                  ...orderInformation,
+                  context: { state: { domain: this?.domain, user: this?.user } },
+                  error: error
+                })}`)
+              }
             })
-          })
-        )
+          )
+        }
       }
+    } catch (error) {
+      throw error
     }
+
   }
 
   async initiateOrderDocument(sellercraft: Sellercraft, releaseGood: ReleaseGood): Promise<void> {

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

@@ -13,7 +13,6 @@ import {
   OrderProduct,
   ReleaseGood
 } from '@things-factory/sales-base'
-import { Setting } from '@things-factory/setting-base'
 import {
   Inventory,
   INVENTORY_ITEM_SOURCE,
@@ -102,15 +101,10 @@ export class PackingWorksheetController extends VasWorksheetController {
         if (sellercraft) {
           const sellercraftCtrl: SellercraftController = new SellercraftController(this.trxMgr, this.domain, this.user)
 
-          const rtsTriggerLevel: Setting = await this.trxMgr.getRepository(Setting).findOne({
-            where: { domain: this.domain, category: 'id-rule', name: 'rts-trigger-level' }
-          })
-
           let rtsOrderDoc = async (sellercraft: any, releaseGood: any, domain: any, user: any) => {
             try {
-              if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 2) {
-                await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
-              }
+              // trigger RTS
+              await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
 
               await sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
             } catch (error) {
@@ -269,6 +263,8 @@ export class PackingWorksheetController extends VasWorksheetController {
 
     if (orderPackageItem.packedQty == orderPackageItem.releaseQty) {
       orderPackageItem.status = ORDER_STATUS.DONE
+    } else if (orderPackageItem.packedQty > orderPackageItem.releaseQty) {
+      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`))
     }
 
     await this.trxMgr.getRepository(OrderPackageItem).save(orderPackageItem)
@@ -433,6 +429,8 @@ export class PackingWorksheetController extends VasWorksheetController {
 
     if (orderPackageItem.packedQty == orderPackageItem.releaseQty) {
       orderPackageItem.status = ORDER_STATUS.DONE
+    } else if (orderPackageItem.packedQty > orderPackageItem.releaseQty) {
+      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`))
     }
 
     await this.trxMgr.getRepository(OrderPackageItem).save(orderPackageItem)

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

@@ -1,5 +1,6 @@
-import { EntityManager, Equal, getConnection, In, IsNull, Not } from 'typeorm'
+import { EntityManager, Equal, getConnection, In, IsNull, Not, getManager } from 'typeorm'
 
+import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
 import { Product, ProductDetail, ProductBarcode } from '@things-factory/product-base'
@@ -38,6 +39,9 @@ import { Worksheet, WorksheetDetail } from '../../entities'
 import { WorksheetNoGenerator } from '../../utils'
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 
+import { SellercraftController } from '../../controllers'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+
 export class PickingWorksheetController extends VasWorksheetController {
   async generatePickingWorksheet(releaseGoodNo: string, currentStatus: string = null): Promise<Worksheet> {
     let releaseGood: ReleaseGood = await this.findRefOrder(
@@ -184,6 +188,7 @@ export class PickingWorksheetController extends VasWorksheetController {
     let worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.PICKING, [
       'releaseGood',
       'releaseGood.bizplace',
+      'releaseGood.bizplace.domain',
       'domain',
       'bizplace',
       'bizplace.domain',
@@ -215,7 +220,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       if (vasWorksheet) {
         await this.activateVAS(vasWorksheet.name, vasWorksheet.worksheetDetails)
       }
-    } catch (e) {}
+    } catch (e) { }
 
     const pendingSplitOIs: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
       where: { domain: this.domain, releaseGood, status: ORDER_INVENTORY_STATUS.PENDING_SPLIT }
@@ -225,6 +230,39 @@ export class PickingWorksheetController extends VasWorksheetController {
       await this.trxMgr.getRepository(OrderInventory).delete(ids)
     }
 
+    try {
+      // trigger SC pack order asynchronously
+      const orderSource: string = releaseGood?.source
+      switch (orderSource) {
+        case ApplicationType.SELLERCRAFT:
+          getManager().transaction(async txMgr => {
+            const sellercraft: Sellercraft = await txMgr
+              .getRepository(Sellercraft)
+              .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+            if (sellercraft) {
+              const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, this.domain, this.user)
+
+              if (!releaseGood?.orderPackages?.length) {
+                const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
+                  where: { releaseGood },
+                  relations: ['product', 'product.productDetails']
+                })
+
+                // asynchronously pack order
+                await sellercraftCtrl.packOrder(sellercraft, { ...releaseGood, orderProducts })
+              }
+            }
+          })
+          break
+
+        default:
+          break
+      }
+    } catch (error) {
+      logger.error(`picking-worksheet-controller[activatePicking]: ${error}`)
+    }
+
     return worksheet
   }
 
@@ -254,19 +292,63 @@ 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']
+      relations: [
+        'releaseGood',
+        'releaseGood.bizplace',
+        'releaseGood.bizplace.domain',
+        'releaseGood.orderPackages'
+      ]
     })
 
-    let releaseGoods: ReleaseGood[] = pickingOrderInventory.map((oi: OrderInventory) => oi.releaseGood)
+    let releaseGoods: 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 = releaseGoods.map((rg: ReleaseGood) => {
-        return {
-          ...rg,
-          status: ORDER_STATUS.PICKING,
-          updater: this.user
-        }
-      })
+      releaseGoods = await Promise.all(
+        releaseGoods.map(async (releaseGood: ReleaseGood) => {
+          try {
+            const orderSource: string = releaseGood?.source
+            switch (orderSource) {
+              case ApplicationType.SELLERCRAFT:
+                getManager().transaction(async txMgr => {
+                  const sellercraft: Sellercraft = await txMgr
+                    .getRepository(Sellercraft)
+                    .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+                  if (sellercraft) {
+                    const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, this.domain, this.user)
+
+                    if (!releaseGood?.orderPackages?.length) {
+                      const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
+                        where: { releaseGood },
+                        relations: ['product', 'product.productDetails']
+                      })
+
+                      // asynchronously pack order
+                      await sellercraftCtrl.packOrder(sellercraft, { ...releaseGood, orderProducts })
+                    }
+                  }
+                })
+                break
+
+              default:
+                break
+            }
+          } catch (error) {
+            logger.error(`picking-worksheet-controller[activateBatchPicking]: ${error}`)
+          }
+
+          return {
+            ...releaseGood,
+            status: ORDER_STATUS.PICKING,
+            updater: this.user
+          }
+        }))
       await this.trxMgr.getRepository(ReleaseGood).save(releaseGoods)
     }
 

package/server/graphql/resolvers/worksheet/picking/complete-batch-picking.ts

@@ -11,7 +11,8 @@ import {
   OrderNoGenerator,
   OrderPackage,
   OrderPackageItem,
-  ReleaseGood
+  ReleaseGood,
+  OrderProduct
 } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
@@ -69,115 +70,107 @@ export async function completeBatchPicking(
     }
   }
 
-  await Promise.all(
-    uniqueReleaseGoods.map(async releaseGood => {
-      let foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-        where: { id: releaseGood.id },
-        relations: [
-          'domain',
-          'creator',
-          'updater',
-          'orderPackages',
-          'orderProducts',
-          'orderProducts.product',
-          'bizplace',
-          'bizplace.company',
-          'bizplace.company.domain'
-        ]
-      })
-      const orderSource: string = foundReleaseGood.source
-      switch (orderSource) {
-        case ApplicationType.SELLERCRAFT:
-          const sellercraft: Sellercraft = await tx
-            .getRepository(Sellercraft)
-            .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
-
-          if (sellercraft) {
-            const initSCOrderShipment = async (sellercraft: Sellercraft, foundReleaseGood: ReleaseGood) => {
-              await getManager().transaction(async txMgr => {
-                const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
-
-                if (!releaseGood?.orderPackages?.length) {
-                  await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
-                }
-
-                const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
-                  where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
-                })
-
-                if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-                  await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
-                }
+  for (let i = 0; i < uniqueReleaseGoods.length; i++) {
+    let foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { id: uniqueReleaseGoods[i].id },
+      relations: [
+        'domain',
+        'creator',
+        'updater',
+        'orderPackages',
+        'orderProducts',
+        'orderProducts.product',
+        'bizplace',
+        'bizplace.company',
+        'bizplace.company.domain'
+      ]
+    })
+    const orderSource: string = foundReleaseGood.source
+    switch (orderSource) {
+      case ApplicationType.SELLERCRAFT:
+        const sellercraft: Sellercraft = await tx
+          .getRepository(Sellercraft)
+          .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+        if (sellercraft) {
+          const initSCOrderShipment = async (sellercraft: Sellercraft, foundReleaseGood: ReleaseGood) => {
+            await getManager().transaction(async txMgr => {
+              const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
+
+              if (!foundReleaseGood?.orderPackages?.length && !foundReleaseGood?.marketPackCallSuccess) {
+                await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
+              }
+
+              const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
+                where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
               })
-            }
 
-            // asynchronouly call to initiate sellercraft order shipment/ RTS
-            initSCOrderShipment(sellercraft, foundReleaseGood)
-          }
-          break
-
-        case ApplicationType.MMS:
-          const companyDomain: Domain = foundReleaseGood.bizplace.company.domain
-          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { orderNo: foundReleaseGood.refNo, domain: companyDomain },
-            relations: [
-              'marketplaceOrderItems',
-              'marketplaceOrderItems.marketplaceOrderShippingItems',
-              'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
-              'marketplaceStore',
-              'marketplaceStore.marketplaceDistributors'
-            ]
-          })
-          const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-
-          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-          if (marketplaceStore?.isAutoUpdateShipment) {
-            await ecommerceCtrl.createOrderShip(foundReleaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+              if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
+                await sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
+              }
+            })
           }
-          await ecommerceCtrl.createOrderPackage(
-            tx,
-            marketplaceOrder,
-            companyDomain,
-            marketplaceStore,
-            foundReleaseGood
-          )
-          break
-
-        default:
-          const orderPackage: OrderPackage = {
-            name: OrderNoGenerator.orderPackage(),
-            packageId: null,
-            trackingNo: null,
-            transporter: null,
-            airwayBill: null,
+
+          // asynchronouly call to initiate sellercraft order shipment/ RTS
+          initSCOrderShipment(sellercraft, foundReleaseGood)
+        }
+        break
+
+      case ApplicationType.MMS:
+        const companyDomain: Domain = foundReleaseGood.bizplace.company.domain
+        const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+          where: { orderNo: foundReleaseGood.refNo, domain: companyDomain },
+          relations: [
+            'marketplaceOrderItems',
+            'marketplaceOrderItems.marketplaceOrderShippingItems',
+            'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+            'marketplaceStore',
+            'marketplaceStore.marketplaceDistributors'
+          ]
+        })
+        const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+        if (marketplaceStore?.isAutoUpdateShipment) {
+          await ecommerceCtrl.createOrderShip(foundReleaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+        }
+        await ecommerceCtrl.createOrderPackage(tx, marketplaceOrder, companyDomain, marketplaceStore, foundReleaseGood)
+        break
+
+      default:
+        const orderPackage: OrderPackage = {
+          name: OrderNoGenerator.orderPackage(),
+          packageId: null,
+          trackingNo: null,
+          transporter: null,
+          airwayBill: null,
+          status: ORDER_STATUS.PROCESSING,
+          releaseGood: foundReleaseGood,
+          domain: foundReleaseGood.domain,
+          bizplace: foundReleaseGood.bizplace,
+          creator: foundReleaseGood.creator,
+          updater: foundReleaseGood.updater
+        }
+
+        let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
+        const orderPackageItems: OrderPackageItem[] = foundReleaseGood.orderProducts.map(op => {
+          return {
+            name: OrderNoGenerator.orderPackageItem(),
+            orderProduct: op,
             status: ORDER_STATUS.PROCESSING,
-            foundReleaseGood,
+            releaseQty: op.releaseQty,
+            orderPackage: savedOrderPackage,
             domain: foundReleaseGood.domain,
             bizplace: foundReleaseGood.bizplace,
             creator: foundReleaseGood.creator,
             updater: foundReleaseGood.updater
           }
+        })
 
-          let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
-          const orderPackageItems: OrderPackageItem[] = foundReleaseGood.orderProducts.map(op => {
-            return {
-              name: OrderNoGenerator.orderPackageItem(),
-              orderProduct: op,
-              status: ORDER_STATUS.PROCESSING,
-              releaseQty: op.releaseQty,
-              orderPackage: savedOrderPackage,
-              domain: foundReleaseGood.domain,
-              bizplace: foundReleaseGood.bizplace,
-              creator: foundReleaseGood.creator,
-              updater: foundReleaseGood.updater
-            }
-          })
-
-          await tx.getRepository(OrderPackageItem).save(orderPackageItems)
-          break
-      }
-    })
-  )
+        await tx.getRepository(OrderPackageItem).save(orderPackageItems)
+        break
+    }
+  }
 
   const pickPackTargetInventories: OrderInventory[] = targetInventories
     .filter(targetInventory => targetInventory.releaseGood.packingOption)

package/server/graphql/resolvers/worksheet/picking/complete-picking.ts

@@ -110,15 +110,15 @@ export async function completePicking(
           await getManager().transaction(async txMgr => {
             const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
 
-            if (!releaseGood?.orderPackages?.length) {
-              const orderProducts: OrderProduct[] = await tx.getRepository(OrderProduct).find({
+            if (!releaseGood?.orderPackages?.length && !releaseGood?.marketPackCallSuccess) {
+              const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
                 where: { releaseGood },
                 relations: ['product', 'product.productDetails']
               })
               await sellercraftCtrl.packOrder(sellercraft, { ...releaseGood, orderProducts })
             }
 
-            const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
+            const rtsTriggerLevel: Setting = await txMgr.getRepository(Setting).findOne({
               where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
             })