@things-factory/worksheet-base 4.3.37 → 4.3.40

package/dist-server/graphql/types/worksheet/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../server/graphql/types/worksheet/index.ts"],"names":[],"mappings":";;;AAAA,6CAAyC;AACzC,yEAAmE;AACnE,6DAAuD;AACvD,mEAA6D;AAC7D,mDAA8C;AAC9C,+DAAyD;AACzD,6DAAwD;AACxD,+DAA0D;AAC1D,qFAA4E;AAC5E,+DAAyD;AACzD,2EAAqE;AACrE,uEAAiE;AACjE,iFAA0E;AAC1E,mDAA8C;AAC9C,2EAAqE;AACrE,yDAAoD;AACpD,qEAA+D;AAC/D,qEAA+D;AAC/D,+DAAyD;AACzD,2CAAuC;AACvC,mEAA6D;AAC7D,qDAAgD;AAChD,qDAAgD;AAChD,uDAAkD;AAClD,2EAAqE;AAExD,QAAA,QAAQ,GAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6hBrC,CAAA;AAEY,QAAA,KAAK,GAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0IlC,CAAA;AAEY,QAAA,KAAK,GAAiB;IACjC,qBAAS;IACT,uBAAU;IACV,4BAAY;IACZ,gCAAc;IACd,8BAAa;IACb,iDAAsB;IACtB,6CAAoB;IACpB,2CAAmB;IACnB,6CAAoB;IACpB,mDAAuB;IACvB,uCAAiB;IACjB,uCAAiB;IACjB,qCAAgB;IAChB,uCAAiB;IACjB,8BAAa;IACb,4BAAY;IACZ,sCAAiB;IACjB,2CAAmB;IACnB,wCAAkB;IAClB,+CAAqB;IACrB,kCAAe;IACf,mDAAuB;IACvB,mDAAuB;IACvB,wDAAyB;IACzB,0DAAyB;CAC1B,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../server/graphql/types/worksheet/index.ts"],"names":[],"mappings":";;;AAAA,6CAAyC;AACzC,yEAAmE;AACnE,6DAAuD;AACvD,mEAA6D;AAC7D,mDAA8C;AAC9C,+DAAyD;AACzD,6DAAwD;AACxD,+DAA0D;AAC1D,qFAA4E;AAC5E,+DAAyD;AACzD,2EAAqE;AACrE,uEAAiE;AACjE,iFAA0E;AAC1E,mDAA8C;AAC9C,2EAAqE;AACrE,yDAAoD;AACpD,qEAA+D;AAC/D,qEAA+D;AAC/D,+DAAyD;AACzD,2CAAuC;AACvC,mEAA6D;AAC7D,qDAAgD;AAChD,qDAAgD;AAChD,uDAAkD;AAClD,2EAAqE;AACrE,2DAAqD;AAGxC,QAAA,QAAQ,GAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6hBrC,CAAA;AAEY,QAAA,KAAK,GAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8IlC,CAAA;AAEY,QAAA,KAAK,GAAgB;IAChC,qBAAS;IACT,uBAAU;IACV,4BAAY;IACZ,gCAAc;IACd,8BAAa;IACb,iDAAsB;IACtB,6CAAoB;IACpB,2CAAmB;IACnB,6CAAoB;IACpB,mDAAuB;IACvB,uCAAiB;IACjB,uCAAiB;IACjB,qCAAgB;IAChB,uCAAiB;IACjB,8BAAa;IACb,4BAAY;IACZ,sCAAiB;IACjB,2CAAmB;IACnB,wCAAkB;IAClB,+CAAqB;IACrB,kCAAe;IACf,mDAAuB;IACvB,mDAAuB;IACvB,wDAAyB;IACzB,0DAAyB;IACzB,mCAAe;CAChB,CAAA"}

package/dist-server/graphql/types/worksheet-detail/inventory-detail.js

@@ -39,6 +39,7 @@ exports.InventoryDetail = (0, graphql_tag_1.default) `
     orderProductRemark: String
     purchaseOrderNo: String
     arrivalNoticeRefNo: String
+    arrivalNoticeNo: String
   }
 `;
 //# sourceMappingURL=inventory-detail.js.map

