@things-factory/worksheet-base 5.0.0-alpha.3 → 5.0.0-alpha.30

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

@@ -11,6 +11,7 @@ import {
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
+import { ProductDetail } from '@things-factory/product-base'
 
 import { WORKSHEET_TYPE } from '../../../constants'
 import { SellercraftController } from '../../../controllers'
@@ -19,165 +20,186 @@ import { fetchExecutingWorksheet } from '../../../utils'
 
 export const packingWorksheetResolver = {
   async packingWorksheet(_: any, { releaseGoodNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: {
-        domain,
-        name: releaseGoodNo
-      },
-      relations: ['bizplace', 'bizplace.domain']
-    })
-
-    // Find Release Order based on Bin
-    if (!releaseGood) {
-      const binLocation: Location = await tx.getRepository(Location).findOne({
-        where: { domain, name: releaseGoodNo }
+    try {
+      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: {
+          domain,
+          name: releaseGoodNo
+        },
+        relations: ['bizplace', 'bizplace.domain']
       })
 
-      const qb: SelectQueryBuilder<OrderInventory> = tx
-        .getRepository(OrderInventory)
-        .createQueryBuilder('orderInventory')
-      qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
-        .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
-        .innerJoinAndSelect('bizplace.domain', 'domain')
-        .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
-        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
-          orderInventoryStatus: [ORDER_INVENTORY_STATUS.PACKING, ORDER_INVENTORY_STATUS.PACKED]
+      // Find Release Order based on Bin
+      if (!releaseGood) {
+        const binLocation: Location = await tx.getRepository(Location).findOne({
+          where: { domain, name: releaseGoodNo }
         })
-        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
-        .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.PACKING })
-
-      const orderInventoryByBin = await qb.getOne()
-      if (orderInventoryByBin?.releaseGood) {
-        releaseGoodNo = orderInventoryByBin.releaseGood.name
-        releaseGood = orderInventoryByBin.releaseGood
-      }
-    }
 
-    if (!releaseGood) throw new Error(`Release good dosen't exist.`)
-
-    const worksheet: Worksheet = await fetchExecutingWorksheet(
-      domain,
-      releaseGood.bizplace,
-      [
-        'bizplace',
-        'bizplace.domain',
-        'releaseGood',
-        'releaseGood.domain',
-        'worksheetDetails',
-        'worksheetDetails.targetInventory',
-        'worksheetDetails.targetInventory.binLocation',
-        'worksheetDetails.targetInventory.inventory',
-        'worksheetDetails.targetInventory.inventory.location',
-        'worksheetDetails.targetInventory.inventory.product',
-        'worksheetDetails.toLocation'
-      ],
-      WORKSHEET_TYPE.PACKING,
-      releaseGood
-    )
-
-    let marketplaceOrder: MarketplaceOrder
-    let marketplaceOrderItems: MarketplaceOrderItem[] = []
-    let marketplaceStore
-    let trackingNo: string
-    let shippingProvider: string
-    let marketplaceStatus: string
-
-    if (releaseGood.type === 'b2c') {
-      const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-        domain: worksheet.bizplace.domain,
-        status: SellercraftStatus.ACTIVE
-      })
-
-      if (sellercraft) {
-        if (!releaseGood?.airwayBill) {
-          const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-          releaseGood = await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+        if (binLocation) {
+          const qb: SelectQueryBuilder<OrderInventory> = tx
+            .getRepository(OrderInventory)
+            .createQueryBuilder('orderInventory')
+
+          qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
+            .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
+            .innerJoinAndSelect('bizplace.domain', 'domain')
+            .innerJoinAndSelect(
+              'worksheets',
+              'ws',
+              `orderInventory.release_good_id = ws.release_good_id AND ws.type = 'PACKING' AND ws.status = 'EXECUTING'`
+            )
+            .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
+            .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
+              orderInventoryStatus: [
+                ORDER_INVENTORY_STATUS.READY_TO_PACK,
+                ORDER_INVENTORY_STATUS.PACKING,
+                ORDER_INVENTORY_STATUS.PACKED
+              ]
+            })
+            .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
+            .andWhere('releaseGood.status IN (:...status)', {
+              status: [ORDER_STATUS.READY_TO_PACK, ORDER_STATUS.PACKING]
+            })
+
+          const orderInventoryByBin = await qb.getOne()
+          if (orderInventoryByBin?.releaseGood) {
+            releaseGoodNo = orderInventoryByBin.releaseGood.name
+            releaseGood = orderInventoryByBin.releaseGood
+          } else {
+            throw new Error(`Bin do not have any existing order.`)
+          }
         }
-        trackingNo = releaseGood?.trackingNo
-        shippingProvider = releaseGood?.transporter
-        marketplaceStatus = releaseGood?.marketplaceOrderStatus
       }
 
