@things-factory/worksheet-base 8.0.0-beta.8 → 8.0.0

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

@@ -0,0 +1,282 @@
+import { EntityManager, getManager } from 'typeorm'
+
+import { ApplicationType, User } from '@things-factory/auth-base'
+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 {
+  MarketplaceOrder,
+  MarketplaceOrderItem,
+  MarketplaceOrderShipping,
+  MarketplaceOrderShippingItem
+} from '@things-factory/marketplace-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderInventory,
+  OrderProduct,
+  ReleaseGood
+} from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
+import {
+  LoadingWorksheetController,
+  PackingWorksheetController,
+  PickingWorksheetController,
+  SellercraftController
+} from '../../../../controllers/'
+import { EcommerceController } from '../../../../controllers/ecommerce'
+import { WorksheetController } from '../../../../controllers/worksheet-controller'
+import { Worksheet, WorksheetDetail } from '../../../../entities'
+
+export const completePickingResolver = {
+  async completePicking(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+
+    await completePicking(tx, domain, user, releaseGoodNo)
+
+    const bizplace: Bizplace = await getMyBizplace(domain, user)
+    const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
+    await worksheetController.notifyToCustomer(bizplace, {
+      title: `Picking has been completed (${bizplace.name}, ${releaseGoodNo})`,
+      body: `Items now are ready to be loaded`,
+      url: context.header.referer,
+      data: { url: context.header.referer }
+    })
+  }
+}
+
+export async function completePicking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  releaseGoodNo: string
+): Promise<void> {
+  const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+    where: { domain: { id: domain.id }, name: releaseGoodNo },
+    relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
+  })
+
+  const worksheet: Worksheet = await pickingWSCtrl.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PICKING, [
+    'worksheetDetails',
+    'worksheetDetails.targetInventory'
+  ])
+
+  const warehouseContactPoint: ContactPoint = await tx.getRepository(ContactPoint).findOne({
+    where: {
+      domain: { id: domain.id },
+      type: 'WAREHOUSE'
+    }
+  })
+
+  const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+  const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+  const pickedTargetInventories: OrderInventory[] = targetInventories.filter(
+    targetInventory => targetInventory.status === ORDER_INVENTORY_STATUS.PICKED
+  )
+
+  await pickingWSCtrl.completePicking(releaseGoodNo)
+
+  const orderSource: string = releaseGood.source
+  switch (orderSource) {
+    case ApplicationType.SELLERCRAFT:
+      const sellercraft: Sellercraft = await tx
+        .getRepository(Sellercraft)
+        .findOneBy({ domain: {id: releaseGood.bizplace.domain.id}, status: SellercraftStatus.ACTIVE })
+      const initSCOrderShipment = async sellercraft => {
+        if (sellercraft) {
+          await getManager().transaction(async txMgr => {
+            const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
+
+            if (!releaseGood?.packageId) {
+              const orderProducts: OrderProduct[] = await tx.getRepository(OrderProduct).find({
+                where: { releaseGood },
+                relations: ['product', 'product.productDetails']
+              })
+              releaseGood = await sellercraftCtrl.packOrder(sellercraft, { ...releaseGood, orderProducts })
+
+              if (releaseGood?.packageId) {
+                await txMgr
+                  .getRepository(ReleaseGood)
+                  .update({ id: releaseGood.id }, { packageId: releaseGood.packageId, updater: releaseGood.updater })
+              }
+            }
+
+            await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+          })
+        }
+      }
+
+      // asynchronouly call to initiate sellercraft order shipment/ RTS
+      initSCOrderShipment(sellercraft)
+      break
+
+    case ApplicationType.MMS:
+      const companyDomain: Domain = releaseGood.bizplace.company.domain
+      let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { orderNo: releaseGood.refNo, domain: companyDomain },
+        relations: [
+          'marketplaceStore',
+          'marketplaceOrderItems',
+          'marketplaceOrderItems.marketplaceOrderShippingItems',
+          'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
+        ]
+      })
+
+      if (marketplaceOrder) {
+        const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+        let eTraxOption: boolean
+
+        if (marketplaceStore.isAutoUpdateShipment) {
+          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+          await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PACKING)
+        }
+
+        if (!marketplaceOrder)
+          throw new Error('Failed to find ecommerce order, kindly contact our support team regarding this issue')
+        eTraxOption = marketplaceOrder?.marketplaceStore.eTrax
+
+        // if eTrax option is true
+        if (eTraxOption) {
+          const marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
+
+          // access every marketplaceOrderItems for shipping information you need
+          // trigger the controller from integration-lmd that trigger the API, build the parameters needed
+          // for etrax didn't support multi awb per order
+          const marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] =
+            marketplaceOrderItems[0].marketplaceOrderShippingItems
+          const marketplaceOrderShipping: MarketplaceOrderShipping =
+            marketplaceOrderShippingItems[0].marketplaceOrderShipping
+          const lmd: LastMileDelivery = await tx.getRepository(LastMileDelivery).findOne({
+            where: {
+              domain,
+              platform: 'eTrax'
+            }
+          })
+
+          //Get which transporter to use
+          const marketplaceTransporter: MarketplaceTransporter = await tx
+            .getRepository(MarketplaceTransporter)
+            .findOne({
+              where: { marketplaceStore: marketplaceOrder.marketplaceStore },
+              relations: ['pickupTransporter', 'deliveryTransporter']
+            })
+
+          const resp = await LastMileAPI.createShipmentRequest(lmd, {
+            orderNo: marketplaceOrder.orderNo,
+            clientId: lmd.clientId,
+            clientType: lmd.clientType,
+            clientName: lmd.clientName,
+            transporterId: marketplaceTransporter.pickupTransporter.transporterId,
+            pickupName: warehouseContactPoint.name,
+            pickupAddress1: warehouseContactPoint.address,
+            pickupAddress2: warehouseContactPoint.address2,
+            pickupPostcode: warehouseContactPoint.postCode,
+            pickupState: warehouseContactPoint.state,
+            pickupCity: warehouseContactPoint.city,
+            pickupPhone: warehouseContactPoint.phone,
+            pickupEmail: warehouseContactPoint.email,
+            name: marketplaceOrderShipping?.attentionTo ? marketplaceOrderShipping.attentionTo.trim() : '',
+            address1: marketplaceOrderShipping?.address1 ? marketplaceOrderShipping?.address1.trim() : '-',
+            address2: marketplaceOrderShipping?.address2 ? marketplaceOrderShipping?.address2.trim() : '-',
+            postCode: marketplaceOrderShipping?.postCode ? marketplaceOrderShipping?.postCode.trim() : '',
+            city: marketplaceOrderShipping?.city ? marketplaceOrderShipping?.city.trim() : '',
+            state: marketplaceOrderShipping?.state ? marketplaceOrderShipping?.state.trim() : '',
+            phone: marketplaceOrderShipping.phone1 || '',
+            email: marketplaceOrderShipping.email || '',
+            attentionTo: marketplaceOrderShipping.attentionTo,
+            quantity: marketplaceOrderItems.length
+          })
+
+          const delay = (ms: number) => {
+            return new Promise(resolve => setTimeout(resolve, ms))
+          }
+
+          if (resp.Status === 'SUCCESS') {
+            //Success
+            let awbObtained = false
+            let retry = 0
+            while (!awbObtained) {
+              const marketplaceOrder2: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+                where: { releaseOrderId: releaseGood.id },
+                relations: [
+                  'marketplaceStore',
+                  'marketplaceOrderItems',
+                  'marketplaceOrderItems.marketplaceOrderShippingItems',
+                  'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping'
+                ]
+              })
+              const orderShipping =
+                marketplaceOrder2.marketplaceOrderItems[0].marketplaceOrderShippingItems[0].marketplaceOrderShipping
+              if (orderShipping?.airwayBill) {
+                awbObtained = true
+              }
+              await delay(5000)
+              //Timeout after 15sec
+              if (++retry > 3) {
+                break
+              }
+            }
+          } else {
+            if (resp?.AWBurl && resp?.TrackingNo)
+              await tx
+                .getRepository(MarketplaceOrderShipping)
+                .update({ id: marketplaceOrderShipping.id }, { airwayBill: resp.AWBurl, trackingNo: resp.TrackingNo })
+            else throw resp
+          }
+        }
+      }
+      break
+
+    default:
+      break
+  }
+
+  if (releaseGood.packingOption) {
+    const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+    await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+  } else {
+    // Find Existing Loading Worksheet if any
+    let existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        releaseGood: { id: releaseGood.id },
+        type: WORKSHEET_TYPE.LOADING,
+        status: WORKSHEET_STATUS.DEACTIVATED
+      }
+    })
+
+    if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
+      if (pickedTargetInventories.length > 0) {
+        const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+        let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
+          releaseGoodNo,
+          pickedTargetInventories
+        )
+
+        if (!loadingWorksheet.worksheetDetails?.length) {
+          loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+        }
+
+        const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+        await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
+      }
+    } else {
+      const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+      let loadingWorksheet: Worksheet = await loadingWSCtrl.updateLoadingWorksheet(
+        releaseGoodNo,
+        pickedTargetInventories,
+        existLoadingWorksheet
+      )
+
+      if (!loadingWorksheet.worksheetDetails?.length) {
+        loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+      }
+
+      const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/picking/fetch-and-assign-picking-task.ts

@@ -0,0 +1,121 @@
+import { EntityManager, getConnection } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
+import { Worksheet } from '../../../../entities'
+import { pickingWorksheet } from '../picking-worksheet'
+import { activatePicking } from './activate-picking'
+
+export const fetchAndAssignPickingTaskResolver = {
+  async fetchAndAssignPickingTask(_: any, {}, context: ResolverContext) {
+    try {
+      const { tx, domain, user } = context.state
+      const assignee: User = await tx.getRepository(User).findOne({
+        where: { id: user.id },
+        relations: ['domains']
+      })
+      if ((assignee?.domains || []).every((userDomain: Domain) => userDomain.id !== domain.id))
+        throw new Error('Target user is not belong to current domain')
+
+      if (!assignee) throw new Error('failed to find target user')
+
+      let worksheet: Worksheet
+      let worksheetQb = await tx
+        .getRepository(Worksheet)
+        .createQueryBuilder('ws')
+        .select('ws.id')
+        .addSelect('ws.name')
+        .addSelect('ws.status')
+        .innerJoinAndSelect('ws.releaseGood', 'rg')
+        .where(
+          '(ws.domain_id = :domain_id AND ws.type = :type AND ws.assignee_id =:assignee AND (ws.status = :status1 OR ws.status = :status2))',
+          {
+            domain_id: domain.id,
+            type: WORKSHEET_TYPE.PICKING,
+            assignee: assignee.id,
+            status1: WORKSHEET_STATUS.EXECUTING,
+            status2: WORKSHEET_STATUS.DEACTIVATED
+          }
+        )
+        .andWhere(qb => {
+          const subQuery = qb
+            .subQuery()
+            .select('COUNT(*) AS totalPS')
+            .from(OrderInventory, 'OrderInventory')
+            .where('OrderInventory.release_good_id = ws.release_good_id')
+            .andWhere(`OrderInventory.status = 'PENDING_SPLIT'`)
+            .groupBy('OrderInventory.release_good_id')
+            .having('COUNT(*) > 0')
+            .getQuery()
+          return 'NOT EXISTS ' + subQuery
+        })
+        .orderBy('"rg"."created_at"', 'ASC')
+
+      worksheet = await worksheetQb.getOne()
+
+      if (!worksheet) {
+        // update and return updated worksheet id
+        let updatedWorksheets = await getConnection().transaction(async (tx2: EntityManager) => {
+          let x = await tx2.getRepository(Worksheet).query(
+            `
+            UPDATE worksheets ws SET assignee_id = $2,
+            updated_at = NOW(),
+            updater_id = $2
+            FROM (
+              SELECT ws.id, ws.name, ws.status, ws.release_good_id FROM worksheets ws
+              INNER JOIN release_goods rg ON rg.id = ws.release_good_id
+              WHERE 
+              ws.domain_id = $1 AND 
+              ws.type = 'PICKING' AND 
+              ws.assignee_id IS NULL AND 
+              (ws.status = 'EXECUTING' OR ws.status = 'DEACTIVATED') AND
+              NOT EXISTS (
+                SELECT count(id) AS "totalPS"
+                FROM order_inventories oi 
+                WHERE oi.release_good_id = ws.release_good_id AND
+                oi.status = 'PENDING_SPLIT'
+                GROUP BY oi.release_good_id 
+                HAVING count(id) > 0
+              )
+              ORDER BY rg.release_date, rg.created_at LIMIT 1
+            ) src where src.id = ws.id
+            RETURNING ws.id;
+          `,
+            [domain.id, assignee.id]
+          )
+          return x[0]
+        })
+
+        if (updatedWorksheets.length == 0) throw new Error('no suitable worksheet found')
+
+        // relace worksheet with newly assigned worksheet
+        worksheet = await tx
+          .getRepository(Worksheet)
+          .findOne({ where: { id: updatedWorksheets[0].id }, relations: ['releaseGood'] })
+      }
+
+      if (worksheet.status == WORKSHEET_STATUS.DEACTIVATED) await activatePicking(tx, domain, user, worksheet.name)
+
+      const locationSortingRules: Setting = await tx.getRepository(Setting).findOne({
+        where: { domain: { id: domain.id }, name: 'rule-for-picking-product' }
+      })
+
+      const sortingRule = JSON.parse(locationSortingRules.value)
+      const locationSortingRule = Object.keys(sortingRule).map(field => {
+        return { name: field, desc: sortingRule[field] === 'DESC' }
+      })
+
+      const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOneBy({
+        id: worksheet.releaseGood.id
+      })
+
+      return await pickingWorksheet(domain, releaseGood.name, locationSortingRule, tx)
+    } catch (error) {
+      throw error
+    }
+  }
+}

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

@@ -0,0 +1,31 @@
+import { activateBatchPickingResolver } from './activate-batch-picking'
+import { activatePickingResolver } from './activate-picking'
+import { assignPickingInventoriesResolver } from './assign-picking-inventories'
+import { assignPickingWorkerResolver } from './assign-picking-worker'
+import { fetchAndAssignPickingTaskResolver } from './fetch-and-assign-picking-task'
+import { batchPickingResolver } from './batch-picking'
+import { completeBatchPickingResolver } from './complete-batch-picking'
+import { completePickingResolver } from './complete-picking'
+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'
+import { sealToteResolver } from './seal-tote'
+
+export const Mutations = {
+  ...assignPickingInventoriesResolver,
+  ...undoPickingAssigmentResolver,
+  ...activatePickingResolver,
+  ...activateBatchPickingResolver,
+  ...pickingResolver,
+  ...scanProductPickingResolver,
+  ...scanProductBatchPickingResolver,
+  ...batchPickingResolver,
+  ...completePickingResolver,
+  ...completeBatchPickingResolver,
+  ...assignPickingWorkerResolver,
+  ...fetchAndAssignPickingTaskResolver,
+  ...undoSerialNumberPickingResolver,
+  ...sealToteResolver
+}

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

@@ -0,0 +1,35 @@
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS } from '../../../../constants'
+import { Worksheet } from '../../../../entities'
+
+type AssignmentStatusType = { userId: string; pending?: Worksheet[]; picking: Worksheet[] }
+
+export const myPickingAssignmentStatusResolver = {
+  async myPickingAssignmentStatus(
+    _parentObj: void,
+    _params: void,
+    context: ResolverContext
+  ): Promise<AssignmentStatusType> {
+    const { domain, user } = context.state
+
+    const pickingWorksheets: Worksheet[] = await getRepository(Worksheet).find({
+      where: {
+        domain: { id: domain.id },
+        assignee: { id: user.id },
+        status: In([WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING])
+      }
+    })
+
+    return (pickingWorksheets || []).reduce(
+      (assignmentStatus: AssignmentStatusType, worksheet: Worksheet) => {
+        if (worksheet.status === WORKSHEET_STATUS.DEACTIVATED) assignmentStatus.pending.push(worksheet)
+        if (worksheet.status === WORKSHEET_STATUS.EXECUTING) assignmentStatus.picking.push(worksheet)
+        return assignmentStatus
+      },
+      { userId: user.id, pending: [], picking: [] }
+    )
+  }
+}

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

