@things-factory/sales-base 4.0.0-y.0 → 4.0.4

package/server/graphql/resolvers/release-good/releasable-inventories.ts

@@ -1,141 +0,0 @@
-import { ListParam } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { getRepository, Repository } from 'typeorm'
-import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
-
-interface IFilter {
-  name: string
-  operator?: string
-  value: any
-}
-
-export const releasableInventoriesResolver = {
-  async releasableInventories(_: any, params: ListParam, context: any) {
-    const myBizplace: Bizplace = await getMyBizplace(context.state.domain, context.state.user)
-    const INV_ALIAS = 'INV'
-    const PROD_ALIAS = 'PROD'
-    const GAN_ALIAS = 'GAN'
-    const conditions: IFilter[] = params?.filters
-    let { batchId = null, containerNo = null, product = [], packingType = null, inventory = [] } = getConditionValues(
-      conditions
-    )
-
-    const SELECT: string = `
-      SELECT
-        ${INV_ALIAS}.batch_id,
-        ${INV_ALIAS}.packing_type,
-        (SUM(COALESCE(${INV_ALIAS}.qty, 0)) - SUM(COALESCE(${INV_ALIAS}.locked_qty, 0))) as remain_qty,
-        (SUM(COALESCE(${INV_ALIAS}.uomValue, 0)) - SUM(COALESCE(${INV_ALIAS}.locked_uom_value, 0))) as remain_uom_value,
-        ${PROD_ALIAS}.id as product_id,
-        ${PROD_ALIAS}.name as product_name,
-        ${GAN_ALIAS}.container_no
-    `
-    const FROM: string = `
-      FROM
-        inventories ${INV_ALIAS}
-      LEFT JOIN
-        products ${PROD_ALIAS}
-      ON
-        ${PROD_ALIAS}.id = ${INV_ALIAS}.product_id
-      LEFT JOIN
-        arrival_notices ${GAN_ALIAS}
-      ON
-        ${GAN_ALIAS}.id = CAST(${INV_ALIAS}.ref_order_id as uuid)
-    `
-
-    const WHERE: string = `
-      WHERE
-        ${INV_ALIAS}.status = 'STORED'
-        AND ${INV_ALIAS}.qty > 0
-        AND ${INV_ALIAS}.bizplace_id = '${myBizplace.id}'
-        ${batchId ? `AND LOWER(${INV_ALIAS}.batch_id) LIKE '%${batchId.toLowerCase()}%'` : ''}
-        ${packingType ? `AND LOWER(${INV_ALIAS}.packing_type) LIKE '%${packingType.toLowerCase()}%'` : ''}
-        ${containerNo ? `AND LOWER(${GAN_ALIAS}.container_no) LIKE '%${containerNo.toLowerCase()}%'` : ''}
-        ${
-          product?.length > 0 && product[0]
-            ? `AND ${PROD_ALIAS}.id IN (${product.map((id: string) => `'${id}'`).join(', ')})`
-            : product[0] === null
-            ? `AND ${PROD_ALIAS}.id isnull`
-            : ''
-        }
-        ${
-          inventory?.length > 0
-            ? `
-              AND (${INV_ALIAS}.batch_id, ${PROD_ALIAS}.id) ${
-                params.filters.find(
-                  (filter: { name: string; operator: string; value: any }) => filter.name === 'inventory'
-                ).operator
-              } (
-                ${inventory
-                  .map((inv: { batchId: string; productId: string }) => `('${inv.batchId}', '${inv.productId}')`)
-                  .join(', ')}
-              )
-            `
-            : ''
-        }
-    `
-
-    // ${product?.length > 0 ? `AND ${PROD_ALIAS}.id IN (${product.map((id: string) => id ? `'${id}'` : null).join(', ')})` : ''}
-    const GROUP_BY: string = `
-      GROUP BY
-      ${INV_ALIAS}.batch_id,
-      ${INV_ALIAS}.packing_type,
-      ${GAN_ALIAS}.container_no,
-      ${PROD_ALIAS}.id
-    `
-
-    const OFFSET_LIMIT: string = `
-        OFFSET ${params.pagination.limit * (params.pagination.page - 1)}
-        LIMIT ${params.pagination.limit}
-    `
-
-    const invRepo: Repository<Inventory> = getRepository(Inventory)
-    let items: Inventory[] = await invRepo.query(`
-      ${SELECT} ${FROM} ${WHERE} ${GROUP_BY} ${OFFSET_LIMIT}
-    `)
-    items = items.map((item: Inventory) => {
-      return {
-        batchId: item.batch_id,
-        packingType: item.packing_type,
-        remainQty: item.remain_qty,
-        remainUomValue: item.remain_uom_value,
-        productName: item.product_name,
-        product: {
-          id: item.product_id,
-          name: item.product_name
-        },
-        containerNo: item.container_no
-      }
-    })
-
-    const results: [{ total: number }] = await invRepo.query(`
-      SELECT max(cnt.cnt) as total FROM (
-        SELECT (ROW_NUMBER() OVER()) as cnt ${FROM} ${WHERE} ${GROUP_BY}
-      ) as cnt
-    `)
-
-    return {
-      items,
-      total: Number(results[0].total)
-    }
-  }
-}
-
-function getConditionValues(
-  conditions: IFilter[]
-): {
-  batchId?: string
-  containerNo?: string
-  product?: string[]
-  packingType?: string
-  inventory?: { batchId: string; productId: string }[]
-} {
-  return conditions.reduce((condition, cond: IFilter): {} => {
-    condition = {
-      ...condition,
-      [cond.name]: cond.value
-    }
-
-    return condition
-  }, {})
-}

