@things-factory/worksheet-base 4.3.367 → 4.3.369

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

@@ -5,7 +5,7 @@ import {
   getManager,
   In,
   IsNull,
-  Not
+  Not,
 } from 'typeorm'
 
 import { ApplicationType } from '@things-factory/auth-base'
@@ -67,7 +67,8 @@ import {
 import { SellercraftController } from '../../controllers'
 import {
   Worksheet,
-  WorksheetDetail
+  WorksheetDetail,
+  ActiveWorksheetPickingView
 } from '../../entities'
 import {
   inventoriesByStrategy,
@@ -423,6 +424,8 @@ export class PickingWorksheetController extends VasWorksheetController {
       )
     } catch (error) {
       throw error
+    } finally {
+      ActiveWorksheetPickingView.refreshView()
     }
     return worksheets
   }
@@ -715,135 +718,109 @@ export class PickingWorksheetController extends VasWorksheetController {
   ): Promise<WorksheetDetail> {
     try {
       //find existing worksheet detail
-      let worksheetDetail: WorksheetDetail = await this.trxMgr
-        .getRepository(WorksheetDetail)
-        .createQueryBuilder('wd')
-        .innerJoinAndSelect('wd.worksheet', 'ws')
-        .innerJoinAndSelect('ws.bizplace', 'bz')
-        .innerJoinAndSelect('wd.targetInventory', 'oi')
-        .innerJoinAndSelect('oi.releaseGood', 'rg')
-        .innerJoinAndSelect('oi.inventory', 'inv')
-        .leftJoinAndSelect('oi.orderProduct', 'op')
-        .innerJoinAndSelect('oi.product', 'prd')
-        .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 })
-        .andWhere('wd.status = :status', { status: WORKSHEET_STATUS.EXECUTING })
-        .andWhere('inv.carton_id = :cartonId', { cartonId: cartonId })
-        .getOne()
-
-      //validation to check matching worksheet detail based on name
-      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
+      let worksheetDetailFilters = [
+        { query: 'mawp."worksheetDetailName"', value: worksheetDetailName },
+        { query: 'mawp."domainId"', value: this.domain.id },
+        { query: 'mawp."inventoryCartonId"', value: cartonId }
+        // { query: 'mawp."gtin"', value: productBarcode }
+      ]
 
