@things-factory/worksheet-base 4.3.248 → 4.3.250

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

@@ -7,6 +7,7 @@ import { generateId } from '@things-factory/id-rule-base'
 import { Powrup } from '@things-factory/integration-powrup'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { Product, ProductBarcode, ProductDetail } from '@things-factory/product-base'
+
 import {
   GenerateBatchPickInfo,
   ORDER_INVENTORY_STATUS,
@@ -20,6 +21,8 @@ import {
   OrderToteSeal,
   OrderVas,
   ReleaseGood,
+  InventoryUtil,
+  ORDER_TYPES,
   PowrupController
 } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
@@ -34,13 +37,14 @@ import {
   Location,
   LOCATION_TYPE,
   Tote,
-  TOTE_STATUS
+  TOTE_STATUS,
+  ProductDetailStock
 } from '@things-factory/warehouse-base'
 
 import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
 import { SellercraftController } from '../../controllers'
 import { Worksheet, WorksheetDetail } from '../../entities'
-import { isInventoryObsolete, WorksheetNoGenerator } from '../../utils'
+import { isInventoryObsolete, WorksheetNoGenerator, inventoriesByStrategy } from '../../utils'
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 
 export class PickingWorksheetController extends VasWorksheetController {
@@ -113,6 +117,10 @@ export class PickingWorksheetController extends VasWorksheetController {
         })
       })
 
