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

package/server/graphql/resolvers/worksheet-detail/generate-batch-picking-worksheet-details-by-bulk.ts

@@ -1,6 +1,3 @@
-import { EntityManager, getRepository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
 import {
   ORDER_INVENTORY_STATUS,
   ORDER_PRODUCT_STATUS,
@@ -10,7 +7,7 @@ import {
   OrderProduct
 } 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 } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
@@ -21,9 +18,9 @@ export const generateBatchPickingWorksheetDetailsByBulkResolver = {
   async generateBatchPickingWorksheetDetailsByBulk(
     _: any,
     { worksheetId, bizplaceId, selectedItems },
-    context: any
+    context: ResolverContext
   ): Promise<Boolean> {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+    const { tx, user, domain } = context.state
 
     try {
       let worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
@@ -52,7 +49,7 @@ export const generateBatchPickingWorksheetDetailsByBulkResolver = {
       )
 
       const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
-        where: { domain, name: 'rule-for-inventory-assignment' }
+        where: { domain: { id: domain.id }, name: 'rule-for-inventory-assignment' }
       })
 
       await Promise.all(
@@ -128,12 +125,10 @@ export const generateBatchPickingWorksheetDetailsByBulkResolver = {
                   await qbInv.execute()
 
                   // update order product status to ASSIGNED
-                  await tx
-                    .getRepository(OrderProduct)
-                    .update(
-                      { id: orderInventory.orderProduct.id },
-                      { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user }
-                    )
+                  await tx.getRepository(OrderProduct).update({ id: orderInventory.orderProduct.id }, {
+                    status: ORDER_PRODUCT_STATUS.ASSIGNED as string,
+                    updater: user
+                  } as any)
 
                   // Create new order inventory with status -> READY_TO_PICK, type -> RELEASE_OF_GOODS
                   let newTargetInventory: OrderInventory = new OrderInventory()
@@ -179,12 +174,11 @@ export const generateBatchPickingWorksheetDetailsByBulkResolver = {
               }
 
               //Update Current Order Inventory status -> COMPLETE_SPLIT
-              await tx
-                .getRepository(OrderInventory)
-                .update(
-                  { id: orderInventory.id },
-                  { status: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT, updater: user, updatedAt: new Date() }
-                )
+              await tx.getRepository(OrderInventory).update({ id: orderInventory.id }, {
+                status: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT,
+                updater: user,
+                updatedAt: new Date()
+              } as any)
             }
             return { orderInventory: oi, status: 'success', message: null }
           } catch (error) {

package/server/graphql/resolvers/worksheet-detail/generate-batch-picking-worksheet-details.ts

@@ -1,6 +1,3 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
 import { Product } from '@things-factory/product-base'
 import {
   ORDER_INVENTORY_STATUS,
@@ -9,7 +6,6 @@ import {
   OrderNoGenerator,
   OrderProduct
 } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
@@ -20,9 +16,9 @@ export const generateBatchPickingWorksheetDetailsResolver = {
   async generateBatchPickingWorksheetDetails(
     _: any,
     { worksheetNo, batchId, productId, packingType, worksheetDetails },
-    context: any
+    context: ResolverContext
   ): Promise<void> {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+    const { tx, user, domain } = context.state
 
     // 1. Find Related Worksheet
     const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
@@ -43,7 +39,7 @@ export const generateBatchPickingWorksheetDetailsResolver = {
     // 2. Find all existing order inventory that is related to the product
     let prevOrdInvs: OrderInventory[] = await tx.getRepository(OrderInventory).find({
       where: {
-        domain,
+        domain: { id: domain.id },
         refWorksheetId: worksheet.id,
         product: productId,
         batchId,
@@ -118,24 +114,21 @@ export const generateBatchPickingWorksheetDetailsResolver = {
         requiredQty = fulfiledQty <= 0 ? 0 : fulfiledQty
         requiredUomValue = fulfiledUomValue <= 0 ? 0 : fulfiledUomValue
 
-        await tx.getRepository(Inventory).update(
-          { domain, id: inventory.id },
-          {
-            lockedQty: Boolean(currentLockedQty)
-              ? newTargetInventory.releaseQty + currentLockedQty
-              : newTargetInventory.releaseQty,
-            lockedUomValue: Boolean(currentLockedUomValue)
-              ? Math.round((newTargetInventory.releaseUomValue + currentLockedUomValue) * 100) / 100
-              : newTargetInventory.releaseUomValue,
-            updater: user,
-            updatedAt: new Date()
-          }
-        )
+        await tx.getRepository(Inventory).update({ domain, id: inventory.id }, {
+          lockedQty: Boolean(currentLockedQty)
+            ? newTargetInventory.releaseQty + currentLockedQty
+            : newTargetInventory.releaseQty,
+          lockedUomValue: Boolean(currentLockedUomValue)
+            ? Math.round((newTargetInventory.releaseUomValue + currentLockedUomValue) * 100) / 100
+            : newTargetInventory.releaseUomValue,
+          updater: user,
+          updatedAt: new Date()
+        } as any)
 
         // update order product status to ASSIGNED
         await tx
           .getRepository(OrderProduct)
-          .update({ id: prevOrdInv.orderProduct.id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user })
+          .update(prevOrdInv.orderProduct, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user } as any)
 
         // Generate Worksheet Detail
         let newWorksheetDetail: WorksheetDetail = new WorksheetDetail()
@@ -161,12 +154,11 @@ export const generateBatchPickingWorksheetDetailsResolver = {
           j = j + 1
         }
       }
-      await tx
-        .getRepository(OrderInventory)
-        .update(
-          { id: prevOrdInvs[i].id },
-          { status: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT, updater: user, updatedAt: new Date() }
-        )
+      await tx.getRepository(OrderInventory).update({ id: prevOrdInvs[i].id }, {
+        status: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT,
+        updater: user,
+        updatedAt: new Date()
+      } as any)
     }
   }
 }

package/server/graphql/resolvers/worksheet-detail/generate-carton-id.ts

@@ -1,10 +1,8 @@
 import { generateId } from '@things-factory/id-rule-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
 
 export const generateCartonIdResolver = {
-  async generateCartonId(_: any, { printQty, type }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async generateCartonId(_: any, { printQty, type }, context: ResolverContext) {
+    const { tx, domain } = context.state
     // 1. get and set the date
     const today = new Date()
     const year = today.getFullYear()

package/server/graphql/resolvers/worksheet-detail/generate-pallet-id.ts

@@ -1,13 +1,12 @@
-import { EntityManager, In } from 'typeorm'
+import { In } from 'typeorm'
 
 import { generateId } from '@things-factory/id-rule-base'
-import { Domain } from '@things-factory/shell'
 
 import { WorksheetDetail } from '../../../entities'
 
 export const generatePalletIdResolver = {
-  async generatePalletId(_: any, { targets, type }, context: any) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async generatePalletId(_: any, { targets, type }, context: ResolverContext) {
+    const { tx, domain } = context.state
     // 1. get date in yymmdd format
     const date = new Date().toJSON().slice(0, 10).replace(/-/g, '').slice(2, 8)
     let results = []
@@ -15,7 +14,7 @@ export const generatePalletIdResolver = {
     // 2. get worksheet details
     const foundWorksheetDetails: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
       where: {
-        domain,
+        domain: { id: domain.id },
         id: In(targets.map(target => target.id))
       },
       relations: [
@@ -51,7 +50,8 @@ export const generatePalletIdResolver = {
                   bizplace: foundWSD.bizplace,
                   orderProductRemark: foundWSD.targetProduct.remark,
                   purchaseOrderNo: foundWSD.targetProduct.arrivalNotice?.purchaseOrder?.name || '',
-                  arrivalNoticeRefNo: foundWSD.targetProduct.arrivalNotice?.refNo || ''
+                  arrivalNoticeRefNo: foundWSD.targetProduct.arrivalNotice?.refNo || '',
+                  arrivalNoticeNo: foundWSD.targetProduct.arrivalNotice?.name || ''
                 }
               } else if (foundWSD.targetInventory) {
                 result = {

package/server/graphql/resolvers/worksheet-detail/generate-picking-worksheet-details.ts

@@ -25,7 +25,7 @@ export const generatePickingWorksheetDetailsResolver = {
     { bizplaceId, selectedItems, worksheetNo, locationSortingRules },
     context: any
   ): Promise<Boolean> {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+    const { tx, user, domain } = context.state
 
     // 1. find related worksheet
     const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
@@ -38,7 +38,7 @@ export const generatePickingWorksheetDetailsResolver = {
 
     // 2. search for sorting rules
     const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
-      where: { domain, name: 'rule-for-inventory-assignment' }
+      where: { domain: { id: domain.id }, name: 'rule-for-inventory-assignment' }
     })
 
     if (!locationSortingRules && inventoryAssignmentSetting) {
@@ -114,14 +114,17 @@ export const generatePickingWorksheetDetailsResolver = {
             lockedQty: () => `COALESCE("locked_qty", 0) + ${targetInventory.releaseQty}`,
             lockedUomValue: () => `COALESCE("locked_uom_value", 0) + ${targetInventory.releaseUomValue}`,
             updater: user
-          })
+          } as any)
           .where('id = :id', { id: targetInventory.inventory.id })
           .execute()
 
         // update order product status to ASSIGNED
         await tx
           .getRepository(OrderProduct)
-          .update({ id: targetInventory.orderProduct.id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user })
+          .update({ id: targetInventory.orderProduct.id }, {
+            status: ORDER_PRODUCT_STATUS.ASSIGNED,
+            updater: user
+          } as any)
 
         // 7. collect new worksheet details records
         const worksheetDetail: WorksheetDetail = Object.assign(new WorksheetDetail(), {

package/server/graphql/resolvers/worksheet-detail/generate-release-good-worksheet-details.ts

@@ -22,7 +22,7 @@ export const generateReleaseGoodWorksheetDetailsResolver = {
     { worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails },
     context: any
   ): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     return await generateReleaseGoodWorksheetDetails(
       tx,
       domain,
@@ -94,7 +94,7 @@ export async function generateReleaseGoodWorksheetDetails(
         batchId,
         batchIdRef: inventory.batchIdRef,
         status: ORDER_INVENTORY_STATUS.READY_TO_PICK,
-        product: await tx.getRepository(Product).findOne(productId),
+        product: await tx.getRepository(Product).findOneBy({ id: productId }),
         packingType,
         packingSize,
         orderProduct: targetProduct,
@@ -119,7 +119,7 @@ export async function generateReleaseGoodWorksheetDetails(
       // update order product status to ASSIGNED
       await tx
         .getRepository(OrderProduct)
-        .update({ id: targetProduct?.id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user })
+        .update({ id: targetProduct?.id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user } as any)
 
       // 3. Create worksheet details
       await tx.getRepository(WorksheetDetail).save({

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

@@ -7,6 +7,7 @@ import { generateCartonIdResolver } from './generate-carton-id'
 import { generatePalletIdResolver } from './generate-pallet-id'
 import { generatePickingWorksheetDetailsResolver } from './generate-picking-worksheet-details'
 import { generateReleaseGoodWorksheetDetailsResolver } from './generate-release-good-worksheet-details'
+import { regenerateReleaseGoodWorksheetDetailsResolver } from './regenerate-release-good-worksheet-details'
 import { updateWorksheetDetail } from './update-worksheet-detail'
 import { worksheetDetailResolver } from './worksheet-detail'
 import { worksheetDetailsResolver } from './worksheet-details'
@@ -28,5 +29,6 @@ export const Mutation = {
   ...generateBatchPickingWorksheetDetailsResolver,
   ...generateBatchPickingWorksheetDetailsByBulkResolver,
   ...generatePickingWorksheetDetailsResolver,
-  ...generateReleaseGoodWorksheetDetailsResolver
+  ...generateReleaseGoodWorksheetDetailsResolver,
+  ...regenerateReleaseGoodWorksheetDetailsResolver
 }

package/server/graphql/resolvers/worksheet-detail/regenerate-release-good-worksheet-details.ts

@@ -0,0 +1,164 @@
+import { EntityManager, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Product } from '@things-factory/product-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderProduct
+} from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { WorksheetNoGenerator } from '../../../utils'
+
+export const regenerateReleaseGoodWorksheetDetailsResolver = {
+  async regenerateReleaseGoodWorksheetDetails(
+    _: any,
+    { worksheetNo, batchId, productId, packingType, packingSize, orderProductId, worksheetDetails },
+    context: any
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
+    return await regenerateReleaseGoodWorksheetDetails(
+      tx,
+      domain,
+      user,
+      worksheetNo,
+      batchId,
+      productId,
+      packingType,
+      packingSize,
+      orderProductId,
+      worksheetDetails
+    )
+  }
+}
+
+export async function regenerateReleaseGoodWorksheetDetails(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  batchId: string,
+  productId: string,
+  packingType: string,
+  packingSize: number,
+  orderProductId: string,
+  worksheetDetails: Partial<WorksheetDetail>[]
+): Promise<void> {
+  // 1. Remove prev worksheet details if it's exists
+  const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+    where: { name: worksheetNo, domain },
+    relations: [
+      'bizplace',
+      'releaseGood',
+      'worksheetDetails',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetInventory.inventory',
+      'worksheetDetails.targetInventory.product',
+      'worksheetDetails.targetInventory.releaseGood',
+      'worksheetDetails.targetInventory.orderProduct',
+      'worksheetDetails.targetInventory.bizplace'
+    ]
+  })
+
+  const prevWSDs: WorksheetDetail[] = worksheet.worksheetDetails.filter((wsd: WorksheetDetail) => {
+    const targetInv: OrderInventory = wsd.targetInventory
+    if (targetInv.orderProductId === orderProductId) return wsd.id
+  })
+
+  // TODO: Update prev inventory locked qty and delete order inventories
+  if (prevWSDs?.length) {
+    const wsdIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.id)
+    const prevOrderInvIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.targetInventory.id)
+    const prevOrderInventories: OrderInventory[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.targetInventory)
+    await Promise.all(
+      prevOrderInventories.map(async prevOI => {
+        if (prevOI?.inventory) {
+          await (tx.getRepository(Inventory) as Repository<Inventory>).update(
+            { id: prevOI.inventory.id },
+            {
+              lockedQty: prevOI.inventory.lockedQty - prevOI.releaseQty,
+              lockedUomValue: prevOI.inventory.lockedUomValue - prevOI.releaseUomValue
+            }
+          )
+        }
+      })
+    )
+
+    await tx.getRepository(WorksheetDetail).delete(wsdIds)
+    await tx.getRepository(OrderInventory).delete(prevOrderInvIds)
+  }
+
+  await Promise.all(
+    worksheetDetails.map(async (wsd: WorksheetDetail) => {
+      // 2. Create order inventory
+      let targetInventory: OrderInventory = wsd.targetInventory
+      const inventory: Inventory = await tx.getRepository(Inventory).findOne(targetInventory.inventory.id)
+
+      let targetProduct: OrderProduct = await tx
+        .getRepository(OrderProduct)
+        .findOne({ where: { id: wsd.targetProduct.id }, relations: ['releaseGood'] })
+
+      targetInventory = await tx.getRepository(OrderInventory).save({
+        ...targetInventory,
+        domain,
+        bizplace: worksheet.bizplace,
+        name: OrderNoGenerator.orderInventory(),
+        releaseGood: worksheet.type == WORKSHEET_TYPE.BATCH_PICKING ? targetProduct.releaseGood : worksheet.releaseGood,
+        inventory,
+        batchId: inventory.batchId,
+        batchIdRef: inventory.batchIdRef,
+        status: ORDER_INVENTORY_STATUS.READY_TO_PICK,
+        product: await tx.getRepository(Product).findOneBy({ id: productId }),
+        packingType,
+        packingSize,
+        orderProduct: targetProduct,
+        refWorksheetId: worksheet.type == WORKSHEET_TYPE.BATCH_PICKING ? worksheet.id : null,
+        creator: user,
+        updater: user
+      })
+
+      const currentLockedQty: any = inventory.lockedQty
+      const currentLockedUomValue: any = inventory.lockedUomValue
+
+      await tx.getRepository(Inventory).save({
+        ...targetInventory.inventory,
+        lockedQty: Boolean(currentLockedQty)
+          ? targetInventory.releaseQty + currentLockedQty
+          : targetInventory.releaseQty,
+        lockedUomValue: Boolean(currentLockedUomValue)
+          ? targetInventory.releaseUomValue + currentLockedUomValue
+          : targetInventory.releaseUomValue,
+        updater: user
+      })
+
+      // update order product status to ASSIGNED
+      await tx
+        .getRepository(OrderProduct)
+        .update({ id: targetProduct.id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user } as any)
+
+      // 3. Create worksheet details
+      await tx.getRepository(WorksheetDetail).save({
+        ...wsd,
+        domain,
+        bizplace: worksheet.bizplace,
+        worksheet,
+        name:
+          worksheet.type == WORKSHEET_TYPE.BATCH_PICKING
+            ? WorksheetNoGenerator.batchPickingDetail()
+            : WorksheetNoGenerator.pickingDetail(),
+        targetProduct,
+        targetInventory,
+        type: worksheet.type == WORKSHEET_TYPE.BATCH_PICKING ? WORKSHEET_TYPE.BATCH_PICKING : WORKSHEET_TYPE.PICKING,
+        status: WORKSHEET_STATUS.DEACTIVATED,
+        creator: user,
+        updater: user
+      })
+    })
+  )
+}

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

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

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

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

package/server/graphql/resolvers/worksheet-detail/worksheet-details-by-product-group.ts

@@ -1,7 +1,7 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
 import { SelectQueryBuilder } from 'typeorm'
+
+import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
+
 import { WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
@@ -11,9 +11,9 @@ export const worksheetDetailsByProductGroupResolver = {
     { worksheetNo, batchId, productName, productSku, packingType, packingSize },
     context: any
   ) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    const { tx, domain } = context.state
     const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-      where: { domain, name: worksheetNo },
+      where: { domain: { id: domain.id }, name: worksheetNo },
       relations: ['bizplace', 'releaseGood']
     })
     if (!worksheet) throw new Error(`Couldn't find worksheet`)

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

@@ -1,14 +1,13 @@
-import { convertListParams, ListParam } from '@things-factory/shell'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { In } from 'typeorm'
-import { User } from '@things-factory/auth-base'
+
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { convertListParams, ListParam } from '@things-factory/shell'
+
 import { WorksheetDetail } from '../../../entities'
 
 export const worksheetDetailsResolver = {
-  async worksheetDetails(_: any, params: ListParam, context: any) {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+  async worksheetDetails(_: any, params: ListParam, context: ResolverContext) {
+    const { tx, user, domain } = context.state
     const convertedParams = convertListParams(params)
     convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
 

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

@@ -1,10 +1,11 @@
 import { EntityManager } from 'typeorm'
-import { WorksheetMovement } from '../../../entities'
 import { v4 as uuidv4 } from 'uuid'
 
+import { WorksheetMovement } from '../../../entities'
+
 export const createWorksheetMovement = {
-  async createWorksheetMovement(_, { worksheetMovement: attrs }, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
+  async createWorksheetMovement(_, { worksheetMovement: attrs }, context: ResolverContext) {
+    const { tx } = context.state
     const repository = tx.getRepository(WorksheetMovement)
     const newWorksheetMovement = {
       id: uuidv4(),

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

@@ -1,9 +1,10 @@
 import { EntityManager } from 'typeorm'
+
 import { WorksheetMovement } from '../../../entities'
 
 export const deleteWorksheetMovement = {
-  async deleteWorksheetMovement(_, { id }, context: any) {
-    const tx: EntityManager  = context.state.tx
+  async deleteWorksheetMovement(_, { id }, context: ResolverContext) {
+    const tx: EntityManager = context.state.tx
     const repository = tx.getRepository(WorksheetMovement)
 
     return await repository.delete(id)

package/server/graphql/resolvers/worksheet-movement/update-worksheet-movement.ts

@@ -1,13 +1,11 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
 import { WorksheetMovement } from '../../../entities'
 
 export const updateWorksheetMovement = {
   async updateWorksheetMovement(_, { id, patch }, context) {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    const { tx, domain } = context.state
     const repository = tx.getRepository(WorksheetMovement)
 
-    const worksheetMovement = await repository.findOne({ domain, id })
+    const worksheetMovement = await repository.findOneBy({ domain: { id: domain.id }, id })
 
     return await repository.save({
       ...worksheetMovement,

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

@@ -1,13 +1,10 @@
-import { EntityManager } from 'typeorm'
 import { WorksheetMovement } from '../../../entities'
 
 export const worksheetMovementResolver = {
-  async worksheetMovement(_, { id }, context, info) {
-    const { tx }: { tx: EntityManager } = context.state
+  async worksheetMovement(_, { id }, context: ResolverContext, info) {
+    const { tx } = context.state
     const repository = tx.getRepository(WorksheetMovement)
 
-    return await repository.findOne(
-      { id }
-    )
+    return await repository.findOneBy({ id })
   }
 }

package/server/graphql/resolvers/worksheet-movement/worksheet-movements.ts

@@ -1,12 +1,12 @@
 import { buildQuery, ListParam } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { WorksheetMovement } from '../../../entities'
 
 export const worksheetMovementsResolver = {
-  async worksheetMovements(_: any, params: ListParam, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
+  async worksheetMovements(_: any, params: ListParam, context: ResolverContext) {
+    const { tx } = context.state
     const queryBuilder = tx.getRepository(WorksheetMovement).createQueryBuilder()
-    buildQuery(queryBuilder, params)
+    buildQuery(queryBuilder, params, context)
     const [items, total] = await queryBuilder.getManyAndCount()
 
     return { items, total }

package/server/graphql/types/worksheet/batch-pick-worksheet-info.ts

@@ -0,0 +1,9 @@
+import { gql } from 'apollo-server-koa'
+
+export const GenerateBatchPickInfo = gql`
+  input GenerateBatchPickInfo {
+    releaseGoodNo: String
+    bizplaceId: String
+    bizplaceName: String
+  }
+`

package/server/graphql/types/worksheet/delivery-order-info.ts

@@ -2,6 +2,7 @@ import gql from 'graphql-tag'
 
 export const DeliveryOrderInfo = gql`
   type DeliveryOrderInfo {
+    name: String
     ownCollection: Boolean
     doStatus: String
     truckNo: String
@@ -17,5 +18,7 @@ export const DeliveryOrderInfo = gql`
     reusablePallet: String
     createdDate: String
     isManualDo: Boolean
+    releaseGood: ReleaseGood
+    productList: [Product]
   }
 `