@things-factory/sales-base 4.3.248 → 4.3.250

package/server/service/release-good/release-good-mutation.ts

@@ -1,28 +1,26 @@
 import { FileUpload, GraphQLUpload } from 'graphql-upload'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { EntityManager, getConnection, getRepository, In, Not, Repository } from 'typeorm'
-import { logger } from '@things-factory/env'
 
 import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Application, ApplicationType, Partner, Role, User } from '@things-factory/auth-base'
 import {
   Bizplace,
+  getCompanyBizplace,
   getDomainUsers,
   getMyBizplace,
   getOutletBizplace,
-  getPermittedBizplaces,
-  getCompanyBizplace
+  getPermittedBizplaces
 } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
 import { MarketplaceStore } from '@things-factory/integration-marketplace'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
-import { Powrup } from '@things-factory/integration-powrup'
-import { MarketplaceOrder, MarketplaceProductVariation } from '@things-factory/marketplace-base'
+import { MarketplaceOrder } from '@things-factory/marketplace-base'
 // import { sendNotification } from '@things-factory/notification'
 import { Product, ProductBundleSetting, ProductDetail } from '@things-factory/product-base'
 import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
+import { Inventory, ProductDetailStock } from '@things-factory/warehouse-base'
 
 // import { NewOrderProduct } from '../order-product/order-product-types'
 import {
@@ -37,13 +35,14 @@ import {
   ORDER_VAS_STATUS,
   PRODUCT_GROUP_TYPE
 } from '../../constants'
-import { EcommerceController, SellercraftController, PowrupController } from '../../controllers'
+import { EcommerceController, PowrupController, SellercraftController } from '../../controllers'
 import { ValidationError } from '../../errors'
 import { InventoryUtil, OrderNoGenerator } from '../../utils'
 import { ArrivalNotice } from '../arrival-notice/arrival-notice'
 import { confirmArrivalNoticeFunction, deleteArrivalNotice } from '../arrival-notice/arrival-notice-mutation'
 import { OrderInventory } from '../order-inventory/order-inventory'
 import { OrderProduct } from '../order-product/order-product'
+import { OrderVasItem } from '../order-vas-item/order-vas-item'
 import { OrderVas } from '../order-vas/order-vas'
 import { NewReleaseGood, ReleaseGoodPatch, ShippingOrderInfoPatch } from '../release-good/release-good-types'
 import { ShippingOrder } from '../shipping-order/shipping-order'
@@ -51,7 +50,6 @@ import { ShippingOrderPatch } from '../shipping-order/shipping-order-types'
 import { Vas } from '../vas/vas'
 import { ReleaseGood } from './release-good'
 import { bulkReleaseGoodsAvailableItemsFunction } from './release-good-query'
-import { OrderVasItem } from '../order-vas-item/order-vas-item'
 
 @Resolver(ReleaseGood)
 export class ReleaseGoodMutation {
@@ -371,6 +369,8 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
     where: { domain, name },
     relations: [
       'arrivalNotice',
+      'orderProducts',
+      'orderProducts.productDetail',
       'orderInventories',
       'orderInventories.orderProduct',
       'orderInventories.inventory',
@@ -385,6 +385,7 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
   const foundOIs: OrderInventory[] = foundReleaseOrder.orderInventories
   const foundOVs: OrderVas[] = foundReleaseOrder.orderVass
   const foundSO: ShippingOrder = foundReleaseOrder.shippingOrder
+  const foundOPs: OrderProduct[] = foundReleaseOrder.orderProducts
 
   let foundAttachment: Attachment
   if (foundReleaseOrder?.ownTransport) {
@@ -421,6 +422,28 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
     })
   )
 
+  // Deduct unassigned qty if ro is unassigned
+  if (foundReleaseOrder.assignedInventory == false) {
+    await Promise.all(
+      foundOPs.map(async (op: OrderProduct) => {
+        await tx
+          .getRepository(ProductDetailStock)
+          .createQueryBuilder()
+          .update(ProductDetailStock)
+          .set({
+            unassignedQty: () => `"unassigned_qty" - ${op.releaseQty}`,
+            unassignedUomValue: () => `"unassigned_uom_value" - ${op.releaseUomValue}`
+          })
+          .where({ productDetail: op.productDetail.id })
+          .execute()
+
+        await tx.getRepository(OrderProduct).delete({ id: op.id })
+
+        return op
+      })
+    )
+  }
+
   // 2. delete order vass
   const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
   if (vasIds.length) {
@@ -449,6 +472,7 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
   if (foundSO) {
     await tx.getRepository(ShippingOrder).delete({ domain, id: foundSO.id })
   }
+
   return true
 }
 
@@ -736,6 +760,18 @@ export async function generateReleaseGoodFunction(
     newReleaseGood.noOfItems = orderInventories.length
     newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
 
+    const worksheetPickingAssignment: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain, category: 'id-rule', name: 'enable-worksheet-picking-activation-assignment' }
+    })
+
+    newReleaseGood.assignedInventory =
+      worksheetPickingAssignment?.value == 'true'
+        ? newReleaseGood.orderMethod == ORDER_METHOD.SELECT_BY_PALLET
+          ? true
+          : false
+        : true
+    newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
+
     for (let oi of orderInventories) {
       let productDetail: any = await tx
         .getRepository(ProductDetail)
@@ -747,7 +783,6 @@ export async function generateReleaseGoodFunction(
         domain: warehouseDomain,
         bizplace: bizplace,
         status: ORDER_INVENTORY_STATUS.PENDING,
-        name: OrderNoGenerator.orderInventory(),
         releaseGood: newReleaseGood,
         product: productDetail.product,
         productDetail,
@@ -758,6 +793,7 @@ export async function generateReleaseGoodFunction(
       let newOrderProduct: OrderProduct = Object.assign(new OrderProduct(), newOrderInv)
       newOrderProduct = {
         ...newOrderProduct,
+        name: OrderNoGenerator.orderProduct(),
         packQty: 0,
         actualPackQty: 0,
         palletQty: 0,
@@ -774,62 +810,67 @@ export async function generateReleaseGoodFunction(
 
         finalOrderInventories.push(newOrderInv)
       } else {
-        // Preassign Inventories
-        const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
-          where: { domain, name: 'rule-for-inventory-assignment' }
-        })
+        if (worksheetPickingAssignment?.value !== 'true') {
+          // Preassign Inventories
+          const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
+            where: { domain, name: 'rule-for-inventory-assignment' }
+          })
 
-        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 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(
-          oi,
-          productDetail.product,
-          productDetail,
-          locationSortingRules,
-          bizplace,
-          warehouseDomain,
-          tx,
-          oi.batchId
-        )
+          let assignedOrderInventories: OrderInventory[] = await InventoryUtil.autoAssignInventoryForRelease(
+            newOrderInv,
+            productDetail.product,
+            productDetail,
+            locationSortingRules,
+            bizplace,
+            warehouseDomain,
+            tx,
+            newOrderInv.batchId
+          )
 
-        assignedOrderInventories = assignedOrderInventories.map(aoi => {
-          return {
-            ...aoi,
-            orderProduct: newOrderProduct
-          }
-        })
+          assignedOrderInventories = assignedOrderInventories.map(aoi => {
+            return {
+              ...aoi,
+              orderProduct: newOrderProduct
+            }
+          })
 
-        finalOrderInventories.push(...assignedOrderInventories)
+          finalOrderInventories.push(...assignedOrderInventories)
+        } else {
+          finalOrderInventories.push(newOrderInv)
+        }
       }
     }
 
     for (let oi of finalOrderInventories) {
-      let generatedOI: OrderInventory = Object.assign(new OrderInventory(), oi)
-      generatedOI = {
-        ...generatedOI,
-        domain: warehouseDomain,
-        bizplace,
-        status: ORDER_INVENTORY_STATUS.PENDING,
-        name: OrderNoGenerator.orderInventory(),
-        releaseGood: newReleaseGood,
-        creator: user,
-        updater: user
-      }
-
-      await tx.getRepository(OrderInventory).save({ ...generatedOI })
-
       // update inventory locked qty and uom value
-      await tx.getRepository(Inventory).update(oi.inventory.id, {
-        lockedQty: (oi.inventory?.lockedQty || 0) + generatedOI.releaseQty,
-        lockedUomValue: (oi.inventory?.lockedUomValue || 0) + generatedOI.releaseUomValue,
-        updater: user
-      })
+      if (worksheetPickingAssignment?.value !== 'true' || oi.inventory?.id) {
+        await tx.getRepository(OrderInventory).save({ ...oi, name: OrderNoGenerator.orderInventory() })
+
+        await tx.getRepository(Inventory).update(oi.inventory.id, {
+          lockedQty: (oi.inventory?.lockedQty || 0) + oi.releaseQty,
+          lockedUomValue: (oi.inventory?.lockedUomValue || 0) + oi.releaseUomValue,
+          updater: user
+        })
+      } else {
+        await tx
+          .getRepository(ProductDetailStock)
+          .createQueryBuilder()
+          .update(ProductDetailStock)
+          .set({
+            unassignedQty: () => `"unassigned_qty" + ${oi.releaseQty}`,
+            unassignedUomValue: () => `"unassigned_uom_value" + ${oi.releaseUomValue}`
+          })
+          .where({ productDetail: oi.productDetail.id })
+          .execute()
+      }
     }
 
     // VAS
