@things-factory/sales-base 3.7.2 → 3.7.7

package/server/graphql/resolvers/delivery-order/delivery-orders.ts

@@ -78,12 +78,23 @@ export const deliveryOrdersResolver = {
         })
       }
 
+      let refNoFilter = params.filters.find(x => x.name == 'refNo')
+      let refNo2Filter = params.filters.find(x => x.name == 'refNo2')
+      let refNo3Filter = params.filters.find(x => x.name == 'refNo3')
+
+      params.filters = params.filters.filter(
+        x =>
+          x.name != 'refNo' &&
+          x.name != 'refNo2' &&
+          x.name != 'refNo3'
+      )
+
       const qb: any = getRepository(DeliveryOrder).createQueryBuilder('do')
       buildQuery(qb, params, context)
       qb.addSelect('COALESCE("cc".rank, 99999)', 'rank')
       qb.leftJoinAndSelect('do.domain', 'domain')
       qb.leftJoinAndSelect('do.bizplace', 'bizplace')
-      qb.leftJoinAndSelect('do.releaseGood', 'rg')
+      qb.leftJoinAndSelect('do.releaseGood', 'releaseGood')
       qb.leftJoinAndSelect('do.transportDriver', 'td')
       qb.leftJoinAndSelect('do.transportVehicle', 'th')
       qb.leftJoinAndSelect('do.orderInventories', 'oi')
@@ -105,20 +116,31 @@ export const deliveryOrdersResolver = {
         'cc.status = do.status'
       )
 
-      const arrChildSortData = ['bizplace', 'releaseGood']
+      if (refNoFilter?.value) {
+        qb.andWhere('releaseGood.ref_no ilike :refNo', { refNo: refNoFilter.value })
+      }
+      if (refNo2Filter?.value) {
+        qb.andWhere('releaseGood.ref_no_2 ilike :refNo2', { refNo2: refNo2Filter.value })
+      }
+      if (refNo3Filter?.value) {
+        qb.andWhere('releaseGood.ref_no_3 ilike :refNo3', { refNo3: refNo3Filter.value })
+      }
+
+      const arrChildSortData = ['refNo', 'refNo2', 'refNo3']
+      const arrNameSortData = ['bizplace', 'releaseGood', 'updater']
       const sort = (params.sortings || []).reduce(
         (acc, sort) => ({
           ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'do.' + sort.name]: sort.desc
+          [arrChildSortData.indexOf(sort.name) >= 0 ? 'releaseGood.' + sort.name : arrNameSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'do.' + sort.name]: sort.desc
             ? 'DESC'
             : 'ASC'
         }),
-        !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+        params.sortings.length < 1 ? { rank: 'ASC', 'do.createdAt': 'DESC' } : {}
       )
 
       qb.orderBy(sort)
-      const [items, total] = await qb.getManyAndCount()
 
