@things-factory/sales-base 4.0.23 → 4.0.27

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

@@ -1,12 +1,11 @@
 import { FileUpload, GraphQLUpload } from 'graphql-upload'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository, In, Not, Repository } from 'typeorm'
+import { EntityManager, getConnection, getRepository, In, Not, Repository } from 'typeorm'
 
 import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Partner, Role, User } from '@things-factory/auth-base'
 import {
   Bizplace,
-  getCompanyBizplace,
   getDomainUsers,
   getMyBizplace,
   getOutletBizplace,
@@ -15,6 +14,7 @@ import {
 import { generateId } from '@things-factory/id-rule-base'
 import { MarketplaceStore } from '@things-factory/integration-marketplace'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { MarketplaceOrder, MarketplaceProductVariation } from '@things-factory/marketplace-base'
 import { sendNotification } from '@things-factory/notification'
 import { Product, ProductBundleSetting } from '@things-factory/product-base'
 import { PartnerSetting, Setting } from '@things-factory/setting-base'
@@ -48,9 +48,100 @@ import { ValidationError } from '../../errors'
 import { InventoryUtil, OrderNoGenerator } from '../../utils'
 import { confirmArrivalNoticeFunction, deleteArrivalNotice } from '../arrival-notice/arrival-notice-mutation'
 import { ReleaseGood } from './release-good'
+import { bulkReleaseGoodsAvailableItemsFunction } from './release-good-query'
 
 @Resolver(ReleaseGood)
 export class ReleaseGoodMutation {
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [ReleaseGood])
+  async bulkAddReleaseGoods(
+    @Ctx() context: any,
+    @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
+    @Arg('bizplaceId', type => String) bizplaceId: string
+  ): Promise<ReleaseGood[]> {
+    const { domain, user, tx } = context.state
+
+    if (!bizplaceId) throw new Error('company ID is not provided')
+
+    let createdReleaseGoods: ReleaseGood[] = []
+    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+
+    const roNoSetting: Setting = await settingRepo.findOne({
+      where: {
+        domain,
+        name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
+      }
+    })
+
+    let releaseGoods: Partial<ReleaseGood[]> = extractRawReleaseGoods(rawReleaseGoods)
+
+    let errorsFound: any[] = []
+    for (let i = 0, l = releaseGoods.length; i < l; i++) {
+      // generate release good by group to avoid duplication
+      // if this function is called simultaneously by different users
+      try {
+        await getConnection().transaction(async (childTx: EntityManager) => {
+          const existingReleaseGood: ReleaseGood = await childTx.getRepository(ReleaseGood).findOne({
+            where: {
+              ...Object.fromEntries(
+                Object.entries(releaseGoods[i]).filter(([_, val]) => !/^\s*$/.test(val) && _ != 'orderInventories')
+              ),
+              domain
+            }
+          })
+          if (existingReleaseGood) throw new Error('release good order is already exist in the system')
+
+          let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
+            [...releaseGoods[i].orderInventories],
+            bizplaceId,
+            context,
+            childTx
+          )
+
+          if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty))
+            throw new ValidationError({
+              ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
+              detail: { data: JSON.stringify(availableItems) }
+            })
+
+          // update orderInventories if availableItems are valid
+          releaseGoods[i].orderInventories = availableItems
+
+          const createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
+            releaseGoods[i],
+            bizplaceId,
+            roNoSetting,
+            domain,
+            user,
+            childTx
+          )
+
+          createdReleaseGoods.push(createdReleaseGood)
+        })
+      } catch (e) {
+        errorsFound.push(e)
+      }
+    }
+
+    let confirmedReleaseGoods: ReleaseGood[] = []
+    try {
+      confirmedReleaseGoods = await bulkConfirmReleaseGoods(
+        createdReleaseGoods.map(rg => rg.name),
+        domain,
+        user,
+        context,
+        tx
+      )
+    } catch (e) {
+      errorsFound.push(e)
+    }
+
+    // if (errorsFound.length) { then ?? }
+
+    return confirmedReleaseGoods
+  }
+
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
@@ -206,71 +297,6 @@ export class ReleaseGoodMutation {
 
     return receivedRO
   }
