@things-factory/worksheet-base 5.0.12 → 6.0.0-alpha.0

package/server/graphql/resolvers/worksheet/pending-cancellation-release-order.ts

@@ -1,8 +1,6 @@
-import { EntityManager, In } from 'typeorm'
+import { In } from 'typeorm'
 
-import { Role, User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
 import {
   DeliveryOrder,
   ORDER_INVENTORY_STATUS,
@@ -12,18 +10,18 @@ import {
   OrderVas,
   ReleaseGood
 } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
 
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
 export const pendingCancellationReleaseOrder = {
-  async pendingCancellationReleaseOrder(_: any, { name }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async pendingCancellationReleaseOrder(_: any, { name }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     const foundRO: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['bizplace', 'orderInventories', 'orderVass']
     })
 
+    if (foundRO.status === 'DONE') throw new Error('Release good has been completed!')
     if (!foundRO) throw new Error(`Release good order doesn't exists.`)
     let targetOIs: OrderInventory[] = foundRO.orderInventories
     let foundOVs: OrderVas[] = foundRO.orderVass
@@ -55,6 +53,7 @@ export const pendingCancellationReleaseOrder = {
       pickingOIs = targetOIs
         .filter(
           (oi: OrderInventory) =>
+            oi.status === ORDER_INVENTORY_STATUS.ASSIGNED ||
             oi.status === ORDER_INVENTORY_STATUS.PICKING ||
             oi.status === ORDER_INVENTORY_STATUS.READY_TO_PICK ||
             oi.status === ORDER_INVENTORY_STATUS.PENDING_SPLIT ||
@@ -93,81 +92,89 @@ export const pendingCancellationReleaseOrder = {
       await tx.getRepository(OrderVas).save(foundOVs)
     }
 
-    if (pickedOIs && pickedOIs.length) {
-      let pickedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-        where: {
-          domain,
-          targetInventory: In(pickedOIs.map(oi => oi.id)),
-          status: ORDER_INVENTORY_STATUS.DONE
-        }
-      })
+    // find worksheet and update status to PENDING_CANCEL
+    let foundWS: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        releaseGood: foundRO
+      },
+      order: { createdAt: 'DESC' }
+    })
 
-      pickedWSD = pickedWSD.map((wsd: WorksheetDetail) => {
-        return {
-          ...wsd,
+    if (foundWS) {
+      await tx.getRepository(Worksheet).update(
+        { id: foundWS.id },
+        {
           status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
           updater: user
         }
-      })
-      await tx.getRepository(WorksheetDetail).save(pickedWSD)
-
-      let replacedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-        where: {
-          domain,
-          targetInventory: In(pickedOIs.map(oi => oi.id)),
-          status: ORDER_INVENTORY_STATUS.REPLACED
-        },
-        relations: ['targetInventory']
-      })
+      )
+
+      if (pickedOIs && pickedOIs.length) {
+        let pickedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+          where: {
+            domain: { id: domain.id },
+            targetInventory: In(pickedOIs.map(oi => oi.id)),
+            status: ORDER_INVENTORY_STATUS.DONE,
+            worksheet: { id: foundWS.id }
+          }
+        })
 
-      if (replacedWSD && replacedWSD.length) {
-        let replacedOI: OrderInventory[] = replacedWSD.map((wsd: WorksheetDetail) => wsd.targetInventory)
-        replacedOI = replacedOI.map((oi: OrderInventory) => {
+        pickedWSD = pickedWSD.map((wsd: WorksheetDetail) => {
           return {
-            ...oi,
-            status: ORDER_INVENTORY_STATUS.REPLACED,
+            ...wsd,
+            status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
             updater: user
           }
         })
-        await tx.getRepository(OrderInventory).save(replacedOI)
-      }
-    }
+        await tx.getRepository(WorksheetDetail).save(pickedWSD)
 
-    if (pickingOIs && pickingOIs.length) {
-      let pickingWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
-        where: { domain, targetInventory: In(pickingOIs.map(oi => oi.id)) }
-      })
+        let replacedWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+          where: {
+            domain: { id: domain.id },
+            targetInventory: In(pickedOIs.map(oi => oi.id)),
+            status: ORDER_INVENTORY_STATUS.REPLACED,
+            worksheet: { id: foundWS.id }
+          },
+          relations: ['targetInventory']
+        })
 