package/server/graphql/resolvers/release-good/release-good-detail.ts

@@ -1,192 +0,0 @@
-import { Attachment } from '@things-factory/attachment-base'
-import { Product } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-import { getRepository, EntityManager } from 'typeorm'
-import { ORDER_STATUS, ORDER_INVENTORY_STATUS } from '../../../constants'
-import { ATTACHMENT_TYPE } from '../../../constants/attachment-type'
-import { OrderInventory, ReleaseGood, ShippingOrder } from '../../../entities'
-import orderBy from 'lodash/orderBy'
-
-export const releaseGoodDetailResolver = {
-  async releaseGoodDetail(_: any, { name }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-    
-    const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: {
-        domain,
-        name
-      },
-      relations: [
-        'domain',
-        'bizplace',
-        'shippingOrder',
-        'arrivalNotice',
-        'orderInventories',
-        'orderInventories.inventory',
-        'orderInventories.product',
-        'orderInventories.inventory.product',
-        'orderInventories.inventory.location',
-        'orderVass',
-        'orderVass.vas',
-        'orderVass.targetProduct',
-        'orderVass.inventory',
-        'creator',
-        'updater',
-        'deliverTo'
-      ]
-    })
-
-    const roBizId: string = releaseGood.bizplace.id
-    const shippingOrder: ShippingOrder = releaseGood.shippingOrder
-    const foundAttachments: Attachment[] = await tx.getRepository(Attachment).find({
-      where: {
-        domain,
-        refBy: releaseGood.id,
-        category: ATTACHMENT_TYPE.DELIVERY_ORDER
-      }
-    })
-
-    await prepOITempTable(domain, tx)
-
-    let invInfos = await Promise.all(
-      releaseGood.orderInventories.filter(itm=> itm.status!= ORDER_INVENTORY_STATUS.COMPLETE_SPLIT).map(async (orderInv: OrderInventory) => {
-        if (orderInv?.inventory?.id) {
-          const inventory: Inventory = orderInv.inventory
-          return {
-            id: inventory.id,
-            name: inventory.name,
-            batchId: inventory.batchId,
-            batchIdRef: inventory.batchIdRef,
-            palletId: inventory.palletId,
-            product: inventory.product,
-            productIdRef: inventory.product.id,
-            productName: `${inventory.product.name} (${inventory.product.description})`,
-            packingType: inventory.packingType,
-            packingSize: inventory.packingSize,
-            location: inventory.location,
-            qty: inventory.qty,
-            uom: inventory.uom,
-            uomValue: inventory.uomValue,
-            releaseQty: orderInv.releaseQty,
-            releaseUomValue: orderInv.releaseUomValue,
-            status: orderInv.status
-          }
-        } else {
-          const { batchId, batchIdRef, product, packingType, packingSize, releaseQty, releaseUomValue } = orderInv
-          const { id: productIdRef, name: productName }: Product = product
-          const { qty, uomValue, uom } = await getAvailableAmount(roBizId, productIdRef, batchId, packingType, tx)
-
-          return {
-            batchId,
-            batchIdRef,
-            productIdRef,
-            product,
-            productName,
-            packingType,
-            packingSize,
-            qty,
-            uom,
-            uomValue,
-            releaseQty,
-            releaseUomValue
-          }
-        }
-      })
-    )
-
-    const result = {
-      ...releaseGood,
-      attachment: foundAttachments,
-      shippingOrderInfo: {
-        containerNo: shippingOrder?.containerNo || '',
-        containerLeavingDate: shippingOrder?.containerLeavingDate || '',
-        containerArrivalDate: shippingOrder?.containerArrivalDate || '',
-        shipName: shippingOrder?.shipName || ''
-      },
-      inventoryInfos:  orderBy(invInfos, ['product.sku'], ['asc'])
-    }
-
-    dropOITempTable(domain, tx)
-
-    return result
-  }
-}
-
-async function prepOITempTable(domain: Domain, tx:EntityManager) {
-  await tx.query(`
-    CREATE TEMP TABLE oi AS (
-      SELECT
-        SUM(oi.release_qty) as release_qty,
-        SUM(oi.release_uom_value) as release_uom_value,
-        oi.batch_id,
-        p.id as product_id,
-        oi.packing_type
-      FROM
-        order_inventories oi
-      LEFT JOIN
-        products p
-      ON
-        oi.product_id = p.id
-      WHERE
-        oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT') 
-        AND oi.batch_id NOTNULL
-        AND oi.product_id NOTNULL
-        AND oi.packing_type NOTNULL
-        AND oi.inventory_id IS NULL
-        AND oi.domain_id = $1
-      GROUP BY
-        oi.product_id,
-        oi.batch_id,
-        oi.packing_type,
-        p.id
-    )`,[domain.id]
-  )
-}
-
-async function dropOITempTable(domain: Domain, tx:EntityManager) {
-  await tx.query(`DROP TABLE oi`)
-}
-
-async function getAvailableAmount(
-  roBizId: string,
-  productIdRef: string,
-  batchId: string,
-  packingType: string,
-  tx: EntityManager
-): Promise<{ qty: number; uomValue: number; uom: string }> {
-  const result: any[] = await tx.getRepository(Inventory).query(`
-    SELECT
-      SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) as "qty",
-      SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) as "uom_value",
-      uom
-    FROM
-      inventories i
-      LEFT JOIN products p on i.product_id = p.id
-      LEFT JOIN oi on i.batch_id = oi.batch_id
-      AND p.id = oi.product_id
-      AND i.packing_type = oi.packing_type
-    WHERE
-      i.bizplace_id = '${roBizId}'
-      AND i.status = 'STORED'
-      AND i.batch_id = '${batchId}'
-      AND p.id = '${productIdRef}'
-      AND i.packing_type = '${packingType}'
-    GROUP BY
-      i.batch_id,
-      p.id,
-      i.packing_type,
-      i.uom
-  `)
-
-  let qty: number = 0
-  let uomValue: number = 0
-  let uom: string = ''
-  if (result?.length) {
-    qty = result[0].qty
-    uomValue = result[0].uom_value
-    uom = result[0].uom
-  }
-
-  return { qty, uomValue, uom }
-}

