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

package/server/{entities → service/release-good}/release-good.ts

@@ -1,7 +1,4 @@
-import { User } from '@things-factory/auth-base'
-import { config } from '@things-factory/env'
-import { Bizplace, ContactPoint } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -12,9 +9,26 @@ import {
   OneToMany,
   OneToOne,
   PrimaryGeneratedColumn,
+  RelationId,
   UpdateDateColumn
 } from 'typeorm'
-import { ArrivalNotice, DeliveryOrder, OrderProduct, OrderInventory, OrderVas, ShippingOrder } from '../entities'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
+import { config } from '@things-factory/env'
+import { Domain } from '@things-factory/shell'
+
+import {
+  ArrivalNotice,
+  DeliveryOrder,
+  InventoryInfos,
+  OrderInventory,
+  OrderProduct,
+  OrderVas,
+  ShippingOrder,
+  ShippingOrderInfo
+} from '../'
 
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
@@ -25,26 +39,40 @@ export enum ReleaseOrderType {
 }
 @Entity()
 @Index('ix_release-good_0', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.name], { unique: true })
+@ObjectType()
 export class ReleaseGood {
   @PrimaryGeneratedColumn('uuid')
-  id: string
+  @Field(type => ID)
+  readonly id: string
 
   @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
   domain: Domain
 
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.domain)
+  domainId: string
+
   @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
   bizplace: Bizplace
 
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.bizplace)
+  bizplaceId: string
+
   @Column({ nullable: true })
+  @Field({ nullable: true })
   name: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   collectionOrderNo: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   description: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   truckNo: string
 
   @Column({
@@ -57,143 +85,234 @@ export class ReleaseGood {
     enum: ReleaseOrderType,
     default: ReleaseOrderType.B2B
   })
+  @Field()
   type: ReleaseOrderType
 
   @Column({ default: false })
+  @Field()
   exportOption: Boolean
 
   @Column({ default: false })
+  @Field()
   courierOption: Boolean
 
   @Column({ default: false })
+  @Field()
   packingOption: Boolean
 
   @Column()
+  @Field()
   ownTransport: Boolean
 
   @Column({ default: false })
+  @Field()
   crossDocking: Boolean
 
-  @ManyToOne(type => ArrivalNotice, { nullable: true })
+  @ManyToOne(type => ArrivalNotice)
+  @Field(type => ArrivalNotice, { nullable: true })
   arrivalNotice: ArrivalNotice
 
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.arrivalNotice)
+  arrivalNoticeId: string
+
   @OneToMany(type => DeliveryOrder, deliveryOrder => deliveryOrder.releaseGood)
+  @Field(type => [DeliveryOrder], { nullable: true })
   deliveryOrders: DeliveryOrder[]
 
   @OneToOne(type => ShippingOrder)
   @JoinColumn()
+  @Field(type => ShippingOrder, { nullable: true })
   shippingOrder: ShippingOrder
 
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.shippingOrder)
+  shippingOrderId: string
+
   @OneToMany(type => OrderVas, orderVas => orderVas.releaseGood)
-  orderVass: OrderVas[]
+  @Field(type => [OrderVas], { nullable: true })
+  orderVass?: OrderVas[]
 
   @OneToMany(type => OrderInventory, orderInventory => orderInventory.releaseGood)
+  @Field(type => [OrderInventory], { nullable: true })
   orderInventories: OrderInventory[]
 
   @OneToMany(type => OrderProduct, orderProduct => orderProduct.releaseGood)
+  @Field(type => [OrderProduct], { nullable: true })
   orderProducts: OrderProduct[]
 
   @Column()
+  @Field()
   status: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   releaseDateTime: Date
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   refNo: String
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   refNo2: String
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   refNo3: String
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   releaseDate: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   remark: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   marketplaceOrderStatus: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   billingAddress: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
+  pickupAddress: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  pickupTime: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  handoverType: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  dropoffAddress: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
   deliveryAddress1: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   deliveryAddress2: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   deliveryAddress3: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   deliveryAddress4: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   deliveryAddress5: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   attentionTo: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   attentionCompany: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   city: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   state: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   postalCode: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   country: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   phone1: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   phone2: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   email: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
+  packageId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
   transporter: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   trackingNo: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   airwayBill: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   invoice: string
 
   @CreateDateColumn()
+  @Field()
   createdAt: Date
 
   @UpdateDateColumn()
+  @Field()
   updatedAt: Date
 
-  @ManyToOne(type => User, { nullable: true })
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
   acceptedBy: User
 
-  @Column({
-    nullable: true
-  })
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.acceptedBy)
+  acceptedById: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
   acceptedAt: Date
 