@@ -1367,6 +1408,10 @@ export async function bulkGenerateReleaseGood(
   tx?: EntityManager
 ): Promise<ReleaseGood> {
   try {
+    const worksheetPickingAssignment: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain, category: 'id-rule', name: 'enable-worksheet-picking-activation-assignment' }
+    })
+
     let warehouseDomain: Domain = domain
     let { orderInventories, shippingOrder } = releaseGood
 
@@ -1402,7 +1447,8 @@ export async function bulkGenerateReleaseGood(
       orderMethod: ORDER_METHOD.SELECT_BY_PRODUCT,
       status: ORDER_STATUS.PENDING,
       creator: releaseGood?.creator || user,
-      updater: releaseGood?.updater || user
+      updater: releaseGood?.updater || user,
+      assignedInventory: worksheetPickingAssignment?.value == 'true' ? false : true
     }
 
     newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
@@ -1432,43 +1478,47 @@ export async function bulkGenerateReleaseGood(
 
     // pre assign inventory to orderInventories
     for (let oi of orderInventories) {
-      const pickingProductSetting: Setting = await tx.getRepository(Setting).findOne({
-        where: { domain, name: 'rule-for-picking-product' }
-      })
+      if (worksheetPickingAssignment?.value !== 'true') {
+        const pickingProductSetting: Setting = await tx.getRepository(Setting).findOne({
+          where: { domain, name: 'rule-for-picking-product' }
+        })
 
-      let locationSortingRules = []
-      if (pickingProductSetting) {
-        let locationSetting = JSON.parse(pickingProductSetting.value)
-        for (const key in locationSetting) {
-          locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
+        let locationSortingRules = []
+        if (pickingProductSetting) {
+          let locationSetting = JSON.parse(pickingProductSetting.value)
+          for (const key in locationSetting) {
+            locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
+          }
         }
-      }
 
-      let productDetail = oi.orderProduct?.productDetail
-      let product = oi.orderProduct?.product
-      if (!productDetail) {
-        productDetail = await tx.getRepository(ProductDetail).findOne(oi.productDetailId, { relations: ['product'] })
-        product = productDetail.product
-      }
+        let productDetail = oi.orderProduct?.productDetail
+        let product = oi.orderProduct?.product
+        if (!productDetail) {
+          productDetail = await tx.getRepository(ProductDetail).findOne(oi.productDetailId, { relations: ['product'] })
+          product = productDetail.product
+        }
 
-      let assignedResult = await InventoryUtil.autoAssignInventoryForRelease(
-        oi,
-        product,
-        productDetail,
-        locationSortingRules,
-        bizplace,
-        warehouseDomain,
-        tx
-      )
+        let assignedResult = await InventoryUtil.autoAssignInventoryForRelease(
+          oi,
+          product,
+          productDetail,
+          locationSortingRules,
+          bizplace,
+          warehouseDomain,
+          tx
+        )
 
-      finalOrderInventories.push(
-        ...assignedResult.map(itm => {
-          return {
-            ...itm,
-            orderProduct: oi?.orderProduct
-          }
-        })
-      )
+        finalOrderInventories.push(
+          ...assignedResult.map(itm => {
+            return {
+              ...itm,
+              orderProduct: oi?.orderProduct
+            }
+          })
+        )
+      } else {
+        finalOrderInventories.push(oi)
+      }
     }
 
     for (let oi of finalOrderInventories) {
@@ -1517,14 +1567,27 @@ export async function bulkGenerateReleaseGood(
         })
       }
 
-      await tx.getRepository(OrderInventory).save({ ...generatedOI, orderProduct: newOrderProduct })
-
       // update inventory locked qty and uom value
-      await tx.getRepository(Inventory).update(oi.inventory.id, {
-        lockedQty: (oi.inventory?.lockedQty || 0) + generatedOI.releaseQty,
-        lockedUomValue: (oi.inventory?.lockedUomValue || 0) + generatedOI.releaseUomValue,
-        updater: user
-      })
+      if (worksheetPickingAssignment?.value !== 'true') {
+        await tx.getRepository(OrderInventory).save({ ...generatedOI, orderProduct: newOrderProduct })
+
+        await tx.getRepository(Inventory).update(oi.inventory.id, {
+          lockedQty: (oi.inventory?.lockedQty || 0) + generatedOI.releaseQty,
+          lockedUomValue: (oi.inventory?.lockedUomValue || 0) + generatedOI.releaseUomValue,
+          updater: user
+        })
+      } else {
+        await tx
+          .getRepository(ProductDetailStock)
+          .createQueryBuilder()
+          .update(ProductDetailStock)
+          .set({
+            unassignedQty: () => `"unassigned_qty" + ${generatedOI.releaseQty}`,
+            unassignedUomValue: () => `"unassigned_uom_value" + ${generatedOI.releaseUomValue}`
+          })
+          .where({ productDetail: oi.productDetail ? oi.productDetail.id : oi.productDetailId })
+          .execute()
+      }
     }
 
     return newReleaseGood

