@things-factory/sales-base 8.0.0-beta.0 → 8.0.0-beta.2

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

@@ -1,1686 +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, Not, Repository } from 'typeorm'
-
-import { Attachment, createAttachments } from '@things-factory/attachment-base'
-import { ApplicationType, Partner, Role, User } from '@things-factory/auth-base'
-import {
-  Bizplace,
-  ContactPoint,
-  getDomainUsers,
-  getMyBizplace,
-  getOutletBizplace,
-  getPermittedBizplaces
-} from '@things-factory/biz-base'
-import { logger } from '@things-factory/env'
-import { generateId } from '@things-factory/id-rule-base'
-import { MarketplaceStore } from '@things-factory/integration-marketplace'
-import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
-import { MarketplaceOrder, MarketplaceProductVariation } from '@things-factory/marketplace-base'
-import { Product, ProductBundleSetting } from '@things-factory/product-base'
-import { PartnerSetting, Setting } from '@things-factory/setting-base'
-import { Domain, getRepository } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-
-// import { NewOrderProduct } from '../order-product/order-product-types'
-import {
-  ATTACHMENT_TYPE,
-  ORDER_INVENTORY_STATUS,
-  ORDER_METHOD,
-  ORDER_NUMBER_RULE_TYPE,
-  ORDER_NUMBER_SETTING_KEY,
-  ORDER_PRODUCT_STATUS,
-  ORDER_STATUS,
-  ORDER_TYPES,
-  ORDER_VAS_STATUS,
-  PRODUCT_GROUP_TYPE
-} from '../../constants'
-import { EcommerceController, SellercraftController } from '../../controllers'
-import { ValidationError } from '../../errors'
-import { InventoryUtil, OrderNoGenerator } from '../../utils'
-import { ArrivalNotice } from '../arrival-notice/arrival-notice'
-import { confirmArrivalNoticeFunction, deleteArrivalNotice } from '../arrival-notice/arrival-notice-mutation'
-import { OrderInventory } from '../order-inventory/order-inventory'
-import { OrderProduct } from '../order-product/order-product'
-import { OrderVas } from '../order-vas/order-vas'
-import { NewReleaseGood, ReleaseGoodPatch, ShippingOrderInfoPatch } from '../release-good/release-good-types'
-import { ShippingOrder } from '../shipping-order/shipping-order'
-import { ShippingOrderPatch } from '../shipping-order/shipping-order-types'
-import { Vas } from '../vas/vas'
-import { ReleaseGood } from './release-good'
-import { bulkReleaseGoodsAvailableItemsFunction } from './release-good-query'
-
-@Resolver(ReleaseGood)
-export class ReleaseGoodMutation {
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => [ReleaseGood])
-  async bulkAddReleaseGoods(
-    @Ctx() context: ResolverContext,
-    @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
-    @Arg('bizplaceId', type => String) bizplaceId: string
-  ): Promise<ReleaseGood[]> {
-    const { domain, user, tx } = context.state
-
-    if (!bizplaceId) throw new Error('company ID is not provided')
-
-    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
-      }
-    })
-
-    let releaseGoods: Partial<ReleaseGood[]> = extractRawReleaseGoods(rawReleaseGoods)
-
-    let errorsCaught: any[] = []
-    for (let i = 0, l = releaseGoods.length; i < l; i++) {
-      // generate release good by group to avoid duplication
-      // if this function is called simultaneously by different users
-      try {
-        await getConnection().transaction(async (childTx: EntityManager) => {
-          const existingReleaseGood: ReleaseGood = await childTx.getRepository(ReleaseGood).findOne({
-            where: {
-              ...Object.fromEntries(
-                Object.entries(releaseGoods[i]).filter(([_, val]) => !/^\s*$/.test(val) && _ != 'orderInventories')
-              ),
-              domain: { id: domain.id }
-            }
-          })
-          if (existingReleaseGood) throw new Error('this order is already exist in the system')
-
-          let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
-            [...releaseGoods[i].orderInventories],
-            bizplaceId,
-            context,
-            childTx
-          )
-
-          if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty))
-            throw new ValidationError({
-              ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
-              detail: { data: JSON.stringify(availableItems) }
-            })
-
-          // update orderInventories if availableItems are valid
-          releaseGoods[i].orderInventories = availableItems
-
-          const createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
-            releaseGoods[i],
-            bizplaceId,
-            roNoSetting,
-            domain,
-            user,
-            childTx
-          )
-
-          createdReleaseGoods.push(createdReleaseGood)
-        })
-      } catch (error) {
-        let rawReleaseGoods = formRawReleaseGoods(releaseGoods[i], error.message)
-        errorsCaught.push(...rawReleaseGoods)
-      }
-    }
-
-    let confirmedReleaseGoods: ReleaseGood[] = []
-
-    if (createdReleaseGoods.length)
-      try {
-        confirmedReleaseGoods = await bulkConfirmReleaseGoods(
-          createdReleaseGoods.map(rg => rg.name),
-          domain,
-          user,
-          context,
-          tx
-        )
-      } catch (error) {}
-
-    if (errorsCaught.length)
-      throw new ValidationError({
-        ...ValidationError.ERROR_CODES.INVALID_DATA_FOUND,
-        detail: { data: JSON.stringify(errorsCaught) }
-      })
-
-    return confirmedReleaseGoods
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteReleaseGood(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { tx, user, domain } = context.state
-    return await deleteReleaseGood(tx, name, user, domain)
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteReleaseGoods(
-    @Arg('names', type => [String]) names: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<Boolean> {
-    const { tx } = context.state
-    await tx.getRepository(ReleaseGood).delete({
-      domain: { id: context.state.domain.id },
-      name: In(names)
-    })
-    return true
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ReleaseGood)
-  async generateReleaseGood(
-    @Ctx() context: ResolverContext,
-    @Arg('attachments', type => [GraphQLUpload], { nullable: true }) attachments?: FileUpload[],
-    @Arg('releaseGood', type => NewReleaseGood, { nullable: true }) releaseGood?: NewReleaseGood,
-    @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch,
-    @Arg('shippingOrderInfo', type => ShippingOrderInfoPatch, { nullable: true })
-    shippingOrderInfo?: ShippingOrderInfoPatch
-  ): Promise<ReleaseGood> {
-    const { tx } = context.state
-    const createdReleaseGood: ReleaseGood = await generateReleaseGoodFunction(
-      null,
-      releaseGood,
-      shippingOrder,
-      shippingOrderInfo,
-      attachments,
-      context,
-      tx
-    )
-
-    return createdReleaseGood
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ReleaseGood)
-  async updateReleaseGoodDetails(
-    @Ctx() context: ResolverContext,
-    @Arg('releaseGood', type => ReleaseGoodPatch, { nullable: true }) releaseGood?: ReleaseGoodPatch,
-    @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch,
-    @Arg('shippingOrderInfo', type => ShippingOrderInfoPatch, { nullable: true })
-    shippingOrderInfo?: ShippingOrderInfoPatch
-  ): Promise<ReleaseGood> {
-    const { tx, domain, user } = context.state
-    let foundReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: { id: releaseGood.id, domain: { id: domain.id } },
-      relations: ['shippingOrder']
-    })
-
-    if (!foundReleaseGood) {
-      throw new Error(`Release order ${releaseGood.id} is not found.`)
-    }
-
-    // case to update existing shippingOrder
-    if (shippingOrder !== null) {
-      shippingOrder.remark = shippingOrder.exportRemark
-      shippingOrder.containerClosureDateTime = new Date(shippingOrder.containerClosureDate)
-      delete shippingOrder.exportRemark
-    }
-
-    if (foundReleaseGood.shippingOrder && shippingOrder) {
-      await tx.getRepository(ShippingOrder).update(foundReleaseGood.shippingOrder.id, shippingOrder)
-    }
-    // case for new shippingOrder
-    else if (!foundReleaseGood.shippingOrder && shippingOrder) {
-      let newShippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).save({
-        ...shippingOrder,
-        name: OrderNoGenerator.shippingOrder(),
-        domain,
-        bizplace: await getMyBizplace(domain, user),
-        status: ORDER_STATUS.PENDING,
-        creator: user,
-        updater: user
-      })
-
-      releaseGood.shippingOrder = newShippingOrder
-    }
-
-    foundReleaseGood = await tx.getRepository(ReleaseGood).save({
-      ...(foundReleaseGood as any),
-      ...releaseGood,
-      ...shippingOrderInfo,
-      remark: releaseGood?.remark ? releaseGood.remark : null
-    })
-
-    return foundReleaseGood
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ReleaseGood)
-  async confirmReleaseGood(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReleaseGood> {
-    const { tx } = context.state
-    const releaseGood: ReleaseGood = await confirmReleaseGood(name, context, tx)
-
-    // If current RO has cross docking
-    if (releaseGood.crossDocking) {
-      const { arrivalNotice } = await tx.getRepository(ReleaseGood).findOne({
-        where: { id: releaseGood.id },
-        relations: ['arrivalNotice']
-      })
-
-      // If status of related GAN is not equal to PENDING_RECEIVE (i.e. Wasn't confirmed yet.)
-      if (arrivalNotice.status !== ORDER_STATUS.PENDING_RECEIVE) {
-        await confirmArrivalNoticeFunction(arrivalNotice.name, context, tx)
-      }
-    }
-
-    return releaseGood
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ReleaseGood)
-  async receiveReleaseGood(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReleaseGood> {
-    const { tx } = context.state
-    const releaseGood: ReleaseGood = await receiveReleaseGood(name, context, tx)
-    return releaseGood
-  }
-
-  @Directive('@privilege(category: "order_warehouse", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => ReleaseGood)
-  async rejectReleaseGood(
-    @Arg('name') name: string,
-    @Arg('patch', type => ReleaseGoodPatch) patch: ReleaseGoodPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<ReleaseGood> {
-    const { tx } = context.state
-
-    return await rejectReleaseGood(tx, context, name, patch.remark)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ReleaseGood)
-  async addReleaseGood(
-    @Ctx() context: ResolverContext,
-    @Arg('releaseGood', type => NewReleaseGood, { nullable: true }) releaseGood: NewReleaseGood,
-    @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder: ShippingOrderPatch,
-    @Arg('file', type => GraphQLUpload, { nullable: true }) file: FileUpload
-  ): Promise<ReleaseGood> {
-    const { tx } = context.state
-    const createdRO: ReleaseGood = await generateReleaseGoodFunction(
-      null,
-      releaseGood,
-      shippingOrder,
-      null,
-      file,
-      context,
-      tx
-    )
-
-    const confirmedRO: ReleaseGood = await confirmReleaseGood(createdRO.name, context, tx)
-
-    const receivedRO: ReleaseGood = await receiveReleaseGood(confirmedRO.name, context, tx)
-
-    return receivedRO
-  }
-
-  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async executeOrderRemark(
-    @Arg('releaseGoodNo') releaseGoodNo: string,
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx, user } = context.state
-
-    await tx.getRepository(ReleaseGood).update(
-      {
-        domain: { id: domain.id },
-        name: releaseGoodNo
-      },
-      {
-        checkedRemarkAt: new Date(),
-        checkedRemarkUser: user,
-        checkedRemarkBy: user.name
-      }
-    )
-
-    return true
-  }
-}
-
-export async function deleteReleaseGood(tx: EntityManager, name: string, user: User, domain: Domain): Promise<boolean> {
-  let foundReleaseOrder: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain: { id: domain.id }, name },
-    relations: [
-      'arrivalNotice',
-      'orderInventories',
-      'orderInventories.orderProduct',
-      'orderInventories.inventory',
-      'orderVass',
-      'shippingOrder',
-      'creator',
-      'updater'
-    ]
-  })
-
-  if (!foundReleaseOrder) throw new Error(`Release order doesn't exists.`)
-  const foundOIs: OrderInventory[] = foundReleaseOrder.orderInventories
-  const foundOVs: OrderVas[] = foundReleaseOrder.orderVass
-  const foundSO: ShippingOrder = foundReleaseOrder.shippingOrder
-
-  let foundAttachment: Attachment
-  if (foundReleaseOrder?.ownTransport) {
-    foundAttachment = await tx.getRepository(Attachment).findOne({
-      where: {
-        domain: { id: domain.id },
-        refBy: foundReleaseOrder.id,
-        category: ATTACHMENT_TYPE.DELIVERY_ORDER
-      }
-    })
-  }
-
-  // Delete order inventories by ids
-  await Promise.all(
-    foundOIs.map(async (oi: OrderInventory) => {
-      if (oi?.inventory?.id) {
-        oi.inventory = await tx.getRepository(Inventory).findOneBy({ id: oi.inventory.id })
-
-        await tx.getRepository(Inventory).save({
-          ...oi.inventory,
-          lockedQty: oi.inventory.lockedQty - oi.releaseQty,
-          lockedUomValue: oi.inventory.lockedUomValue - oi.releaseUomValue,
-          updater: user
-        })
-      }
-
-      await tx.getRepository(OrderInventory).delete({ id: oi.id })
-
-      if (oi?.orderProduct?.id) {
-        await tx.getRepository(OrderProduct).delete({ id: oi.orderProduct.id })
-      }
-
-      return oi
-    })
-  )
-
-  // 2. delete order vass
-  const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
-  if (vasIds.length) {
-    await tx.getRepository(OrderVas).delete({ id: In(vasIds) })
-  }
-
-  if (foundAttachment) {
-    await tx.getRepository(Attachment).delete({ domain: { id: domain.id }, id: foundAttachment.id })
-  }
-
-  // 4. Remove relation with GAN if it's cross docking
-  if (foundReleaseOrder.crossDocking && foundReleaseOrder.arrivalNotice?.id) {
-    let arrivalNotice: ArrivalNotice = foundReleaseOrder.arrivalNotice
-    arrivalNotice.releaseGood = null
-    arrivalNotice = await tx.getRepository(ArrivalNotice).save(arrivalNotice)
-
-    await tx.getRepository(ReleaseGood).delete({ domain: { id: domain.id }, name })
-    await deleteArrivalNotice(tx, arrivalNotice.name, user, domain)
-  } else {
-    await tx.getRepository(ReleaseGood).delete({ domain: { id: domain.id }, name })
-  }
-
-  // 5. if there is SO, delete SO
-  if (foundSO) {
-    await tx.getRepository(ShippingOrder).delete({ domain: { id: domain.id }, id: foundSO.id })
-  }
-  return true
-}
-
-export async function generateReleaseGoodFunction(
-  _: any,
-  releaseGood: any,
-  shippingOrder: ShippingOrderPatch,
-  shippingOrderInfo: any,
-  attachments: FileUpload[],
-  context: ResolverContext,
-  tx?: EntityManager
-): Promise<ReleaseGood> {
-  try {
-    const { domain, user } = context.state
-    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-
-    // let orderInventories: OrderInventory[] = releaseGood.orderInventories
-    // let orderVass: OrderVas[] = releaseGood.orderVass
-
-    let { orderInventories, orderVass }: { orderInventories: OrderInventory[]; orderVass: OrderVas[] } = releaseGood
-
-    let bizplace: Bizplace
-    let warehouseDomain: Domain = domain
-    let finalOrderInventories: OrderInventory[] = []
-
-    if (releaseGood.deliverTo) {
-      const deliverTo: ContactPoint = await tx.getRepository(ContactPoint).findOne({
-        where: { id: releaseGood.deliverTo.id },
-        relations: ['bizplace']
-      })
-
-      if (!deliverTo) throw new Error('contact point does not exist')
-
-      releaseGood.deliverTo = deliverTo
-    }
-
-    /** Validate user permitted Bizplace */
-    if (releaseGood.warehouseId) {
-      bizplace = await getOutletBizplace(releaseGood.warehouseId)
-    } else if (releaseGood.customerBizplaceId) {
-      const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-      let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == releaseGood.customerBizplaceId)
-
-      if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-      bizplace = await tx.getRepository(Bizplace).findOne({
-        where: {
-          id: releaseGood.customerBizplaceId
-        },
-        relations: ['domain']
-      })
-      const customerPartner: Partner = await tx.getRepository(Partner).findOne({
-        where: { partnerDomain: { id: bizplace.domain.id }, domain: { id: domain.id } },
-        relations: ['domain']
-      })
-      warehouseDomain = customerPartner.domain
-    } else if (releaseGood.partnerBizplaceId) {
-      const permittedBizplaces: Bizplace[] = await getPermittedBizplaces(domain, user)
-      let foundPermittedBizplace: Bizplace = permittedBizplaces.find(biz => biz.id == releaseGood.partnerBizplaceId)
-
-      if (!foundPermittedBizplace) throw new Error(`This user does not permitted for this company`)
-
-      bizplace = await tx.getRepository(Bizplace).findOne({
-        where: {
-          id: releaseGood.partnerBizplaceId
-        },
-        relations: ['domain']
-      })
-      warehouseDomain = domain
-    } else {
-      bizplace = await getMyBizplace(domain, user)
-    }
-    /** End Validate user permitted Bizplace Section */
-
-    /** Validate Release Order Product Quantity */
-    await InventoryUtil.validateWarehousePartnersProductsQuantity(domain, bizplace, orderInventories, context, tx)
-    /** End Validate Release Order Product Quantity Section */
-
-    const orderSource: string = releaseGood.source
-    switch (orderSource) {
-      case ApplicationType.SELLERCRAFT:
-        const sellercraft: Sellercraft = await tx
-          .getRepository(Sellercraft)
-          .findOneBy({ domain: { id: bizplace.domain.id }, status: SellercraftStatus.ACTIVE })
-
-        if (sellercraft) {
-          const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-          await sellercraftCtrl.checkExistingReleaseGood(sellercraft, releaseGood)
-        }
-
-        break
-
-      case ApplicationType.MMS:
-        const refNo: string = releaseGood.refNo
-        const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-          where: {
-            domain: { id: warehouseDomain.id },
-            refNo,
-            status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]))
-          },
-          relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
-        })
-
-        if (foundReleaseGood) {
-          const customerCompanyDomain: Domain = foundReleaseGood.bizplace.company.domain
-          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { orderNo: refNo, domain: { id: customerCompanyDomain.id } }
-          })
-
-          // Need to restructure the validation
-          if (marketplaceOrder?.isSplitted) {
-            const refNo2: string = releaseGood.refNo2
-            const foundSplittedReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-              where: {
-                domain: { id: warehouseDomain.id },
-                refNo2,
-                status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]))
-              },
-              relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
-            })
-
-            if (foundSplittedReleaseGood) throw new Error('Existing release order found')
-          } else {
-            throw new Error('Existing release order found')
-          }
-        }
-        break
-
-      default:
-        break
-    }
-
-    let newReleaseGood: ReleaseGood = new ReleaseGood()
-
-    /** Generate Shipping Order */
-    if (shippingOrder) {
-      shippingOrder.remark = shippingOrder.exportRemark
-      if (shippingOrder.containerClosureDate !== undefined) {
-        shippingOrder.containerClosureDateTime = new Date(shippingOrder.containerClosureDate)
-      }
-      delete shippingOrder.exportRemark
-
-      const createdSO: ShippingOrder = await tx.getRepository(ShippingOrder).save({
-        ...shippingOrder,
-        name: OrderNoGenerator.shippingOrder(),
-        domain,
-        bizplace,
-        status: ORDER_STATUS.PENDING,
-        creator: user,
-        updater: user
-      })
-
-      newReleaseGood.shippingOrder = createdSO
-    }
-    /** End Generate Shipping Order Section */
-
-    // find RO number rule setting
-    const roNoSetting: Setting = await settingRepo.findOne({
-      where: {
-        domain: { id: domain.id },
-        name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
-      }
-    })
-
-    newReleaseGood = {
-      ...newReleaseGood,
-      name: roNoSetting
-        ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RO_NUMBER, seed: {} })
-        : OrderNoGenerator.releaseGood(),
-      domain: warehouseDomain,
-      bizplace: bizplace,
-      collectionOrderNo: releaseGood.collectionOrderNo,
-      courierOption: releaseGood.courierOption,
-      exportOption: releaseGood.exportOption,
-      ownTransport: releaseGood.ownTransport,
-      packingOption: releaseGood.packingOption,
-      recall: releaseGood.recall,
-      marketplaceOrderStatus: releaseGood?.marketplaceOrderStatus || null,
-      deliverTo: releaseGood.deliverTo,
-      billingAddress:
-        releaseGood.type == 'b2c' ? releaseGood?.billingAddress || null : shippingOrderInfo.billingAddress || null,
-      deliveryAddress1: releaseGood?.deliveryAddress1 || shippingOrderInfo.deliveryAddress1 || null,
-      deliveryAddress2: releaseGood?.deliveryAddress2 || null,
-      deliveryAddress3: releaseGood?.deliveryAddress3 || null,
-      deliveryAddress4: releaseGood?.deliveryAddress4 || null,
-      deliveryAddress5: releaseGood?.deliveryAddress5 || null,
-      attentionTo: releaseGood.type == 'b2c' ? releaseGood?.attentionTo || null : shippingOrderInfo.attentionTo || null,
-      attentionCompany:
-        releaseGood.type == 'b2c' ? releaseGood?.companyName || null : shippingOrderInfo.attentionCompany || null,
-      city: releaseGood.type == 'b2c' ? releaseGood?.city || null : shippingOrderInfo.city || null,
-      state: releaseGood.type == 'b2c' ? releaseGood?.state || null : shippingOrderInfo.state || null,
-      postalCode: releaseGood.type == 'b2c' ? releaseGood?.postalCode || null : shippingOrderInfo.postalCode || null,
-      country: releaseGood.type == 'b2c' ? releaseGood?.country || null : shippingOrderInfo.country || null,
-      phone1: releaseGood.type == 'b2c' ? releaseGood?.phone1 || null : shippingOrderInfo.phone1 || null,
-      phone2: releaseGood?.phone2 || null,
-      email: releaseGood?.email || null,
-      billingCity: releaseGood.type == 'b2c' ? releaseGood?.billingCity || null : shippingOrderInfo.billingCity || null,
-      billingCountry:
-        releaseGood.type == 'b2c' ? releaseGood?.billingCountry || null : shippingOrderInfo.billingCountry || null,
-      billingPostalCode:
-        releaseGood.type == 'b2c'
-          ? releaseGood?.billingPostalCode || null
-          : shippingOrderInfo.billingPostalCode || null,
-      billingState:
-        releaseGood.type == 'b2c' ? releaseGood?.billingState || null : shippingOrderInfo.billingState || null,
-      transporter: releaseGood?.transporter,
-      trackingNo: releaseGood?.trackingNo,
-      airwayBill: releaseGood?.airwayBill,
-      invoice: releaseGood?.invoice,
-      refNo: releaseGood.refNo,
-      refNo2: releaseGood.refNo2,
-      refNo3: releaseGood.refNo3,
-      remark: releaseGood?.remark || null,
-      releaseDate: releaseGood.releaseDate,
-      truckNo: releaseGood.truckNo,
-      bundleInfo: releaseGood?.bundleInfo || [],
-      orderInventories: releaseGood.orderInventories,
-      type: releaseGood?.type ? releaseGood.type : 'b2b',
-      orderMethod: releaseGood?.orderMethod
-        ? releaseGood.orderMethod
-        : releaseGood.orderInventories[0]?.inventory?.id
-          ? ORDER_METHOD.SELECT_BY_PALLET
-          : ORDER_METHOD.SELECT_BY_PRODUCT,
-      status: ORDER_STATUS.PENDING,
-      packageId: releaseGood?.packageId,
-      storeName: releaseGood?.storeName,
-      storeId: releaseGood?.storeId,
-      routeId: releaseGood?.routeId,
-      stopId: releaseGood?.stopId,
-      creator: user,
-      updater: user
-    }
-
-    // Make relation with GAN for cross docking
-    let crossDockingGAN: ArrivalNotice = undefined
-    if (releaseGood.crossDocking && releaseGood.ganNo) {
-      crossDockingGAN = await tx.getRepository(ArrivalNotice).findOne({
-        where: {
-          domain: { id: domain.id },
-          bizplace: { id: bizplace.id },
-          name: releaseGood.ganNo,
-          status: ORDER_STATUS.PENDING
-        }
-      })
-      if (!crossDockingGAN) throw new Error(`Failed to find GAN (${releaseGood.ganNo}) for cross docking`)
-
-      newReleaseGood.arrivalNotice = crossDockingGAN
-    }
-
-    // Make relation with RO for cross docking
-    if (newReleaseGood.crossDocking) {
-      crossDockingGAN.releaseGood = newReleaseGood
-      await tx.getRepository(ArrivalNotice).save(crossDockingGAN)
-    }
-
-    // Check if there is bundle item in orderInventories
-    const bundledOIs: OrderInventory[] = orderInventories.filter(
-      oi => (oi.product as any).groupType === PRODUCT_GROUP_TYPE.BUNDLE
-    )
-
-    const singleProductOIs: OrderInventory[] = orderInventories.filter(
-      oi => (oi.product as any).groupType !== PRODUCT_GROUP_TYPE.BUNDLE
-    )
-
-    const splitBundleOIs: OrderInventory[] = []
-
-    // If there is bundle item, split each item in that bundle into into each product
-    if (bundledOIs && bundledOIs.length > 0) {
-      await Promise.all(
-        bundledOIs.map(async (oi: OrderInventory) => {
-          let splitOI: OrderInventory = null
-
-          const pbSettings: ProductBundleSetting[] = await tx.getRepository(ProductBundleSetting).find({
-            where: { productBundle: { id: oi.product.id } },
-            relations: ['product', 'productBundle']
-          })
-
-          pbSettings.forEach(pbs => {
-            splitOI = {
-              ...oi,
-              releaseQty: oi.releaseQty * pbs.bundleQty,
-              releaseUomValue: oi.releaseUomValue * pbs.bundleQty * pbs.product.primaryValue,
-              packingType: pbs.product.packingType,
-              batchId: '',
-              product: {
-                id: pbs.product.id,
-                name: pbs.product.name,
-                groupType: PRODUCT_GROUP_TYPE.SINGLE
-              } as any
-            }
-            splitBundleOIs.push(splitOI)
-          })
-        })
-      )
-    }
-
-    orderInventories = [...singleProductOIs, ...splitBundleOIs]
-
-    newReleaseGood.noOfItems = orderInventories.length
-    newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
-
-    for (let oi of orderInventories) {
-      let newOrderInv: OrderInventory = Object.assign({}, oi)
-      newOrderInv = {
-        ...newOrderInv,
-        domain: warehouseDomain,
-        bizplace: bizplace,
-        status: ORDER_INVENTORY_STATUS.PENDING,
-        name: OrderNoGenerator.orderInventory(),
-        releaseGood: newReleaseGood,
-        product: await tx.getRepository(Product).findOneBy({ id: oi.product.id }),
-        creator: user,
-        updater: user
-      }
-
-      let newOrderProduct: OrderProduct = Object.assign(new OrderProduct(), newOrderInv)
-      newOrderProduct = {
-        ...newOrderProduct,
-        packQty: 0,
-        actualPackQty: 0,
-        palletQty: 0,
-        actualPalletQty: 0,
-        status: ORDER_PRODUCT_STATUS.ASSIGNED
-      }
-
-      newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
-
-      if (newOrderInv.inventory?.id) {
-        const foundInv: Inventory = await tx.getRepository(Inventory).findOneBy({ id: newOrderInv.inventory.id })
-        newOrderInv.inventory = foundInv
-        newOrderInv.orderProduct = newOrderProduct
-
-        finalOrderInventories.push(newOrderInv)
-      } else {
-        // Preassign Inventories
-        const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
-          where: { domain: { id: domain.id }, name: 'rule-for-inventory-assignment' }
-        })
-
-        let locationSortingRules = []
-        if (inventoryAssignmentSetting) {
-          let locationSetting = JSON.parse(inventoryAssignmentSetting.value)
-          for (const key in locationSetting) {
-            locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
-          }
-        }
-
-        let assignedOrderInventories: OrderInventory[] = await InventoryUtil.autoAssignInventoryForRelease(
-          newOrderInv.product,
-          oi,
-          oi.packingType,
-          locationSortingRules,
-          bizplace,
-          warehouseDomain,
-          tx,
-          oi.batchId
-        )
-
-        assignedOrderInventories = assignedOrderInventories.map(aoi => {
-          return {
-            ...aoi,
-            orderProduct: newOrderProduct
-          }
-        })
-
-        finalOrderInventories.push(...assignedOrderInventories)
-      }
-    }
-
-    for (let oi of finalOrderInventories) {
-      let generatedOI: OrderInventory = Object.assign(new OrderInventory(), oi)
-      generatedOI = {
-        ...generatedOI,
-        domain: warehouseDomain,
-        bizplace,
-        status: ORDER_INVENTORY_STATUS.PENDING,
-        name: OrderNoGenerator.orderInventory(),
-        releaseGood: newReleaseGood,
-        creator: user,
-        updater: user
-      }
-
-      await tx.getRepository(OrderInventory).save({ ...generatedOI })
-
-      // update inventory locked qty and uom value
-      await tx.getRepository(Inventory).update({ id: oi.inventory.id }, {
-        lockedQty: (oi.inventory?.lockedQty || 0) + generatedOI.releaseQty,
-        lockedUomValue: (oi.inventory?.lockedUomValue || 0) + generatedOI.releaseUomValue,
-        updater: user
-      } as any)
-    }
-
-    if (orderVass?.length) {
-      orderVass = await Promise.all(
-        orderVass.map(async orderVas => {
-          if (orderVas?.targetProduct?.id) {
-            orderVas.targetProduct = await tx.getRepository(Product).findOneBy({ id: orderVas.targetProduct.id })
-          }
-
-          let newOrderVas: OrderVas = {
-            ...orderVas,
-            domain: warehouseDomain,
-            bizplace,
-            name: OrderNoGenerator.releaseVas(),
-            vas: await tx.getRepository(Vas).findOneBy({ id: orderVas.vas.id }),
-            type: ORDER_TYPES.RELEASE_OF_GOODS,
-            releaseGood: newReleaseGood,
-            status: ORDER_VAS_STATUS.PENDING,
-            creator: user,
-            updater: user
-          }
-
-          if (orderVas?.inventory?.id) {
-            newOrderVas.inventory = await tx.getRepository(Inventory).findOneBy({ id: orderVas.inventory.id })
-          }
-
-          return newOrderVas
-        })
-      )
-
-      await tx.getRepository(OrderVas).save(orderVass)
-    }
-
-    if (attachments?.length > 0) {
-      const files: Partial<Attachment>[] = attachments.map(attachment => {
-        return {
-          file: attachment,
-          refType: ATTACHMENT_TYPE.DELIVERY_ORDER,
-          refBy: newReleaseGood.id,
-          category: ATTACHMENT_TYPE.DELIVERY_ORDER /* TODO use refType */
-        }
-      })
-      await createAttachments(_, { attachments: files }, context)
-    }
-
-    const directReceiveSetting: Setting = await tx.getRepository(Setting).findOne({
-      where: { domain: { id: domain.id }, category: 'id-rule', name: 'enable-direct-receive-release-order' }
-    })
-
-    if (directReceiveSetting) {
-      const partnerDirectReceiveSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
-        where: {
-          setting: { id: directReceiveSetting?.id },
-          domain: { id: domain.id },
-          partnerDomain: { id: bizplace?.domain.id }
-        }
-      })
-
-      // If status of create RO is PENDING then directly CONFIRM -> RECEIVE
-      if (
-        !isNaN(Number(partnerDirectReceiveSetting?.value)) &&
-        !isNaN(parseFloat(partnerDirectReceiveSetting?.value)) &&
-        newReleaseGood.status === ORDER_STATUS.PENDING
-      ) {
-        let partnerDirectReceiveSettingValue = parseFloat(partnerDirectReceiveSetting.value)
-
-        // CONFIRM if setting value is > 0
-        if (partnerDirectReceiveSettingValue > 0) await confirmReleaseGood(newReleaseGood.name, context, tx)
-
-        // RECEIVE if setting value is > 1
-        if (partnerDirectReceiveSettingValue > 1) await receiveReleaseGood(newReleaseGood.name, context, tx)
-      }
-    }
-
-    return newReleaseGood
-  } catch (error) {
-    throw error
-  }
-}
-
-export async function confirmReleaseGood(name: string, context: any, tx?: EntityManager): Promise<ReleaseGood> {
-  const { user, domain } = context.state
-
-  let foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { name, status: ORDER_STATUS.PENDING },
-    relations: ['domain', 'bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain', 'orderVass']
-  })
-
-  if (!foundReleaseGood) throw new Error(`Release good order doesn't exists.`)
-
-  // query orderInventories separately from releaseGood to reduce resource usage
-  let foundOIs: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-    where: { domain: { id: domain.id }, releaseGood: { id: foundReleaseGood.id } },
-    relations: ['product']
-  })
-
-  // query orderProducts separately from releaseGood to reduce resource usage
-  let foundOPs: OrderProduct[] = await tx.getRepository(OrderProduct).find({
-    where: { domain: { id: domain.id }, releaseGood: { id: foundReleaseGood.id } },
-    relations: ['bizplace', 'product', 'product.productDetails']
-  })
-
-  let foundBundleInfo: any[] = JSON.parse(foundReleaseGood.bundleInfo)
-  let foundOVs: OrderVas[] = foundReleaseGood.orderVass
-  let customerBizplace: Bizplace = foundReleaseGood.bizplace
-  const companyDomain: Domain = customerBizplace?.company.domain
-
-  const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-    where: { domain: { id: foundReleaseGood.bizplace.domain.id }, status: SellercraftStatus.ACTIVE },
-    relations: ['domain']
-  })
-
-  const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-
-  let updateSCStock = async sellercraft => {
-    if (sellercraft) {
-      await sellercraftCtrl.updateSellercraftStock(sellercraft, foundOPs, 'CONFIRM_ORDER')
-    }
-  }
-
-  const orderSource: string = foundReleaseGood.source
-  switch (orderSource) {
-    case ApplicationType.SELLERCRAFT:
-      if (foundReleaseGood.type == 'b2c' && sellercraft) {
-        try {
-          let rg = await sellercraftCtrl.packOrder(sellercraft, {
-            ...foundReleaseGood,
-            orderProducts: foundOPs
-          })
-          foundReleaseGood = rg
-        } catch (error) {
-          logger.error(
-            `release-good-mutation[confirmReleaseGood]:(data:${JSON.stringify({
-              sellercraft,
-              foundReleaseGood,
-              domain,
-              user
-            })}) ${error} `
-          )
-        }
-      }
-      break
-
-    case ApplicationType.MMS:
-      // find for any existing marketplace store connections
-      let marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-        where: { domain: { id: companyDomain.id }, status: 'ACTIVE' },
-        relations: ['marketplaceDistributors']
-      })
-
-      const foundMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-        where: { domain: { id: companyDomain.id }, orderNo: foundReleaseGood.refNo },
-        relations: ['marketplaceStore']
-      })
-
-      let matchedMarketplaceStore: MarketplaceStore
-      if (foundMarketplaceOrder) {
-        matchedMarketplaceStore = marketplaceStores.filter(
-          marketplaceStore => marketplaceStore.id == foundMarketplaceOrder.marketplaceStore.id
-        )[0]
-      }
-
-      let combinedOrderInventories: any[] = foundOIs.map(oi => {
-        return {
-          sku: oi.product.sku,
-          releaseQty: oi.releaseQty
-        }
-      })
-
-      if (foundBundleInfo?.length) {
-        foundBundleInfo.map(bundle => {
-          combinedOrderInventories.push({
-            sku: bundle.sku,
-            releaseQty: bundle.releaseQty
-          })
-        })
-      }
-
-      for (let oi of combinedOrderInventories) {
-        let foundMarketplaceProductVariations: MarketplaceProductVariation[] = await tx
-          .getRepository(MarketplaceProductVariation)
-          .find({
-            where: { domain: { id: companyDomain.id }, sku: oi.sku },
-            relations: ['marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-          })
-
-        if (foundMarketplaceProductVariations) {
-          await Promise.all(
-            foundMarketplaceProductVariations.map(async variation => {
-              if (variation.marketplaceProduct.marketplaceStore.reserveEnabled) {
-                variation.reserveQty -= oi.releaseQty
-              }
-
-              await tx.getRepository(MarketplaceProductVariation).save(variation)
-            })
-          )
-        }
-      }
-
-      if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-        marketplaceStores = marketplaceStores.filter(marketplaceStore => marketplaceStore.isAutoUpdateStockQty)
-        let productIds: string[] = foundOIs.map(oi => oi.product.id)
-        productIds = Array.from(new Set([...productIds]))
-        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-        await ecommerceCtrl.updateProductVariationStock(marketplaceStores, productIds, companyDomain)
-      }
-
-      updateSCStock(sellercraft)
-      break
-
-    default:
-      updateSCStock(sellercraft)
-      break
-  }
-
-  // 1. RO Status change (PENDING => PENDING_RECEIVE)
-  const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).save({
-    ...foundReleaseGood,
-    status: ORDER_STATUS.PENDING_RECEIVE,
-    updater: user
-  })
-
-  // 1. Update status of order inventories
-  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
-    return {
-      ...orderInventory,
-      status: ORDER_INVENTORY_STATUS.PENDING_RECEIVE,
-      updater: user
-    }
-  })
-  await tx.getRepository(OrderInventory).save(foundOIs)
-
-  // 2. Update status of order vass
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((orderVas: OrderVas) => {
-      return {
-        ...orderVas,
-        status: ORDER_VAS_STATUS.PENDING_RECEIVE,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // notification logics
-  // get Office Admin Users
-  if (context?.state?.type != 'api') {
-    const users: any[] = await tx
-      .getRepository('users_roles')
-      .createQueryBuilder('ur')
-      .select('ur.users_id', 'id')
-      .where(qb => {
-        const subQuery = qb
-          .subQuery()
-          .select('role.id')
-          .from(Role, 'role')
-          .where("role.name = 'Office Admin'")
-          .andWhere('role.domain_id = :domain', { domain: domain.id })
-          .getQuery()
-        return 'ur.roles_id IN ' + subQuery
-      })
-      .getRawMany()
-
-    // send notification to Office Admin Users
-    if (users?.length && context.header?.referer) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `New Release Order from ${customerBizplace.name}`,
-        body: `New incoming order, ${foundReleaseGood.name} is pending for receiving`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-
-      /**
-       * @notes Temporary off sendNotification due to suspect of causing wms down
-       */
-
-      // await sendNotification({
-      //   receivers,
-      //   message: { ...msg }
-      // })
-    }
-  }
-
-  return releaseGood
-}
-
-export async function receiveReleaseGood(name: string, context: any, tx: EntityManager): Promise<ReleaseGood> {
-  const { domain, user } = context.state
-
-  const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
-    relations: ['bizplace', 'orderInventories', 'orderVass']
-  })
-
-  if (!foundReleaseGood) throw new Error(`Release good order doesn't exists.`)
-  let foundOIs: OrderInventory[] = foundReleaseGood.orderInventories
-  let foundOVs: OrderVas[] = foundReleaseGood.orderVass
-  let customerBizplace: Bizplace = foundReleaseGood.bizplace
-
-  // 1. RO Status change (PENDING_RECEIVE => PENDING_WORKSHEET)
-  const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).save({
-    ...foundReleaseGood,
-    status: ORDER_STATUS.PENDING_WORKSHEET,
-    acceptedBy: user,
-    acceptedAt: new Date(),
-    updater: user
-  })
-
-  // 1. Update status of order inventories
-  foundOIs = foundOIs.map((orderInventory: OrderInventory) => {
-    return {
-      ...orderInventory,
-      status: ORDER_INVENTORY_STATUS.PENDING_WORKSHEET,
-      updater: user
-    }
-  })
-  await tx.getRepository(OrderInventory).save(foundOIs)
-
-  // 2. Update status of order vass
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((orderVas: OrderVas) => {
-      return {
-        ...orderVas,
-        status: ORDER_VAS_STATUS.READY_TO_PROCESS,
-        updater: user
-      }
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  // notification logics
-  // get Office Admin Users
-  if (context?.state?.type != 'api') {
-    const users: any[] = await tx
-      .getRepository('users_roles')
-      .createQueryBuilder('ur')
-      .select('ur.users_id', 'id')
-      .where(qb => {
-        const subQuery = qb
-          .subQuery()
-          .select('role.id')
-          .from(Role, 'role')
-          .where("role.name = 'Office Admin'")
-          .andWhere('role.domain_id = :domain', { domain: domain.id })
-          .getQuery()
-        return 'ur.roles_id IN ' + subQuery
-      })
-      .getRawMany()
-
-    // send notification to Office Admin Users
-    if (users?.length && context.header?.referer) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `New Release Order from ${customerBizplace.name}`,
-        body: `New incoming order, ${foundReleaseGood.name} is pending for receiving`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-
-      /**
-       * @notes Temporary off sendNotification due to suspect of causing wms down
-       */
-
-      // await sendNotification({
-      //   receivers,
-      //   message: { ...msg }
-      // })
-    }
-  }
-
-  return releaseGood
-}
-
-export async function rejectReleaseGood(
-  tx: EntityManager,
-  context: ResolverContext,
-  name: string,
-  remark: string
-): Promise<ReleaseGood> {
-  const { domain, user } = context.state
-
-  const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
-    relations: [
-      'bizplace',
-      'bizplace.domain',
-      'orderProducts',
-      'orderProducts.product',
-      'orderProducts.product.productDetails',
-      'orderInventories',
-      'orderInventories.inventory',
-      'orderVass',
-      'shippingOrder'
-    ]
-  })
-
-  if (!releaseGood) throw new Error(`Release good doesn't exists.`)
-  if (!remark) throw new Error('Remark is not exist.')
-
-  let foundOIs: OrderInventory[] = releaseGood.orderInventories
-  let foundOVs: OrderVas[] = releaseGood.orderVass
-  let foundOPs: OrderProduct[] = releaseGood.orderProducts
-
-  // 1. Update status of order products (PENDING_RECEIVE => REJECTED)
-  if (foundOIs && foundOIs.length) {
-    await tx.getRepository(OrderInventory).save(
-      await Promise.all(
-        foundOIs.map(async (oi: OrderInventory) => {
-          if (oi?.inventory?.id) {
-            oi.inventory = await tx.getRepository(Inventory).findOneBy({ id: oi.inventory.id })
-
-            await tx.getRepository(Inventory).save({
-              ...oi.inventory,
-              lockedQty: oi.inventory.lockedQty - oi.releaseQty,
-              lockedUomValue: oi.inventory.lockedUomValue - oi.releaseUomValue,
-              updater: user
-            })
-          }
-
-          oi.status = ORDER_INVENTORY_STATUS.REJECTED
-          oi.updater = user
-          return oi
-        })
-      )
-    )
-  }
-
-  if (foundOPs && foundOPs.length) {
-    const orderSource: string = releaseGood.source
-    switch (orderSource) {
-      case ApplicationType.SELLERCRAFT:
-        const sellercraft: Sellercraft = await tx
-          .getRepository(Sellercraft)
-          .findOneBy({ domain: { id: releaseGood.bizplace.domain.id }, status: SellercraftStatus.ACTIVE })
-
-        if (sellercraft) {
-          const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
-          await sellercraftCtrl.updateSellercraftStock(sellercraft, foundOPs, 'REJECT_ORDER')
-        }
-        break
-
-      default:
-        break
-    }
-
-    await tx.getRepository(OrderProduct).save(
-      await Promise.all(
-        foundOPs.map(async (op: OrderProduct) => {
-          op.status = ORDER_PRODUCT_STATUS.REJECTED
-          op.updater = user
-          return op
-        })
-      )
-    )
-  }
-
-  // 2. Update status of order vass if it exists (PENDING_RECEIVE => REJECTED)
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((ov: OrderVas) => {
-      ov.status = ORDER_VAS_STATUS.REJECTED
-      ov.updater = user
-      return ov
-    })
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
-
-  if (releaseGood.shippingOrder) {
-    // 2. 1) if it's yes update status of collection order
-    const shippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).findOne({
-      where: { domain: { id: domain.id }, name: releaseGood.shippingOrder.name }
-    })
-
-    shippingOrder.status = ORDER_STATUS.REJECTED
-    shippingOrder.updater = user
-    await tx.getRepository(ShippingOrder).save(shippingOrder)
-  }
-
-  releaseGood.remark = remark
-  releaseGood.status = ORDER_STATUS.REJECTED
-  releaseGood.updater = user
-  await tx.getRepository(ReleaseGood).save(releaseGood)
-
-  // notification logics
-  const users: any[] = await getDomainUsers(releaseGood?.bizplace, tx)
-
-  if (users?.length && context.header?.referer) {
-    const receivers: any[] = users.map(user => user.id)
-    const msg = {
-      title: `Latest status for ${releaseGood.name}`,
-      body: `Your RO has been rejected.`,
-      url: context.header.referer,
-      data: { url: context.header.referer }
-    }
-
-    /**
-     * @notes Temporary off sendNotification due to suspect of causing wms down
-     */
-
-    // await sendNotification({
-    //   receivers,
-    //   message: { ...msg }
-    // })
-  }
-
-  return releaseGood
-}
-
-export async function bulkGenerateReleaseGood(
-  releaseGood: any,
-  bizplaceId: string,
-  roNoSetting: any,
-  domain: Domain,
-  user: User,
-  tx?: EntityManager
-): Promise<ReleaseGood> {
-  try {
-    let warehouseDomain: Domain = domain
-    let { orderInventories, shippingOrder } = releaseGood
-
-    let bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({ id: bizplaceId })
-
-    let newReleaseGood: ReleaseGood = {
-      ...releaseGood,
-      name: roNoSetting
-        ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RO_NUMBER, seed: {} })
-        : OrderNoGenerator.releaseGood(),
-      domain: warehouseDomain,
-      bizplace: bizplace,
-      deliveryAddress1: releaseGood?.deliveryAddress1 || null,
-      deliveryAddress2: releaseGood?.deliveryAddress2 || null,
-      deliveryAddress3: releaseGood?.deliveryAddress3 || null,
-      deliveryAddress4: releaseGood?.deliveryAddress4 || null,
-      attentionTo: releaseGood?.attentionTo || null,
-      attentionCompany: releaseGood?.attentionCompany || null,
-      city: releaseGood?.city || null,
-      state: releaseGood?.state || null,
-      postalCode: releaseGood?.postalCode || null,
-      country: releaseGood?.country || null,
-      phone1: releaseGood?.phone1 || null,
-      phone2: releaseGood?.phone2 || null,
-      email: releaseGood?.email || null,
-      source: releaseGood?.source || null,
-      airwayBill: releaseGood?.airwayBill,
-      refNo: releaseGood.refNo,
-      refNo2: releaseGood.refNo2,
-      refNo3: releaseGood.refNo3,
-      releaseDate: releaseGood.releaseDate,
-      ownTransport: releaseGood?.ownTransport || false,
-      orderMethod: ORDER_METHOD.SELECT_BY_PRODUCT,
-      status: ORDER_STATUS.PENDING,
-      creator: releaseGood?.creator || user,
-      updater: releaseGood?.updater || user
-    }
-
-    newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
-
-    /** Generate Shipping Order */
-    if (shippingOrder) {
-      shippingOrder.remark = shippingOrder.exportRemark
-      if (shippingOrder.containerClosureDate !== undefined) {
-        shippingOrder.containerClosureDateTime = new Date(shippingOrder.containerClosureDate)
-      }
-      delete shippingOrder.exportRemark
-
-      const createdSO: ShippingOrder = await tx.getRepository(ShippingOrder).save({
-        ...shippingOrder,
-        name: OrderNoGenerator.shippingOrder(),
-        domain,
-        bizplace,
-        status: ORDER_STATUS.PENDING,
-        creator: user,
-        updater: user
-      })
-
-      newReleaseGood.shippingOrder = createdSO
-    }
-
-    let finalOrderInventories: Partial<OrderInventory>[] = []
-
-    // pre assign inventory to orderInventories
-    for (let oi of orderInventories) {
-      const pickingProductSetting: Setting = await tx.getRepository(Setting).findOne({
-        where: { domain: { id: domain.id }, name: 'rule-for-picking-product' }
-      })
-
-      let locationSortingRules = []
-      if (pickingProductSetting) {
-        let locationSetting = JSON.parse(pickingProductSetting.value)
-        for (const key in locationSetting) {
-          locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
-        }
-      }
-
-      const product: Product = await tx.getRepository(Product).findOneBy({ id: oi.productId })
-
-      let assignedResult = await InventoryUtil.autoAssignInventoryForRelease(
-        product,
-        oi,
-        oi.packingType,
-        locationSortingRules,
-        bizplace,
-        warehouseDomain,
-        tx
-      )
-
-      finalOrderInventories.push(
-        ...assignedResult.map(itm => {
-          return {
-            ...itm,
-            orderProduct: oi?.orderProduct
-          }
-        })
-      )
-    }
-
-    for (let oi of finalOrderInventories) {
-      let generatedOI: OrderInventory = Object.assign(new OrderInventory(), oi)
-      generatedOI = {
-        ...generatedOI,
-        domain: warehouseDomain,
-        bizplace,
-        status: ORDER_INVENTORY_STATUS.PENDING,
-        name: OrderNoGenerator.orderInventory(),
-        releaseGood: newReleaseGood,
-        creator: newReleaseGood?.creator || user,
-        updater: newReleaseGood?.updater || user
-      }
-
-      let newOrderProduct: Partial<OrderProduct>
-      if (!oi?.orderProduct) {
-        newOrderProduct = {
-          name: generatedOI.name,
-          product: generatedOI.product,
-          batchId: generatedOI.batchId,
-          packingType: generatedOI.packingType,
-          packingSize: generatedOI.packingSize,
-          uom: generatedOI.uom,
-          domain: warehouseDomain,
-          bizplace,
-          releaseQty: generatedOI.releaseQty,
-          releaseUomValue: generatedOI.releaseUomValue,
-          packQty: 0,
-          actualPackQty: 0,
-          palletQty: 0,
-          actualPalletQty: 0,
-          status: ORDER_PRODUCT_STATUS.ASSIGNED,
-          releaseGood: newReleaseGood,
-          creator: newReleaseGood?.creator || user,
-          updater: newReleaseGood?.updater || user
-        }
-
-        newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
-      } else {
-        newOrderProduct = await tx.getRepository(OrderProduct).save({
-          ...oi.orderProduct,
-          totalUomValue: `${oi.orderProduct.releaseUomValue} ${oi.orderProduct.uom}`,
-          status: ORDER_PRODUCT_STATUS.ASSIGNED,
-          updater: newReleaseGood?.updater || user
-        })
-      }
-
-      await tx.getRepository(OrderInventory).save({ ...generatedOI, orderProduct: newOrderProduct })
-
-      // update inventory locked qty and uom value
-      await tx.getRepository(Inventory).update(oi.inventory.id, {
-        lockedQty: (oi.inventory?.lockedQty || 0) + generatedOI.releaseQty,
-        lockedUomValue: (oi.inventory?.lockedUomValue || 0) + generatedOI.releaseUomValue,
-        updater: user
-      } as any)
-    }
-
-    return newReleaseGood
-  } catch (error) {
-    throw error
-  }
-}
-
-export async function bulkConfirmReleaseGoods(
-  releaseGoodsNo: string[],
-  domain: Domain,
-  user: User,
-  context: any,
-  tx?: EntityManager
-): Promise<ReleaseGood[]> {
-  let foundReleaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
-    where: { name: In(releaseGoodsNo), status: ORDER_STATUS.PENDING },
-    relations: ['bizplace']
-  })
-
-  if (!foundReleaseGoods.length) throw new Error(`release good order doesn't exists.`)
-  let customerBizplace: Bizplace = foundReleaseGoods[0].bizplace
-
-  let foundOrderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-    where: { domain: { id: domain.id }, releaseGood: { id: In(foundReleaseGoods.map((rg: ReleaseGood) => rg.id)) } }
-  })
-
-  await tx
-    .getRepository(ReleaseGood)
-    .update({ id: In(foundReleaseGoods.map(rg => rg.id)) }, { status: ORDER_STATUS.PENDING_RECEIVE, updater: user })
-
-  await tx
-    .getRepository(OrderInventory)
-    .update(
-      { id: In(foundOrderInventories.map(oi => oi.id)) },
-      { status: ORDER_INVENTORY_STATUS.PENDING_RECEIVE, updater: user }
-    )
-
-  if (context?.state?.type != 'api') {
-    const users: any[] = await tx
-      .getRepository('users_roles')
-      .createQueryBuilder('ur')
-      .select('ur.users_id', 'id')
-      .where(qb => {
-        const subQuery = qb
-          .subQuery()
-          .select('role.id')
-          .from(Role, 'role')
-          .where("role.name = 'Office Admin'")
-          .andWhere('role.domain_id = :domain', { domain: domain.id })
-          .getQuery()
-        return 'ur.roles_id IN ' + subQuery
-      })
-      .getRawMany()
-
-    // send notification to Office Admin Users
-    if (users?.length && context.header?.referer) {
-      const receivers: any[] = users.map(user => user.id)
-      const message = {
-        title: `New Release Order from ${customerBizplace.name}`,
-        body: `New incoming bulk release orders are pending for receiving`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
-
-      /**
-       * @notes Temporary off sendNotification due to suspect of causing wms down
-       */
-
-      // await sendNotification({
-      //   receivers,
-      //   message
-      // })
-    }
-  }
-
-  return Promise.all(
-    foundReleaseGoods.map(async (releaseGood: ReleaseGood) => {
-      return {
-        ...releaseGood,
-        orderInventories: await tx
-          .getRepository(OrderInventory)
-          .find({ where: { releaseGood: { id: releaseGood.id } } }) /* CONFIRMME regarding TYPEORM */,
-        status: ORDER_STATUS.PENDING_RECEIVE,
-        updater: user
-      }
-    })
-  )
-}
-
-function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
-  return rawReleaseGoods.reduce((releaseGoods, item) => {
-    const idx: number = releaseGoods.findIndex(rg => {
-      // consider these attributes if they are exist in "item"
-      const comparison = [
-        'refNo2',
-        'refNo3',
-        'attentionTo',
-        'phone1',
-        'deliveryAddress1',
-        'deliveryAddress2',
-        'deliveryAddress3',
-        'deliveryAddress4',
-        'postalCode'
-      ]
-
-      let a: any = {},
-        b: any = {}
-
-      comparison.forEach(cc => {
-        if (item[cc]) {
-          a[cc] = item[cc]
-          b[cc] = rg[cc]
-        }
-      })
-
-      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
-      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
-
-      return rg.refNo == item.refNo && rg.releaseDate == item.releaseDate && a === b
-    })
-
-    if (idx >= 0) {
-      const duplicateSkuIdx: number = releaseGoods[idx].orderInventories.findIndex(
-        oi => oi.sku === item.sku && oi.packingType === item.packingType && oi.packingSize === item.packingSize
-      )
-
-      // if there is duplicated SKU, merge them and sum up the releaseQty
-      if (duplicateSkuIdx >= 0) {
-        releaseGoods[idx].orderInventories[duplicateSkuIdx].releaseQty += item.releaseQty
-      } else {
-        releaseGoods[idx].orderInventories.push({
-          sku: item.sku,
-          productId: item.productId,
-          packingType: item.packingType,
-          packingSize: item.packingSize,
-          uom: item.uom,
-          releaseQty: item.releaseQty,
-          releaseUomValue: item.releaseUomValue
-        })
-      }
-    } else {
-      releaseGoods.push({
-        releaseDate: item.releaseDate,
-        refNo: item.refNo,
-        refNo2: item.refNo2,
-        refNo3: item.refNo3,
-        attentionTo: item.attentionTo,
-        phone1: item.phone1,
-        deliveryAddress1: item.deliveryAddress1,
-        deliveryAddress2: item.deliveryAddress2,
-        deliveryAddress3: item.deliveryAddress3,
-        deliveryAddress4: item.deliveryAddress4,
-        billingAddress: item.billingAddress,
-        billingCity: item.billingPostalCode,
-        billingState: item.billingState,
-        billingCountry: item.billingCountry,
-        billingPostalCode: item.billingPostalCode,
-        city: item.city,
-        postalCode: item.postalCode,
-        state: item.state,
-        country: item.country,
-        orderInventories: [
-          {
-            sku: item.sku,
-            productId: item.productId,
-            packingType: item.packingType,
-            packingSize: item.packingSize,
-            uom: item.uom,
-            releaseQty: item.releaseQty,
-            releaseUomValue: item.releaseUomValue
-          }
-        ]
-      })
-    }
-
-    return releaseGoods
-  }, [])
-}
-
-function formRawReleaseGoods(releaseGood, errorMsg) {
-  let rawReleaseGoods = []
-  for (let i = 0, l = releaseGood.orderInventories.length; i < l; i++) {
-    let rawReleaseGood = {
-      ...releaseGood,
-      ...releaseGood.orderInventories[i],
-      errorMsg
-    }
-
-    delete rawReleaseGood.orderInventories
-    delete rawReleaseGood.product
-
-    rawReleaseGoods.push(rawReleaseGood)
-  }
-  return rawReleaseGoods
-}