@things-factory/worksheet-base 4.3.346 → 4.3.348

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

@@ -1,12 +1,27 @@
-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 { Powrup } from '@things-factory/integration-powrup'
-import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
-import { Product, ProductBarcode, ProductDetail } from '@things-factory/product-base'
+import {
+  Sellercraft,
+  SellercraftStatus
+} from '@things-factory/integration-sellercraft'
+import {
+  Product,
+  ProductBarcode,
+  ProductDetail
+} from '@things-factory/product-base'
 import {
   GenerateBatchPickInfo,
   InventoryUtil,
@@ -25,6 +40,7 @@ import {
   ReleaseGood
 } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
 import {
   generateInventoryHistory,
   Inventory,
@@ -40,10 +56,22 @@ import {
   TOTE_STATUS
 } from '@things-factory/warehouse-base'
 
-import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
+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 { inventoriesByStrategy, isInventoryObsolete, WorksheetNoGenerator } from '../../utils'
+import {
+  Worksheet,
+  WorksheetDetail
+} from '../../entities'
+import {
+  inventoriesByStrategy,
+  isInventoryObsolete,
+  WorksheetNoGenerator
+} from '../../utils'
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 
 export class PickingWorksheetController extends VasWorksheetController {
@@ -347,6 +375,56 @@ export class PickingWorksheetController extends VasWorksheetController {
     return worksheet
   }
 
+  async activateBulkPicking(worksheetNo: string[]): Promise<Worksheet[]> {
+    let worksheets: Worksheet[] = []
+    try {
+      const worksheetRepo = this.trxMgr.getRepository(Worksheet)
+      worksheets = await worksheetRepo
+        .createQueryBuilder('w')
+        .leftJoinAndSelect('w.domain', 'd')
+        .leftJoinAndSelect('w.bizplace', 'b')
+        .leftJoinAndSelect('w.worksheetDetails', 'wd')
+        .leftJoinAndSelect('w.releaseGood', 'rg')
+        .leftJoinAndSelect('rg.domain', 'rgd')
+        .leftJoinAndSelect('rg.bizplace', 'rgbz')
+        .leftJoinAndSelect('rgbz.domain', 'bzd')
+        .leftJoinAndSelect('b.domain', 'bd')
+        .leftJoinAndSelect('b.company', 'c')
+        .leftJoinAndSelect('c.domain', 'cd')
+        .leftJoinAndSelect('wd.targetInventory', 'ti')
+        .leftJoinAndSelect('ti.product', 'tp')
+        .where('w.name IN (:...worksheetNo)', { worksheetNo: worksheetNo })
+        .andWhere('w.status = :status', { status: WORKSHEET_STATUS.DEACTIVATED })
+        .getMany()
+
+      if (worksheets.length > 50) {
+        throw new Error('Please select maximum 50 worksheets with status deactivated to proceed')
+      }
+
+      let groupWs = new Map<string, string[]>()
+      for (const worksheet of worksheets) {
+        const bizplaceId = worksheet.bizplace.id
+        const worksheetId = worksheet.id
+
+        if (groupWs.has(bizplaceId)) {
+          groupWs.get(bizplaceId).push(worksheetId)
+        } else {
+          groupWs.set(bizplaceId, [worksheetId])
+        }
+      }
+
+      const groupedWsBiz = [...groupWs.entries()]
+      await Promise.all(
+        groupedWsBiz.map(async ([bizplaceId, worksheetIds]) => {
+          return await this.activateBulkWorksheets(bizplaceId, worksheetIds)
+        })
+      )
+    } catch (error) {
+      throw error
+    }
+    return worksheets
+  }
+
   async activateBatchPicking(worksheetNo: string): Promise<Worksheet> {
     let worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.BATCH_PICKING, [
       'worksheetDetails',
@@ -2030,14 +2108,16 @@ export class PickingWorksheetController extends VasWorksheetController {
     }
   }
 
-  async assignInventoriesForUnassignedOrder(worksheet: Worksheet): Promise<any> {
+  async assignInventoriesForUnassignedOrder(worksheet: Worksheet, tx?: EntityManager): Promise<any> {
     const releaseGood = worksheet.releaseGood
     const orderProducts = releaseGood.orderProducts
     let finalOrderInventories: OrderInventory[] = []
     let newWorksheetDetails: WorksheetDetail[] = []
-    const inventoryAssignmentSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
-      where: { domain: this.domain, name: 'rule-for-inventory-assignment' }
-    })
+    const transaction = tx ? tx : this.trxMgr
+
+    const inventoryAssignmentSetting: Setting = await transaction
+      .getRepository(Setting)
+      .findOne({ where: { domain: this.domain, name: 'rule-for-inventory-assignment' } })
 
     for (let op of orderProducts) {
       let locationSortingRules = []
@@ -2055,7 +2135,7 @@ export class PickingWorksheetController extends VasWorksheetController {
         locationSortingRules,
         releaseGood.bizplace,
         this.domain,
-        this.trxMgr,
+        transaction,
         op.batchId
       )
 
@@ -2074,23 +2154,22 @@ export class PickingWorksheetController extends VasWorksheetController {
 
       finalOrderInventories.push(...assignedOrderInventories)
 
-      await this.trxMgr
+      await transaction
         .getRepository(OrderProduct)
         .update({ id: op.id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: this.user })
     }
 
     for (let oi of finalOrderInventories) {
       // update inventory locked qty and uom value
-      oi = await this.trxMgr.getRepository(OrderInventory).save({ ...oi })
+      oi = await transaction.getRepository(OrderInventory).save({ ...oi })
 
-      await this.trxMgr.getRepository(Inventory).update(oi.inventory.id, {
+      await transaction.getRepository(Inventory).update(oi.inventory.id, {
         lockedQty: (oi.inventory?.lockedQty || 0) + oi.releaseQty,
         lockedUomValue: (oi.inventory?.lockedUomValue || 0) + oi.releaseUomValue,
         updater: this.user
       })
 
-      // update product detail stock deduct unassigned qty and unassigned uom value
-      await this.trxMgr
+      await transaction
         .getRepository(ProductDetailStock)
         .createQueryBuilder()
         .update(ProductDetailStock)
@@ -2117,7 +2196,7 @@ export class PickingWorksheetController extends VasWorksheetController {
 
       newWorksheetDetails.push(worksheetDetail)
     }
-    newWorksheetDetails = await this.trxMgr.getRepository(WorksheetDetail).save(newWorksheetDetails)
+    newWorksheetDetails = await transaction.getRepository(WorksheetDetail).save(newWorksheetDetails)
 
     return newWorksheetDetails
   }
@@ -2272,4 +2351,143 @@ export class PickingWorksheetController extends VasWorksheetController {
     }
     return newWorksheetDetails
   }
+
+  async activateBulkWorksheets(bizplaceId, worksheetIds) {
+    try {
+      for (const worksheetId of worksheetIds) {
+        try {
+          let releaseGood: ReleaseGood
+          let domain: Domain
+
+          getManager().transaction(async (tx: EntityManager) => {
+            const worksheetRepo = tx.getRepository(Worksheet)
+            let worksheet = await worksheetRepo
+              .createQueryBuilder('w')
+              .leftJoinAndSelect('w.domain', 'd')
+              .leftJoinAndSelect('w.bizplace', 'b')
+              .leftJoinAndSelect('w.worksheetDetails', 'wd')
+              .leftJoinAndSelect('w.releaseGood', 'rg')
+              .leftJoinAndSelect('rg.domain', 'rgd')
+              .leftJoinAndSelect('rg.bizplace', 'rgbz')
+              .leftJoinAndSelect('rgbz.domain', 'bzd')
+              .leftJoinAndSelect('rg.orderProducts', 'op')
+              .leftJoinAndSelect('op.productDetail', 'pd')
+              .leftJoinAndSelect('pd.product', 'p')
+              .leftJoinAndSelect('b.domain', 'bd')
+              .leftJoinAndSelect('b.company', 'c')
+              .leftJoinAndSelect('c.domain', 'cd')
+              .leftJoinAndSelect('wd.targetInventory', 'ti')
+              .leftJoinAndSelect('ti.product', 'tp')
+              .where('w.id = :worksheetId', { worksheetId: worksheetId })
+              .andWhere('w.bizplace_id = :bizplaceId', { bizplaceId: bizplaceId })
+              .getOne()
+
+            let worksheetDetails: WorksheetDetail[]
+
+            if (worksheet.releaseGood?.assignedInventory == false) {
+              worksheetDetails = await this.assignInventoriesForUnassignedOrder(worksheet, tx)
+              worksheet.worksheetDetails = worksheetDetails
+              worksheet.releaseGood.assignedInventory = true
+            } else {
+              worksheetDetails = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED')
+              const targetInventoryIds: OrderInventory[] = worksheetDetails.map(
+                (wsd: WorksheetDetail) => wsd.targetInventory.id
+              )
+
+              await tx.getRepository(OrderInventory).update(
+                { id: In(targetInventoryIds) },
+                {
+                  status: ORDER_INVENTORY_STATUS.PICKING,
+                  updater: this.user
+                }
+              )
+            }
+
+            await tx.getRepository(ReleaseGood).update(
+              { id: worksheet.releaseGood.id },
+              {
+                status: ORDER_STATUS.PICKING,
+                updater: this.user
+              }
+            )
+
+            worksheet = await this.activateWorksheet(worksheet, worksheetDetails, [], tx)
+            releaseGood = worksheet.releaseGood
+            domain = worksheet.domain
+          })
+
+          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,
+                      domain: domain
+                    })
+                  }
+                }
+              })
+              break
+
+            case ApplicationType.POWRUP:
+              getManager().transaction(async txMgr => {
+                const powrup: Powrup = await txMgr.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
+
+                if (powrup) {
+                  const powrupCtrl: PowrupController = new PowrupController()
+
+                  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,
+                      this.user,
+                      txMgr
+                    )
+                  }
+                }
+              })
+              break
+
+            default:
+              break
+          }
+        } catch (e) {
+          logger.error(
+            `picking-worksheet-controller[activateBulkWorksheets]: ( WorksheetId: ${worksheetId}, Error: ${e})`
+          )
+        }
+      }
+    } catch (e) {
+      console.log(e)
+    }
+  }
 }

