tango-app-api-infra 3.9.5-vms.81 → 3.9.5-vms.83

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.9.5-vms.81",
+    "version": "3.9.5-vms.83",
     "description": "infra",
     "main": "index.js",
     "type": "module",
@@ -27,7 +27,7 @@
         "mongodb": "^6.4.0",
         "nodemon": "^3.1.0",
         "swagger-ui-express": "^5.0.0",
-        "tango-api-schema": "^2.5.1",
+        "tango-api-schema": "^2.5.2",
         "tango-app-api-infra": "^3.9.5-vms.56",
         "tango-app-api-middleware": "^3.1.93",
         "winston": "^3.12.0",

package/src/validations/footfallDirectory.validation.js

@@ -2,7 +2,7 @@ import { bulkUpdate, getOpenSearchCount, getOpenSearchData, insertWithId, logger
 import { aggregateCluster } from '../services/cluster.service.js';
 import { findOneRevopDownload } from '../services/revopDownload.service.js';
 import { findOneStore } from '../services/store.service.js';
-import { findOneClient } from '../services/client.service.js';
+import { aggregateClient, findOneClient } from '../services/client.service.js';
 import { updateOneUpsertVmsStoreRequest } from '../services/vmsStoreRequest.service.js';
 import { findOneUser, aggregateUser } from '../services/user.service.js';
 import { findteams } from '../services/teams.service.js';
@@ -277,16 +277,90 @@ export async function ticketCreation( req, res, next ) {
     }
 
     // get category details from the client level configuration
-    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1, clientId: 1 } );
+    const configQuery = [
+      {
+        $match: {
+          clientId: getstoreName?.clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
+              {
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
+              },
+              0,
+            ],
+          },
+        },
+      },
+
+      {
+        $project: {
+          config: 1,
+          effectiveLimitation: 1,
+          footfallDirectoryConfigs: 1,
+        },
+      },
+    ];
+
+
+    const config = await aggregateClient( configQuery );
+    const getConfig = config[0];
     if ( !getConfig || getConfig == null ) {
       return res.sendError( 'The Client ID is either not configured or not found', 400 );
     }
 
     // Get taggingLimitation from config (check both possible paths)
-    const taggingLimitation = getConfig?.footfallDirectoryConfigs?.taggingLimitation;
+    const taggingLimitation = getConfig?.effectiveLimitation?.values;
     // Initialize count object from taggingLimitation
     const tempAcc = [];
-    taggingLimitation?.reduce( ( acc, item ) => {
+    taggingLimitation.reduce( ( acc, item ) => {
       if ( item?.type ) {
         // Convert type to camelCase with "Count" suffix
         // e.g., "duplicate" -> "duplicateCount", "housekeeping" -> "houseKeepingCount"
@@ -384,6 +458,7 @@ export async function ticketCreation( req, res, next ) {
     const totalCount = Array.isArray( tempAcc ) ?
       tempAcc.reduce( ( sum, acc ) => sum + ( acc.value || 0 ), 0 ) :
       0;
+
     const footfallCount = hits?.[0]?._source?.footfall_count || 0;
     const revisedFootfall = Math.max( 0, footfallCount - totalCount );
     if ( footfallCount - revisedFootfall == 0 ) {
@@ -920,16 +995,90 @@ export async function ticketReview( req, res, next ) {
     }
 
     // get category details from the client level configuration
-    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1 } );
+    const configQuery = [
+      {
+        $match: {
+          clientId: getstoreName?.clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
+              {
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
+              },
+              0,
+            ],
+          },
+        },
+      },
+
+      {
+        $project: {
+          config: 1,
+          effectiveLimitation: 1,
+          footfallDirectoryConfigs: 1,
+        },
+      },
+    ];
+
+
+    const config = await aggregateClient( configQuery );
+    const getConfig = config[0];
     if ( !getConfig || getConfig == null ) {
       return res.sendError( 'The Client ID is either not configured or not found', 400 );
     }
 
     // Get taggingLimitation from config (check both possible paths)
-    const taggingLimitation = getConfig?.footfallDirectoryConfigs?.taggingLimitation;
+    const taggingLimitation = getConfig?.effectiveLimitation?.values;
     // Initialize count object from taggingLimitation
     const tempAcc = [];
-    taggingLimitation?.reduce( ( acc, item ) => {
+    taggingLimitation.reduce( ( acc, item ) => {
       if ( item?.type ) {
         // Convert type to camelCase with "Count" suffix
         // e.g., "duplicate" -> "duplicateCount", "housekeeping" -> "houseKeepingCount"
@@ -1454,16 +1603,90 @@ export async function ticketApprove( req, res, next ) {
     }
 
     // get category details from the client level configuration
-    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1 } );
+    const configQuery = [
+      {
+        $match: {
+          clientId: getstoreName?.clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
+              {
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
+              },
+              0,
+            ],
+          },
+        },
+      },
+
+      {
+        $project: {
+          config: 1,
+          effectiveLimitation: 1,
+          footfallDirectoryConfigs: 1,
+        },
+      },
+    ];
+
+
+    const config = await aggregateClient( configQuery );
+    const getConfig = config[0];
     if ( !getConfig || getConfig == null ) {
       return res.sendError( 'The Client ID is either not configured or not found', 400 );
     }
 
     // Get taggingLimitation from config (check both possible paths)
-    const taggingLimitation = getConfig?.footfallDirectoryConfigs?.taggingLimitation;
+    const taggingLimitation = getConfig?.effectiveLimitation?.values;
     // Initialize count object from taggingLimitation
     const tempAcc = [];
-    taggingLimitation?.reduce( ( acc, item ) => {
+    taggingLimitation.reduce( ( acc, item ) => {
       if ( item?.type ) {
         // Convert type to camelCase with "Count" suffix
         // e.g., "duplicate" -> "duplicateCount", "housekeeping" -> "houseKeepingCount"
@@ -1553,9 +1776,9 @@ export async function ticketApprove( req, res, next ) {
       0;
     const footfallCount = hits?.[0]?._source?.footfall_count || 0;
     const revisedFootfall = Math.max( 0, footfallCount - totalCount );
-    logger.info( { footfallCount, revisedFootfall } );
+
     if ( footfallCount - revisedFootfall == 0 ) {
-      return res.sendError( 'Cannot review a ticket because footfall hasn’t changed', 400 );
+      return res.sendError( 'Cannot approve a ticket because footfall hasn’t changed', 400 );
     }
 
     const taggingData = {
@@ -1621,7 +1844,7 @@ export async function ticketApprove( req, res, next ) {
     if ( !ticketData || ticketData?.length == 0 ) {
       return res.sendError( 'You don’t have any tagged images right now', 400 );
     }
-    logger.info( { ticketData, getFootfallticketData } );
+
     const record = {
 
       status: 'Approver-Closed',
@@ -1641,12 +1864,10 @@ export async function ticketApprove( req, res, next ) {
     let autoCloseAccuracy = getConfig?.footfallDirectoryConfigs?.autoCloseAccuracy;
 
     const getNumber = autoCloseAccuracy.split( '%' )[0];
-    logger.info( { getNumber } );
     let autoCloseAccuracyValue = parseFloat( ( autoCloseAccuracy || getNumber ).replace( '%', '' ) );
     let revisedPercentage = Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 );
     const revised = Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) );
     const tangoReview = Number( getConfig?.footfallDirectoryConfigs?.tangoReview?.split( '%' )[0] );
-    logger.info( { tangoReview, revised } );
     // If autoclose enabled and revisedPercentage meets/exceeds threshold, close ticket and skip revision
     if (
       isAutoCloseEnable === true &&