@things-factory/sales-base 4.0.21 → 4.0.25

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

@@ -1,6 +1,6 @@
 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'
@@ -15,11 +15,12 @@ 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'
 import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
+import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
 
 import {
   ArrivalNotice,
@@ -51,6 +52,96 @@ import { ReleaseGood } from './release-good'
 
 @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 bulkGenerateReleaseGoods(
+            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 = {
@@ -711,6 +762,7 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
         CREATE TEMP TABLE temp_order_products(
           product_id VARCHAR(50),
           sku VARCHAR(150),
+          product_info VARCHAR(250),
           packing_type VARCHAR(50),
           packing_size INT,
           uom VARCHAR(10),
@@ -723,6 +775,8 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
     `
         INSERT INTO temp_order_products
         SELECT p.id AS product_id, js.sku,
+        CASE WHEN p.description NOT IN (NULL, '', '-') THEN CONCAT(p.name, '(', p.description, ')')
+          ELSE p.name END AS product_info,
         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,
@@ -736,16 +790,12 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
 
   let availableItems = await tx.query(
     `
-        SELECT i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom,
+      WITH inv AS (
+        SELECT i.product_id, foo.sku, foo.product_info, 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'
-              )
+              WHERE oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')
               AND oi.inventory_id IS null
               AND oi.product_id = i.product_id::uuid
               AND oi.packing_type = i.packing_type
@@ -756,12 +806,7 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
           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'
-              )
+              WHERE oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')
               AND oi.inventory_id IS null
               AND oi.product_id = i.product_id::uuid
               AND oi.packing_type = i.packing_type
@@ -770,10 +815,12 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
               AND oi.bizplace_id = $2
             ), 0) as "remain_uom_value"
         FROM inventories i
+        LEFT JOIN locations l
+        ON i.location_id = l.id
         INNER JOIN (
-          SELECT top.product_id, top.sku, top.packing_type, top.packing_size, top.uom 
+          SELECT top.product_id, top.sku, top.product_info, 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
+          GROUP BY top.product_id, top.sku, top.product_info, 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
@@ -781,10 +828,12 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
         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
+        WHERE l.type NOT IN ($3, $4)
+        GROUP BY i.product_id, foo.sku,foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom
         ORDER BY foo.sku, remain_qty
-      `,
-    [domain.id, bizplaceId]
+      ) SELECT * FROM inv WHERE remain_qty > 0
+    `,
+    [domain.id, bizplaceId, LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
   )
 
   await tx.query('DROP TABLE temp_order_products')
@@ -792,6 +841,7 @@ export async function bulkReleaseGoodsAvailableItemsFunction(
   availableItems = availableItems.map(item => {
     return {
       productId: item.product_id,
+      productInfo: item.product_info,
       sku: item.sku,
       batchId: item.batch_id,
       packingType: item.packing_type,
@@ -826,33 +876,41 @@ function _extractData(rawData, validatedData) {
       return val.sku == raw.sku && a === b
     })
 
-    let releaseUomValue = 0
+    let releaseUomValue: number = 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
+      const uomValuePerQty: number =
+        Math.round((validatedData[idx].remainUomValue / validatedData[idx].remainQty) * 100) / 100
 
+      // use Math.round again because 4.2 * 6 = 25.200000000000003
+      releaseUomValue = Math.round(uomValuePerQty * raw.releaseQty * 100) / 100
+
+      // assign qty to rawData as much as possible
       raw.assignedQty =
         validatedData[idx].remainQty >= raw.releaseQty
           ? raw.releaseQty > 0
             ? raw.releaseQty
             : 0
-          : validatedData[idx].remainQty
+          : validatedData[idx].remainQty > 0
+          ? validatedData[idx].remainQty
+          : 0
 
       raw.assignedUomValue =
         validatedData[idx].remainUomValue >= releaseUomValue
           ? releaseUomValue > 0
             ? releaseUomValue
             : 0
-          : validatedData[idx].remainUomValue
+          : validatedData[idx].remainUomValue > 0
+          ? validatedData[idx].remainUomValue
+          : 0
 
       // deduct qty & uomValue from validateData
       validatedData[idx].remainQty -= raw.assignedQty
       validatedData[idx].remainUomValue -= raw.assignedUomValue
 
       raw.productId = validatedData[idx].productId
+      raw.productInfo = validatedData[idx].productInfo
       raw.packingType = validatedData[idx].packingType
       raw.packingSize = validatedData[idx].packingSize
       raw.uom = validatedData[idx].uom
@@ -883,6 +941,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 +950,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 +1029,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 +1196,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 +1214,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 +1240,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) => {
@@ -1184,7 +1333,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 +1354,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 +1460,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 +1523,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 +1560,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 {

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

@@ -158,6 +158,9 @@ export class NewReleaseGood {
   @Field({ nullable: true })
   name: string
 
+  @Field({ nullable: true })
+  bundleInfo: string
+
   @Field({ nullable: true })
   releaseDate: string
 
@@ -323,6 +326,9 @@ export class NewReleaseGood {
 
 @InputType()
 export class ReleaseGoodPatch {
+  @Field({ nullable: true })
+  id: string
+
   @Field({ nullable: true })
   name: string