package/dist-server/graphql/types/worksheet-detail/inventory-detail.js.map

@@ -1 +1 @@
-{"version":3,"file":"inventory-detail.js","sourceRoot":"","sources":["../../../../server/graphql/types/worksheet-detail/inventory-detail.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA6B;AAEhB,QAAA,eAAe,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCjC,CAAA"}
+{"version":3,"file":"inventory-detail.js","sourceRoot":"","sources":["../../../../server/graphql/types/worksheet-detail/inventory-detail.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA6B;AAEhB,QAAA,eAAe,GAAG,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCjC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worksheet-base",
-  "version": "4.3.37",
+  "version": "4.3.40",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,21 +24,21 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^4.3.35",
-    "@things-factory/biz-base": "^4.3.35",
+    "@things-factory/auth-base": "^4.3.40",
+    "@things-factory/biz-base": "^4.3.40",
     "@things-factory/document-template-base": "^4.3.35",
-    "@things-factory/id-rule-base": "^4.3.35",
-    "@things-factory/integration-lmd": "^4.3.35",
-    "@things-factory/integration-marketplace": "^4.3.37",
-    "@things-factory/integration-sellercraft": "^4.3.37",
-    "@things-factory/integration-sftp": "^4.3.37",
-    "@things-factory/marketplace-base": "^4.3.37",
-    "@things-factory/notification": "^4.3.35",
-    "@things-factory/sales-base": "^4.3.37",
-    "@things-factory/setting-base": "^4.3.35",
+    "@things-factory/id-rule-base": "^4.3.40",
+    "@things-factory/integration-lmd": "^4.3.40",
+    "@things-factory/integration-marketplace": "^4.3.40",
+    "@things-factory/integration-sellercraft": "^4.3.40",
+    "@things-factory/integration-sftp": "^4.3.40",
+    "@things-factory/marketplace-base": "^4.3.40",
+    "@things-factory/notification": "^4.3.40",
+    "@things-factory/sales-base": "^4.3.40",
+    "@things-factory/setting-base": "^4.3.40",
     "@things-factory/shell": "^4.3.35",
-    "@things-factory/transport-base": "^4.3.35",
-    "@things-factory/warehouse-base": "^4.3.37"
+    "@things-factory/transport-base": "^4.3.40",
+    "@things-factory/warehouse-base": "^4.3.40"
   },
-  "gitHead": "63cc1d86f82b002d7bd96a72347e8d333c1b696a"
+  "gitHead": "5ae9cd8d8abe747c4e8ac9e243468c1f6662481b"
 }

package/server/controllers/outbound/picking-worksheet-controller.ts

@@ -1152,25 +1152,15 @@ export class PickingWorksheetController extends VasWorksheetController {
 
   private async checkAndSetBinPicking(orderInventory, binLocation) {
     // bin picking validation
-    const binPickingSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
-      where: {
-        domain: this.domain,
-        name: 'enable-bin-picking'
-      }
-    })
-    if (binPickingSetting != undefined && binPickingSetting.value.toLowerCase() == 'true') {
-      if (binLocation) {
-        const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
-          where: { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN }
-        })
-
-        if (!foundBinLocation)
-          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+    if (binLocation) {
+      const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+        where: { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN }
+      })
 
-        orderInventory.binLocation = foundBinLocation
-      } else {
+      if (!foundBinLocation)
         throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
-      }
+
+      orderInventory.binLocation = foundBinLocation
     }
 
     return orderInventory

package/server/controllers/render-po.ts

@@ -5,7 +5,13 @@ import { getRepository, SelectQueryBuilder } from 'typeorm'
 import { Attachment, STORAGE } from '@things-factory/attachment-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { config } from '@things-factory/env'
-import { InvoiceProduct, ReleaseGood, PurchaseOrder, PurchaseOrderOtherCharge, OrderProduct } from '@things-factory/sales-base'
+import {
+  InvoiceProduct,
+  ReleaseGood,
+  PurchaseOrder,
+  PurchaseOrderOtherCharge,
+  OrderProduct
+} from '@things-factory/sales-base'
 
 import { Domain } from '@things-factory/shell'
 
