@things-factory/sales-base 4.0.0-alpha.7 → 4.0.0-beta.1

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

@@ -0,0 +1,734 @@
+import { FileUpload, GraphQLUpload } from 'graphql-upload'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, getRepository, In, Repository } from 'typeorm'
+
+import { Attachment, createAttachment, deleteAttachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint, getPermittedBizplaceIds } 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, ObjectRef } from '@things-factory/shell'
+import { TransportDriver, TransportVehicle, TRUCK_STATUS } from '@things-factory/transport-base'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import {
+  DeliveryOrderPatch,
+  NewDeliveryOrder,
+  NewOrderInventory,
+  OrderInventory,
+  OrderInventoryPatch,
+  ReleaseGood
+} from '../'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_NUMBER_RULE_TYPE,
+  ORDER_NUMBER_SETTING_KEY,
+  ORDER_STATUS,
+  ORDER_TYPES
+} from '../../constants'
+import { OrderNoGenerator } from '../../utils/order-no-generator'
+import { DeliveryOrder } from './delivery-order'
+
+@Resolver(DeliveryOrder)
+export class DeliveryOrderMutation {
+  @Directive('@transaction')
+  @Mutation(returns => DeliveryOrder)
+  async createDeliveryOrder(
+    @Ctx() context: any,
+    @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
+
+    return await createDeliveryOrder(orderInfo, customerBizplace, targetInventories, file, domain, user, tx)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => DeliveryOrder)
+  async updateDeliveryOrder(
+    @Arg('name') name: string,
+    @Arg('patch', type => DeliveryOrderPatch) patch: DeliveryOrderPatch,
+    @Ctx() context: any
+  ): Promise<DeliveryOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const deliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
+      where: {
+        domain,
+        name,
+        bizplace: In(await getPermittedBizplaceIds(domain, user))
+      }
+    })
+
+    return await tx.getRepository(DeliveryOrder).save({
+      ...deliveryOrder,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @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
+
+    const foundDO = await tx.getRepository(DeliveryOrder).findOne({
+      where: { domain, name }
+    })
+    if (foundDO) {
+      const previousAttachment: Attachment = await tx.getRepository(Attachment).findOne({
+        where: { domain, refBy: foundDO.id }
+      })
+      if (previousAttachment) await deleteAttachment(null, { id: previousAttachment.id }, context)
+      await tx.getRepository(DeliveryOrder).delete({ domain, name })
+    }
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => DeliveryOrder)
+  async generateDeliveryOrder(
+    @Ctx() context: any,
+    @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
+
+    return await generateDeliveryOrder(orderInfo, targetInventories, customerBizplace, releaseGood, 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
+
+    const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
+      where: { domain, name },
+      relations: ['creator', 'updater']
+    })
+
+    let deliveryOrder: DeliveryOrder
+    if (!foundDeliveryOrder) throw new Error(`Delivery Order doesn't exists.`)
+    if (foundDeliveryOrder.status !== ORDER_STATUS.PENDING) throw new Error('Not confirmable status.')
+
+    // delivery Order Status change (PENDING => PENDING_RECEIVE)
+    deliveryOrder = await tx.getRepository(DeliveryOrder).save({
+      ...foundDeliveryOrder,
+      status: ORDER_STATUS.PENDING_RECEIVE,
+      updater: user
+    })
+
+    return deliveryOrder
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => DeliveryOrder)
+  async receiveDeliveryOrder(@Arg('name') name: string, @Ctx() context: any): Promise<DeliveryOrder> {
+    try {
+      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+      const deliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
+        where: { domain, name }
+      })
+
+      if (!deliveryOrder) throw new Error(`Delivery order doesn't exists.`)
+      if (deliveryOrder.status !== ORDER_STATUS.PENDING_RECEIVE) throw new Error(`Status is not receivable.`)
+
+      await tx.getRepository(DeliveryOrder).save({
+        ...deliveryOrder,
+        status: ORDER_STATUS.READY_TO_DISPATCH,
+        updater: user
+      })
+
+      return deliveryOrder
+    } catch (e) {
+      throw e
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => DeliveryOrder)
+  async checkDeliveredOrder(
+    @Ctx() context: any,
+    @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 deliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
+        where: { domain, name },
+        relations: ['bizplace', 'transportDriver', 'transportVehicle']
+      })
+
+      if (!deliveryOrder) throw new Error(`Delivery order doesn't exists.`)
+      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 },
+        relations: ['product']
+      })
+
+      // update order inventory status for manual DO only
+      orderInventories = orderInventories.map((orderInventory: OrderInventory) => {
+        if (
+          orderInventory.type === ORDER_TYPES.DELIVERY &&
+          orderInventory.status === ORDER_INVENTORY_STATUS.DELIVERING
+        ) {
+          return {
+            ...orderInventory,
+            status: ORDER_INVENTORY_STATUS.DONE
+          }
+        } else return orderInventory
+      })
+      await tx.getRepository(OrderInventory).save(orderInventories)
+
+      await tx.getRepository(DeliveryOrder).save({
+        ...deliveryOrder,
+        ...patch,
+        status: ORDER_STATUS.DONE,
+        updater: user
+      })
+
+      if (!deliveryOrder?.ownCollection) {
+        const foundTruck: TransportVehicle = deliveryOrder.transportVehicle
+        await tx.getRepository(TransportVehicle).save({
+          ...foundTruck,
+          status: TRUCK_STATUS.IDLE,
+          updater: user
+        })
+      }
+
+      return deliveryOrder
+    } catch (e) {
+      throw e
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => DeliveryOrder)
+  async dispatchDeliveryOrder(
+    @Ctx() context: any,
+    @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 foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
+        where: { domain, name: orderInfo.name },
+        relations: ['transportVehicle', 'bizplace']
+      })
+
+      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')
+
+      let deliveryOrderStatus = foundDeliveryOrder.status
+      let orderInventories: OrderInventory[]
+      orderInventories = await tx.getRepository(OrderInventory).find({
+        where: { domain, deliveryOrder: foundDeliveryOrder },
+        relations: ['inventory', 'inventory.product', 'inventory.reusablePallet']
+      })
+
+      orderInventories = orderInventories.map((orderInventory: OrderInventory) => {
+        const inventory: Inventory = orderInventory.inventory
+        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
+            )
+          : orderItems.filter(
+              (item: any) =>
+                item.productName === `${product.name} (${product.description})` &&
+                item.batchId === orderInventory.batchId
+            )
+
+        if (foundItem[0].remark !== '') orderInventory.remark = foundItem[0].remark
+        return orderInventory
+      })
+      await tx.getRepository(OrderInventory).save(orderInventories)
+
+      // if there is other destination value, create a new contact point
+      let foundCP: any = {}
+      if (orderInfo?.otherDestination) {
+        foundCP = {
+          domain,
+          name: orderInfo.contactName,
+          bizplace: foundDeliveryOrder.bizplace,
+          address: orderInfo.otherDestination,
+          billingAddress: orderInfo.billingAddress,
+          phone: orderInfo.contactPhone,
+          email: orderInfo.contactEmail,
+          companyName: orderInfo.contactCompany,
+          type: orderInfo.contactType,
+          creator: user
+        }
+        foundCP = await tx.getRepository(ContactPoint).save(foundCP)
+      } else {
+        foundCP = await tx.getRepository(ContactPoint).findOne({
+          where: { domain, id: orderInfo.contactPoint, bizplace: foundDeliveryOrder.bizplace }
+        })
+      }
+
+      let transportDriver: TransportDriver = null
+      let transportVehicle: TransportVehicle = null
+      if (orderInfo?.ownDriver) {
+        transportDriver = await tx.getRepository(TransportDriver).findOne({
+          where: { domain, name: orderInfo.ownDriver }
+        })
+      }
+
+      if (orderInfo?.ownTruck) {
+        transportVehicle = await tx.getRepository(TransportVehicle).findOne({
+          where: { domain, name: orderInfo.ownTruck }
+        })
+
+        await tx.getRepository(TransportVehicle).save({
+          ...transportVehicle,
+          status: TRUCK_STATUS.IN_USE,
+          updater: user
+        })
+      }
+
+      if (foundDeliveryOrder.status === ORDER_STATUS.READY_TO_DISPATCH) {
+        // update status to DELIVERING if current status is READY_TO_DISPATCH
+        deliveryOrderStatus = ORDER_STATUS.DELIVERING
+      }
+
+      await tx.getRepository(DeliveryOrder).save({
+        ...foundDeliveryOrder,
+        transportDriver,
+        transportVehicle,
+        contactPointRefId: foundCP.id || null,
+        otherDriver: orderInfo?.otherDriver || null,
+        truckNo: orderInfo?.otherTruck || orderInfo?.ownTruck,
+        to: foundCP.address,
+        deliveryDate: orderInfo.deliveryDate,
+        remark: orderInfo.remark,
+        status: deliveryOrderStatus,
+        reusablePallet: orderInfo.reusablePallet,
+        updater: user
+      })
+
+      return foundDeliveryOrder
+    } catch (e) {
+      throw e
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => DeliveryOrder)
+  async dispatchManualDeliveryOrder(
+    @Ctx() context: any,
+    @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 foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
+        where: { domain, name: orderInfo.name },
+        relations: ['transportVehicle', 'bizplace']
+      })
+
+      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')
+
+      let deliveryOrderStatus = foundDeliveryOrder.status
+      let orderInventories: OrderInventory[]
+      orderInventories = await tx.getRepository(OrderInventory).find({
+        where: { domain, deliveryOrder: foundDeliveryOrder },
+        relations: ['product']
+      })
+
+      // if there is other destination value, create a new contact point
+      let foundCP: any = {}
+      if (orderInfo?.otherDestination) {
+        foundCP = {
+          domain,
+          name: orderInfo.contactName,
+          bizplace: foundDeliveryOrder.bizplace,
+          address: orderInfo.otherDestination,
+          billingAddress: orderInfo.billingAddress,
+          phone: orderInfo.contactPhone,
+          email: orderInfo.contactEmail,
+          companyName: orderInfo.contactCompany,
+          type: orderInfo.contactType,
+          creator: user
+        }
+        foundCP = await tx.getRepository(ContactPoint).save(foundCP)
+      } else {
+        foundCP = await tx.getRepository(ContactPoint).findOne({
+          where: { domain, id: orderInfo.contactPoint }
+        })
+      }
+
+      let transportDriver: TransportDriver = null
+      let transportVehicle: TransportVehicle = null
+      if (orderInfo?.ownDriver) {
+        transportDriver = await tx.getRepository(TransportDriver).findOne({
+          where: { domain, name: orderInfo.ownDriver }
+        })
+      }
+
+      if (orderInfo?.ownTruck) {
+        transportVehicle = await tx.getRepository(TransportVehicle).findOne({
+          where: { domain, name: orderInfo.ownTruck }
+        })
+
+        await tx.getRepository(TransportVehicle).save({
+          ...transportVehicle,
+          status: TRUCK_STATUS.IN_USE,
+          updater: user
+        })
+      }
+
+      orderInventories = orderInventories.map((orderInventory: OrderInventory) => {
+        const remark = orderItems.find(
+          (item: any) => item.productId === orderInventory.product.id && item.batchId === orderInventory.batchId
+        ).remark
+
+        // add remark if found, else remain existing remark
+        if (remark) {
+          orderInventory.remark = remark
+        }
+
+        // update status of DO and order inventory to DELIVERING if current status is READY_TO_DISPATCH
+        if (foundDeliveryOrder.status === ORDER_STATUS.READY_TO_DISPATCH) {
+          deliveryOrderStatus = ORDER_STATUS.DELIVERING
+          orderInventory.status = ORDER_STATUS.DELIVERING
+        }
+
+        return orderInventory
+      })
+      await tx.getRepository(OrderInventory).save(orderInventories)
+
+      await tx.getRepository(DeliveryOrder).save({
+        ...foundDeliveryOrder,
+        transportDriver,
+        transportVehicle,
+        contactPointRefId: foundCP.id || null,
+        otherDriver: orderInfo?.otherDriver || null,
+        truckNo: orderInfo?.otherTruck || orderInfo?.ownTruck,
+        to: foundCP.address,
+        deliveryDate: orderInfo.deliveryDate,
+        remark: orderInfo.remark,
+        status: deliveryOrderStatus,
+        reusablePallet: orderInfo.reusablePallet,
+        updater: user
+      })
+
+      return foundDeliveryOrder
+    } catch (e) {
+      throw e
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => DeliveryOrder)
+  async rejectDeliveryOrder(
+    @Arg('name') name: string,
+    @Arg('patch', type => DeliveryOrderPatch) patch: DeliveryOrderPatch,
+    @Ctx() context: any
+  ): Promise<DeliveryOrder> {
+    try {
+      const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+      const deliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
+        where: { domain, name }
+      })
+
+      if (!deliveryOrder) throw new Error(`Delivery order doesn't exists.`)
+      if (deliveryOrder.status !== ORDER_STATUS.PENDING_RECEIVE) throw new Error(`Status is not receivable.`)
+
+      await tx.getRepository(DeliveryOrder).save({
+        ...deliveryOrder,
+        status: ORDER_STATUS.READY_TO_DISPATCH,
+        updater: user
+      })
+
+      return deliveryOrder
+    } catch (e) {
+      throw e
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => DeliveryOrder)
+  async submitGoodsDeliveryNote(
+    @Ctx() context: any,
+    @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 foundDO: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
+      where: { domain, 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 }
+    })
+
+    const attachment = {
+      refBy: foundDO.id,
+      file: file,
+      category: 'DO'
+    }
+
+    if (!foundAttachment) {
+      await createAttachment(null, { attachment }, context)
+    } else {
+      const id = foundAttachment.id
+      await deleteAttachment(null, { id }, context)
+      await createAttachment(null, { attachment }, context)
+    }
+
+    return await tx.getRepository(DeliveryOrder).save({
+      ...foundDO,
+      status: ORDER_STATUS.DONE,
+      updater: user
+    })
+  }
+}
+
+export async function createDeliveryOrder(
+  orderInfo: any,
+  customerBizplace: Bizplace,
+  targetInventories: (OrderInventory | NewOrderInventory)[],
+  file: FileUpload[],
+  domain: Domain,
+  user: User,
+  tx?: EntityManager
+): Promise<DeliveryOrder> {
+  const bizplaceRepo: Repository<Bizplace> = tx?.getRepository(Bizplace) || getRepository(Bizplace)
+  const deliveryOrderRepo: Repository<DeliveryOrder> = tx?.getRepository(DeliveryOrder) || getRepository(DeliveryOrder)
+  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
+  const transportVehicleRepo: Repository<TransportVehicle> =
+    tx?.getRepository(TransportVehicle) || getRepository(TransportVehicle)
+  const transportDriverRepo: Repository<TransportDriver> =
+    tx?.getRepository(TransportDriver) || getRepository(TransportDriver)
+  const orderInventoryRepo: Repository<OrderInventory> =
+    tx?.getRepository(OrderInventory) || getRepository(OrderInventory)
+  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+
+  const foundBizplace: Bizplace = await bizplaceRepo.findOne({
+    where: {
+      id: customerBizplace.id,
+      name: customerBizplace.name
+    }
+  })
+
+  if (!foundBizplace) throw new Error(`customer not found`)
+
+  // #1 find order number setting and set as DO name
+  const doNoSetting: Setting = await settingRepo.findOne({
+    where: {
+      domain,
+      name: ORDER_NUMBER_SETTING_KEY.DO_NUMBER_RULE
+    }
+  })
+
+  let orderNo: string = ''
+
+  if (doNoSetting) {
+    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.DO_NUMBER, seed: {} })
+  } else {
+    orderNo = OrderNoGenerator.deliveryOrder()
+  }
+
+  // #2 update truck vehicle status to IN_USE (only if using warehouse truck)
+  let transportVehicle: TransportVehicle = null
+  let transportDriver: TransportDriver = null
+
+  if (!orderInfo.ownCollection) {
+    transportVehicle = await transportVehicleRepo.findOne({
+      where: {
+        domain,
+        id: orderInfo.transportVehicle
+      }
+    })
+
+    transportDriver = await transportDriverRepo.findOne({
+      where: {
+        domain,
+        id: orderInfo.transportDriver
+      }
+    })
+
+    transportVehicle = {
+      ...transportVehicle,
+      status: TRUCK_STATUS.IN_USE,
+      updater: user
+    }
+
+    await transportVehicleRepo.save(transportVehicle)
+  }
+
+  // #3 save other destination info in Contact Point if there's any
+  let foundCP: ContactPoint = {}
+  if (orderInfo?.otherDestination) {
+    foundCP = {
+      domain,
+      name: orderInfo.contactName,
+      bizplace: foundBizplace,
+      address: orderInfo.otherDestination,
+      billingAddress: orderInfo.otherBillingAddress ? orderInfo.otherBillingAddress : orderInfo.otherDestination,
+      phone: orderInfo.contactPhone || '-',
+      email: orderInfo.contactEmail || '-',
+      companyName: orderInfo.contactCompany || '-',
+      type: orderInfo.contactType,
+      creator: user,
+      updater: user
+    }
+    foundCP = await tx.getRepository(ContactPoint).save(foundCP)
+  } else {
+    foundCP = await tx.getRepository(ContactPoint).findOne({
+      where: { domain, id: orderInfo.contactPointRefId, bizplace: foundBizplace }
+    })
+  }
+
+  // #4 save the delivery order info
+  let totalPalletQty = 0
+  targetInventories.forEach(oi => (totalPalletQty += oi.palletQty))
+
+  let deliveryOrder: any = {
+    domain,
+    name: orderNo,
+    refNo: orderInfo.refNo,
+    bizplace: foundBizplace,
+    deliveryDate: orderInfo.deliveryDate,
+    ownCollection: orderInfo.ownCollection,
+    truckNo: orderInfo.truckNo,
+    palletQty: totalPalletQty,
+    status: ORDER_STATUS.READY_TO_DISPATCH,
+    contactPointRefId: foundCP.id,
+    remark: orderInfo.remark,
+    transportDriver,
+    transportVehicle,
+    otherDriver: orderInfo.otherDriver,
+    creator: user,
+    updater: user
+  }
+  deliveryOrder = <DeliveryOrder>await deliveryOrderRepo.save(deliveryOrder)
+
+  // #5 save order inventories
+  targetInventories = await Promise.all(
+    targetInventories.map(async (orderInventory: OrderInventory) => {
+      const product: Product = await productRepo.findOne({
+        where: {
+          id: orderInventory.product.id
+        }
+      })
+
+      if (!product) throw new Error(`product not found`)
+      return {
+        ...orderInventory,
+        domain,
+        product,
+        name: OrderNoGenerator.orderInventory(),
+        bizplace: foundBizplace,
+        status: ORDER_INVENTORY_STATUS.READY_TO_DISPATCH,
+        type: ORDER_TYPES.DELIVERY,
+        deliveryOrder,
+        creator: user,
+        updater: user
+      }
+    })
+  )
+  await orderInventoryRepo.save(targetInventories)
+
+  // if (file?.length) {
+  //   const attachments: Attachment[] = file.map(attachment => {
+  //     return {
+  //       file: attachment,
+  //       refBy: deliveryOrder.id,
+  //       category: ATTACHMENT_TYPE.GAN
+  //     }
+  //   })
+  //   await createAttachments(_, { attachments }, context)
+  // }
+
+  return deliveryOrder
+}
+
+export async function generateDeliveryOrder(
+  orderInfo: DeliveryOrder | DeliveryOrderPatch,
+  targetInventories: OrderInventory[],
+  customerBizplace: Bizplace,
+  releaseGood: ReleaseGood,
+  domain: Domain,
+  user: User,
+  tx?: EntityManager
+): Promise<DeliveryOrder> {
+  /**
+   * 1. Validation for creating DO - data existing
+   */
+  const deliveryOrderRepo: Repository<DeliveryOrder> = tx?.getRepository(DeliveryOrder) || getRepository(DeliveryOrder)
+  const transportVehicleRepo: Repository<TransportVehicle> =
+    tx?.getRepository(TransportVehicle) || getRepository(TransportVehicle)
+  const orderInventoryRepo: Repository<OrderInventory> =
+    tx?.getRepository(OrderInventory) || getRepository(OrderInventory)
+  const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+
+  let transportVehicle: TransportVehicle = null
+  if (orderInfo?.truckNo) {
+    transportVehicle = await transportVehicleRepo.findOne({
+      where: { domain, name: orderInfo.truckNo }
+    })
+  }
+
+  const doNoSetting: Setting = await settingRepo.findOne({
+    where: {
+      domain,
+      name: ORDER_NUMBER_SETTING_KEY.DO_NUMBER_RULE
+    }
+  })
+
+  let orderNo: string = ''
+
+  if (doNoSetting) {
+    orderNo = await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.DO_NUMBER, seed: {} })
+  } else {
+    orderNo = OrderNoGenerator.deliveryOrder()
+  }
+
+  let deliveryOrder: any = {
+    domain,
+    name: orderNo,
+    bizplace: customerBizplace,
+    releaseGood,
+    refNo: releaseGood.refNo,
+    ownCollection: orderInfo.ownCollection,
+    truckNo: orderInfo?.truckNo || null,
+    palletQty: orderInfo?.palletQty || null,
+    transportVehicle,
+    status: ORDER_STATUS.READY_TO_DISPATCH,
+    contactPointRefId: orderInfo?.contactPointRefId || null,
+    creator: user,
+    updater: user
+  }
+
+  deliveryOrder = <DeliveryOrder>await deliveryOrderRepo.save(deliveryOrder)
+
+  targetInventories = targetInventories.map((targetInventory: OrderInventory) => {
+    return {
+      ...targetInventory,
+      deliveryOrder,
+      updater: user
+    }
+  })
+  await orderInventoryRepo.save(targetInventories)
+
+  return deliveryOrder
+}