@things-factory/worksheet-base 5.0.0-alpha.4 → 5.0.0-alpha.40

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,
@@ -206,30 +205,16 @@ export async function completePicking(
             }
           }
         } else {
-          throw resp
-          //Failed
+          if (resp?.AWBurl && resp?.TrackingNo)
+            await tx
+              .getRepository(MarketplaceOrderShipping)
+              .update({ id: marketplaceOrderShipping.id }, { airwayBill: resp.AWBurl, trackingNo: resp.TrackingNo })
+          else throw resp
         }
       }
     }
   }
 
-  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,81 +1,82 @@
-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 { getDomainUsers, User, Role } from '@things-factory/auth-base'
+import { Domain, ListParam, buildQuery, Sorting} from '@things-factory/shell'
+import { FindManyOptions, getRepository, ILike, In, EntityManager, getManager, SelectQueryBuilder } from 'typeorm'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import { Worksheet } from '../../../../entities'
 
-type AssignmentStatusByUserType = { user: User; pending?: Worksheet[]; picking?: Worksheet[] }
+type AssignmentStatusByUserType = { user: User; pending?: String; picking?: String }
 
 export const pickingAssignmentStatusByUsersResolver = {
   async pickingAssignmentStatusByUsers(
     _: void,
-    { bizplaceId, name, email }: { bizplaceId: string; name?: string; email?: string },
+    params: ListParam,
     context: any
   ): Promise<AssignmentStatusByUserType[]> {
+    
     const { domain }: { domain: Domain } = context.state
-    const domainUsers: User[] = await getDomainUsers(domain)
 
-    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 nameFilter = params.filters.find(p=>{return p.name == "name"});
+    const emailFilter = params.filters.find(p=>{return p.name == "email"});
+    const roleFilter = params.filters.find(p=>{return p.name == 'roles'});
 
-    const users: User[] = await getRepository(User).find(findOneOption)
+    const pendingSorter = params.sortings.find(p=>{return p.name == 'pending'});
+    const pickingSorter = params.sortings.find(p=>{return p.name == 'picking'});
 
-    const bizplace: Bizplace = await getRepository(Bizplace).findOne(bizplaceId)
-    const assignedPickingWorksheets: Worksheet[] = await getRepository(Worksheet).find({
-      where: {
-        domain,
-        bizplace,
-        type: WORKSHEET_TYPE.PICKING,
-        status: In([WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]),
-        assignee: In(users.map((u: User) => u.id))
-      },
-      relations: ['assignee']
-    })
 
-    const assignmentMap: Map<string, AssignmentStatusByUserType> = assignedPickingWorksheets.reduce(
-      (assignmentMap: Map<string, AssignmentStatusByUserType>, worksheet: Worksheet) => {
-        const assignee: User = worksheet.assignee
-        const status: string = worksheet.status
 
-        if (assignmentMap.has(assignee.id)) {
-          const assignment: AssignmentStatusByUserType = assignmentMap.get(assignee.id)
-          if (status === WORKSHEET_STATUS.DEACTIVATED) {
-            assignment.pending.push(worksheet)
-          } else if (status === WORKSHEET_STATUS.EXECUTING) {
-            assignment.picking.push(worksheet)
-          }
-        } else {
-          if (status === WORKSHEET_STATUS.DEACTIVATED) {
-            assignmentMap.set(assignee.id, {
-              user: assignee,
-              pending: [worksheet],
-              picking: []
-            })
-          } else if (status === WORKSHEET_STATUS.EXECUTING) {
-            assignmentMap.set(assignee.id, {
-              user: assignee,
-              pending: [],
-              picking: [worksheet]
-            })
-          }
-        }
+    const getUserInfoQb:SelectQueryBuilder<User> = await getRepository(User).createQueryBuilder('u')
 
-        return assignmentMap
-      },
-      new Map()
-    )
+    getUserInfoQb.select('u.id')
+    getUserInfoQb.addSelect('u.name')
+    getUserInfoQb.addSelect('u.email')
+    getUserInfoQb.addSelect("string_agg(r.name,', ') as roles")
+    getUserInfoQb.innerJoin('u.roles','r')
+    getUserInfoQb.where('r.domain_id = :domainId',{domainId:domain.id})
+    roleFilter? getUserInfoQb.andWhere('r.name ilike :userRole', { userRole: `%${roleFilter.value}%` }) :""
+    nameFilter? getUserInfoQb.andWhere('u.name ilike :userName', { userName: `%${nameFilter.value}%` }) :""
+    emailFilter? getUserInfoQb.andWhere('u.email ilike :userEmail', { userEmail: `%${emailFilter.value}%` }) :""
+    getUserInfoQb.andWhere('r.name not ilike :userR',{userR:`%CLIENT%`})
+    getUserInfoQb.andWhere('u.user_type = :userType',{userType:"user"})
+    getUserInfoQb.groupBy('u.id')
+    getUserInfoQb.addGroupBy('u.name')
+    getUserInfoQb.addGroupBy('u.email')
+
+    const getAssignedWSQb = await getRepository(Worksheet).createQueryBuilder('ws')
+
+    getAssignedWSQb.select('ws.assignee_id')
+    getAssignedWSQb.addSelect('u.name')
+    getAssignedWSQb.addSelect("sum(case when ws.status='EXECUTING' then 1 else 0 end) as picking")
+    getAssignedWSQb.addSelect("sum(case when ws.status='DEACTIVATED' then 1 else 0 end) as pending")
+    getAssignedWSQb.innerJoin('ws.assignee','u')
+    getAssignedWSQb.where('ws.domain_id = :id',{id:domain.id})
+    getAssignedWSQb.andWhere('ws.type IN (:...type)', {type: [WORKSHEET_TYPE.PICKING, WORKSHEET_TYPE.BATCH_PICKING]})
+    getAssignedWSQb.andWhere('ws.status IN (:...status)', {status: [WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]})
+    getAssignedWSQb.groupBy('ws.assignee_id')
+    getAssignedWSQb.addGroupBy('u.name')
+    pendingSorter?.desc ? getAssignedWSQb.orderBy('pending','DESC') : ''
+    pickingSorter?.desc ? getAssignedWSQb.orderBy('picking','DESC') : ''
+    pickingSorter && Object.keys(pickingSorter).length == 1 ?getAssignedWSQb.orderBy('picking','ASC') : ''
+    pendingSorter && Object.keys(pendingSorter).length == 1 ? getAssignedWSQb.orderBy('pending','ASC') : ''
 
-    users.forEach((user: User) => {
-      if (!assignmentMap.has(user.id)) {
-        assignmentMap.set(user.id, { user, pending: [], picking: [] })
-      }
-    })
 
-    return Array.from(assignmentMap.values())
+    const parameter1= getUserInfoQb.getParameters()
+    const parameter2 = getAssignedWSQb.getParameters()
+
+    const combineParams = Object.assign(parameter1, parameter2)
+  
+    const combineQb = getManager().createQueryBuilder()
+
+    combineQb.select('u.*')
+    combineQb.addSelect('coalesce(ws.picking, 0) as picking')
+    combineQb.addSelect('coalesce(ws.pending, 0) as pending')
+    combineQb.from("(" + getUserInfoQb.getQuery() + ")","u")
+    combineQb.leftJoin("(" + getAssignedWSQb.getQuery() + ")","ws",' ws.assignee_id = u.u_id')
+    combineQb.setParameters(combineParams)
+    
+    const combineInfo = await combineQb.getRawMany()
+
+    return combineInfo.map(itm => {
+      return { user: { id:itm.u_id,email:itm.u_email,name:itm.u_name, description: itm.roles },pending:itm.pending,picking:itm.picking }
+    })
   }
 }

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)
 }