-      if (!sellercraft) {
-        marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-          where: { orderNo: releaseGood.refNo },
-          relations: [
-            'domain',
-            'marketplaceStore',
-            'marketplaceOrderItems',
-            'marketplaceOrderItems.marketplaceOrderShippingItems',
-            'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
-          ]
-        })
+      if (!releaseGood) throw new Error(`Release good do not exist.`)
 
-        if (!marketplaceOrder) {
-          throw new Error('Failed to retrieve ecommerce information, kindly contact our support team for this issue.')
-        }
+      const worksheet: Worksheet = await fetchExecutingWorksheet(
+        domain,
+        releaseGood.bizplace,
+        [
+          'bizplace',
+          'bizplace.domain',
+          'releaseGood',
+          'releaseGood.domain',
+          'worksheetDetails',
+          'worksheetDetails.targetInventory',
+          'worksheetDetails.targetInventory.binLocation',
+          'worksheetDetails.targetInventory.inventory',
+          'worksheetDetails.targetInventory.inventory.location',
+          'worksheetDetails.targetInventory.inventory.product',
+          'worksheetDetails.targetInventory.inventory.product.productDetails',
+          'worksheetDetails.toLocation'
+        ],
+        WORKSHEET_TYPE.PACKING,
+        releaseGood
+      )
+
+      let marketplaceOrder: MarketplaceOrder
+      let marketplaceOrderItems: MarketplaceOrderItem[] = []
+      let marketplaceStore
+      let trackingNo: string
+      let shippingProvider: string
+      let marketplaceStatus: string
+
+      if (releaseGood.type === 'b2c') {
+        const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
+          domain: worksheet.bizplace.domain,
+          status: SellercraftStatus.ACTIVE
+        })
 
-        let marketplaceOrderShipping: MarketplaceOrderShipping
-        if (marketplaceOrder.isSplitted) {
-          marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
-            where: { subOrderNoRef: worksheet.releaseGood.refNo2 }
-          })
+        if (sellercraft) {
+          if (!releaseGood?.airwayBill) {
+            const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+            releaseGood = await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+          }
+          trackingNo = releaseGood?.trackingNo
+          shippingProvider = releaseGood?.transporter
+          marketplaceStatus = releaseGood?.marketplaceOrderStatus
         } else {
-          marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
-            where: { orderNoRef: worksheet.releaseGood.refNo }
+          marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+            where: { orderNo: releaseGood.refNo },
+            relations: [
+              'domain',
+              'marketplaceStore',
+              'marketplaceOrderItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
+            ]
           })
-        }
 
-        trackingNo = marketplaceOrderShipping.ownTrackingNo
-          ? marketplaceOrderShipping.ownTrackingNo
-          : marketplaceOrderShipping.trackingNo
-        shippingProvider = marketplaceOrderShipping.ownTransporter
-          ? marketplaceOrderShipping.ownTransporter
-          : marketplaceOrderShipping.transporter
-
-        marketplaceStore = marketplaceOrder?.marketplaceStore
-        marketplaceStatus = marketplaceOrder?.status
+          if (!marketplaceOrder) {
+            throw new Error('Failed to retrieve ecommerce information, kindly contact our support team for this issue.')
+          }
+
+          let marketplaceOrderShipping: MarketplaceOrderShipping
+          if (marketplaceOrder.isSplitted) {
+            marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+              where: { subOrderNoRef: worksheet.releaseGood.refNo2 }
+            })
+          } else {
+            marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+              where: { orderNoRef: worksheet.releaseGood.refNo }
+            })
+          }
+
+          trackingNo = marketplaceOrderShipping.ownTrackingNo
+            ? marketplaceOrderShipping.ownTrackingNo
+            : marketplaceOrderShipping.trackingNo
+          shippingProvider = marketplaceOrderShipping.ownTransporter
+            ? marketplaceOrderShipping.ownTransporter
+            : marketplaceOrderShipping.transporter
+
+          marketplaceStore = marketplaceOrder?.marketplaceStore
+          marketplaceStatus = marketplaceOrder?.status
+        }
       }
-    }
 