-
-  @Directive('@transaction')
-  @Mutation(returns => [ReleaseGood])
-  async bulkAddReleaseGoods(
-    @Ctx() context: any,
-    @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
-    @Arg('bizplaceId', type => String) bizplaceId: string
-  ): Promise<ReleaseGood[]> {
-    const { domain, user, tx } = context.state
-
-    if (!bizplaceId) throw new Error('company ID is not provided')
-
-    let createdReleaseGoods: ReleaseGood[] = []
-    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-    const roNoSetting: Setting = await settingRepo.findOne({
-      where: {
-        domain,
-        name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
-      }
-    })
-
-    let releaseGoods: Partial<ReleaseGood[]> = extractRawReleaseGoods(rawReleaseGoods)
-
-    for (let i = 0, l = releaseGoods.length; i < l; i++) {
-      // generate release good by group to avoid duplication
-      // if this function is called simultaneously by different users
-      let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
-        [...releaseGoods[i].orderInventories],
-        bizplaceId,
-        context,
-        tx
-      )
-
-      if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty))
-        throw new ValidationError({
-          ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
-          detail: { data: JSON.stringify(availableItems) }
-        })
-
-      // update orderInventories if availableItems are valid
-      releaseGoods[i].orderInventories = availableItems
-
-      const createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGoods(
-        releaseGoods[i],
-        bizplaceId,
-        roNoSetting,
-        domain,
-        user,
-        tx
-      )
-
-      createdReleaseGoods.push(createdReleaseGood)
-    }
-
-    let confirmedReleaseGoods: ReleaseGood[] = await bulkConfirmReleaseGoods(
-      createdReleaseGoods.map(rg => rg.name),
-      domain,
-      user,
-      context,
-      tx
-    )
-
-    return confirmedReleaseGoods
-  }
 }
 
 export async function deleteReleaseGood(tx: EntityManager, name: string, user: User, domain: Domain): Promise<boolean> {
@@ -433,10 +459,33 @@ export async function generateReleaseGoodFunction(
             domain: warehouseDomain,
             refNo,
             status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]))
-          }
+          },
+          relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
         })
 
-        if (foundReleaseGood) throw new Error('Existing release order found')
+        if (foundReleaseGood) {
+          const customerCompanyDomain: Domain = foundReleaseGood.bizplace.company.domain
+          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+            where: { orderNo: refNo, domain: customerCompanyDomain }
+          })
+
+          // Need to restructure the validation
+          if (marketplaceOrder.isSplitted) {
+            const refNo2: string = releaseGood.refNo2
+            const foundSplittedReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+              where: {
+                domain: warehouseDomain,
+                refNo2,
+                status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]))
+              },
+              relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
+            })
+
+            if (foundSplittedReleaseGood) throw new Error('Existing release order found')
+          } else {
+            throw new Error('Existing release order found')
+          }
+        }
       }
     }
 