package/server/service/release-good/release-good.ts

@@ -516,6 +516,10 @@ export class ReleaseGood {
   @Field({ nullable: true })
   lastMarketPackCall: Date
 
+  @Column({ nullable: true, default: true })
+  @Field({ nullable: true })
+  assignedInventory: Boolean
+
   @ManyToOne(type => User)
   @Field(type => User, { nullable: true })
   manifestedBy: User

package/server/utils/inventory-util.ts

@@ -1,29 +1,10 @@
-import {
-  EntityManager,
-  Equal,
-  getRepository,
-  In,
-  Not,
-  Raw,
-  Repository,
-  SelectQueryBuilder
-} from 'typeorm'
+import { EntityManager, Equal, getRepository, In, Not, Raw, Repository, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import {
-  Product,
-  ProductBundle,
-  ProductDetail
-} from '@things-factory/product-base'
-import {
-  PartnerSetting,
-  Setting
-} from '@things-factory/setting-base'
-import {
-  Domain,
-  ListParam
-} from '@things-factory/shell'
+import { Product, ProductBundle, ProductDetail } from '@things-factory/product-base'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
+import { Domain, ListParam } from '@things-factory/shell'
 import {
   generateInventoryHistory,
   Inventory,
@@ -122,14 +103,15 @@ export const InventoryUtil = {
               coalesce(p.brand, '') AS "productBrand",
               p.id AS "productId",
               pd.id AS "productDetailId",
-              COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)),0) AS "remainQty",
-              COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)),0) AS "remainUomValue",
-              concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', pd.uom) AS "remainUomValueWithUom",
+              COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - SUM(COALESCE(pds.unassigned_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)),0) AS "remainQty",
+              COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)),0) AS "remainUomValue",
+              concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', pd.uom) AS "remainUomValueWithUom",
               COALESCE(SUM(COALESCE(i.transfer_qty, 0)), 0) AS "transferQty",
               COALESCE(SUM(COALESCE(i.transfer_uom_value, 0)), 0) AS "transferUomValue",
               'SINGLE' AS "groupType"
             FROM products p
             INNER join product_details pd on pd.product_id = p.id