-    return {
-      worksheetInfo: {
-        releaseGood,
-        bizplaceName: releaseGood.bizplace.name,
-        refNo: releaseGood.refNo,
-        refNo2: releaseGood.refNo2,
-        refNo3: releaseGood.refNo3,
-        partnerDomainId: releaseGood.bizplace?.domain.id,
-        startedAt: worksheet.startedAt,
-        shippingProvider: shippingProvider ? shippingProvider : '',
-        trackingNo: trackingNo ? trackingNo : '',
-        airwayBill: releaseGood?.airwayBill,
-        invoice: releaseGood?.invoice,
-        platform: marketplaceOrder ? marketplaceOrder.marketplaceStore.platform : 'operato',
-        marketplaceStoreId: marketplaceOrder ? marketplaceOrder.marketplaceStore.id : '',
-        marketplaceStatus: marketplaceStatus ? marketplaceStatus : '',
-        marketplaceOrder: marketplaceOrder ? marketplaceOrder : ''
-      },
-      worksheetDetailInfos: worksheet.worksheetDetails.map(async (packingWSD: WorksheetDetail) => {
-        const targetInventory: OrderInventory = packingWSD.targetInventory
-        const inventory: Inventory = targetInventory.inventory
-        return {
-          name: packingWSD.name,
-          palletId: inventory.palletId,
-          cartonId: inventory.cartonId,
-          batchId: inventory.batchId,
-          batchIdRef: inventory.batchIdRef,
-          product: inventory.product,
-          sku: inventory.product.sku,
-          releaseQty: targetInventory.releaseQty,
-          packedQty: targetInventory.packedQty,
-          status: packingWSD.status,
-          description: packingWSD.description,
-          targetName: targetInventory.name,
-          packingType: inventory.packingType,
-          packingSize: inventory.packingSize,
-          binLocation: targetInventory?.binLocation,
-          location: inventory.location
-        }
-      })
+      return {
+        worksheetInfo: {
+          releaseGood,
+          bizplaceName: releaseGood.bizplace.name,
+          refNo: releaseGood.refNo,
+          refNo2: releaseGood.refNo2,
+          refNo3: releaseGood.refNo3,
+          partnerDomainId: releaseGood.bizplace?.domain.id,
+          startedAt: worksheet.startedAt,
+          shippingProvider: shippingProvider ? shippingProvider : '',
+          trackingNo: trackingNo ? trackingNo : '',
+          airwayBill: releaseGood?.airwayBill,
+          invoice: releaseGood?.invoice,
+          platform: marketplaceOrder ? marketplaceOrder.marketplaceStore.platform : 'operato',
+          marketplaceStoreId: marketplaceOrder ? marketplaceOrder.marketplaceStore.id : '',
+          marketplaceStatus: marketplaceStatus ? marketplaceStatus : '',
+          marketplaceOrder: marketplaceOrder ? marketplaceOrder : ''
+        },
+        worksheetDetailInfos: worksheet.worksheetDetails.map(async (packingWSD: WorksheetDetail) => {
+          const targetInventory: OrderInventory = packingWSD.targetInventory
+          const inventory: Inventory = targetInventory.inventory
+          return {
+            name: packingWSD.name,
+            palletId: inventory.palletId,
+            cartonId: inventory.cartonId,
+            batchId: inventory.batchId,
+            batchIdRef: inventory.batchIdRef,
+            product: inventory.product,
+            sku: inventory.product.sku,
+            releaseQty: targetInventory.releaseQty,
+            packedQty: targetInventory.packedQty,
+            status: packingWSD.status,
+            description: packingWSD.description,
+            targetName: targetInventory.name,
+            packingType: inventory.packingType,
+            packingSize: inventory.packingSize,
+            binLocation: targetInventory?.binLocation,
+            location: inventory.location,
+            relatedOrderInv: targetInventory
+          }
+        })
+      }
+    } catch (error) {
+      console.error(error)
+      throw error
     }
   }
 }

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