@@ -503,6 +552,7 @@ export async function generateReleaseGoodFunction(
       refNo3: releaseGood.refNo3,
       releaseDate: releaseGood.releaseDate,
       truckNo: releaseGood.truckNo,
+      bundleInfo: releaseGood?.bundleInfo || [],
       orderInventories: releaseGood.orderInventories,
       type: releaseGood?.type ? releaseGood.type : 'b2b',
       status: ORDER_STATUS.PENDING,
@@ -521,8 +571,6 @@ export async function generateReleaseGoodFunction(
       newReleaseGood.arrivalNotice = crossDockingGAN
     }
 
-    newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
-
     // Make relation with RO for cross docking
     if (newReleaseGood.crossDocking) {
       crossDockingGAN.releaseGood = newReleaseGood
@@ -572,6 +620,9 @@ export async function generateReleaseGoodFunction(
 
     orderInventories = [...singleProductOIs, ...splitBundleOIs]
 
+    newReleaseGood.noOfItems = orderInventories.length
+    newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
+
     for (let oi of orderInventories) {
       let newOrderInv: OrderInventory = Object.assign({}, oi)
       newOrderInv = {
@@ -683,193 +734,6 @@ export async function generateReleaseGoodFunction(
   }
 }
 
-export async function bulkReleaseGoodsAvailableItemsFunction(
-  rawReleaseGoods: any[],
-  bizplaceId: string,
-  context: any,
-  tx?: EntityManager
-): Promise<any[]> {
-  const { domain }: { domain: Domain } = context.state
-  const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
-
-  if (!rawReleaseGoods) return
-
-  const json_oi = JSON.stringify(
-    rawReleaseGoods.map(raw => {
-      return {
-        sku: raw.sku,
-        packing_type: raw.packingType,
-        packing_size: raw.packingSize,
-        uom: raw.uom,
-        release_qty: raw.releaseQty
-      }
-    })
-  )
-
-  await tx.query(
-    `
-        CREATE TEMP TABLE temp_order_products(
-          product_id VARCHAR(50),
-          sku VARCHAR(150),
-          packing_type VARCHAR(50),
-          packing_size INT,
-          uom VARCHAR(10),
-          release_qty INT
-          );
-      `
-  )
-
-  await tx.query(
-    `
-        INSERT INTO temp_order_products
-        SELECT p.id AS product_id, js.sku,
-        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
-        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
-        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END,
-        js.release_qty
-        FROM JSON_POPULATE_RECORDSET(NULL::temp_order_products,'${json_oi}') js
-        LEFT JOIN products p ON js.sku = p.sku AND p.bizplace_id = $1
-        LEFT JOIN product_details pd ON p.id = pd.product_id AND pd.is_default = TRUE;
-      `,
-    [companyBizplaceId.id]
-  )
-
-  let availableItems = await tx.query(
-    `
-        SELECT i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom,
-          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
-            (
-              SELECT SUM(oi.release_qty) FROM order_inventories oi 
-              WHERE (
-                oi.status = 'PENDING'
-                OR oi.status = 'PENDING_RECEIVE'
-                OR oi.status = 'PENDING_WORKSHEET'
-                OR oi.status = 'PENDING_SPLIT'
-              )
-              AND oi.inventory_id IS null
-              AND oi.product_id = i.product_id::uuid
-              AND oi.packing_type = i.packing_type
-              AND oi.uom = i.uom
-              AND oi.domain_id = $1
-              AND oi.bizplace_id = $2
-            ), 0) as "remain_qty",
-          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
-            (
-              SELECT SUM(oi.release_uom_value) FROM order_inventories oi 
-              WHERE (
-                oi.status = 'PENDING'
-                OR oi.status = 'PENDING_RECEIVE'
-                OR oi.status = 'PENDING_WORKSHEET'
-                OR oi.status = 'PENDING_SPLIT'
-              )
-              AND oi.inventory_id IS null
-              AND oi.product_id = i.product_id::uuid
-              AND oi.packing_type = i.packing_type
-              AND oi.uom = i.uom
-              AND oi.domain_id = $1
-              AND oi.bizplace_id = $2
-            ), 0) as "remain_uom_value"
-        FROM inventories i
-        INNER JOIN (
-          SELECT top.product_id, top.sku, top.packing_type, top.packing_size, top.uom 
-          FROM temp_order_products top
-          GROUP BY top.product_id, top.sku, top.packing_type, top.packing_size, top.uom
-        ) AS foo
-        ON i.product_id = foo.product_id::uuid
-        AND i.packing_type = foo.packing_type
-        AND i.packing_size = foo.packing_size
-        AND i.uom = foo.uom
-        AND i.domain_id = $1
-        AND i.bizplace_id = $2
-        GROUP BY i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom
-        ORDER BY foo.sku, remain_qty
-      `,
-    [domain.id, bizplaceId]
-  )
-
-  await tx.query('DROP TABLE temp_order_products')
-
-  availableItems = availableItems.map(item => {
-    return {
-      productId: item.product_id,
-      sku: item.sku,
-      batchId: item.batch_id,
-      packingType: item.packing_type,
-      packingSize: item.packing_size,
-      uom: item.uom,
-      remainQty: item.remain_qty,
-      remainUomValue: item.remain_uom_value
-    }
-  })
-
-  return _extractData(rawReleaseGoods, availableItems)
-}
-
-function _extractData(rawData, validatedData) {
-  return rawData.map(raw => {
-    const idx = validatedData.findIndex(val => {
-      const comparison = ['packingType', 'packingSize', 'uom']
-
-      let a: any = {},
-        b: any = {}
-
-      comparison.forEach(cc => {
-        if (raw[cc]) {
-          a[cc] = raw[cc]
-          b[cc] = val[cc]
-        }
-      })
-
-      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
-      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
-
-      return val.sku == raw.sku && a === b
-    })
-
-    let releaseUomValue = 0
-
-    // if sku is matched, assign qty and product id
-    if (idx >= 0) {
-      // assign qty to rawData as much as possible
-      releaseUomValue =
-        (Math.round((validatedData[idx]?.remainUomValue / validatedData[idx]?.remainQty) * 100) / 100) * raw.releaseQty
-
-      raw.assignedQty =
-        validatedData[idx].remainQty >= raw.releaseQty
-          ? raw.releaseQty > 0
-            ? raw.releaseQty
-            : 0
-          : validatedData[idx].remainQty
-
-      raw.assignedUomValue =
-        validatedData[idx].remainUomValue >= releaseUomValue
-          ? releaseUomValue > 0
-            ? releaseUomValue
-            : 0
-          : validatedData[idx].remainUomValue
-
-      // deduct qty & uomValue from validateData
-      validatedData[idx].remainQty -= raw.assignedQty
-      validatedData[idx].remainUomValue -= raw.assignedUomValue
-
-      raw.productId = validatedData[idx].productId
-      raw.packingType = validatedData[idx].packingType
-      raw.packingSize = validatedData[idx].packingSize
-      raw.uom = validatedData[idx].uom
-      raw.batchId = validatedData[idx].batchId
-    } else {
-      raw.assignedQty = 0
-      raw.assignedUomValue = 0
-      raw.productId = null
-    }
-
-    return {
-      ...raw,
-      releaseUomValue
-    }
-  })
-}
-
 export async function confirmReleaseGood(name: string, context: any, tx?: EntityManager): Promise<ReleaseGood> {
   const { user, domain }: { user: User; domain: Domain } = context.state
 
@@ -883,6 +747,7 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
       'bizplace.company.domain',
       'orderProducts',
       'orderProducts.product',
+      'orderProducts.product.productDetails',
       'orderInventories',
       'orderInventories.product',
       'orderVass'
@@ -891,26 +756,77 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
 
   if (!foundReleaseGood) throw new Error(`Release good order doesn't exists.`)
   let foundOIs: OrderInventory[] = foundReleaseGood.orderInventories
+  let foundBundleInfo: any[] = JSON.parse(foundReleaseGood.bundleInfo)
   let foundOVs: OrderVas[] = foundReleaseGood.orderVass
+  let foundOPs: OrderProduct[] = foundReleaseGood.orderProducts
   let customerBizplace: Bizplace = foundReleaseGood.bizplace
   const companyDomain: Domain = customerBizplace?.company.domain
+  const sellercraft: Sellercraft = await tx
+    .getRepository(Sellercraft)
+    .findOne({ domain: foundReleaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
   if (foundReleaseGood.type == 'b2c') {
-    const sellercraft: Sellercraft = await tx
-      .getRepository(Sellercraft)
-      .findOne({ domain: foundReleaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
-
     if (sellercraft) {
       const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
       foundReleaseGood = await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
     } else {
       // find for any existing marketplace store connections
-      const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-        where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+      let marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+        where: { domain: companyDomain, status: 'ACTIVE' },
         relations: ['marketplaceDistributors']
       })
 
+      const foundMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { domain: companyDomain, orderNo: foundReleaseGood.refNo },
+        relations: ['marketplaceStore']
+      })
+
+      let matchedMarketplaceStore: MarketplaceStore
+      if (foundMarketplaceOrder) {
+        matchedMarketplaceStore = marketplaceStores.filter(
+          marketplaceStore => marketplaceStore.id != foundMarketplaceOrder.marketplaceStore.id
+        )[0]
+      }
+
+      let combinedOrderInventories: any[] = foundOIs.map(oi => {
+        return {
+          sku: oi.product.sku,
+          releaseQty: oi.releaseQty
+        }
+      })
+
+      if (foundBundleInfo?.length) {
+        foundBundleInfo.map(bundle => {
+          combinedOrderInventories.push({
+            sku: bundle.sku,
+            releaseQty: bundle.releaseQty
+          })
+        })
+      }
+
+      for (let oi of combinedOrderInventories) {
+        let foundMarketplaceProductVariations: MarketplaceProductVariation[] = await tx
+          .getRepository(MarketplaceProductVariation)
+          .find({
+            where: { domain: companyDomain, sku: oi.sku },
+            relations: ['marketplaceProduct', 'marketplaceProduct.marketplaceStore']
+          })
+
+        if (foundMarketplaceProductVariations) {
+          await Promise.all(
+            foundMarketplaceProductVariations.map(async variation => {
+              if (variation.marketplaceProduct.marketplaceStore.id != matchedMarketplaceStore.id) {
+                variation.reserveQty -= oi.releaseQty
+
+                await tx.getRepository(MarketplaceProductVariation).save(variation)
+              }
+            })
+          )
+        }
+      }
+
       if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+        marketplaceStores = marketplaceStores.filter(marketplaceStore => marketplaceStore.isAutoUpdateStockQty)
         let productIds: string[] = foundOIs.map(oi => oi.product.id)
         productIds = Array.from(new Set([...productIds]))
         const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
@@ -919,6 +835,13 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
     }
   }
 
+  if (foundReleaseGood.type == 'b2b') {
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.updateSellercraftStock(sellercraft, foundOPs, 'CONFIRM_ORDER')
+    }
+  }
+
   // 1. RO Status change (PENDING => PENDING_RECEIVE)
   const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).save({
     ...foundReleaseGood,
@@ -1079,7 +1002,17 @@ export async function rejectReleaseGood(
 
   const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
     where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
-    relations: ['bizplace', 'orderInventories', 'orderInventories.inventory', 'orderVass', 'shippingOrder']
+    relations: [
+      'bizplace',
+      'bizplace.domain',
+      'orderProducts',
+      'orderProducts.product',
+      'orderProducts.product.productDetails',
+      'orderInventories',
+      'orderInventories.inventory',
+      'orderVass',
+      'shippingOrder'
+    ]
   })
 
   if (!releaseGood) throw new Error(`Release good doesn't exists.`)
@@ -1087,6 +1020,7 @@ export async function rejectReleaseGood(
 
   let foundOIs: OrderInventory[] = releaseGood.orderInventories
   let foundOVs: OrderVas[] = releaseGood.orderVass
+  let foundOPs: OrderProduct[] = releaseGood.orderProducts
 
   // 1. Update status of order products (PENDING_RECEIVE => REJECTED)
   if (foundOIs && foundOIs.length) {
@@ -1112,6 +1046,27 @@ export async function rejectReleaseGood(
     )
   }
 
+  if (foundOPs && foundOPs.length) {
+    const sellercraft: Sellercraft = await tx
+      .getRepository(Sellercraft)
+      .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.updateSellercraftStock(sellercraft, foundOPs, 'REJECT_ORDER')
+    }
+
+    await tx.getRepository(OrderProduct).save(
+      await Promise.all(
+        foundOPs.map(async (op: OrderProduct) => {
+          op.status = ORDER_PRODUCT_STATUS.REJECTED
+          op.updater = user
+          return op
+        })
+      )
+    )
+  }
+
   // 2. Update status of order vass if it exists (PENDING_RECEIVE => REJECTED)
   if (foundOVs && foundOVs.length) {
     foundOVs = foundOVs.map((ov: OrderVas) => {
@@ -1159,7 +1114,7 @@ export async function rejectReleaseGood(
   return releaseGood
 }
 
-export async function bulkGenerateReleaseGoods(
+export async function bulkGenerateReleaseGood(
   releaseGood: any,
   bizplaceId: string,
   roNoSetting: any,
@@ -1184,7 +1139,6 @@ export async function bulkGenerateReleaseGoods(
       deliveryAddress2: releaseGood?.deliveryAddress2 || null,
       deliveryAddress3: releaseGood?.deliveryAddress3 || null,
       deliveryAddress4: releaseGood?.deliveryAddress4 || null,
-      deliveryAddress5: releaseGood?.deliveryAddress5 || null,
       attentionTo: releaseGood?.attentionTo || null,
       attentionCompany: releaseGood?.attentionCompany || null,
       city: releaseGood?.city || null,
@@ -1206,40 +1160,82 @@ export async function bulkGenerateReleaseGoods(
     }
 
     newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
+    let finalOrderInventories: OrderInventory[] = []
 
+    // pre assign inventory to orderInventories
     for (let oi of orderInventories) {
-      delete oi.sku
+      const pickingProductSetting: Setting = await tx.getRepository(Setting).findOne({
+        where: { domain, name: 'rule-for-picking-product' }
+      })
 
-      let newOrderInv: OrderInventory = Object.assign(new OrderInventory(), oi)
-      newOrderInv = {
-        ...newOrderInv,
+      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 })
+        }
+      }
+
+      const product: Product = await tx.getRepository(Product).findOne(oi.productId)
+
+      finalOrderInventories.push(
+        ...(await InventoryUtil.autoAssignInventoryForRelease(
+          product,
+          oi,
+          oi.packingType,
+          locationSortingRules,
+          bizplace,
+          warehouseDomain,
+          tx
+        ))
+      )
+    }
+
+    for (let oi of finalOrderInventories) {
+      let generatedOI: OrderInventory = Object.assign(new OrderInventory(), oi)
+      generatedOI = {
+        ...generatedOI,
         domain: warehouseDomain,
-        bizplace: bizplace,
+        bizplace,
         status: ORDER_INVENTORY_STATUS.PENDING,
         name: OrderNoGenerator.orderInventory(),
-        batchId: oi?.batchId || '',
         releaseGood: newReleaseGood,
-        product: await tx.getRepository(Product).findOne(oi.productId),
         creator: user,
         updater: user
       }
 
-      let newOrderProduct: OrderProduct = Object.assign(new OrderProduct(), newOrderInv)
-      newOrderProduct = {
-        ...newOrderProduct,
+      let newOrderProduct: Partial<OrderProduct> = {
+        name: generatedOI.name,
+        product: generatedOI.product,
+        batchId: generatedOI.batchId,
+        packingType: generatedOI.packingType,
+        packingSize: generatedOI.packingSize,
+        uom: generatedOI.uom,
+        domain: warehouseDomain,
+        bizplace,
+        releaseQty: generatedOI.releaseQty,
+        releaseUomValue: generatedOI.releaseUomValue,
         packQty: 0,
         actualPackQty: 0,
         palletQty: 0,
         actualPalletQty: 0,
-        status: ORDER_PRODUCT_STATUS.PENDING_ASSIGN
+        status: ORDER_PRODUCT_STATUS.PENDING_ASSIGN,
+        releaseGood: newReleaseGood,
+        creator: user,
+        updater: user
       }
 
       newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
 
-      await tx.getRepository(OrderInventory).save({ ...newOrderInv, orderProduct: newOrderProduct })
-    }
+      await tx.getRepository(OrderInventory).save({ ...generatedOI, orderProduct: newOrderProduct })
 
-    // Change the status to PENDING_RECEIVE
+      // 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
+      })
+    }
 
     return newReleaseGood
   } catch (error) {
@@ -1270,7 +1266,7 @@ export async function bulkConfirmReleaseGoods(
     ]
   })
 
-  if (!foundReleaseGoods.length) throw new Error(`Release good order doesn't exists.`)
+  if (!foundReleaseGoods.length) throw new Error(`release good order doesn't exists.`)
   let customerBizplace: Bizplace = foundReleaseGoods[0].bizplace
 
   let foundOrderInventories: OrderInventory[] = foundReleaseGoods
@@ -1333,7 +1329,7 @@ export async function bulkConfirmReleaseGoods(
   })
 }
 
-export function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
+function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
   return rawReleaseGoods.reduce((releaseGoods, item) => {
     const idx: number = releaseGoods.findIndex(rg => {
       // consider these attributes if they are exist in "item"
@@ -1370,6 +1366,7 @@ export function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]>
         oi => oi.sku === item.sku && oi.packingType === item.packingType && oi.packingSize === item.packingSize
       )
 
+      // if there is duplicated SKU, merge them and sum up the releaseQty
       if (duplicateSkuIdx >= 0) {
         releaseGoods[idx].orderInventories[duplicateSkuIdx].releaseQty += item.releaseQty
       } else {