@things-factory/sales-base 3.8.8 → 3.8.12

package/server/controllers/order-controller.ts

@@ -1,6 +1,12 @@
+import { EntityManager, EntitySchema, FindOneOptions } from 'typeorm'
+
 import { Role, User } from '@things-factory/auth-base'
 import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
 import { sendNotification } from '@things-factory/notification'
+import { ProductDetail } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
 import {
   ArrivalNotice,
   DeliveryOrder,
@@ -12,9 +18,6 @@ import {
   ReturnOrder,
   VasOrder
 } from '../entities'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { EntityManager, EntitySchema, FindOneOptions } from 'typeorm'
 
 export type ReferenceOrderType = ArrivalNotice | ReleaseGood | VasOrder | InventoryCheck | DeliveryOrder | ReturnOrder
 export type OrderTargetTypes = OrderProduct | OrderInventory | OrderVas
@@ -48,7 +51,9 @@ export type NotificationMsgInterface = {
 export class OrderController {
   public readonly ERROR_MSG = {
     FIND: {
-      NO_RESULT: (condition: any) => `There's no results matched with condition ${condition}`
+      NO_RESULT: (condition: any) => `There's no results matched with condition ${condition}`,
+      NO_CHILD_RESULT: (condition: any) => `There's no child result matched with condition ${condition}`,
+      NOT_MATCH: (source: any, target: any) => `Unable to find matching ${target} using ${source}`
     },
     CREATE: {
       ID_EXISTS: 'Target has ID already',
@@ -217,6 +222,54 @@ export class OrderController {
     return await this.trxMgr.getRepository(Inventory).save(inventory)
   }
 
+  async getChildPackingSize(
+    productDetails: ProductDetail[],
+    defaultProductDetail: ProductDetail,
+    unmatchingProductDetail: ProductDetail
+  ): Promise<number> {
+    let hasChildRelation: boolean = Boolean(unmatchingProductDetail?.childProductDetail)
+    let hasMatchingChild: boolean
+    let packingSize: number = 1
+    let currentChildProductDetail: ProductDetail
+
+    if (hasChildRelation) {
+      currentChildProductDetail = productDetails.find(
+        (productDetail: ProductDetail) => productDetail.id === unmatchingProductDetail.childProductDetail.id
+      )
+
+      if (!currentChildProductDetail) {
+        throw new Error(this.ERROR_MSG.FIND.NOT_MATCH('packing type', `GTIN (${unmatchingProductDetail.gtin})`))
+      }
+
+      hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id)
+      if (hasMatchingChild) {
+        packingSize = unmatchingProductDetail.packingSize
+      } else {
+        packingSize = unmatchingProductDetail.packingSize * packingSize
+      }
+    } else {
+      throw new Error(this.ERROR_MSG.FIND.NO_CHILD_RESULT(`${unmatchingProductDetail.gtin}`))
+    }
+
+    while (hasChildRelation && !hasMatchingChild) {
+      if (hasMatchingChild) {
+        packingSize = currentChildProductDetail.packingSize * packingSize // 12 x 10
+      } else if (!hasMatchingChild && hasChildRelation) {
+        packingSize = currentChildProductDetail.packingSize * packingSize // 12 x 10
+        currentChildProductDetail = productDetails.find(
+          (productDetail: ProductDetail) => productDetail.id === currentChildProductDetail.childProductDetail.id
+        )
+
+        hasChildRelation = Boolean(currentChildProductDetail?.childProductDetail)
+        hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id)
+      } else if (!hasChildRelation && !hasMatchingChild) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(unmatchingProductDetail.gtin))
+      }
+    }
+
+    return packingSize
+  }
+
   /**
    * @summary set common stamp like domain, creator, updater
    * @description Set common stamp to passed record

package/server/entities/release-good.ts

@@ -219,6 +219,9 @@ export class ReleaseGood {
   @Column({ nullable: true })
   invoice: string
 
+  @Column({ nullable: true })
+  bundleInfo: string
+
   @Column({ type: 'int', nullable: true })
   noOfItems: number
 

package/server/graphql/resolvers/release-good/bulk-add-release-goods.ts

@@ -1,4 +1,4 @@
-import { EntityManager, getRepository, In, Repository } from 'typeorm'
+import { EntityManager, getConnection, getRepository, In, Repository } from 'typeorm'
 
 import { Role, User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
@@ -7,6 +7,7 @@ import { sendNotification } from '@things-factory/notification'
 import { Product } from '@things-factory/product-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
 
 import { ORDER_STATUS } from '../../../constants'
 import {
@@ -17,6 +18,7 @@ import {
 } from '../../../constants/order'
 import { OrderInventory, OrderProduct, ReleaseGood } from '../../../entities'
 import { ValidationError } from '../../../errors'
+import { InventoryUtil } from '../../../utils'
 import { OrderNoGenerator } from '../../../utils/order-no-generator'
 import { bulkReleaseGoodsAvailableItemsFunction } from './bulk-release-goods-available-items'
 
@@ -38,46 +40,70 @@ export const bulkAddReleaseGoods = {
 
     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
-      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) }
+      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)
+      }
+    }
 
-      // update orderInventories if availableItems are valid
-      releaseGoods[i].orderInventories = availableItems
-
-      const createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGoods(
-        _,
-        releaseGoods[i],
-        bizplaceId,
-        roNoSetting,
+    let confirmedReleaseGoods: ReleaseGood[] = []
+    try {
+      confirmedReleaseGoods = await bulkConfirmReleaseGoods(
+        createdReleaseGoods.map(rg => rg.name),
         domain,
         user,
+        context,
         tx
       )
-
-      createdReleaseGoods.push(createdReleaseGood)
+    } catch (e) {
+      errorsFound.push(e)
     }
 
-    let confirmedReleaseGoods: ReleaseGood[] = await bulkConfirmReleaseGoods(
-      createdReleaseGoods.map(rg => rg.name),
-      domain,
-      user,
-      context,
-      tx
-    )
+    // if (errorsFound.length) { then ?? }
 
     return confirmedReleaseGoods
   }
@@ -109,7 +135,6 @@ 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,
@@ -131,40 +156,82 @@ 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) {
@@ -195,7 +262,7 @@ 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
@@ -295,6 +362,7 @@ 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/graphql/resolvers/release-good/bulk-release-goods-available-items.ts

@@ -2,6 +2,7 @@ import { EntityManager } from 'typeorm'
 
 import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
 import { Domain } from '@things-factory/shell'
+import { LOCATION_TYPE } from '@things-factory/warehouse-base'
 
 export const bulkReleaseGoodsAvailableItems = {
   async bulkReleaseGoodsAvailableItems(_: any, { rawReleaseGoods, bizplaceId }, context: any) {
@@ -47,6 +48,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),
@@ -59,6 +61,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,
@@ -72,16 +76,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
@@ -92,12 +92,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
@@ -106,10 +101,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
@@ -117,10 +114,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')
@@ -128,6 +127,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,
@@ -162,33 +162,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

package/server/graphql/resolvers/release-good/confirm-release-good.ts

@@ -4,12 +4,13 @@ import { Role, User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-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 { Domain } from '@things-factory/shell'
 
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
 import { EcommerceController, SellercraftController } from '../../../controllers'
-import { OrderInventory, OrderVas, ReleaseGood } from '../../../entities'
+import { OrderInventory, OrderProduct, OrderVas, ReleaseGood } from '../../../entities'
 import { confirmArrivalNoticeFunction } from '../arrival-notice/confirm-arrival-notice'
 
 export const confirmReleaseGoodResolver = {
@@ -46,6 +47,7 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
       'bizplace.company.domain',
       'orderProducts',
       'orderProducts.product',
+      'orderProducts.product.productDetails',
       'orderInventories',
       'orderInventories.product',
       'orderVass'
@@ -54,26 +56,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)
@@ -82,6 +135,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,

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

@@ -222,6 +222,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,