-      pickingWSD = pickingWSD.map((wsd: WorksheetDetail) => {
-        return {
-          ...wsd,
-          status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
-          updater: user
+        if (replacedWSD && replacedWSD.length) {
+          let replacedOI: OrderInventory[] = replacedWSD.map((wsd: WorksheetDetail) => wsd.targetInventory)
+          replacedOI = replacedOI.map((oi: OrderInventory) => {
+            return {
+              ...oi,
+              status: ORDER_INVENTORY_STATUS.REPLACED,
+              updater: user
+            }
+          })
+          await tx.getRepository(OrderInventory).save(replacedOI)
         }
-      })
-      await tx.getRepository(WorksheetDetail).save(pickingWSD)
-    }
-
-    // find worksheet and update status to PENDING_CANCEL
-    let foundWS: Worksheet[] = await tx.getRepository(Worksheet).find({
-      where: {
-        domain,
-        releaseGood: foundRO
       }
-    })
 
-    foundWS = foundWS.map((ws: Worksheet) => {
-      return {
-        ...ws,
-        status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
-        updater: user
+      if (pickingOIs && pickingOIs.length) {
+        let pickingWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+          where: {
+            domain: { id: domain.id },
+            targetInventory: In(pickingOIs.map(oi => oi.id)),
+            worksheet: { id: foundWS.id }
+          }
+        })
+
+        pickingWSD = pickingWSD.map((wsd: WorksheetDetail) => {
+          return {
+            ...wsd,
+            status: ORDER_INVENTORY_STATUS.PENDING_CANCEL,
+            updater: user
+          }
+        })
+        await tx.getRepository(WorksheetDetail).save(pickingWSD)
       }
-    })
-    await tx.getRepository(Worksheet).save(foundWS)
+    }
 
     // find DO and change status to pending cancel
     let foundDO: DeliveryOrder[] = await tx.getRepository(DeliveryOrder).find({
-      where: { domain, releaseGood: foundRO }
+      where: { domain: { id: domain.id }, releaseGood: foundRO }
     })
 
     foundDO = foundDO.map((deliveryOrder: DeliveryOrder) => {
@@ -185,39 +192,42 @@ export const pendingCancellationReleaseOrder = {
       updater: user
     })
 
-    // notification logics
-    // get Office Admin Users
-    const users: any[] = await tx
-      .getRepository('users_roles')
-      .createQueryBuilder('ur')
-      .select('ur.users_id', 'id')
-      .where(qb => {
-        const subQuery = qb
-          .subQuery()
-          .select('role.id')
-          .from(Role, 'role')
-          .where("role.name = 'Office Admin'")
-          .andWhere('role.domain_id = :domain', { domain: domain.id })
-          .getQuery()
-        return 'ur.roles_id IN ' + subQuery
-      })
-      .getRawMany()
-
-    // send notification to Office Admin Users
-    if (users?.length && context.header?.referer) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `${foundRO.name} cancellation`,
-        body: `${customerBizplace.name} is requesting to cancel order`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
-    }
+    /**
+     * @notes Temporary off sendNotification due to suspect of causing wms down
+     */
+    // // notification logics
+    // // get Office Admin Users
+    // const users: any[] = await tx
+    //   .getRepository('users_roles')
+    //   .createQueryBuilder('ur')
+    //   .select('ur.users_id', 'id')
+    //   .where(qb => {
+    //     const subQuery = qb
+    //       .subQuery()
+    //       .select('role.id')
+    //       .from(Role, 'role')
+    //       .where("role.name = 'Office Admin'")
+    //       .andWhere('role.domain_id = :domain', { domain: domain.id })
+    //       .getQuery()
+    //     return 'ur.roles_id IN ' + subQuery
+    //   })
+    //   .getRawMany()
+
+    // // send notification to Office Admin Users
+    // if (users?.length && context.header?.referer) {
+    //   const receivers: any[] = users.map(user => user.id)
+    //   const msg = {
+    //     title: `${foundRO.name} cancellation`,
+    //     body: `${customerBizplace.name} is requesting to cancel order`,
+    //     url: context.header.referer,
+    //     data: { url: context.header.referer }
+    //   }
+
+    //   await sendNotification({
+    //     receivers,
+    //     message: { ...msg }
+    //   })
+    // }
 
     return
   }

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

