@things-factory/worksheet-base 4.3.236 → 4.3.238

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

@@ -0,0 +1,272 @@
+import { getRepository } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { Powrup, PowrupAPI } from '@things-factory/integration-powrup'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import {
+  ORDER_STATUS,
+  OrderNoGenerator,
+  OrderPackage,
+  OrderPackageItem,
+  OrderProduct,
+  ReleaseGood
+} from '@things-factory/sales-base'
+import { Inventory, INVENTORY_STATUS, LOCATION_TYPE } from '@things-factory/warehouse-base'
+
+import { DateTimeDifference } from '../../utils/datetime-util'
+import { WorksheetController } from '../worksheet-controller'
+
+export class PowrupController extends WorksheetController {
+  async packOrder(powrup: Powrup, releaseGood: ReleaseGood): Promise<ReleaseGood> {
+    try {
+      const orderProducts: OrderProduct[] = releaseGood.orderProducts
+      const orderInformation: any = {
+        orderId: releaseGood.refOrderId
+      }
+
+      if (
+        releaseGood?.lastMarketPackCall &&
+        DateTimeDifference.timeDifferenceInSeconds(releaseGood.lastMarketPackCall, new Date()) <= 5
+      ) {
+        return false
+      }
+
+      await getRepository(ReleaseGood).update(
+        { id: releaseGood.id },
+        {
+          lastMarketPackCall: new Date()
+        }
+      )
+
+      const orderPack: any = await PowrupAPI.packOrder(powrup, {
+        ...orderInformation,
+        context: { state: { domain: this?.domain, user: this?.user } }
+      })
+
+      if (orderPack?.packages) {
+        const packages: any[] = orderPack.packages
+
+        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)
+
+            const orderPackageItems: OrderPackageItem[] = items.map(itm => {
+              const { refCode, qty } = itm
+              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
+              }
+            })
+
+            await this.trxMgr.getRepository(OrderPackageItem).save(orderPackageItems)
+          })
+        )
+
+        await this.trxMgr.getRepository(ReleaseGood).update(
+          { id: releaseGood.id },
+          {
+            packageId: packages[0].packageId,
+            marketPackCallSuccess: new Date(),
+            lastMarketPackCall: new Date(),
+            updatedAt: new Date()
+          }
+        )
+      }
+    } catch (error) {
+      logger.error(`powrup-controller[packOrder]: ${error}`)
+      throw error
+    }
+
+    return releaseGood
+  }
+
+  async updateStock(powrup: Powrup, inventory: Inventory): Promise<void> {
+    const bizplace: Bizplace = await this.trxMgr.getRepository(Bizplace).findOne({ domain: powrup.domain })
+    let product: Product = inventory.product
+    const productDetail: ProductDetail = inventory.productDetail
+    let qb = await this.trxMgr.getRepository(Inventory).createQueryBuilder('inv')
+    qb.leftJoinAndSelect('inv.location', 'loc')
+      .andWhere('"inv"."domain_id" = :domainId')
+      .andWhere('"inv"."bizplace_id" = :bizplaceId')
+      .andWhere('"inv"."product_id" = :productId')
+      .andWhere('"inv"."product_detail_id" = :productDetailId')
+      .andWhere('"inv"."status" = :status')
+      .andWhere('"loc"."type" NOT IN (:...locationTypes)')
+      .setParameters({
+        domainId: this.domain.id,
+        bizplaceId: bizplace.id,
+        productId: product.id,
+        productDetailId: productDetail.id,
+        status: INVENTORY_STATUS.STORED,
+        locationTypes: [LOCATION_TYPE.QUARANTINE]
+      })
+
+    const warehouseDomainId = this.domain.id
+    let inventories: Inventory[] = await qb.getMany()
+    let inventoryTotalQty: number = 0
+    let inventoryTotalLockedQty: number = 0
+    let inventoryBufferQty: number = 0
+
+    inventories.forEach((inventory: Inventory) => {
+      const { qty, lockedQty } = inventory
+      inventoryTotalQty += qty
+      inventoryTotalLockedQty += lockedQty
+      if (inventory.location.type === LOCATION_TYPE.RESERVE) {
+        inventoryBufferQty += qty
+      }
+    })
+
+    const powrupInvs: any[] = [
+      {
+        refCode: productDetail.refCode,
+        stock: {
+          quantityTotal: inventoryTotalQty - inventoryTotalLockedQty - inventoryBufferQty,
+          quantityReserved: inventoryTotalLockedQty - inventoryBufferQty,
+          quantityBuffer: inventoryBufferQty
+        }
+      }
+    ]
+
+    await PowrupAPI.updateStock(powrup, {
+      context: { state: { domain: this?.domain, user: this?.user } },
+      warehouseDomainId,
+      powrupInvs
+    })
+  }
+
+  async initiateShipment(powrup: Powrup, releaseGood: ReleaseGood): Promise<void> {
+    try {
+      let orderPackages: OrderPackage[] = await this.trxMgr
+        .getRepository(OrderPackage)
+        .find({ where: { releaseGood, bizplace: releaseGood.bizplace } })
+
+      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')
+              if (releaseGood.lmdOption && !op?.parcelId) return
+
+              let orderInformation: any = {
+                orderId: releaseGood.refOrderId,
+                packageId: op.packageId
+              }
+              if (releaseGood.lmdOption) {
+                let releaseGoodQuery: ReleaseGood = await getRepository(ReleaseGood).findOne({
+                  where: { id: releaseGood.id },
+                  relations: ['lastMileDelivery']
+                })
+                orderInformation = {
+                  ...orderInformation,
+                  awb: op.airwayBill,
+                  trackingNo: op.trackingNo,
+                  lmdOption: releaseGood.lmdOption,
+                  shipperName: releaseGoodQuery.lastMileDelivery.platform
+                }
+              }
+
+              try {
+                await PowrupAPI.initiateShipment(powrup, {
+                  ...orderInformation,
+                  context: { state: { domain: this?.domain, user: this?.user } }
+                })
+                await getRepository(OrderPackage).update({ id: op.id }, { marketRtsCallSuccess: new Date() })
+              } catch (error) {
+                logger.error(
+                  `powrup-controller[initiateShipment]: ${JSON.stringify({
+                    ...orderInformation,
+                    context: { state: { domain: this?.domain, user: this?.user } },
+                    error: error
+                  })}`
+                )
+              }
+            })
+        )
+      }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  async fetchDocument(powrup: Powrup, releaseGood: ReleaseGood): Promise<ReleaseGood> {
+    if (releaseGood?.ownTransport && releaseGood?.lmdOption) {
+      return
+    }
+    try {
+      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')
+
+            const orderInformation: any = {
+              orderId: releaseGood.refOrderId,
+              packageId: op.packageId
+            }
+
+            const {
+              documents,
+              trackingNo,
+              transporter
+            }: { documents: any[]; trackingNo: string; transporter: string } = await PowrupAPI.fetchDocument(powrup, {
+              ...orderInformation,
+              context: { state: { domain: this?.domain, user: this?.user } }
+            })
+
+            let updateInfo: any
+            if (documents?.length) {
+              documents.map(document => {
+                if (document.type === 'invoice') {
+                  updateInfo = { ...updateInfo, invoice: document.download_url }
+                } else if (document.type === 'airway_bill') {
+                  updateInfo = { ...updateInfo, airwayBill: document.download_url }
+                }
+              })
+
+              updateInfo = {
+                ...updateInfo,
+                trackingNo: trackingNo,
+                transporter: transporter,
+                updater: this.user
+              }
+
+              await this.trxMgr.getRepository(OrderPackage).update({ id: op.id }, { ...updateInfo })
+            }
+          })
+        )
+
+        releaseGood = await this.trxMgr.getRepository(ReleaseGood).findOne({ id: releaseGood.id })
+      }
+
+      return releaseGood
+    } catch (error) {
+      throw error
+    }
+  }
+}

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

