@things-factory/sales-base 4.3.448 → 4.3.452

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

@@ -0,0 +1,715 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getConnection, getRepository, In, Repository } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { ProductBundle } from '@things-factory/product-base'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+
+// import { Location } from '@things-factory/warehouse-base'
+import { bulkReleaseGoodsAvailableItemsFunction, DraftReleaseGood, DraftReleaseGoodInfos, OrderProduct } from '../'
+import { DRAFT_RELEASE_ORDER_STATUS, ORDER_NUMBER_SETTING_KEY, ORDER_STATUS } from '../../constants'
+import { ValidationError } from '../../errors'
+import { InventoryUtil, OrderNoGenerator } from '../../utils'
+import { ReleaseGood } from '../release-good/release-good'
+import { SuccessReleasedDraftOrder } from './draft-release-good-type'
+import { bulkGenerateReleaseGood, confirmReleaseGood, receiveReleaseGood } from '../release-good/release-good-mutation'
+
+@Resolver(DraftReleaseGood)
+export class DraftReleaseGoodCreate {
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [SuccessReleasedDraftOrder], {
+    nullable: true,
+    description: 'To generate Release Goods from Draft'
+  })
+  async generateReleaseGoodsfromDraft(
+    @Ctx() context: any,
+    @Arg('releaseInfo', type => [DraftReleaseGoodInfos]) releaseInfo: DraftReleaseGoodInfos[]
+  ): Promise<SuccessReleasedDraftOrder[] | null> {
+    let results = []
+
+    try {
+      const _generatePartialReleaseGoodsRecord = releaseInfo.filter(
+        item => item.releaseType === 'partial' && item.id !== ''
+      )
+      const _generateReleaseGoodsRecord = releaseInfo.filter(item => item.releaseType === 'release' && item.id !== '')
+
+      if (_generateReleaseGoodsRecord.length > 0) {
+        const result = await generateReleaseGoods(_generateReleaseGoodsRecord, context)
+        results.push(...result)
+      }
+
+      if (_generatePartialReleaseGoodsRecord.length > 0) {
+        const result = await generatePartialReleaseGoods(_generatePartialReleaseGoodsRecord, context)
+        results.push(...result)
+      }
+      return results
+    } catch (e) {
+      logger.error(e)
+      throw new Error('Failed Released Draft Orders')
+    }
+  }
+}
+
+export async function generateReleaseGoods(_generateReleaseGoodsRecord, context: any) {
+  const { domain, user, tx } = context.state
+  try {
+    let ids = [] // Initialize the ids array outside the loop
+    ids = _generateReleaseGoodsRecord.map(item => item.id)
+    let releasedOrders = []
+
+    const updatableDraftOrders = await tx.getRepository(DraftReleaseGood).find({
+      where: {
+        domain,
+        id: In(ids),
+        status: In([DRAFT_RELEASE_ORDER_STATUS.DRAFT, DRAFT_RELEASE_ORDER_STATUS.PARTIAL_RELEASED])
+      },
+      order: {
+        createdAt: 'ASC'
+      },
+      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'
+      ]
+    })
+    let failReleaseOrder = []
+
+    if (updatableDraftOrders.length > 0) {
+      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 (tx: EntityManager) => {
+        
+          const draftOrder = updatableDraftOrders[index]
+
+          let foundPermittedBizplace: Bizplace
+          let companyBizplace: Bizplace
+
+          if (draftOrder?.bizplace?.id) {
+            foundPermittedBizplace = await tx.getRepository(Bizplace).findOne(draftOrder.bizplace.id, {
+              relations: ['company', 'company.domain']
+            })
+            const companyDomain: Domain = foundPermittedBizplace.company.domain
+            companyBizplace = await tx.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}`)
+
+            draftOrder.orderProducts = draftOrder.orderProducts.filter(op => op.status == 'DRAFT')
+
+            let productIds = []
+
+            for (let item of draftOrder.orderProducts) {
+              if (item && item.product) {
+                productIds.push(item.product.id)
+              }
+              if (item && item.productBundle) {
+                for (let bundleSetting of item.productBundle.productBundleSettings) {
+                  productIds.push(bundleSetting.product.id)
+                }
+              }
+            }
+
+            let productInventory = await InventoryUtil.bizplaceProductInventory(
+              bizplaces,
+              {
+                filters: [
+                  {
+                    name: 'productId',
+                    operator: 'in',
+                    value: productIds
+                  }
+                ]
+              },
+              context,
+              tx
+            )
+
+            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
+                )
+                if (!foundProductInv) {
+                  failReleaseOrder.push(draftOrder.name)
+                }
+              } 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 tx.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 (tx: EntityManager) => {
+                let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
+                  orderInventories,
+                  draftOrder.bizplace.id,
+                  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
+                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,
+                  draftOrder,
+                  tx
+                )
+                await tx
+                  .getRepository(DraftReleaseGood)
+                  .update({ id: draftOrder.id }, { 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, tx)
+
+                if (settingValue > 1) {
+                  createdReleaseGood = await receiveReleaseGood(createdReleaseGood.name, context, tx)
+                }
+              })          
+            } else {
+              if (draftOrder.orderProducts.every(op => op.id === insufficient?.id)) {
+                failReleaseOrder.push(draftOrder?.name)
+              }
+            }
+          } catch (e) {
+            logger.error(`draft-release-good-mutation[generateReleaseGoodsFromDraft:${loggerJson}]: ${e?.message}`)
+          } finally {
+            console.timeEnd(`creating_order:${loggerJson}`)
+          }
+        })
+      }
+    }
+    releasedOrders = updatableDraftOrders.filter(drg => !drg.name.includes(failReleaseOrder))
+    releasedOrders = releasedOrders.map(item => {
+      return {
+        draftName: item.name
+      }
+    })
+    return releasedOrders
+  } catch (e) {
+    logger.error(`draft-release-good-mutation[generateReleaseGoodsFromDraft]: ${e?.message}`)
+  }
+}
+
+export async function generatePartialReleaseGoods(_generatePartialReleaseGoodsRecord, context: any) {
+  const { domain, user, tx } = context.state
+  try {
+    let ids = []
+    ids = _generatePartialReleaseGoodsRecord.map(item => item.id)
+    const selectedStatus = [
+      DRAFT_RELEASE_ORDER_STATUS.PARTIAL_RELEASED,
+      DRAFT_RELEASE_ORDER_STATUS.DRAFT,
+      DRAFT_RELEASE_ORDER_STATUS.TRANSFER
+    ]
+
+    const value = _generatePartialReleaseGoodsRecord[0]
+    const updatableDraftOrders = await tx.getRepository(DraftReleaseGood).find({
+      where: {
+        domain,
+        id: In(ids),
+        status: In(selectedStatus)
+      },
+      order: {
+        createdAt: 'ASC',
+        status: 'ASC'
+      },
+      relations: [
+        'orderProducts',
+        'orderProducts.product',
+        'orderProducts.productDetail',
+        'orderProducts.productBundle',
+        '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 draftOrder of updatableDraftOrders) {
+        await getConnection().transaction(async (tx: EntityManager) => {
+          let foundPermittedBizplace: Bizplace
+          let companyBizplace: Bizplace
+
+          //remove op productBundle as there no support for partial release
+
+          if (draftOrder.orderProducts.some(itm => !itm.product)) {
+            draftOrder.orderProducts = draftOrder.orderProducts.filter(itm => itm.product)
+          }
+
+          if (draftOrder?.bizplace?.id) {
+            foundPermittedBizplace = await tx.getRepository(Bizplace).findOne(draftOrder.bizplace.id, {
+              relations: ['company', 'company.domain']
+            })
+            const companyDomain: Domain = foundPermittedBizplace.company.domain
+            companyBizplace = await tx.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.id
+                        })
+                    ]
+                  }
+                ]
+              },
+              context,
+              tx
+            )
+
+            draftOrder.orderProducts = draftOrder.orderProducts.filter(op => op.status == 'DRAFT')
+
+            if (!Array.isArray(draftOrder.orderProducts)) {
+              draftOrder.orderProducts = [draftOrder.orderProducts]
+            }
+
+            // if (!foundItem)
+            let releaseOrderProducts = []
+            draftOrder.orderProducts = draftOrder.orderProducts.map((itm, idx) => {
+              let foundProductInv = productInventory.items.find(
+                i =>
+                  (i.productDetailId == itm?.productDetailId || i.productId == itm?.productBundle?.id) &&
+                  !(i.remainQty === 0)
+              )
+              if (foundProductInv) {
+                releaseOrderProducts.push({
+                  ...itm,
+                  releaseUomValue:
+                    itm.releaseQty > foundProductInv.remainQty
+                      ? (foundProductInv.remainUomValue / foundProductInv.remainQty) * foundProductInv.remainQty
+                      : (foundProductInv.remainUomValue / foundProductInv.remainQty) * itm.releaseQty,
+                  status: itm.releaseQty <= foundProductInv.remainQty ? 'suffice' : 'partial-release',
+                  releaseQty: itm.releaseQty > foundProductInv.remainQty ? foundProductInv.remainQty : itm.releaseQty, //it will take the remainQty instead of releaseQty when remainQty < releaseQty
+                  newReleaseQty:
+                    itm.releaseQty > foundProductInv.remainQty ? itm.releaseQty - foundProductInv.remainQty : 0
+                })
+              }
+            })
+
+            let sufficient = releaseOrderProducts.filter(op => op.status == 'suffice' || op.status == 'partial-release')
+
+            //create RO
+            if (sufficient.length > 0) {
+              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 < releaseOrderProducts.length; index++) {
+                const itm: Partial<OrderProduct> = releaseOrderProducts[index]
+                let data = []
+                if (itm.productBundle) {
+                  let bundle: ProductBundle = await tx.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 (tx: EntityManager) => {
+                let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
+                  orderInventories,
+                  draftOrder.bizplace.id,
+                  context,
+                  tx
+                )
+
+                // first condition for partial release (values use for generating release good)
+                if (draftOrder.id === value.id && value.releaseType === 'partial') {
+                  releaseGood.orderInventories = availableItems.map(itm => {
+                    return {
+                      ...itm,
+                      releaseQty: itm.assignedQty,
+                      releaseUomValue: itm.releaseUomValue,
+                      uomValue: itm.uomValue
+                    }
+                  })
+                } else if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty)) {
+                  throw new ValidationError({
+                    ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
+                    detail: { data: JSON.stringify(availableItems) }
+                  })
+                } else {
+                  releaseGood.orderInventories = availableItems.map(itm => {
+                    return {
+                      ...itm,
+                      releaseQty: itm.releaseQty,
+                      releaseUomValue: itm.releaseUomValue,
+                      uomValue: itm.uomValue
+                    }
+                  })
+                }
+
+                // update orderInventories if availableItems are valid
+                releaseGood.noOfItems = orderInventories.length
+
+                let createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
+                  releaseGood,
+                  releaseGood.bizplace.id,
+                  roNoSetting,
+                  domain,
+                  user,
+                  draftOrder,
+                  tx
+                )
+
+                await tx
+                  .getRepository(DraftReleaseGood)
+                  .update({ id: draftOrder.id }, { status: DRAFT_RELEASE_ORDER_STATUS.PARTIAL_RELEASED })
+
+                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, tx)
+
+                if (settingValue > 1) {
+                  createdReleaseGood = await receiveReleaseGood(createdReleaseGood.name, context, tx)
+
+                  for (let value = 0; value < releaseOrderProducts.length; value++) {
+                    if (releaseOrderProducts[value].status == 'partial-release') {
+                      let newOrderProduct = releaseOrderProducts.map(item => {
+                        return {
+                          ...item,
+                          name: OrderNoGenerator.orderProduct(),
+                          draftReleaseGood: draftOrder,
+                          releaseQty: item.newReleaseQty,
+                          bizplace: draftOrder.bizplace,
+                          domain: draftOrder.domain,
+                          creator: user,
+                          updater: user,
+                          productDetail: item.productDetail,
+                          status: ORDER_STATUS.DRAFT
+                        }
+                      })
+
+                      delete newOrderProduct[value].id
+                      delete newOrderProduct[value].releaseUomValue
+
+                      let generatedOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct[value])
+
+                      console.log(generatedOrderProduct)
+                    }
+                  }
+                }
+              })
+            }
+          } catch (e) {
+            logger.error(`draft-release-good-mutation[generateReleaseGoodsFromDraft:${loggerJson}]: ${e?.message}`)
+          } finally {
+            console.timeEnd(`creating_order:${loggerJson}`)
+          }
+        })
+      }
+    }
+    const checkDraftOrders = await tx.getRepository(DraftReleaseGood).find({
+      where: {
+        domain,
+        id: In(ids),
+        status: In([DRAFT_RELEASE_ORDER_STATUS.DRAFT, DRAFT_RELEASE_ORDER_STATUS.PARTIAL_RELEASED])
+      },
+      relations: ['bizplace', 'domain', 'orderProducts', 'orderProducts.product', 'orderProducts.productBundle']
+    })
+
+    let productBundleOrders = []
+    let failReleaseOrder = []
+    let releasedOrders = []
+
+    for (let index = 0; index < checkDraftOrders.length; index++) {
+      const allProductsAssignedOrPartialReleased = checkDraftOrders[index].orderProducts.every(itm =>
+        ['ASSIGNED', DRAFT_RELEASE_ORDER_STATUS.PARTIAL_RELEASED].includes(itm.status)
+      )
+      if (allProductsAssignedOrPartialReleased) {
+
+        let draftOrderId = checkDraftOrders[index].id
+        await tx
+          .getRepository(DraftReleaseGood)
+          .update({ id: draftOrderId }, { status: DRAFT_RELEASE_ORDER_STATUS.SUBMITTED })
+      }
+
+      const commonOrders = checkDraftOrders[index].orderProducts.every(checkOrder => checkOrder.status === 'DRAFT')
+      const hasPB = checkDraftOrders[index].orderProducts.some(itm => !itm.product)
+
+      if (commonOrders) {
+        failReleaseOrder.push(checkDraftOrders[index].name)
+      }
+
+      if (hasPB) {
+        productBundleOrders.push(checkDraftOrders[index].name)
+      }
+    }
+
+    if (failReleaseOrder.length > 0) {
+      releasedOrders = checkDraftOrders.filter(order => !failReleaseOrder.includes(order.name))
+      releasedOrders = releasedOrders.map(item => {
+        return {
+          draftName: item.name
+        }
+      })
+    }
+
+    if (productBundleOrders.length > 0) {
+      let productBundleOrder = productBundleOrders.map(item => {
+        return {
+          draftName: item,
+          isProductBundle: true
+        }
+      })
+      releasedOrders.push(...productBundleOrder)
+    }
+
+    return releasedOrders
+  } catch (e) {
+    logger.error(`draft-release-good-mutation[generateReleaseGoodsFromDraft]: ${e?.message}`)
+  }
+}