@things-factory/sales-base 4.0.25 → 4.0.29

package/server/service/arrival-notice/arrival-notice-query.ts

@@ -450,7 +450,7 @@ export async function validateBulkArrivalNoticesFunction(
         ELSE CASE WHEN tp.batch_id ISNULL THEN 'batch no. is required'
         ELSE CASE WHEN tp.ref_no ISNULL OR tp.ref_no = '' THEN 'ref no. is required'
         ELSE CASE WHEN tp.eta_date ISNULL OR tp.eta_date = '' THEN 'eta date is required'
-        ELSE CASE WHEN tp.eta_date:: date < timeofday():: date THEN 'backdate is not allowed'
+        ELSE CASE WHEN tp.eta_date::date < now()::date THEN 'backdate is not allowed'
         ELSE CASE WHEN tp.container_no NOTNULL AND tp.container_size ISNULL OR tp.container_no ISNULL AND tp.container_size NOTNULL THEN 'incomplete container information'
         ELSE '' END END END END END END END END AS remark 
       FROM 

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

@@ -94,7 +94,7 @@ export class DeliveryOrder {
   retailReplenishmentOrderId: string
 
   @OneToMany(type => OrderInventory, orderInventory => orderInventory.deliveryOrder)
-  @Field(type => OrderInventory, { nullable: true })
+  @Field(type => [OrderInventory], { nullable: true })
   orderInventories: OrderInventory[]
 
   @Field(type => [OrderInventory], { nullable: true })

package/server/service/job-sheet/job-sheet-mutation.ts

@@ -18,6 +18,7 @@ export class JobSheetMutation {
     return await generateJobSheet(domain, user, arrivalNotice, tx)
   }
 
+  @Directive('@transaction')
   @Mutation(returns => JobSheet)
   async updateJobSheet(
     @Arg('name') name: string,

package/server/service/job-sheet/job-sheet-query.ts

@@ -1,13 +1,14 @@
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root, Directive } from 'type-graphql'
 import { EntityManager, getRepository, SelectQueryBuilder } from 'typeorm'
 import { ArrivalNotice, JobSheetList } from '../'
 import { JobSheet } from './job-sheet'
 
 @Resolver(JobSheet)
 export class JobSheetQuery {
+  @Directive('@transaction')
   @Query(returns => JobSheetList)
   async jobSheets(
     @Ctx() context: any,
@@ -65,6 +66,7 @@ export class JobSheetQuery {
     return { items, total }
   }
 
+  @Directive('transaction')
   @Query(returns => JobSheet)
   async jobSheet(@Arg('arrivalNoticeRefNo') arrivalNoticeRefNo: string, @Ctx() context: any): Promise<JobSheet> {
     const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state

package/server/service/purchase-order/purchase-order.ts

@@ -3,6 +3,7 @@ import { Bizplace, ContactPoint } from '@things-factory/biz-base'
 import { Domain } from '@things-factory/shell'
 import { Location } from '@things-factory/warehouse-base'
 import { Field, ID, ObjectType } from 'type-graphql'
+import { Attachment } from '@things-factory/attachment-base'
 import {
   Column,
   CreateDateColumn,
@@ -53,6 +54,12 @@ export class PurchaseOrder {
   @Field()
   status: string
 
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => [Attachment], { nullable: true })
+  attachment: Attachment[]
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   refNo: string
@@ -105,7 +112,7 @@ export class PurchaseOrder {
   orderProducts: OrderProduct[]
 
   @OneToMany(type => PurchaseOrderOtherCharge, otherCharge => otherCharge.purchaseOrder)
-  @Field(type => PurchaseOrderOtherCharge, { nullable: true })
+  @Field(type => [PurchaseOrderOtherCharge], { nullable: true })
   otherCharges: (PurchaseOrderOtherCharge | PurchaseOrderOtherChargePatch)[]
 
   @ManyToOne(type => ContactPoint)

package/server/service/release-good/release-good-mutation.ts

@@ -6,7 +6,6 @@ import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Partner, Role, User } from '@things-factory/auth-base'
 import {
   Bizplace,
-  getCompanyBizplace,
   getDomainUsers,
   getMyBizplace,
   getOutletBizplace,
@@ -20,7 +19,7 @@ import { sendNotification } from '@things-factory/notification'
 import { Product, ProductBundleSetting } from '@things-factory/product-base'
 import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
+import { Inventory } from '@things-factory/warehouse-base'
 
 import {
   ArrivalNotice,
@@ -49,6 +48,7 @@ import { ValidationError } from '../../errors'
 import { InventoryUtil, OrderNoGenerator } from '../../utils'
 import { confirmArrivalNoticeFunction, deleteArrivalNotice } from '../arrival-notice/arrival-notice-mutation'
 import { ReleaseGood } from './release-good'
+import { bulkReleaseGoodsAvailableItemsFunction } from './release-good-query'
 
 @Resolver(ReleaseGood)
 export class ReleaseGoodMutation {
@@ -108,7 +108,7 @@ export class ReleaseGoodMutation {
           // update orderInventories if availableItems are valid
           releaseGoods[i].orderInventories = availableItems
 
-          const createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGoods(
+          const createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGood(
             releaseGoods[i],
             bizplaceId,
             roNoSetting,
@@ -734,200 +734,6 @@ export async function generateReleaseGoodFunction(
   }
 }
 
-export async function bulkReleaseGoodsAvailableItemsFunction(
-  rawReleaseGoods: any[],
-  bizplaceId: string,
-  context: any,
-  tx?: EntityManager
-): Promise<any[]> {
-  const { domain }: { domain: Domain } = context.state
-  const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
-
-  if (!rawReleaseGoods) return
-
-  const json_oi = JSON.stringify(
-    rawReleaseGoods.map(raw => {
-      return {
-        sku: raw.sku,
-        packing_type: raw.packingType,
-        packing_size: raw.packingSize,
-        uom: raw.uom,
-        release_qty: raw.releaseQty
-      }
-    })
-  )
-
-  await tx.query(
-    `
-        CREATE TEMP TABLE temp_order_products(
-          product_id VARCHAR(50),
-          sku VARCHAR(150),
-          product_info VARCHAR(250),
-          packing_type VARCHAR(50),
-          packing_size INT,
-          uom VARCHAR(10),
-          release_qty INT
-          );
-      `
-  )
-
-  await tx.query(
-    `
-        INSERT INTO temp_order_products
-        SELECT p.id AS product_id, js.sku,
-        CASE WHEN p.description NOT IN (NULL, '', '-') THEN CONCAT(p.name, '(', p.description, ')')
-          ELSE p.name END AS product_info,
-        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
-        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
-        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END,
-        js.release_qty
-        FROM JSON_POPULATE_RECORDSET(NULL::temp_order_products,'${json_oi}') js
-        LEFT JOIN products p ON js.sku = p.sku AND p.bizplace_id = $1
-        LEFT JOIN product_details pd ON p.id = pd.product_id AND pd.is_default = TRUE;
-      `,
-    [companyBizplaceId.id]
-  )
-
-  let availableItems = await tx.query(
-    `
-      WITH inv AS (
-        SELECT i.product_id, foo.sku, foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom,
-          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
-            (
-              SELECT SUM(oi.release_qty) FROM order_inventories oi 
-              WHERE oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')
-              AND oi.inventory_id IS null
-              AND oi.product_id = i.product_id::uuid
-              AND oi.packing_type = i.packing_type
-              AND oi.uom = i.uom
-              AND oi.domain_id = $1
-              AND oi.bizplace_id = $2
-            ), 0) as "remain_qty",
-          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
-            (
-              SELECT SUM(oi.release_uom_value) FROM order_inventories oi 
-              WHERE oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')
-              AND oi.inventory_id IS null
-              AND oi.product_id = i.product_id::uuid
-              AND oi.packing_type = i.packing_type
-              AND oi.uom = i.uom
-              AND oi.domain_id = $1
-              AND oi.bizplace_id = $2
-            ), 0) as "remain_uom_value"
-        FROM inventories i
-        LEFT JOIN locations l
-        ON i.location_id = l.id
-        INNER JOIN (
-          SELECT top.product_id, top.sku, top.product_info, top.packing_type, top.packing_size, top.uom 
-          FROM temp_order_products top
-          GROUP BY top.product_id, top.sku, top.product_info, top.packing_type, top.packing_size, top.uom
-        ) AS foo
-        ON i.product_id = foo.product_id::uuid
-        AND i.packing_type = foo.packing_type
-        AND i.packing_size = foo.packing_size
-        AND i.uom = foo.uom
-        AND i.domain_id = $1
-        AND i.bizplace_id = $2
-        WHERE l.type NOT IN ($3, $4)
-        GROUP BY i.product_id, foo.sku,foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom
-        ORDER BY foo.sku, remain_qty
-      ) SELECT * FROM inv WHERE remain_qty > 0
-    `,
-    [domain.id, bizplaceId, LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
-  )
-
-  await tx.query('DROP TABLE temp_order_products')
-
-  availableItems = availableItems.map(item => {
-    return {
-      productId: item.product_id,
-      productInfo: item.product_info,
-      sku: item.sku,
-      batchId: item.batch_id,
-      packingType: item.packing_type,
-      packingSize: item.packing_size,
-      uom: item.uom,
-      remainQty: item.remain_qty,
-      remainUomValue: item.remain_uom_value
-    }
-  })
-
-  return _extractData(rawReleaseGoods, availableItems)
-}
-
-function _extractData(rawData, validatedData) {
-  return rawData.map(raw => {
-    const idx = validatedData.findIndex(val => {
-      const comparison = ['packingType', 'packingSize', 'uom']
-
-      let a: any = {},
-        b: any = {}
-
-      comparison.forEach(cc => {
-        if (raw[cc]) {
-          a[cc] = raw[cc]
-          b[cc] = val[cc]
-        }
-      })
-
-      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
-      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
-
-      return val.sku == raw.sku && a === b
-    })
-
-    let releaseUomValue: number = 0
-
-    // if sku is matched, assign qty and product id
-    if (idx >= 0) {
-      const uomValuePerQty: number =
-        Math.round((validatedData[idx].remainUomValue / validatedData[idx].remainQty) * 100) / 100
-
-      // use Math.round again because 4.2 * 6 = 25.200000000000003
-      releaseUomValue = Math.round(uomValuePerQty * raw.releaseQty * 100) / 100
-
-      // assign qty to rawData as much as possible
-      raw.assignedQty =
-        validatedData[idx].remainQty >= raw.releaseQty
-          ? raw.releaseQty > 0
-            ? raw.releaseQty
-            : 0
-          : validatedData[idx].remainQty > 0
-          ? validatedData[idx].remainQty
-          : 0
-
-      raw.assignedUomValue =
-        validatedData[idx].remainUomValue >= releaseUomValue
-          ? releaseUomValue > 0
-            ? releaseUomValue
-            : 0
-          : validatedData[idx].remainUomValue > 0
-          ? validatedData[idx].remainUomValue
-          : 0
-
-      // deduct qty & uomValue from validateData
-      validatedData[idx].remainQty -= raw.assignedQty
-      validatedData[idx].remainUomValue -= raw.assignedUomValue
-
-      raw.productId = validatedData[idx].productId
-      raw.productInfo = validatedData[idx].productInfo
-      raw.packingType = validatedData[idx].packingType
-      raw.packingSize = validatedData[idx].packingSize
-      raw.uom = validatedData[idx].uom
-      raw.batchId = validatedData[idx].batchId
-    } else {
-      raw.assignedQty = 0
-      raw.assignedUomValue = 0
-      raw.productId = null
-    }
-
-    return {
-      ...raw,
-      releaseUomValue
-    }
-  })
-}
-
 export async function confirmReleaseGood(name: string, context: any, tx?: EntityManager): Promise<ReleaseGood> {
   const { user, domain }: { user: User; domain: Domain } = context.state
 
@@ -978,7 +784,7 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
       let matchedMarketplaceStore: MarketplaceStore
       if (foundMarketplaceOrder) {
         matchedMarketplaceStore = marketplaceStores.filter(
-          marketplaceStore => marketplaceStore.id != foundMarketplaceOrder.marketplaceStore.id
+          marketplaceStore => marketplaceStore.id == foundMarketplaceOrder.marketplaceStore.id
         )[0]
       }
 
@@ -1308,7 +1114,7 @@ export async function rejectReleaseGood(
   return releaseGood
 }
 
-export async function bulkGenerateReleaseGoods(
+export async function bulkGenerateReleaseGood(
   releaseGood: any,
   bizplaceId: string,
   roNoSetting: any,

package/server/service/release-good/release-good-query.ts

@@ -7,7 +7,7 @@ import { User } from '@things-factory/auth-base'
 import { Bizplace, getCompanyBizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { buildQuery, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
+import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
 
 import {
   InventoryInfos,
@@ -477,120 +477,10 @@ export class ReleaseGoodQuery {
     @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
     @Arg('bizplaceId', type => String) bizplaceId: string
   ): Promise<ReleaseGood[]> {
-    const { domain, tx } = context.state
-    const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
-
-    if (!rawReleaseGoods) return
-
-    const json_oi = JSON.stringify(
-      rawReleaseGoods.map(raw => {
-        return {
-          sku: raw.sku,
-          packing_type: raw.packingType,
-          packing_size: raw.packingSize,
-          uom: raw.uom,
-          release_qty: raw.releaseQty
-        }
-      })
-    )
+    const { tx }: { tx: EntityManager } = context.state
+    const availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(rawReleaseGoods, bizplaceId, context, tx)
 
-    await tx.query(
-      `
-        CREATE TEMP TABLE temp_order_products(
-          product_id VARCHAR(50),
-          sku VARCHAR(150),
-          packing_type VARCHAR(50),
-          packing_size INT,
-          uom VARCHAR(10),
-          release_qty INT
-          );
-      `
-    )
-
-    await tx.query(
-      `
-        INSERT INTO temp_order_products
-        SELECT p.id AS product_id, js.sku,
-        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
-        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
-        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END,
-        js.release_qty
-        FROM JSON_POPULATE_RECORDSET(NULL::temp_order_products,'${json_oi}') js
-        LEFT JOIN products p ON js.sku = p.sku AND p.bizplace_id = $1
-        LEFT JOIN product_details pd ON p.id = pd.product_id AND pd.is_default = TRUE;
-      `,
-      [companyBizplaceId.id]
-    )
-
-    let availableItems = await tx.query(
-      `
-        SELECT i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom,
-          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
-            (
-              SELECT SUM(oi.release_qty) FROM order_inventories oi 
-              WHERE (
-                oi.status = 'PENDING'
-                OR oi.status = 'PENDING_RECEIVE'
-                OR oi.status = 'PENDING_WORKSHEET'
-                OR oi.status = 'PENDING_SPLIT'
-              )
-              AND oi.inventory_id IS null
-              AND oi.product_id = i.product_id::uuid
-              AND oi.packing_type = i.packing_type
-              AND oi.uom = i.uom
-              AND oi.domain_id = $1
-              AND oi.bizplace_id = $2
-            ), 0) as "remain_qty",
-          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
-            (
-              SELECT SUM(oi.release_uom_value) FROM order_inventories oi 
-              WHERE (
-                oi.status = 'PENDING'
-                OR oi.status = 'PENDING_RECEIVE'
-                OR oi.status = 'PENDING_WORKSHEET'
-                OR oi.status = 'PENDING_SPLIT'
-              )
-              AND oi.inventory_id IS null
-              AND oi.product_id = i.product_id::uuid
-              AND oi.packing_type = i.packing_type
-              AND oi.uom = i.uom
-              AND oi.domain_id = $1
-              AND oi.bizplace_id = $2
-            ), 0) as "remain_uom_value"
-        FROM inventories i
-        INNER JOIN (
-          SELECT top.product_id, top.sku, top.packing_type, top.packing_size, top.uom 
-          FROM temp_order_products top
-          GROUP BY top.product_id, top.sku, top.packing_type, top.packing_size, top.uom
-        ) AS foo
-        ON i.product_id = foo.product_id::uuid
-        AND i.packing_type = foo.packing_type
-        AND i.packing_size = foo.packing_size
-        AND i.uom = foo.uom
-        AND i.domain_id = $1
-        AND i.bizplace_id = $2
-        GROUP BY i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom
-        ORDER BY foo.sku, remain_qty
-      `,
-      [domain.id, bizplaceId]
-    )
-
-    await tx.query('DROP TABLE temp_order_products')
-
-    availableItems = availableItems.map(item => {
-      return {
-        productId: item.product_id,
-        sku: item.sku,
-        batchId: item.batch_id,
-        packingType: item.packing_type,
-        packingSize: item.packing_size,
-        uom: item.uom,
-        remainQty: item.remain_qty,
-        remainUomValue: item.remain_uom_value
-      }
-    })
-
-    return _extractData(rawReleaseGoods, availableItems)
+    return availableItems
   }
 
   @FieldResolver(type => Domain)
@@ -689,6 +579,134 @@ async function dropOITempTable(domain: Domain, tx: EntityManager) {
   await tx.query(`DROP TABLE oi`)
 }
 
+export async function bulkReleaseGoodsAvailableItemsFunction(
+  rawReleaseGoods: any[],
+  bizplaceId: string,
+  context: any,
+  tx?: EntityManager
+): Promise<any[]> {
+  const { domain }: { domain: Domain } = context.state
+  const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
+
+  if (!rawReleaseGoods) return
+  const json_oi = JSON.stringify(
+    rawReleaseGoods.map(raw => {
+      return {
+        sku: raw.sku,
+        packing_type: raw.packingType,
+        packing_size: raw.packingSize,
+        uom: raw.uom,
+        release_qty: raw.releaseQty
+      }
+    })
+  )
+
+  await tx.query(
+    `
+        CREATE TEMP TABLE raw_release_goods(
+          product_id VARCHAR(50),
+          product_detail_id VARCHAR(50),
+          sku VARCHAR(150),
+          product_info VARCHAR(250),
+          packing_type VARCHAR(50),
+          packing_size INT,
+          uom VARCHAR(10),
+          release_qty INT
+        );
+      `
+  )
+
+  await tx.query(
+    `
+        INSERT INTO raw_release_goods
+        SELECT p.id AS product_id,
+        pd.id AS product_detail_id,
+        js.sku,
+        CASE WHEN p.description NOT IN (NULL, '', '-') THEN CONCAT(p.name, '(', p.description, ')')
+          ELSE p.name END AS product_info,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
+        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END
+        FROM JSON_POPULATE_RECORDSET(NULL::raw_release_goods, $1) js
+        LEFT JOIN products p ON js.sku = p.sku AND p.bizplace_id = $2
+        LEFT JOIN product_details pd ON p.id = pd.product_id
+        AND CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL AND js.uom NOTNULL
+          THEN pd.packing_type = js.packing_type AND pd.packing_size = js.packing_size AND pd.uom = js.uom 
+          WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL AND js.uom ISNULL 	
+            THEN pd.packing_type = js.packing_type AND pd.packing_size = js.packing_size AND pd.is_default IS TRUE
+            WHEN js.packing_type ISNULL AND js.packing_size ISNULL AND js.uom NOTNULL
+              THEN pd.uom = js.uom AND pd.is_default IS TRUE ELSE pd.is_default IS TRUE 
+        END;
+      `,
+    [json_oi, companyBizplaceId.id]
+  )
+
+  let availableItems = await tx.query(
+    `
+        WITH inv AS (
+        SELECT i.product_id, foo.product_detail_id, foo.sku, foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom,
+          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_qty) FROM order_inventories oi 
+              WHERE oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_qty",
+          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_uom_value) FROM order_inventories oi 
+              WHERE oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_uom_value"
+        FROM inventories i
+        LEFT JOIN locations l
+        ON i.location_id = l.id
+        INNER JOIN (
+          SELECT rrg.product_id, rrg.product_detail_id, rrg.sku, rrg.product_info, rrg.packing_type, rrg.packing_size, rrg.uom 
+          FROM raw_release_goods rrg
+          GROUP BY rrg.product_id, rrg.product_detail_id, rrg.sku, rrg.product_info, rrg.packing_type, rrg.packing_size, rrg.uom
+        ) AS foo
+        ON i.product_id = foo.product_id::uuid
+        AND i.packing_type = foo.packing_type
+        AND i.packing_size = foo.packing_size
+        AND i.uom = foo.uom
+        AND i.domain_id = $1
+        AND i.bizplace_id = $2
+        WHERE l.type NOT IN ($3, $4)
+        GROUP BY i.product_id, foo.product_detail_id, foo.sku,foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom
+        ORDER BY foo.sku, remain_qty
+      ) SELECT * FROM inv WHERE remain_qty > 0
+      `,
+    [domain.id, bizplaceId, LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
+  )
+
+  availableItems = availableItems.map(item => {
+    return {
+      productId: item.product_id,
+      productDetailId: item.product_detail_id,
+      productInfo: item.product_info,
+      sku: item.sku,
+      batchId: item.batch_id,
+      packingType: item.packing_type,
+      packingSize: item.packing_size,
+      uom: item.uom,
+      remainQty: item.remain_qty,
+      remainUomValue: item.remain_uom_value
+    }
+  })
+
+  return _extractData(rawReleaseGoods, availableItems)
+}
+
 function _extractData(rawData, validatedData) {
   return rawData.map(raw => {
     const idx = validatedData.findIndex(val => {
@@ -737,6 +755,7 @@ function _extractData(rawData, validatedData) {
       validatedData[idx].remainUomValue -= raw.assignedUomValue
 
       raw.productId = validatedData[idx].productId
+      raw.productDetailId = validatedData[idx].productDetailId
       raw.packingType = validatedData[idx].packingType
       raw.packingSize = validatedData[idx].packingSize
       raw.uom = validatedData[idx].uom
@@ -747,9 +766,25 @@ function _extractData(rawData, validatedData) {
       raw.productId = null
     }
 
+    let releaseDate = _getStdDateStr(new Date(raw.releaseDate || ''))
+
     return {
       ...raw,
-      releaseUomValue
+      releaseUomValue,
+      errorMsg:
+        !raw.productId || !raw.productDetailId
+          ? 'product not found'
+          : raw.releaseQty <= 0
+          ? 'invalid release qty'
+          : raw.assignedQty < raw.releaseQty
+          ? 'insufficient stock'
+          : raw.releaseDate == ''
+          ? 'release date is empty'
+          : releaseDate < _getStdDateStr(new Date())
+          ? 'backdate is not allowed'
+          : !raw.refNo
+          ? 'ref no is empty'
+          : ''
     }
   })
 }
@@ -772,3 +807,11 @@ function getConditionValues(
     return condition
   }, {})
 }
+
+function _getStdDateStr(date) {
+  if (isNaN(date.getFullYear())) return ''
+  else {
+    date.setHours(date.getHours() + 8)
+    return date.toISOString().split('T')[0]
+  }
+}

package/server/service/release-good/release-good-types.ts

@@ -308,6 +308,13 @@ export class NewReleaseGood {
   @Field({ nullable: true })
   partnerBizplaceId: string
 
+  /* Mainly used for rawReleaseGood*/
+  @Field({ nullable: true })
+  productId: string
+
+  @Field({ nullable: true })
+  productDetailId: string
+
   @Field({ nullable: true })
   sku: string
 
@@ -315,13 +322,28 @@ export class NewReleaseGood {
   packingType: string
 
   @Field({ nullable: true })
-  packingSize: string
+  packingSize: number
 
   @Field({ nullable: true })
   uom: string
 
   @Field({ nullable: true })
-  releaseQty: string
+  releaseQty: number
+
+  @Field({ nullable: true })
+  assignedQty: number
+
+  @Field({ nullable: true })
+  assignedUomValue: number
+
+  @Field({ nullable: true })
+  remainQty: number
+
+  @Field({ nullable: true })
+  remainUomValue: number
+
+  @Field({ nullable: true })
+  errorMsg: string
 }
 
 @InputType()