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

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

@@ -0,0 +1,297 @@
+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 { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { ArrivalNotice, DeliveryOrder, OrderInventory, OrderProduct, OrderVas, ShippingOrder } from '../'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+export enum ReleaseOrderType {
+  B2B = 'b2b',
+  B2C = 'b2c'
+}
+@Entity()
+@Index('ix_release-good_0', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.name], { unique: true })
+@ObjectType()
+export class ReleaseGood {
+  @PrimaryGeneratedColumn('uuid')
+  @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({
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+        ? 'varchar2'
+        : 'smallint',
+    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)
+  @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)
+  @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)
+  @Field(type => User, { nullable: true })
+  acceptedBy: User
+
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.acceptedBy)
+  acceptedById: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  acceptedAt: Date
+
+  @ManyToOne(type => ContactPoint)
+  @Field(type => ContactPoint, { nullable: true })
+  deliverTo: ContactPoint
+
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.deliverTo)
+  deliverToId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((releaseGood: ReleaseGood) => releaseGood.updater)
+  updaterId: string
+}

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

@@ -0,0 +1,6 @@
+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]

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)
+}