@things-factory/worksheet-base 8.0.0-beta.1 → 8.0.0-beta.4

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

@@ -1,282 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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
-  )
-}