@@ -31,6 +37,7 @@ export async function renderPO({ req, timezoneOffSet }, context: any) {
             .innerJoinAndSelect('bizplace.company', 'company')
             .innerJoinAndSelect('company.domain', 'company_domain')
             .leftJoinAndSelect('contact_points', 'cp', 'po.supplier_id = cp.id')
+            .leftJoinAndSelect('arrival_notices', 'an', 'an.purchase_order_id = po.id')
             .where('po.id = :poId')
             .andWhere('po.domain = :domainId')
             .setParameters({ poId, domainId: domain.id })
@@ -71,7 +78,6 @@ export async function renderPO({ req, timezoneOffSet }, context: any) {
 
             let poOtherCharges: any[] = await poocQb.getRawMany()
 
-
             const qb: SelectQueryBuilder<OrderProduct> = await getRepository(OrderProduct)
               .createQueryBuilder('op')
               .innerJoin('domains', 'd', 'op.domain_id = d.id')
@@ -89,17 +95,21 @@ export async function renderPO({ req, timezoneOffSet }, context: any) {
                 product_sku: item.p_sku,
                 product_name: item.p_name,
                 product_desc: item.p_description,
+                product_remark: item.op_remark,
                 product_qty: item.op_pack_qty,
                 product_uom: item.op_uom,
                 product_other_charges: item.ip_other_charges,
-                product_unit_price: (item.op_unit_price).toFixed(2),
-                product_total_price: ((((item.op_unit_price || 0) * item.op_pack_qty) - (item.op_discount_amt || 0)) * (1 + (item.op_tax_rate / 100))).toFixed(2),
+                product_unit_price: item.op_unit_price.toFixed(2),
+                product_total_price: (
+                  ((item.op_unit_price || 0) * item.op_pack_qty - (item.op_discount_amt || 0)) *
+                  (1 + item.op_tax_rate / 100)
+                ).toFixed(2),
                 product_tax_rate: item.op_tax_rate,
-                product_disc_amt: item.op_discount_amt
+                product_disc_amt: item.op_discount_amt,
+                ref_no: record.po_ref_no
               }
             })
 
-
             let date = DateTimeConverter.date(new Date(record.po_created_at - timezoneOffSet))
             let eta = DateTimeConverter.date(new Date(record.po_eta_date))
 
@@ -114,6 +124,7 @@ export async function renderPO({ req, timezoneOffSet }, context: any) {
               company_name: record.company_description,
               company_address: record.company_address,
               company_postal_code: record.company_postal_code,
+              an_name: record.an_name,
               po_number: record.po_name,
               po_order_date: date,
               po_delivery_date: eta,
@@ -126,14 +137,20 @@ export async function renderPO({ req, timezoneOffSet }, context: any) {
               product_list,
               charges_list: [
                 {
-                  field: 'SUBTOTAL', value: subtotal.toFixed(2)
+                  field: 'SUBTOTAL',
+                  value: subtotal.toFixed(2)
                 },
-                ...poOtherCharges.map(itm => { return { field: itm.pooc_name.toUpperCase(), value: itm.pooc_total_amt.toFixed(2) } }),
+                ...poOtherCharges.map(itm => {
+                  return { field: itm.pooc_name.toUpperCase(), value: itm.pooc_total_amt.toFixed(2) }
+                }),
                 {
-                  field: 'TOTAL', value: (poOtherCharges.reduce((init, item) => {
-                    return init += (item.pooc_total_amt)
-                  }, subtotal) || 0).toFixed(2),
-                },
+                  field: 'TOTAL',
+                  value: (
+                    poOtherCharges.reduce((init, item) => {
+                      return (init += item.pooc_total_amt)
+                    }, subtotal) || 0
+                  ).toFixed(2)
+                }
               ]
             }
 
@@ -141,7 +158,7 @@ export async function renderPO({ req, timezoneOffSet }, context: any) {
             formData.append('template', template)
             formData.append('jsonString', JSON.stringify(data))
 
-            const response = await fetch(REPORT_API_URL, {
+            const response =  await fetch(REPORT_API_URL, {
               method: 'POST',
               body: formData
             })

package/server/controllers/render-ro-do.ts

@@ -360,7 +360,7 @@ export async function renderRODO({ doNo }, context: any) {
     }),
     serialNumber: foundInventoryItem.map((item: any, idx) => {
       return { ...item, delivery_to: foundDO.to }
-    })
+    }) || ''
   } //.. make data from do
   const formData = new FormData()
 

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

