@things-factory/worksheet-base 3.7.1 → 3.7.6

package/server/controllers/outbound/picking-worksheet-controller.ts

@@ -17,7 +17,8 @@ import {
   INVENTORY_STATUS,
   INVENTORY_TRANSACTION_TYPE,
   Location,
-  LOCATION_TYPE
+  LOCATION_TYPE,
+  LOCATION_STATUS
 } from '@things-factory/warehouse-base'
 
 import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
@@ -190,7 +191,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       if (vasWorksheet) {
         await this.activateVAS(vasWorksheet.name, vasWorksheet.worksheetDetails)
       }
-    } catch (e) {}
+    } catch (e) { }
 
     const pendingSplitOIs: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
       where: { domain: this.domain, releaseGood, status: ORDER_INVENTORY_STATUS.PENDING_SPLIT }
@@ -388,104 +389,138 @@ export class PickingWorksheetController extends VasWorksheetController {
     cartonId: string,
     binLocation?: string
   ): Promise<void> {
-    let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
-      worksheetDetailName,
-      worksheetType,
-      [
-        'worksheet',
-        'worksheet.bizplace',
-        'targetInventory',
-        'targetInventory.releaseGood',
-        'targetInventory.inventory',
-        'targetInventory.product',
-        'targetInventory.product.productDetails',
-        'targetInventory.product.productDetails.product',
-        'targetInventory.product.productDetails.childProductDetail'
-      ]
-    )
+    try {
+      let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
+        worksheetDetailName,
+        worksheetType,
+        [
+          'worksheet',
+          'worksheet.bizplace',
+          'targetInventory',
+          'targetInventory.releaseGood',
+          'targetInventory.inventory',
+          'targetInventory.product',
+          'targetInventory.product.productDetails',
+          'targetInventory.product.productDetails.product',
+          'targetInventory.product.productDetails.childProductDetail'
+        ]
+      )
 
-    const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    const product: Product = targetInventory.product
-    let inventory: Inventory = targetInventory.inventory
-    const packingType: string = inventory.packingType
-    const packingSize: number = inventory.packingSize
+      const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
+      let targetInventory: OrderInventory = worksheetDetail.targetInventory
+      const product: Product = targetInventory.product
+      let inventory: Inventory = targetInventory.inventory
 
-    let pickedQty: number = 1
-    const releaseQty: number = targetInventory.releaseQty
+      //validation to prevent over release
+      if (inventory.qty <= 0)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
 
-    if (inventory.cartonId !== cartonId)
-      throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Carton ID', cartonId, inventory.cartonId))
+      const packingType: string = inventory.packingType
+      const packingSize: number = inventory.packingSize
 
-    // search for matching product barcode
-    const productDetails: ProductDetail[] = product?.productDetails.filter(detail => !detail.deletedAt)
-    const isMatchingBarcode: boolean = productDetails.map(detail => detail.gtin).includes(productBarcode)
-    if (!isMatchingBarcode) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+      let pickedQty: number = 1
+      const releaseQty: number = targetInventory.releaseQty
 
-    // case for scanning parent packing type, packing size
-    const foundProductDetail: ProductDetail = productDetails.find(
-      (detail: ProductDetail) =>
-        detail.gtin === productBarcode &&
-        detail.packingType === packingType &&
-        detail.packingSize == packingSize &&
-        detail.product?.id === product.id
-    )
+      // bin picking validation
+      const binPickingSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+        where: {
+          domain: this.domain,
+          name: 'enable-bin-picking'
+        }
+      })
+      if (binPickingSetting != undefined && (binPickingSetting.value).toLowerCase() == 'true') {
+        if (binLocation) {
+          const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+            where: { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN }
+          })
 
-    if (!foundProductDetail) {
-      const roProductDetail: ProductDetail = productDetails.find(
-        (parentDetail: ProductDetail) =>
-          parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
-      )
+          if (!foundBinLocation)
+            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
 
-      pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
-      if (pickedQty > releaseQty) {
-        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
-      }
-    }
+          targetInventory.binLocation = foundBinLocation
 