@@ -2,6 +2,7 @@ import { Equal, Not } from 'typeorm'
 
 import { ApplicationType } from '@things-factory/auth-base'
 import { logger } from '@things-factory/env'
+import { Powrup } from '@things-factory/integration-powrup'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { Product, ProductBarcode, ProductDetail } from '@things-factory/product-base'
 import {
@@ -24,7 +25,7 @@ import {
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
 import { Worksheet, WorksheetDetail } from '../../entities'
-import { SellercraftController } from '../index'
+import { SellercraftController, PowrupController } from '../index'
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 
 export class PackingWorksheetController extends VasWorksheetController {
@@ -124,6 +125,33 @@ export class PackingWorksheetController extends VasWorksheetController {
         }
         break
 
+      case ApplicationType.POWRUP:
+        const powrup: Powrup = await this.trxMgr.getRepository(Powrup).findOne({ active: true })
+
+        if (powrup) {
+          const powrupCtrl: PowrupController = new PowrupController(this.trxMgr, this.domain, this.user)
+
+          let rtsOrderDoc = async (powrup: any, releaseGood: any, domain: any, user: any) => {
+            try {
+              // trigger RTS
+              await powrupCtrl.initiateShipment(powrup, releaseGood)
+            } catch (error) {
+              logger.error(
+                `packing-worksheet-controller[activatePacking]:(data:${JSON.stringify({
+                  powrup,
+                  releaseGood,
+                  domain,
+                  user
+                })}) ${error} `
+              )
+            }
+          }
+
+          // asynchronously trigger RTS
+          rtsOrderDoc(powrup, releaseGood, this.domain, this.user)
+        }
+        break
+
       default:
         break
     }

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

@@ -1,26 +1,12 @@
-import {
-  EntityManager,
-  Equal,
-  getConnection,
-  getManager,
-  In,
-  IsNull,
-  Not
-} from 'typeorm'
+import { EntityManager, Equal, getConnection, getManager, In, IsNull, Not } from 'typeorm'
 
 import { ApplicationType } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { logger } from '@things-factory/env'
 import { generateId } from '@things-factory/id-rule-base'
-import {
-  Sellercraft,
-  SellercraftStatus
-} from '@things-factory/integration-sellercraft'
-import {
-  Product,
-  ProductBarcode,
-  ProductDetail
-} from '@things-factory/product-base'
+import { Powrup } from '@things-factory/integration-powrup'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { Product, ProductBarcode, ProductDetail } from '@things-factory/product-base'
 import {
   GenerateBatchPickInfo,
   ORDER_INVENTORY_STATUS,
@@ -50,21 +36,10 @@ import {
   TOTE_STATUS
 } from '@things-factory/warehouse-base'
 
-import {
-  TASK_NUMBER_RULE_TYPE,
-  TASK_NUMBER_SETTING_KEY,
-  WORKSHEET_STATUS,
-  WORKSHEET_TYPE
-} from '../../constants'
-import { SellercraftController } from '../../controllers'
-import {
-  Worksheet,
-  WorksheetDetail
-} from '../../entities'
-import {
-  isInventoryObsolete,
-  WorksheetNoGenerator
-} from '../../utils'
+import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
+import { SellercraftController, PowrupController } from '../../controllers'
+import { Worksheet, WorksheetDetail } from '../../entities'
+import { isInventoryObsolete, WorksheetNoGenerator } from '../../utils'
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 
 export class PickingWorksheetController extends VasWorksheetController {
@@ -292,6 +267,30 @@ export class PickingWorksheetController extends VasWorksheetController {
           })
           break
 
+        case ApplicationType.POWRUP:
+          getManager().transaction(async txMgr => {
+            const powrup: Powrup = await txMgr.getRepository(Powrup).findOne({ active: true })
+
+            if (powrup) {
+              const powrupCtrl: PowrupController = new PowrupController(txMgr, this.domain, this.user)
+
+              if (!releaseGood?.orderPackages?.length) {
+                const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
+                  where: { releaseGood },
+                  relations: ['product', 'productDetail']
+                })
+
+                // asynchronously pack order
+                await powrupCtrl.packOrder(powrup, {
+                  ...releaseGood,
+                  orderProducts,
+                  domain: worksheet.domain
+                })
+              }
+            }
+          })
+          break
+
         default:
           break
       }
