@things-factory/sales-base 8.0.2 → 8.0.5

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

@@ -1,765 +0,0 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getConnection, In, IsNull, Repository } from 'typeorm'
-
-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 { generateId } from '@things-factory/id-rule-base'
-import { Product, ProductBundle, ProductDetail } from '@things-factory/product-base'
-import { Setting } from '@things-factory/setting-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-// import { Location } from '@things-factory/warehouse-base'
-import { DraftReleaseGood, DraftReleaseGoodPatch, NewDraftReleaseGood, OrderProduct } from '../'
-import {
-  ATTACHMENT_TYPE,
-  DRAFT_RELEASE_ORDER_STATUS,
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  ORDER_STATUS
-} from '../../constants'
-import { ValidationError } from '../../errors'
-import { InventoryUtil, OrderNoGenerator } from '../../utils'
-import { OrderProductPatch } from '../order-product/order-product-types'
-import { ReleaseGood } from '../release-good/release-good'
-import { bulkGenerateReleaseGood, confirmReleaseGood } 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 {
-//   checkArrivedNoticeFunction,
-//   confirmArrivalNoticeFunction,
-//   generateArrivalNoticeFunction,
-//   receiveArrivalNoticeFunction
-// } from '../arrival-notice/arrival-notice-mutation'
-import { getDraftReleaseGoodFunction } from './draft-release-good-query'
-
-@Resolver(DraftReleaseGood)
-export class DraftReleaseGoodMutation {
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => DraftReleaseGood)
-  async upsertDraftReleaseGood(
-    @Ctx() context: ResolverContext,
-    @Arg('draftReleaseGood', type => DraftReleaseGoodPatch) draftReleaseGood: DraftReleaseGoodPatch,
-    @Arg('orderProducts', type => [OrderProductPatch]) orderProducts: [OrderProductPatch],
-    @Arg('files', type => [GraphQLUpload], { nullable: true }) files?: FileUpload[],
-    @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch
-  ): Promise<DraftReleaseGood> {
-    try {
-      const { tx } = context.state
-      const createdDraftReleaseGood: DraftReleaseGood = await upsertDraftReleaseGoodFunction(
-        null,
-        draftReleaseGood,
-        orderProducts,
-        shippingOrder,
-        files,
-        context,
-        tx
-      )
-
-      return createdDraftReleaseGood
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DraftReleaseGood, { description: 'To create new DraftReleaseGood' })
-  async createDraftReleaseGood(
-    @Arg('draftReleaseGood', type => NewDraftReleaseGood, { nullable: true }) draftReleaseGood: NewDraftReleaseGood,
-    @Ctx() context: ResolverContext
-  ): Promise<DraftReleaseGood> {
-    const { domain, user, tx } = context.state
-
-    let drg = await tx.getRepository(DraftReleaseGood).save({
-      ...(draftReleaseGood as any),
-      domain,
-      status: 'INSUFFICIENT',
-      creator: user,
-      updater: user
-    })
-
-    // add order products
-
-    return drg
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DraftReleaseGood, { description: 'To modify DraftReleaseGood information' })
-  async updateDraftReleaseGood(
-    @Arg('id') id: string,
-    @Arg('patch', type => DraftReleaseGoodPatch) patch: DraftReleaseGoodPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<DraftReleaseGood> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(DraftReleaseGood)
-    const draftReleaseGood = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    return await repository.save({
-      ...draftReleaseGood,
-      ...(patch as any),
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [DraftReleaseGood], { description: "To modify multiple DraftReleaseGoods' information" })
-  async updateMultipleDraftReleaseGood(
-    @Arg('patches', type => [DraftReleaseGoodPatch]) patches: DraftReleaseGoodPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<DraftReleaseGood[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const draftReleaseGoodRepo = tx.getRepository(DraftReleaseGood)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await draftReleaseGoodRepo.save({
-          ...(newRecord as any),
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const draftReleaseGood = await draftReleaseGoodRepo.findOneBy({ id: newRecord.id })
-
-        const result = await draftReleaseGoodRepo.save({
-          ...draftReleaseGood,
-          ...(newRecord as any),
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete DraftReleaseGood' })
-  async deleteDraftReleaseGood(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(DraftReleaseGood).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple draftReleaseGoods' })
-  async deleteDraftReleaseGoods(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(DraftReleaseGood).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    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: ResolverContext,
-    @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
-
-    const updatableDraftOrders = await tx.getRepository(DraftReleaseGood).find({
-      where: {
-        domain: { id: domain.id },
-        id: In(ids),
-        status: DRAFT_RELEASE_ORDER_STATUS.DRAFT
-      },
-      relations: [
-        'orderProducts',
-        'orderProducts.product',
-        'orderProducts.productBundle',
-        'shippingOrder',
-        'bizplace',
-        'domain',
-        'creator',
-        'updater'
-      ]
-    })
-    if (updatableDraftOrders.length > 0) {
-      let createdReleaseGoods: ReleaseGood[] = []
-      const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-      const roNoSetting: Setting = await settingRepo.findOne({
-        where: {
-          domain: { id: domain.id },
-          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({
-              where: { id: draftOrder.bizplace.id },
-              relations: ['company', 'company.domain']
-            })
-            const companyDomain: Domain = foundPermittedBizplace.company.domain
-            companyBizplace = await parentTx
-              .getRepository(Bizplace)
-              .findOne({ where: { domain: { id: companyDomain.id } } })
-          } else {
-            return false
-          }
-
-          const bizplaces: Bizplace[] = [foundPermittedBizplace, companyBizplace]
-
-          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,
-            parentTx
-          )
-
-          draftOrder.orderProducts = draftOrder.orderProducts.map(itm => {
-            let foundProductInv = productInventory.items.find(
-              i =>
-                (i.productId == itm?.product?.id || i.productId == itm?.productBundle?.id) &&
-                i.packingType == itm.packingType &&
-                i.packingSize == itm.packingSize &&
-                i.uom == itm.uom &&
-                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 as any).createdBy
-            delete releaseGood.updatedAt
-            delete (releaseGood as any).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 })
-                }
-              })
-            }
-            try {
-              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 as any).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 }
-                  )
-                createdReleaseGood = await confirmReleaseGood(createdReleaseGood.name, context, childTx)
-              })
-            } catch (error) {
-              console.error(error)
-            }
-          }
-        })
-      }
-    }
-
-    return true
-  }
-}
-
-export async function upsertDraftReleaseGoodFunction(
-  _: any,
-  draftReleaseGood: any,
-  orderProducts: OrderProductPatch[],
-  shippingOrder: any,
-  files: FileUpload[],
-  context: any,
-  tx?: EntityManager
-): Promise<DraftReleaseGood> {
-  if (!draftReleaseGood.id) {
-    draftReleaseGood = await createDraftReleaseGoodFunction(
-      _,
-      draftReleaseGood,
-      orderProducts,
-      shippingOrder,
-      files,
-      context,
-      tx
-    )
-  } else {
-    draftReleaseGood = await updateDraftReleaseGoodFunction(
-      _,
-      draftReleaseGood,
-      orderProducts,
-      shippingOrder,
-      files,
-      context,
-      tx
-    )
-  }
-
-  return draftReleaseGood
-}
-
-export async function createDraftReleaseGoodFunction(
-  _: any,
-  draftReleaseGood: any,
-  orderProducts: OrderProductPatch[],
-  shippingOrder: any,
-  files: FileUpload[],
-  context: any,
-  tx?: EntityManager
-): Promise<DraftReleaseGood> {
-  const { domain, user } = context.state
-
-  let myBizplace: Bizplace
-  let orderNo: string = ''
-  let arrError: string[] = []
-
-  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-  if (draftReleaseGood?.bizplace?.id) {
-    const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-    let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == draftReleaseGood.bizplace.id)
-
-    if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-    draftReleaseGood.bizplace = foundPermittedBizplace
-  } else {
-    arrError.push(`No bizplace was selected`)
-  }
-
-  if (arrError.length > 0) {
-    throw new Error(arrError.join(', '))
-  }
-
-  // // find DRO number rule setting
-  const droNoSetting: Setting = await settingRepo.findOne({
-    where: {
-      domain: { id: domain.id },
-      name: ORDER_NUMBER_SETTING_KEY.DO_NUMBER_RULE
-    }
-  })
-
-  if (droNoSetting) {
-    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.DRO_NUMBER, seed: {} })
-  } else {
-    orderNo = OrderNoGenerator.draftReleaseGood()
-  }
-
-  // // 1. Create shipping order if found
-  if (shippingOrder) {
-    let newShippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).save({
-      ...shippingOrder,
-      name: OrderNoGenerator.shippingOrder(),
-      domain,
-      bizplace: draftReleaseGood.bizplace,
-      status: ORDER_STATUS.PENDING,
-      creator: user,
-      updater: user
-    })
-    draftReleaseGood.shippingOrder = newShippingOrder
-  }
-
-  // // 2. Create draft release good
-  const createdDraftReleaseGood: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).save({
-    ...draftReleaseGood,
-    name: orderNo,
-    status: DRAFT_RELEASE_ORDER_STATUS.DRAFT,
-    domain,
-    creator: user,
-    updater: user
-  })
-
-  // // 3. Create draft release good product
-  await upsertDraftReleaseGoodProducts(
-    domain,
-    draftReleaseGood.bizplace,
-    createdDraftReleaseGood,
-    orderProducts,
-    user,
-    tx
-  )
-
-  // // 4. Create Attachments
-  if (files?.length) {
-    const attachments: Partial<Attachment>[] = files.map(attachment => {
-      return {
-        file: attachment,
-        refType: ATTACHMENT_TYPE.DGRN,
-        refBy: createdDraftReleaseGood.id,
-        category: ATTACHMENT_TYPE.DGRN /* TODO use refType */
-      }
-    })
-    await createAttachments(_, { attachments }, context)
-  }
-
-  return createdDraftReleaseGood
-}
-
-export async function updateDraftReleaseGoodFunction(
-  _: any,
-  draftReleaseGood: any,
-  orderProducts: OrderProductPatch[],
-  shippingOrder: any,
-  files: FileUpload[],
-  context: any,
-  tx?: EntityManager
-): Promise<DraftReleaseGood> {
-  const { domain, user } = context.state
-
-  let existingDraftReleaseGood: any = await getDraftReleaseGoodFunction(_, draftReleaseGood.name, context, tx)
-
-  if (draftReleaseGood?.bizplace?.id) {
-    const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-    let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == draftReleaseGood.bizplace.id)
-
-    if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-    draftReleaseGood.bizplace = foundPermittedBizplace
-  }
-
-  if (shippingOrder) {
-    // case to update existing shippingOrder
-    if (existingDraftReleaseGood.shippingOrder) {
-      await tx.getRepository(ShippingOrder).update(existingDraftReleaseGood.shippingOrder.id, shippingOrder)
-    } else {
-      let newShippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).save({
-        ...shippingOrder,
-        name: OrderNoGenerator.shippingOrder(),
-        domain,
-        bizplace: draftReleaseGood.bizplace,
-        status: ORDER_STATUS.PENDING,
-        creator: user,
-        updater: user
-      })
-      draftReleaseGood.shippingOrder = newShippingOrder
-    }
-  } else {
-    // case to delete existing shippingOrder
-    if (existingDraftReleaseGood.shippingOrder) {
-      await tx.getRepository(ShippingOrder).delete(existingDraftReleaseGood.shippingOrder)
-    }
-  }
-
-  // // 1. Update draft release good
-  const updateDraftReleaseGood: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).save({
-    ...existingDraftReleaseGood,
-    ...draftReleaseGood,
-    domain,
-    creator: existingDraftReleaseGood.creator,
-    updater: user
-  })
-
-  // // 2. Update draft release good product
-  await upsertDraftReleaseGoodProducts(domain, draftReleaseGood.bizplace, draftReleaseGood, orderProducts, user, tx)
-
-  // // 3. Remove Purchase Order Attachment
-  const foundAttachments: Attachment[] = await getRepository(Attachment).find({
-    where: {
-      domain: { id: domain.id },
-      refBy: draftReleaseGood.id,
-      category: ATTACHMENT_TYPE.DGRN
-    }
-  })
-
-  // // 4. Remove All Attachment
-  if (foundAttachments?.length) {
-    await deleteAttachmentsByRef(_, { refBys: foundAttachments.map(file => file.refBy) }, context)
-  }
-
-  // // 5. Add New Attachment
-  if (files?.length > 0) {
-    const attachments: Partial<Attachment>[] = files.map(attachment => {
-      return {
-        file: attachment,
-        refType: ATTACHMENT_TYPE.DGRN,
-        refBy: updateDraftReleaseGood.id,
-        category: ATTACHMENT_TYPE.DGRN /* TODO use refType */
-      }
-    })
-    await createAttachments(_, { attachments }, context)
-  }
-
-  return existingDraftReleaseGood
-}
-
-export async function upsertDraftReleaseGoodProducts(
-  domain: Domain,
-  bizplace: Bizplace,
-  draftReleaseGood: DraftReleaseGood,
-  orderProductsPatch: OrderProductPatch[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  try {
-    let orderProducts: OrderProduct[] = []
-
-    const draftReleaseGoodRepo: Repository<DraftReleaseGood> =
-      tx?.getRepository(DraftReleaseGood) || getRepository(DraftReleaseGood)
-    const bizplaceRepo: Repository<Bizplace> = tx?.getRepository(Bizplace) || getRepository(Bizplace)
-    const orderProductRepo: Repository<OrderProduct> = tx?.getRepository(OrderProduct) || getRepository(OrderProduct)
-    const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
-    const productBundleRepo: Repository<ProductBundle> =
-      tx?.getRepository(ProductBundle) || getRepository(ProductBundle)
-
-    draftReleaseGood = (await draftReleaseGoodRepo.findOne({
-      where: { id: draftReleaseGood.id },
-      relations: [
-        'orderProducts',
-        'orderProducts.product',
-        'orderProducts.productBundle',
-        'orderProducts.creator',
-        'orderProducts.updater'
-      ]
-    })) as any
-
-    // 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
-    )
-    // removeOP.forEach(async op => {
-    //   await orderProductRepo.delete(op)
-    // })
-
-    if (removeOP.length > 0) await orderProductRepo.delete(removeOP.map(itm => itm.id))
-
-    bizplace = await bizplaceRepo.findOne({
-      where: { id: bizplace.id },
-      relations: ['domain', 'company', 'company.domain']
-    })
-
-    orderProducts = await Promise.all(
-      orderProductsPatch.map(async (op: any) => {
-        if (!op?.id) delete op.id
-
-        const customerCompanyDomain: Domain = bizplace.company.domain
-        let product: Product = null
-        let productBundle: ProductBundle = null
-        let existingOP = draftReleaseGood.orderProducts.find(existOP => existOP.id == op.id)
-
-        let updatePatch = {
-          ...existingOP,
-          ...op,
-          domain,
-          batchId: '',
-          packQty: 0,
-          actualPackQty: 0,
-          palletQty: 0,
-          actualPalletQty: 0,
-          bizplace: bizplace,
-          name: op?.id ? op.name : OrderNoGenerator.orderProduct(),
-          draftReleaseGood: draftReleaseGood,
-          status: draftReleaseGood.status,
-          creator: op?.id ? op.creator : user,
-          updater: user
-        }
-
-        if (op?.product?.id) {
-          product = await productRepo.findOne({
-            where: { domain: { id: customerCompanyDomain.id }, id: op.product.id }
-          })
-          updatePatch['product'] = product || undefined
-
-          if (!product) {
-            productBundle = await productBundleRepo.findOne({
-              where: { domain: { id: customerCompanyDomain.id }, id: op.product.id }
-            })
-            updatePatch['productBundle'] = productBundle || undefined
-          }
-
-          if (!product && !productBundle) throw new Error(`product not found`)
-        } else {
-          if (existingOP) {
-            product = existingOP.product
-            productBundle = existingOP.productBundle
-            updatePatch['product'] = existingOP.product || undefined
-            updatePatch['productBundle'] = existingOP.productBundle || undefined
-          } else {
-            product = await productRepo.findOne({
-              where: { domain: { id: customerCompanyDomain.id }, sku: op.product.sku, deletedAt: IsNull() },
-              relations: ['productDetails']
-            })
-            if (product) {
-              const productDetails: ProductDetail[] = product.productDetails
-              let selectedProductDetail: ProductDetail[]
-              if (op?.product?.packingType) {
-                selectedProductDetail = productDetails.filter(pd => pd.packingType == op.product.packingType)
-              } else {
-                selectedProductDetail = productDetails.filter(pd => pd.isDefault)
-              }
-
-              product.packingType = selectedProductDetail[0].packingType
-              product.primaryUnit = selectedProductDetail[0].uom
-              product.primaryValue = selectedProductDetail[0].uomValue
-            }
-
-            updatePatch['product'] = product || undefined
-
-            if (!product) {
-              productBundle = await productBundleRepo.findOne({
-                where: { domain: { id: customerCompanyDomain.id }, sku: op.product.sku }
-              })
-              updatePatch['productBundle'] = productBundle || undefined
-            }
-
-            if (!product && !productBundle) throw new Error(`product not found`)
-          }
-        }
-
-        updatePatch['packingType'] = op?.packingType
-          ? op.packingType
-          : product?.packingType
-            ? product.packingType
-            : productBundle.packingType
-        updatePatch['uom'] = op?.uom ? op.uom : product?.primaryUnit ? product.primaryUnit : 'UNIT'
-        updatePatch['uomValue'] = op?.uomValue ? op.uomValue : product?.primaryValue ? product.primaryValue : 0
-
-        return updatePatch
-      })
-    )
-
-    await orderProductRepo.save(orderProducts)
-  } catch (error) {
-    throw error
-  }
-}