@things-factory/worksheet-base 5.0.0-alpha.5 → 5.0.0-alpha.52

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

@@ -4,9 +4,25 @@ import { EntityManager } from 'typeorm'
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const pickingResolver = {
-  async picking(_: any, { worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber }, context: any) {
+  async picking(
+    _: any,
+    { worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber, toteNo },
+    context: any
+  ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await picking(tx, domain, user, worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber)
+    await picking(
+      tx,
+      domain,
+      user,
+      worksheetDetailName,
+      worksheetType,
+      palletId,
+      locationName,
+      releaseQty,
+      binLocation,
+      serialNumber,
+      toteNo
+    )
   }
 }
 
@@ -20,8 +36,18 @@ export async function picking(
   locationName: string,
   releaseQty: number,
   binLocation?: string,
-  serialNumber?: string
+  serialNumber?: string,
+  toteNo?: string
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.picking(worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber)
+  await worksheetController.picking(
+    worksheetDetailName,
+    worksheetType,
+    palletId,
+    locationName,
+    releaseQty,
+    binLocation,
+    serialNumber,
+    toteNo
+  )
 }

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

@@ -6,7 +6,7 @@ import { PickingWorksheetController } from '../../../../controllers'
 export const scanProductPickingResolver = {
   async scanProductPicking(
     _: any,
-    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber },
+    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber, toteNo },
     context: any
   ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
@@ -19,7 +19,8 @@ export const scanProductPickingResolver = {
       productBarcode,
       cartonId,
       binLocation,
-      serialNumber
+      serialNumber,
+      toteNo
     )
   }
 }
@@ -33,7 +34,8 @@ export async function scanProductPicking(
   productBarcode: string,
   cartonId: string,
   binLocation?: string,
-  serialNumber?: string
+  serialNumber?: string,
+  toteNo?: string
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   await worksheetController.scanProductPicking(
@@ -42,6 +44,7 @@ export async function scanProductPicking(
     productBarcode,
     cartonId,
     binLocation,
-    serialNumber
+    serialNumber,
+    toteNo
   )
 }

package/server/graphql/resolvers/worksheet/picking/seal-tote.ts

@@ -0,0 +1,25 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PickingWorksheetController } from '../../../../controllers'
+
+export const sealToteResolver = {
+  async sealTote(_: any, { sealNo, toteNo, orderNo }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await sealTote(tx, domain, user, sealNo, toteNo, orderNo)
+  }
+}
+
+async function sealTote(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  sealNo: string,
+  toteNo: string,
+  orderNo: string
+): Promise<void> {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  await worksheetController.sealTote(sealNo, toteNo, orderNo)
+}

package/server/graphql/resolvers/worksheet/picking/undo-serial-number-picking.ts

@@ -0,0 +1,24 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PickingWorksheetController } from '../../../../controllers'
+
+export const undoSerialNumberPickingResolver = {
+  async undoSerialNumberPicking(_: any, { worksheetDetailName, inventoryItemId }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await undoSerialNumberPicking(tx, domain, user, worksheetDetailName, inventoryItemId)
+  }
+}
+
+async function undoSerialNumberPicking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  inventoryItemId: string
+): Promise<void> {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  await worksheetController.undoSerialNumberPicking(worksheetDetailName, inventoryItemId)
+}

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

@@ -2,7 +2,7 @@ import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
 
 import { ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood, ShippingOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, Location } from '@things-factory/warehouse-base'
+import { Inventory, Location, InventoryChange } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
@@ -109,6 +109,16 @@ export async function pickingWorksheet(
     worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
       const targetInventory: OrderInventory = pickingWSD.targetInventory
       const inventory: Inventory = targetInventory.inventory
+
+      const inventoryChangesCount: number = await tx.getRepository(InventoryChange).count({
+        where: {
+          inventory: inventory.id,
+          status:"PENDING",
+          transactionType:"MISSING"
+        },
+        relations:['inventory','product']
+      })
+
       return {
         name: pickingWSD.name,
         palletId: inventory?.palletId,
@@ -127,7 +137,8 @@ export async function pickingWorksheet(
         packingSize: inventory?.packingSize,
         expirationDate: inventory?.expirationDate,
         location: inventory?.location,
-        relatedOrderInv: targetInventory
+        relatedOrderInv: targetInventory,
+        hasMissingInventoryChanges:inventoryChangesCount > 0 ? true:false
       }
     })
   }

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

