@things-factory/worksheet-base 4.3.137 → 4.3.138

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

@@ -2,7 +2,7 @@ import { EntityManager, Equal, getConnection, In, IsNull, Not } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
-import { Product, ProductDetail } from '@things-factory/product-base'
+import { Product, ProductDetail, ProductBarcode } from '@things-factory/product-base'
 import {
   GenerateBatchPickInfo,
   ORDER_INVENTORY_STATUS,
@@ -28,12 +28,13 @@ import {
   Location,
   LOCATION_TYPE,
   Tote,
-  TOTE_STATUS
+  TOTE_STATUS,
+  generateInventoryHistory
 } from '@things-factory/warehouse-base'
 
 import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
 import { Worksheet, WorksheetDetail } from '../../entities'
-import { generateInventoryHistory, WorksheetNoGenerator } from '../../utils'
+import { WorksheetNoGenerator } from '../../utils'
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 
 export class PickingWorksheetController extends VasWorksheetController {
@@ -213,7 +214,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       if (vasWorksheet) {
         await this.activateVAS(vasWorksheet.name, vasWorksheet.worksheetDetails)
       }
-    } catch (e) { }
+    } catch (e) {}
 
     const pendingSplitOIs: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
       where: { domain: this.domain, releaseGood, status: ORDER_INVENTORY_STATUS.PENDING_SPLIT }
@@ -428,11 +429,8 @@ export class PickingWorksheetController extends VasWorksheetController {
         .innerJoinAndSelect('oi.inventory', 'inv')
         .leftJoinAndSelect('oi.orderProduct', 'op')
         .innerJoinAndSelect('oi.product', 'prd')
-        .leftJoinAndSelect(
-          'prd.productDetails',
-          'pd',
-          'pd.product_id = oi.product_id AND pd.deleted_at is null AND pd.packing_type = oi.packing_type AND pd.packing_size = oi.packing_size AND pd.uom = oi.uom'
-        )
+        .innerJoinAndSelect('oi.productDetail', 'pd')
+        .innerJoinAndSelect('pd.productBarcodes', 'pb')
         .where('wd.name = :name', { name: worksheetDetailName })
         .andWhere('wd.domain_id = :domainId', { domainId: this.domain.id })
         .andWhere('wd.type = :type', { type: worksheetType })
@@ -441,17 +439,35 @@ export class PickingWorksheetController extends VasWorksheetController {
         .getOne()
 
       //validation to check matching worksheet detail based on name
-      if (!worksheetDetail || !worksheetDetail.targetInventory)
-        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName))
+      if (!worksheetDetail) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName))
+
+      const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
+      let targetInventory: OrderInventory = worksheetDetail.targetInventory
+      let targetProduct: OrderProduct = targetInventory.orderProduct
+      const product: Product = targetInventory.product
+      const matchProductBarcode: ProductBarcode = await this.trxMgr.getRepository(ProductBarcode).findOne({
+        where: { gtin: productBarcode },
+        relations: ['productDetail']
+      })
+      const productDetail: ProductDetail = targetInventory.productDetail
+      const productBarcodes: [ProductBarcode] = productDetail.productBarcodes
+      let inventory: Inventory = targetInventory.inventory
+      let bizplace: Bizplace = worksheetDetail.worksheet.bizplace
+      let pickedUomValue = pickedQty * productDetail.uomValue
+      let matchingProduct
 
       //validation to prevent duplicated picking
