@things-factory/sales-base 4.3.3 → 4.4.0-alpha.1

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

@@ -1,734 +0,0 @@
-import { FileUpload, GraphQLUpload } from 'graphql-upload'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getConnection, getRepository, 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 } 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: any,
-    @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 }: { tx: EntityManager } = 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: any
-  ): Promise<DraftReleaseGood> {
-    const { domain, user, tx } = context.state
-
-    let drg = await tx.getRepository(DraftReleaseGood).save({
-      ...draftReleaseGood,
-      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: any
-  ): Promise<DraftReleaseGood> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(DraftReleaseGood)
-    const draftReleaseGood = await repository.findOne({
-      where: { domain, id }
-    })
-
-    return await repository.save({
-      ...draftReleaseGood,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [DraftReleaseGood], { description: "To modify multiple DraftReleaseGoods' information" })
-  async updateMultipleDraftReleaseGood(
-    @Arg('patches', type => [DraftReleaseGoodPatch]) patches: DraftReleaseGoodPatch[],
-    @Ctx() context: any
-  ): 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,
-          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.findOne(newRecord.id)
-
-        const result = await draftReleaseGoodRepo.save({
-          ...draftReleaseGood,
-          ...newRecord,
-          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: any): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(DraftReleaseGood).delete({ domain, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple draftReleaseGoods' })
-  async deleteDraftReleaseGoods(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(DraftReleaseGood).delete({
-      domain,
-      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: 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
-
-    const updatableDraftOrders = await tx.getRepository(DraftReleaseGood).find({
-      where: {
-        domain,
-        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,
-          name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
-        }
-      })
-
-      for (let index = 0; index < updatableDraftOrders.length; index++) {
-        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 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.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, 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 = draftOrder.orderProducts[index]
-            let data = []
-            if (itm.productBundle) {
-              let bundle = 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,
-                  packing_type: objProductBundleSetting.productDetail.packingType,
-                  packing_size: objProductBundleSetting.productDetail.packingSize,
-                  uom: objProductBundleSetting.productDetail.uom,
-                  release_qty: objProductBundleSetting.bundleQty * itm.releaseQty,
-                  assignedQty: undefined,
-                  assignedUomValue: undefined,
-                  releaseUomValue: undefined
-                })
-              }
-            } else {
-              data = [
-                {
-                  sku: itm.product.sku,
-                  packing_type: itm.packingType,
-                  packing_size: itm.packingSize,
-                  uom: itm.uom,
-                  release_qty: itm.releaseQty,
-                  assignedQty: undefined,
-                  assignedUomValue: undefined,
-                  releaseUomValue: undefined
-                }
-              ]
-            }
-
-            data.forEach(data => {
-              let existingOI = orderInventories.find(
-                itm =>
-                  itm.sku == data.sku &&
-                  itm.packing_type == data.packing_type &&
-                  itm.packing_size == data.packing_size &&
-                  itm.uom == data.uom
-              )
-
-              if (existingOI) {
-                existingOI.release_qty = existingOI.release_qty + data.release_qty
-              } else {
-                orderInventories.push(data)
-              }
-            })
-          }
-          try {
-            await getConnection().transaction(async (childTx: EntityManager) => {
-              let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
-                orderInventories,
-                draftOrder.bizplace.id,
-                context,
-                childTx
-              )
-
-              if (availableItems.some(item => !item.release_qty || item.release_qty > item.assignedQty))
-                throw new ValidationError({
-                  ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
-                  detail: { data: JSON.stringify(availableItems) }
-                })
-
-              // update orderInventories if availableItems are valid
-              releaseGood.orderInventories = availableItems.map(itm => {
-                return {
-                  ...itm,
-                  releaseQty: itm.release_qty
-                }
-              })
-
-              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 }: { domain: Domain; user: 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,
-      name: ORDER_NUMBER_SETTING_KEY.PO_NUMBER_RULE
-    }
-  })
-
-  if (droNoSetting) {
-    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.DRO_NUMBER, seed: {} })
-  } else {
-    orderNo = OrderNoGenerator.draftReleaseGood()
-  }
-
-  // // 1. 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
-  })
-
-  // // 2. Create draft release good product
-  await upsertDraftReleaseGoodProducts(
-    domain,
-    draftReleaseGood.bizplace,
-    createdDraftReleaseGood,
-    orderProducts,
-    user,
-    tx
-  )
-
-  // // 3. Create Attachments
-  if (files?.length) {
-    const attachments: Attachment[] = files.map(attachment => {
-      return {
-        file: attachment,
-        refBy: createdDraftReleaseGood.id,
-        category: ATTACHMENT_TYPE.DGRN
-      }
-    })
-    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 }: { domain: Domain; user: 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: user,
-    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,
-      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: Attachment[] = files.map(attachment => {
-      return {
-        file: attachment,
-        refBy: updateDraftReleaseGood.id,
-        category: ATTACHMENT_TYPE.DGRN
-      }
-    })
-    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<Product> =
-      tx?.getRepository(DraftReleaseGood) || getRepository(DraftReleaseGood)
-    const bizplaceRepo: Repository<Product> = 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<Product> = tx?.getRepository(ProductBundle) || getRepository(ProductBundle)
-
-    draftReleaseGood = await draftReleaseGoodRepo.findOne({
-      where: { id: draftReleaseGood.id },
-      relations: [
-        'orderProducts',
-        'orderProducts.product',
-        'orderProducts.productBundle',
-        'orderProducts.creator',
-        'orderProducts.updater'
-      ]
-    })
-
-    // 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(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: customerCompanyDomain, id: op.product.id }
-          })
-          updatePatch['product'] = product || undefined
-
-          if (!product) {
-            productBundle = await productBundleRepo.findOne({
-              where: { domain: customerCompanyDomain, 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: customerCompanyDomain, 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: customerCompanyDomain, 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
-  }
-}