@@ -1,13 +1,56 @@
+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 { ArrivalNotice } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { PutawayWorksheetController } from '../../../../controllers'
+import { EcommerceController, SellercraftController } from '../../../../controllers/ecommerce'
 import { Worksheet } from '../../../../entities'
 
 export const completePutawayResolver = {
   async completePutaway(_: any, { arrivalNoticeNo }, context: any) {
     const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
     await completePutaway(tx, domain, user, arrivalNoticeNo)
+
+    const arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: { domain, name: arrivalNoticeNo },
+      relations: [
+        'purchaseOrder',
+        'bizplace',
+        'bizplace.domain',
+        'bizplace.company',
+        'bizplace.company.domain',
+        'orderProducts',
+        'orderProducts.product',
+        'orderProducts.product.productDetails',
+        'orderProducts.product.productDetails.childProductDetail'
+      ]
+    })
+
+    // search for any active marketplace connection
+    const companyDomain: Domain = arrivalNotice.bizplace.company.domain
+    const customerDomain: Domain = arrivalNotice.bizplace.domain
+    const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+      where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+      relations: ['marketplaceDistributors']
+    })
+
+    const sellercraft: Sellercraft = await tx
+      .getRepository(Sellercraft)
+      .findOne({ domain: customerDomain, status: SellercraftStatus.ACTIVE })
+
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.registerProductInbound(sellercraft, arrivalNotice)
+    }
+
+    if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+      const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+      await ecommerceCtrl.updateProductVariationStock(marketplaceStores, arrivalNotice.orderProducts, companyDomain)
+    }
   }
 }
 
@@ -28,4 +71,4 @@ export async function completePutaway(
       relations: ['bizplace', 'arrivalNotice']
     })
   }
-} 
+}

package/server/graphql/resolvers/worksheet/sorting/complete-order-sorting.ts

@@ -19,16 +19,20 @@ export async function completeOrderSorting(
   user: User,
   releaseGoodNo: string
 ): Promise<void> {
-  const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-  const releaseGood = await sortingWSCtrl.completeOrderSorting(releaseGoodNo)
+  try {
+    const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
+    const releaseGood = await sortingWSCtrl.completeOrderSorting(releaseGoodNo)
 
-  const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
-    releaseGood.name,
-    releaseGood.orderInventories.filter(itm => itm.status != ORDER_INVENTORY_STATUS.COMPLETE_SPLIT)
-  )
+    const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+    let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
+      releaseGood.name,
+      releaseGood.orderInventories.filter(itm => itm.status != ORDER_INVENTORY_STATUS.COMPLETE_SPLIT)
+    )
 
-  if (loadingWorksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
-    await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheet.worksheetDetails)
+    if (loadingWorksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
+      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheet.worksheetDetails)
+    }
+  } catch (e) {
+    throw e
   }
 }

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

