@things-factory/sales-base 5.0.13 → 6.0.0-alpha.1

package/server/service/delivery-order/delivery-order-mutation.ts

@@ -1,7 +1,7 @@
 import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
 import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository, In, Repository } from 'typeorm'
+import { EntityManager, In, Repository } from 'typeorm'
 
 import { Attachment, createAttachment, deleteAttachment } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
@@ -9,7 +9,7 @@ import { Bizplace, ContactPoint, getPermittedBizplaceIds } from '@things-factory
 import { generateId } from '@things-factory/id-rule-base'
 import { Product } from '@things-factory/product-base'
 import { Setting } from '@things-factory/setting-base'
-import { Domain, ObjectRef } from '@things-factory/shell'
+import { Domain, getRepository, ObjectRef } from '@things-factory/shell'
 import { TransportDriver, TransportVehicle, TRUCK_STATUS } from '@things-factory/transport-base'
 import { Inventory } from '@things-factory/warehouse-base'
 
@@ -24,6 +24,8 @@ import { OrderNoGenerator } from '../../utils/order-no-generator'
 import { OrderInventory } from '../order-inventory/order-inventory'
 import { NewOrderInventory, OrderInventoryPatch } from '../order-inventory/order-inventory-types'
 import { ReleaseGood } from '../release-good/release-good'
+import { ExportInformationPatch, ShippingOrderInfoPatch } from '../release-good/release-good-types'
+import { ShippingOrder } from '../shipping-order/shipping-order'
 import { DeliveryOrder } from './delivery-order'
 import { DeliveryOrderPatch, NewDeliveryOrder } from './delivery-order-types'
 
@@ -32,13 +34,13 @@ export class DeliveryOrderMutation {
   @Directive('@transaction')
   @Mutation(returns => DeliveryOrder)
   async createDeliveryOrder(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('orderInfo', type => NewDeliveryOrder, { nullable: true }) orderInfo?: NewDeliveryOrder,
     @Arg('customerBizplace', type => ObjectRef, { nullable: true }) customerBizplace?: ObjectRef,
     @Arg('targetInventories', type => [NewOrderInventory], { nullable: true }) targetInventories?: NewOrderInventory[],
     @Arg('file', type => [GraphQLUpload], { nullable: true }) file?: FileUpload[]
   ): Promise<DeliveryOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     return await createDeliveryOrder(orderInfo, customerBizplace, targetInventories, file, domain, user, tx)
   }
@@ -48,13 +50,13 @@ export class DeliveryOrderMutation {
   async updateDeliveryOrder(
     @Arg('name') name: string,
     @Arg('patch', type => DeliveryOrderPatch) patch: DeliveryOrderPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DeliveryOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const deliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name,
         bizplace: In(await getPermittedBizplaceIds(domain, user))
       }
@@ -69,15 +71,15 @@ export class DeliveryOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteDeliveryOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteDeliveryOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
 
     const foundDO = await tx.getRepository(DeliveryOrder).findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
     if (foundDO) {
       const previousAttachment: Attachment = await tx.getRepository(Attachment).findOne({
-        where: { domain, refBy: foundDO.id }
+        where: { domain: { id: domain.id }, refBy: foundDO.id }
       })
       if (previousAttachment) await deleteAttachment(null, { id: previousAttachment.id }, context)
       await tx.getRepository(DeliveryOrder).delete({ domain, name })
@@ -88,24 +90,32 @@ export class DeliveryOrderMutation {
   @Directive('@transaction')
   @Mutation(returns => DeliveryOrder)
   async generateDeliveryOrder(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('orderInfo', type => DeliveryOrderPatch, { nullable: true }) orderInfo?: DeliveryOrderPatch,
     @Arg('customerBizplace', type => ObjectRef, { nullable: true }) customerBizplace?: ObjectRef,
     @Arg('releaseGood', type => ObjectRef, { nullable: true }) releaseGood?: ObjectRef,
     @Arg('targetInventories', type => [ObjectRef], { nullable: true }) targetInventories?: ObjectRef[]
   ): Promise<DeliveryOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
-    return await generateDeliveryOrder(orderInfo, targetInventories, customerBizplace, releaseGood, domain, user, tx)
+    return await generateDeliveryOrder(
+      orderInfo,
+      targetInventories as any,
+      customerBizplace,
+      releaseGood as any,
+      domain,
+      user,
+      tx
+    )
   }
 
   @Directive('@transaction')
   @Mutation(returns => DeliveryOrder)
-  async confirmDeliveryOrder(@Arg('name') name: string, @Ctx() context: any): Promise<DeliveryOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async confirmDeliveryOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<DeliveryOrder> {
+    const { tx, domain, user } = context.state
 
     const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['creator', 'updater']
     })
 
@@ -125,12 +135,12 @@ export class DeliveryOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => DeliveryOrder)
-  async receiveDeliveryOrder(@Arg('name') name: string, @Ctx() context: any): Promise<DeliveryOrder> {
+  async receiveDeliveryOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<DeliveryOrder> {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
 
       const deliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain, name }
+        where: { domain: { id: domain.id }, name }
       })
 
       if (!deliveryOrder) throw new Error(`Delivery order doesn't exists.`)
