@things-factory/sales-base 4.3.448 → 4.3.452

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

@@ -1,9 +1,17 @@
-import { FileUpload, GraphQLUpload } from 'graphql-upload'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import {
+  FileUpload,
+  GraphQLUpload
+} from 'graphql-upload'
+import {
+  Arg,
+  Ctx,
+  Directive,
+  Mutation,
+  Resolver
+} from 'type-graphql'
 import {
   Brackets,
   EntityManager,
-  getConnection,
   getRepository,
   ILike,
   In,
@@ -12,19 +20,34 @@ import {
   SelectQueryBuilder
 } from 'typeorm'
 
-import { Attachment, createAttachments, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+import {
+  Attachment,
+  createAttachments,
+  deleteAttachmentsByRef
+} from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaces } from '@things-factory/biz-base'
-import { logger } from '@things-factory/env'
+import {
+  Bizplace,
+  getPermittedBizplaces
+} from '@things-factory/biz-base'
 import { GeoCountry } from '@things-factory/geography'
 import { generateId } from '@things-factory/id-rule-base'
 import { LastMileDelivery } from '@things-factory/integration-lmd'
-import { Product, ProductBundle, ProductDetail } from '@things-factory/product-base'
-import { PartnerSetting, Setting } from '@things-factory/setting-base'
+import {
+  Product,
+  ProductBundle,
+  ProductDetail
+} from '@things-factory/product-base'
+import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 
 // import { Location } from '@things-factory/warehouse-base'
-import { DraftReleaseGood, DraftReleaseGoodPatch, NewDraftReleaseGood, OrderProduct } from '../'
+import {
+  DraftReleaseGood,
+  DraftReleaseGoodPatch,
+  NewDraftReleaseGood,
+  OrderProduct
+} from '../'
 import {
   ATTACHMENT_TYPE,
   DRAFT_RELEASE_ORDER_STATUS,
@@ -32,12 +55,8 @@ import {
   ORDER_NUMBER_SETTING_KEY,
   ORDER_STATUS
 } from '../../constants'
-import { ValidationError } from '../../errors'
-import { InventoryUtil, OrderNoGenerator } from '../../utils'
+import { OrderNoGenerator } from '../../utils'
 import { OrderProductPatch } from '../order-product/order-product-types'
-import { ReleaseGood } from '../release-good/release-good'
-import { bulkGenerateReleaseGood, confirmReleaseGood, receiveReleaseGood } from '../release-good/release-good-mutation'
-import { bulkReleaseGoodsAvailableItemsFunction } from '../release-good/release-good-query'
 import { ShippingOrder } from '../shipping-order/shipping-order'
 import { ShippingOrderPatch } from '../shipping-order/shipping-order-types'
 // import {
@@ -187,277 +206,6 @@ export class DraftReleaseGoodMutation {
 
     return true
   }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To generate Release Goods from Draft' })
-  async generateReleaseGoodsFromDraft(
-    @Ctx() context: any,
-    @Arg('ids', type => [String]) ids: string[]
-    // @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
-    // @Arg('bizplaceId', type => String) bizplaceId: string
-  ): Promise<boolean> {
-    const { domain, user, tx } = context.state
-    try {
-      const updatableDraftOrders = await tx.getRepository(DraftReleaseGood).find({
-        where: {
-          domain,
-          id: In(ids),
-          status: DRAFT_RELEASE_ORDER_STATUS.DRAFT
-        },
-        relations: [
-          'orderProducts',
-          'orderProducts.product',
-          'orderProducts.productBundle',
-          'orderProducts.productBundle.productBundleSettings',
-          'orderProducts.productBundle.productBundleSettings.product',
-          'orderProducts.productBundle.productBundleSettings.productDetail',
-          'shippingOrder',
-          'bizplace',
-          'bizplace.domain',
-          'domain',
-          'creator',
-          'updater',
-          'lastMileDelivery'
-        ]
-      })
-
-      if (updatableDraftOrders.length > 0) {
-        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
-          }
-        })
-
-        for (let index = 0; index < updatableDraftOrders.length; index++) {
-          await getConnection().transaction(async (parentTx: EntityManager) => {
-            const draftOrder = updatableDraftOrders[index]
-
-            let foundPermittedBizplace: Bizplace
-            let companyBizplace: Bizplace
-
-            if (draftOrder?.bizplace?.id) {
-              foundPermittedBizplace = await parentTx.getRepository(Bizplace).findOne(draftOrder.bizplace.id, {
-                relations: ['company', 'company.domain']
-              })
-              const companyDomain: Domain = foundPermittedBizplace.company.domain
-              companyBizplace = await parentTx.getRepository(Bizplace).findOne({ where: { domain: companyDomain } })
-            } else {
-              return false
-            }
-
-            const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
-
-            let loggerJson = JSON.stringify({ refNo: draftOrder.refNo, bizplaceId: draftOrder.bizplace.id, domain })
-            try {
-              console.time(`creating_order:${loggerJson}`)
-
-              let productInventory = await InventoryUtil.bizplaceProductInventory(
-                bizplaces,
-                {
-                  filters: [
-                    {
-                      name: 'productId',
-                      operator: 'in',
-                      value: [
-                        ...draftOrder.orderProducts
-                          .filter(itm => itm?.product)
-                          .map(itm => {
-                            return itm.product.id
-                          }),
-                        ...draftOrder.orderProducts
-                          .filter(itm => itm?.productBundle)
-                          .map(itm => {
-                            return itm.productBundle.productBundleSettings.map(itm => {
-                              return itm.product.id
-                            })
-                          })
-                      ]
-                    }
-                  ]
-                },
-                context,
-                parentTx
-              )
-
-              draftOrder.orderProducts = draftOrder.orderProducts.map(itm => {
-                let foundProductInv
-                if(itm.product){
-                  foundProductInv = productInventory.items.find(
-                    i =>
-                      (i.productDetailId == itm?.productDetailId || i.productId == itm?.productBundle?.id) &&
-                      itm.releaseQty <= i.remainQty
-                  )
-                } else {
-                  itm.productBundle.productBundleSettings.map(pbs => {
-                    foundProductInv = productInventory.items.find(
-                      i =>
-                        (i.productDetailId == pbs?.productDetail.id || i.productId == pbs?.product?.id) &&
-                        itm.releaseQty <= i.remainQty
-                    )
-                  })
-                }
-                return {
-                  ...itm,
-                  releaseUomValue: (foundProductInv.remainUomValue / foundProductInv.remainQty) * itm.releaseQty,
-                  status: foundProductInv ? 'suffice' : 'insufficient'
-                }
-              })
-
-              let insufficient = draftOrder.orderProducts.find(op => op.status == 'insufficient')
-              if (!insufficient) {
-                //create RO
-                let releaseGood = { ...draftOrder }
-                delete releaseGood.id
-                delete releaseGood.name
-                delete releaseGood.createdAt
-                delete releaseGood.createdBy
-                delete releaseGood.updatedAt
-                delete releaseGood.updatedBy
-
-                let orderInventories = []
-
-                for (let index = 0; index < draftOrder.orderProducts.length; index++) {
-                  const itm: Partial<OrderProduct> = draftOrder.orderProducts[index]
-                  let data = []
-                  if (itm.productBundle) {
-                    let bundle: ProductBundle = await parentTx.getRepository(ProductBundle).findOne({
-                      where: { id: itm.productBundle.id },
-                      relations: [
-                        'productBundleSettings',
-                        'productBundleSettings.productDetail',
-                        'productBundleSettings.product'
-                      ]
-                    })
-
-                    for (let index2 = 0; index2 < bundle.productBundleSettings.length; index2++) {
-                      const objProductBundleSetting = bundle.productBundleSettings[index2]
-                      data.push({
-                        sku: objProductBundleSetting.product.sku,
-                        packingType: objProductBundleSetting.productDetail.packingType,
-                        packingSize: objProductBundleSetting.productDetail.packingSize,
-                        uom: objProductBundleSetting.productDetail.uom,
-                        releaseQty: objProductBundleSetting.bundleQty * itm.releaseQty,
-                        assignedQty: undefined,
-                        assignedUomValue: undefined,
-                        releaseUomValue: objProductBundleSetting.bundleQty * itm.releaseQty * itm.releaseUomValue
-                      })
-                    }
-                  } else {
-                    data = [
-                      {
-                        sku: itm.product.sku,
-                        packingType: itm.packingType,
-                        packingSize: itm.packingSize,
-                        uom: itm.uom,
-                        releaseQty: itm.releaseQty,
-                        assignedQty: undefined,
-                        assignedUomValue: undefined,
-                        releaseUomValue: itm.releaseUomValue
-                      }
-                    ]
-                  }
-
-                  data.forEach(data => {
-                    let existingOI = orderInventories.find(
-                      itm =>
-                        itm.sku == data.sku &&
-                        itm.packingType == data.packingType &&
-                        itm.packingSize == data.packingSize &&
-                        itm.uom == data.uom
-                    )
-
-                    if (existingOI) {
-                      existingOI.releaseQty = existingOI.releaseQty + data.releaseQty
-                      existingOI.releaseUomValue = existingOI.releaseUomValue + data.uomValue
-                      existingOI.uomValue = existingOI.uomValue + data.uomValue
-                    } else {
-                      orderInventories.push({ ...data, orderProduct: itm })
-                    }
-                  })
-                }
-                await getConnection().transaction(async (childTx: EntityManager) => {
-                  let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
-                    orderInventories,
-                    draftOrder.bizplace.id,
-                    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
-                  releaseGood.noOfItems = orderInventories.length
-
-                  releaseGood.orderInventories = availableItems.map(itm => {
-                    return {
-                      ...itm,
-                      releaseQty: itm.releaseQty,
-                      releaseUomValue: itm.releaseUomValue,
-                      uomValue: itm.uomValue
-                    }
-                  })
-                  let createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
-                    releaseGood,
-                    releaseGood.bizplace.id,
-                    roNoSetting,
-                    domain,
-                    user,
-                    childTx
-                  )
-                  await childTx
-                    .getRepository(DraftReleaseGood)
-                    .update(
-                      { id: draftOrder.id },
-                      { releaseGood: createdReleaseGood, status: DRAFT_RELEASE_ORDER_STATUS.SUBMITTED }
-                    )
-
-                  const directReceiveSetting: Setting = await tx.getRepository(Setting).findOne({
-                    where: { domain, category: 'id-rule', name: 'enable-direct-receive-release-order' }
-                  })
-
-                  const partnerDirectReceiveSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
-                    where: { setting: directReceiveSetting, domain, partnerDomain: draftOrder.bizplace?.domain }
-                  })
-
-                  let settingValue
-
-                  if (
-                    !isNaN(partnerDirectReceiveSetting?.value) &&
-                    !isNaN(parseFloat(partnerDirectReceiveSetting?.value))
-                  ) {
-                    settingValue = parseFloat(partnerDirectReceiveSetting.value)
-                  } else {
-                    settingValue = parseFloat(directReceiveSetting.value)
-                  }
-
-                  createdReleaseGood = await confirmReleaseGood(createdReleaseGood.name, context, childTx)
-
-                  if (settingValue > 1) {
-                    createdReleaseGood = await receiveReleaseGood(createdReleaseGood.name, context, childTx)
-                  }
-                })
-              }
-            } catch (e) {
-              logger.error(`draft-release-good-mutation[generateReleaseGoodsFromDraft:${loggerJson}]: ${e?.message}`)
-            } finally {
-              console.timeEnd(`creating_order:${loggerJson}`)
-            }
-          })
-        }
-      }
-
-      return true
-    } catch (e) {
-      logger.error(`draft-release-good-mutation[generateReleaseGoodsFromDraft]: ${e?.message}`)
-    }
-  }
 }
 
 export async function upsertDraftReleaseGoodFunction(
@@ -627,7 +375,7 @@ export async function updateDraftReleaseGoodFunction(
 ): Promise<DraftReleaseGood> {
   const { domain, user }: { domain: Domain; user: User } = context.state
 
-  let existingDraftReleaseGood: any = await getDraftReleaseGoodFunction(_, draftReleaseGood.name, context, tx)
+  let existingDraftReleaseGood: any = await getDraftReleaseGoodFunction(_, context, null, draftReleaseGood.name, tx)
 
   if (draftReleaseGood?.bizplace?.id) {
     const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
@@ -656,7 +404,7 @@ export async function updateDraftReleaseGoodFunction(
     }
   } else {
     // case to delete existing shippingOrder
-    if (existingDraftReleaseGood.shippingOrder) {
+    if (existingDraftReleaseGood?.shippingOrder) {
       await tx.getRepository(ShippingOrder).delete(existingDraftReleaseGood.shippingOrder)
     }
   }
@@ -736,7 +484,7 @@ export async function upsertDraftReleaseGoodProducts(
 
     // Remove all existing order products that do not exist in current input
     let removeOP = draftReleaseGood.orderProducts.filter(
-      existingOP => orderProductsPatch.filter(inOP => inOP.id == existingOP.id).length == 0
+      existingOP => !orderProductsPatch.some(inOP => inOP.id == existingOP.id)
     )
     // removeOP.forEach(async op => {
     //   await orderProductRepo.delete(op)

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

@@ -1,35 +1,13 @@
-import {
-  Arg,
-  Args,
-  Ctx,
-  Directive,
-  Query,
-  Resolver
-} from 'type-graphql'
-import {
-  EntityManager,
-  getRepository,
-  In,
-  SelectQueryBuilder
-} from 'typeorm'
+import { Arg, Args, Ctx, Directive, Query, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, In, SelectQueryBuilder } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
-import {
-  Bizplace,
-  getPermittedBizplaceIds,
-  getPermittedBizplaces
-} from '@things-factory/biz-base'
-import {
-  buildQuery,
-  Domain,
-  ListParam
-} from '@things-factory/shell'
-
-import {
-  ATTACHMENT_TYPE,
-  DRAFT_RELEASE_ORDER_STATUS
-} from '../../constants'
+import { Bizplace, getPermittedBizplaceIds, getPermittedBizplaces } from '@things-factory/biz-base'
+import { Setting } from '@things-factory/setting-base'
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
+import { ATTACHMENT_TYPE, DRAFT_RELEASE_ORDER_STATUS } from '../../constants'
 import { InventoryUtil } from '../../utils'
 import { DraftReleaseGood } from './draft-release-good'
 import { DraftReleaseGoodList } from './draft-release-good-type'
@@ -47,10 +25,14 @@ export class DraftReleaseGoodQuery {
 
   @Directive('@transaction')
   @Query(returns => DraftReleaseGood, { description: 'To fetch a DraftReleaseGood' })
-  async draftReleaseGoodByName(@Arg('name') name: string, @Ctx() context: any): Promise<DraftReleaseGood> {
+  async draftReleaseGoodByName(
+    @Ctx() context: any,
+    @Arg('name', { nullable: true }) name?: string,
+    @Arg('id', { nullable: true }) id?: string
+  ): Promise<DraftReleaseGood> {
     const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
 
-    return getDraftReleaseGoodFunction(null, name, context, tx)
+    return getDraftReleaseGoodFunction(null, context, id, name, tx)
   }
 
   @Directive('@transaction')
@@ -310,24 +292,40 @@ export class DraftReleaseGoodQuery {
       }
 
       const arrChildSortData = ['bizplace', 'creator']
-      const sort = (params.sortings || []).reduce(
-        (acc, sort) => ({
-          ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'drg.' + sort.name]: sort.desc
-            ? 'DESC'
-            : 'ASC'
-        }),
-        params.sortings.length < 1 ? { rank: 'ASC', 'drg.createdAt': 'DESC' } : {}
-      )
+      const sort =
+        (params.sortings || []).length > 0
+          ? (params.sortings || []).reduce(
+              (acc, sort) => ({
+                ...acc,
+                [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'drg.' + sort.name]: sort.desc
+                  ? 'DESC'
+                  : 'ASC'
+              }),
+              {}
+            )
+          : { rank: 'ASC', 'drg.createdAt': 'DESC' }
 
       qb.orderBy(sort)
-      qb.offset((params.pagination.page - 1) * params.pagination.limit)
-      qb.limit(params.pagination.limit)
+      if (params.pagination?.page && params.pagination?.limit) {
+        qb.offset((params.pagination.page - 1) * params.pagination.limit)
+        qb.limit(params.pagination.limit)
+      }
 
       let [items, total] = await Promise.all([qb.getRawMany(), qb.getCount()])
       let newPlatformCode
+      let uniqueItems = await removeDuplicates(items)
+
+      const result: Setting = await tx
+        .getRepository(Setting)
+        .createQueryBuilder('st')
+        .select()
+        .where('st.domain_id = :domainId', { domainId: domain.id })
+        .andWhere('st.name = :name', { name: 'partial-release-rule' })
+        .getOne()
+
+      let settingValue = result ? result.value : null
 
-      items = items.map(itm => {
+      items = uniqueItems.map(itm => {
         if (itm.drg_platform_code) {
           if (itm.drg_platform_code == 'LZD') {
             newPlatformCode = 'Lazada'
@@ -345,6 +343,7 @@ export class DraftReleaseGoodQuery {
           name: itm.drg_name,
           description: itm.drg_description,
           type: itm.drg_type,
+          source: itm.drg_source,
           platformCode: newPlatformCode ? newPlatformCode : itm.platformCode,
           releaseDate: itm.drg_release_date,
           exportOption: itm.drg_export_option,
@@ -362,20 +361,24 @@ export class DraftReleaseGoodQuery {
         }
       })
 
-      return { items, total }
+      return { items, settingValue, total }
     } catch (error) {
       throw error
     }
   }
 }
 
-export async function getDraftReleaseGoodFunction(_: any, name: any, context: any, tx?: EntityManager) {
+export async function getDraftReleaseGoodFunction(_: any, context: any, id?: any, name?: any, tx?: EntityManager) {
   try {
     const { domain, user, bizplace }: { domain: Domain; user: User; bizplace: Bizplace } = context.state
 
     let permittedBizplaces = await getPermittedBizplaces(domain, user)
-    let result = await tx.getRepository(DraftReleaseGood).findOne({
-      where: { domain, name, bizplace: In(permittedBizplaces.map(biz => biz.id)) },
+
+    const whereCondition = id ? { id } : { name }
+    const where = { ...whereCondition, domain, bizplace: In(permittedBizplaces.map(biz => biz.id)) }
+
+    const result = await tx.getRepository(DraftReleaseGood).findOne({
+      where,
       relations: [
         'releaseGood',
         'orderProducts',
@@ -445,63 +448,75 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
         tx
       )
 
-    result.orderProducts = result.orderProducts.map(itm => {
-      let foundProductInv
-      if(itm.product){
-        foundProductInv = productInventory?.items.find(
-          i => i.productDetailId == itm?.productDetail?.id || i.productId == itm?.productBundle?.id
-        )
-        return {
-          ...itm,
-          product: itm.product || {
-            id: foundProductInv.productId,
-            name: foundProductInv.productName,
-            brand: foundProductInv.productBrand,
-            sku: foundProductInv.productSKU
-          },
-          productDetail: itm.productDetail || {
-            id: foundProductInv.productDetailId
-          },
-          groupType: foundProductInv ? foundProductInv.groupType : 'SINGLE',
-          remainQty: foundProductInv ? foundProductInv.remainQty : 0,
-          remainUomValue: foundProductInv ? foundProductInv.remainUomValue : 0,
-          remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0,
-          status: foundProductInv?.transferQty
-            ? DRAFT_RELEASE_ORDER_STATUS.TRANSFER
-            : (foundProductInv?.remainQty || 0) < itm.releaseQty
-            ? DRAFT_RELEASE_ORDER_STATUS.INSUFFICIENT
-            : DRAFT_RELEASE_ORDER_STATUS.DRAFT
-        }
-      } else {
-        return itm.productBundle.productBundleSettings.map(pbs => {
+    result.orderProducts = result.orderProducts
+      .map(itm => {
+        let foundProductInv
+        let orgReleaseQty = itm.releaseQty // to get the original release qty based of that bundle to be used when calculating the components release qty in the bundle
+
+        if (itm.product) {
           foundProductInv = productInventory?.items.find(
-            i => i.productDetailId == pbs?.productDetail?.id || i.productId == pbs?.product.id
+            i => i.productDetailId == itm?.productDetail?.id || i.productId == itm?.productBundle?.id
           )
-          return itm = {
+          return {
             ...itm,
-            product: pbs.product || {
+            product: itm.product || {
               id: foundProductInv.productId,
               name: foundProductInv.productName,
               brand: foundProductInv.productBrand,
               sku: foundProductInv.productSKU
             },
-            productDetail: pbs.productDetail || {
+            productDetail: itm.productDetail || {
               id: foundProductInv.productDetailId
             },
             groupType: foundProductInv ? foundProductInv.groupType : 'SINGLE',
             remainQty: foundProductInv ? foundProductInv.remainQty : 0,
             remainUomValue: foundProductInv ? foundProductInv.remainUomValue : 0,
             remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0,
-            status: foundProductInv?.transferQty
-              ? DRAFT_RELEASE_ORDER_STATUS.TRANSFER
-              : (foundProductInv?.remainQty || 0) < itm.releaseQty
-              ? DRAFT_RELEASE_ORDER_STATUS.INSUFFICIENT
-              : DRAFT_RELEASE_ORDER_STATUS.DRAFT
+            status:
+              itm.status === DRAFT_RELEASE_ORDER_STATUS.PARTIAL_RELEASED
+                ? DRAFT_RELEASE_ORDER_STATUS.PARTIAL_RELEASED
+                : foundProductInv?.transferQty
+                ? DRAFT_RELEASE_ORDER_STATUS.TRANSFER
+                : (foundProductInv?.remainQty || 0) < itm.releaseQty
+                ? DRAFT_RELEASE_ORDER_STATUS.INSUFFICIENT
+                : DRAFT_RELEASE_ORDER_STATUS.DRAFT
           }
-        })
-      }
-    }).flat()
-    
+        } else {
+          return itm.productBundle.productBundleSettings.map(pbs => {
+            foundProductInv = productInventory?.items.find(
+              i => i.productDetailId == pbs?.productDetail?.id || i.productId == pbs?.product.id
+            )
+            let itmBundleReleaseQty = orgReleaseQty * pbs.bundleQty // to calculate for each component release qty based on releaseQty set for tht bundle 
+            return (itm = {
+              ...itm,
+              product: pbs.product || {
+                id: foundProductInv.productId,
+                name: foundProductInv.productName,
+                brand: foundProductInv.productBrand,
+                sku: foundProductInv.productSKU
+              },
+              productDetail: pbs.productDetail || {
+                id: foundProductInv.productDetailId
+              },
+              groupType: 'BUNDLE',
+              releaseQty: itmBundleReleaseQty,
+              remainQty: foundProductInv ? foundProductInv.remainQty : 0,
+              remainUomValue: foundProductInv ? foundProductInv.remainUomValue : 0,
+              remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0,
+              status:
+                itm.status === DRAFT_RELEASE_ORDER_STATUS.PARTIAL_RELEASED
+                  ? DRAFT_RELEASE_ORDER_STATUS.PARTIAL_RELEASED
+                  : foundProductInv?.transferQty
+                  ? DRAFT_RELEASE_ORDER_STATUS.TRANSFER
+                  : (foundProductInv?.remainQty || 0) < itmBundleReleaseQty
+                  ? DRAFT_RELEASE_ORDER_STATUS.INSUFFICIENT
+                  : DRAFT_RELEASE_ORDER_STATUS.DRAFT
+            })
+          })
+        }
+      })
+      .flat()
+
     const foundAttachments: Attachment[] = await tx.getRepository(Attachment).find({
       where: {
         domain,
@@ -518,3 +533,8 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
     console.error(error)
   }
 }
+
+function removeDuplicates(items) {
+  const uniqueItems = [...new Set(items.map(item => item.drg_id))];
+  return items.filter(item => uniqueItems.includes(item.drg_id));
+}