-      if (worksheetDetail?.targetInventory?.status != ORDER_INVENTORY_STATUS.PICKING)
+      if (targetInventory?.status != ORDER_INVENTORY_STATUS.PICKING)
         throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`))
 
-      let matchingProduct = await this.getDirectQty(
+      if (!productBarcodes.find(itm => itm.gtin == productBarcode) && product?.isRequireSerialNumberScanningOutbound) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+      }
+
+      matchingProduct = await this.getDirectQty(
         {
-          ...worksheetDetail?.targetInventory?.product?.productDetails[0],
-          product: worksheetDetail?.targetInventory?.product
+          ...productDetail,
+          product: targetInventory?.product
         },
         productBarcode,
         pickedQty
@@ -461,7 +477,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
       pickedQty = matchingProduct.qty
-      let pickedUomValue = matchingProduct.uomValue
+      pickedUomValue = matchingProduct.uomValue
 
       //validation to prevent over release
       if (
@@ -471,15 +487,24 @@ export class PickingWorksheetController extends VasWorksheetController {
       )
         throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
 
-      const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
+      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
 
-      let targetInventory: OrderInventory = worksheetDetail.targetInventory
-      let targetProduct: OrderProduct = targetInventory.orderProduct
-      let inventory: Inventory = targetInventory.inventory
-      let bizplace: Bizplace = worksheetDetail.worksheet.bizplace
-      const product: Product = targetInventory.product
+      // // search for matching product barcode
+      // const productDetails: ProductDetail[] = product?.productDetails.filter(detail => !detail.deletedAt)
+      // // scannedProductDetail can be child or gtin
+      // const scannedProductDetail: ProductDetail = productDetails.find(detail => detail.gtin == productBarcode)
+      // if (!scannedProductDetail) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
-      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
+      // // case for scanning parent packing type, packing size
+      // // when scannedProductDetail id is not the same as productDetail id, then it's not child gtin, proceed to get child qty
+      // if (scannedProductDetail.id !== productDetail.id && !product?.isRequireSerialNumberScanningOutbound) {
+      //   let childQty = await this.getChildQty(productDetails, productBarcode, productDetail, scannedProductDetail)
+      //   pickedQty *= childQty
+      // }
+
+      // if (pickedQty + targetInventory.pickedQty > releaseQty) {
+      //   throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
+      // }
 
       // for required outbound serial number scanning
       if (product?.isRequireSerialNumberScanningOutbound) {
@@ -527,6 +552,7 @@ export class PickingWorksheetController extends VasWorksheetController {
           inventoryItem.outboundOrderId = releaseGood.id
           inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
           inventoryItem.product = product
+          inventoryItem.productDetail = productDetail
           inventoryItem.inventory = inventory
           inventoryItem.domain = this.domain
 
@@ -692,13 +718,15 @@ export class PickingWorksheetController extends VasWorksheetController {
           'targetInventory.orderProduct',
           'targetInventory.inventory',
           'targetInventory.inventory.location',
-          'targetInventory.product'
+          'targetInventory.product',
+          'targetInventory.productDetail'
         ]
       )
 
       const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
       let targetInventory: OrderInventory = worksheetDetail.targetInventory
       const product: Product = targetInventory.product
+      const productDetail: ProductDetail = targetInventory.productDetail
       let inventory: Inventory = targetInventory.inventory
       let targetProduct: OrderProduct = targetInventory.orderProduct
       let bizplace: Bizplace = worksheetDetail.worksheet.bizplace
@@ -728,13 +756,13 @@ export class PickingWorksheetController extends VasWorksheetController {
         })
 
         let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
-          where: { domain: this.domain, serialNumber: serialNumber, product },
-          relations: ['product', 'inventory']
+          where: { domain: this.domain, serialNumber: serialNumber, productDetail },
+          relations: ['product', 'productDetail', 'inventory']
         })
 
         let scannedPalletIdInventory: Inventory = await this.trxMgr
           .getRepository(Inventory)
-          .findOne({ where: { domain: this.domain, palletId }, relations: ['product'] })
+          .findOne({ where: { domain: this.domain, palletId }, relations: ['productDetail'] })
 
         if (foundSerialNumber) {
           if (foundSerialNumber.outboundOrderId) {
@@ -761,6 +789,7 @@ export class PickingWorksheetController extends VasWorksheetController {
           inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
           inventoryItem.outboundOrderId = releaseGood.id
           inventoryItem.product = product
+          inventoryItem.productDetail = productDetail
           inventoryItem.inventory = scannedPalletIdInventory
           inventoryItem.domain = this.domain
 
@@ -786,8 +815,7 @@ export class PickingWorksheetController extends VasWorksheetController {
             )
           } else if (
             scannedPalletIdInventory.batchId == inventory.batchId &&
-            scannedPalletIdInventory.product.id == product.id &&
-            scannedPalletIdInventory.product.packingType == product.packingType
+            scannedPalletIdInventory.productDetail.id == productDetail.id
           ) {
             //if replacement order inventory does not exist
             await this.serialNumberReplacement(
@@ -795,6 +823,7 @@ export class PickingWorksheetController extends VasWorksheetController {
               scannedPalletIdInventory,
               releaseGood,
               product,
+              productDetail,
               worksheetDetail,
               foundSerialNumber
             )
@@ -970,6 +999,8 @@ export class PickingWorksheetController extends VasWorksheetController {
         'worksheetDetails.targetInventory.releaseGood',
         'worksheetDetails.targetInventory.inventory',
         'worksheetDetails.targetInventory.inventory.location',
+        'worksheetDetails.targetInventory.productDetail',
+        'worksheetDetails.targetInventory.productDetail.product',
         'worksheetDetails.targetInventory.product',
         'worksheetDetails.targetInventory.product.productDetails',
         'worksheetDetails.targetInventory.product.productDetails.childProductDetail'
@@ -977,49 +1008,51 @@ export class PickingWorksheetController extends VasWorksheetController {
     })
 
     const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-    const product: Product = worksheetDetails
-      .map((wsd: WorksheetDetail) => wsd.targetInventory.product)
-      .find((product: Product) => product.id === inventory.product.id)
+    const productDetail: ProductDetail = worksheetDetails
+      .map(wsd => wsd.targetInventory.productDetail)
+      .find(productDetail => productDetail.id === inventory.productDetail.id)
+
+    const product: Product = productDetail.product
 
     const batchId: string = inventory.batchId
-    const packingType: string = inventory.packingType
-    const packingSize: number = inventory.packingSize
     let pickedQty: number = pickingQty ? pickingQty : 1
+    let matchingProduct
 
     const targetInventories: OrderInventory[] = worksheetDetails
       .map((wsd: WorksheetDetail) => wsd.targetInventory)
       .filter(
         (targetInventory: OrderInventory) =>
           targetInventory.batchId === batchId &&
-          targetInventory.packingType === packingType &&
           targetInventory.inventory.cartonId === cartonId &&
-          targetInventory.product.id === product.id
+          targetInventory.productDetail.id === productDetail.id
       )
 
-    // search for matching product barcode
-    const productDetails: ProductDetail[] = product?.productDetails.filter(detail => !detail.deletedAt)
-    const isMatchingBarcode: boolean = productDetails.map(detail => detail.gtin).includes(productBarcode)
-    if (!isMatchingBarcode) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(`GTIN (${productBarcode})`))
-
-    // case for scanning parent packing type, packing size
-    const foundProductDetail: ProductDetail = productDetails.find(
-      (detail: ProductDetail) =>
-        detail.gtin === productBarcode && detail.packingType === packingType && detail.packingSize == packingSize
+    matchingProduct = await this.getDirectQty(
+      {
+        ...productDetail,
+        product
+      },
+      productBarcode,
+      pickedQty
     )
 
-    if (!foundProductDetail) {
-      const roProductDetail: ProductDetail = productDetails.find(
-        (parentDetail: ProductDetail) =>
-          parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
-      )
-      if (!roProductDetail)
-        throw new Error(
-          this.ERROR_MSG.FIND.NO_RESULT(`Packing Type ( ${packingType}) or Packing Size (${packingSize})`)
-        )
+    //validate matching product details based on scanned barcode
+    if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
-      let childQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
-      pickedQty *= childQty
-    }
+    pickedQty = matchingProduct.qty
+
+    // // search for matching product barcode
+    // const productDetails: ProductDetail[] = product?.productDetails.filter(detail => !detail.deletedAt)
+    // // scannedProductDetail can be child or gtin
+    // const scannedProductDetail: ProductDetail = productDetails.find(detail => detail.gtin == productBarcode)
+    // if (!scannedProductDetail) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+
+    // // case for scanning parent packing type, packing size
+    // // when scannedProductDetail id is not the same as productDetail id, then it's not child gtin, proceed to get child qty
+    // if (scannedProductDetail.id !== productDetail.id) {
+    //   let childQty = await this.getChildQty(productDetails, productBarcode, productDetail, scannedProductDetail)
+    //   pickedQty *= childQty
+    // }
 
     const sumOfReleaseQty: number = targetInventories
       .map((oi: OrderInventory) => oi.releaseQty)
@@ -1404,7 +1437,7 @@ export class PickingWorksheetController extends VasWorksheetController {
         await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.ild)
         await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
       }
-    } catch (e) { }
+    } catch (e) {}
   }
 
   private async serialNumberReplacement(
@@ -1412,6 +1445,7 @@ export class PickingWorksheetController extends VasWorksheetController {
     scannedPalletIdInventory,
     releaseGood,
     product,
+    productDetail,
     worksheetDetail,
     foundSerialNumber
   ) {
@@ -1476,6 +1510,7 @@ export class PickingWorksheetController extends VasWorksheetController {
         releaseUomValue: newOrderInventoryReleaseUomValue,
         pickedQty: 1,
         product,
+        productDetail,
         inventory: scannedPalletIdInventory,
         creator: this.user,
         updater: this.user
@@ -1519,7 +1554,7 @@ export class PickingWorksheetController extends VasWorksheetController {
         await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.id)
         await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
       }
-    } catch (e) { }
+    } catch (e) {}
   }
 
   private async toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace) {

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

@@ -1,6 +1,6 @@
 import { In, IsNull } from 'typeorm'
 
-import { Product, ProductDetail } from '@things-factory/product-base'
+import { Product, ProductDetail, ProductBarcode } from '@things-factory/product-base'
 import {
   ORDER_INVENTORY_STATUS,
   ORDER_STATUS,
@@ -85,9 +85,8 @@ export class SortingWorksheetController extends VasWorksheetController {
       .innerJoinAndSelect('worksheet.worksheetDetails', 'worksheetDetails')
       .innerJoinAndSelect('worksheetDetails.targetInventory', 'targetInventory')
       .innerJoinAndSelect('targetInventory.product', 'product')
-      .innerJoinAndSelect('product.productDetails', 'productDetails')
-      .leftJoinAndSelect('productDetails.childProductDetail', 'childProductDetail')
       .leftJoinAndSelect('targetInventory.orderProduct', 'orderProduct')
+      .leftJoinAndSelect('targetInventory.productDetail', 'productDetail')
       .leftJoinAndSelect('targetInventory.bizplace', 'bizplace')
       .leftJoinAndSelect('targetInventory.inventory', 'inventory')
       .leftJoinAndSelect('targetInventory.releaseGood', 'releaseGood')
@@ -96,7 +95,6 @@ export class SortingWorksheetController extends VasWorksheetController {
       .andWhere('worksheet.type = :type', { type: WORKSHEET_TYPE.SORTING })
       .andWhere('worksheet.status = :status', { status: WORKSHEET_STATUS.EXECUTING })
       .andWhere('releaseGood.name = :rg', { rg: releaseGoodNo })
-      .andWhere('productDetails.gtin = :gtin', { gtin: productBarcode })
       .getOne()
 
     if (!worksheet) {
@@ -105,17 +103,15 @@ export class SortingWorksheetController extends VasWorksheetController {
 
     const worksheetDetails = worksheet.worksheetDetails
     const orderInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
-    const productDetails: ProductDetail[] = orderInventories[0].product.productDetails
-    const scannedProductDetail: ProductDetail = productDetails.find(itm => itm.gtin == productBarcode)
+    const scanProductBarcode: ProductBarcode = await this.trxMgr.getRepository(ProductBarcode).findOne({
+      where: { gtin: productBarcode },
+      relations: ['productDetail', 'productDetail.childProductDetail']
+    })
+    const scannedProductDetail: ProductDetail = scanProductBarcode.productDetail
     const scannedChildProductDetail: ProductDetail = scannedProductDetail.childProductDetail
 
     //find matching order inventories based on scanned product detail
-    let matchingOIs = orderInventories.filter(
-      oi =>
-        oi.packingType == scannedProductDetail.packingType &&
-        oi.packingSize == scannedProductDetail.packingSize &&
-        oi.uom == scannedProductDetail.uom
-    )
+    let matchingOIs = orderInventories.filter(oi => oi.productDetail.id == scannedProductDetail.id)
 
     let productDetail = scannedProductDetail
 
@@ -125,12 +121,7 @@ export class SortingWorksheetController extends VasWorksheetController {
       if (!scannedChildProductDetail) {
         throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
       }
-      matchingOIs = orderInventories.filter(
-        oi =>
-          oi.packingType == scannedChildProductDetail.packingType &&
-          oi.packingSize == scannedChildProductDetail.packingSize &&
-          oi.uom == scannedChildProductDetail.uom
-      )
+      matchingOIs = orderInventories.filter(oi => oi.productDetail.id == scannedChildProductDetail.id)
 
       productDetail = scannedChildProductDetail
 
@@ -295,7 +286,8 @@ export class SortingWorksheetController extends VasWorksheetController {
         'worksheetDetails.targetInventory.inventory.product',
         'worksheetDetails.targetInventory.inventory.product.productDetails',
         'worksheetDetails.targetInventory.inventory.product.productDetails.product',
-        'worksheetDetails.targetInventory.releaseGood'
+        'worksheetDetails.targetInventory.releaseGood',
+        'worksheetDetails.targetInventory.productDetail'
       ]
     })
 
@@ -315,6 +307,7 @@ export class SortingWorksheetController extends VasWorksheetController {
           const inventory: Inventory = matchingOI.inventory
           const releaseGood: ReleaseGood = matchingOI.releaseGood
           const product: Product = matchingOI.inventory.product
+          const productDetail: ProductDetail = matchingOI.productDetail
           const packingType: string = matchingOI.packingType
           const packingSize: number = matchingOI.packingSize
 
@@ -324,8 +317,7 @@ export class SortingWorksheetController extends VasWorksheetController {
             }
 
             let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
-              where: { domain: this.domain, serialNumber: serialNumber, product },
-              relations: ['product', 'inventory']
+              where: { domain: this.domain, serialNumber: serialNumber, productDetail }
             })
 
             if (foundSerialNumber) {
@@ -349,6 +341,7 @@ export class SortingWorksheetController extends VasWorksheetController {
               inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
               inventoryItem.outboundOrderId = releaseGood.id
               inventoryItem.product = product
+              inventoryItem.productDetail = productDetail
               inventoryItem.inventory = inventory
               inventoryItem.domain = this.domain
 

package/server/controllers/vas/vas-worksheet-controller.ts

@@ -22,7 +22,8 @@ import {
   InventoryNoGenerator,
   Location,
   LOCATION_TYPE,
-  Warehouse
+  Warehouse,
+  generateInventoryHistory
 } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
@@ -36,7 +37,6 @@ import {
   RefOrderType
 } from '../../graphql/resolvers/worksheet/vas-transactions'
 import { PackingUnits } from '../../graphql/resolvers/worksheet/vas-transactions/interfaces/repackaging'
-import { generateInventoryHistory } from '../../utils'
 import { ReferenceOrderType, WorksheetController } from '../worksheet-controller'
 
 type CompleteTransactionType = (trxMgr: EntityManager, orderVas: OrderVas, user: User) => Promise<void>

package/server/controllers/worksheet-controller.ts

@@ -19,11 +19,17 @@ import {
   VasOrder
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS, InventoryItem, Pallet } from '@things-factory/warehouse-base'
+import {
+  Inventory,
+  INVENTORY_STATUS,
+  InventoryItem,
+  Pallet,
+  generateInventoryHistory
+} from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../constants'
 import { Worksheet, WorksheetDetail } from '../entities'
-import { generateInventoryHistory, WorksheetNoGenerator } from '../utils'
+import { WorksheetNoGenerator } from '../utils'
 
 export type ReferenceOrderType = ArrivalNotice | ReleaseGood | VasOrder | InventoryCheck | DeliveryOrder | ReturnOrder
 export type OrderTargetTypes = OrderProduct | OrderInventory | OrderVas
@@ -590,8 +596,7 @@ export class WorksheetController {
     return worksheet
   }
 
-  // @chernhaoee I think the naming of this function is not proper. Seems like it should be something like "updateLoadingWorksheet" since the logic targets only Loading Order Target
-  async updateWorksheet(
+  async updateLoadWorksheet(
     worksheetType: string,
     refOrder: ReferenceOrderType,
     worksheet: Worksheet,
@@ -1006,11 +1011,9 @@ export class WorksheetController {
   async getChildQty(
     productDetails: ProductDetail[],
     productBarcode: string,
-    orderProductDetail: ProductDetail
+    orderProductDetail: ProductDetail,
+    scannedProductDetail: ProductDetail
   ): Promise<number> {
-    const scannedProductDetail: ProductDetail = productDetails.find(
-      (productDetail: ProductDetail) => productDetail.gtin === productBarcode
-    )
     let hasChildRelation: boolean = Boolean(scannedProductDetail?.childProductDetail)
     let hasMatchingChild: boolean
     let childQty: number
@@ -1061,16 +1064,18 @@ export class WorksheetController {
         WITH RECURSIVE cte as (
         select * from (
           select pd2.product_id as "productId", pd2.id, pd2.packing_size as "packingSize",
-          pd2.packing_type as "packingType", pd2.uom as "uom", (pd2.uom_value * $2::float) as "uomValue", $2::float as "qty", pd2.gtin            
+          pd2.packing_type as "packingType", pd2.uom as "uom", (pd2.uom_value * $2::float) as "uomValue", $2::float as "qty", pb.gtin            
           from product_details pd 
           inner join product_details pd2 on pd.product_id = pd2.product_id and pd.packing_type = pd2.packing_type and pd.packing_size = pd2.packing_size and pd.uom = pd2.uom
+          inner join product_barcodes pb on pb.product_detail_id = pd2.id
           where pd.id = $1
           ) as dt
           union all
           select pd.product_id as "productId", pd.id, pd.packing_size as "packingSize",
           pd.packing_type as "packingType", pd.uom,
-          dt1.qty * pd.packing_size * pd.uom_value as "uomValue", dt1.qty * pd.packing_size as "qty", pd.gtin
+          dt1.qty * pd.packing_size * pd.uom_value as "uomValue", dt1.qty * pd.packing_size as "qty", pb.gtin
           from product_details pd
+          inner join product_barcodes pb on pb.product_detail_id = pd.id
           inner join cte dt1 on dt1.id = pd.child_product_detail_id 
           where pd.deleted_at is null
         )

package/server/entities/index.ts

@@ -1,8 +1,8 @@
+import { WarehouseBizplaceOnhandInventory } from './warehouse-bizplace-onhand-inventory'
 import { Worksheet } from './worksheet'
 import { WorksheetDetail } from './worksheet-detail'
 import { WorksheetMovement } from './worksheet-movement'
-import { WarehouseBizplaceOnhandInventory } from './warehouse-bizplace-onhand-inventory'
 
 export const entities = [Worksheet, WorksheetDetail, WorksheetMovement, WarehouseBizplaceOnhandInventory]
 
-export { Worksheet, WorksheetDetail, WorksheetMovement }
+export { WarehouseBizplaceOnhandInventory, Worksheet, WorksheetDetail, WorksheetMovement }

package/server/entities/warehouse-bizplace-onhand-inventory.ts

@@ -2,55 +2,23 @@ import { ViewColumn, ViewEntity } from 'typeorm'
 
 @ViewEntity({
   expression: `  