@@ -4,9 +4,9 @@ import { EntityManager } from 'typeorm'
 import { SortingWorksheetController } from '../../../../controllers'
 
 export const scanProductSortingResolver = {
-  async scanProductSorting(_: any, { taskNo, releaseGoodNo, productBarcode }, context: any) {
+  async scanProductSorting(_: any, { taskNo, releaseGoodNo, productBarcode, serialNumber, toteNo }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await scanProductSorting(tx, domain, user, taskNo, releaseGoodNo, productBarcode)
+    await scanProductSorting(tx, domain, user, taskNo, releaseGoodNo, productBarcode, serialNumber, toteNo)
   }
 }
 
@@ -16,8 +16,10 @@ export async function scanProductSorting(
   user: User,
   taskNo: string,
   releaseGoodNo: string,
-  productBarcode?: string
+  productBarcode?: string,
+  serialNumber?: string,
+  toteNo?: string
 ) {
   const worksheetController: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-  await worksheetController.scanProductSorting(taskNo, releaseGoodNo, productBarcode)
+  await worksheetController.scanProductSorting(taskNo, releaseGoodNo, productBarcode, serialNumber, toteNo)
 }

package/server/graphql/resolvers/worksheet/sorting/sorting-product.ts

@@ -4,9 +4,9 @@ import { EntityManager } from 'typeorm'
 import { SortingWorksheetController } from '../../../../controllers'
 
 export const sortingProductResolver = {
-  async sortingProduct(_: any, { taskNo, releaseGoodNo, productId, sortingQty }, context: any) {
+  async sortingProduct(_: any, { taskNo, releaseGoodNo, productId, sortingQty, serialNumber, toteNo }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await sortingProduct(tx, domain, user, taskNo, releaseGoodNo, productId, sortingQty)
+    await sortingProduct(tx, domain, user, taskNo, releaseGoodNo, productId, sortingQty, serialNumber, toteNo)
   }
 }
 
@@ -17,8 +17,10 @@ export async function sortingProduct(
   taskNo: string,
   releaseGoodNo: string,
   productId: string,
-  sortingQty: number
+  sortingQty: number,
+  serialNumber?: string,
+  toteNo?: string
 ) {
   const worksheetController: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-  await worksheetController.sortingProduct(taskNo, releaseGoodNo, productId, sortingQty)
+  await worksheetController.sortingProduct(taskNo, releaseGoodNo, productId, sortingQty, serialNumber, toteNo)
 }

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

@@ -26,22 +26,26 @@ export const sortingWorksheetResolver = {
     const qb: SelectQueryBuilder<OrderInventory> = getRepository(OrderInventory).createQueryBuilder('OI')
     qb.select('SUM(OI.releaseQty)', 'releaseQty')
       .addSelect('SUM(OI.sortedQty)', 'sortedQty')
+      .addSelect(`string_agg(CONCAT(BIN.name, '(', OI.releaseQty, ')' ), ' ')`, 'binRemarks')
       .addSelect('PROD.id', 'productId')
       .addSelect('PROD.name', 'productName')
       .addSelect('PROD.sku', 'productSku')
       .addSelect('PROD.description', 'productDescription')
+      .addSelect('PROD.isRequireSerialNumberScanningOutbound', 'isRequireSerialNumberScanningOutbound')
       .addSelect('OI.batch_id', 'batchId')
       .addSelect('OI.packing_type', 'packingType')
       .addSelect('OI.packing_size', 'packingSize')
       .addSelect('INV.expiration_date', 'expirationDate')
       .leftJoin('OI.product', 'PROD')
       .leftJoin('OI.inventory', 'INV')
+      .leftJoin('OI.binLocation', 'BIN')
       .where('OI.release_good_id = :releaseGoodId', { releaseGoodId: releaseGood?.id })
       .andWhere('OI.status <> :releaseGoodStatus', { releaseGoodStatus: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT })
       .groupBy('PROD.id')
       .addGroupBy('PROD.name')
       .addGroupBy('PROD.sku')
       .addGroupBy('PROD.description')
+      .addGroupBy('PROD.isRequireSerialNumberScanningOutbound')
       .addGroupBy('INV.expiration_date')
       .addGroupBy('OI.batch_id')
       .addGroupBy('OI.packing_type')
@@ -67,12 +71,14 @@ export const sortingWorksheetResolver = {
           productSku: item?.productSku,
           productName: item?.productName,
           productDescription: item?.productDescription,
+          isRequireSerialNumberScanningOutbound: item?.isRequireSerialNumberScanningOutbound,
           releaseQty: item.releaseQty,
           sortedQty: item.sortedQty,
           status: item.status,
           expirationDate: item?.expirationDate,
           packingType: item?.packingType,
           packingSize: item?.packingSize,
+          binRemarks: item?.binRemarks,
           releaseGood
         }
       })

package/server/graphql/resolvers/worksheet/unloaded-inventories.ts

@@ -1,7 +1,9 @@
+import { getRepository, In } from 'typeorm'
+
 import { ArrivalNotice, Bizplace, ReturnOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-import { getRepository, In } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
 
@@ -46,9 +48,11 @@ export const unloadedInventories = {
       })
       const items = foundInv.map((inv: Inventory) => {
         const expirationDate: Date = inv.expirationDate ? new Date(inv.expirationDate) : null
+        const manufactureDate: Date = inv.manufactureDate ? new Date(inv.manufactureDate) : null
         return {
           ...inv,
-          expirationDate: expirationDate
+          expirationDate: expirationDate,
+          manufactureDate: manufactureDate
         }
       })
 

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

@@ -2,15 +2,12 @@ import { EntityManager, In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { MarketplaceStore } from '@things-factory/integration-marketplace'
-import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { ArrivalNotice, generateGoodsReceivalNote } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS } from '../../../../constants'
 import { PutawayWorksheetController, UnloadingWorksheetController } from '../../../../controllers'
-import { EcommerceController, SellercraftController } from '../../../../controllers/ecommerce'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const completeUnloadingResolver = {
@@ -40,28 +37,6 @@ export const completeUnloadingResolver = {
       where: { domain, refOrderId: arrivalNotice.id, status: In([INVENTORY_STATUS.UNLOADED, INVENTORY_STATUS.CHECKED]) }
     })
 
-    // search for any active marketplace connection
-    const companyDomain: Domain = arrivalNotice.bizplace.company.domain
-    const customerDomain: Domain = arrivalNotice.bizplace.domain
-    const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-      where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
-      relations: ['marketplaceDistributors']
-    })
-
-    const sellercraft: Sellercraft = await tx
-      .getRepository(Sellercraft)
-      .findOne({ domain: customerDomain, status: SellercraftStatus.ACTIVE })
-
-    if (sellercraft) {
-      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-      await sellercraftCtrl.registerProductInbound(sellercraft, arrivalNotice)
-    }
-
-    if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-      const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-      await ecommerceCtrl.updateProductVariationStock(marketplaceStores, arrivalNotice.orderProducts, companyDomain)
-    }
-
     putawayWorksheet = await putawayWSCtrl.generatePutawayWorksheet(arrivalNotice.name, inventories)
 
     if (putawayWorksheet.status === WORKSHEET_STATUS.DEACTIVATED) {

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

@@ -3,14 +3,18 @@ import { completeProductScanUnloadResolver } from './complete-product-scan-unloa
 import { completeUnloadingResolver } from './complete-unloading'
 import { completeUnloadingPartiallyResolver } from './complete-unloading-partially'
 import { scanProductUnloadResolver } from './scan-product-unload'
+import { scanSerialNumberUnloadResolver } from './scan-serial-number-unload'
+import { undoSerialNumberUnloadResolver } from './undo-serial-number-unload'
 import { undoUnloadingResolver } from './undo-unloading'
 import { unloadResolver } from './unload'
 
 export const Mutations = {
   ...activateUnloadingResolver,
   ...scanProductUnloadResolver,
+  ...scanSerialNumberUnloadResolver,
   ...unloadResolver,
   ...undoUnloadingResolver,
+  ...undoSerialNumberUnloadResolver,
   ...completeProductScanUnloadResolver,
   ...completeUnloadingResolver,
   ...completeUnloadingPartiallyResolver

package/server/graphql/resolvers/worksheet/unloading/scan-serial-number-unload.ts

@@ -0,0 +1,26 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { UnloadingWorksheetController } from '../../../../controllers'
+
+export const scanSerialNumberUnloadResolver = {
+  async scanSerialNumberUnload(_: any, { worksheetDetailName, serialNumber, inventory }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await scanSerialNumberUnload(tx, domain, user, worksheetDetailName, serialNumber, inventory)
+  }
+}
+
+async function scanSerialNumberUnload(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  serialNumber: string,
+  inventory: Partial<Inventory>
+): Promise<void> {
+  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
+  await worksheetController.scanSerialNumberUnload(worksheetDetailName, serialNumber, inventory)
+}

package/server/graphql/resolvers/worksheet/unloading/undo-serial-number-unload.ts

@@ -0,0 +1,24 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { UnloadingWorksheetController } from '../../../../controllers'
+
+export const undoSerialNumberUnloadResolver = {
+  async undoSerialNumberUnload(_: any, { worksheetDetailName, inventoryItemId }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await undoSerialNumberUnload(tx, domain, user, worksheetDetailName, inventoryItemId)
+  }
+}
+
+async function undoSerialNumberUnload(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  inventoryItemId: string
+): Promise<void> {
+  const worksheetController: UnloadingWorksheetController = new UnloadingWorksheetController(tx, domain, user)
+  await worksheetController.undoSerialNumberUnload(worksheetDetailName, inventoryItemId)
+}

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

@@ -1,7 +1,9 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
+
 import { UnloadingWorksheetController } from '../../../../controllers'
 
 export const unloadResolver = {

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

@@ -59,6 +59,7 @@ export const unloadingWorksheetResolver = {
 
     return {
       worksheetInfo: {
+        arrivalNotice,
         bizplaceName: customerBizplace.name,
         partnerDomainId: customerBizplace?.domain.id,
         customerCompanyDomainId: customerCompanyDomain.id,
@@ -90,7 +91,8 @@ export const unloadingWorksheetResolver = {
           actualPackQty: targetProduct.actualPackQty,
           remark: targetProduct.remark,
           issue: productWSD.issue,
-          status: productWSD.status
+          status: productWSD.status,
+          manufactureDate: targetProduct.manufactureDate ? new Date(targetProduct.manufactureDate) : null
         }
       })
     }

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

@@ -117,6 +117,7 @@ export const worksheetResolver = {
         .leftJoinAndSelect('oi.releaseGood', 'releaseGood')
         .leftJoinAndSelect('oi.inventory', 'inventory')
         .leftJoinAndSelect('oi.product', 'product')
+        .leftJoinAndSelect('oi.orderProduct', 'orderProduct')
         .leftJoinAndSelect('inventory.location', 'location')
         .leftJoinAndSelect('oi.bizplace', 'bizplace')
         .where('"oi"."domain_id" = :domain')
@@ -146,6 +147,7 @@ export const worksheetResolver = {
         .leftJoinAndSelect('oi.releaseGood', 'releaseGood')
         .leftJoinAndSelect('oi.inventory', 'inventory')
         .leftJoinAndSelect('oi.product', 'product')
+        .leftJoinAndSelect('oi.orderProduct', 'orderProduct')
         .leftJoinAndSelect('inventory.location', 'location')
         .leftJoinAndSelect('oi.bizplace', 'bizplace')
         .where('"oi"."domain_id" = :domain')