@@ -7,7 +7,7 @@ import { Worksheet } from '../../../../entities'
 export const assignPickingWorkerResolver = {
   async assignPickingWorker(
     _parentObj: void,
-    { worksheetId, userId }: { worksheetId: string; userId: string },
+    { worksheetId, userId }: { worksheetId: [string]; userId: string },
     context: any
   ): Promise<void> {
     const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
@@ -17,16 +17,20 @@ export const assignPickingWorkerResolver = {
 
     if (!assignee) throw new Error('failed to find target user')
 
-    const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-      id: worksheetId,
-      type: WORKSHEET_TYPE.PICKING
-    })
+    await Promise.all(worksheetId.map(async (worksheetId)=>{
+      const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+        id: worksheetId,
+      },{where: [{
+        type:WORKSHEET_TYPE.BATCH_PICKING
+      },{type:WORKSHEET_TYPE.PICKING}]})
+  
+      if (!worksheet) throw new Error('failed to find target picking worksheet')
+      if (worksheet.status !== WORKSHEET_STATUS.DEACTIVATED)
+        throw new Error(`current status of worksheet is not able to assign worker`)
+  
+      worksheet.assignee = assignee
+      await tx.getRepository(Worksheet).save(worksheet)
 
-    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/complete-picking.ts

@@ -5,7 +5,6 @@ import { Bizplace, ContactPoint, getMyBizplace } from '@things-factory/biz-base'
 import { LastMileAPI, LastMileDelivery } from '@things-factory/integration-lmd'
 import { MarketplaceStore, MarketplaceTransporter } from '@things-factory/integration-marketplace'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
-import { Sftp, SftpAPI } from '@things-factory/integration-sftp'
 import {
   MarketplaceOrder,
   MarketplaceOrderItem,
@@ -213,23 +212,6 @@ export async function completePicking(
     }
   }
 
-  const customerDomain: Domain = releaseGood.bizplace.domain
-  let customerAvailableSftp: Sftp = await tx.getRepository(Sftp).findOne({
-    where: { domain: customerDomain }
-  })
-  if (customerAvailableSftp) {
-    const orderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-      where: { releaseGood },
-      relations: ['product']
-    })
-    let result: Sftp = await SftpAPI.createShipment(customerAvailableSftp, {
-      releaseGood,
-      orderInventories,
-      sftp: customerAvailableSftp
-    })
-    customerAvailableSftp = await tx.getRepository(Sftp).save(result)
-  }
-
   if (releaseGood.packingOption) {
     const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
 

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

@@ -10,6 +10,7 @@ import { pickingResolver } from './picking'
 import { scanProductPickingResolver } from './scan-product-picking'
 import { scanProductBatchPickingResolver } from './scan-product-batch-picking'
 import { undoPickingAssigmentResolver } from './undo-picking-assignment'
+import { undoSerialNumberPickingResolver } from './undo-serial-number-picking'
 
 export const Mutations = {
   ...assignPickingInventoriesResolver,
@@ -23,5 +24,6 @@ export const Mutations = {
   ...completePickingResolver,
   ...completeBatchPickingResolver,
   ...assignPickingWorkerResolver,
-  ...fetchAndAssignPickingTaskResolver
+  ...fetchAndAssignPickingTaskResolver,
+  ...undoSerialNumberPickingResolver
 }

package/server/graphql/resolvers/worksheet/picking/picking-assignment-status-by-user.ts

@@ -1,5 +1,4 @@
 import { getDomainUsers, User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
 import { Domain } from '@things-factory/shell'
 import { FindManyOptions, getRepository, ILike, In } from 'typeorm'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
@@ -10,7 +9,7 @@ type AssignmentStatusByUserType = { user: User; pending?: Worksheet[]; picking?:
 export const pickingAssignmentStatusByUsersResolver = {
   async pickingAssignmentStatusByUsers(
     _: void,
-    { bizplaceId, name, email }: { bizplaceId: string; name?: string; email?: string },
+    { name, email }: { name?: string; email?: string },
     context: any
   ): Promise<AssignmentStatusByUserType[]> {
     const { domain }: { domain: Domain } = context.state
@@ -19,20 +18,19 @@ export const pickingAssignmentStatusByUsersResolver = {
     const domainUserIds: string[] = domainUsers
       .filter((user: User) => user.userType === 'user')
       .map((user: User) => user.id)
+
     const findOneOption: FindManyOptions<User> = { where: { id: In(domainUserIds) } }
     if (name) findOneOption.where.name = ILike(`%${name}%`)
     if (email) findOneOption.where.email = ILike(`%${email}%`)
 
     const users: User[] = await getRepository(User).find(findOneOption)
 
-    const bizplace: Bizplace = await getRepository(Bizplace).findOne(bizplaceId)
     const assignedPickingWorksheets: Worksheet[] = await getRepository(Worksheet).find({
       where: {
-        domain,
-        bizplace,
-        type: WORKSHEET_TYPE.PICKING,
+        type: In([WORKSHEET_TYPE.PICKING, WORKSHEET_TYPE.BATCH_PICKING]),
         status: In([WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]),
-        assignee: In(users.map((u: User) => u.id))
+        assignee: In(users.map((u: User) => u.id)),
+        domain
       },
       relations: ['assignee']
     })

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/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 }, 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)
   }
 }
 
@@ -16,8 +16,9 @@ export async function scanProductSorting(
   user: User,
   taskNo: string,
   releaseGoodNo: string,
-  productBarcode?: string
+  productBarcode?: string,
+  serialNumber?: string
 ) {
   const worksheetController: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-  await worksheetController.scanProductSorting(taskNo, releaseGoodNo, productBarcode)
+  await worksheetController.scanProductSorting(taskNo, releaseGoodNo, productBarcode, serialNumber)
 }

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 }, 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)
   }
 }
 
@@ -17,8 +17,9 @@ export async function sortingProduct(
   taskNo: string,
   releaseGoodNo: string,
   productId: string,
-  sortingQty: number
+  sortingQty: number,
+  serialNumber?: string
 ) {
   const worksheetController: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-  await worksheetController.sortingProduct(taskNo, releaseGoodNo, productId, sortingQty)
+  await worksheetController.sortingProduct(taskNo, releaseGoodNo, productId, sortingQty, serialNumber)
 }

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/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