@@ -2,16 +2,14 @@ import { EntityManager } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { MarketplaceStore } from '@things-factory/integration-marketplace'
-import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
-import { ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 
-import { EcommerceController, PickingWorksheetController, SellercraftController } from '../../../../controllers'
+import { EcommerceController, PickingWorksheetController } from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
 
 export const activateBatchPickingResolver = {
-  async activateBatchPicking(_: any, { worksheetNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async activateBatchPicking(_: any, { worksheetNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     return await activateBatchPicking(tx, domain, user, worksheetNo)
   }
 }
@@ -27,31 +25,6 @@ export async function activateBatchPicking(
   const worksheetDetails = worksheet.worksheetDetails
   const companyDomain: Domain = worksheet?.bizplace.company.domain
 
-  const sellercraft: Sellercraft = await tx
-    .getRepository(Sellercraft)
-    .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
-
-  if (sellercraft) {
-    const releaseGoods: ReleaseGood[] = worksheetDetails.map(
-      worksheetDetail => worksheetDetail.targetInventory && worksheetDetail.targetInventory.releaseGood
-    )
-    const uniqueReleaseGoods: ReleaseGood[] = []
-    const map = new Map()
-    for (const releaseGood of releaseGoods) {
-      if (!map.has(releaseGood.id)) {
-        map.set(releaseGood.id, true)
-        uniqueReleaseGoods.push({ ...releaseGood })
-      }
-    }
-
-    await Promise.all(
-      uniqueReleaseGoods.map(async releaseGood => {
-        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-        await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
-      })
-    )
-  }
-
   // find for any existing marketplace store connections
   const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
     where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },

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

@@ -11,8 +11,8 @@ import { EcommerceController, PickingWorksheetController } from '../../../../con
 import { Worksheet } from '../../../../entities'
 
 export const activatePickingResolver = {
-  async activatePicking(_: any, { worksheetNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async activatePicking(_: any, { worksheetNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     return await activatePicking(tx, domain, user, worksheetNo)
   }
 }
@@ -38,7 +38,7 @@ export async function activatePicking(
   if (releaseGood.type === 'b2c') {
     const sellercraft: Sellercraft = await tx
       .getRepository(Sellercraft)
-      .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+      .findOneBy({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
     if (marketplaceStores?.length && !sellercraft) {
       if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {

package/server/graphql/resolvers/worksheet/picking/assign-picking-inventories.ts

@@ -1,6 +1,8 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { PickingWorksheetController } from '../../../../controllers'
 import { WorksheetDetail } from '../../../../entities'
 
@@ -10,8 +12,18 @@ export const assignPickingInventoriesResolver = {
     { worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails },
     context: any
   ): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await assignPickingInventories(tx, domain, user, worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails)
+    const { tx, domain, user } = context.state
+    await assignPickingInventories(
+      tx,
+      domain,
+      user,
+      worksheetNo,
+      batchId,
+      productId,
+      packingType,
+      packingSize,
+      worksheetDetails
+    )
   }
 }
 
@@ -27,5 +39,12 @@ export async function assignPickingInventories(
   worksheetDetails: Partial<WorksheetDetail>[]
 ): Promise<void> {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.assignPickingInventories(worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails)
+  await worksheetController.assignPickingInventories(
+    worksheetNo,
+    batchId,
+    productId,
+    packingType,
+    packingSize,
+    worksheetDetails
+  )
 }

package/server/graphql/resolvers/worksheet/picking/assign-picking-worker.ts

@@ -1,6 +1,8 @@
+import { In } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import { Worksheet } from '../../../../entities'
 
@@ -10,27 +12,33 @@ export const assignPickingWorkerResolver = {
     { worksheetId, userId }: { worksheetId: [string]; userId: string },
     context: any
   ): Promise<void> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
-    const assignee: User = await tx.getRepository(User).findOne(userId, { relations: ['domains'] })
+    const { tx, domain } = context.state
+    const assignee: User = await tx.getRepository(User).findOne({
+      where: { id: userId },
+      relations: ['domains']
+    })
     if ((assignee?.domains || []).every((userDomain: Domain) => userDomain.id !== domain.id))
       throw new Error('Target user is not belong to current domain')
 
     if (!assignee) throw new Error('failed to find target user')
 
-    await Promise.all(worksheetId.map(async (worksheetId)=>{
-      const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-        id: worksheetId,
-      },{where: [{
-        type:WORKSHEET_TYPE.BATCH_PICKING
-      },{type:WORKSHEET_TYPE.PICKING}]})
-  
-      if (!worksheet) throw new Error('failed to find target picking worksheet')
-      if (worksheet.status !== WORKSHEET_STATUS.DEACTIVATED)
-        throw new Error(`current status of worksheet is not able to assign worker`)
-  
-      worksheet.assignee = assignee
-      await tx.getRepository(Worksheet).save(worksheet)
+    await Promise.all(
+      worksheetId.map(async worksheetId => {
+        const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+          where: {
+            id: worksheetId,
+            type: In([WORKSHEET_TYPE.BATCH_PICKING, WORKSHEET_TYPE.PICKING])
+          }
+          /* CONFIRMME regarding TYPEORM */
+        })
+
+        if (!worksheet) throw new Error('failed to find target picking worksheet')
+        if (worksheet.status !== WORKSHEET_STATUS.DEACTIVATED)
+          throw new Error(`current status of worksheet is not able to assign worker`)
 
-    }))
+        worksheet.assignee = assignee
+        await tx.getRepository(Worksheet).save(worksheet)
+      })
+    )
   }
 }

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

@@ -1,6 +1,8 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const batchPickingResolver = {
@@ -9,7 +11,7 @@ export const batchPickingResolver = {
     { taskNo, worksheetType, palletId, locationName, binLocationName, releaseQty },
     context: any
   ) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     await batchPicking(tx, domain, user, taskNo, worksheetType, palletId, locationName, binLocationName, releaseQty)
   }
 }

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

@@ -16,8 +16,8 @@ import { WorksheetController } from '../../../../controllers/worksheet-controlle
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const completeBatchPickingResolver = {
-  async completeBatchPicking(_: any, { taskNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async completeBatchPicking(_: any, { taskNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
 
     await completeBatchPicking(tx, domain, user, taskNo)
 
@@ -42,11 +42,13 @@ export async function completeBatchPicking(
   const worksheet = await pickingWSCtrl.completeBatchPicking(taskNo)
 
   const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-  const targetInventories: OrderInventory[] = worksheetDetails.filter(wsd=>wsd.status != 'MISSING').map((wsd: WorksheetDetail) => wsd.targetInventory)
+  const targetInventories: OrderInventory[] = worksheetDetails
+    .filter(wsd => wsd.status != 'MISSING')
+    .map((wsd: WorksheetDetail) => wsd.targetInventory)
 
   const sellercraft: Sellercraft = await tx
     .getRepository(Sellercraft)
-    .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+    .findOneBy({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
   if (sellercraft) {
     const releaseGoods: ReleaseGood[] = worksheetDetails.map(
@@ -72,10 +74,17 @@ export async function completeBatchPicking(
 
         if (!foundReleaseGood?.packageId) {
           foundReleaseGood = await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
+          if (foundReleaseGood?.packageId) {
+            await tx
+              .getRepository(ReleaseGood)
+              .update(
+                { id: foundReleaseGood.id },
+                { packageId: foundReleaseGood.packageId, updater: foundReleaseGood.updater }
+              )
+          }
         }
 
-        foundReleaseGood = await sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
-        await sellercraftCtrl.initiateOrderDocument(sellercraft, foundReleaseGood)
+        sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
       })
     )
   }

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

@@ -1,4 +1,4 @@
-import { EntityManager } from 'typeorm'
+import { EntityManager, getManager } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint, getMyBizplace } from '@things-factory/biz-base'
@@ -33,8 +33,8 @@ import { WorksheetController } from '../../../../controllers/worksheet-controlle
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const completePickingResolver = {
-  async completePicking(_: any, { releaseGoodNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async completePicking(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
 
     await completePicking(tx, domain, user, releaseGoodNo)
 
@@ -57,7 +57,7 @@ export async function completePicking(
 ): Promise<void> {
   const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name: releaseGoodNo },
+    where: { domain: { id: domain.id }, name: releaseGoodNo },
     relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
   })
 
@@ -68,7 +68,7 @@ export async function completePicking(
 
   const warehouseContactPoint: ContactPoint = await tx.getRepository(ContactPoint).findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       type: 'WAREHOUSE'
     }
   })
@@ -82,25 +82,39 @@ export async function completePicking(
   await pickingWSCtrl.completePicking(releaseGoodNo)
 
   if (releaseGood.type == 'b2c') {
-    const sellercraft: Sellercraft = await tx
-      .getRepository(Sellercraft)
-      .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+    const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOneBy({
+      domain: {
+        id: releaseGood.bizplace.domain.id
+      },
+      status: SellercraftStatus.ACTIVE
+    })
+    const initSCOrderShipment = async sellercraft => {
+      if (sellercraft) {
+        await getManager().transaction(async txMgr => {
+          const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
+
+          if (!releaseGood?.packageId) {
+            const orderProducts: OrderProduct[] = await tx.getRepository(OrderProduct).find({
+              where: { releaseGood },
+              relations: ['product', 'product.productDetails']
+            })
+            releaseGood = await sellercraftCtrl.packOrder(sellercraft, { ...releaseGood, orderProducts })
 
-    if (sellercraft) {
-      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+            if (releaseGood?.packageId) {
+              await txMgr
+                .getRepository(ReleaseGood)
+                .update({ id: releaseGood.id }, { packageId: releaseGood.packageId, updater: releaseGood.updater })
+            }
+          }
 
-      if (!releaseGood?.packageId) {
-        const orderProducts: OrderProduct[] = await tx.getRepository(OrderProduct).find({
-          where: { releaseGood },
-          relations: ['product', 'product.productDetails']
+          await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
         })
-        releaseGood = await sellercraftCtrl.packOrder(sellercraft, { ...releaseGood, orderProducts })
       }
-
-      releaseGood = await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
-      await sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
     }
 
+    // asynchronouly call to initiate sellercraft order shipment/ RTS
+    initSCOrderShipment(sellercraft)
+
     const companyDomain: Domain = releaseGood.bizplace.company.domain
     let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
       where: { orderNo: releaseGood.refNo, domain: companyDomain },
@@ -138,7 +152,7 @@ export async function completePicking(
           marketplaceOrderShippingItems[0].marketplaceOrderShipping
         const lmd: LastMileDelivery = await tx.getRepository(LastMileDelivery).findOne({
           where: {
-            domain,
+            domain: { id: domain.id },
             platform: 'eTrax'
           }
         })
@@ -217,26 +231,7 @@ export async function completePicking(
 
   if (releaseGood.packingOption) {
     const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-
-    const directActivatePackingWorksheet: Setting = await tx.getRepository(Setting).findOne({
-      where: { domain: domain, category: 'id-rule', name: 'enable-direct-activate-packing-worksheet' }
-    })
-    const partnerDirectActivatePackingWorksheetSetting: PartnerSetting = await tx
-      .getRepository(PartnerSetting)
-      .findOne({
-        where: { setting: directActivatePackingWorksheet, domain: domain, partnerDomain: releaseGood.bizplace?.domain }
-      })
-
-    let packingWorksheet: Worksheet = await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
-
-    if (directActivatePackingWorksheet != undefined && directActivatePackingWorksheet.value.toLowerCase() == 'true') {
-      if (partnerDirectActivatePackingWorksheetSetting != undefined) {
-        if (partnerDirectActivatePackingWorksheetSetting.value.toLowerCase() == 'true')
-          await packingWSCtrl.activatePacking(packingWorksheet.name)
-      } else {
-        await packingWSCtrl.activatePacking(packingWorksheet.name)
-      }
-    }
+    await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
   } else {
     // Find Existing Loading Worksheet if any
     let existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
@@ -248,17 +243,17 @@ export async function completePicking(
     })
 
     if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
-      if(pickedTargetInventories.length>0){
+      if (pickedTargetInventories.length > 0) {
         const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
         let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
           releaseGoodNo,
           pickedTargetInventories
         )
-  
+
         if (!loadingWorksheet.worksheetDetails?.length) {
           loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
         }
-  
+
         const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
         await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
       }