@@ -1,24 +1,20 @@
-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 { User } from '@things-factory/auth-base'
 import {
+  DeliveryOrder,
   ORDER_INVENTORY_STATUS,
   ORDER_STATUS,
   ORDER_VAS_STATUS,
   OrderInventory,
-  DeliveryOrder,
   OrderVas,
   ReleaseGood
 } from '@things-factory/sales-base'
-import { generateInventoryHistory } from '../../../utils'
+import { Domain } from '@things-factory/shell'
+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) {
@@ -39,132 +35,82 @@ 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
+              })
+              .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 })
     }
 
-    // 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
+              })
+              .where('id = :id', { id: inventory.id })
+              .execute()
+          }
+
+          return orderInventory
+        })
       )
+
+      await tx
+        .getRepository(OrderInventory)
+        .update(cancelOIs, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: user })
     }
 
-    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 })
     }
 
     if (foundOVs && foundOVs?.length) {
@@ -234,3 +180,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/fetch-delivery-order-ro.ts

@@ -0,0 +1,193 @@
+import _ from 'lodash'
+import FormData from 'form-data'
+import fetch from 'node-fetch'
+import { Equal, getRepository, In } from 'typeorm'
+
+import { Partner } from '@things-factory/auth-base'
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
+import { DeliveryOrder, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, Pallet } from '@things-factory/warehouse-base'
+import { InventoryItem } from '@things-factory/warehouse-base'
+import { TEMPLATE_TYPE, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { DateTimeConverter } from '../../../utils'
+
+export const fetchDeliveryOrderROResolver = {
+  async fetchDeliveryOrderRO(_: any, { name }, context: any) {
+    const domain: Domain = await getRepository(Domain).findOne({
+      where: { id: context.state.domain.id }
+    })
+
+    const foundDO: DeliveryOrder = await getRepository(DeliveryOrder).findOne({
+      where: { domain, name },
+      relations: [
+        'domain',
+        'bizplace',
+        'bizplace.company',
+        'bizplace.domain',
+        'transportDriver',
+        'transportVehicle',
+        'releaseGood',
+        'creator',
+        'updater'
+      ]
+    })
+
+    const ownTransportFlag: Boolean = foundDO.ownCollection
+
+    let foundCP: ContactPoint = null
+    if (foundDO?.contactPointRefId) {
+      foundCP = await getRepository(ContactPoint).findOne({
+        where: { domain, id: foundDO.contactPointRefId }
+      })
+    }
+
+    const foundRO: ReleaseGood = foundDO.releaseGood
+    const partnerBiz: Bizplace = foundDO.bizplace //customer bizplace
+    const ownRefNo = foundRO.refNo
+
+    //find list of loaded inventory
+    const targetInventories: OrderInventory[] = await getRepository(OrderInventory).find({
+      where: { domain, deliveryOrder: foundDO },
+      relations: ['inventory']
+    })
+    const orderInvIds: string[] = targetInventories.map((oi: any) => oi.id)
+
+    const foundWSD: WorksheetDetail[] = await getRepository(WorksheetDetail).find({
+      where: {
+        domain,
+        targetInventory: In(orderInvIds),
+        type: WORKSHEET_TYPE.LOADING,
+        status: Equal(WORKSHEET_STATUS.DONE)
+      },
+      relations: [
+        'targetInventory',
+        'targetInventory.inventory',
+        'targetInventory.inventory.location',
+        'targetInventory.inventory.product',
+        'targetInventory.inventory.product.productDetails',
+        'targetInventory.inventory.reusablePallet',
+        'updater'
+      ]
+    })
+
+    let foundDriver: any = null
+    if (foundDO.status !== ORDER_STATUS.READY_TO_DISPATCH) {
+      if (foundDO?.ownCollection && foundDO?.otherDriver) {
+        foundDriver = foundDO.otherDriver
+      } else {
+        foundDriver = foundDO.transportDriver.name
+      }
+    }
+
+    let productList: any[] = []
+    productList = foundWSD
+      .map((wsd: WorksheetDetail) => {
+        const targetInventory: OrderInventory = wsd.targetInventory
+        const inventory: Inventory = targetInventory.inventory
+        const productDetails: any[] = inventory.product.productDetails
+        const matchedProductDetail: any = productDetails.find(
+          productDetail => productDetail.packingType === inventory.packingType
+        )
+        return {
+          product_name: `${inventory.product.name} (${inventory.product.description})`,
+          product_desc: `${inventory.product?.description || ''}`,
+          product_nameOnly: `${inventory.product.name}`,
+          product_sku: `${inventory.product.sku}`,
+          product_type: inventory.packingType,
+          product_size: matchedProductDetail ? matchedProductDetail.packingSize : inventory.packingSize,
+          product_batch: inventory.batchId,
+          product_batch_ref: inventory.batchIdRef,
+          product_qty: targetInventory.releaseQty,
+          product_weight: targetInventory.releaseWeight,
+          product_gross_weight: inventory.product.grossWeight,
+          product_uom_value: targetInventory.releaseUomValue,
+          product_uom: inventory.uom,
+          remark: targetInventory.remark,
+          inventory_remark: inventory.remark,
+          cross_docking: targetInventory.crossDocking,
+          pallet: inventory?.reusablePallet && inventory?.reusablePallet?.name ? inventory.reusablePallet.name : ''
+        }
+      })
+      .reduce((newItem, item) => {
+        var foundItem = newItem.find(
+          newItem =>
+            newItem.product_name === item.product_name &&
+            newItem.product_batch === item.product_batch &&
+            newItem.product_batch_ref === item.product_batch_ref &&
+            newItem.cross_docking === item.cross_docking &&
+            newItem.pallet === item.pallet
+        )
+        if (!foundItem) {
+          foundItem = {
+            product_sku: item.product_sku,
+            product_name: item.product_name,
+            product_type: item.product_type,
+            product_size: item.product_size,
+            product_batch: item.product_batch,
+            product_batch_ref: item.product_batch_ref,
+            product_qty: item.product_qty,
+            product_weight: item.product_weight,
+            product_gross_weight: item.product_gross_weight,
+            product_uom_value: item.product_uom_value,
+            product_uom: item.product_uom,
+            product_desc: item.product_desc,
+            product_nameOnly: item.product_nameOnly,
+            remark: item.remark,
+            inventory_remark: item.inventory_remark,
+            palletQty: 1,
+            cross_docking: item.cross_docking,
+            pallet: item.pallet
+          }
+
+          newItem.push(foundItem)
+          return newItem
+        } else {
+          return newItem.map(ni => {
+            if (
+              ni.product_name === item.product_name &&
+              ni.product_batch === item.product_batch &&
+              ni.product_batch_ref === item.product_batch_ref &&
+              ni.cross_docking === item.cross_docking &&
+              ni.pallet === item.pallet
+            ) {
+              return {
+                ...ni,
+                palletQty: ni.palletQty + 1,
+                product_qty: ni.product_qty + item.product_qty,
+                product_weight: ni.product_weight + item.product_weight,
+                product_uom_value: ni.product_uom_value + item.product_uom_value
+              }
+            } else {
+              return ni
+            }
+          })
+        }
+      }, [])
+
+    const data = {
+      roNo: foundRO.name,
+      doNo: foundDO.name,
+      roRef: foundRO.refNo,
+      roRef2: foundRO.refNo2,
+      roRef3: foundRO.refNo3,
+      companyDomain: foundDO.bizplace.name,
+      recipientBiz: foundRO.attentionTo || '',
+      doDate: DateTimeConverter.date(foundDO.createdAt),
+      productList: productList.map((prod: any, idx) => {
+        return {
+          batchNo: prod.product_batch,
+          sku: prod.product_sku,
+          name: prod.product_name,
+          type: prod.product_type,
+          loadedQty: prod.product_qty,
+          uom: prod.product_uom,
+          uomValue: `${Math.round(prod.product_uom_value * 100) / 100}`
+        }
+      })
+    }
+
+    return data
+  }
+}