-  @ManyToOne(type => ContactPoint, { nullable: true })
+  @ManyToOne(type => ContactPoint)
+  @Field(type => ContactPoint, { nullable: true })
   deliverTo: ContactPoint
 
-  @ManyToOne(type => User, { nullable: true })
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.deliverTo)
+  deliverToId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
   creator: User
 
-  @ManyToOne(type => User, { nullable: true })
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
   updater: User
+
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.updater)
+  updaterId: string
+
+  @Field(type => [Attachment], { nullable: true })
+  attachment?: Attachment[]
+
+  @Field(type => [InventoryInfos], { nullable: true })
+  inventoryInfos?: InventoryInfos[]
+
+  @Field(type => ShippingOrderInfo, { nullable: true })
+  shippingOrderInfo?: ShippingOrderInfo
 }

package/server/service/retail-replenishment-order/index.ts

@@ -0,0 +1,9 @@
+import { RetailReplenishmentOrder } from './retail-replenishment-order'
+import { RetailReplenishmentOrderMutation } from './retail-replenishment-order-mutation'
+import { RetailReplenishmentOrderQuery } from './retail-replenishment-order-query'
+
+export const entities = [RetailReplenishmentOrder]
+export const resolvers = [RetailReplenishmentOrderQuery, RetailReplenishmentOrderMutation]
+
+export * from './retail-replenishment-order-mutation'
+export * from './retail-replenishment-order-query'

package/server/service/retail-replenishment-order/retail-replenishment-order-mutation.ts