-    targetInventory.pickedQty = Boolean(targetInventory?.pickedQty) ? targetInventory.pickedQty + pickedQty : pickedQty
-    if (targetInventory.pickedQty == releaseQty) {
-      const leftQty: number = inventory.qty - releaseQty
-      if (leftQty < 0) {
-        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`))
+          //// Temporarily disable Bin Usage Tracking
+          // await this.trxMgr.getRepository(Location).update(
+          //   { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN },
+          //   { status: LOCATION_STATUS.OCCUPIED }
+          // )
+        } else {
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+        }
       }
 
-      targetInventory.status = ORDER_INVENTORY_STATUS.PICKED
-
-      if (binLocation) {
-        const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
-          where: { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN }
-        })
+      if (inventory.cartonId !== cartonId)
+        throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Carton ID', cartonId, inventory.cartonId))
+
+      // search for matching product barcode
+      const productDetails: ProductDetail[] = product?.productDetails.filter(detail => !detail.deletedAt)
+      const isMatchingBarcode: boolean = productDetails.map(detail => detail.gtin).includes(productBarcode)
+      if (!isMatchingBarcode) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+
+      // case for scanning parent packing type, packing size
+      const foundProductDetail: ProductDetail = productDetails.find(
+        (detail: ProductDetail) =>
+          detail.gtin === productBarcode &&
+          detail.packingType === packingType &&
+          detail.packingSize == packingSize &&
+          detail.product?.id === product.id
+      )
 
-        if (!foundBinLocation)
-          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+      if (!foundProductDetail) {
+        const roProductDetail: ProductDetail = productDetails.find(
+          (parentDetail: ProductDetail) =>
+            parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
+        )
 
-        targetInventory.binLocation = foundBinLocation
+        pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
+        if (pickedQty > releaseQty) {
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
+        }
       }
-      await this.updateOrderTargets([targetInventory])
+      console.log('')
 
-      inventory.qty -= targetInventory.releaseQty
-      inventory.uomValue = Math.round((inventory.uomValue - targetInventory.releaseUomValue) * 100) / 100
-      inventory.lockedQty = inventory.lockedQty - targetInventory.releaseQty
-      inventory.lockedUomValue = Math.round((inventory.lockedUomValue - targetInventory.releaseUomValue) * 100) / 100
-      inventory = await this.transactionInventory(
-        inventory,
-        releaseGood,
-        -targetInventory.releaseQty,
-        -targetInventory.releaseUomValue,
-        INVENTORY_TRANSACTION_TYPE.PICKING
-      )
+      targetInventory.pickedQty = Boolean(targetInventory?.pickedQty) ? targetInventory.pickedQty + pickedQty : pickedQty
+      if (targetInventory.pickedQty == releaseQty) {
+        const leftQty: number = inventory.qty - releaseQty
+        if (leftQty < 0) {
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`))
+        }
 
-      worksheetDetail.status = WORKSHEET_STATUS.DONE
-      worksheetDetail.updater = this.user
-      await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+        targetInventory.status = ORDER_INVENTORY_STATUS.PICKED
+
+        inventory.qty -= targetInventory.releaseQty
+        inventory.uomValue = Math.round((inventory.uomValue - targetInventory.releaseUomValue) * 100) / 100
+        inventory.lockedQty = inventory.lockedQty - targetInventory.releaseQty
+        inventory.lockedUomValue = Math.round((inventory.lockedUomValue - targetInventory.releaseUomValue) * 100) / 100
+        inventory = await this.transactionInventory(
+          inventory,
+          releaseGood,
+          -targetInventory.releaseQty,
+          -targetInventory.releaseUomValue,
+          INVENTORY_TRANSACTION_TYPE.PICKING
+        )
 
