@things-factory/worksheet-base 5.0.13 → 6.0.0-alpha.1

package/server/graphql/resolvers/worksheet/vas-transactions/unpacking/unpacking.ts

@@ -1,18 +1,15 @@
-import { EntityManager, In } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
 import { Product } from '@things-factory/product-base'
-import { OrderProduct, ReleaseGood, OrderVas, OrderNoGenerator, ORDER_PRODUCT_STATUS } from '@things-factory/sales-base'
+import { ORDER_PRODUCT_STATUS, OrderNoGenerator, OrderProduct, OrderVas, ReleaseGood } from '@things-factory/sales-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../../constants'
+import { VasWorksheetController } from '../../../../../controllers/vas/vas-worksheet-controller'
 import { Worksheet, WorksheetDetail } from '../../../../../entities'
-import { getWorksheetDetailByName } from '../common-utils'
 import { WorksheetNoGenerator } from '../../../../../utils'
 import { executeVas } from '../../vas/execute-vas'
+import { getWorksheetDetailByName } from '../common-utils'
 import { RefOrderType } from '../interfaces'
-import { WORKSHEET_TYPE, WORKSHEET_STATUS } from '../../../../../constants'
-import { VasWorksheetController } from '../../../../../controllers/vas/vas-worksheet-controller'
-import { Inventory } from '@things-factory/warehouse-base'
 
 export const unpackingResolver = {
   async unpacking(
@@ -20,7 +17,7 @@ export const unpackingResolver = {
     { worksheetDetailName, childProductId, unpackQty, unpackUomValue, palletId, locationName },
     context: any
   ) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const childProduct: Product = await tx.getRepository(Product).findOne({
       where: { id: childProductId },
@@ -83,8 +80,8 @@ export const unpackingResolver = {
     } else {
       let foundOP: OrderProduct = await tx.getRepository(OrderProduct).findOne({
         where: {
-          domain,
-          arrivalNotice,
+          domain: { id: domain.id },
+          arrivalNotice: { id: arrivalNotice.id },
           batchId: targetVas.targetBatchId,
           product: targetVas.targetProduct
         }
@@ -127,8 +124,8 @@ export const unpackingResolver = {
 
       let worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
         where: {
-          domain,
-          arrivalNotice,
+          domain: { id: domain.id },
+          arrivalNotice: { id: arrivalNotice.id },
           type: WORKSHEET_TYPE.UNLOADING
         }
       })

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

@@ -1,36 +1,38 @@
+import { Equal, Not } from 'typeorm'
+
 import {
   ArrivalNotice,
-  OrderInventory,
-  OrderVas,
   ORDER_STATUS,
   ORDER_TYPES,
+  OrderInventory,
+  OrderVas,
   ReleaseGood,
   VasOrder
 } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { Equal, getRepository, Not } from 'typeorm'
-import { fetchExecutingWorksheet } from '../../../utils'
+import { getRepository } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
 
 export const vasWorksheetResolver = {
-  async vasWorksheet(_: any, { orderNo, orderType }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async vasWorksheet(_: any, { orderNo, orderType }, context: ResolverContext) {
+    const { domain } = context.state
     let refOrder: ArrivalNotice | ReleaseGood | VasOrder
     if (orderType === ORDER_TYPES.ARRIVAL_NOTICE) {
       refOrder = await getRepository(ArrivalNotice).findOne({
-        where: { domain, name: orderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
+        where: { domain: { id: domain.id }, name: orderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
         relations: ['bizplace']
       })
     } else if (orderType === ORDER_TYPES.RELEASE_OF_GOODS) {
       refOrder = await getRepository(ReleaseGood).findOne({
-        where: { domain, name: orderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
+        where: { domain: { id: domain.id }, name: orderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
         relations: ['bizplace']
       })
     } else if (orderType === ORDER_TYPES.VAS_ORDER) {
       refOrder = await getRepository(VasOrder).findOne({
-        where: { domain, name: orderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
+        where: { domain: { id: domain.id }, name: orderNo, status: Not(Equal(ORDER_STATUS.DONE)) },
         relations: ['bizplace']
       })
     }
@@ -58,7 +60,7 @@ export const vasWorksheetResolver = {
       for (let wsd of worksheet.worksheetDetails) {
         const inventory: Inventory = wsd.targetVas.inventory
         const orderInv: OrderInventory = await getRepository(OrderInventory).findOne({
-          where: { domain, releaseGood: refOrder, inventory }
+          where: { domain: { id: domain.id }, releaseGood: refOrder, inventory }
         })
 
         wsd.targetInventory = orderInv

package/server/graphql/resolvers/worksheet/worksheet-by-order-no.ts

@@ -1,8 +1,10 @@
+import { EntityManager, FindOneOptions, Repository } from 'typeorm'
+
 import { ArrivalNotice, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager, FindOneOptions, Repository } from 'typeorm'
-import { Worksheet } from '../../../entities'
+
 import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet } from '../../../entities'
 
 export const worksheetByOrderNoResolver = {
   async worksheetByOrderNo(
@@ -10,7 +12,7 @@ export const worksheetByOrderNoResolver = {
     { orderType, orderNo }: { orderType: string; orderNo: string },
     context: any
   ): Promise<Worksheet> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    const { tx, domain } = context.state
     return await worksheetByOrderNo(domain, orderNo, orderType, tx)
   }
 }
@@ -21,16 +23,19 @@ export async function worksheetByOrderNo(
   type: string,
   tx: EntityManager
 ): Promise<Worksheet> {
-  let findOption: FindOneOptions<Worksheet> = { where: { domain, type }, relations: ['worksheetDetails'] }
+  let findOption: FindOneOptions<Worksheet> = {
+    where: { domain: { id: domain.id }, type },
+    relations: ['worksheetDetails']
+  }
 
   if (type === WORKSHEET_TYPE.UNLOADING || type === WORKSHEET_TYPE.PUTAWAY) {
     const ganRepo: Repository<ArrivalNotice> = tx.getRepository(ArrivalNotice)
-    findOption.where['arrivalNotice'] = await ganRepo.findOne({ domain, name: orderNo })
-    findOption.relations.push('worksheetDetails.targetProduct')
+    findOption.where['arrivalNotice'] = await ganRepo.findOneBy({ domain: { id: domain.id }, name: orderNo })
+    ;(findOption.relations as string[]).push('worksheetDetails.targetProduct')
   } else if (type === WORKSHEET_TYPE.PICKING || type === WORKSHEET_TYPE.LOADING) {
     const roRepo: Repository<ReleaseGood> = tx.getRepository(ReleaseGood)
-    findOption.where['releaseGood'] = await roRepo.findOne({ domain, name: orderNo })
-    findOption.relations.push('worksheetDetails.targetInventory')
+    findOption.where['releaseGood'] = await roRepo.findOneBy({ domain: { id: domain.id }, name: orderNo })
+    ;(findOption.relations as string[]).push('worksheetDetails.targetInventory')
   }
 
   const wsRepo: Repository<Worksheet> = tx.getRepository(Worksheet)

package/server/graphql/resolvers/worksheet/worksheet-with-pagination.ts

@@ -1,5 +1,7 @@
-import { Domain } from '@things-factory/shell'
-import { FindManyOptions, getRepository } from 'typeorm'
+import { FindManyOptions } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
 export const worksheetWithPaginationResolver = {
@@ -8,14 +10,14 @@ export const worksheetWithPaginationResolver = {
     { name, pagination }: { name: string; pagination?: { page: number; limit: number } },
     context: any
   ): Promise<{ worksheet: Worksheet; worksheetDetails: WorksheetDetail[]; total: number }> {
-    const { domain }: { domain: Domain } = context.state
+    const { domain } = context.state
     const worksheet: Worksheet = await getRepository(Worksheet).findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['bizplace', 'arrivalNotice', 'releaseGood', 'inventoryCheck']
     })
 
     let findManyOptions: FindManyOptions<WorksheetDetail> = {
-      where: { domain, worksheet },
+      where: { domain: { id: domain.id }, worksheet: { id: worksheet.id } },
       relations: [
         'targetInventory',
         'targetInventory.originLocation',

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

@@ -1,12 +1,13 @@
-import { Equal, getRepository, Not } from 'typeorm'
+import { Equal, Not } from 'typeorm'
 
 import { MarketplaceOrder, MarketplaceOrderShipping } from '@things-factory/marketplace-base'
 import { ORDER_INVENTORY_STATUS, OrderInventory, OrderProduct, OrderVas } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
+import { getRepository } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS, InventoryHistory } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_TYPE } from '../../../constants'
-import { Worksheet } from '../../../entities'
+import { Worksheet, WorksheetDetail } from '../../../entities'
 
 interface WorksheetInterface extends Worksheet {
   orderProducts: OrderProduct[]
@@ -16,12 +17,12 @@ interface WorksheetInterface extends Worksheet {
 }
 
 export const worksheetResolver = {
-  async worksheet(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async worksheet(_: any, { name }, context: ResolverContext) {
+    const { domain } = context.state
     let worksheet: WorksheetInterface
     worksheet = (await getRepository(Worksheet).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name
       },
       relations: [
@@ -37,6 +38,7 @@ export const worksheetResolver = {
         'releaseGood.shippingOrder',
         'releaseGood.deliverTo',
         'releaseGood.deliverTo.bizplace',
+        'releaseGood.manifest',
         'returnOrder',
         'inventoryCheck',
         'vasOrder',
@@ -66,8 +68,8 @@ export const worksheetResolver = {
     if (!worksheet) {
       worksheet = (await getRepository(Worksheet).findOne({
         where: {
-          domain,
-          arrivalNotice: name
+          domain: { id: domain.id },
+          arrivalNotice: { id: name } /* CONFIRMME regarding TYPEORM - name means id ? */
         },
         relations: [
           'domain',
@@ -91,26 +93,65 @@ export const worksheetResolver = {
     }
 
     let pWorksheetPickingItemSorting = getRepository(Setting).findOne({
-      where: { domain, category: 'location', name: 'rule-for-worksheet-release-goods-item' }
+      where: { domain: { id: domain.id }, category: 'location', name: 'rule-for-picking-product' }
     })
 
     if (worksheet?.arrivalNotice?.id) {
       worksheet.orderProducts = await getRepository(OrderProduct).find({
         where: {
-          domain,
-          bizplace: worksheet.bizplace,
-          arrivalNotice: worksheet.arrivalNotice
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          arrivalNotice: { id: worksheet.arrivalNotice.id }
         }
       })
 
       worksheet.orderVass = await getRepository(OrderVas).find({
         where: {
-          domain,
-          bizplace: worksheet.bizplace,
-          arrivalNotice: worksheet.arrivalNotice
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          arrivalNotice: { id: worksheet.arrivalNotice.id }
         },
         relations: ['targetProduct']
       })
+
+      // update inventory data >> unloaded inventory history data
+      if (
+        worksheet.type === WORKSHEET_TYPE.PUTAWAY &&
+        worksheet.worksheetDetails.every(wsd => wsd.targetInventory.inventory)
+      ) {
+        worksheet.worksheetDetails = await Promise.all(
+          worksheet.worksheetDetails.map(async (wsd: WorksheetDetail) => {
+            let inventory: Inventory = wsd.targetInventory.inventory
+
+            let foundHistory: InventoryHistory = await getRepository(InventoryHistory).findOne({
+              where: [
+                { inventory, refOrderId: worksheet.arrivalNotice.id, status: INVENTORY_STATUS.UNLOADED },
+                { inventory, refOrderId: worksheet.arrivalNotice.id, status: INVENTORY_STATUS.PARTIALLY_UNLOADED },
+                { inventory, refOrderId: worksheet.arrivalNotice.id, status: INVENTORY_STATUS.CHECKED },
+                { inventory, refOrderId: worksheet.arrivalNotice.id, status: INVENTORY_STATUS.STORED }
+              ],
+              relations: ['location', 'product'],
+              order: { seq: 'DESC' }
+            })
+
+            wsd.targetInventory.inventory = {
+              ...inventory,
+              qty: foundHistory?.qty || foundHistory?.openingQty || 0,
+              uomValue: foundHistory?.uomValue || foundHistory?.openingUomValue || 0,
+              location: foundHistory?.location,
+              product: foundHistory?.product,
+              cartonId: foundHistory?.cartonId,
+              batchId: foundHistory?.batchId,
+              batchIdRef: foundHistory?.batchIdRef,
+              packingType: foundHistory?.packingType,
+              packingSize: foundHistory?.packingSize,
+              uom: foundHistory?.uom
+            }
+
+            return wsd
+          })
+        )
+      }
     }
 
     if (worksheet.type === WORKSHEET_TYPE.BATCH_PICKING) {
@@ -135,10 +176,12 @@ export const worksheetResolver = {
       if (sortingSetting?.value) {
         let settingValue = JSON.parse(sortingSetting.value)
         for (const key in settingValue) {
-          qbOrderInventories.addOrderBy(`location.${key}`, settingValue[key] ? 'ASC' : 'DESC')
+          qbOrderInventories.addOrderBy(`location.${key}`, settingValue[key] == 'ASC' ? 'ASC' : 'DESC')
         }
       }
 
+      qbOrderInventories.addOrderBy(`product.name`, 'ASC')
+
       let orderInventories: OrderInventory[] = await qbOrderInventories.getMany()
       worksheet.orderInventories = orderInventories
     }
@@ -167,10 +210,12 @@ export const worksheetResolver = {
       if (sortingSetting?.value) {
         let settingValue = JSON.parse(sortingSetting.value)
         for (const key in settingValue) {
-          qbOrderInventories.addOrderBy(`location.${key}`, settingValue[key] ? 'ASC' : 'DESC')
+          qbOrderInventories.addOrderBy(`location.${key}`, settingValue[key] == 'ASC' ? 'ASC' : 'DESC')
         }
       }
 
+      qbOrderInventories.addOrderBy(`product.name`, 'ASC')
+
       let orderInventories: OrderInventory[] = await qbOrderInventories.getMany()
       worksheet.orderInventories = orderInventories
 
@@ -203,20 +248,29 @@ export const worksheetResolver = {
 
       worksheet.orderVass = await getRepository(OrderVas).find({
         where: {
-          domain,
-          bizplace: worksheet.bizplace,
-          releaseGood: worksheet.releaseGood
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          releaseGood: { id: worksheet.releaseGood.id }
         },
         relations: ['targetProduct']
       })
     }
 
+    if (worksheet.orderInventories) {
+      worksheet.worksheetDetails.sort(function (a, b) {
+        return (
+          worksheet.orderInventories.map(oi => oi.id).indexOf(a.targetInventory.id) -
+          worksheet.orderInventories.map(oi => oi.id).indexOf(b.targetInventory.id)
+        )
+      })
+    }
+
     if (worksheet?.returnOrder?.id) {
       worksheet.orderInventories = await getRepository(OrderInventory).find({
         where: {
-          domain,
-          bizplace: worksheet.bizplace,
-          returnOrder: worksheet.returnOrder,
+          dodomain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          returnOrder: { id: worksheet.returnOrder.id },
           status: Not(Equal(ORDER_INVENTORY_STATUS.CANCELLED))
         },
         relations: ['product', 'inventory', 'inventory.location']
@@ -224,9 +278,9 @@ export const worksheetResolver = {
 
       worksheet.orderVass = await getRepository(OrderVas).find({
         where: {
-          domain,
-          bizplace: worksheet.bizplace,
-          returnOrder: worksheet.returnOrder
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          returnOrder: { id: worksheet.returnOrder.id }
         },
         relations: ['targetProduct']
       })
@@ -235,9 +289,9 @@ export const worksheetResolver = {
     if (worksheet?.inventoryCheck?.id) {
       worksheet.orderInventories = await getRepository(OrderInventory).find({
         where: {
-          domain,
-          bizplace: worksheet.bizplace,
-          inventoryCheck: worksheet.inventoryCheck
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          inventoryCheck: { id: worksheet.inventoryCheck.id }
         },
         relations: ['product', 'inventory', 'inventory.location']
       })
@@ -246,9 +300,9 @@ export const worksheetResolver = {
     if (worksheet?.vasOrder?.id) {
       worksheet.orderVass = await getRepository(OrderVas).find({
         where: {
-          domain,
-          bizplace: worksheet.bizplace,
-          vasOrder: worksheet.vasOrder
+          domain: { id: domain.id },
+          bizplace: { id: worksheet.bizplace.id },
+          vasOrder: { id: worksheet.vasOrder.id }
         },
         relations: ['targetProduct']
       })

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

@@ -1,9 +1,9 @@
-import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
+import { Brackets, OrderByCondition, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { ArrivalNotice, InventoryCheck, ReleaseGood, ReturnOrder } from '@things-factory/sales-base'
-import { buildQuery, convertListParams, Domain, ListParam } from '@things-factory/shell'
+import { buildQuery, convertListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet } from '../../../entities'
@@ -12,7 +12,7 @@ export const worksheetsResolver = {
   async worksheets(_: any, params: ListParam, context: any) {
     try {
       ////For inbound worksheet filter
-      const { domain, user }: { domain: Domain; user: User } = context.state
+      const { domain, user } = context.state
       const arrivalNoticeParam: any = params.filters.find((param: any) => param.name === 'arrivalNoticeNo')
       const arrivalNoticeRefNoParam = params.filters.find(param => param.name === 'arrivalNoticeRefNo')
       const arrivalNoticeCrossDockingParam = params.filters.find(param => param.name === 'crossDocking')
@@ -103,12 +103,20 @@ export const worksheetsResolver = {
       }
 
       ////For outbound worksheet filter
+      let outboundOrderInfoFilter
+      const outboundOrderInfoParamIdx = params.filters.findIndex(param => param.name === 'outboundOrderInfo')
+      if (outboundOrderInfoParamIdx >= 0) {
+        outboundOrderInfoFilter = params.filters[outboundOrderInfoParamIdx].value.toLowerCase().split(',').join('|')
+
+        params.filters.splice(outboundOrderInfoParamIdx, 1)
+      }
       const releaseGoodParam = params.filters.find(param => param.name === 'releaseGoodNo')
       const releaseGoodRefNoParam = params.filters.find(param => param.name === 'releaseGoodRefNo')
       const releaseGoodCrossDockingParam = params.filters.find(param => param.name === 'crossDocking')
       const releaseGoodCourierOptionParam = params.filters.find(param => param.name === 'courierOption')
       const releaseGoodPackingOptionParam = params.filters.find(param => param.name === 'packingOption')
       const orderRemarkParam = params.filters.find(param => param.name === 'orderRemark')
+      const manifestParam = params.filters.find(param => param.name === 'manifest')
 
       const releaseGoodPickerOptionParam = params.filters.find(param => param.name === 'assignee')
       if (
@@ -116,8 +124,7 @@ export const worksheetsResolver = {
         releaseGoodRefNoParam ||
         releaseGoodCrossDockingParam ||
         releaseGoodCourierOptionParam ||
-        releaseGoodPackingOptionParam ||
-        orderRemarkParam
+        releaseGoodPackingOptionParam
       ) {
         let arrFilters = []
         if (releaseGoodParam) {
@@ -160,19 +167,6 @@ export const worksheetsResolver = {
           arrFilters.push({ ...releaseGoodPackingOptionParam, name: 'packingOption' })
         }
 
-        if (orderRemarkParam) {
-          params.filters.splice(
-            params.filters.findIndex(item => item.name == 'orderRemark'),
-            1
-          )
-
-          if (orderRemarkParam?.value == true) {
-            arrFilters.push({ operator: 'is_not_null', name: 'remark' })
-          } else if (orderRemarkParam?.value == false) {
-            arrFilters.push({ operator: 'is_null', name: 'remark' })
-          }
-        }
-
         const foundReleaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
           ...convertListParams({ filters: arrFilters }, { searchables: ['arrivalNoticeNo', 'releaseGoodNo'] })
         })
@@ -304,6 +298,20 @@ export const worksheetsResolver = {
         }
       }
 
+      //check packing worksheet checkbox filter
+      if (manifestParam) {
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'manifest'),
+          1
+        )
+      }
+
+      if (orderRemarkParam) {
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'orderRemark'),
+          1
+        )
+      }
       ////Set default bizplace filter
       const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
       if (!bizplaceFilter && typeParam?.value[0] !== WORKSHEET_TYPE.BATCH_PICKING) {
@@ -340,6 +348,39 @@ export const worksheetsResolver = {
         )
       }
 
+      if (outboundOrderInfoFilter) {
+        qb.andWhere(
+          '(releaseGood.name ~* :outboundOrderInfoFilter or releaseGood.ref_no ~* :outboundOrderInfoFilter or releaseGood.ref_no_2 ~* :outboundOrderInfoFilter or releaseGood.ref_no_3 ~* :outboundOrderInfoFilter)',
+          { outboundOrderInfoFilter }
+        )
+      }
+
+      if (manifestParam) {
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'manifest'),
+          1
+        )
+
+        if (manifestParam?.value == true) {
+          qb.andWhere('releaseGood.manifest_id is not null')
+        } else if (manifestParam?.value == false) {
+          qb.andWhere('releaseGood.manifest_id is null')
+        }
+      }
+
+      if (orderRemarkParam) {
+        params.filters.splice(
+          params.filters.findIndex(item => item.name == 'orderRemark'),
+          1
+        )
+
+        if (orderRemarkParam?.value == true) {
+          qb.andWhere('releaseGood.remark is not null')
+        } else if (orderRemarkParam?.value == false) {
+          qb.andWhere('releaseGood.remark is null')
+        }
+      }
+
       qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
       qb.leftJoinAndSelect('ws.domain', 'domain')
       qb.leftJoinAndSelect('ws.bizplace', 'bizplace')
@@ -371,7 +412,7 @@ export const worksheetsResolver = {
 
       ////Add sorting conditions
       const arrChildSortData = ['bizplace', 'arrivalNotice', 'releaseGood', 'returnOrder', 'inventoryCheck']
-      let sort = (params.sortings || []).reduce(
+      let sort: OrderByCondition = (params.sortings || []).reduce(
         (acc, sort) => {
           if (
             sort.name != 'arrivalRefNo' &&

package/server/graphql/resolvers/worksheet-detail/check-progressing-pallet.ts

@@ -1,12 +1,11 @@
-import { WorksheetDetail } from '../../../entities'
-import { WORKSHEET_STATUS } from '../../../constants'
-import { EntityManager } from 'typeorm'
 import { SelectQueryBuilder } from 'typeorm'
-import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS } from '../../../constants'
+import { WorksheetDetail } from '../../../entities'
 
 export const checkProgressingPalletResolver = {
-  async checkProgressingPallet(_: any, { palletId }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async checkProgressingPallet(_: any, { palletId }, context: ResolverContext) {
+    const { tx, domain } = context.state
     const qb: SelectQueryBuilder<WorksheetDetail> = tx.getRepository(WorksheetDetail).createQueryBuilder('WSD')
     const cnt: number = await qb
       .leftJoin('WSD.targetInventory', 'T_INV')
@@ -14,10 +13,10 @@ export const checkProgressingPalletResolver = {
       .where('"INV"."domain_id" = :domainId', { domainId: domain.id })
       .andWhere('"INV"."pallet_id" = :palletId', { palletId })
       .andWhere('"WSD"."status" IN (:...status)', {
-        status: [WORKSHEET_STATUS.EXECUTING, WORKSHEET_STATUS.DEACTIVATED],
+        status: [WORKSHEET_STATUS.EXECUTING, WORKSHEET_STATUS.DEACTIVATED]
       })
       .getCount()
 
     return Boolean(cnt)
-  },
+  }
 }

package/server/graphql/resolvers/worksheet-detail/create-worksheet-detail.ts

@@ -1,16 +1,14 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
 import { getPermittedBizplaceIds, Worker } from '@things-factory/biz-base'
 import { OrderProduct, OrderVas } from '@things-factory/sales-base'
+
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
 export const createWorksheetDetail = {
-  async createWorksheetDetail(_: any, { worksheetDetail }, context: any) {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+  async createWorksheetDetail(_: any, { worksheetDetail }, context: ResolverContext) {
+    const { tx, user, domain } = context.state
     worksheetDetail.worksheet = await tx.getRepository(Worksheet).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         bizplace: await getPermittedBizplaceIds(domain, user),
         id: worksheetDetail.worksheet.id
       }

package/server/graphql/resolvers/worksheet-detail/delete-worksheet-detail.ts

@@ -1,13 +1,12 @@
-import { EntityManager } from 'typeorm'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { In } from 'typeorm'
+
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+
 import { WorksheetDetail } from '../../../entities'
 
 export const deleteWorksheetDetail = {
-  async deleteWorksheetDetail(_: any, { id }, context: any) {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+  async deleteWorksheetDetail(_: any, { id }, context: ResolverContext) {
+    const { tx, user, domain } = context.state
     await tx.getRepository(WorksheetDetail).delete({
       domain: domain,
       bizplace: In(await getPermittedBizplaceIds(domain, user)),