@@ -151,14 +161,14 @@ export class DeliveryOrderMutation {
   @Directive('@transaction')
   @Mutation(returns => DeliveryOrder)
   async checkDeliveredOrder(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('name') name: string,
     @Arg('patch', type => DeliveryOrderPatch, { nullable: true }) patch?: DeliveryOrderPatch
   ): Promise<DeliveryOrder> {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
       const deliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain, name },
+        where: { domain: { id: domain.id }, name },
         relations: ['bizplace', 'transportDriver', 'transportVehicle']
       })
 
@@ -166,7 +176,7 @@ export class DeliveryOrderMutation {
       if (deliveryOrder.status !== ORDER_STATUS.DELIVERING) throw new Error(`Status is not receivable.`)
 
       let orderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-        where: { domain, deliveryOrder: deliveryOrder },
+        where: { domain: { id: domain.id }, deliveryOrder: { id: deliveryOrder.id } },
         relations: ['product']
       })
 
@@ -206,28 +216,51 @@ export class DeliveryOrderMutation {
     }
   }
 
+  /**
+   * comment start
+   * detailed review needed 06 Aug 2022 by @ChrisLim-git
+   * @param context 
+   * @param orderInfo 
+   * @param orderItems 
+   * @param shippingOrderInfo 
+   * @param exportInfo 
+   * @returns DeliveryOrder
+   */
   @Directive('@transaction')
   @Mutation(returns => DeliveryOrder)
   async dispatchDeliveryOrder(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('orderInfo', type => DeliveryOrderPatch, { nullable: true }) orderInfo?: DeliveryOrderPatch,
-    @Arg('orderItems', type => [OrderInventoryPatch], { nullable: true }) orderItems?: OrderInventoryPatch[]
+    @Arg('orderItems', type => [OrderInventoryPatch], { nullable: true }) orderItems?: OrderInventoryPatch[],
+    @Arg('shippingInfo', type => ShippingOrderInfoPatch, { nullable: true })
+    shippingOrderInfo?: ShippingOrderInfoPatch,
+    @Arg('exportInfo', type => ExportInformationPatch, { nullable: true }) exportInfo?: ExportInformationPatch
   ): Promise<DeliveryOrder> {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
       const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain, name: orderInfo.name },
+        where: { domain: { id: domain.id }, name: orderInfo.name },
         relations: ['transportVehicle', 'bizplace']
       })
 
+      const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: {
+          name: orderInfo.releaseGoodNo,
+          domain
+        },
+        relations: ['shippingOrder']
+      })
+
       if (!foundDeliveryOrder) throw new Error(`Delivery order doesn't exists.`)
       if (foundDeliveryOrder.status === ORDER_STATUS.PENDING_CANCEL)
         throw new Error('Release order is pending for cancel')
 