+      const [items, total] = await qb.getManyAndCount()
       return { items, total }
     } catch (error) {
       debug('deliveryOrders', error.toString())

package/server/graphql/resolvers/goods-receival-note/goods-receival-notes.ts

@@ -1,65 +1,123 @@
+import { getRepository, SelectQueryBuilder } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
-import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
-import { getRepository, In, IsNull } from 'typeorm'
-import { ArrivalNotice } from '../../../entities/arrival-notice'
-import { GoodsReceivalNote } from '../../../entities/goods-receival-note'
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
+import { GoodsReceivalNote } from '../../../entities'
 
 export const goodsReceivalNotesResolver = {
   async goodsReceivalNotes(_: any, params: ListParam, context: any) {
     const { domain, user }: { domain: Domain; user: User } = context.state
 
-    const convertedParams = convertListParams(params)
-
-    const arrivalNoticeParam: any = params.filters.find((param: any) => param.name === 'arrivalNoticeNo')
-    const arrivalNoticeRefNoParam = params.filters.find(param => param.name === 'arrivalNoticeRefNo')
+    const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+    if (fromDateParamIdx >= 0) {
+      let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+      params.filters.splice(fromDateParamIdx, 1)
 
-    const bizplaceParam = params.filters.find(param => param.name === 'bizplaceName')
-    if (bizplaceParam) {
-      const foundBizplaces: Bizplace[] = await getRepository(Bizplace).find({
-        where: {
-          ...convertListParams({ filters: [{ ...bizplaceParam, name: 'name' }] }).where
-        }
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'gte',
+        value: fromDateVal.toISOString(),
+        relation: false
       })
-
-      // remove non-column params
-      delete convertedParams.where.bizplaceName
-
-      if (foundBizplaces && foundBizplaces.length) {
-        convertedParams.where.bizplace = In(foundBizplaces.map((foundBizplace: Bizplace) => foundBizplace.id))
-      } else {
-        convertedParams.where.bizplace = IsNull()
-      }
-    } else {
-      convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
-      convertedParams.where.domain = domain
     }
 
-    if (arrivalNoticeParam || arrivalNoticeRefNoParam) {
-      let arrFilters = []
-      if (arrivalNoticeParam) {
-        arrFilters.push({ ...arrivalNoticeParam, name: 'name' })
-      }
-      if (arrivalNoticeRefNoParam) arrFilters.push({ ...arrivalNoticeRefNoParam, name: 'refNo' })
-      const foundArrivalNotices: ArrivalNotice[] = await getRepository(ArrivalNotice).find({
-        ...convertListParams({ filters: arrFilters })
+    const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+    if (toDateParamIdx >= 0) {
+      let toDateVal = new Date(params.filters[toDateParamIdx].value)
+      params.filters.splice(toDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'lt',
+        value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+        relation: false
       })
+    }
+
+    let refNoFilter = params.filters.find(x=> x.name =='refNo')
+    let refNo2Filter = params.filters.find(x=> x.name =='refNo2')
+    let refNo3Filter = params.filters.find(x=> x.name =='refNo3')
+    let ganNameFilter = params.filters.find(x=> x.name =='arrivalNoticeNo')
+    let bizplaceFilter = params.filters.find(x=> x.name =='bizplaceName')
+    let ganStatusFilter = params.filters.find(x=> x.name =='ganStatus')
+    let grnStatusFilter = params.filters.find(x=> x.name =='grnStatus')
+
+
+    params.filters = params.filters.filter(
+      x =>
+        x.name != 'refNo' &&
+        x.name != 'refNo2' &&
+        x.name != 'refNo3' &&
+        x.name != 'arrivalNoticeNo' &&
+        x.name != 'bizplaceName' &&
+        x.name != 'ganStatus' &&
+        x.name != 'grnStatus'
+    )
 
-      // remove non-column params
-      delete convertedParams.where.arrivalNoticeNo
-      delete convertedParams.where.arrivalNoticeRefNo
+    const qb: SelectQueryBuilder<GoodsReceivalNote> = getRepository(GoodsReceivalNote).createQueryBuilder('grn')
+    buildQuery(qb, params, context)
+    qb.addSelect('COALESCE("cc".rank, 9999)', 'rank')
+    qb.leftJoinAndSelect('grn.domain', 'domain')
+    qb.leftJoinAndSelect('grn.bizplace', 'bizplace')
+    qb.leftJoinAndSelect('grn.creator', 'creator')
+    qb.leftJoinAndSelect('grn.updater', 'updater')
+    qb.innerJoinAndSelect('grn.arrivalNotice', 'arrivalNotice')
+    qb.leftJoin(
+      subQuery => {
+        return subQuery
+          .select(`ccd.rank`, 'rank')
+          .addSelect(`ccd.name`, 'status')
+          .from(`common_code_details`, 'ccd')
+          .innerJoin(`ccd.commonCode`, 'cc')
+          .where(`ccd.domain_id = :domainId`, { domainId: domain.id })
+          .andWhere(`cc.name = 'GRN_STATUS'`)
+          .andWhere(`cc.name = 'GAN_REQUESTS_STATUS'`)
+      },
+      'cc',
+      'cc.status = arrivalNotice.status'
+    )
 
-      if (foundArrivalNotices && foundArrivalNotices.length) {
-        convertedParams.where.arrivalNotice = In(foundArrivalNotices.map((foundAN: ArrivalNotice) => foundAN.id))
-      } else {
-        convertListParams.where.arrivalNotice = IsNull()
-      }
+    if (refNoFilter?.value) {
+      qb.andWhere('arrivalNotice.ref_no ilike :refNo', { refNo: refNoFilter.value })
     }
+    if (refNo2Filter?.value) {
+      qb.andWhere('arrivalNotice.ref_no_2 ilike :refNo2', { refNo2: refNo2Filter.value })
+    }
+    if (refNo3Filter?.value) {
+      qb.andWhere('arrivalNotice.ref_no_3 ilike :refNo3', { refNo3: refNo3Filter.value })
+    }
+    if (ganNameFilter?.value) {
+      qb.andWhere('arrivalNotice.name ilike :ganName', { ganName: ganNameFilter.value })
+    }
+    if (bizplaceFilter?.value) {
+      qb.andWhere('bizplace.name ilike :bizName', { bizName: bizplaceFilter.value })
+    }
+    if (ganStatusFilter?.value) {
+      qb.andWhere('arrivalNotice.status ilike :ganStatus', { ganStatus: ganStatusFilter.value })
+    }
+    if (grnStatusFilter?.value) {
+      qb.andWhere('grn.status ilike :grnStatus', { grnStatus: grnStatusFilter.value })
+    }
+
+    const arrChildSortData = ['refNo', 'refNo2', 'refNo3']
+    const arrNameSortData = ['bizplace', 'arrivalNotice', 'updater']
+    const arrGanStatusSortData = ['ganStatus']
+    const arrGrnStatuSortData = ['status']
+    const sort = (params.sortings || []).reduce(
+      (acc, sort) => ({
+        ...acc,
+        [arrChildSortData.indexOf(sort.name) >= 0 ? 'arrivalNotice.' + sort.name : arrNameSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' 
+        : arrGanStatusSortData.indexOf(sort.name) >= 0 ? 'arrivalNotice.status' : arrGrnStatuSortData.indexOf(sort.name) >=0 ? 'grn.status' : 'grn.' + sort.name]: sort.desc
+          ? 'DESC'
+          : 'ASC'
+      }),
+      !params.sortings.some(e => e.name === 'status') ? { rank: 'ASC' } : {}
+    )
+
+      qb.orderBy(sort)
 
-    let [items, total] = await getRepository(GoodsReceivalNote).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'arrivalNotice', 'bizplace', 'creator', 'updater']
-    })
+    const [items, total] = await qb.getManyAndCount()
 
     return { items, total }
   }

package/server/graphql/resolvers/index.ts

@@ -8,8 +8,10 @@ import * as GoodsReceivalNote from './goods-receival-note'
 import * as InventoryCheck from './inventory-check'
 import * as Invoice from './invoice'
 import * as JobSheet from './job-sheet'
+import * as Manifest from './manifest'
 import * as OrderInventory from './order-inventory'
 import * as OrderProduct from './order-product'
+import * as OrderReverseKitting from './order-reverse-kitting'
 import * as OrderVas from './order-vas'
 import * as Others from './others'
 import * as PurchaseOrder from './purchase-order'
@@ -47,7 +49,8 @@ export const queries = [
   VasOrder.Query,
   GoodsReceivalNote.Query,
   Others.Query,
-  ReverseKittingOrder.Query
+  ReverseKittingOrder.Query,
+  Manifest.Query
 ]
 
 export const mutations = [
@@ -74,5 +77,7 @@ export const mutations = [
   VasOrder.Mutation,
   GoodsReceivalNote.Mutation,
   Others.Mutation,
-  ReverseKittingOrder.Mutation
+  ReverseKittingOrder.Mutation,
+  OrderReverseKitting.Mutation,
+  Manifest.Mutation
 ]

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

@@ -0,0 +1,13 @@
+import { getRepository } from 'typeorm'
+import { Manifest } from '../../../entities'
+
+export const deleteManifest = {
+  async deleteManifest(_: any, { name }, context: any) {
+    const { domain, user } = context.state
+
+    await getRepository(Manifest).delete({ domain, name })
+    
+    return true
+  }
+}
+

package/server/graphql/resolvers/manifest/dispatch-manifest.ts

@@ -0,0 +1,34 @@
+import { DISPATCHMENT_STATUS, MANIFEST_STATUS } from '../../../constants'
+import { Manifest, ReleaseGood } from '../../../entities'
+
+export const dispatchManifest = {
+  async dispatchManifest(_: any, { name, patch }, context: any) {
+    const { domain, user, tx } = context.state
+
+    const manifest: Manifest = await tx.getRepository(Manifest).findOne({
+      where: { domain, name, status: MANIFEST_STATUS.OPEN }
+    })
+    if (!manifest) throw new Error(`Unable to find ${name}`)
+
+    let releaseGoods: any[] = await tx.getRepository(ReleaseGood).find({ where: { domain, manifest } })
+
+    releaseGoods = await Promise.all(
+      releaseGoods.map((releaseGood: ReleaseGood) => {
+        return {
+          ...releaseGood,
+          dispatchmentStatus: DISPATCHMENT_STATUS.DISPATCHED,
+          updater: user
+        }
+      })
+    )
+    await tx.getRepository(ReleaseGood).save(releaseGoods)
+
+    return await tx.getRepository(Manifest).save({
+      ...manifest,
+      ...patch,
+      status: MANIFEST_STATUS.CLOSED,
+      dispatchedAt: new Date(),
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/manifest/generate-manifest.ts

@@ -0,0 +1,50 @@
+import { MANIFEST_STATUS } from '../../../constants'
+import { Manifest, ReleaseGood } from '../../../entities'
+import { OrderNoGenerator } from '../../../utils'
+
+export const generateManifest = {
+  async generateManifest(_: any, { manifest }, context: any) {
+    const { domain, user, tx } = context.state
+    const manifestItems: any[] = manifest.manifestItems
+
+    // regroup array of object by transporter
+    let shippingProviderGrouping: any = manifestItems.reduce((a, b) => {
+      a[b.transporter] = [...(a[b.transporter] || []), b]
+      return a
+    }, {})
+
+    for (const transporter in shippingProviderGrouping) {
+      const items: any[] = shippingProviderGrouping[transporter]
+
+      const openManifest: Manifest = await tx
+        .getRepository(Manifest)
+        .findOne({ domain, shippingProvider: transporter, status: MANIFEST_STATUS.OPEN })
+
+      let manifest: Manifest
+
+      if (openManifest) {
+        manifest = openManifest
+      } else {
+        manifest = new Manifest()
+        manifest.domain = domain
+        manifest.shippingProvider = transporter
+        manifest.name = OrderNoGenerator.manifest()
+        manifest.creator = user
+        manifest = await tx.getRepository(Manifest).save(manifest)
+      }
+
+      await Promise.all(
+        items.map(async item => {
+          let releaseOrder: ReleaseGood = await tx
+            .getRepository(ReleaseGood)
+            .findOne({ domain, refNo: item.refNo, trackingNo: item.trackingNo })
+          releaseOrder.manifest = manifest
+          releaseOrder.updater = user
+          await tx.getRepository(ReleaseGood).save(releaseOrder)
+        })
+      )
+    }
+
+    return true
+  }
+}

package/server/graphql/resolvers/manifest/index.ts

@@ -0,0 +1,16 @@
+import { deleteManifest } from './delete-manifest'
+import { dispatchManifest } from './dispatch-manifest'
+import { generateManifest } from './generate-manifest'
+import { manifestResolver } from './manifest'
+import { manifestsResolver } from './manifests'
+
+export const Query = {
+  ...manifestResolver,
+  ...manifestsResolver
+}
+
+export const Mutation = {
+  ...deleteManifest,
+  ...generateManifest,
+  ...dispatchManifest
+}

package/server/graphql/resolvers/manifest/manifest.ts

@@ -0,0 +1,28 @@
+import { Manifest, ReleaseGood } from '../../../entities'
+
+export const manifestResolver = {
+  async manifest(_: any, { name }, context: any) {
+    const { domain, tx } = context.state
+    const manifest: Manifest = await tx.getRepository(Manifest).findOne({ where: { domain, name } })
+
+    const releaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({ where: { manifest } })
+
+    const trackingNos: any[] = releaseGoods.map(releaseGood => {
+      return {
+        trackingNo: releaseGood.trackingNo,
+        refNo: releaseGood.refNo,
+        deliveryAddress: releaseGood.deliveryAddress1,
+        attentionTo: releaseGood.attentionTo,
+        postalCode: releaseGood.postalCode,
+        city: releaseGood.city,
+        phone: releaseGood.phone1,
+        dispatchmentStatus: releaseGood.dispatchmentStatus
+      }
+    })
+
+    return {
+      ...manifest,
+      trackingNos
+    }
+  }
+}

package/server/graphql/resolvers/manifest/manifests.ts

@@ -0,0 +1,43 @@
+import { getRepository } from 'typeorm'
+
+import { convertListParams, ListParam } from '@things-factory/shell'
+
+import { Manifest as ManifestEntity } from '../../../entities'
+
+export const manifestsResolver = {
+  async manifests(_: any, params: ListParam, context: any) {
+    const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+    if (fromDateParamIdx >= 0) {
+      let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+      params.filters.splice(fromDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'gte',
+        value: fromDateVal.toISOString(),
+        relation: false
+      })
+    }
+
+    const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+    if (toDateParamIdx >= 0) {
+      let toDateVal = new Date(params.filters[toDateParamIdx].value)
+      params.filters.splice(toDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'lt',
+        value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+        relation: false
+      })
+    }
+
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(ManifestEntity).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/order-inventory/index.ts

@@ -2,6 +2,7 @@ import { orderInventoryResolver } from './order-inventory'
 import { orderInventoriesResolver } from './order-inventories'
 import { inventoriesByOrderResolver } from './inventories-by-order'
 import { mergedProductOrderInventoriesResolver } from './merged-product-order-inventories'
+import { updateOrderInventorySerialNumberResolver } from './update-order-inventories-serial-number'
 
 import { deleteOrderInventory } from './delete-order-inventory'
 import { deleteOrderInventories } from './delete-order-inventories'
@@ -15,5 +16,6 @@ export const Query = {
 
 export const Mutation = {
   ...deleteOrderInventory,
-  ...deleteOrderInventories
+  ...deleteOrderInventories,
+  ...updateOrderInventorySerialNumberResolver
 }

package/server/graphql/resolvers/order-inventory/order-inventories.ts

@@ -55,6 +55,7 @@ export const orderInventoriesResolver = {
         'inventory.product',
         'releaseGood',
         'deliveryOrder',
+        'bizplace',
         'creator',
         'updater'
       ]

package/server/graphql/resolvers/order-inventory/order-inventory.ts

@@ -3,15 +3,15 @@ import { getRepository } from 'typeorm'
 import { OrderInventory } from '../../../entities'
 
 export const orderInventoryResolver = {
-  async orderInventory(_: any, { name }, context: any) {
+  async orderInventory(_: any, { id }, context: any) {
     const { domain }: { domain: Domain } = context.state
 
     return await getRepository(OrderInventory).findOne({
       where: {
         domain,
-        name
+        id
       },
-      relations: ['domain', 'releaseGood', 'vasOrder', 'shippingOrder', 'inventory', 'creator', 'updater']
+      relations: ['domain', 'releaseGood', 'inventory', 'creator', 'updater']
     })
   }
 }

package/server/graphql/resolvers/order-inventory/update-order-inventories-serial-number.ts

@@ -0,0 +1,28 @@
+import { Product } from '@things-factory/product-base'
+import { convertListParams, ListParam, Domain } from '@things-factory/shell'
+import { getRepository, EntityManager } from 'typeorm'
+import { OrderInventory } from '../../../entities'
+
+export const updateOrderInventorySerialNumberResolver = {
+  async updateOrderInventorySerialNumber(_: any, { orderInventory }, context: any) {
+    try {
+      const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+      await tx.getRepository(OrderInventory).update(
+        {
+          domain,
+          id: orderInventory.id
+        },
+        {
+          serialNumber: orderInventory.serialNumber
+        }
+      )
+      orderInventory = await tx.getRepository(OrderInventory).findOne({ id: orderInventory.id })
+
+      return orderInventory
+    } catch (error) {
+      throw error
+    }
+
+  }
+}

package/server/graphql/resolvers/order-reverse-kitting/index.ts

@@ -1,9 +1,12 @@
 import { orderReverseKittingResolver } from './order-reverse-kitting'
 import { orderReverseKittingsResolver } from './order-reverse-kittings'
+import { updateOrderReverseKitting } from './update-order-reverse-kitting'
 
 export const Query = {
   ...orderReverseKittingResolver,
   ...orderReverseKittingsResolver
 }
 
-export const Mutation = {}
+export const Mutation = {
+  ...updateOrderReverseKitting
+}

package/server/graphql/resolvers/order-reverse-kitting/update-order-reverse-kitting.ts

@@ -0,0 +1,26 @@
+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 { OrderReverseKitting } from '../../../entities'
+
+export const updateOrderReverseKitting = {
+  async updateOrderReverseKitting(_: any, { id, patch }, context: any) {
+    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+    const orderReverseKitting: OrderReverseKitting = await tx.getRepository(OrderReverseKitting).findOne({
+      where: {
+        domain,
+        bizplace: In(await getPermittedBizplaceIds(domain, user)),
+        id
+      }
+    })
+
+    return await tx.getRepository(OrderReverseKitting).save({
+      ...orderReverseKitting,
+      ...patch,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/others/bulk-upload-validate-warehouse-partners-products-quantity.ts

@@ -1,9 +1,11 @@
+import orderBy from 'lodash/orderBy'
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getPermittedBizplaces } from '@things-factory/biz-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { InventoryUtil } from '../../../utils'
-import orderBy from 'lodash/orderBy'
 
 export const bulkUploadValidateWarehousePartnersProductsQuantityResolver = {
   async bulkUploadValidateWarehousePartnersProductsQuantity(
@@ -81,15 +83,16 @@ export const bulkUploadValidateWarehousePartnersProductsQuantityResolver = {
         inventory:
           total > 0
             ? {
-                ...items[0],
-                remainQty: total > 0 ? items[0].remainQty : null,
-                remainUomValue: total > 0 ? items[0].remainUomValue : null,
-                remainUomValueWithUom: total > 0 ? items[0].remainUomValueWithUom : ''
-              }
+              ...items[0],
+              remainQty: total > 0 ? items[0].remainQty : null,
+              remainUomValue: total > 0 ? items[0].remainUomValue : null,
+              remainUomValueWithUom: total > 0 ? items[0].remainUomValueWithUom : ''
+            }
             : null,
         productId: total > 0 ? items[0].productId : null,
         productSKU: total > 0 ? items[0].productSKU : orderInventory.productSKU,
         productName: total > 0 ? items[0].productName : null,
+        uom: total > 0 ? items[0].uom : null,
         remainQty: total > 0 ? items[0].remainQty : null,
         remainUomValue: total > 0 ? items[0].remainUomValue : null,
         remainUomValueWithUom: total > 0 ? items[0].remainUomValueWithUom : '',

package/server/graphql/resolvers/release-good/index.ts

@@ -10,6 +10,7 @@ import { releaseGoodResolver } from './release-good'
 import { releaseGoodDetailResolver } from './release-good-detail'
 import { releaseGoodRequestsResolver } from './release-good-requests'
 import { releaseGoodsResolver } from './release-goods'
+import { updateReleaseGoodDetailsResolver } from './update-release-good-details'
 
 export const Query = {
   ...releaseGoodsResolver,
@@ -26,5 +27,6 @@ export const Mutation = {
   ...generateReleaseGood,
   ...receiveReleaseGoodResolver,
   ...rejectReleaseGoodResolver,
-  ...addReleaseGood
+  ...addReleaseGood,
+  ...updateReleaseGoodDetailsResolver
 }

package/server/graphql/resolvers/release-good/release-good-detail.ts

@@ -74,6 +74,8 @@ export const releaseGoodDetailResolver = {
                 packingSize: inventory.packingSize,
                 location: inventory.location,
                 qty: inventory.qty,
+                lockedQty: inventory.lockedQty,
+                lockedUomValue: inventory. lockedUomValue,
                 uom: inventory.uom,
                 uomValue: inventory.uomValue,
                 releaseQty: orderInv.releaseQty,
@@ -103,18 +105,25 @@ export const releaseGoodDetailResolver = {
           })
       )
 
-      const result = {
+      let result = {
         ...releaseGood,
         attachment: foundAttachments,
-        shippingOrderInfo: {
-          containerNo: shippingOrder?.containerNo || '',
-          containerLeavingDate: shippingOrder?.containerLeavingDate || '',
-          containerArrivalDate: shippingOrder?.containerArrivalDate || '',
-          shipName: shippingOrder?.shipName || ''
-        },
+        shippingOrderInfo: {},
         inventoryInfos: orderBy(invInfos, ['product.sku'], ['asc'])
       }
 
+      if (shippingOrder) {
+        result = {
+          ...result,
+          shippingOrderInfo: {
+            id: shippingOrder?.id ,
+            containerNo: shippingOrder?.containerNo,
+            containerLeavingDate: shippingOrder?.containerLeavingDate,
+            containerArrivalDate: shippingOrder?.containerArrivalDate,
+            shipName: shippingOrder?.shipName
+          }
+        }
+      }
       dropOITempTable(domain, tx)
 
       return result