package/server/controllers/worksheet-controller.ts

@@ -1,8 +1,25 @@
-import { EntityManager, EntitySchema, Equal, FindOneOptions, getRepository, In, Not } from 'typeorm'
+import {
+  EntityManager,
+  EntitySchema,
+  Equal,
+  FindOneOptions,
+  getRepository,
+  In,
+  Not
+} from 'typeorm'
 
-import { Role, User } from '@things-factory/auth-base'
-import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
-import { Product, ProductDetail } from '@things-factory/product-base'
+import {
+  Role,
+  User
+} from '@things-factory/auth-base'
+import {
+  Bizplace,
+  getDomainUsers
+} from '@things-factory/biz-base'
+import {
+  Product,
+  ProductDetail
+} from '@things-factory/product-base'
 import {
   ArrivalNotice,
   DeliveryOrder,
@@ -27,8 +44,14 @@ import {
   Pallet
 } from '@things-factory/warehouse-base'
 
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../constants'
-import { Worksheet, WorksheetDetail } from '../entities'
+import {
+  WORKSHEET_STATUS,
+  WORKSHEET_TYPE
+} from '../constants'
+import {
+  Worksheet,
+  WorksheetDetail
+} from '../entities'
 import { WorksheetNoGenerator } from '../utils'
 
 export type ReferenceOrderType =
@@ -742,8 +765,12 @@ export class WorksheetController {
   async activateWorksheet(
     worksheet: Worksheet,
     worksheetDetails: WorksheetDetail[],
-    changedWorksheetDetails: Partial<WorksheetDetail>[]
+    changedWorksheetDetails: Partial<WorksheetDetail>[],
+    tx?: EntityManager
   ): Promise<Worksheet> {
+
+    const transaction = tx ? tx : this.trxMgr
+
     if (!worksheet.id || worksheetDetails.some((wsd: WorksheetDetail) => !wsd.id)) {
       throw new Error(this.ERROR_MSG.UPDATE.ID_NOT_EXISTS)
     }
@@ -751,13 +778,14 @@ export class WorksheetController {
     worksheet.status = WORKSHEET_STATUS.EXECUTING
     worksheet.startedAt = new Date()
     worksheet.updater = this.user
-    worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
+    worksheet = await transaction.getRepository(Worksheet).save(worksheet)
+
 
     worksheetDetails = this.renewWorksheetDetails(worksheetDetails, changedWorksheetDetails, 'name', {
       status: WORKSHEET_STATUS.EXECUTING,
       updater: this.user
     })
-    worksheet.worksheetDetails = await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
+    worksheet.worksheetDetails = await transaction.getRepository(WorksheetDetail).save(worksheetDetails)
 
     return worksheet
   }

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

@@ -1,7 +1,9 @@
+import { EntityManager } 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_TYPE } from '../../../../constants'
 import { Worksheet } from '../../../../entities'
 
 export const assignPickingWorkerResolver = {
@@ -25,9 +27,6 @@ export const assignPickingWorkerResolver = {
       },{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)
 

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

@@ -0,0 +1,79 @@
+import { EntityManager } from 'typeorm'
+
+import {
+  ApplicationType,
+  User
+} from '@things-factory/auth-base'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { MarketplaceOrder } from '@things-factory/marketplace-base'
+import {
+  ORDER_STATUS,
+  ReleaseGood
+} from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import {
+  EcommerceController,
+  PickingWorksheetController
+} from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const activateBulkPickingResolver = {
+  async activateBulkPicking(_: any, { worksheetNo }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    return await activateBulkPicking(tx, domain, user, worksheetNo)
+  }
+}
+
+export async function activateBulkPicking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string[]
+): Promise<Worksheet[]> {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  const worksheets = await worksheetController.activateBulkPicking(worksheetNo)
+
+  for (const worksheet of worksheets) {
+    const companyDomain: Domain = worksheet?.bizplace.company.domain
+    let releaseGood: ReleaseGood = worksheet.releaseGood
+    const orderSource: string = releaseGood.source
+
+    switch (orderSource) {
+      case ApplicationType.MMS:
+        // find for any existing marketplace store connections
+        const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+          where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+          relations: ['marketplaceDistributors']
+        })
+
+        if (marketplaceStores?.length) {
+          if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+            const worksheetDetails = worksheet.worksheetDetails
+            let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+            const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+            await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
+          }
+
+          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+            where: { orderNo: releaseGood.refNo, domain: companyDomain },
+            relations: ['marketplaceStore']
+          })
+
+          if (marketplaceOrder) {
+            const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+            if (marketplaceStore.isAutoUpdateShipment) {
+              const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+              await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
+            }
+          }
+        }
+        break
+      default:
+        break
+    }
+  }
+  return worksheets
+}