-      if (leftQty === 0) {
-        inventory.status = INVENTORY_STATUS.TERMINATED
-        await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+        worksheetDetail.status = WORKSHEET_STATUS.DONE
+        worksheetDetail.updater = this.user
+        await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+        if (leftQty === 0) {
+          inventory.status = INVENTORY_STATUS.TERMINATED
+          await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+        }
       }
-    } else {
+
+      //validation to prevent duplicated picking      
+      let oiValidate: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
+        where: { domain: this.domain, id: targetInventory.id, status: ORDER_INVENTORY_STATUS.PICKING }
+      })
+      if (!oiValidate)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`))
+
       await this.updateOrderTargets([targetInventory])
+
+    } catch (error) {
+      throw error
     }
   }
 
@@ -494,7 +529,8 @@ export class PickingWorksheetController extends VasWorksheetController {
     worksheetType: string,
     palletId: string,
     locationName: string,
-    releaseQty: number
+    releaseQty: number,
+    binLocation?: string
   ): Promise<void> {
     let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
       worksheetDetailName,
@@ -518,6 +554,35 @@ export class PickingWorksheetController extends VasWorksheetController {
       throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`))
     }
 
+
+    // bin picking validation
+    const binPickingSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+      where: {
+        domain: this.domain,
+        name: 'enable-bin-picking'
+      }
+    })
+    if (binPickingSetting != undefined && (binPickingSetting.value).toLowerCase() == 'true') {
+      if (binLocation) {
+        const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+          where: { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN }
+        })
+
+        if (!foundBinLocation)
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+
+        targetInventory.binLocation = foundBinLocation
+
+        //// Temporarily disable Bin Usage Tracking
+        // await this.trxMgr.getRepository(Location).update(
+        //   { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN },
+        //   { status: LOCATION_STATUS.OCCUPIED }
+        // )
+      } else {
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+      }
+    }
+
     targetInventory.pickedQty = releaseQty
     targetInventory.status = ORDER_INVENTORY_STATUS.PICKED
     await this.updateOrderTargets([targetInventory])

package/server/controllers/worksheet-controller.ts

@@ -555,6 +555,44 @@ export class WorksheetController {
     return worksheet
   }
 