@@ -331,16 +330,16 @@ export class PickingWorksheetController extends VasWorksheetController {
     const pickingOrderInventory: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
       where: { domain: this.domain, refWorksheetId: worksheet.id, status: ORDER_STATUS.PICKING },
       relations: [
-      'releaseGood',
-      'releaseGood.domain',
-      'releaseGood.lastMileDelivery', 
-      'releaseGood.bizplace',
-      'releaseGood.bizplace.domain',
-      'releaseGood.orderPackages',
-      'releaseGood.orderPackages.orderPackageItems',
-      'releaseGood.orderPackages.orderPackageItems.orderProduct',
-      'releaseGood.orderPackages.orderPackageItems.orderProduct.product'
-    ]
+        'releaseGood',
+        'releaseGood.domain',
+        'releaseGood.lastMileDelivery',
+        'releaseGood.bizplace',
+        'releaseGood.bizplace.domain',
+        'releaseGood.orderPackages',
+        'releaseGood.orderPackages.orderPackageItems',
+        'releaseGood.orderPackages.orderPackageItems.orderProduct',
+        'releaseGood.orderPackages.orderPackageItems.orderProduct.product'
+      ]
     })
 
     let releaseGoods: ReleaseGood[] = pickingOrderInventory.reduce((data, oi: OrderInventory) => {
@@ -383,6 +382,26 @@ export class PickingWorksheetController extends VasWorksheetController {
                 })
                 break
 
+              case ApplicationType.POWRUP:
+                getManager().transaction(async txMgr => {
+                  const powrup: Powrup = await txMgr.getRepository(Powrup).findOne({ active: true })
+
+                  if (powrup) {
+                    const powrupCtrl: PowrupController = new PowrupController(txMgr, this.domain, this.user)
+
+                    if (!releaseGood?.orderPackages?.length) {
+                      const orderProducts: OrderProduct[] = await txMgr.getRepository(OrderProduct).find({
+                        where: { releaseGood },
+                        relations: ['product', 'productDetail']
+                      })
+
+                      // asynchronously pack order
+                      await powrupCtrl.packOrder(powrup, { ...releaseGood, orderProducts })
+                    }
+                  }
+                })
+                break
+
               default:
                 break
             }