package/server/graphql/resolvers/worksheet/picking/index.ts

@@ -2,22 +2,24 @@ import { activateBatchPickingResolver } from './activate-batch-picking'
 import { activatePickingResolver } from './activate-picking'
 import { assignPickingInventoriesResolver } from './assign-picking-inventories'
 import { assignPickingWorkerResolver } from './assign-picking-worker'
-import { fetchAndAssignPickingTaskResolver } from './fetch-and-assign-picking-task'
 import { batchPickingResolver } from './batch-picking'
+import { activateBulkPickingResolver } from './bulk-activate-picking'
 import { completeBatchPickingResolver } from './complete-batch-picking'
 import { completePickingResolver } from './complete-picking'
+import { fetchAndAssignPickingTaskResolver } from './fetch-and-assign-picking-task'
 import { pickingResolver } from './picking'
-import { scanProductPickingResolver } from './scan-product-picking'
+import { replenishmentPickingResolver } from './replenishment-picking'
 import { scanProductBatchPickingResolver } from './scan-product-batch-picking'
+import { scanProductPickingResolver } from './scan-product-picking'
+import { sealToteResolver } from './seal-tote'
 import { undoPickingAssigmentResolver } from './undo-picking-assignment'
 import { undoSerialNumberPickingResolver } from './undo-serial-number-picking'