-      // validation to prevent picking if the inventory is involved in cycle count
-      let inventoryCheckItem: InventoryCheckItem = await this.trxMgr.getRepository(InventoryCheckItem).findOne({
-        where: {
-          domain: this.domain,
-          inventory: inventory.id,
-          status: In([
-            INVENTORY_CHECK_ITEM_STATUS.PENDING,
-            INVENTORY_CHECK_ITEM_STATUS.INSPECTING,
-            INVENTORY_CHECK_ITEM_STATUS.INSPECTED,
-            INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY,
-            INVENTORY_CHECK_ITEM_STATUS.GROUP_NOT_TALLY,
-            INVENTORY_CHECK_ITEM_STATUS.MISSING,
-            INVENTORY_CHECK_ITEM_STATUS.ADDED
-          ])
-        }
+      let worksheetDetailRaw = await this.trxMgr.query(`
+        select * from active_worksheet_picking_views mawp
+        where 1 = 1
+        and
+        ${worksheetDetailFilters.map((data, idx) => {
+        return `${data.query} = $${idx + 1}`
+      }).join(' AND ')}
+      `, worksheetDetailFilters.map((data, idx) => {
+        return data.value
       })
+      )
 
-      if (inventoryCheckItem) {
+      //validation to check matching worksheet detail based on name
+      if ((worksheetDetailRaw.length < 1)) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName))
+
+      let worksheetDetailInfos: ActiveWorksheetPickingView = worksheetDetailRaw[0]
+      let targetInventory: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({ where: { id: worksheetDetailInfos.orderInventoryId } })
+      const inventory: Inventory = await this.trxMgr.getRepository(Inventory).findOne({ where: { id: worksheetDetailInfos.inventoryId } })
+
+      let targetProduct = { id: worksheetDetailInfos.targetProductId }
+      let bizplace: Partial<Bizplace> = { id: worksheetDetailInfos.bizplaceId }
+      const releaseGood: Partial<ReleaseGood> = { id: worksheetDetailInfos.releaseGoodId }
+
+      let matchingProduct, pickedUomValue
+
+      // // validation to prevent picking if the inventory is involved in cycle count
+      const inventoryCheckStatus = new Set([
+        INVENTORY_CHECK_ITEM_STATUS.PENDING,
+        INVENTORY_CHECK_ITEM_STATUS.INSPECTING,
+        INVENTORY_CHECK_ITEM_STATUS.INSPECTED,
+        INVENTORY_CHECK_ITEM_STATUS.NOT_TALLY,
+        INVENTORY_CHECK_ITEM_STATUS.GROUP_NOT_TALLY,
+        INVENTORY_CHECK_ITEM_STATUS.MISSING,
+        INVENTORY_CHECK_ITEM_STATUS.ADDED
+      ]);
+      if (inventoryCheckStatus.has(worksheetDetailInfos.inventoryCheckItemStatus)) {
         throw new Error(
           `Inventory currently involved in an ongoing cycle count. Please complete the cycle count to proceed with picking.`
         )
       }
 
       //validation to prevent duplicated picking
-      if (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`))
 
-      if (!productBarcodes.find(itm => itm.gtin == productBarcode) && product?.isRequireSerialNumberScanningOutbound) {
-        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
-      }
+      // if (!productBarcodes.find(itm => itm.gtin == productBarcode) && product?.isRequireSerialNumberScanningOutbound) {
+      //   throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+      // }
+      matchingProduct = worksheetDetailRaw.find(x => x.gtin === productBarcode)
+      if (matchingProduct) {
+        pickedUomValue = pickedQty * (matchingProduct.uomValue || 1)
+      } else {
+        matchingProduct = await this.getDirectQty(
+          { id: worksheetDetailInfos.productDetailId },
+          productBarcode,
+          pickedQty
+        )
 
-      matchingProduct = await this.getDirectQty(
-        {
-          ...productDetail,
-          product: targetInventory?.product
-        },
-        productBarcode,
-        pickedQty
-      )
+        //validate matching product details based on scanned barcode
+        if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
-      //validate matching product details based on scanned barcode
-      if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+        pickedQty = matchingProduct.qty
+        pickedUomValue = matchingProduct.uomValue
+      }
 
-      pickedQty = matchingProduct.qty
-      pickedUomValue = matchingProduct.uomValue
+      // //validation to prevent over release
+      if (!targetInventory)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `inventory not assigned`))
 
-      //validation to prevent over release
+      // //validation to prevent over release
       if (
-        !worksheetDetail?.targetInventory ||
-        worksheetDetail?.targetInventory.inventory.qty < 1 ||
-        pickedQty + (worksheetDetail.targetInventory?.pickedQty || 0) > worksheetDetail.targetInventory.releaseQty
+        inventory.qty < 1 || pickedQty + (targetInventory?.pickedQty || 0) > targetInventory.releaseQty
       )
         throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
 
       targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
 
-      // // 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 && !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) {
+      if (worksheetDetailInfos?.productIsRequireSerialNumberScanningOutbound) {
         if (!serialNumber || serialNumber == '') {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
         }
 
         let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
           where: {
-            inventory,
+            inventory: { id: worksheetDetailInfos.inventoryId },
             status: Not(In([INVENTORY_STATUS.TERMINATED, INVENTORY_STATUS.PICKED]))
           }
         })
 
         let foundSerialNumber: InventoryItem = await this.trxMgr
           .getRepository(InventoryItem)
-          .findOne({ where: { domain: this.domain, serialNumber: serialNumber, product } })
+          .findOne({ where: { domain: this.domain, serialNumber: serialNumber, product: { id: worksheetDetailInfos.productId } } })
 
         if (foundSerialNumber) {
-          if (foundSerialNumber.inventoryId !== inventory.id) {
+          if (foundSerialNumber.inventoryId !== worksheetDetailInfos.inventoryId) {
             throw new Error('Serial Number scanned is in another inventory')
           }
 
@@ -859,7 +836,7 @@ export class PickingWorksheetController extends VasWorksheetController {
 
           foundSerialNumber.status = INVENTORY_STATUS.PICKING
           foundSerialNumber.updater = this.user
-          foundSerialNumber.outboundOrderId = releaseGood.id
+          foundSerialNumber.outboundOrderId = worksheetDetailInfos.releaseGoodId
 
           await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
         } else {
@@ -871,11 +848,11 @@ export class PickingWorksheetController extends VasWorksheetController {
           inventoryItem.name = InventoryNoGenerator.inventoryItemName()
           inventoryItem.serialNumber = serialNumber
           inventoryItem.status = INVENTORY_STATUS.PICKING
-          inventoryItem.outboundOrderId = releaseGood.id
+          inventoryItem.outboundOrderId = worksheetDetailInfos.releaseGoodId
           inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
-          inventoryItem.product = product
-          inventoryItem.productDetail = productDetail
-          inventoryItem.inventory = inventory
+          inventoryItem.product = { id: worksheetDetailInfos.productId }
+          inventoryItem.productDetail = { id: worksheetDetailInfos.productDetailId }
+          inventoryItem.inventory = { id: worksheetDetailInfos.inventoryId }
           inventoryItem.domain = this.domain
 
           await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
@@ -900,11 +877,8 @@ export class PickingWorksheetController extends VasWorksheetController {
         updater: this.user,
         pickedBy: this.user.name,
         pickedByUser: this.user,
-        pickedAt: new Date()
-      }
-
-      if (targetInventory.pickedQty == releaseQty) {
-        updateOiObj['status'] = ORDER_INVENTORY_STATUS.PICKED
+        pickedAt: new Date(),
+        status: () => `case when release_qty = "picked_qty" + ${pickedQty} then '${ORDER_INVENTORY_STATUS.PICKED}' else status end`
       }
 
       if (targetInventory.binLocation) {
@@ -921,85 +895,78 @@ export class PickingWorksheetController extends VasWorksheetController {
         .execute()
 
       if (targetInventory.pickedQty == releaseQty) {
-        //update worksheet details only when line item picking complete
-        await this.trxMgr
-          .getRepository(WorksheetDetail)
-          .createQueryBuilder()
-          .update(WorksheetDetail)
-          .set({
-            status: WORKSHEET_STATUS.DONE,
-            updater: this.user,
-            updatedAt: new Date()
-          })
-          .where('id = :id', { id: worksheetDetail.id })
-          .execute()
-
         getConnection().transaction(async (tx: EntityManager) => {
-          let releaseUomValue = Math.round((pickedUomValue / pickedQty) * releaseQty * 100) / 100
-
-          let updateInvObj = {
-            qty: () => `"qty" - ${releaseQty}`,
-            lockedQty: () => `"locked_qty" - ${releaseQty}`,
-            uomValue: () => `"uom_value" - ${releaseUomValue}`,
-            lockedUomValue: () => `"locked_uom_value" - ${releaseUomValue}`,
-            updater: this.user,
-            updatedAt: new Date()
-          }
-
-          let remainingQty = await tx
-            .getRepository(Inventory)
-            .createQueryBuilder()
-            .update(Inventory)
-            .set(updateInvObj)
-            .where('id = :id', { id: targetInventory.inventory.id })
-            .returning(['qty'])
-            .execute()
-            .then(dt => {
-              return dt.raw[0].qty
-            })
-
-          await generateInventoryHistory(
-            inventory,
-            releaseGood,
-            INVENTORY_TRANSACTION_TYPE.PICKING,
-            -releaseQty,
-            -releaseUomValue,
-            this.user,
-            tx
-          )
-
-          let inventoryItems: InventoryItem = await tx
-            .getRepository(InventoryItem)
-            .find({ where: { outboundOrderId: releaseGood.id } })
+          try {
+            //update worksheet details only when line item picking complete
+            await tx
+              .getRepository(WorksheetDetail)
+              .createQueryBuilder()
+              .update(WorksheetDetail)
+              .set({
+                status: WORKSHEET_STATUS.DONE,
+                updater: this.user,
+                updatedAt: new Date()
+              })
+              .where('id = :id', { id: worksheetDetailInfos.worksheetDetailId })
+              .execute()
 
-          if (inventoryItems.length > 0) {
-            inventoryItems.forEach((itm: InventoryItem) => {
-              itm.status = INVENTORY_STATUS.PICKED
-              itm.updater = this.user
-            })
+            let releaseUomValue = Math.round((pickedUomValue / pickedQty) * releaseQty * 100) / 100
 
-            await tx.getRepository(InventoryItem).save(inventoryItems)
-          }
+            let updateInvObj = {
+              qty: () => `"qty" - ${releaseQty}`,
+              lockedQty: () => `"locked_qty" - ${releaseQty}`,
+              uomValue: () => `"uom_value" - ${releaseUomValue}`,
+              lockedUomValue: () => `"locked_uom_value" - ${releaseUomValue}`,
+              status: () => `case when "qty" - ${releaseQty} <= 0 then '${INVENTORY_STATUS.TERMINATED}' else status end`,
+              updater: this.user,
+              updatedAt: new Date()
+            }
 
-          if (remainingQty === 0) {
             await tx
               .getRepository(Inventory)
               .createQueryBuilder()
               .update(Inventory)
-              .set({ status: INVENTORY_STATUS.TERMINATED })
-              .where('id = :id', { id: targetInventory.inventory.id })
+              .set(updateInvObj)
+              .where('id = :id', { id: worksheetDetailInfos.inventoryId })
+              .returning(['qty'])
               .execute()
+
+            await generateInventoryHistory(
+              inventory,
+              releaseGood,
+              INVENTORY_TRANSACTION_TYPE.PICKING,
+              -releaseQty,
+              -releaseUomValue,
+              this.user,
+              tx
+            )
+
+            let inventoryItems: InventoryItem = await tx
+              .getRepository(InventoryItem)
+              .find({ where: { outboundOrderId: worksheetDetailInfos.releaseGoodId } })
+
+            if (inventoryItems.length > 0) {
+              inventoryItems.forEach((itm: InventoryItem) => {
+                itm.status = INVENTORY_STATUS.PICKED
+                itm.updater = this.user
+              })
+
+              await tx.getRepository(InventoryItem).save(inventoryItems)
+            }
+
+          } catch (error) {
+            throw error
+
           }
         })
       }
 
-      // return worksheet details
-      worksheetDetail = await this.trxMgr
+      let worksheetDetail = await this.trxMgr
         .getRepository(WorksheetDetail)
         .createQueryBuilder('wd')
         .innerJoin('wd.targetInventory', 'oi')
         .innerJoinAndSelect('oi.releaseGood', 'rg')
-        .where('wd.id = :id', { id: worksheetDetail.id })
+        .where('wd.id = :id', { id: worksheetDetailInfos.worksheetDetailId })
         .getOne()
 
       return worksheetDetail

package/server/entities/active-worksheet-picking-view.ts

@@ -0,0 +1,118 @@
+import { ViewColumn, ViewEntity, Index, getConnection, EntityManager } from 'typeorm'
+
+@ViewEntity({
+  materialized: true,
+  expression: `
+  select
+  wd.id AS "worksheetDetailId",
+  wd.name as "worksheetDetailName",
+  w.id as "worksheetId",
+  w.domain_id as "domainId",
+  op.id as "targetProductId",
+  op.product_id as "productId",
+  op.product_detail_id as "productDetailId",
+  op.uom_value as "uomValue",
+  pb.id  as "productBarcodeId",
+  pb.gtin,
+  p.is_require_serial_number_scanning_outbound as "productIsRequireSerialNumberScanningOutbound",
+  oi.release_good_id as "releaseGoodId",
+  oi.id as "orderInventoryId",
+  oi.status as "orderInventoryStatus",
+  oi.bizplace_id as "bizplaceId",
+  i.id as "inventoryId",
+  i.carton_id as "inventoryCartonId",
+  i.status as "inventoryStatus",
+  ici.status as "inventoryCheckItemStatus"
+  FROM worksheet_details wd
+  INNER JOIN worksheets w ON wd.worksheet_id = w.id
+  inner JOIN order_inventories oi ON oi.id = wd.target_inventory_id
+  inner JOIN order_products op ON op.id = oi.order_product_id
+  inner join inventories i on i.id = oi.inventory_id
+  left join inventory_check_items ici on ici.inventory_id = oi.inventory_id
+  inner join products p on p.id = oi.product_id
+  LEFT JOIN product_barcodes pb ON pb.product_detail_id = op.product_detail_id
+  WHERE w.type::text = 'PICKING'::text AND w.status::text = 'EXECUTING'::text
+  ORDER BY w.domain_id, w.bizplace_id, wd.id
+  `
+})
+export class ActiveWorksheetPickingView {
+  static async refreshView() {
+    await getConnection().transaction(async (tx: EntityManager) => {
+      await tx.getRepository(ActiveWorksheetPickingView).query('REFRESH MATERIALIZED VIEW CONCURRENTLY active_worksheet_picking_views')
+        .then(resp => console.log('update active_worksheet_picking_views ok'))
+        .catch(err => console.error('update active_worksheet_picking_views error'))
+    })
+  }
+
+  @Index(
+    'ix_active-worksheet-picking_0',
+    (ActiveWorksheetPickingView: ActiveWorksheetPickingView) => [ActiveWorksheetPickingView.orderInventoryId, ActiveWorksheetPickingView.productBarcodeId],
+    { unique: true }
+  )
+  @Index(
+    'ix_active-worksheet-picking_1',
+    (ActiveWorksheetPickingView: ActiveWorksheetPickingView) => [ActiveWorksheetPickingView.worksheetDetailId]
+  )
+  @Index(
+    'ix_active-worksheet-picking_2',
+    (ActiveWorksheetPickingView: ActiveWorksheetPickingView) => [ActiveWorksheetPickingView.domainId, ActiveWorksheetPickingView.worksheetDetailName]
+  )
+
+  @ViewColumn()
+  worksheetDetailId: string
+
+  @ViewColumn()
+  worksheetDetailName: string
+
+  @ViewColumn()
+  worksheetId: string
+
+  @ViewColumn()
+  domainId: string
+
+  @ViewColumn()
+  bizplaceId: string
+
+  @ViewColumn()
+  targetProductId: string
+
+  @ViewColumn()
+  productId: string
+
+  @ViewColumn()
+  productDetailId: string
+
+  @ViewColumn()
+  uomValue: number
+
+  @ViewColumn()
+  productBarcodeId: string
+
+  @ViewColumn()
+  gtin: string
+
+  @ViewColumn()
+  productIsRequireSerialNumberScanningOutbound: string
+
+  @ViewColumn()
+  releaseGoodId: string
+
+  @ViewColumn()
+  orderInventoryId: string
+
+  @ViewColumn()
+  orderInventoryStatus: string
+
+  @ViewColumn()
+  inventoryId: string
+
+  @ViewColumn()
+  inventoryCartonId: string
+
+  @ViewColumn()
+  inventoryStatus: string
+
+  @ViewColumn()
+  inventoryCheckItemStatus: string
+
+}

package/server/entities/index.ts

@@ -1,3 +1,5 @@
+
+import { ActiveWorksheetPickingView } from './active-worksheet-picking-view'
 import { WarehouseBizplaceOnhandInventory } from './warehouse-bizplace-onhand-inventory'
 import { WarehouseInventoryAssignmentRanking } from './warehouse-inventory-assignment-ranking'
 import { Worksheet } from './worksheet'
@@ -5,6 +7,7 @@ import { WorksheetDetail } from './worksheet-detail'
 import { WorksheetMovement } from './worksheet-movement'
 
 export const entities = [
+  ActiveWorksheetPickingView,
   Worksheet,
   WorksheetDetail,
   WorksheetMovement,
@@ -13,6 +16,7 @@ export const entities = [
 ]
 
 export {
+  ActiveWorksheetPickingView,
   WarehouseBizplaceOnhandInventory,
   WarehouseInventoryAssignmentRanking,
   Worksheet,