+      foundDeliveryOrder.ownCollection = orderInfo.transportType == 'Own Transport' ? true : false
+
       let deliveryOrderStatus = foundDeliveryOrder.status
       let orderInventories: OrderInventory[]
       orderInventories = await tx.getRepository(OrderInventory).find({
-        where: { domain, deliveryOrder: foundDeliveryOrder },
+        where: { domain: { id: domain.id }, deliveryOrder: { id: foundDeliveryOrder.id } },
         relations: ['inventory', 'inventory.product', 'inventory.reusablePallet']
       })
 
@@ -236,16 +269,16 @@ export class DeliveryOrderMutation {
         const product: Product = inventory.product
         const foundItem = inventory.reusablePallet
           ? orderItems.filter(
-              (item: any) =>
-                item.productName === `${product.name} (${product.description})` &&
-                item.batchId === orderInventory.batchId &&
-                item.pallet === inventory.reusablePallet.name
-            )
+            (item: any) =>
+              item.productName === `${product.name} (${product.description})` &&
+              item.batchId === orderInventory.batchId &&
+              item.pallet === inventory.reusablePallet.name
+          )
           : orderItems.filter(
-              (item: any) =>
-                item.productName === `${product.name} (${product.description})` &&
-                item.batchId === orderInventory.batchId
-            )
+            (item: any) =>
+              item.productName === `${product.name} (${product.description})` &&
+              item.batchId === orderInventory.batchId
+          )
 
         if (foundItem[0].remark !== '') orderInventory.remark = foundItem[0].remark
         return orderInventory
@@ -270,7 +303,7 @@ export class DeliveryOrderMutation {
         foundCP = await tx.getRepository(ContactPoint).save(foundCP)
       } else {
         foundCP = await tx.getRepository(ContactPoint).findOne({
-          where: { domain, id: orderInfo.contactPoint, bizplace: foundDeliveryOrder.bizplace }
+          where: { domain: { id: domain.id }, id: orderInfo.contactPoint, bizplace: foundDeliveryOrder.bizplace }
         })
       }
 