@@ -0,0 +1,376 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
+import { generateId } from '@things-factory/id-rule-base'
+import { Product } from '@things-factory/product-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, In, Repository } from 'typeorm'
+import {
+  NewOrderProduct,
+  NewRetailReplenishmentOrder,
+  OrderProduct,
+  OrderVas,
+  RetailReplenishmentOrderPatch
+} from '../'
+import {
+  ORDER_NUMBER_RULE_TYPE,
+  ORDER_NUMBER_SETTING_KEY,
+  ORDER_PRODUCT_STATUS,
+  ORDER_STATUS,
+  TRANSFER_ORDER_TYPE
+} from '../../constants'
+import { OrderNoGenerator } from '../../utils'
+import { generateTransferOrder } from '../transfer-order/transfer-order-mutation'
+import { RetailReplenishmentOrder } from './retail-replenishment-order'
+
+@Resolver(RetailReplenishmentOrder)
+export class RetailReplenishmentOrderMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async addRetailReplenishmentOrderProducts(
+    @Arg('sroNo') sroNo: string,
+    @Arg('orderProducts', type => [NewOrderProduct]) orderProducts: NewOrderProduct[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    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)
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => RetailReplenishmentOrder)
+  async cancelRetailReplenishmentOrder(
+    @Arg('patch', type => RetailReplenishmentOrderPatch) patch: RetailReplenishmentOrderPatch,
+    @Ctx() context: any
+  ): Promise<RetailReplenishmentOrder> {
+    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
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => RetailReplenishmentOrder)
+  async createRetailReplenishmentOrder(
+    @Arg('retailReplenishmentOrder', type => NewRetailReplenishmentOrder)
+    retailReplenishmentOrder: NewRetailReplenishmentOrder,
+    @Ctx() context: any
+  ): Promise<RetailReplenishmentOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+
+    let orderVass: OrderVas[] = retailReplenishmentOrder.orderVass
+    const myBizplace: Bizplace = await getOutletBizplace(retailReplenishmentOrder.warehouseId)
+
+    // #1 check for allocated qty to identify the status: APPROVED or PENDING
+    const allocatedQty: number = null
+    let status = allocatedQty ? ORDER_STATUS.PENDING : ORDER_STATUS.APPROVED
+    let remark = allocatedQty ? 'INSUFFICIENT QTY' : ''
+
+    let orderProducts: NewOrderProduct[] = retailReplenishmentOrder.orderProducts
+    orderProducts = orderProducts.map((op: NewOrderProduct) => {
+      return {
+        ...op,
+        status: allocatedQty ? ORDER_PRODUCT_STATUS.PENDING : ORDER_PRODUCT_STATUS.APPROVED,
+        remark
+      }
+    })
+
+    const rrNoSetting: Setting = await settingRepo.findOne({
+      where: {
+        domain,
+        name: ORDER_NUMBER_SETTING_KEY.RR_NUMBER_RULE
+      }
+    })
+
+    let orderNo: string = ''
+
+    if (rrNoSetting) {
+      orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RR_NUMBER, seed: {} })
+    } else {
+      orderNo = OrderNoGenerator.retailReplenishmentOrder()
+    }
+
+    // #2 Create Retail Replenishment Order
+    const createdRetailReplenishmentOrder: RetailReplenishmentOrder = await tx
+      .getRepository(RetailReplenishmentOrder)
+      .save({
+        ...retailReplenishmentOrder,
+        name: orderNo,
+        bizplace: myBizplace,
+        status,
+        domain,
+        creator: user,
+        updater: user
+      })
+
+    // #3 Create retail replenishment order products
+    await addRetailReplenishmentOrderProducts(domain, createdRetailReplenishmentOrder, orderProducts, user, tx)
+
+    // #4 generate transfer order if status is APPROVED
+    if (createdRetailReplenishmentOrder.status === ORDER_STATUS.APPROVED) {
+      const issuedDate: string = retailReplenishmentOrder.issuedDate
+      const remark: string = retailReplenishmentOrder.remark
+      const refNo: string = retailReplenishmentOrder.refNo
+      const ownTransport: boolean = retailReplenishmentOrder.ownTransport
+      const orderInventories: any[] = orderProducts.map((op: NewOrderProduct) => {
+        return {
+          batchId: op.batchId,
+          releaseQty: op.packQty,
+          product: op.product,
+          packingType: op.packingType
+        }
+      })
+
+      await generateTransferOrder(
+        {
+          issuedDate,
+          remark,
+          refNo,
+          type: TRANSFER_ORDER_TYPE.NORMAL,
+          ownTransport,
+          orderInventories,
+          orderVass,
+          bizplace: myBizplace,
+          retailReplenishmentOrder: createdRetailReplenishmentOrder
+        } as any,
+        domain,
+        user,
+        tx
+      )
+    }
+
+    return createdRetailReplenishmentOrder
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => RetailReplenishmentOrder)
+  async completeRetailReplenishmentOrder(
+    @Arg('patch', type => RetailReplenishmentOrderPatch) patch: RetailReplenishmentOrderPatch,
+    @Ctx() context: any
+  ): Promise<RetailReplenishmentOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const myBizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
+    let targetOPs: NewOrderProduct[] = 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: NewOrderProduct) => 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
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => RetailReplenishmentOrder)
+  async updateRetailReplenishmentOrder(
+    @Arg('name') name: string,
+    @Arg('patch', type => RetailReplenishmentOrderPatch) patch: RetailReplenishmentOrderPatch,
+    @Ctx() context: any
+  ): Promise<RetailReplenishmentOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const bizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
+    const repository = tx.getRepository(RetailReplenishmentOrder)
+
+    delete patch.warehouseId //exclude warehouse Id from patch
+
+    const retailReplenishmentOrder = await repository.findOne({
+      where: { domain, name, bizplace },
+      relations: ['orderProducts', 'orderProducts.product']
+    })
+
+    if (!retailReplenishmentOrder) throw new Error(`Retail replenishment order is not found.`)
+    if (retailReplenishmentOrder && retailReplenishmentOrder.status !== ORDER_STATUS.REJECTED)
+      throw new Error(`You are not allowed to update this order with status: ${retailReplenishmentOrder.status}`)
+
+    return await repository.save({
+      ...retailReplenishmentOrder,
+      ...patch,
+      status: ORDER_STATUS.PENDING_RECEIVE,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [RetailReplenishmentOrder])
+  async updateMultipleRetailReplenishmentOrder(
+    @Arg('patches', type => [RetailReplenishmentOrderPatch]) patches: RetailReplenishmentOrderPatch[],
+    @Ctx() context: any
+  ): Promise<RetailReplenishmentOrder[]> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    let results: RetailReplenishmentOrder[] = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const retailReplenishmentOrderRepo = tx.getRepository(RetailReplenishmentOrder)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await retailReplenishmentOrderRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const retailReplenishmentOrder = await retailReplenishmentOrderRepo.findOne(newRecord.id)
+
+        const result = await retailReplenishmentOrderRepo.save({
+          ...retailReplenishmentOrder,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteRetailReplenishmentOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    await tx.getRepository(RetailReplenishmentOrder).delete({ domain, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteRetailReplenishmentOrders(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    await tx.getRepository(RetailReplenishmentOrder).delete({
+      domain,
+      name: In(names)
+    })
+    return true
+  }
+}
+export async function addRetailReplenishmentOrderProducts(
+  domain: Domain,
+  retailReplenishmentOrder: RetailReplenishmentOrder,
+  orderProducts: (OrderProduct | NewOrderProduct)[],
+  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)
+}