-import { sealToteResolver } from './seal-tote'
-import { replenishmentPickingResolver } from './replenishment-picking'
 
 export const Mutations = {
   ...assignPickingInventoriesResolver,
   ...undoPickingAssigmentResolver,
   ...activatePickingResolver,
+  ...activateBulkPickingResolver,
   ...activateBatchPickingResolver,
   ...pickingResolver,
   ...scanProductPickingResolver,
@@ -29,5 +31,5 @@ export const Mutations = {
   ...fetchAndAssignPickingTaskResolver,
   ...undoSerialNumberPickingResolver,
   ...sealToteResolver,
-  ...replenishmentPickingResolver
+  ...replenishmentPickingResolver,
 }

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

@@ -37,54 +37,93 @@ interface WorksheetInterface extends Worksheet {
 
 export const worksheetResolver = {
   async worksheet(_: any, { name }, context: any) {
+    console.time('query for worksheet')
     const { domain }: { domain: Domain } = context.state
+
     let worksheet: WorksheetInterface
+
+    let thisWorksheet = await getRepository(Worksheet).findOne({
+      where: {
+        domain,
+        name
+      }
+    })
+
+    let worksheetRelations: string[] = []
+
+    switch (thisWorksheet?.type) {
+      case 'PICKING':
+      case 'BATCH_PICKING':
+      case 'LOADING':
+      case 'PACKING':
+      case 'PICKING_REPLENISHMENT':
+      case 'SORTING':
+      case 'WAREHOUSE_RETURN':
+      case 'PUTAWAY_RETURN':
+      case 'UNLOADING_RETURN':
+      case 'PUTAWAY_REPLENISHMENT':
+      case 'VAS':
+        worksheetRelations.push(
+          'domain',
+          'bizplace',
+          'bizplace.domain',
+          'bufferLocation',
+          'bufferLocation.warehouse',
+          'arrivalNotice',
+          'arrivalNotice.releaseGood',
+          'releaseGood',
+          'releaseGood.arrivalNotice',
+          'releaseGood.shippingOrder',
+          'releaseGood.orderPackages',
+          'releaseGood.orderProducts',
+          'releaseGood.orderProducts.product',
+          'replenishment',
+          'returnOrder',
+          'inventoryCheck',
+          'vasOrder',
+          'assignee',
+          'worksheetDetails',
+          'worksheetDetails.targetInventory',
+          'worksheetDetails.targetInventory.bizplace',
+          'worksheetDetails.targetInventory.product',
+          'worksheetDetails.targetInventory.inventory',
+          'worksheetDetails.targetInventory.inventory.product',
+          'worksheetDetails.targetInventory.inventory.warehouse',
+          'worksheetDetails.targetInventory.inventory.location',
+          'worksheetDetails.targetVas',
+          'creator',
+          'updater'
+        )
+        break
+
+      case 'UNLOADING':
+        worksheetRelations.push(
+          'worksheetDetails',
+          'worksheetDetails.toLocation',
+          'worksheetDetails.targetProduct',
+          'worksheetDetails.targetProduct.product',
+          'worksheetDetails.targetProduct.releaseGood',
+          'worksheetDetails.targetVas.product',
+          'worksheetDetails.targetVas.newProduct',
+          'worksheetDetails.targetVas.newProductDetail',
+          'worksheetDetails.targetVas.orderVasItems',
+          'worksheetDetails.targetVas.orderVasItems.vas',
+          'worksheetDetails.targetInventory.releaseGood',
+          'worksheetDetails.targetInventory.inspectedLocation'
+        )
+        break
+
+      default:
+        // Default case if the name doesn't match any defined case
+        break
+    }
+
     worksheet = (await getRepository(Worksheet).findOne({
       where: {
         domain,
         name
       },
-      relations: [
-        'domain',
-        'bizplace',
-        'bizplace.domain',
-        'bufferLocation',
-        'bufferLocation.warehouse',
-        'arrivalNotice',
-        'arrivalNotice.releaseGood',
-        'releaseGood',
-        'releaseGood.arrivalNotice',
-        'releaseGood.shippingOrder',
-        'releaseGood.orderPackages',
-        'releaseGood.orderProducts',
-        'releaseGood.orderProducts.product',
-        'replenishment',
-        'returnOrder',
-        'inventoryCheck',
-        'vasOrder',
-        'assignee',
-        'worksheetDetails',
-        'worksheetDetails.toLocation',
-        'worksheetDetails.targetProduct',
-        'worksheetDetails.targetProduct.product',
-        'worksheetDetails.targetProduct.releaseGood',
-        'worksheetDetails.targetVas',
-        'worksheetDetails.targetVas.product',
-        'worksheetDetails.targetVas.newProduct',
-        'worksheetDetails.targetVas.newProductDetail',
-        'worksheetDetails.targetVas.orderVasItems',
-        'worksheetDetails.targetVas.orderVasItems.vas',
-        'worksheetDetails.targetInventory',
-        'worksheetDetails.targetInventory.releaseGood',
-        'worksheetDetails.targetInventory.product',
-        'worksheetDetails.targetInventory.inventory',
-        'worksheetDetails.targetInventory.inventory.product',
-        'worksheetDetails.targetInventory.inventory.warehouse',
-        'worksheetDetails.targetInventory.inventory.location',
-        'worksheetDetails.targetInventory.inspectedLocation',
-        'creator',
-        'updater'
-      ]
+      relations: worksheetRelations
     })) as WorksheetInterface
 
     if (!worksheet) {
@@ -353,7 +392,7 @@ export const worksheetResolver = {
         relations: ['targetProduct']
       })
     }
-
+    console.timeEnd('query for worksheet')
     return worksheet
   },