@@ -0,0 +1,96 @@
+import { getManager, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getRepository, ListParam } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
+import { Worksheet } from '../../../../entities'
+
+type AssignmentStatusByUserType = { user: User; pending?: string; picking?: string }
+
+export const pickingAssignmentStatusByUsersResolver = {
+  async pickingAssignmentStatusByUsers(
+    _: void,
+    params: ListParam,
+    context: any
+  ): Promise<AssignmentStatusByUserType[]> {
+    const { domain } = context.state
+
+    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 pendingSorter = params.sortings.find(p => {
+      return p.name == 'pending'
+    })
+    const pickingSorter = params.sortings.find(p => {
+      return p.name == 'picking'
+    })
+
+    const getUserInfoQb: SelectQueryBuilder<User> = await getRepository(User).createQueryBuilder('u')
+
+    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') : ''
+
+    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
+      } as any
+    })
+  }
+}

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

@@ -0,0 +1,55 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PickingWorksheetController } from '../../../../controllers'
+
+export const pickingResolver = {
+  async picking(
+    _: any,
+    { worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber, toteNo },
+    context: any
+  ) {
+    const { tx, domain, user } = context.state
+    await picking(
+      tx,
+      domain,
+      user,
+      worksheetDetailName,
+      worksheetType,
+      palletId,
+      locationName,
+      releaseQty,
+      binLocation,
+      serialNumber,
+      toteNo
+    )
+  }
+}
+
+export async function picking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  worksheetType: string,
+  palletId: string,
+  locationName: string,
+  releaseQty: number,
+  binLocation?: string,
+  serialNumber?: string,
+  toteNo?: string
+) {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  await worksheetController.picking(
+    worksheetDetailName,
+    worksheetType,
+    palletId,
+    locationName,
+    releaseQty,
+    binLocation,
+    serialNumber,
+    toteNo
+  )
+}

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

@@ -0,0 +1,52 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PickingWorksheetController } from '../../../../controllers'
+
+export const scanProductBatchPickingResolver = {
+  async scanProductBatchPicking(
+    _: any,
+    { taskNo, worksheetType, cartonId, productBarcode, inventory, binLocationName, pickingQty },
+    context: any
+  ) {
+    const { tx, domain, user } = context.state
+    await scanProductBatchPicking(
+      tx,
+      domain,
+      user,
+      taskNo,
+      worksheetType,
+      cartonId,
+      productBarcode,
+      inventory,
+      binLocationName,
+      pickingQty
+    )
+  }
+}
+
+export async function scanProductBatchPicking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  taskNo: string,
+  worksheetType: string,
+  cartonId: string,
+  productBarcode: string,
+  inventory: any,
+  binLocationName?: string,
+  pickingQty?: number
+) {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  await worksheetController.scanProductBatchPicking(
+    taskNo,
+    worksheetType,
+    cartonId,
+    productBarcode,
+    inventory,
+    binLocationName,
+    pickingQty
+  )
+}