@things-factory/sales-base 4.0.0-alpha.6 → 4.0.0-beta.0

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

@@ -0,0 +1,861 @@
+import { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, In, Not, Repository } from 'typeorm'
+
+import { Attachment, createAttachments } from '@things-factory/attachment-base'
+import { Partner, Role, User } from '@things-factory/auth-base'
+import {
+  Bizplace,
+  getDomainUsers,
+  getMyBizplace,
+  getOutletBizplace,
+  getPermittedBizplaces
+} from '@things-factory/biz-base'
+import { generateId } from '@things-factory/id-rule-base'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { sendNotification } from '@things-factory/notification'
+import { Product, ProductBundleSetting } from '@things-factory/product-base'
+import { PartnerSetting, Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import {
+  ArrivalNotice,
+  NewReleaseGood,
+  OrderInventory,
+  OrderProduct,
+  OrderVas,
+  ReleaseGoodPatch,
+  ShippingOrder,
+  ShippingOrderPatch,
+  Vas
+} from '../'
+import {
+  ATTACHMENT_TYPE,
+  ORDER_INVENTORY_STATUS,
+  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 { InventoryUtil, OrderNoGenerator } from '../../utils'
+import { confirmArrivalNoticeFunction, deleteArrivalNotice } from '../arrival-notice/arrival-notice-mutation'
+import { ReleaseGood } from './release-good'
+
+@Resolver(ReleaseGood)
+export class ReleaseGoodMutation {
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteReleaseGood(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
+    const { tx, user, domain }: { tx: EntityManager; user: User; domain: 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: any): Promise<Boolean> {
+    const { tx }: { tx: EntityManager } = context.state
+    await tx.getRepository(ReleaseGood).delete({
+      domain: context.state.domain,
+      name: In(names)
+    })
+    return true
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ReleaseGood)
+  async generateReleaseGood(
+    @Ctx() context: any,
+    @Arg('attachments', type => [GraphQLUpload]) attachments: FileUpload[],
+    @Arg('releaseGood', type => NewReleaseGood, { nullable: true }) releaseGood?: NewReleaseGood,
+    @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch
+  ): Promise<ReleaseGood> {
+    const { tx }: { tx: EntityManager } = context.state
+    const createdReleaseGood: ReleaseGood = await generateReleaseGoodFunction(
+      null,
+      releaseGood,
+      shippingOrder,
+      attachments,
+      context,
+      tx
+    )
+
+    return createdReleaseGood
+  }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ReleaseGood)
+  async confirmReleaseGood(@Arg('name') name: string, @Ctx() context: any): Promise<ReleaseGood> {
+    const { tx }: { tx: EntityManager } = 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(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: any): Promise<ReleaseGood> {
+    const { tx }: { tx: EntityManager } = 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: any
+  ): Promise<ReleaseGood> {
+    const { tx }: { tx: EntityManager } = context.state
+
+    return await rejectReleaseGood(tx, context, name, patch.remark)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ReleaseGood)
+  async addReleaseGood(
+    @Ctx() context: any,
+    @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 }: { tx: EntityManager } = context.state
+    const createdRO: ReleaseGood = await generateReleaseGoodFunction(
+      null,
+      releaseGood,
+      shippingOrder,
+      file,
+      context,
+      tx
+    )
+
+    const confirmedRO: ReleaseGood = await confirmReleaseGood(createdRO.name, context, tx)
+
+    const receivedRO: ReleaseGood = await receiveReleaseGood(confirmedRO.name, context, tx)
+
+    return receivedRO
+  }
+}
+
+export async function deleteReleaseGood(tx: EntityManager, name: string, user: User, domain: Domain): Promise<boolean> {
+  let foundReleaseOrder: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+    where: { domain, name },
+    relations: [
+      'arrivalNotice',
+      'orderInventories',
+      'orderInventories.orderProduct',
+      'orderInventories.inventory',
+      'orderVass',
+      'shippingOrder',
+      'creator',
+      'updater'
+    ]
+  })
+
+  if (!foundReleaseOrder) throw new Error(`Arrival notice 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,
+        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).findOne(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) })
+  }
+
+  // 4. if there is SO, delete SO
+  if (foundSO) {
+    await tx.getRepository(ShippingOrder).delete({ domain, id: foundSO.id })
+  }
+
+  if (foundAttachment) {
+    await tx.getRepository(Attachment).delete({ domain, id: foundAttachment.id })
+  }
+
+  // 5. 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, name })
+    await deleteArrivalNotice(tx, arrivalNotice.name, user, domain)
+  } else {
+    await tx.getRepository(ReleaseGood).delete({ domain, name })
+  }
+  return true
+}
+
+export async function generateReleaseGoodFunction(
+  _: any,
+  releaseGood: any,
+  shippingOrder: any,
+  attachments: FileUpload[],
+  context: any,
+  tx?: EntityManager
+): Promise<ReleaseGood> {
+  try {
+    const { domain, user }: { domain: Domain; user: 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
+
+    /** 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: bizplace.domain, domain }, 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 */
+
+    if (releaseGood.type == 'b2c') {
+      const sellercraft: Sellercraft = await tx
+        .getRepository(Sellercraft)
+        .findOne({ domain: bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+      if (sellercraft) {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        await sellercraftCtrl.checkExistingReleaseGood(sellercraft, releaseGood)
+      } else {
+        const refNo: string = releaseGood.refNo
+        const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+          where: {
+            domain: warehouseDomain,
+            refNo,
+            status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]))
+          }
+        })
+
+        if (foundReleaseGood) throw new Error('Existing release order found')
+      }
+    }
+
+    let newReleaseGood: ReleaseGood = new ReleaseGood()
+
+    /** Generate Shipping Order */
+    if (shippingOrder) {
+      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,
+        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,
+      marketplaceOrderStatus: releaseGood?.marketplaceOrderStatus || null,
+      billingAddress: releaseGood?.billingAddress || null,
+      deliveryAddress1: releaseGood?.deliveryAddress1 || null,
+      deliveryAddress2: releaseGood?.deliveryAddress2 || null,
+      deliveryAddress3: releaseGood?.deliveryAddress3 || null,
+      deliveryAddress4: releaseGood?.deliveryAddress4 || null,
+      deliveryAddress5: releaseGood?.deliveryAddress5 || 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,
+      transporter: releaseGood?.transporter,
+      trackingNo: releaseGood?.trackingNo,
+      airwayBill: releaseGood?.airwayBill,
+      invoice: releaseGood?.invoice,
+      refNo: releaseGood.refNo,
+      refNo2: releaseGood.refNo2,
+      refNo3: releaseGood.refNo3,
+      releaseDate: releaseGood.releaseDate,
+      truckNo: releaseGood.truckNo,
+      orderInventories: releaseGood.orderInventories,
+      type: releaseGood?.type ? releaseGood.type : 'b2b',
+      status: ORDER_STATUS.PENDING,
+      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, bizplace, name: releaseGood.ganNo, status: ORDER_STATUS.PENDING }
+      })
+      if (!crossDockingGAN) throw new Error(`Failed to find GAN (${releaseGood.ganNo}) for cross docking`)
+
+      newReleaseGood.arrivalNotice = crossDockingGAN
+    }
+
+    newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
+
+    // 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.groupType === PRODUCT_GROUP_TYPE.BUNDLE
+    )
+
+    const singleProductOIs: OrderInventory[] = orderInventories.filter(
+      oi => oi.product.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: 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
+              }
+            }
+            splitBundleOIs.push(splitOI)
+          })
+        })
+      )
+    }
+
+    orderInventories = [...singleProductOIs, ...splitBundleOIs]
+
+    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).findOne(oi.product.id),
+        creator: user,
+        updater: user
+      }
+
+      if (newOrderInv.inventory?.id) {
+        const foundInv: Inventory = await tx.getRepository(Inventory).findOne(newOrderInv.inventory.id)
+        newOrderInv.inventory = foundInv
+
+        foundInv.lockedQty = Number(foundInv.lockedQty) + newOrderInv.releaseQty
+        foundInv.lockedUomValue = Number(foundInv.lockedUomValue) + newOrderInv.releaseUomValue
+        foundInv.updater = user
+
+        await tx.getRepository(Inventory).save(foundInv)
+      }
+
+      let newOrderProduct: OrderProduct = Object.assign(new OrderProduct(), newOrderInv)
+      newOrderProduct = {
+        ...newOrderProduct,
+        packQty: 0,
+        actualPackQty: 0,
+        palletQty: 0,
+        actualPalletQty: 0,
+        status: newOrderInv.inventory?.id ? ORDER_PRODUCT_STATUS.ASSIGNED : ORDER_PRODUCT_STATUS.PENDING_ASSIGN
+      }
+
+      newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
+
+      await tx.getRepository(OrderInventory).save({ ...newOrderInv, orderProduct: newOrderProduct })
+    }
+
+    if (orderVass?.length) {
+      orderVass = await Promise.all(
+        orderVass.map(async orderVas => {
+          if (orderVas?.targetProduct?.id) {
+            orderVas.targetProduct = await tx.getRepository(Product).findOne(orderVas.targetProduct.id)
+          }
+
+          let newOrderVas: OrderVas = {
+            ...orderVas,
+            domain: warehouseDomain,
+            bizplace,
+            name: OrderNoGenerator.releaseVas(),
+            vas: await tx.getRepository(Vas).findOne(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).findOne(orderVas.inventory.id)
+          }
+
+          return newOrderVas
+        })
+      )
+
+      await tx.getRepository(OrderVas).save(orderVass)
+    }
+
+    if (attachments?.length > 0) {
+      const files: Attachment[] = attachments.map(attachment => {
+        return {
+          file: attachment,
+          refBy: newReleaseGood.id,
+          category: ATTACHMENT_TYPE.DELIVERY_ORDER
+        }
+      })
+      await createAttachments(_, { attachments: files }, context)
+    }
+
+    const directReceiveSetting: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain, category: 'id-rule', name: 'enable-direct-receive-release-order' }
+    })
+
+    const partnerDirectReceiveSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
+      where: { setting: directReceiveSetting, domain, partnerDomain: bizplace?.domain }
+    })
+
+    // If status of create RO is PENDING then directly CONFIRM -> RECEIVE
+    if (
+      !isNaN(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 }: { user: User; domain: 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',
+      'orderProducts',
+      'orderProducts.product',
+      'orderInventories',
+      'orderInventories.product',
+      '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
+  const companyDomain: Domain = customerBizplace?.company.domain
+
+  if (foundReleaseGood.type == 'b2c') {
+    const sellercraft: Sellercraft = await tx
+      .getRepository(Sellercraft)
+      .findOne({ domain: foundReleaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      foundReleaseGood = await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
+    } else {
+      // find for any existing marketplace store connections
+      const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+        where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+        relations: ['marketplaceDistributors']
+      })
+
+      if (marketplaceStores?.length && marketplaceStores.some(store => store.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)
+      }
+    }
+  }
+
+  // 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) {
+      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 }
+      }
+      await sendNotification({
+        receivers,
+        message: { ...msg }
+      })
+    }
+  }
+
+  return releaseGood
+}
+
+export async function receiveReleaseGood(name: string, context: any, tx: EntityManager): Promise<ReleaseGood> {
+  const { domain, user }: { domain: Domain; user: User } = context.state
+
+  const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+    where: { domain, 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) {
+      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 }
+      }
+
+      await sendNotification({
+        receivers,
+        message: { ...msg }
+      })
+    }
+  }
+
+  return releaseGood
+}
+
+export async function rejectReleaseGood(
+  tx: EntityManager,
+  context: any,
+  name: string,
+  remark: string
+): Promise<ReleaseGood> {
+  const { domain, user }: { domain: Domain; user: User } = context.state
+
+  const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
+    relations: ['bizplace', '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
+
+  // 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).findOne(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
+        })
+      )
+    )
+  }
+
+  // 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, 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) {
+    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 }
+    }
+
+    await sendNotification({
+      receivers,
+      message: { ...msg }
+    })
+  }
+
+  return releaseGood
+}