-  select d.name as "domainName", b.name as "bizplaceName", src.* from (
-    WITH oi as (
-      select
-        oi.domain_id,
-        oi.bizplace_id,
-        SUM(oi.release_qty) AS release_qty,
-        SUM(oi.release_uom_value) AS release_uom_value,
-        oi.batch_id,
-        oi.batch_id_ref,
-        oi.product_id,
-        oi.packing_type,
-        oi.packing_size,
-        oi.uom
-      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.batch_id NOTNULL
-        AND oi.product_id NOTNULL
-        AND oi.packing_type NOTNULL
-        AND oi.packing_size NOTNULL
-        AND oi.inventory_id IS NULL
-      GROUP BY
-        oi.domain_id,
-        oi.bizplace_id,
-        oi.batch_id,
-        oi.batch_id_ref,
-        oi.product_id,
-        oi.packing_type,
-        oi.packing_size,
-        oi.uom
-    ) 
+  select d.name as "domain_name", b.name as "bizplace_name", src.* from (
     -- SINGLE ITEM INVENTORY QUERY
     select
-    i.domain_id as "domainId",
-    i.bizplace_id as "bizplaceId",
-    i.packing_type as "packingType",
-    i.packing_size as "packingSize",
+    i.domain_id as "domain_id",
+    i.bizplace_id as "bizplace_id",
+    i.packing_type as "packing_type",
+    i.packing_size as "packing_size",
     i.uom,
-    i.product_id as "productId",
-    null as "productBundleId",
-    COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) AS "remainQty",
-    COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)), 0) AS "remainUomValue",
+    i.product_id as "product_id",
+    null as "product_bundle_id",
+    COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0))) AS "remain_qty",
+    COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0))) AS "remain_uom_value",
     COALESCE(sum(COALESCE(i.qty, 0::double precision))) AS "qty",
