@things-factory/worksheet-base 4.3.185 → 4.3.187

package/server/controllers/worksheet-controller.ts

@@ -16,7 +16,8 @@ import {
   OrderVas,
   ReleaseGood,
   ReturnOrder,
-  VasOrder
+  VasOrder,
+  Replenishment
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import {
@@ -31,7 +32,14 @@ import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../constants'
 import { Worksheet, WorksheetDetail } from '../entities'
 import { WorksheetNoGenerator } from '../utils'
 
-export type ReferenceOrderType = ArrivalNotice | ReleaseGood | VasOrder | InventoryCheck | DeliveryOrder | ReturnOrder
+export type ReferenceOrderType =
+  | ArrivalNotice
+  | ReleaseGood
+  | VasOrder
+  | InventoryCheck
+  | DeliveryOrder
+  | ReturnOrder
+  | Replenishment
 export type OrderTargetTypes = OrderProduct | OrderInventory | OrderVas
 
 export enum ReferenceOrderFields {
@@ -39,7 +47,8 @@ export enum ReferenceOrderFields {
   ReleaseGood = 'releaseGood',
   VasOrder = 'vasOrder',
   InventoryCheck = 'inventoryCheck',
-  ReturnOrder = 'returnOrder'
+  ReturnOrder = 'returnOrder',
+  Replenishment = 'replenishment'
 }
 
 export enum OrderTargetFields {
@@ -121,6 +130,8 @@ export class WorksheetController {
       return ReferenceOrderFields.InventoryCheck
     } else if (refOrder instanceof ReturnOrder) {
       return ReferenceOrderFields.ReturnOrder
+    } else if (refOrder instanceof Replenishment) {
+      return ReferenceOrderFields.Replenishment
     } else {
       throw new Error(
         this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('refOrder', 'One of reference order type', refOrder)
@@ -247,13 +258,17 @@ export class WorksheetController {
         case ReferenceOrderFields.ReturnOrder:
           refOrder = await this.findRefOrder(ReturnOrder, refOrder, ['bizplace'])
           break
+
+        case ReferenceOrderFields.Replenishment:
+          refOrder = await this.findRefOrder(Replenishment, refOrder)
+          break
       }
     }
 
-    const bizplace: Bizplace = refOrder.bizplace
+    const bizplace: Bizplace = refOrder?.bizplace
     const condition: FindOneOptions = {
       where: {
-        bizplace,
+        bizplace: bizplace ? bizplace : null,
         domain: this.domain,
         type,
         [refOrderField]: refOrder
@@ -394,7 +409,10 @@ export class WorksheetController {
     additionalProps: Partial<Worksheet> = {}
   ): Promise<Worksheet> {
     let refOrderType: string = await this.getRefOrderField(refOrder)
-    const bizplace: Bizplace = await this.extractBizplaceFromRefOrder(refOrder)
+    let bizplace: Bizplace
+    if (refOrderType !== 'replenishment') {
+      bizplace = await this.extractBizplaceFromRefOrder(refOrder)
+    }
 
     let existingWorksheet: Worksheet
     try {
@@ -411,10 +429,13 @@ export class WorksheetController {
 
     const worksheet: Partial<Worksheet> = {
       domain: this.domain,
-      bizplace,
+      bizplace: bizplace ? bizplace : null,
       name: WorksheetNoGenerator.generate(type),
       type,
-      status: WORKSHEET_STATUS.DEACTIVATED,
+      status:
+        refOrderType == 'replenishment' && type == WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT
+          ? WORKSHEET_STATUS.EXECUTING
+          : WORKSHEET_STATUS.DEACTIVATED,
       creator: this.user,
       updater: this.user,
       [refOrderType]: refOrder,
@@ -463,7 +484,11 @@ export class WorksheetController {
     orderTargets: OrderTargetTypes[],
     additionalProps: Partial<WorksheetDetail> = {}
   ): Promise<WorksheetDetail[]> {
-    if (!worksheet.bizplace?.id) {
+    if (
+      !worksheet.bizplace?.id &&
+      type !== WORKSHEET_TYPE.PICKING_REPLENISHMENT &&
+      type !== WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT
+    ) {
       worksheet = await this.findWorksheetById(worksheet.id, ['bizplace'])
     }
     const bizplace: Bizplace = worksheet.bizplace
@@ -472,11 +497,12 @@ export class WorksheetController {
       const orderTargetField: string = this.getOrderTargetField(orderTarget)
       return {
         domain: this.domain,
-        bizplace,
+        bizplace: bizplace ? bizplace : orderTarget.bizplace,
         worksheet,
         name: WorksheetNoGenerator.generate(type, true),
         type,
-        status: WORKSHEET_STATUS.DEACTIVATED,
+        status:
+          type == WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT ? WORKSHEET_STATUS.EXECUTING : WORKSHEET_STATUS.DEACTIVATED,
         [orderTargetField]: orderTarget,
         creator: this.user,
         updater: this.user,
@@ -511,6 +537,8 @@ export class WorksheetController {
         entitySchema = InventoryCheck
       } else if (refOrder instanceof ReturnOrder) {
         entitySchema = ReturnOrder
+      } else if (refOrder instanceof Replenishment) {
+        entitySchema = Replenishment
       }
     }
 
@@ -746,7 +774,9 @@ export class WorksheetController {
       worksheetType === WORKSHEET_TYPE.PACKING ||
       worksheetType === WORKSHEET_TYPE.LOADING ||
       worksheetType === WORKSHEET_TYPE.WAREHOUSE_RETURN ||
-      worksheetType === WORKSHEET_TYPE.UNLOADING_RETURN
+      worksheetType === WORKSHEET_TYPE.UNLOADING_RETURN ||
+      worksheetType === WORKSHEET_TYPE.PICKING_REPLENISHMENT ||
+      worksheetType === WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT
     ) {
       let targetInventories: OrderInventory[] = worksheet.worksheetDetails
         .filter((wsd: WorksheetDetail) => wsd.status !== ORDER_INVENTORY_STATUS.REPLACED)
@@ -904,10 +934,11 @@ export class WorksheetController {
       worksheet.vasOrder ||
       worksheet.inventoryCheck ||
       worksheet.returnOrder ||
+      worksheet.replenishment ||
       null
     if (!refOrder) {
       const wsWithRefOrd: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne(worksheet.id, {
-        relations: ['arrivalNotice', 'releaseGood', 'vasOrder', 'inventoryCheck', 'returnOrder']
+        relations: ['arrivalNotice', 'releaseGood', 'vasOrder', 'inventoryCheck', 'returnOrder', 'replenishment']
       })
 
       refOrder =
@@ -916,6 +947,7 @@ export class WorksheetController {
         wsWithRefOrd.vasOrder ||
         wsWithRefOrd.inventoryCheck ||
         wsWithRefOrd.returnOrder ||
+        wsWithRefOrd.replenishment ||
         null
       if (!refOrder) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheet.id))
     }
@@ -1221,6 +1253,8 @@ export class WorksheetController {
         entitySchema = InventoryCheck
       } else if (refOrder instanceof ReturnOrder) {
         entitySchema = ReturnOrder
+      } else if (refOrder instanceof Replenishment) {
+        entitySchema = Replenishment
       }
     }
 

package/server/entities/index.ts

@@ -1,8 +1,21 @@
 import { WarehouseBizplaceOnhandInventory } from './warehouse-bizplace-onhand-inventory'
+import { WarehouseInventoryAssignmentRanking } from './warehouse-inventory-assignment-ranking'
 import { Worksheet } from './worksheet'
 import { WorksheetDetail } from './worksheet-detail'
 import { WorksheetMovement } from './worksheet-movement'
 
-export const entities = [Worksheet, WorksheetDetail, WorksheetMovement, WarehouseBizplaceOnhandInventory]
+export const entities = [
+  Worksheet,
+  WorksheetDetail,
+  WorksheetMovement,
+  WarehouseBizplaceOnhandInventory,
+  WarehouseInventoryAssignmentRanking
+]
 
-export { WarehouseBizplaceOnhandInventory, Worksheet, WorksheetDetail, WorksheetMovement }
+export {
+  WarehouseBizplaceOnhandInventory,
+  WarehouseInventoryAssignmentRanking,
+  Worksheet,
+  WorksheetDetail,
+  WorksheetMovement
+}

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

@@ -16,6 +16,8 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_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",
+    COALESCE(sum(COALESCE(i.transfer_uom_value, 0::double precision))) AS "transfer_uom_value",
     'SINGLE' AS "group_type"
     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')
@@ -43,6 +45,8 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     COALESCE(MIN(FLOOR(pbs."available_uom_value")),0) AS "remain_uom_value",
     COALESCE(MIN(FLOOR(pbs."qty")), 0::double precision) AS "qty",
     COALESCE(MIN(FLOOR(pbs."uom_value")), 0::double precision) AS "uom_value",
+    COALESCE(MIN(FLOOR(pbs."transfer_qty")), 0::double precision) AS "transfer_qty",
+    COALESCE(MIN(FLOOR(pbs."transfer_uom_value")), 0::double precision) AS "transfer_uom_value",
     'BUNDLE' AS "group_type"
     FROM product_bundles pb
     INNER JOIN (
@@ -50,7 +54,9 @@ import { ViewColumn, ViewEntity } from 'typeorm'
       (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::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.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
       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
@@ -112,6 +118,12 @@ export class WarehouseBizplaceOnhandInventory {
   @ViewColumn()
   remainUomValue: number
 
+  @ViewColumn()
+  transferQty: number
+
+  @ViewColumn()
+  transferUomValue: number
+
   @ViewColumn()
   groupType: string
 }

package/server/entities/warehouse-inventory-assignment-ranking.ts

@@ -0,0 +1,19 @@
+import { ViewColumn, ViewEntity } from 'typeorm'
+
+@ViewEntity({
+  expression: `
+    select src.* from (select 0 as "rank", 'SHELF' as location_type
+    union all
+    select 1 as "rank", 'FLOOR' as location_type
+    union all
+    select 2 as "rank", 'STORAGE' as location_type
+    ) src
+  `
+})
+export class WarehouseInventoryAssignmentRanking {
+  @ViewColumn()
+  locationType: string
+
+  @ViewColumn()
+  rank: number
+}

package/server/entities/worksheet.ts

@@ -6,7 +6,8 @@ import {
   ReleaseGood,
   ShippingOrder,
   VasOrder,
-  ReturnOrder
+  ReturnOrder,
+  Replenishment
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Location } from '@things-factory/warehouse-base'
@@ -44,6 +45,9 @@ export class Worksheet {
   @ManyToOne(type => ReleaseGood)
   releaseGood: ReleaseGood
 
+  @ManyToOne(type => Replenishment)
+  replenishment: Replenishment
+
   @ManyToOne(type => ReturnOrder)
   returnOrder: ReturnOrder
 

package/server/graphql/resolvers/worksheet/cancel-replenishment.ts

@@ -0,0 +1,69 @@
+import { In, Not, EntityManager } from 'typeorm'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, Replenishment } from '@things-factory/sales-base'
+import { User } from '@things-factory/auth-base'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const cancelReplenishment = {
+  async cancelReplenishment(_: any, { name }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    let replenishment: Replenishment = await tx.getRepository(Replenishment).findOne({
+      where: { domain, name, status: Not(In([ORDER_STATUS.PICKING, ORDER_STATUS.PUTTING_AWAY])) },
+      relations: ['orderInventories', 'orderInventories.inventory', 'orderInventories.inventory.location']
+    })
+
+    if (!replenishment) throw new Error(`Replenishment doesn't exists.`)
+    let targetOIs: OrderInventory[] = replenishment.orderInventories
+
+    // change status to cancelled for order inventory that has not executed yet and remove locked qty
+
+    await Promise.all(
+      targetOIs.map(async (orderInventory: OrderInventory) => {
+        let inventory: Inventory = orderInventory.inventory
+
+        if (inventory && inventory.id) {
+          await tx
+            .createQueryBuilder()
+            .update(Inventory)
+            .set({
+              transferQty: () => `COALESCE("transfer_qty", 0) - ${orderInventory.releaseQty}`,
+              transferUomValue: () => `COALESCE("transfer_uom_value", 0) - ${orderInventory.releaseUomValue}`,
+              updater: user
+            })
+            .where('id = :id', { id: inventory.id })
+            .execute()
+        }
+
+        return orderInventory
+      })
+    )
+
+    await tx
+      .getRepository(OrderInventory)
+      .update(targetOIs, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: user })
+
+    let worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: { replenishment },
+      relations: ['worksheetDetails']
+    })
+
+    if (worksheet) {
+      let worksheetDetailIds = worksheet.worksheetDetails.map(wsd => wsd.id)
+
+      await tx
+        .getRepository(Worksheet)
+        .update({ id: worksheet.id }, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: this.user })
+
+      await tx
+        .getRepository(WorksheetDetail)
+        .update({ id: In(worksheetDetailIds) }, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: this.user })
+    }
+
+    await tx
+      .getRepository(Replenishment)
+      .update({ id: replenishment.id }, { status: ORDER_STATUS.CANCELLED, updater: this.user })
+
+    return worksheet
+  }
+}

package/server/graphql/resolvers/worksheet/confirm-cancellation-release-order.ts

@@ -22,6 +22,7 @@ import {
 } from '@things-factory/warehouse-base'
 
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { LastMileAPI } from '@things-factory/integration-lmd'
 
 export const confirmCancellationReleaseOrder = {
   async confirmCancellationReleaseOrder(_: any, { name }, context: any) {
@@ -35,7 +36,9 @@ export const confirmCancellationReleaseOrder = {
         'orderInventories',
         'orderInventories.inventory',
         'orderInventories.inventory.location',
-        'orderVass'
+        'orderVass',
+        'lastMileDelivery',
+        'orderPackages'
       ]
     })
 
@@ -232,6 +235,24 @@ export const confirmCancellationReleaseOrder = {
       createSalesReturn(account)
     }
 
+    // cancel consignment for lmd orders
+    if (releaseGood?.lmdOption && releaseGood?.lastMileDelivery && releaseGood?.orderPackages) {
+      for (let op of releaseGood.orderPackages) {
+        if (op?.parcelId) {
+          let res = await LastMileAPI.deleteParcel({...releaseGood.lastMileDelivery, platform: 'lmdMiddleware'}, {
+            clientId: releaseGood.lastMileDelivery?.clientId,
+            clientPass: releaseGood.lastMileDelivery?.secretKey,
+            soldToAccountId: releaseGood.lastMileDelivery?.soldToAccountId,
+            pickupAccountId: releaseGood.lastMileDelivery?.pickupAccountId,
+            token: releaseGood.lastMileDelivery?.accessToken,
+            parcelId: op.parcelId,
+            warehouse: domain?.name
+          })
+          if (!res?.status) throw new Error('cannot cancel consignment note')  
+        }
+      }
+    }
+
     return
   }
 }

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-release-good-worksheet.ts

@@ -13,7 +13,12 @@ import { Inventory, InventoryUtil, INVENTORY_TRANSACTION_TYPE } from '@things-fa
 export const generateReleaseGoodWorksheetResolver = {
   async generateReleaseGoodWorksheet(_: any, { releaseGoodNo, currentStatus = null }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    return await generatePickingWorksheet(tx, domain, user, releaseGoodNo, currentStatus)
+    let worksheet = await generatePickingWorksheet(tx, domain, user, releaseGoodNo, currentStatus)
+    if (worksheet) {
+      return true
+    } else {
+      return false
+    }
   }
 }
 

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-replenishement-worksheet.ts

@@ -0,0 +1,30 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { OrderInventory } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { ReplenishmentWorksheetController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const generateReplenishmentWorksheetResolver = {
+  async generateReplenishmentWorksheets(_: any, { replenishmentNos }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    for (let i = 0; i < replenishmentNos.length; i++) {
+      await generateReplenishmentWorksheet(tx, domain, user, replenishmentNos[i])
+    }
+
+    return true
+  }
+}
+
+export async function generateReplenishmentWorksheet(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  replenishmentNo: string
+): Promise<Worksheet> {
+  const worksheetController: ReplenishmentWorksheetController = new ReplenishmentWorksheetController(tx, domain, user)
+  return await worksheetController.generateReplenishmentWorksheet(replenishmentNo)
+}

package/server/graphql/resolvers/worksheet/generate-worksheet/index.ts

@@ -8,6 +8,7 @@ import { generateMultipleReleaseGoodWorksheetResolver } from './generate-multipl
 import { generateVasOrderWorksheetResolver } from './generate-vas-order-worksheet'
 import { generateReturnOrderWorksheetResolver } from './generate-return-order-worksheet'
 import { generatePartialPutawayReturnWorksheetResolver } from './generate-partial-putaway-return-worksheet'
+import { generateReplenishmentWorksheetResolver } from './generate-replenishement-worksheet'
 
 export const Mutations = {
   ...generateArrivalNoticeWorksheetResolver,
@@ -19,5 +20,6 @@ export const Mutations = {
   ...generateMultipleReleaseGoodWorksheetResolver,
   ...generateVasOrderWorksheetResolver,
   ...generateReturnOrderWorksheetResolver,
-  ...generatePartialPutawayReturnWorksheetResolver
+  ...generatePartialPutawayReturnWorksheetResolver,
+  ...generateReplenishmentWorksheetResolver
 }

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

@@ -67,6 +67,9 @@ import { worksheetResolver } from './worksheet'
 import { worksheetByOrderNoResolver } from './worksheet-by-order-no'
 import { worksheetWithPaginationResolver } from './worksheet-with-pagination'
 import { worksheetsResolver } from './worksheets'
+import { cancelReplenishment } from './cancel-replenishment'
+import { Mutations as ReplenishmentMutations } from './replenishment'
+import { putawayReplenishmentWorksheetResolver } from './putaway-replenishment-worksheet'
 
 export const Query = {
   ...worksheetsResolver,
@@ -102,7 +105,8 @@ export const Query = {
   ...sortingWorksheetResolver,
   ...findSortingReleaseOrdersByTaskNoResolver,
   ...findReleaseOrdersByTaskNoResolver,
-  ...fetchDeliveryOrderROResolver
+  ...fetchDeliveryOrderROResolver,
+  ...putawayReplenishmentWorksheetResolver
 }
 
 export const Mutation = {
@@ -138,5 +142,7 @@ export const Mutation = {
   ...unpackingResolver,
   ...palletizingPallets,
   ...fetchSellercraftDocumentResolver,
-  ...cancelDraftReleaseOrder
+  ...cancelDraftReleaseOrder,
+  ...cancelReplenishment,
+  ...ReplenishmentMutations
 }

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

@@ -1,16 +1,28 @@
-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 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')
@@ -18,17 +30,10 @@ export const inventoriesByPalletResolver = {
       skipLockCheckFilters && skipLockCheckFilters?.value ? skipLockCheckFilters?.value : false
     const productFilterColumns = ['sku', 'brandSku', 'name', 'description', 'brand', 'subBrand']
     params.filters = params.filters.filter(x => x.name != 'productName')
+    const batchIdFilters = params.filters.find(x => x.name == 'batchId')
 
-    if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
-      params.filters.push({
-        name: 'bizplace',
-        operator: 'in',
-        value: permittedBizplaceIds,
-        relation: true
-      })
-    } else {
-      permittedBizplaceIds = params.filters.find(filter => filter.name === 'bizplace').value
-      params.filters.find(filter => filter.name === 'bizplace').relation = true
+    if (!params.filters.find((filter: any) => filter.name === 'bizplace_id')) {
+      throw new Error('No Bizplace found')
     }
 
     const locationFilters = params.filters.find(x => x.name == 'locationName')
@@ -46,6 +51,8 @@ export const inventoriesByPalletResolver = {
       .leftJoinAndSelect('iv.creator', 'creator')
       .leftJoinAndSelect('iv.updater', 'updater')
       .andWhere('iv.qty > 0')
+      .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
@@ -63,12 +70,37 @@ export const inventoriesByPalletResolver = {
             oi.product_id = p2.id
           WHERE 
             oi.status = '${ORDER_INVENTORY_STATUS.PENDING_SPLIT}'
-          AND oi.bizplace_id IN (:...permittedBizplaceIds)
           AND oi.domain_id = (:domainId)
+          AND oi.bizplace_id = (:bizplaceId)
         )`,
-        { permittedBizplaceIds, domainId: domain.id }
+        { bizplaceId: bizplaceId.value , domainId: domain.id }
       )
 
+      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')
@@ -76,8 +108,39 @@ export const inventoriesByPalletResolver = {
 
     if (recallFilters?.value === true) {
       qb.orWhere(
-        '(iv.obsolete = true or 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)'
-      )
+        '(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}'`
+            )
+        }
+      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(
@@ -85,10 +148,6 @@ export const inventoriesByPalletResolver = {
       )
     }
 
-    if (locationFilters) {
-      qb.andWhere(`location.name ilike '${locationFilters.value}'`)
-    }
-
     if (sortings?.length !== 0) {
       const arrChildSortData = ['productName', 'productSKU']
 
@@ -112,25 +171,6 @@ export const inventoriesByPalletResolver = {
       qb.addOrderBy('location.name', 'DESC')
     }
 
-    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)
-          })
-        })
-      )
-    }
     let [items, total] = await qb.getManyAndCount()
 
     items = await Promise.all(
@@ -161,4 +201,4 @@ async function getRemainAmount(inventory: Inventory): Promise<{ remainQty: numbe
     remainQty: inventory.qty - (inventory.lockedQty || 0),
     remainUomValue: inventory.uomValue - (inventory.lockedUomValue || 0)
   }
-}
+}