package/server/graphql/resolvers/release-good/release-good-requests.ts

@@ -1,70 +0,0 @@
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, ListParam } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
-import { ORDER_STATUS } from '../../../constants'
-import { ReleaseGood } from '../../../entities'
-
-export const releaseGoodRequestsResolver = {
-  async releaseGoodRequests(_: any, params: ListParam, context: any) {
-    try {
-      const statusFilter = params.filters.some(e => e.name === 'status')
-      const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
-
-      if (!statusFilter) {
-        params.filters.push({
-          name: 'status',
-          operator: 'notin',
-          value: [ORDER_STATUS.PENDING, ORDER_STATUS.EDITING],
-          relation: false
-        })
-      }
-
-      if (!bizplaceFilter) {
-        params.filters.push({
-          name: 'bizplaceId',
-          operator: 'in',
-          value: await getPermittedBizplaceIds(context.state.domain, context.state.user),
-          relation: false
-        })
-      }
-
-      const qb: SelectQueryBuilder<ReleaseGood> = getRepository(ReleaseGood).createQueryBuilder('rg')
-      buildQuery(qb, params, context)
-      qb.addSelect(subQuery => {
-        return subQuery
-          .select('COALESCE("ccd".rank, 99999)', 'rank')
-          .from('common_code_details', 'ccd')
-          .innerJoin('ccd.commonCode', 'cc')
-          .where('"ccd"."name" = "rg"."status"')
-          .andWhere('"ccd"."domain_id" = "rg"."domain_id"')
-          .andWhere('"cc"."name" = \'RO_REQUESTS_STATUS\'')
-      }, 'rank')
-      qb.leftJoinAndSelect('rg.domain', 'domain')
-      qb.leftJoinAndSelect('rg.bizplace', 'bizplace')
-      qb.leftJoinAndSelect('rg.arrivalNotice', 'an')
-      qb.leftJoinAndSelect('rg.creator', 'creator')
-      qb.leftJoinAndSelect('rg.updater', 'updater')
-      qb.leftJoinAndSelect('rg.acceptedBy', 'acceptedBy')
-      qb.leftJoinAndSelect('rg.deliverTo', 'deliverTo')
-
-      const arrChildSortData = ['bizplace']
-      const sort = (params.sortings || []).reduce(
-        (acc, sort) => ({
-          ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'rg.' + sort.name]: sort.desc
-            ? 'DESC'
-            : 'ASC'
-        }),
-        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
-      )
-
-      qb.orderBy(sort)
-
-      const [items, total] = await qb.getManyAndCount()
-
-      return { items, total }
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/release-good/release-good.ts

@@ -1,33 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository, In } from 'typeorm'
-import { ReleaseGood } from '../../../entities'
-
-export const releaseGoodResolver = {
-  async releaseGood(_: any, { name }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
-
-    return await getRepository(ReleaseGood).findOne({
-      where: {
-        domain,
-        name,
-        bizplace: In(await getPermittedBizplaceIds(domain, user))
-      },
-      relations: [
-        'domain',
-        'bizplace',
-        'shippingOrder',
-        'arrivalNotice',
-        'orderInventories',
-        'orderInventories.product',
-        'orderInventories.inventory',
-        'orderInventories.inventory.product',
-        'orderVass',
-        'orderVass.vas',
-        'creator',
-        'updater'
-      ]
-    })
-  }
-}

package/server/graphql/resolvers/release-good/release-goods.ts

@@ -1,58 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
-import { ReleaseGood } from '../../../entities'
-
-export const releaseGoodsResolver = {
-  async releaseGoods(_: any, params: ListParam, context: any) {
-    try {
-      const { domain, user }: { domain: Domain; user: User } = context.state
-
-      if (!params.filters.find((filter: any) => filter.name === 'bizplace')) {
-        params.filters.push({
-          name: 'bizplaceId',
-          operator: 'in',
-          value: await getPermittedBizplaceIds(domain, user),
-          relation: false
-        })
-      }
-
-      const qb: SelectQueryBuilder<ReleaseGood> = getRepository(ReleaseGood).createQueryBuilder('rg')
-      buildQuery(qb, params, context)
-      qb.addSelect(subQuery => {
-        return subQuery
-          .select('COALESCE("ccd".rank, 99999)', 'rank')
-          .from('common_code_details', 'ccd')
-          .innerJoin('ccd.commonCode', 'cc')
-          .where('"ccd"."name" = "rg"."status"')
-          .andWhere('"ccd"."domain_id" = "rg"."domain_id"')
-          .andWhere('"cc"."name" = \'RO_LIST_STATUS\'')
-      }, 'rank')
-      qb.leftJoinAndSelect('rg.domain', 'domain')
-      qb.leftJoinAndSelect('rg.bizplace', 'bizplace')
-      qb.leftJoinAndSelect('rg.arrivalNotice', 'an')
-      qb.leftJoinAndSelect('rg.creator', 'creator')
-      qb.leftJoinAndSelect('rg.updater', 'updater')
-
-      const arrChildSortData = ['bizplace']
-      const sort = (params.sortings || []).reduce(
-        (acc, sort) => ({
-          ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'rg.' + sort.name]: sort.desc
-            ? 'DESC'
-            : 'ASC'
-        }),
-        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
-      )
-
-      qb.orderBy(sort)
-
-      const [items, total] = await qb.getManyAndCount()
-
-      return { items, total }
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/retail-replenishment-order/add-retail-replenishment-order-products.ts

@@ -1,64 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Product } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { OrderProduct, RetailReplenishmentOrder } from '../../../entities'
-import { OrderNoGenerator } from '../../../utils'
-
-export const addRetailReplenishmentOrderProductsResolver = {
-  async addRetailReplenishmentOrderProducts(_: any, { sroNo, orderProducts }, context: any): Promise<void> {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
-    const retailReplenishmentOrder: RetailReplenishmentOrder = await tx
-      .getRepository(RetailReplenishmentOrder)
-      .findOne({
-        where: { name: sroNo },
-        relations: ['bizplace', 'orderProducts']
-      })
-
-    await addRetailReplenishmentOrderProducts(domain, retailReplenishmentOrder, orderProducts, user, tx)
-  }
-}
-
-export async function addRetailReplenishmentOrderProducts(
-  domain: Domain,
-  retailReplenishmentOrder: RetailReplenishmentOrder,
-  orderProducts: OrderProduct[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
-  const orderProductRepo: Repository<OrderProduct> = tx?.getRepository(OrderProduct) || getRepository(OrderProduct)
-
-  if (!retailReplenishmentOrder?.bizplace || !retailReplenishmentOrder?.orderProducts?.length) {
-    retailReplenishmentOrder = await tx.getRepository(RetailReplenishmentOrder).findOne({
-      where: { ...retailReplenishmentOrder },
-      relations: ['bizplace', 'orderProducts']
-    })
-  }
-
-  orderProducts = await Promise.all(
-    orderProducts.map(async (op: OrderProduct) => {
-      const foundProduct = await productRepo.findOne({ domain, sku: op.product.sku, name: op.product.name })
-      if (!foundProduct) throw new Error(`Product ${op.product.name} (${op.product.sku}) is not exist.`)
-
-      return {
-        ...op,
-        domain,
-        bizplace: retailReplenishmentOrder.bizplace,
-        name: OrderNoGenerator.orderProduct(),
-        product: foundProduct,
-        retailReplenishmentOrder,
-        //========= need to revise ===========
-        packingType: foundProduct.packingType,
-        uom: foundProduct.weightUnit,
-        uomValue: foundProduct.weight,
-        totalUomValue: `${(foundProduct.weight * op.packQty).toFixed(2)} ${foundProduct.weightUnit}`,
-        //====================================
-        creator: user,
-        updater: user
-      }
-    })
-  )
-
-  await orderProductRepo.save(orderProducts)
-}

package/server/graphql/resolvers/retail-replenishment-order/cancel-retail-replenishment-order.ts

@@ -1,44 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { OrderProduct, RetailReplenishmentOrder } from '../../../entities'
-
-export const cancelRetailReplenishmentOrderResolver = {
-  async cancelRetailReplenishmentOrder(_: any, { patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    const bizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
-
-    const retailReplenishmentOrder: RetailReplenishmentOrder = await tx
-      .getRepository(RetailReplenishmentOrder)
-      .findOne({
-        where: { domain, bizplace, name: patch.name },
-        relations: ['orderProducts']
-      })
-
-    if (!retailReplenishmentOrder) throw new Error(`Retail replenishment order does not exist.`)
-    if (!patch.status) throw new Error('Status was not specified.')
-    // if (status && (status !== ORDER_STATUS.PENDING_CANCEL || status !== ORDER_STATUS.CANCELLED))
-    //   throw new Error(`Status provided was invalid.`)
-
-    let foundOPs: OrderProduct[] = retailReplenishmentOrder.orderProducts
-
-    // 1. Update status of order products based on status (to PENDING_CANCEL or CANCELLED)
-    if (foundOPs && foundOPs.length) {
-      foundOPs = foundOPs.map((orderProduct: OrderProduct) => {
-        orderProduct.status = patch.status
-        orderProduct.updater = user
-        return orderProduct
-      })
-    }
-    await tx.getRepository(OrderProduct).save(foundOPs)
-
-    // 2. Update retail replenishment order status
-    return await tx.getRepository(RetailReplenishmentOrder).save({
-      ...retailReplenishmentOrder,
-      remark: patch.remark, //think another way if warehouse confirm cancellation > no need to overwrite remark
-      status: patch.status,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/retail-replenishment-order/complete-retail-replenishment-order.ts

@@ -1,54 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { ORDER_PRODUCT_STATUS, ORDER_STATUS } from '../../../constants'
-import { OrderProduct, RetailReplenishmentOrder } from '../../../entities'
-
-export const completeRetailReplenishmentOrderResolver = {
-  async completeRetailReplenishmentOrder(_: any, { patch }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-
-    const myBizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
-    let targetOPs: OrderProduct[] = patch.orderProducts
-    let partialReceived: Boolean = false
-
-    // #1 Find Retail Replenishment Order
-    const foundRRO: RetailReplenishmentOrder = await tx.getRepository(RetailReplenishmentOrder).findOne({
-      where: { domain, name: patch.name, bizplace: myBizplace },
-      relations: ['orderProducts']
-    })
-
-    if (!foundRRO) throw new Error(`Retail replenishment order does not exist.`)
-
-    if (foundRRO?.status && foundRRO.status === ORDER_STATUS.RECEIVED)
-      throw new Error(`Retail replenishment order is already completed.`)
-
-    // #2 Find related order inventories
-    let foundOPs: OrderProduct[] = await tx.getRepository(OrderProduct).find({
-      where: { domain, transferOrder: foundRRO }
-    })
-    if (!foundOPs) throw new Error(`Order products were not found.`)
-
-    foundOPs = foundOPs.map((orderProduct: OrderProduct) => {
-      const foundTargetOP = targetOPs.filter(
-        (targetOP: OrderProduct) => targetOP.name === orderProduct.name && targetOP.batchId === orderProduct.batchId
-      )[0]
-
-      orderProduct.status = foundTargetOP.status
-      orderProduct.remark = foundTargetOP?.remark ? foundTargetOP.remark : null
-      if (orderProduct.status.includes(ORDER_PRODUCT_STATUS.NOT_RECEIVED)) partialReceived = true
-      orderProduct.updater = user
-
-      return orderProduct
-    })
-    await tx.getRepository(OrderProduct).save(foundOPs)
-
-    // #3 Update status of retail replenishment order (RECEIVED / PARTIALLY_RECEIVED)
-    return await tx.getRepository(RetailReplenishmentOrder).save({
-      ...foundRRO,
-      status: partialReceived ? ORDER_STATUS.PARTIAL_RECEIVED : ORDER_STATUS.RECEIVED,
-      updater: user
-    })
-  }
-}