+            LEFT JOIN product_detail_stocks pds on pds.product_detail_id = pd.id
             LEFT JOIN (
               SELECT i.* FROM inventories i 
               INNER JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id
@@ -175,13 +157,14 @@ export const InventoryUtil = {
             FROM product_bundles pb
             LEFT JOIN (
               SELECT pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
-              (SUM(COALESCE(i2.qty, 0)) - SUM(COALESCE(i2.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
-              (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue",
+              (SUM(COALESCE(i2.qty, 0)) - SUM(COALESCE(i2.locked_qty, 0)) - SUM(COALESCE(pds2.unassigned_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
+              (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - SUM(COALESCE(pds2.unassigned_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue",
               (SUM(COALESCE(i2.transfer_qty, 0)) / min(pbs.bundle_qty)) AS "transferQty",
               (SUM(COALESCE(i2.transfer_uom_value, 0)) / min(pbs.bundle_qty)) AS "transferUomValue",
               pbs.product_detail_id
               FROM product_bundle_settings pbs 
               LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id AND i2.domain_id = $1 AND i2.status = 'STORED'
+              LEFT JOIN product_detail_stocks pds2 ON pds2.product_detail_id = pbs.product_detail_id
               INNER JOIN locations l2 ON i2.location_id = l2.id                
               LEFT JOIN oi ON oi.product_id = i2.product_id
               WHERE l2.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')
@@ -305,13 +288,14 @@ export const InventoryUtil = {
               coalesce(p.brand, '') AS "productBrand",
               p.id AS "productId",
               i.product_detail_id AS "productDetailId",
-              SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)) AS "remainQty",
-              SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) AS "remainUomValue",
-              concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', i.uom) AS "remainUomValueWithUom",
+              SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)) - SUM(COALESCE(pds.unassigned_qty, 0))  AS "remainQty",
+              SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value)) AS "remainUomValue",
+              concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value)), ' ', i.uom) AS "remainUomValueWithUom",
               'SINGLE' AS "groupType"
             FROM
               inventories i
               LEFT JOIN products p ON i.product_id = p.id
+              LEFT JOIN product_detail_stocks pds ON pds.product_detail_id = i.product_detail_id
               LEFT JOIN oi ON i.batch_id = oi.batch_id AND p.name = oi.product_name AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
               LEFT JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id
               LEFT JOIN (
@@ -535,7 +519,7 @@ export const InventoryUtil = {
       validOrderInventories.map(x => {
         return {
           product_detail_id: x.productDetail.id,
-          batch_id: x.batchId.replace(`'`,`''`),
+          batch_id: x.batchId.replace(`'`, `''`),
           release_qty: x.releaseQty,
           uom: x.uom
         }
@@ -652,11 +636,10 @@ export const InventoryUtil = {
     })
 
     if (partnerStrictProductSelectionSetting) strictProduct = partnerStrictProductSelectionSetting.value
-    
-    
+
     let locationTypes = [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
 
-    if(recall === false){
+    if (recall === false) {
       locationTypes.push(LOCATION_TYPE.DAMAGE)
     }
 
@@ -812,7 +795,7 @@ async function getConditions(
     WHERE pb.status = 'ACTIVATED'
   `
 
-  let whereClause = hasRemainingQty ? ` WHERE "remainQty" > 0` : ` WHERE 1 = 1`
+  let whereClause = hasRemainingQty ? ` WHERE "remainQty" > 0 ` : ` WHERE 1 = 1 `
 
   let productDetailWhereClause = ``
 
@@ -845,7 +828,7 @@ async function getConditions(
 
           case 'batchId':
             let batchId = `${value}`
-            whereClause += `AND LOWER("batchId") LIKE '${batchId.replace(`'`,`''`).toLowerCase()}'`
+            whereClause += `AND LOWER("batchId") LIKE '${batchId.replace(`'`, `''`).toLowerCase()}'`
             break
 
           case 'batchIdRef':
@@ -949,7 +932,7 @@ async function getConditions(
               AND (i.batch_id, p.id, i.packing_type, i.packing_size) ${operator === 'in' ? 'IN' : 'NOT IN'} (${value
               .map(
                 (v: { batchId: string; productId: string; packingType: string; packingSize: string }) =>
-                  `('${v.batchId.replace(`'`,`''`)}', '${v.productId}', '${v.packingType}', '${v.packingSize}')`
+                  `('${v.batchId.replace(`'`, `''`)}', '${v.productId}', '${v.packingType}', '${v.packingSize}')`
               )
               .join()})
             `
@@ -1117,6 +1100,7 @@ export function _composeTargetInventories(
     }
 
     orderInventories.push({
+      ...record,
       ...orderInventory,
       inventory,
       packingType,