+      const worksheetPickingAssignment: Setting = await this.trxMgr.getRepository(Setting).findOne({
+        where: { domain: this.domain, category: 'id-rule', name: 'enable-worksheet-picking-activation-assignment' }
+      })
+
       const worksheetSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
         where: {
           domain: this.domain,
@@ -136,24 +144,42 @@ export class PickingWorksheetController extends VasWorksheetController {
       worksheet.updater = this.user
       worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
 
-      if (orderInventories.some((oi: OrderInventory) => oi.inventory?.id)) {
-        const hasInventoryOIs: OrderInventory[] = orderInventories.filter(
-          (orderInventory: OrderInventory) => orderInventory.inventory !== null
-        )
+      if (orderInventories?.length > 0) {
+        if (orderInventories.some((oi: OrderInventory) => oi.inventory?.id)) {
+          const hasInventoryOIs: OrderInventory[] = orderInventories.filter(
+            (orderInventory: OrderInventory) => orderInventory.inventory !== null
+          )
 
-        worksheet.worksheetDetails = await this.createWorksheetDetails(
-          worksheet,
-          WORKSHEET_TYPE.BATCH_PICKING,
-          hasInventoryOIs
-        )
-      }
+          worksheet.worksheetDetails = await this.createWorksheetDetails(
+            worksheet,
+            WORKSHEET_TYPE.BATCH_PICKING,
+            hasInventoryOIs
+          )
+        }
 
-      orderInventories.forEach((oi: OrderInventory) => {
-        oi.refWorksheetId = worksheet.id
-        oi.status = oi.inventory?.id ? ORDER_INVENTORY_STATUS.READY_TO_PICK : ORDER_INVENTORY_STATUS.PENDING_SPLIT
-        oi.updater = this.user
-      })
-      await this.updateOrderTargets(orderInventories)
+        orderInventories.forEach((oi: OrderInventory) => {
+          oi.refWorksheetId = worksheet.id
+          oi.status = oi.inventory?.id ? ORDER_INVENTORY_STATUS.READY_TO_PICK : ORDER_INVENTORY_STATUS.PENDING_SPLIT
+          oi.updater = this.user
+        })
+
+        await this.updateOrderTargets(orderInventories)
+      } else {
+        let orderProducts: OrderProduct[] = []
+        releaseGoods.map((releaseGood: ReleaseGood) => {
+          const foundOPs: OrderProduct[] = releaseGood.orderProducts
+          foundOPs.map((op: OrderProduct) => {
+            orderProducts.push(op)
+          })
+        })
+        if (worksheetPickingAssignment && orderProducts?.length > 0) {
+          worksheet.worksheetDetails = await this.createWorksheetDetails(
+            worksheet,
+            WORKSHEET_TYPE.BATCH_PICKING,
+            orderProducts
+          )
+        }
+      }
 
       releaseGoods = releaseGoods.map((releaseGood: ReleaseGood) => {
         return {
@@ -192,6 +218,9 @@ export class PickingWorksheetController extends VasWorksheetController {
       'releaseGood.domain',
       'releaseGood.lastMileDelivery',
       'releaseGood.bizplace.domain',
+      'releaseGood.orderProducts',
+      'releaseGood.orderProducts.productDetail',
+      'releaseGood.orderProducts.productDetail.product',
       'releaseGood.orderPackages',
       'releaseGood.orderPackages.orderPackageItems',
       'releaseGood.orderPackages.orderPackageItems.orderProduct',
@@ -206,17 +235,25 @@ export class PickingWorksheetController extends VasWorksheetController {
       'worksheetDetails.targetInventory.product'
     ])
 
-    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED')
-    const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
-      let targetInventory: OrderInventory = wsd.targetInventory
-      targetInventory.status = ORDER_INVENTORY_STATUS.PICKING
-      targetInventory.updater = this.user
+    let worksheetDetails: WorksheetDetail[]
+    let releaseGood: ReleaseGood = worksheet.releaseGood
 
-      return targetInventory
-    })
-    this.updateOrderTargets(targetInventories)
+    // assign inventory if unassigned
+    if (!releaseGood.assignedInventory) {
+      worksheetDetails = await this.assignInventoriesForUnassignedOrder(worksheet)
+      worksheet.worksheetDetails = worksheetDetails
+      releaseGood.assignedInventory = true
+    } else {
+      worksheetDetails = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED')
+      const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
+        let targetInventory: OrderInventory = wsd.targetInventory
+        targetInventory.status = ORDER_INVENTORY_STATUS.PICKING
+        targetInventory.updater = this.user
 
-    let releaseGood: ReleaseGood = worksheet.releaseGood
+        return targetInventory
+      })
+      this.updateOrderTargets(targetInventories)
+    }
     releaseGood.status = ORDER_STATUS.PICKING
     releaseGood.updater = this.user
     this.updateRefOrder(releaseGood)
@@ -311,6 +348,11 @@ export class PickingWorksheetController extends VasWorksheetController {
   async activateBatchPicking(worksheetNo: string): Promise<Worksheet> {
     let worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.BATCH_PICKING, [
       'worksheetDetails',
+      'worksheetDetails.targetProduct',
+      'worksheetDetails.targetProduct.bizplace',
+      'worksheetDetails.targetProduct.product',
+      'worksheetDetails.targetProduct.productDetail',
+      'worksheetDetails.targetProduct.releaseGood',
       'worksheetDetails.targetInventory',
       'worksheetDetails.targetInventory.releaseGood',
       'worksheetDetails.targetInventory.releaseGood.domain',
@@ -321,15 +363,21 @@ export class PickingWorksheetController extends VasWorksheetController {
       'bizplace.company.domain'
     ])
 
-    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED')
-    const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
-      let targetInventory: OrderInventory = wsd.targetInventory
-      targetInventory.status = ORDER_INVENTORY_STATUS.PICKING
-      targetInventory.updater = this.user
+    let worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED')
 
-      return targetInventory
-    })
-    this.updateOrderTargets(targetInventories)
+    if (worksheet.worksheetDetails.find(wsd => wsd.targetProduct?.releaseGood?.assignedInventory == false)) {
+      worksheetDetails = await this.assignInventoriesForUnassignedMergedOrder(worksheet)
+      worksheet.worksheetDetails = worksheetDetails
+    } else {
+      const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
+        let targetInventory: OrderInventory = wsd.targetInventory
+        targetInventory.status = ORDER_INVENTORY_STATUS.PICKING
+        targetInventory.updater = this.user
+
+        return targetInventory
+      })
+      this.updateOrderTargets(targetInventories)
+    }
 
     worksheet = await this.activateWorksheet(worksheet, worksheetDetails, [])
 