+  // @chernhaoee I think the naming of this function is not proper. Seems like it should be something like "updateLoadingWorksheet" since the logic targets only Loading Order Target
+  async updateWorksheet(
+    worksheetType: string,
+    refOrder: ReferenceOrderType,
+    worksheet: Worksheet,
+    orderTargets: OrderTargetTypes[],
+    refOrderStatus: string,
+    orderTargetStatus: string,
+  ): Promise<Worksheet> {
+    let newOrderTarget = []
+
+    orderTargets.forEach((orderTarget: OrderTargetTypes) => {
+      orderTarget.status = orderTargetStatus
+    })
+    orderTargets = await this.updateOrderTargets(orderTargets)
+
+    for (let orderTarget of orderTargets) {
+      try {
+        await this.findWorksheetDetail({
+          targetInventory: orderTarget.id,
+          type: WORKSHEET_TYPE.LOADING
+        })
+      } catch (e) {
+        newOrderTarget.push(orderTarget)
+      }
+    }
+
+    worksheet.worksheetDetails = await this.createWorksheetDetails(worksheet, worksheetType, newOrderTarget)
+
+    // find worksheet details that doesnt exist based on order inventory
+    //worksheet.worksheetDetails = await this.findWorksheetDetail(worksheet.id)
+
+    refOrder.status = refOrderStatus
+    await this.updateRefOrder(refOrder)
+
+    return worksheet
+  }
+
   async generateBatchWorksheet(
     worksheetType: string,
     batchPickingWorksheet: Worksheet,
@@ -928,13 +966,13 @@ export class WorksheetController {
       )
       if (!currentProductDetail)
         throw new Error(this.ERROR_MSG.FIND.NOT_MATCH('inner pack', `GTIN (${productBarcode})`))
-      childQty = scannedProductDetail.childQty
+      childQty = scannedProductDetail.packingSize
     } else {
       throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
     }
 
     if (hasMatchingChild) {
-      childQty = scannedProductDetail.childQty
+      childQty = scannedProductDetail.packingSize
     } else {
       while (hasChildRelation && !hasMatchingChild) {
         hasChildRelation = Boolean(currentProductDetail?.childProductDetail)

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

@@ -1,7 +1,9 @@
-import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { Equal, getRepository, In, Not } from 'typeorm'
+
+import { ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { Equal, getRepository, Not } from 'typeorm'
+import { Inventory, Location } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { fetchExecutingWorksheet } from '../../../utils'
@@ -9,11 +11,37 @@ import { fetchExecutingWorksheet } from '../../../utils'
 export const loadingWorksheetResolver = {
   async loadingWorksheet(_: any, { releaseGoodNo }, context: any) {
     const { domain }: { domain: Domain } = context.state
-    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+    let releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
       where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.LOADING*/ },
       relations: ['bizplace']
     })
 
+    // Find Release Order based on Bin
+    if (!releaseGood) {
+      const binLocation: Location = await getRepository(Location).findOne({
+        where: { domain, name: releaseGoodNo }
+      })
+
+      const orderInventoryByBin: OrderInventory = await getRepository(OrderInventory).findOne({
+        where: {
+          domain, binLocation, status: In([ORDER_INVENTORY_STATUS.LOADING, ORDER_INVENTORY_STATUS.LOADED])
+        },
+        order: {
+          createdAt: 'ASC'
+        },
+        relations: [
+          'releaseGood',
+          'releaseGood.bizplace',
+          'releaseGood.bizplace.domain'
+        ]
+      })
+
+      if (orderInventoryByBin?.releaseGood) {
+        releaseGoodNo = orderInventoryByBin.releaseGood.name
+        releaseGood = orderInventoryByBin.releaseGood
+      }
+    }
+
     if (!releaseGood) throw new Error(`Release good doesn't exists.`)
 
     const foundWorksheet: Worksheet = await fetchExecutingWorksheet(
@@ -40,6 +68,7 @@ export const loadingWorksheetResolver = {
 
     return {
       worksheetInfo: {
+        releaseGood,
         bizplaceName: releaseGood.bizplace.name,
         startedAt: foundWorksheet.startedAt,
         refNo: releaseGood.refNo,

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

@@ -1,11 +1,11 @@
-import { EntityManager } from 'typeorm'
+import { EntityManager, In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { MarketplaceOrder, MarketplaceOrderItem, MarketplaceOrderShipping } from '@things-factory/marketplace-base'
-import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
+import { Inventory, Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_TYPE } from '../../../constants'
 import { SellercraftController } from '../../../controllers'
@@ -23,7 +23,34 @@ export const packingWorksheetResolver = {
       relations: ['bizplace', 'bizplace.domain']
     })
 
+    // Find Release Order based on Bin
+    if (!releaseGood) {
+      const binLocation: Location = await tx.getRepository(Location).findOne({
+        where: { domain, name: releaseGoodNo }
+      })
+
+      const orderInventoryByBin: OrderInventory = await tx.getRepository(OrderInventory).findOne({
+        where: {
+          domain, binLocation, status: In([ORDER_INVENTORY_STATUS.PACKING, ORDER_INVENTORY_STATUS.PACKED])
+        },
+        order: {
+          createdAt: 'ASC'
+        },
+        relations: [
+          'releaseGood',
+          'releaseGood.bizplace',
+          'releaseGood.bizplace.domain'
+        ]
+      })
+
+      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,
@@ -110,6 +137,7 @@ export const packingWorksheetResolver = {
 
     return {
       worksheetInfo: {
+        releaseGood,
         bizplaceName: releaseGood.bizplace.name,
         refNo: releaseGood.refNo,
         refNo2: releaseGood.refNo2,

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

@@ -19,6 +19,7 @@ import {
 import { EcommerceController } from '../../../../controllers/ecommerce'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
+import { Setting, PartnerSetting } from '@things-factory/setting-base'
 
 export const completePickingResolver = {
   async completePicking(_: any, { releaseGoodNo }, context: any) {
@@ -187,10 +188,30 @@ export async function completePicking(
 
   if (releaseGood.packingOption) {
     const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-    await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+
+    const directActivatePackingWorksheet: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain: domain, category: 'id-rule', name: 'enable-direct-activate-packing-worksheet' }
+    })
+    const partnerDirectActivatePackingWorksheetSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
+      where: { setting: directActivatePackingWorksheet, domain: domain, partnerDomain: releaseGood.bizplace?.domain }
+    })
+
+    let packingWorksheet: Worksheet = await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+
+    if (
+      directActivatePackingWorksheet != undefined && (directActivatePackingWorksheet.value).toLowerCase() == 'true'
+    ) {
+      if (partnerDirectActivatePackingWorksheetSetting != undefined) {
+        if ((partnerDirectActivatePackingWorksheetSetting.value).toLowerCase() == 'true')
+          await packingWSCtrl.activatePacking(packingWorksheet.name)
+      } else {
+        await packingWSCtrl.activatePacking(packingWorksheet.name)
+      }
+    }
+
   } else {
     // Find Existing Loading Worksheet if any
-    const existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+    let existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
       where: {
         releaseGood,
         type: WORKSHEET_TYPE.LOADING,
@@ -211,10 +232,21 @@ export async function completePicking(
 
       const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
       await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
-    } else {
-      throw new Error(
-        'Picking completion has been triggered twice, loading worksheet has been generated. Kindly proceed to loading.'
+    }
+    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,78 @@
+import { EntityManager, getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-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: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const assignee: User = await tx.getRepository(User).findOne(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
+    worksheet = await tx.getRepository(Worksheet).findOne({
+      relations: ['releaseGood'],
+      where: [
+        {
+          domain,
+          type: WORKSHEET_TYPE.PICKING,
+          status: WORKSHEET_STATUS.EXECUTING,
+          assignee: assignee
+        },
+        {
+          domain,
+          type: WORKSHEET_TYPE.PICKING,
+          status: WORKSHEET_STATUS.DEACTIVATED,
+          assignee: assignee
+        }
+      ],
+      order: {
+        name: 'ASC'
+      }
+    })
+
+    if (!worksheet) {
+      worksheet = await tx.getRepository(Worksheet).findOne({
+        relations: ['releaseGood'],
+        where: [
+          {
+            domain,
+            type: WORKSHEET_TYPE.PICKING,
+            status: WORKSHEET_STATUS.EXECUTING,
+            assignee: null
+          },
+          {
+            domain,
+            type: WORKSHEET_TYPE.PICKING,
+            status: WORKSHEET_STATUS.DEACTIVATED,
+            assignee: null
+          }
+        ]
+      })
+
+      await getRepository(Worksheet).update({ id: worksheet.id }, { assignee: assignee })
+    }
+
+    if (worksheet.status == WORKSHEET_STATUS.DEACTIVATED) await activatePicking(tx, domain, user, worksheet.name)
+
+    const locationSortingRules: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain, 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' }
+    })
+
+    return await pickingWorksheet(domain, worksheet.releaseGood.name, locationSortingRule, tx)
+  }
+}

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

@@ -2,6 +2,7 @@ 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'
@@ -21,5 +22,6 @@ export const Mutations = {
   ...batchPickingResolver,
   ...completePickingResolver,
   ...completeBatchPickingResolver,
-  ...assignPickingWorkerResolver
+  ...assignPickingWorkerResolver,
+  ...fetchAndAssignPickingTaskResolver
 }

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

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