@@ -278,13 +311,13 @@ export class DeliveryOrderMutation {
       let transportVehicle: TransportVehicle = null
       if (orderInfo?.ownDriver) {
         transportDriver = await tx.getRepository(TransportDriver).findOne({
-          where: { domain, name: orderInfo.ownDriver }
+          where: { domain: { id: domain.id }, name: orderInfo.ownDriver }
         })
       }
 
       if (orderInfo?.ownTruck) {
         transportVehicle = await tx.getRepository(TransportVehicle).findOne({
-          where: { domain, name: orderInfo.ownTruck }
+          where: { domain: { id: domain.id }, name: orderInfo.ownTruck }
         })
 
         await tx.getRepository(TransportVehicle).save({
@@ -299,18 +332,101 @@ export class DeliveryOrderMutation {
         deliveryOrderStatus = ORDER_STATUS.DELIVERING
       }
 
+      // save export option information
+      if (orderInfo?.exportOption) {
+        let savedShippingOrder: any = ''
+        /**
+         * Could potentially override important data
+         */
+        if (foundReleaseGood.shippingOrder == null) {
+          savedShippingOrder = await tx.getRepository(ShippingOrder).save({
+            name: OrderNoGenerator.shippingOrder(),
+            shipName: exportInfo.shipName,
+            containerNo: exportInfo.containerNo,
+            containerArrivalDate: exportInfo.containerArrivalDate,
+            containerLeavingDate: exportInfo.containerLeavingDate,
+            status: ORDER_STATUS.PENDING,
+            domain,
+            bizplace: foundDeliveryOrder.bizplace,
+            creator: user,
+            updater: user
+          })
+        }
+
+        /**
+         * @oscarchuaweiwen-fsd
+         * I think the expectation here is to update instead of save
+         * Should use .update instead of .save as it will override data that was not meant to be updated
+         * example:
+         * 
+         * savedShippingOrder = await tx.getRepository(ShippingOrder).update({
+         *  shipName: exportInfo.shipName,
+         *  containerNo: exportInfo.containerNo,
+         *  containerArrivalDate: exportInfo.containerArrivalDate,
+         *  containerLeavingDate: exportInfo.containerLeavingDate,
+         *  status: ORDER_STATUS.PENDING,
+         *  updater: user
+         * })
+         * 
+         * Unless the intention was not to update but to insert
+         */
+        savedShippingOrder = await tx.getRepository(ShippingOrder).save({
+          ...foundReleaseGood.shippingOrder,
+          name: OrderNoGenerator.shippingOrder(),
+          shipName: exportInfo.shipName,
+          containerNo: exportInfo.containerNo,
+          containerArrivalDate: exportInfo.containerArrivalDate,
+          containerLeavingDate: exportInfo.containerLeavingDate,
+          status: ORDER_STATUS.PENDING,
+          domain,
+          bizplace: foundDeliveryOrder.bizplace,
+          creator: user,
+          updater: user
+        })
+        /** */
+
+        exportInfo = savedShippingOrder
+        foundReleaseGood.exportOption = true
+      } else {
+        foundReleaseGood.exportOption = false
+        foundReleaseGood.collectionOrderNo = ''
+      }
+
+      await tx.getRepository(ReleaseGood).save({
+        ...foundReleaseGood,
+        shippingOrder: {
+          ...exportInfo
+        },
+        collectionOrderNo: orderInfo.coNo
+      })
+
       await tx.getRepository(DeliveryOrder).save({
         ...foundDeliveryOrder,
         transportDriver,
+        palletQty: orderInfo?.totalPalletQty,
         transportVehicle,
-        contactPointRefId: foundCP.id || null,
+        contactPointRefId: foundCP?.id || null,
         otherDriver: orderInfo?.otherDriver || null,
         truckNo: orderInfo?.otherTruck || orderInfo?.ownTruck,
-        to: foundCP.address,
-        deliveryDate: orderInfo.deliveryDate,
-        remark: orderInfo.remark,
+        to: foundCP?.address,
+        deliveryDate: orderInfo?.deliveryDate,
+        deliveryDateTime: new Date(),
+        remark: orderInfo?.remark,
         status: deliveryOrderStatus,
-        reusablePallet: orderInfo.reusablePallet,
+        reusablePallet: orderInfo?.reusablePallet,
+        attentionTo: shippingOrderInfo?.attentionTo || null,
+        attentionCompany: shippingOrderInfo?.attentionCompany || null,
+        city: shippingOrderInfo?.city || null,
+        state: shippingOrderInfo?.state || null,
+        postalCode: shippingOrderInfo?.postalCode || null,
+        country: shippingOrderInfo?.country || null,
+        phone1: shippingOrderInfo?.phone1 || null,
+        deliveryAddress1: shippingOrderInfo?.deliveryAddress1 || null,
+        billingAddress: shippingOrderInfo?.billingAddress || null,
+        billingCountry: shippingOrderInfo?.billingCountry || null,
+        billingPostalCode: shippingOrderInfo?.billingPostalCode || null,
+        billingState: shippingOrderInfo?.billingState || null,
+        billingCity: shippingOrderInfo?.billingCity || null,
         updater: user
       })
 
@@ -319,18 +435,19 @@ export class DeliveryOrderMutation {
       throw e
     }
   }
+  /** */
 
   @Directive('@transaction')
   @Mutation(returns => DeliveryOrder)
   async dispatchManualDeliveryOrder(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('orderInfo', type => DeliveryOrderPatch, { nullable: true }) orderInfo?: DeliveryOrderPatch,
     @Arg('orderItems', type => [OrderInventoryPatch], { nullable: true }) orderItems?: OrderInventoryPatch[]
   ): Promise<DeliveryOrder> {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
       const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain, name: orderInfo.name },
+        where: { domain: { id: domain.id }, name: orderInfo.name },
         relations: ['transportVehicle', 'bizplace']
       })
 
@@ -341,7 +458,7 @@ export class DeliveryOrderMutation {
       let deliveryOrderStatus = foundDeliveryOrder.status
       let orderInventories: OrderInventory[]
       orderInventories = await tx.getRepository(OrderInventory).find({
-        where: { domain, deliveryOrder: foundDeliveryOrder },
+        where: { domain: { id: domain.id }, deliveryOrder: { id: foundDeliveryOrder.id } },
         relations: ['product']
       })
 
@@ -363,7 +480,7 @@ export class DeliveryOrderMutation {
         foundCP = await tx.getRepository(ContactPoint).save(foundCP)
       } else {
         foundCP = await tx.getRepository(ContactPoint).findOne({
-          where: { domain, id: orderInfo.contactPoint }
+          where: { domain: { id: domain.id }, id: orderInfo.contactPoint }
         })
       }
 
@@ -371,13 +488,13 @@ export class DeliveryOrderMutation {
       let transportVehicle: TransportVehicle = null
       if (orderInfo?.ownDriver) {
         transportDriver = await tx.getRepository(TransportDriver).findOne({
-          where: { domain, name: orderInfo.ownDriver }
+          where: { domain: { id: domain.id }, name: orderInfo.ownDriver }
         })
       }
 
       if (orderInfo?.ownTruck) {
         transportVehicle = await tx.getRepository(TransportVehicle).findOne({
-          where: { domain, name: orderInfo.ownTruck }
+          where: { domain: { id: domain.id }, name: orderInfo.ownTruck }
         })
 
         await tx.getRepository(TransportVehicle).save({
@@ -416,6 +533,7 @@ export class DeliveryOrderMutation {
         truckNo: orderInfo?.otherTruck || orderInfo?.ownTruck,
         to: foundCP.address,
         deliveryDate: orderInfo.deliveryDate,
+        deliveryDateTime: new Date(),
         remark: orderInfo.remark,
         status: deliveryOrderStatus,
         reusablePallet: orderInfo.reusablePallet,
@@ -431,14 +549,14 @@ export class DeliveryOrderMutation {
   @Directive('@transaction')
   @Mutation(returns => DeliveryOrder)
   async sendDeliveryOrder(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('orderInfo', type => DeliveryOrderPatch, { nullable: true }) orderInfo?: DeliveryOrderPatch,
     @Arg('orderItems', type => [OrderInventoryPatch], { nullable: true }) orderItems?: OrderInventoryPatch[]
   ): Promise<DeliveryOrder> {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
       const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain, name: orderInfo.name },
+        where: { domain: { id: domain.id }, name: orderInfo.name },
         relations: ['transportVehicle', 'bizplace']
       })
 
@@ -449,7 +567,7 @@ export class DeliveryOrderMutation {
       let deliveryOrderStatus = foundDeliveryOrder.status
       let orderInventories: OrderInventory[]
       orderInventories = await tx.getRepository(OrderInventory).find({
-        where: { domain, deliveryOrder: foundDeliveryOrder },
+        where: { domain: { id: domain.id }, deliveryOrder: { id: foundDeliveryOrder.id } },
         relations: ['inventory', 'inventory.product', 'inventory.reusablePallet']
       })
 
@@ -477,13 +595,13 @@ export class DeliveryOrderMutation {
       let transportVehicle: TransportVehicle = null
       if (orderInfo?.ownDriver) {
         transportDriver = await tx.getRepository(TransportDriver).findOne({
-          where: { domain, name: orderInfo.ownDriver }
+          where: { domain: { id: domain.id }, name: orderInfo.ownDriver }
         })
       }
 
       if (orderInfo?.ownTruck) {
         transportVehicle = await tx.getRepository(TransportVehicle).findOne({
-          where: { domain, name: orderInfo.ownTruck }
+          where: { domain: { id: domain.id }, name: orderInfo.ownTruck }
         })
 
         await tx.getRepository(TransportVehicle).save({
@@ -524,13 +642,13 @@ export class DeliveryOrderMutation {
   async rejectDeliveryOrder(
     @Arg('name') name: string,
     @Arg('patch', type => DeliveryOrderPatch) patch: DeliveryOrderPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<DeliveryOrder> {
     try {
-      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+      const { tx, domain, user } = context.state
 
       const deliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain, name }
+        where: { domain: { id: domain.id }, name }
       })
 
       if (!deliveryOrder) throw new Error(`Delivery order doesn't exists.`)
@@ -551,21 +669,21 @@ export class DeliveryOrderMutation {
   @Directive('@transaction')
   @Mutation(returns => DeliveryOrder)
   async submitGoodsDeliveryNote(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('name') name: string,
     @Arg('file', type => GraphQLUpload, { nullable: true }) file?: FileUpload
   ): Promise<DeliveryOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const foundDO: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['bizplace']
     })
 
     if (!foundDO) throw new Error(`DO doesn't exists.`)
 
     const foundAttachment: Attachment = await tx.getRepository(Attachment).findOne({
-      where: { domain, refBy: foundDO.id }
+      where: { domain: { id: domain.id }, refBy: foundDO.id }
     })
 
     const attachment = {
@@ -623,7 +741,7 @@ export async function createDeliveryOrder(
   // #1 find order number setting and set as DO name
   const doNoSetting: Setting = await settingRepo.findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       name: ORDER_NUMBER_SETTING_KEY.DO_NUMBER_RULE
     }
   })
@@ -643,14 +761,14 @@ export async function createDeliveryOrder(
   if (!orderInfo.ownCollection) {
     transportVehicle = await transportVehicleRepo.findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         id: orderInfo.transportVehicle
       }
     })
 
     transportDriver = await transportDriverRepo.findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         id: orderInfo.transportDriver
       }
     })
@@ -683,7 +801,7 @@ export async function createDeliveryOrder(
     foundCP = await tx.getRepository(ContactPoint).save(foundCP)
   } else {
     foundCP = await tx.getRepository(ContactPoint).findOne({
-      where: { domain, id: orderInfo.contactPointRefId, bizplace: foundBizplace }
+      where: { domain: { id: domain.id }, id: orderInfo.contactPointRefId, bizplace: foundBizplace }
     })
   }
 
@@ -776,20 +894,20 @@ export async function generateDeliveryOrder(
   let transportVehicle: TransportVehicle = null
   if (orderInfo?.truckNo) {
     transportVehicle = await transportVehicleRepo.findOne({
-      where: { domain, name: orderInfo.truckNo }
+      where: { domain: { id: domain.id }, name: orderInfo.truckNo }
     })
   }
 
   let transportDriver: TransportDriver = null
   if (orderInfo?.transportDriver) {
     transportDriver = await transportDriverRepo.findOne({
-      where: { domain, id: orderInfo.transportDriver.id }
+      where: { domain: { id: domain.id }, id: orderInfo.transportDriver.id }
     })
   }
 
   const doNoSetting: Setting = await settingRepo.findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       name: ORDER_NUMBER_SETTING_KEY.DO_NUMBER_RULE
     }
   })
@@ -802,6 +920,8 @@ export async function generateDeliveryOrder(
     orderNo = OrderNoGenerator.deliveryOrder()
   }
 
+  // insert shipping information from r/o to d/o
+
   let deliveryOrder: any = {
     domain,
     name: orderNo,
@@ -815,6 +935,19 @@ export async function generateDeliveryOrder(
     transportDriver,
     status: ORDER_STATUS.READY_TO_DISPATCH,
     contactPointRefId: orderInfo?.contactPointRefId || 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,
+    deliveryAddress1: releaseGood?.deliveryAddress1 || null,
+    billingAddress: releaseGood?.billingAddress || null,
+    billingCountry: releaseGood?.billingCountry || null,
+    billingPostalCode: releaseGood?.billingPostalCode || null,
+    billingState: releaseGood?.billingState || null,
+    billingCity: releaseGood?.billingCity || null,
     creator: user,
     updater: user
   }