@@ -419,7 +467,8 @@ export class PickingWorksheetController extends VasWorksheetController {
           return {
             ...releaseGood,
             status: ORDER_STATUS.PICKING,
-            updater: this.user
+            updater: this.user,
+            assignedInventory: true
           }
         })
       )
@@ -1970,4 +2019,247 @@ export class PickingWorksheetController extends VasWorksheetController {
       })
     }
   }
+
+  async assignInventoriesForUnassignedOrder(worksheet: Worksheet): Promise<any> {
+    const releaseGood = worksheet.releaseGood
+    const orderProducts = releaseGood.orderProducts
+    let finalOrderInventories: OrderInventory[] = []
+    let newWorksheetDetails: WorksheetDetail[] = []
+    const inventoryAssignmentSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+      where: { domain: this.domain, name: 'rule-for-inventory-assignment' }
+    })
+
+    for (let op of orderProducts) {
+      let locationSortingRules = []
+      if (inventoryAssignmentSetting) {
+        let locationSetting = JSON.parse(inventoryAssignmentSetting.value)
+        for (const key in locationSetting) {
+          locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
+        }
+      }
+
+      let assignedOrderInventories: OrderInventory[] = await InventoryUtil.autoAssignInventoryForRelease(
+        op,
+        op.productDetail.product,
+        op.productDetail,
+        locationSortingRules,
+        releaseGood.bizplace,
+        this.domain,
+        this.trxMgr,
+        op.batchId
+      )
+
+      assignedOrderInventories = assignedOrderInventories.map(aoi => {
+        delete aoi.id
+        return {
+          ...aoi,
+          orderProduct: op,
+          status: ORDER_INVENTORY_STATUS.PICKING,
+          name: OrderNoGenerator.orderInventory(),
+          domain: this.domain,
+          bizplace: { id: releaseGood.bizplace.id },
+          releaseGood
+        }
+      })
+
+      finalOrderInventories.push(...assignedOrderInventories)
+
+      await this.trxMgr
+        .getRepository(OrderProduct)
+        .update({ id: op.id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: this.user })
+    }
+
+    for (let oi of finalOrderInventories) {
+      // update inventory locked qty and uom value
+      oi = await this.trxMgr.getRepository(OrderInventory).save({ ...oi })
+
+      await this.trxMgr.getRepository(Inventory).update(oi.inventory.id, {
+        lockedQty: (oi.inventory?.lockedQty || 0) + oi.releaseQty,
+        lockedUomValue: (oi.inventory?.lockedUomValue || 0) + oi.releaseUomValue,
+        updater: this.user
+      })
+
+      // update product detail stock deduct unassigned qty and unassigned uom value
+      await this.trxMgr
+        .getRepository(ProductDetailStock)
+        .createQueryBuilder()
+        .update(ProductDetailStock)
+        .set({
+          unassignedQty: () => `"unassigned_qty" - ${oi.releaseQty}`,
+          unassignedUomValue: () => `"unassigned_uom_value" - ${oi.releaseUomValue}`
+        })
+        .where({ productDetail: oi.productDetail.id })
+        .execute()
+
+      const worksheetDetail: WorksheetDetail = Object.assign(new WorksheetDetail(), {
+        domain: this.domain,
+        bizplace: { id: releaseGood.bizplace.id },
+        worksheet,
+        name: WorksheetNoGenerator.pickingDetail(),
+        seq: 0,
+        targetInventory: oi,
+        targetProduct: oi.orderProduct,
+        type: WORKSHEET_TYPE.PICKING,
+        status: WORKSHEET_STATUS.DEACTIVATED,
+        creator: this.user,
+        updater: this.user
+      })
+
+      newWorksheetDetails.push(worksheetDetail)
+    }
+    newWorksheetDetails = await this.trxMgr.getRepository(WorksheetDetail).save(newWorksheetDetails)
+
+    return newWorksheetDetails
+  }
+
+  async assignInventoriesForUnassignedMergedOrder(worksheet: Worksheet): Promise<any> {
+    //const releaseGood = worksheet.releaseGood
+    const orderProducts = worksheet.worksheetDetails
+      .filter(itm => itm.targetProduct.releaseGood.assignedInventory == false)
+      .map(wsd => wsd.targetProduct)
+    const releaseGoodIds = [...new Set(orderProducts.map(op => op.releaseGood.id))]
+    let newWorksheetDetails: WorksheetDetail[] = []
+
+    const inventoryAssignmentSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+      where: { domain: this.domain, name: 'rule-for-inventory-assignment' }
+    })
+
+    for (let i = 0; i < orderProducts.length; i++) {
+      let pInventoryList = inventoriesByStrategy(
+        {
+          ...orderProducts[i],
+          worksheetId: worksheet.id,
+          bizplaceId: worksheet.bizplace.id,
+          locationSortingRules: inventoryAssignmentSetting ? JSON.parse(inventoryAssignmentSetting.value) : false,
+          pickingStrategy: orderProducts[i].product.pickingStrategy
+        },
+        this.domain,
+        this.trxMgr
+      )
+
+      let idx = 0
+      let [inventoryList] = await Promise.all([pInventoryList])
+
+      let { releaseQty, releaseUomValue } = orderProducts[i]
+
+      while (releaseQty > 0 && idx < inventoryList.items.length) {
+        let targetInventory: Inventory = await this.trxMgr
+          .getRepository(Inventory)
+          .findOne({ where: { id: inventoryList.items[idx].id } })
+
+        let inventoryAvailableQty = targetInventory.qty - (targetInventory?.lockedQty || 0)
+        let inventoryAvailableUomValue = targetInventory.uomValue - (targetInventory?.lockedUomValue || 0)
+
+        if (inventoryAvailableQty > 0) {
+          let allocatedQty = 0,
+            allocatedUomValue = 0
+          if (inventoryAvailableQty < releaseQty) {
+            idx = idx + 1
+            allocatedQty = inventoryAvailableQty
+            allocatedUomValue = inventoryAvailableUomValue
+          } else {
+            allocatedQty = releaseQty
+            allocatedUomValue = releaseUomValue
+          }
+
+          releaseQty = releaseQty - allocatedQty
+          releaseUomValue = releaseUomValue - allocatedUomValue
+
+          //// Update inventory locked quantity
+          await this.trxMgr
+            .getRepository(Inventory)
+            .createQueryBuilder('inv')
+            .update(Inventory)
+            .set({
+              lockedUomValue: () => `COALESCE(locked_uom_value,0) + ${allocatedUomValue}`,
+              lockedQty: () => `COALESCE(locked_qty,0) + ${allocatedQty}`
+            })
+            .where('id = :id', { id: targetInventory.id })
+            .execute()
+
+          // update product detail stock deduct unassigned qty and unassigned uom value
+          await this.trxMgr
+            .getRepository(ProductDetailStock)
+            .createQueryBuilder()
+            .update(ProductDetailStock)
+            .set({
+              unassignedQty: () => `"unassigned_qty" - ${allocatedQty}`,
+              unassignedUomValue: () => `"unassigned_uom_value" - ${allocatedUomValue}`
+            })
+            .where({ productDetail: orderProducts[i].productDetail.id })
+            .execute()
+
+          // update order product status to ASSIGNED
+          await this.trxMgr
+            .getRepository(OrderProduct)
+            .update({ id: orderProducts[i].id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: this.user })
+
+          // Create new order inventory with status -> READY_TO_PICK, type -> RELEASE_OF_GOODS
+          let newTargetInventory: OrderInventory = new OrderInventory()
+          newTargetInventory = {
+            domain: this.domain,
+            bizplace: orderProducts[i].bizplace,
+            name: OrderNoGenerator.orderInventory(),
+            releaseGood: orderProducts[i].releaseGood,
+            batchId: orderProducts[i].batchId,
+            status: ORDER_INVENTORY_STATUS.PICKING,
+            type: ORDER_TYPES.RELEASE_OF_GOODS,
+            refWorksheetId: worksheet.id,
+            product: orderProducts[i].product,
+            productDetail: orderProducts[i].productDetail,
+            packingType: orderProducts[i].packingType,
+            packingSize: parseFloat(orderProducts[i].packingSize),
+            creator: this.user,
+            inventory: targetInventory,
+            releaseQty: allocatedQty,
+            releaseUomValue: allocatedUomValue,
+            uom: orderProducts[i].uom,
+            orderProduct: orderProducts[i]
+          }
+          newTargetInventory = await this.trxMgr.getRepository(OrderInventory).save(newTargetInventory)
+
+          if (idx == 0) {
+            let updatedWorksheetDetail = {
+              ...worksheet.worksheetDetails[i],
+              targetInventory: newTargetInventory,
+              worksheet,
+              bizplace: worksheet.bizplace,
+              domain: this.domain,
+              updater: this.user,
+              creator: this.user
+            }
+            await this.trxMgr.getRepository(WorksheetDetail).update(worksheet.worksheetDetails[i].id, {
+              targetInventory: newTargetInventory,
+              worksheet,
+              bizplace: worksheet.bizplace,
+              domain: this.domain,
+              updater: this.user,
+              creator: this.user
+            })
+
+            newWorksheetDetails.push(updatedWorksheetDetail)
+          } else {
+            let newWorksheetDetail = {
+              ...worksheet.worksheetDetails[i],
+              name: WorksheetNoGenerator.batchPickingDetail(),
+              targetInventory: newTargetInventory,
+              worksheet,
+              bizplace: worksheet.bizplace,
+              domain: this.domain,
+              updater: this.user,
+              creator: this.user
+            }
+            delete newWorksheetDetail.id
+
+            newWorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).save(newWorksheetDetail)
+            newWorksheetDetails.push(newWorksheetDetail)
+          }
+        } else {
+          idx = idx + 1
+        }
+      }
+      await this.trxMgr.getRepository(ReleaseGood).update(releaseGoodIds, { assignedInventory: true })
+    }
+    return newWorksheetDetails
+  }
 }

