@things-factory/worksheet-base 5.0.12 → 6.0.0-alpha.0

package/server/graphql/resolvers/worksheet/confirm-cancellation-release-order.ts

@@ -1,30 +1,24 @@
+import { In } from 'typeorm'
+
 import {
-  Inventory,
-  Location,
-  LOCATION_STATUS,
-  INVENTORY_STATUS,
-  INVENTORY_TRANSACTION_TYPE
-} from '@things-factory/warehouse-base'
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
-import {
+  DeliveryOrder,
   ORDER_INVENTORY_STATUS,
   ORDER_STATUS,
   ORDER_VAS_STATUS,
   OrderInventory,
-  DeliveryOrder,
   OrderVas,
   ReleaseGood
 } from '@things-factory/sales-base'
-import { generateInventoryHistory } from '../../../utils'
+import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location } from '@things-factory/warehouse-base'
+
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { generateInventoryHistory } from '../../../utils'
 
 export const confirmCancellationReleaseOrder = {
-  async confirmCancellationReleaseOrder(_: any, { name }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async confirmCancellationReleaseOrder(_: any, { name }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-      where: { domain, name, status: ORDER_STATUS.PENDING_CANCEL },
+      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_CANCEL },
       relations: [
         'bizplace',
         'orderInventories',
@@ -39,132 +33,95 @@ export const confirmCancellationReleaseOrder = {
     let foundOVs: OrderVas[] = releaseGood.orderVass
 
     // 1. Check Order Inventory status
-    // 1a. separate into two groups, group 1: pending cancel, group 2: picked
-    let cancelOI: OrderInventory[] = targetOIs.filter(
-      (oi: OrderInventory) => oi.status === ORDER_INVENTORY_STATUS.PENDING_CANCEL
-    ).reduce((acc, oi) => {
-      let existingRecordIdx = acc.findIndex(i => i.inventory.id == oi.inventory.id)
-      if (existingRecordIdx >= 0) {
-        acc[existingRecordIdx].releaseQty += oi.releaseQty
-        acc[existingRecordIdx].releaseUomValue += oi.releaseQty
-      } else {
-        acc.push(oi)
-      }
-      return acc
-    }, [])
-
-    let pickedOI: OrderInventory[] = targetOIs.filter(
-      (oi: OrderInventory) => oi.status === ORDER_INVENTORY_STATUS.PENDING_REVERSE
-    ).reduce((acc, oi) => {
-      let existingRecordIdx = acc.findIndex(i => i.inventory.id == oi.inventory.id)
-      if (existingRecordIdx >= 0) {
-        acc[existingRecordIdx].releaseQty += oi.releaseQty
-        acc[existingRecordIdx].releaseUomValue += oi.releaseQty
-      } else {
-        acc.push(oi)
-      }
-      return acc
-    }, [])
-
-    let replacedOI: OrderInventory[] = targetOIs.filter(
-      (oi: OrderInventory) => oi.status === ORDER_INVENTORY_STATUS.REPLACED
-    ).reduce((acc, oi) => {
-      let existingRecordIdx = acc.findIndex(i => i.inventory.id == oi.inventory.id)
-      if (existingRecordIdx >= 0) {
-        acc[existingRecordIdx].releaseQty += oi.releaseQty
-        acc[existingRecordIdx].releaseUomValue += oi.releaseQty
-      } else {
-        acc.push(oi)
-      }
-      return acc
-    }, [])
-
-    if (pickedOI && pickedOI?.length) {
-      await tx.getRepository(OrderInventory).save(
-        await Promise.all(
-          pickedOI.map(async (orderInventory: OrderInventory) => {
-            let inventory: Inventory = orderInventory.inventory
-            let location: Location = inventory.location
-
-            let cancelledTargetInventory: OrderInventory = Object.assign({}, orderInventory)
-            cancelledTargetInventory.status = ORDER_INVENTORY_STATUS.CANCELLED
-            cancelledTargetInventory.updater = user
-
-            if (inventory) {
-              inventory = await tx.getRepository(Inventory).findOne({ id: inventory.id })
-              inventory.qty += orderInventory.releaseQty
-              inventory.uomValue += orderInventory.releaseUomValue
-              inventory.status = INVENTORY_STATUS.STORED
-              inventory.updater = user
-              inventory = await tx.getRepository(Inventory).save(inventory)
-
-              await generateInventoryHistory(
-                inventory,
-                releaseGood,
-                INVENTORY_TRANSACTION_TYPE.CANCEL_ORDER,
-                orderInventory.releaseQty,
-                orderInventory.releaseUomValue,
-                user,
-                tx
-              )
-            }
-
-            // Update status of location
-            if (location.status === LOCATION_STATUS.EMPTY) {
-              location.status = LOCATION_STATUS.OCCUPIED
-              location.updater = user
-              await tx.getRepository(Location).save(location)
-            }
-
-            return cancelledTargetInventory
-          })
-        )
+    // 1a. separate into three groups, group 1: pending cancel, group 2: picked, group 3: replaced
+    let cancelOIs: OrderInventory[] = _filterOrderInventoriesByStatus(targetOIs, ORDER_INVENTORY_STATUS.PENDING_CANCEL)
+    let pickedOIs: OrderInventory[] = _filterOrderInventoriesByStatus(targetOIs, ORDER_INVENTORY_STATUS.PENDING_REVERSE)
+    let replacedOIs: OrderInventory[] = _filterOrderInventoriesByStatus(targetOIs, ORDER_INVENTORY_STATUS.REPLACED)
+
+    if (pickedOIs && pickedOIs.length) {
+      await Promise.all(
+        pickedOIs.map(async (orderInventory: OrderInventory) => {
+          let inventory: Inventory = orderInventory.inventory
+          let location: Location = inventory?.location
+
+          if (inventory && inventory.id) {
+            await tx
+              .createQueryBuilder()
+              .update(Inventory)
+              .set({
+                qty: () => `COALESCE("qty", 0) + ${orderInventory.releaseQty}`,
+                uomValue: () => `COALESCE("uom_value", 0) + ${orderInventory.releaseUomValue}`,
+                status: INVENTORY_STATUS.STORED,
+                updater: user
+              } as any)
+              .where('id = :id', { id: inventory.id })
+              .execute()
+
+            await generateInventoryHistory(
+              inventory,
+              releaseGood,
+              INVENTORY_TRANSACTION_TYPE.CANCEL_ORDER,
+              orderInventory.releaseQty,
+              orderInventory.releaseUomValue,
+              user,
+              tx
+            )
+          }
+
+          return orderInventory
+        })
       )
+
+      await tx
+        .getRepository(OrderInventory)
+        .update(pickedOIs, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: user } as any)
     }
 
-    // change status to cancelled for order inventory that has not executed yet
-    if (cancelOI && cancelOI?.length) {
-      await tx.getRepository(OrderInventory).save(
-        await Promise.all(
-          cancelOI.map(async (orderInventory: OrderInventory) => {
-            let inventory: Inventory = orderInventory.inventory
-
-            if (inventory) {
-              inventory = await tx.getRepository(Inventory).findOne({ id: inventory.id })
-              inventory.lockedQty -= orderInventory.releaseQty
-              inventory.lockedUomValue -= orderInventory.releaseUomValue
-              await tx.getRepository(Inventory).save(inventory)
-
-              await generateInventoryHistory(
-                inventory,
-                releaseGood,
-                INVENTORY_TRANSACTION_TYPE.CANCEL_ORDER,
-                0,
-                0,
-                user,
-                tx
-              )
-            }
-
-            let cancelledTargetInventory: OrderInventory = Object.assign({}, orderInventory)
-            cancelledTargetInventory.status = ORDER_INVENTORY_STATUS.CANCELLED
-            cancelledTargetInventory.updater = user
-
-            return cancelledTargetInventory
-          })
-        )
+    // change status to cancelled for order inventory that has not executed yet and remove locked qty
+    if (cancelOIs && cancelOIs.length) {
+      await Promise.all(
+        cancelOIs.map(async (orderInventory: OrderInventory) => {
+          let inventory: Inventory = orderInventory.inventory
+
+          if (inventory && inventory.id) {
+            await tx
+              .createQueryBuilder()
+              .update(Inventory)
+              .set({
+                lockedQty: () => `COALESCE("locked_qty", 0) - ${orderInventory.releaseQty}`,
+                lockedUomValue: () => `COALESCE("locked_uom_value", 0) - ${orderInventory.releaseUomValue}`,
+                updater: user
+              } as any)
+              .where('id = :id', { id: inventory.id })
+              .execute()
+
+            // @ChrisLim-git commented for further review as it causes qty to add into inventory
+            // await tx
+            //   .createQueryBuilder()
+            //   .update(Inventory)
+            //   .set({
+            //     qty: () => `COALESCE("qty", 0) + ${orderInventory.releaseQty}`,
+            //     uomValue: () => `COALESCE("uom_value", 0) + ${orderInventory.releaseUomValue}`,
+            //     status: INVENTORY_STATUS.STORED,
+            //     updater: user
+            //   })
+            //   .where('id = :id', { id: inventory.id })
+            //   .execute()
+          }
+
+          return orderInventory
+        })
       )
+
+      await tx
+        .getRepository(OrderInventory)
+        .update(cancelOIs, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: user } as any)
     }
 
-    if (replacedOI && replacedOI?.length) {
-      replacedOI = replacedOI.map((orderInventory: OrderInventory) => {
-        return {
-          ...orderInventory,
-          status: ORDER_INVENTORY_STATUS.CANCELLED,
-          updater: user
-        }
-      })
-      await tx.getRepository(OrderInventory).save(replacedOI)
+    if (replacedOIs && replacedOIs.length) {
+      await tx
+        .getRepository(OrderInventory)
+        .update(replacedOIs, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: user } as any)
     }
 
     if (foundOVs && foundOVs?.length) {
@@ -180,7 +137,9 @@ export const confirmCancellationReleaseOrder = {
     }
 
     // find worksheet and update status to CANCELLED
-    let foundWS: Worksheet[] = await tx.getRepository(Worksheet).find({ where: { domain, releaseGood } })
+    let foundWS: Worksheet[] = await tx
+      .getRepository(Worksheet)
+      .find({ where: { domain: { id: domain.id }, releaseGood } })
 
     foundWS = foundWS.map((ws: Worksheet) => {
       return {
@@ -194,7 +153,7 @@ export const confirmCancellationReleaseOrder = {
     // find worksheet detail and update status to CANCELLED
     let foundWSD: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
       where: {
-        domain,
+        domain: { id: domain.id },
         targetInventory: In(targetOIs.map((oi: OrderInventory) => oi.id))
       }
     })
@@ -212,7 +171,7 @@ export const confirmCancellationReleaseOrder = {
 
     // find DO and change status to pending cancel
     let foundDO: DeliveryOrder[] = await tx.getRepository(DeliveryOrder).find({
-      where: { domain, releaseGood, status: ORDER_STATUS.PENDING_CANCEL },
+      where: { domain: { id: domain.id }, releaseGood, status: ORDER_STATUS.PENDING_CANCEL },
       relations: ['transportVehicle']
     })
 
@@ -234,3 +193,18 @@ export const confirmCancellationReleaseOrder = {
     return
   }
 }
+
+function _filterOrderInventoriesByStatus(orderInventories: OrderInventory[], status: string): OrderInventory[] {
+  return orderInventories
+    .filter((oi: OrderInventory) => oi.status === status)
+    .reduce((acc, oi) => {
+      let existingInvIdx = !oi.inventory ? -1 : acc.findIndex(i => i.inventory?.id == oi.inventory?.id)
+      if (existingInvIdx >= 0) {
+        acc[existingInvIdx].releaseQty += oi.releaseQty
+        acc[existingInvIdx].releaseUomValue += oi.releaseQty
+      } else {
+        acc.push(oi)
+      }
+      return acc
+    }, [])
+}

package/server/graphql/resolvers/worksheet/create-worksheet.ts

@@ -1,17 +1,15 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { Worksheet } from '../../../entities'
 
 export const createWorksheet = {
-  async createWorksheet(_: any, { worksheet }, context: any) {
-    const {
-      tx,
-      domain,
-      bizplace,
-      user
-    }: { tx: EntityManager; domain: Domain; bizplace: Bizplace; user: User } = context.state
+  async createWorksheet(_: any, { worksheet }, context: ResolverContext) {
+    const { tx, domain, bizplace, user }: { tx: EntityManager; domain: Domain; bizplace?: Bizplace; user: User } =
+      context.state
 
     return await tx.getRepository(Worksheet).save({
       ...worksheet,

package/server/graphql/resolvers/worksheet/cross-dock-picking.ts

@@ -1,9 +1,9 @@
-import { User } from '@things-factory/auth-base'
+import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
+
 import { Bizplace } from '@things-factory/biz-base'
 import { OrderInventory, OrderNoGenerator, ReleaseGood } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetController } from '../../../controllers/worksheet-controller'
 import { Worksheet, WorksheetDetail } from '../../../entities'
@@ -20,9 +20,9 @@ export const crossDockPickingResolver = {
     }: { worksheetDetailName: string; worksheetType: string; palletId: string; releaseQty: number },
     context: any
   ): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     const wsd: WorksheetDetail = await tx.getRepository(WorksheetDetail).findOne({
-      where: { domain, name: worksheetDetailName },
+      where: { domain: { id: domain.id }, name: worksheetDetailName },
       relations: [
         'targetInventory',
         'targetInventory.domain',
@@ -43,7 +43,7 @@ export const crossDockPickingResolver = {
     const bizplace: Bizplace = targetInv.bizplace
     let inventory: Inventory = await tx.getRepository(Inventory).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         bizplace,
         palletId,
         status: In([INVENTORY_STATUS.STORED, INVENTORY_STATUS.PARTIALLY_UNLOADED, INVENTORY_STATUS.UNLOADED])
@@ -103,7 +103,8 @@ export const crossDockPickingResolver = {
         })
       }
     } else {
-      let { targetInventory: originOrdInv } = await tx.getRepository(WorksheetDetail).findOne(originWSD.id, {
+      let { targetInventory: originOrdInv } = await tx.getRepository(WorksheetDetail).findOne({
+        where: { id: originWSD.id },
         relations: ['targetInventory']
       })
       originOrdInv.releaseQty += releaseQty

package/server/graphql/resolvers/worksheet/cycle-count-adjustment.ts

@@ -12,8 +12,8 @@ import { Worksheet, WorksheetDetail } from '../../../entities'
 import { generateInventoryHistory, switchLocationStatus } from '../../../utils'
 
 export const cycleCountAdjustmentResolver = {
-  async cycleCountAdjustment(_: any, { cycleCountNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async cycleCountAdjustment(_: any, { cycleCountNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await cycleCountAdjustment(tx, domain, user, cycleCountNo)
   }
 }
@@ -27,7 +27,7 @@ export async function cycleCountAdjustment(
   // get cycle count no
   const cycleCount: InventoryCheck = await tx.getRepository(InventoryCheck).findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       name: cycleCountNo,
       status: ORDER_STATUS.PENDING_REVIEW
     }
@@ -35,7 +35,7 @@ export async function cycleCountAdjustment(
 
   let worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
       inventoryCheck: cycleCount
     }
@@ -44,8 +44,8 @@ export async function cycleCountAdjustment(
   // get cycle count wsd that is not tally
   const worksheetDetails: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
     where: {
-      domain,
-      worksheet,
+      domain: { id: domain.id },
+      worksheet: { id: worksheet.id },
       type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
       status: WORKSHEET_STATUS.NOT_TALLY
     },
@@ -171,7 +171,7 @@ export async function cycleCountAdjustment(
       inventory = await tx.getRepository(Inventory).save(inventory)
 
       if (prevLocationId !== targetInventory.inspectedLocation.id) {
-        const prevLocation: Location = await tx.getRepository(Location).findOne(prevLocationId)
+        const prevLocation: Location = await tx.getRepository(Location).findOneBy({ id: prevLocationId })
         await switchLocationStatus(domain, prevLocation, user, tx)
       }
 

package/server/graphql/resolvers/worksheet/cycle-count-worksheet.ts

@@ -1,24 +1,24 @@
-import { createQueryBuilder, getRepository, In, SelectQueryBuilder } from 'typeorm'
+import { createQueryBuilder, In, SelectQueryBuilder } from 'typeorm'
 
 import { InventoryCheck, ORDER_STATUS, OrderInventory } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
+import { getRepository } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
 export const cycleCountWorksheetResolver = {
-  async cycleCountWorksheet(_: any, { inventoryCheckNo, locationSortingRules }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async cycleCountWorksheet(_: any, { inventoryCheckNo, locationSortingRules }, context: ResolverContext) {
+    const { domain } = context.state
     const cycleCount: InventoryCheck = await getRepository(InventoryCheck).findOne({
-      where: { domain, name: inventoryCheckNo, status: ORDER_STATUS.INSPECTING }
+      where: { domain: { id: domain.id }, name: inventoryCheckNo, status: ORDER_STATUS.INSPECTING }
     })
 
     if (!cycleCount) throw new Error('Failed to find cycle count worksheet')
 
     const worksheet: Worksheet = await getRepository(Worksheet).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         inventoryCheck: cycleCount,
         type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
         status: WORKSHEET_STATUS.EXECUTING

package/server/graphql/resolvers/worksheet/delete-worksheet.ts

@@ -1,12 +1,14 @@
+import { EntityManager, In } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager, In } from 'typeorm'
+
 import { Worksheet } from '../../../entities'
 
 export const deleteWorksheet = {
-  async deleteWorksheet(_: any, { id }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async deleteWorksheet(_: any, { id }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
 
     await tx.getRepository(Worksheet).delete({
       domain: domain,

package/server/graphql/resolvers/worksheet/delivery-order-by-worksheet.ts

@@ -1,67 +1,101 @@
 import { Bizplace, ContactPoint } from '@things-factory/biz-base'
-import { DeliveryOrder } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
+import { logger } from '@things-factory/env'
+import { DeliveryOrder, OrderInventory } from '@things-factory/sales-base'
 import { TransportDriver } from '@things-factory/transport-base'
 
 export const deliveryOrderByWorksheetResolver = {
-  async deliveryOrderByWorksheet(_: any, { name }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-    const foundDO: DeliveryOrder = await getRepository(DeliveryOrder).findOne({
-      where: {
-        domain,
-        name
-      },
-      relations: ['domain', 'bizplace', 'transportDriver', 'transportVehicle', 'releaseGood', 'creator', 'updater']
-    })
+  async deliveryOrderByWorksheet(_: any, { name }, context: ResolverContext) {
+    const { domain, tx } = context.state
+    try {
+      const foundDO: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
+        where: {
+          domain: { id: domain.id },
+          name
+        },
+        relations: ['domain', 'bizplace', 'transportDriver', 'transportVehicle', 'releaseGood', 'creator', 'updater']
+      })
 
-    if (!foundDO) throw new Error('Delivery order not found!')
+      if (!foundDO) throw new Error('Delivery order not found!')
 
-    const partnerBiz: Bizplace = await getRepository(Bizplace).findOne({
-      where: { id: foundDO.bizplace.id }
-    })
+      const foundOI: any = await tx
+        .getRepository(OrderInventory)
+        .createQueryBuilder('oi')
+        .select('p.name', 'name')
+        .addSelect('p.sku', 'sku')
+        .addSelect('p.type', 'type')
+        .addSelect('oi.batch_id', 'batchNo')
+        .addSelect('oi.uom', 'uom')
+        .addSelect('sum(oi.release_qty)', 'loadedQty')
+        .addSelect('sum(oi.release_uom_value)', 'uomValue')
+        .innerJoin('products', 'p', 'p.id = oi.product_id')
+        .groupBy('p.name')
+        .addGroupBy('p.sku')
+        .addGroupBy('p.type')
+        .addGroupBy('oi.batch_id')
+        .addGroupBy('oi.uom')
+        .where('oi.domain_id = :domainId', { domainId: domain.id })
+        .andWhere('oi.delivery_order_id = :deliveryOrderId', { deliveryOrderId: foundDO.id })
+        .orderBy('p.sku')
+        .addOrderBy('oi.batch_id')
+        .getRawMany()
 
-    const partnerContactPoint: ContactPoint[] = await getRepository(ContactPoint).find({
-      where: { domain, bizplace: partnerBiz }
-    })
+      const partnerBiz: Bizplace = await tx.getRepository(Bizplace).findOne({
+        where: { id: foundDO.bizplace.id }
+      })
 
-    let foundTransportDriver: TransportDriver = { name: '' }
-    if (foundDO.transportDriver) {
-      foundTransportDriver = await getRepository(TransportDriver).findOne({
-        where: { domain, id: foundDO.transportDriver.id }
+      const partnerContactPoint: ContactPoint[] = await tx.getRepository(ContactPoint).find({
+        where: { domain, bizplace: partnerBiz }
       })
 
-      if (!foundTransportDriver) throw new Error('transport driver is not found')
-    }
+      let foundTransportDriver: TransportDriver = { name: '' }
+      if (foundDO.transportDriver) {
+        foundTransportDriver = await tx.getRepository(TransportDriver).findOne({
+          where: { domain, id: foundDO.transportDriver.id }
+        })
 
-    return {
-      deliveryOrderInfo: {
-        ownCollection: foundDO.ownCollection,
-        doStatus: foundDO.status,
-        truckNo: foundDO.truckNo,
-        bizplace: foundDO.bizplace,
-        deliverTo: foundDO.contactPointRefId || '',
-        deliveryDate: foundDO.deliveryDate || '',
-        driverName: foundTransportDriver.name,
-        otherDestination: foundDO.otherDestination || false,
-        contactName: foundDO.contactName || '',
-        otherDriver: foundDO.otherDriver || '',
-        looseItem: foundDO.looseItem || false,
-        remark: foundDO.remark || '',
-        reusablePallet: foundDO.reusablePallet || '',
-        createdDate: foundDO.createdAt.toISOString().split('T')[0],
-        isManualDo: foundDO.releaseGood ? false : true
-      },
-      contactPointInfo: partnerContactPoint.map(async (cp: ContactPoint) => {
-        return {
-          id: cp.id,
-          address: cp.address || '',
-          email: cp.email || '',
-          fax: cp.fax || '',
-          phone: cp.phone || '',
-          contactName: cp.name || ''
-        }
-      })
+        if (!foundTransportDriver) throw new Error('transport driver is not found')
+      }
+
+      return {
+        deliveryOrderInfo: {
+          name: foundDO.name,
+          ownCollection: foundDO.ownCollection,
+          doStatus: foundDO.status,
+          truckNo: foundDO.truckNo,
+          bizplace: foundDO.bizplace,
+          deliverTo: foundDO.contactPointRefId || '',
+          deliveryDate: foundDO.deliveryDate || '',
+          driverName: foundTransportDriver.name,
+          otherDestination: foundDO.otherDestination || false,
+          contactName: foundDO.contactName || '',
+          otherDriver: foundDO.otherDriver || '',
+          looseItem: foundDO.looseItem || false,
+          remark: foundDO.remark || '',
+          reusablePallet: foundDO.reusablePallet || '',
+          createdDate: foundDO.createdAt.toISOString().split('T')[0],
+          isManualDo: foundDO.releaseGood ? false : true,
+          attentionTo: foundDO.attentionTo,
+          releaseGood: {
+            ...foundDO.releaseGood,
+            attentionTo: foundDO.attentionTo || foundDO.releaseGood.attentionTo,
+            bizplace: partnerBiz
+          },
+          productList: foundOI
+        },
+        contactPointInfo: partnerContactPoint.map(async (cp: ContactPoint) => {
+          return {
+            id: cp.id,
+            address: cp.address || '',
+            email: cp.email || '',
+            fax: cp.fax || '',
+            phone: cp.phone || '',
+            contactName: cp.name || ''
+          }
+        })
+      }
+    } catch (error) {
+      logger.error(`delivery-order-by-worksheet:(data:${JSON.stringify({ name, domain })}) ${error} `)
+      throw new Error('Something went wrong. Please contact support.')
     }
   }
 }