@@ -1354,7 +1373,9 @@ export class PickingWorksheetController extends VasWorksheetController {
     worksheet.endedAt = new Date()
     worksheet.updater = this.user
 
-    const worksheetDetails: any = worksheet.worksheetDetails.filter(wsD => wsD.status != 'MISSING' && wsD.status != 'CANCELLED')
+    const worksheetDetails: any = worksheet.worksheetDetails.filter(
+      wsD => wsD.status != 'MISSING' && wsD.status != 'CANCELLED'
+    )
     worksheetDetails.forEach((wsd: WorksheetDetail) => {
       wsd.status = WORKSHEET_STATUS.DONE
       wsd.updater = this.user

package/server/controllers/worksheet-controller.ts

@@ -416,7 +416,7 @@ export class WorksheetController {
     let existingWorksheet: Worksheet
     try {
       existingWorksheet = await this.findWorksheetByRefOrder(refOrder, type)
-    } catch (e) {}
+    } catch (e) { }
 
     if (existingWorksheet)
       throw new Error(
@@ -1128,8 +1128,8 @@ export class WorksheetController {
   }
 
   public async getDirectQty(productDetail: ProductDetail, productBarcode: string, qty: number): Promise<any> {
+    console.time(`getDirectQty ${productDetail.id} - ${productBarcode}`)
     try {
-      console.time('getDirectQty')
       let results = await this.trxMgr.query(
         `
         WITH RECURSIVE cte as (
@@ -1157,9 +1157,10 @@ export class WorksheetController {
 
       if (results.length <= 0) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
-      console.timeEnd('getDirectQty')
+      console.timeEnd(`getDirectQty ${productDetail.id} - ${productBarcode}`)
       return results[0]
     } catch (error) {
+      console.timeEnd(`getDirectQty ${productDetail.id} - ${productBarcode}`)
       throw error
     }
   }

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

@@ -37,16 +37,17 @@ export const completePackingResolver = {
           logger.error(`worksheet-base[completePacking]: ${error}`)
         }
       }
+    } else {
+      const bizplace: Bizplace = await getMyBizplace(domain, user)
+      const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
+
+      await worksheetController.notifyToCustomer(bizplace, {
+        title: `Packing has been completed (${bizplace.name}, ${releaseGoodNo})`,
+        body: `Items now are ready to be shipped/delivery`,
+        url: context.header.referer,
+        data: { url: context.header.referer }
+      })
     }
-
-    const bizplace: Bizplace = await getMyBizplace(domain, user)
-    const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
-    await worksheetController.notifyToCustomer(bizplace, {
-      title: `Packing has been completed (${bizplace.name}, ${releaseGoodNo})`,
-      body: `Items now are ready to be shipped/delivery`,
-      url: context.header.referer,
-      data: { url: context.header.referer }
-    })
   }
 }
 

package/server/graphql/resolvers/worksheet/packing/packing.ts

@@ -1,11 +1,13 @@
 import { EntityManager } from 'typeorm'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
+import { Powrup } from '@things-factory/integration-powrup'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
+// import { PowrupController } from '@things-factory/warehouse-base'
 
-import { PackingWorksheetController, SellercraftController } from '../../../../controllers'
+import { PackingWorksheetController, SellercraftController, PowrupController } from '../../../../controllers'
 
 export const packingResolver = {
   async packing(_: any, { orderPackageItemId, releaseQty, serialNumber }, context: any) {
@@ -40,6 +42,15 @@ export async function packing(
       }
       break
 
+    case ApplicationType.POWRUP:
+      const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true })
+
+      if (powrup) {
+        const powrupCtrl: PowrupController = new PowrupController(tx, domain, user)
+        await powrupCtrl.fetchDocument(powrup, releaseGood)
+      }
+      break
+
     default:
       break
   }

package/server/graphql/resolvers/worksheet/packing/scan-product-packing.ts

@@ -20,8 +20,8 @@ export async function scanProductPacking(
   productBarcode: string,
   serialNumber?: string
 ) {
+  console.time(`execution time to scan for packing ${orderPackageItemId} - ${productBarcode}`)
   try {
-    console.time('execution time to scan for packing')
     const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
     const inventoryItems = await worksheetController.scanProductPacking(
       orderPackageItemId,
@@ -29,7 +29,7 @@ export async function scanProductPacking(
       serialNumber
     )
 
-    console.timeEnd('execution time to scan for packing')
+    console.timeEnd(`execution time to scan for packing ${orderPackageItemId} - ${productBarcode}`)
     return inventoryItems
 
     // if (releaseGood.type === 'b2c' && !releaseGood?.airwayBill) {
@@ -43,6 +43,7 @@ export async function scanProductPacking(
     //   }
     // }
   } catch (error) {
+    console.timeEnd(`execution time to scan for packing ${orderPackageItemId} - ${productBarcode}`)
     throw error
   }
 }

package/server/graphql/resolvers/worksheet/packing-worksheet.ts

@@ -2,6 +2,7 @@ import { EntityManager, getManager, SelectQueryBuilder } from 'typeorm'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { logger } from '@things-factory/env'
+import { Powrup } from '@things-factory/integration-powrup'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import {
   MarketplaceOrder,
@@ -22,7 +23,7 @@ import { Domain } from '@things-factory/shell'
 import { Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
-import { PackingWorksheetController, SellercraftController } from '../../../controllers'
+import { PackingWorksheetController, SellercraftController, PowrupController } from '../../../controllers'
 import { Worksheet } from '../../../entities'
 
 export const packingWorksheetResolver = {
@@ -210,6 +211,15 @@ export const packingWorksheetResolver = {
           }
           break
 
+        case ApplicationType.POWRUP:
+          const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true })
+
+          if (powrup) {
+            // asynchronously get document from powrup
+            getPowrupDocument(powrup, releaseGood, domain, user)
+          }
+          break
+
         case ApplicationType.MMS:
           marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
             where: { orderNo: releaseGood.refNo },
@@ -297,7 +307,9 @@ export const packingWorksheetResolver = {
               // packingType: inventory.packingType,
               // packingSize: inventory.packingSize,
               // this is the problem
-              binLocation: binLocation ? releaseGood.orderInventories.find(oi  => oi.orderProductId == opi.orderProduct.id)?.binLocation : binLocation ,
+              binLocation: binLocation
+                ? releaseGood.orderInventories.find(oi => oi.orderProductId == opi.orderProduct.id)?.binLocation
+                : binLocation,
               isBatchPicking
               // location: inventory.location,
               // relatedOrderInv: targetInventory
@@ -397,3 +409,35 @@ async function getSellercraftDocument(sellercraft: Sellercraft, releaseGood: Rel
     }
   })
 }
+
+//trigger RTS, init document, and fetch powrup document in separated transaction
+async function getPowrupDocument(powrup: Powrup, releaseGood: ReleaseGood, domain: Domain, user: User) {
+  await getManager().transaction(async txMgr => {
+    const powrupCtrl: PowrupController = new PowrupController(txMgr, domain, user)
+    try {
+      if (!releaseGood?.airwayBill) {
+        try {
+          // try fetch order document / AWB
+          releaseGood = await powrupCtrl.fetchDocument(powrup, releaseGood)
+        } catch (error) {
+          try {
+            // retry initiate order shipment / RTS
+            await powrupCtrl.initiateShipment(powrup, releaseGood)
+          } catch (error) {
+            throw new Error(`initiateOrderShipment: ${error}`)
+          }
+          throw new Error(`fetchOrderDocument: ${error}`)
+        }
+      }
+    } catch (error) {
+      logger.error(
+        `packing-worksheet[getPowrupDocument]:(data:${JSON.stringify({
+          powrup,
+          releaseGood,
+          domain,
+          user
+        })}) ${error} `
+      )
+    }
+  })
+}