package/server/entities/warehouse-bizplace-onhand-inventory.ts

@@ -12,8 +12,8 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     i.uom,
     i.product_id as "product_id",
     null as "product_bundle_id",
-    COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0))) AS "remain_qty",
-    COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0))) AS "remain_uom_value",
+    COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - SUM(COALESCE(pds.unassigned_qty, 0))) AS "remain_qty",
+    COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value, 0))) AS "remain_uom_value",
     COALESCE(sum(COALESCE(i.qty, 0::double precision))) AS "qty",
     COALESCE(sum(COALESCE(i.uom_value, 0::double precision))) AS "uom_value",
     COALESCE(sum(COALESCE(i.transfer_qty, 0::double precision))) AS "transfer_qty",
@@ -22,6 +22,7 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     FROM inventories i
     INNER JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id AND l2.type NOT IN ('QUARANTINE', 'RESERVE')
     INNER JOIN products p ON p.id = i.product_id
+    LEFT JOIN product_detail_stocks pds on pds.product_detail_id = i.product_detail_id
     WHERE i.status = 'STORED' AND CASE WHEN i.expiration_date is not null and p.shelf_life is not null then CURRENT_DATE < i.expiration_date - p.shelf_life else true end
     AND i.obsolete is false
     GROUP by