-    COALESCE(sum(COALESCE(i.uom_value, 0::double precision))) AS "uomValue",
-    'SINGLE' AS "groupType"
+    COALESCE(sum(COALESCE(i.uom_value, 0::double precision))) AS "uom_value",
+    'SINGLE' AS "group_type"
     FROM inventories i
     INNER JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id AND l2.type NOT IN ('QUARANTINE', 'RESERVE')
-    LEFT JOIN oi ON i.batch_id = oi.batch_id AND i.product_id = oi.product_id AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
     WHERE i.status = 'STORED'
     GROUP by
       i.domain_id,
@@ -62,29 +30,28 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     union all
     -- BUNDLE ITEM INVENTORY QUERY
     SELECT 
-    pbs.domain_id as "domainId",
-    pbs.bizplace_id as "bizplaceId",
-    pb.packing_type as "packingType", 
-    pb.packing_size as "packingSize",
+    pbs.domain_id as "domain_id",
+    pbs.bizplace_id as "bizplace_id",
+    pb.packing_type as "packing_type", 
+    pb.packing_size as "packing_size",
     'UNIT' AS "uom", 
-    null as "productId",
-    pb.id AS "productBundleId",
-    COALESCE(MIN(FLOOR(pbs."availableQty")),0) AS "remainQty", 
-    COALESCE(MIN(FLOOR(pbs."availableUomValue")),0) AS "remainUomValue",
+    null as "product_id",
+    pb.id AS "product_bundle_id",
+    COALESCE(MIN(FLOOR(pbs."available_qty")),0) AS "remain_qty", 
+    COALESCE(MIN(FLOOR(pbs."available_uom_value")),0) AS "remain_uom_value",
     COALESCE(MIN(FLOOR(pbs."qty")), 0::double precision) AS "qty",
