@things-factory/sales-base 8.0.2 → 8.0.5

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

@@ -1,967 +0,0 @@
-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, 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, getRepository, ObjectRef } from '@things-factory/shell'
-import { TransportDriver, TransportVehicle, TRUCK_STATUS } from '@things-factory/transport-base'
-import { Inventory } from '@things-factory/warehouse-base'
-
-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 { 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'
-
-@Resolver(DeliveryOrder)
-export class DeliveryOrderMutation {
-  @Directive('@transaction')
-  @Mutation(returns => DeliveryOrder)
-  async createDeliveryOrder(
-    @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 } = context.state
-
-    return await createDeliveryOrder(orderInfo, customerBizplace as any, targetInventories, file, domain, user, tx)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DeliveryOrder)
-  async updateDeliveryOrder(
-    @Arg('name') name: string,
-    @Arg('patch', type => DeliveryOrderPatch) patch: DeliveryOrderPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<DeliveryOrder> {
-    const { tx, domain, user } = context.state
-
-    const deliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-      where: {
-        domain: { id: domain.id },
-        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: ResolverContext): Promise<boolean> {
-    const { tx, domain } = context.state
-
-    const foundDO = await tx.getRepository(DeliveryOrder).findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-    if (foundDO) {
-      const previousAttachment: Attachment = await tx.getRepository(Attachment).findOne({
-        where: { domain: { id: domain.id }, refBy: foundDO.id }
-      })
-      if (previousAttachment) await deleteAttachment(null, { id: previousAttachment.id }, context)
-      await tx.getRepository(DeliveryOrder).delete({ domain: { id: domain.id }, name })
-    }
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DeliveryOrder)
-  async generateDeliveryOrder(
-    @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 } = context.state
-
-    return await generateDeliveryOrder(
-      orderInfo,
-      targetInventories as any,
-      customerBizplace as any,
-      releaseGood as any,
-      domain,
-      user,
-      tx
-    )
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DeliveryOrder)
-  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: { id: domain.id }, 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: ResolverContext): Promise<DeliveryOrder> {
-    try {
-      const { tx, domain, user } = context.state
-
-      const deliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain: { id: domain.id }, 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: ResolverContext,
-    @Arg('name') name: string,
-    @Arg('patch', type => DeliveryOrderPatch, { nullable: true }) patch?: DeliveryOrderPatch
-  ): Promise<DeliveryOrder> {
-    try {
-      const { tx, domain, user } = context.state
-      const deliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain: { id: domain.id }, 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: { id: domain.id }, deliveryOrder: { id: deliveryOrder.id } },
-        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.AVAILABLE,
-          updater: user
-        })
-      }
-
-      return deliveryOrder
-    } catch (e) {
-      throw e
-    }
-  }
-
-  /**
-   * 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: ResolverContext,
-    @Arg('orderInfo', type => DeliveryOrderPatch, { nullable: true }) orderInfo?: DeliveryOrderPatch,
-    @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 } = context.state
-      const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain: { id: domain.id }, name: orderInfo.name },
-        relations: ['transportVehicle', 'bizplace']
-      })
-
-      const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-        where: {
-          name: orderInfo.releaseGoodNo,
-          domain: { id: domain.id }
-        },
-        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: { id: domain.id }, deliveryOrder: { id: foundDeliveryOrder.id } },
-        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: domain.id }, 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: { id: domain.id }, name: orderInfo.ownDriver }
-        })
-      }
-
-      if (orderInfo?.ownTruck) {
-        transportVehicle = await tx.getRepository(TransportVehicle).findOne({
-          where: { domain: { id: domain.id }, 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
-      }
-
-      // 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,
-        otherDriver: orderInfo?.otherDriver || null,
-        truckNo: orderInfo?.otherTruck || orderInfo?.ownTruck,
-        to: foundCP?.address,
-        deliveryDate: orderInfo?.deliveryDate,
-        deliveryDateTime: new Date(),
-        remark: orderInfo?.remark,
-        status: deliveryOrderStatus,
-        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
-      })
-
-      return foundDeliveryOrder
-    } catch (e) {
-      throw e
-    }
-  }
-  /** */
-
-  @Directive('@transaction')
-  @Mutation(returns => DeliveryOrder)
-  async dispatchManualDeliveryOrder(
-    @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 } = context.state
-      const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain: { id: domain.id }, 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: { id: domain.id }, deliveryOrder: { id: foundDeliveryOrder.id } },
-        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: domain.id }, id: orderInfo.contactPoint }
-        })
-      }
-
-      let transportDriver: TransportDriver = null
-      let transportVehicle: TransportVehicle = null
-      if (orderInfo?.ownDriver) {
-        transportDriver = await tx.getRepository(TransportDriver).findOne({
-          where: { domain: { id: domain.id }, name: orderInfo.ownDriver }
-        })
-      }
-
-      if (orderInfo?.ownTruck) {
-        transportVehicle = await tx.getRepository(TransportVehicle).findOne({
-          where: { domain: { id: domain.id }, 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,
-        deliveryDateTime: new Date(),
-        remark: orderInfo.remark,
-        status: deliveryOrderStatus,
-        reusablePallet: orderInfo.reusablePallet,
-        updater: user
-      })
-
-      return foundDeliveryOrder
-    } catch (e) {
-      throw e
-    }
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DeliveryOrder)
-  async sendDeliveryOrder(
-    @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 } = context.state
-      const foundDeliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain: { id: domain.id }, 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: { id: domain.id }, deliveryOrder: { id: foundDeliveryOrder.id } },
-        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)
-
-      let transportDriver: TransportDriver = null
-      let transportVehicle: TransportVehicle = null
-      if (orderInfo?.ownDriver) {
-        transportDriver = await tx.getRepository(TransportDriver).findOne({
-          where: { domain: { id: domain.id }, name: orderInfo.ownDriver }
-        })
-      }
-
-      if (orderInfo?.ownTruck) {
-        transportVehicle = await tx.getRepository(TransportVehicle).findOne({
-          where: { domain: { id: domain.id }, 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,
-        otherDriver: orderInfo?.otherDriver || null,
-        truckNo: orderInfo?.otherTruck || orderInfo?.ownTruck,
-        to: foundDeliveryOrder.bizplace.address,
-        deliveryDate: orderInfo.deliveryDate,
-        remark: orderInfo.remark,
-        status: deliveryOrderStatus,
-        reusablePallet: orderInfo.reusablePallet,
-        updater: user
-      })
-
-      return foundDeliveryOrder
-    } catch (e) {
-      throw e
-    }
-    return
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => DeliveryOrder)
-  async rejectDeliveryOrder(
-    @Arg('name') name: string,
-    @Arg('patch', type => DeliveryOrderPatch) patch: DeliveryOrderPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<DeliveryOrder> {
-    try {
-      const { tx, domain, user } = context.state
-
-      const deliveryOrder: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-        where: { domain: { id: domain.id }, 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: ResolverContext,
-    @Arg('name') name: string,
-    @Arg('file', type => GraphQLUpload, { nullable: true }) file?: FileUpload
-  ): Promise<DeliveryOrder> {
-    const { tx, domain, user } = context.state
-
-    const foundDO: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
-      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: { id: domain.id }, refBy: foundDO.id }
-    })
-
-    const attachment = {
-      refType: 'DO',
-      refBy: foundDO.id,
-      file: file,
-      category: 'DO' /* TODO use refType */
-    }
-
-    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: { id: domain.id },
-      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: domain.id },
-        id: orderInfo.transportVehicle
-      }
-    })
-
-    transportDriver = await transportDriverRepo.findOne({
-      where: {
-        domain: { id: domain.id },
-        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 = {} as any
-  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
-    } as any
-    foundCP = await tx.getRepository(ContactPoint).save(foundCP)
-  } else {
-    foundCP = await tx.getRepository(ContactPoint).findOne({
-      where: { domain: { id: domain.id }, 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 as any)
-
-  // if (file?.length) {
-  //   const attachments: Attachment[] = file.map(attachment => {
-  //     return {
-  //       file: attachment,
-  //       refType: ATTACHMENT_TYPE.GAN,
-  //       refBy: deliveryOrder.id,
-  //       category: ATTACHMENT_TYPE.GAN /* TODO use refType */
-  //     }
-  //   })
-  //   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 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)
-
-  let transportVehicle: TransportVehicle = null
-  if (orderInfo?.truckNo) {
-    transportVehicle = await transportVehicleRepo.findOne({
-      where: { domain: { id: domain.id }, name: orderInfo.truckNo }
-    })
-  }
-
-  let transportDriver: TransportDriver = null
-  if (orderInfo?.transportDriver) {
-    transportDriver = await transportDriverRepo.findOne({
-      where: { domain: { id: domain.id }, id: orderInfo.transportDriver.id }
-    })
-  }
-
-  const doNoSetting: Setting = await settingRepo.findOne({
-    where: {
-      domain: { id: domain.id },
-      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()
-  }
-
-  // insert shipping information from r/o to d/o
-
-  let deliveryOrder: any = {
-    domain,
-    name: orderNo,
-    bizplace: customerBizplace,
-    releaseGood,
-    refNo: releaseGood.refNo,
-    ownCollection: orderInfo.ownCollection,
-    truckNo: orderInfo?.truckNo || null,
-    palletQty: orderInfo?.palletQty || null,
-    transportVehicle,
-    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
-  }
-
-  deliveryOrder = <DeliveryOrder>await deliveryOrderRepo.save(deliveryOrder)
-
-  targetInventories = targetInventories.map((targetInventory: OrderInventory) => {
-    return {
-      ...targetInventory,
-      deliveryOrder,
-      updater: user
-    }
-  })
-  await orderInventoryRepo.save(targetInventories)
-
-  return deliveryOrder
-}