@@ -51,14 +52,15 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     FROM product_bundles pb
     INNER JOIN (
       SELECT i.domain_id, i.bizplace_id, pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
-      (SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0))) / min(pbs.bundle_qty) AS "available_qty",
-      (SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0))) / min(pbs.bundle_qty)  AS "available_uom_value",
+      (SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - SUM(COALESCE(pds.unassigned_qty, 0))) / min(pbs.bundle_qty) AS "available_qty",
+      (SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value, 0))) / min(pbs.bundle_qty)  AS "available_uom_value",
       (sum(COALESCE(i.qty, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "qty",
       (sum(COALESCE(i.uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "uom_value",
       (sum(COALESCE(i.transfer_qty, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "transfer_qty",
       (sum(COALESCE(i.transfer_uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "transfer_uom_value"
       FROM product_bundle_settings pbs 
       LEFT JOIN inventories i ON i.product_id = pbs.product_id AND i.status = 'STORED' AND i.obsolete = false
+      LEFT JOIN product_detail_stocks pds ON pds.product_detail_id = i.product_detail_id
       INNER JOIN products p ON p.id = pbs.product_id AND CASE WHEN i.expiration_date is not null and p.shelf_life is not null then CURRENT_DATE < i.expiration_date - p.shelf_life else true end
       INNER JOIN locations l ON i.location_id = l.id AND i.domain_id = l.domain_id AND l.type NOT IN ('QUARANTINE', 'RESERVE') 
       GROUP by

package/server/graphql/resolvers/worksheet/inventories-by-pallet.ts

@@ -1,28 +1,17 @@
-import {
-  Brackets,
-  getRepository,
-  SelectQueryBuilder
-} from 'typeorm'
+import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
-import {
-  buildCondition,
-  buildQuery,
-  Domain
-} from '@things-factory/shell'
-import {
-  Inventory,
-  LOCATION_TYPE
-} from '@things-factory/warehouse-base'
+import { buildCondition, buildQuery, Domain } from '@things-factory/shell'
+import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
 
 export const inventoriesByPalletResolver = {
   async inventoriesByPallet(_: any, { filters, pagination, sortings, locationSortingRules }, context: any) {
     const { domain, user }: { domain: Domain; user: User } = context.state
     const params = { filters, pagination }
     let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
-    const bizplaceId =  params.filters.find(x => x.name == 'bizplace_id')
+    const bizplaceId = params.filters.find(x => x.name == 'bizplace_id')
     const productFilters = params.filters.filter(x => x.name == 'productName')
     const recallFilters = params.filters.find(x => x.name === 'recall')
     const skipLockCheckFilters = params.filters.find(x => x.name === 'skipLockCheck')
@@ -46,6 +35,7 @@ export const inventoriesByPalletResolver = {
       .leftJoinAndSelect('iv.bizplace', 'bizplace')
       .leftJoinAndSelect('iv.product', 'product')
       .leftJoinAndSelect('iv.productDetail', 'productDetail')
+      .leftJoin('product_detail_stocks', 'pds', 'pds.product_detail_id = iv.product_detail_id')
       .leftJoinAndSelect('iv.warehouse', 'warehouse')
       .leftJoinAndSelect('iv.location', 'location')
       .leftJoinAndSelect('iv.creator', 'creator')
@@ -54,7 +44,9 @@ export const inventoriesByPalletResolver = {
       .andWhere('iv.transfer_qty <= 0')
       .andWhere('iv.transfer_uom_value <= 0')
       .andWhere(
-        `location.type ${recallFilters?.value === true ? '' : 'NOT'} IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}', '${LOCATION_TYPE.DAMAGE}')`
+        `location.type ${recallFilters?.value === true ? '' : 'NOT'} IN ('${LOCATION_TYPE.QUARANTINE}', '${
+          LOCATION_TYPE.RESERVE
+        }', '${LOCATION_TYPE.DAMAGE}')`
       )
       .andWhere(
         `(iv.batch_id, product.name, iv.packing_type, product.brand) NOT IN (
@@ -71,14 +63,43 @@ export const inventoriesByPalletResolver = {
           AND oi.domain_id = (:domainId)
           AND oi.bizplace_id = (:bizplaceId)
         )`,
-        { bizplaceId: bizplaceId.value , domainId: domain.id }
+        { bizplaceId: bizplaceId.value, domainId: domain.id }
       )
 
-      if (locationFilters) {
-        qb.andWhere
-        (`location.name ilike '${locationFilters.value}'`)
-      }  
+    if (locationFilters) {
+      qb.andWhere(`location.name ilike '${locationFilters.value}'`)
+    }
+
+    if (productFilters && productFilters.length > 0) {
+      let productInfo = productFilters[0]
+      qb.andWhere(
+        new Brackets(qb2 => {
+          productFilterColumns.forEach(filter => {
+            const condition = buildCondition(
+              'product',
+              filter,
+              'i_like',
+              productInfo.value,
+              false,
+              Object.keys(qb.getParameters()).length
+            )
+
+            qb2.orWhere(condition.clause, condition.parameters)
+          })
+        })
+      )
+    }
 
+    if (!skipLockCheck) {
+      qb.andWhere('CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END >= 0')
+      qb.andWhere('iv.qty - CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END > 0')
+    }
+
+    if (recallFilters?.value === true) {
+      qb.orWhere('(iv.domain_id = (:domainId) and iv.bizplace_id = (:bizplaceId)')
+      if (locationFilters) {
+        qb.andWhere(`location.name ilike '${locationFilters.value}'`)
+      }
       if (productFilters && productFilters.length > 0) {
         let productInfo = productFilters[0]
         qb.andWhere(
@@ -92,53 +113,18 @@ export const inventoriesByPalletResolver = {
                 false,
                 Object.keys(qb.getParameters()).length
               )
-  
+
               qb2.orWhere(condition.clause, condition.parameters)
             })
           })
         )
       }
-
-    if (!skipLockCheck) {
-      qb.andWhere('CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END >= 0')
-      qb.andWhere('iv.qty - CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END > 0')
-    }
-
-    if (recallFilters?.value === true) {
-      qb.orWhere(
-        '(iv.domain_id = (:domainId) and iv.bizplace_id = (:bizplaceId)'
-        )
-        if (locationFilters){
-          qb.andWhere
-        (`location.name ilike '${locationFilters.value}'`)
-        }
-        if (productFilters && productFilters.length > 0) {
-          let productInfo = productFilters[0]
-          qb.andWhere(
-            new Brackets(qb2 => {
-              productFilterColumns.forEach(filter => {
-                const condition = buildCondition(
-                  'product',
-                  filter,
-                  'i_like',
-                  productInfo.value,
-                  false,
-                  Object.keys(qb.getParameters()).length
-                )
-    
-                qb2.orWhere(condition.clause, condition.parameters)
-              })
-            })
-          )
-        }
-        if (batchIdFilters) {
-          qb.andWhere(
-            `iv.batch_id ilike '${batchIdFilters.value}'`
-            )
-        }
+      if (batchIdFilters) {
+        qb.andWhere(`iv.batch_id ilike '${batchIdFilters.value}'`)
+      }
       qb.andWhere(
         'iv.obsolete = true and case when iv.expiration_date is not null and product.shelf_life is not null then CURRENT_DATE > iv.expiration_date - product.shelf_life else true end)'
-        )
+      )
     } else {
       qb.andWhere('iv.obsolete = false')
       qb.andWhere(
@@ -199,4 +185,4 @@ async function getRemainAmount(inventory: Inventory): Promise<{ remainQty: numbe
     remainQty: inventory.qty - (inventory.lockedQty || 0),
     remainUomValue: inventory.uomValue - (inventory.lockedUomValue || 0)
   }
-}
+}