-    COALESCE(MIN(FLOOR(pbs."uomValue")), 0::double precision) AS "uomValue",
-    'BUNDLE' AS "groupType"
+    COALESCE(MIN(FLOOR(pbs."uom_value")), 0::double precision) AS "uom_value",
+    'BUNDLE' AS "group_type"
     FROM product_bundles pb
     INNER JOIN (
       SELECT i.domain_id, i.bizplace_id, pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
-      (SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
-      (SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue",
+      (SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0))) / min(pbs.bundle_qty) AS "available_qty",
+      (SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0))) / min(pbs.bundle_qty)  AS "available_uom_value",
       (sum(COALESCE(i.qty, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "qty",
-      (sum(COALESCE(i.uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "uomValue"
+      (sum(COALESCE(i.uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "uom_value"
       FROM product_bundle_settings pbs 
       LEFT JOIN inventories i ON i.product_id = pbs.product_id AND i.status = 'STORED'
-      INNER JOIN locations l ON i.location_id = l.id AND i.domain_id = l.domain_id AND l.type NOT IN ('QUARANTINE', 'RESERVE')    
-      LEFT JOIN oi ON oi.product_id = i.product_id
+      INNER JOIN locations l ON i.location_id = l.id AND i.domain_id = l.domain_id AND l.type NOT IN ('QUARANTINE', 'RESERVE') 
       GROUP by
         i.domain_id, 
         i.bizplace_id,
@@ -101,14 +68,13 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     pb.id
   )
   AS src 
-  inner join domains d on d.id = src."domainId"
-  inner join bizplaces b on b.id = src."bizplaceId"
-  where src."remainQty" >= 0
+  inner join domains d on d.id = src."domain_id"
+  inner join bizplaces b on b.id = src."bizplace_id"
+  where src."remain_qty" >= 0
   and src."qty" > 0
-  order by src."domainId"
+  order by src."domain_id"
   `
 })
-
 export class WarehouseBizplaceOnhandInventory {
   @ViewColumn()
   domainName: string