tango-app-api-analysis-traffic 3.8.7-vms.2 → 3.8.7-vms.20

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-analysis-traffic",
-    "version": "3.8.7-vms.2",
+    "version": "3.8.7-vms.20",
     "description": "Traffic Analysis",
     "main": "index.js",
     "type": "module",
@@ -23,7 +23,7 @@
         "mongodb": "^6.8.0",
         "nodemon": "^3.1.4",
         "swagger-ui-express": "^5.0.1",
-        "tango-api-schema": "^2.4.23",
+        "tango-api-schema": "^2.4.29",
         "tango-app-api-middleware": "^3.6.5",
         "winston": "^3.13.1",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/revop.controller.js

@@ -1,7 +1,7 @@
 import { logger, insertOpenSearchData, getOpenSearchData, updateOpenSearchData } from 'tango-app-api-middleware';
 import { findOnerevopConfig } from '../services/revopConfig.service.js';
 import * as clientService from '../services/clients.services.js';
-import { bulkUpdate, upsertWithScript } from 'tango-app-api-middleware/src/utils/openSearch.js';
+import { bulkUpdate, insertWithId, upsertWithScript } from 'tango-app-api-middleware/src/utils/openSearch.js';
 import { findOneVmsStoreRequest } from '../services/vmsStoreRequest.service.js';
 // import dayjs from 'dayjs';
 // Lamda Service Call //
@@ -221,6 +221,9 @@ export async function storeProcessedData( req, res ) {
       dayjs.extend( isSameOrBefore );
 
       let start = dayjs( fromDate );
+      // get start value from the before day one
+      // Move start one day back so we can access "day before" when looping
+      start = start.subtract( 1, 'day' );
       let end = dayjs( toDate );
 
       if ( !start.isValid() || !end.isValid() ) {
@@ -267,10 +270,12 @@ export async function storeProcessedData( req, res ) {
 
       const responseArray = [];
 
-      for ( let i = 0; i < orderedDates.length; i++ ) {
+      for ( let i = 1; i < orderedDates.length; i++ ) {
         const currentDate = orderedDates[i];
         const currentId = `${storeId}_${currentDate}`;
+        logger.info( { currentId, currentDate } );
         const processedData = hitsMap.get( currentId );
+        logger.info( { processedData } );
         if ( !processedData ) {
           responseArray.push( {
             date: currentDate,
@@ -283,13 +288,17 @@ export async function storeProcessedData( req, res ) {
 
         const prevDate = dayjs( currentDate ).subtract( 1, 'day' ).format( 'YYYY-MM-DD' );
         const prevId = `${storeId}_${prevDate}`;
+        logger.info( { prevId, prevDate } );
         const previousData = hitsMap.get( prevId );
 
         let footfallCountTrend = 0;
+        logger.info( { previousData, previoucubr1: previousData?.footfall_count } );
         if ( previousData && previousData.footfall_count ) {
+          logger.info( { previousData, previoucubr: previousData?.footfall_count } );
           footfallCountTrend = Math.round(
-              ( ( processedData.footfall_count - previousData.footfall_count ) / previousData.footfall_count ) * 100,
+              ( ( processedData.footfall_count - previousData?.footfall_count ) / previousData.footfall_count ) * 100,
           );
+          logger.info( { footfallCountTrend } );
         }
         // Add ticket status from openSearch.footfallDirectory (_source.status)
         let ticketStatus = null;
@@ -302,16 +311,28 @@ export async function storeProcessedData( req, res ) {
                 { term: { 'storeId.keyword': storeId } },
                 { term: { 'dateString': currentDate } },
                 { term: { 'ticketName.keyword': 'footfall-directory' } },
+                {
+                  'term': {
+                    'type.keyword': 'store',
+                  },
+                },
               ],
             },
           },
           size: 1,
-          _source: [ 'status' ],
+          _source: [ 'status', 'mappingInfo' ],
         };
         try {
           const footfallDirRes = await getOpenSearchData( openSearch.footfallDirectory, footfallDirQuery );
           const hit = footfallDirRes?.body?.hits?.hits?.[0];
-          ticketStatus = hit?._source?.status || null;
+          if ( hit?._source?.mappingInfo && Array.isArray( hit._source.mappingInfo ) ) {
+            for ( let i = 0; i < hit._source.mappingInfo.length; i++ ) {
+              if ( hit._source.mappingInfo[i].type === 'tagging' ) {
+                ticketStatus = hit._source.mappingInfo[i].status;
+                break;
+              }
+            }
+          }
         } catch ( err ) {
           logger.warn( { message: 'Could not get ticket status from footfallDirectory', error: err } );
         }
@@ -335,7 +356,27 @@ export async function storeProcessedData( req, res ) {
           downtime: processedData?.down_time || 0,
           ticketStatus,
           raisedStatusEnabled,
+
         } );
+
+        if ( raisedStatusEnabled === 'block' ) {
+          // Calculate the number of days from currentDate + 1 to the end of the month
+          // Assume currentDate is in format 'YYYY-MM-DD'
+          const currentDateObj = new Date( currentDate );
+          // Move to next day
+          const nextDay = new Date( currentDateObj );
+          nextDay.setDate( currentDateObj.getDate() + 1 );
+
+          // Get the last date of the current month
+          const endOfMonth = new Date( currentDateObj.getFullYear(), currentDateObj.getMonth() + 1, 0 );
+
+          // Calculate number of days (inclusive of end date, exclusive of nextDay)
+          let noOfBlockedDays = Math.floor( ( endOfMonth - nextDay ) / ( 1000 * 60 * 60 * 24 ) ) + 1;
+          if ( noOfBlockedDays < 0 ) noOfBlockedDays = 0;
+
+          // Add to response
+          responseArray[responseArray.length - 1].noOfBlockedDays = noOfBlockedDays;
+        }
       }
 
       return res.sendSuccess( responseArray );
@@ -376,43 +417,176 @@ export async function footFallImages( req, res ) {
                 'ticketName.keyword': 'footfall-directory',
               },
             },
+            {
+              'term': {
+                'type.keyword': 'store',
+              },
+            },
           ],
         },
       },
-      // '_source': [ 'dateString', 'storeId', 'duplicateCount', 'footfallCount', 'employeeCount', 'houseKeepingCount', 'junkCount', 'status', 'ticketId', 'comments', 'userName', 'role', 'createdAt', 'email', 'houseKeepingACCount', 'duplicateACCount', 'employeeACCount', 'junkACCount', 'approverEmail', 'approverRole', 'approverUserName' ],
+      '_source': [ 'dateString', 'storeId', 'mappingInfo', 'revicedFootfall', 'revicedPerc', 'createdAt', 'updatedAt', 'footfallCount' ],
 
     };
 
     const getData = await getOpenSearchData( opensearch.footfallDirectory, query );
     const ticketDetails = getData?.body?.hits?.hits[0];
     let temp = [];
-   ticketDetails?._source? temp.push( ticketDetails?._source ) :null;
-   //  temp[0].status = 'open';
-   if ( ticketDetails?._source?.status == 'closed' ) {
-     delete temp[0].status;
-     temp.push( { ...ticketDetails?._source, status: 'closed' } );
-
-     temp[1].userName = getData?.body?.hits?.hits?.[0]?._source?.approverUserName;
-     temp[1].email = getData?.body?.hits?.hits?.[0]?._source?.approverEmail;
-     temp[1].role = getData?.body?.hits?.hits?.[0]?._source?.approverRole;
-     temp[1].employeeCount = getData?.body?.hits?.hits?.[0]?._source?.employeeACCount;
-     temp[1].houseKeepingCount = getData?.body?.hits?.hits?.[0]?._source?.houseKeepingACCount;
-     temp[1].duplicateCount = getData?.body?.hits?.hits?.[0]?._source?.duplicateACCount;
-     temp[1].junkCount = getData?.body?.hits?.hits?.[0]?._source?.junkACCount;
-   }
-   const LamdaURL = revop.getImages;
-   let resultData = await LamdaServiceCall( LamdaURL, inputData );
-   logger.info( { resultData: resultData } );
-   if ( resultData ) {
-   temp.length? temp[0].status = 'open': null;
-   if ( resultData.status_code == '200' ) {
-     return res.sendSuccess( { ...resultData, ticketStatus: temp?.length > 0? temp : null, config: req?.store?.footfallDirectoryConfigs } );
-   } else {
-     return res.sendError( 'No Content', 204 );
-   }
-   } else {
-     return res.sendError( 'No Content', 204 );
-   }
+    const footfallValue = ticketDetails?._source?.footfallCount ?? 0;
+    const mappingInfoArray = ticketDetails?._source?.mappingInfo ?? [];
+    // Helper to get mappingInfo for an actionType
+    function getMappingForType( type ) {
+      return mappingInfoArray.find( ( m ) => m.type === type ) || {};
+    }
+
+    // List of actionTypes to process in sequence
+
+    if ( req.user.userType !== 'tango' && req.user.role !== 'superadmin' ) {
+      switch ( req.user.role ) {
+        case 'user':
+          const actionTypesUser = [ 'tagging', 'finalRevision' ];
+
+          temp = [];
+          actionTypesUser.forEach( ( type ) => {
+            const mapping = getMappingForType( type );
+            if ( type === 'tagging' ) {
+              const revisedFootfall = mapping.revicedFootfall ?? 0;
+              const revisedPerc =
+                footfallValue > 0 ?
+                  `${Math.round( ( revisedFootfall / footfallValue ) * 100 )}` :
+                  '0';
+              const countObj = mapping.count ? [ ...mapping.count ] : [];
+              temp.push( {
+                actionType: type,
+                footfall: footfallValue,
+                revicedFootfall: revisedFootfall,
+                revicedPerc: revisedPerc,
+                count: countObj,
+                createdAt: mapping.createdAt ?? '',
+                createdByEmail: mapping.createdByEmail ?? '',
+                createdByUserName: mapping.createdByUserName ?? '',
+                createdByRole: mapping.createdByRole ?? '',
+                isUp: false,
+              } );
+            } else if ( type !== 'tagging' && mapping.status === 'Closed' ) {
+              const revisedFootfall = mapping.revicedFootfall ?? 0;
+              const revisedPerc =
+                footfallValue > 0 ?
+                  `${Math.round( ( revisedFootfall / footfallValue ) * 100 )}` :
+                  '0';
+              const countObj = mapping.count ? [ ...mapping.count ] : [];
+              temp.push( {
+                actionType: type,
+                footfall: footfallValue,
+                revicedFootfall: revisedFootfall,
+                revicedPerc: revisedPerc,
+                count: countObj,
+                createdAt: mapping.createdAt ?? '',
+                createdByEmail: mapping.createdByEmail ?? '',
+                createdByUserName: mapping.createdByUserName ?? '',
+                createdByRole: mapping.createdByRole ?? '',
+              } );
+            }
+          } );
+          break;
+        case 'admin':
+          const actionTypesAdmin = [ 'tagging', 'review', 'finalRevision' ];
+          temp = [];
+          actionTypesAdmin.forEach( ( type ) => {
+            const mapping = getMappingForType( type );
+            if ( type === 'tagging' ) {
+              const revisedFootfall = mapping.revicedFootfall ?? 0;
+              const revisedPerc =
+                footfallValue > 0 ?
+                  `${Math.round( ( revisedFootfall / footfallValue ) * 100 )}` :
+                  '0';
+              const countObj = mapping.count ? [ ...mapping.count ] : [];
+              temp.push( {
+                actionType: type,
+                footfall: footfallValue,
+                revicedFootfall: revisedFootfall,
+                revicedPerc: revisedPerc,
+                count: countObj,
+                createdAt: mapping.createdAt ?? '',
+                createdByEmail: mapping.createdByEmail ?? '',
+                createdByUserName: mapping.createdByUserName ?? '',
+                createdByRole: mapping.createdByRole ?? '',
+                isUp: false,
+              } );
+            } else if ( type !== 'tagging' && mapping.status === 'Closed' ) {
+              const revisedFootfall = mapping.revicedFootfall ?? 0;
+              const revisedPerc =
+                footfallValue > 0 ?
+                  `${Math.round( ( revisedFootfall / footfallValue ) * 100 )}` :
+                  '0';
+              const countObj = mapping.count ? [ ...mapping.count ] : [];
+              temp.push( {
+                actionType: type,
+                footfall: footfallValue,
+                revicedFootfall: revisedFootfall,
+                revicedPerc: revisedPerc,
+                count: countObj,
+                createdAt: mapping.createdAt ?? '',
+                createdByEmail: mapping.createdByEmail ?? '',
+                createdByUserName: mapping.createdByUserName ?? '',
+                createdByRole: mapping.createdByRole ?? '',
+              } );
+            }
+          } );
+      }
+    } else {
+      const actionTypes = [ 'tagging', 'review', 'approve', 'tangoreview', 'finalRevision' ];
+
+      // Dynamically add to temp only if actionType matches and status is 'closed',
+      // except for 'tagging' where status must be 'raised'
+      temp = [];
+      actionTypes.forEach( ( type ) => {
+        const mapping = getMappingForType( type );
+        if ( type === 'tagging' ) {
+          const countObj = mapping.count ? [ ...mapping.count ] : [];
+          temp.push( {
+            actionType: type,
+            footfall: footfallValue,
+            revicedFootfall: mapping.revicedFootfall ?? 0,
+            revicedPerc: mapping.revisedPerc ?? '--',
+            count: countObj,
+            createdAt: mapping.createdAt ?? '',
+            createdByEmail: mapping.createdByEmail ?? '',
+            createdByUserName: mapping.createdByUserName ?? '',
+            createdByRole: mapping.createdByRole ?? '',
+            isUp: false,
+          } );
+        }
+        if ( type !== 'tagging' && mapping.status === 'Closed' ) {
+          const countObj = mapping.count ? [ ...mapping.count ] : [];
+          temp.push( {
+            actionType: type,
+            footfall: footfallValue,
+            revicedFootfall: mapping.revicedFootfall ?? 0,
+            revicedPerc: mapping.revisedPerc ?? '--',
+            count: countObj,
+            createdAt: mapping.createdAt ?? '',
+            createdByEmail: mapping.createdByEmail ?? '',
+            createdByUserName: mapping.createdByUserName ?? '',
+            createdByRole: mapping.createdByRole ?? '',
+          } );
+        }
+      } );
+    }
+
+
+    const LamdaURL = revop.getImages;
+    let resultData = await LamdaServiceCall( LamdaURL, inputData );
+    if ( resultData ) {
+      //  temp.length? temp[0].status = 'open': null;
+      if ( resultData.status_code == '200' ) {
+        return res.sendSuccess( { ...resultData, ticketStatus: temp?.length > 0 && ticketDetails? temp : null, config: req?.store?.footfallDirectoryConfigs } );
+      } else {
+        return res.sendError( 'No Content', 204 );
+      }
+    } else {
+      return res.sendError( 'No Content', 204 );
+    }
   } catch ( error ) {
     logger.error( { message: error, data: req.query, function: 'storeProcessedData' } );
     const err = error.message || 'Internal Server Error';
@@ -437,9 +611,21 @@ export async function tagTempId( req, res ) {
       exitTime: inputData.exitTime,
       filePath: inputData.filePath,
       status: inputData?.revopsType == 'non-tagging' ?'':'submitted',
-      description: '',
+      description: inputData.comments || '',
       isChecked: inputData.isChecked,
-      duplicateImage: inputData?.duplicateImage?.length>0? inputData?.duplicateImage :[],
+      // Add id to each object in duplicateImage if it exists and is an array
+      duplicateImage: Array.isArray( inputData?.duplicateImage ) ?
+        inputData.duplicateImage.map( ( img ) => ( {
+          ...img,
+          id: `${inputData?.storeId}_${inputData?.dateString}_${img?.tempId}`,
+          actions: [
+            {
+              actionType: 'tagging',
+              action: 'submitted',
+            },
+          ],
+        } ) ) :
+        [],
       type: 'tagging-reflect',
       ticketStatus: 'submitted',
       isParent: inputData?.revopsType === 'duplicate'? true : false,
@@ -449,6 +635,7 @@ export async function tagTempId( req, res ) {
           action: 'submitted',
         },
       ],
+      comments: inputData.comments || '',
       createdAt: new Date(),
       updatedAt: new Date(),
 
@@ -464,8 +651,10 @@ export async function tagTempId( req, res ) {
     ctx._source.description = params.description;
     ctx._source.isChecked = params.isChecked;
     ctx._source.duplicateImage = params.duplicateImage;
+     ctx._source.isParent = params.isParent;
     ctx._source.updatedAt = params.updatedAt;
     ctx._source.timeRange = params.timeRange;
+    ctx._source.comments = params.comments;
     if (ctx._source.createdAt == null) {
       ctx._source.createdAt = params.createdAt;
        ctx._source.clientId = params.clientId;
@@ -480,6 +669,32 @@ export async function tagTempId( req, res ) {
     };
     const id = `${inputData.storeId}_${inputData.dateString}_${inputData.timeRange}_${inputData.tempId}`;
     await upsertWithScript( openSearch.revop, id, { script, upsert: upsertRecord } );
+    if ( inputData?.comments && inputData?.comments !== '' ) {
+      const id = `${inputData.storeId}_${inputData.dateString}_${Date.now()}`;
+      const logs = {
+        type: 'tagging',
+        parent: inputData?.revopsType == 'duplicate'? inputData.tempId : null,
+        id: `${inputData?.storeId}_${inputData?.dateString}_${inputData?.tempId}`,
+        tempId: inputData.tempId,
+        timeRange: inputData.timeRange,
+        storeId: inputData.storeId,
+        dateString: inputData.dateString,
+        processType: inputData.processType,
+        category: inputData.revopsType,
+        entryTime: inputData.entryTime,
+        exitTime: inputData.exitTime,
+        filePath: inputData.filePath,
+        status: inputData?.revopsType == 'non-tagging' ?'':'submitted',
+        description: inputData.comments || '',
+        isChecked: inputData.isChecked,
+        createdByEmail: req?.user?.email,
+        createdByUserName: req?.user?.userName,
+        createdByRole: req?.user?.role,
+        message: inputData.comments || '',
+        createdAt: new Date(),
+      };
+      await insertWithId( openSearch.vmsCommentsLog, id, logs );
+    }
     if ( inputData?.duplicateImage?.length> 0 ) {
       let bulkBody = [];
       for ( let item of inputData?.duplicateImage ) {
@@ -487,7 +702,7 @@ export async function tagTempId( req, res ) {
           clientId: inputData.storeId.split( '-' )[0],
           storeId: inputData.storeId,
           tempId: item.tempId,
-          id: `${inputData?.storeId}_${inputData?.dateString}_${inputData?.tempId}`,
+          id: `${inputData?.storeId}_${inputData?.dateString}_${item?.tempId}`,
           dateString: inputData.dateString,
           timeRange: item.timeRange,
           isChecked: item.isChecked,
@@ -502,6 +717,7 @@ export async function tagTempId( req, res ) {
           isParent: false,
           type: 'tagging-reflect',
           ticketStatus: 'submitted',
+          comments: inputData.comments || '',
           actions: [
             {
               actionType: 'tagging',

package/src/controllers/tangoTrafficV3.controllers.js

@@ -3129,29 +3129,30 @@ export const managerTrafficDensityExport = async ( req, res ) => {
   }
 };
 
-// async function getGeocodedAddress( lat, lng ) {
-//   try {
-//     const apiKey = 'AIzaSyDlOezgwQO0JviD0aizrCuN1FY9tcWfR3o'; // Use this if you're using dotenv
-//     const url = `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${apiKey}`;
-
-//     const requestOptions = {
-//       method: 'GET',
-//       headers: {
-//         'Content-Type': 'application/json',
-//       },
-//     };
-//     const response = await fetch( url, requestOptions );
-//     console.log( 'response =>', response );
-//     if ( !response.ok ) {
-//       throw new Error( `Response status: ${response.status}` );
-//       return false;
-//     }
-//     const json = await response.json();
-//     return json;
-//   } catch ( error ) {
-//     console.log( 'getGeocodedAddress error =>', error );
-//     logger.error( { error: error, message: data, function: 'getGeocodedAddress' } );
-//   }
-// }
-// let getGEO = await getGeocodedAddress( 12.900260100404893, 80.23384232089138 );
-//     console.log( 'getGEO =>', getGEO );
+
+export const getStoreListv2 = async ( req, res ) => {
+  try {
+    let reqestData = req.body;
+    let getClientData = await getClientConfig( reqestData.clientId );
+    if ( !getClientData ) {
+      return res.sendError( 'Invalid Client Id', 400 );
+    }
+    reqestData.featureConfigs = getClientData.featureConfigs;
+    let LamdaURL = 'https://nmnnlq3ie65bljcvxauhxmsrpa0edhfa.lambda-url.ap-south-1.on.aws/';
+    let resultData = await LamdaServiceCall( LamdaURL, reqestData );
+    if ( resultData ) {
+      if ( resultData.status_code == '200' ) {
+        return res.sendSuccess( resultData );
+      } else {
+        return res.sendError( 'No Content', 204 );
+      }
+    } else {
+      return res.sendError( 'No Content', 204 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, message: req.body, function: 'getStoreListv2' } );
+    return res.sendError( err, 500 );
+  }
+};
+

package/src/dtos/revop.dtos.js

@@ -56,8 +56,8 @@ export const tagTempIdSchema = joi.object( {
 
     const diff = today.diff( inputDate, 'day' );
 
-    if ( diff > 7 ) {
-      return helpers.message( 'Tagging is not allowed for a period exceeding 7 days' );
+    if ( diff > 3 ) {
+      return helpers.message( 'Tagging is not allowed for a period exceeding 3 days' );
     }
 
     return value;
@@ -84,6 +84,7 @@ export const tagTempIdSchema = joi.object( {
   entryTime: joi.string().required(),
   exitTime: joi.string().required(),
   filePath: joi.string().required(),
+  comments: joi.string().optional().allow( '' ),
 
 } );
 

package/src/dtos/validation.dtos.js

@@ -239,6 +239,17 @@ export const validateCountryHeaderSchemav2 = joi.object( {
 export const validateCountryHeaderParamsv2 = {
   body: validateCountryHeaderSchemav2,
 };
+
+export const validateGetStoreListSchemav2 = joi.object( {
+  clientId: joi.string().required(),
+  storeId: joi.array().items( joi.string().required() ).required(),
+  downtime: joi.array().items( joi.string().required() ).required(),
+  fromDate: joi.string().required(),
+  toDate: joi.string().required(),
+} );
+export const validateGetStoreList = {
+  body: validateGetStoreListSchemav2,
+};
 export const getMyProductSchema = joi.object( {
   clientId: joi.string().required(),
   storeId: joi.array().optional().empty(),

package/src/routes/revop.routes.js

@@ -18,7 +18,6 @@ revopRouter
     .get( '/footfall-images', isAllowedSessionHandler, validate( footfallImagesValid ), getTaggingConfig, footFallImages )
     .post( '/tag-tempId', isAllowedSessionHandler, validate( tagTempIdValid ), deleteTaggedDuplicate, mappingConfig, tagTempId )
 
-
     .post( '/get-categorized-images', isAllowedSessionHandler, validate( getCategorizedImagesValid ), getCategorizedImages );
 
 

package/src/routes/traffic.routes.js

@@ -92,6 +92,7 @@ import {
   funnelV3,
   getStoreMapDataV3,
   managerTrafficDensityExport,
+  getStoreListv2,
 } from '../controllers/tangoTrafficV3.controllers.js';
 analysisTrafficRouter
     .get( '/welcome', welcome )
@@ -175,5 +176,6 @@ analysisTrafficRouter
     .post( '/headerCountry_v2', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateCountryHeaderParamsv2 ), getAssinedStore, headerCountryV2 )
     .post( '/checkTodayReportStatus', isAllowedSessionHandler, checkTodayReportStatus )
     .post( '/headerZoneV2', isAllowedSessionHandler, headerZoneV2 )
-    .post( '/trafficDensityExport_v2', managerTrafficDensityExport );
+    .post( '/trafficDensityExport_v2', managerTrafficDensityExport )
+    .post( '/get-store-list-v2', isAllowedSessionHandler, isAllowedClient, validate( validationDtos.validateGetStoreList ), getStoreListv2 );
 export default analysisTrafficRouter;

package/src/validations/revop.validation.js

@@ -1,6 +1,5 @@
 import { getOpenSearchCount, logger } from 'tango-app-api-middleware';
-import { findOneStore } from '../services/stores.service.js';
-import { deleteByQuery } from 'tango-app-api-middleware/src/utils/openSearch.js';
+import { deleteByQuery, getOpenSearchData } from 'tango-app-api-middleware/src/utils/openSearch.js';
 import { findOne } from '../services/clients.services.js';
 
 export async function getTaggingConfig( req, res, next ) {
@@ -65,41 +64,54 @@ export async function getFootfallCount( req, res, next ) {
 export async function mappingConfig( req, res, next ) {
   try {
     const inputData = req.body;
+
     const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const config =await findOneStore( { storeId: inputData.storeId }, { revopTagging: 1 } );
-    if ( inputData.revopsType == 'employee' ) {
-      const getQuery = {
-        query: {
-          bool: {
-            must: [
-              {
-                term: {
-                  'storeId.keyword': inputData.storeId,
-                },
-              },
-              {
-                term: {
-                  'dateString': inputData.dateString,
-                },
+    const footfallQuery ={
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'store_id.keyword': inputData.storeId,
               },
-              {
-                term: {
-                  'revopsType.keyword': inputData.revopsType,
-                },
+            },
+            {
+              term: {
+                'date_string': inputData.dateString,
               },
-            ],
-          },
+            },
+
+          ],
         },
-      };
+      },
+    };
 
-      const getData = await getOpenSearchCount( openSearch.revop, getQuery );
-      if ( getData && getData?.body?.count >= config?.revopTagging?.employee ) {
-        return res.sendError( `Select up to ${config?.revopTagging?.employee} items only`, 400 );
-      } else {
-        next();
-      }
-    } else if ( inputData.revopsType == 'house-keeping' ) {
-      const getQuery = {
+
+    const footfallOutput = await getOpenSearchData( openSearch.footfall, footfallQuery );
+    if ( footfallOutput?.body?.hits?.hits?.length === 0 ) {
+      return res.sendError( 'No updated footfall for this date', 400 );
+    }
+    const getFootfallCount = footfallOutput?.body?.hits?.hits;
+    const footfall = getFootfallCount?.[0]?._source?.footfall_count;
+
+    const getConfig = await findOne( { clientId: inputData?.storeId?.split( '-' )[0] }, { footfallDirectoryConfigs: 1 } );
+    const taggingLimitation = getConfig?.footfallDirectoryConfigs?.taggingLimitation;
+    // Find the tagging limitation for the given revopsType
+    let matchedLimitation = null;
+    if ( Array.isArray( taggingLimitation ) ) {
+      matchedLimitation = taggingLimitation.find(
+          ( l ) => l.type === inputData.revopsType,
+      );
+    }
+
+    if ( matchedLimitation ) {
+      // Determine the limit value
+      let limitValue = Number( matchedLimitation.value ) || 0;
+      let unit = matchedLimitation.unit;
+
+      // Assuming getData and/or getOpenSearchCount provides the actual tagged count for revopsType
+      // Query OpenSearch for current tagged count for this revopsType
+      const taggedCountQuery = {
         query: {
           bool: {
             must: [
@@ -118,92 +130,51 @@ export async function mappingConfig( req, res, next ) {
                   'revopsType.keyword': inputData.revopsType,
                 },
               },
+              {
+                term: {
+                  'isParent': false,
+                },
+              },
             ],
           },
         },
       };
-      const getData = await getOpenSearchCount( openSearch.revop, getQuery );
-      if ( getData && getData?.body?.count >= config?.revopTagging?.houseKeeping ) {
-        return res.sendError( `Select up to ${config?.revopTagging?.houseKeeping} items only`, 400 );
+      const taggedData = await getOpenSearchCount( openSearch.revop, taggedCountQuery );
+      const taggedValue = ( taggedData?.body?.count || 0 )+ ( inputData.revopsType == 'duplicate'? inputData?.duplicateImage?.length : 1 );
+      // If the unit is %, compare percentage of taggedValue/footfall, otherwise compare taggedValue to limitValue directly
+      let isLimitExceeded = false;
+      if ( unit === '%' ) {
+        // footfall may be undefined, treat as 0 (avoid division by zero)
+        const totalFootfall = Number( footfall ) || 0;
+        const taggedPercent = totalFootfall > 0 ? ( taggedValue / totalFootfall ) * 100 : 0;
+        isLimitExceeded = taggedPercent > limitValue;
+        logger.info( {
+          limitType: 'PERCENT',
+          taggedValue,
+          totalFootfall,
+          taggedPercent,
+          limitValue,
+          isLimitExceeded,
+          forRevopsType: inputData.revopsType,
+        } );
       } else {
-        next();
+        // Non-percent, treat limitValue as an absolute number
+        isLimitExceeded = taggedValue > limitValue;
+        logger.info( {
+          limitType: 'ABSOLUTE',
+          taggedValue,
+          limitValue,
+          isLimitExceeded,
+          forRevopsType: inputData.revopsType,
+        } );
       }
-    } else if ( inputData.revopsType === 'junk' ) {
-      if ( ( req?.user?.userType == 'client' && req?.user?.userType !== 'user ' ) || req?.user?.userType === 'tango' ) {
-        next();
-        return;
-      } else {
-        return res.sendError( 'Forbidden to junk mapping', 500 );
+      if ( isLimitExceeded ) {
+        return res.sendError( `Limit exceed: Only ${limitValue}${unit || ''} items allowed for ${inputData.revopsType}`, 400 );
       }
+      return next();
     } else {
-      next();
+      return next();
     }
-    // else if ( inputData.revopsType == 'duplicate' ) {
-    //   const getFootfallQuery = {
-    //     query: {
-    //       terms: {
-    //         _id: [ inputData?.dateString ],
-    //       },
-    //     },
-    //     _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
-    //     sort: [
-    //       {
-    //         date_iso: {
-    //           order: 'desc',
-    //         },
-    //       },
-    //     ],
-    //   };
-
-    //   const getFootfall = await getOpenSearchData( openSearch.footfall, getFootfallQuery );
-    //   const footfall = getFootfall?.body?.hites?.hits?.[0]?._source?.footfall_count;
-    //   const getQuery = {
-    //     query: {
-    //       bool: {
-    //         must: [
-    //           {
-    //             term: {
-    //               'storeId.keyword': inputData.storeId,
-    //             },
-    //           },
-    //           {
-    //             term: {
-    //               'dateString': inputData.dateString,
-    //             },
-    //           },
-    //           {
-    //             term: {
-    //               'revopsType.keyword': inputData.revopsType,
-    //             },
-    //           },
-    //           {
-    //             term: {
-    //               'parent.keyword': null,
-    //             },
-    //           },
-    //         ],
-    //       },
-    //     },
-    //   };
-    //   const getData = await getOpenSearchCount( openSearch.revop, getQuery );
-    //   logger.info( { getData: getData, footfall: footfall, duplicate: config?.revopTagging?.duplicate } );
-    //   if ( getData && footfall && config?.revopTagging?.duplicate ) {
-    //     const data = config?.revopTagging?.duplicate;
-    //     // Convert "20%" → 0.2 (handle both "20%" and 20)
-    //     const percentStr = typeof data === 'string' ? data.replace( '%', '' ) : data;
-    //     logger.info( { percentStr: percentStr } );
-    //     const percentValue =percentStr / 100;
-
-    //     const result = percentValue * footfall;
-
-    //     logger.info( { result: result, footfall: footfall } );
-    //   }
-    //   if ( getData && getData?.body?.count >= Math.round( result ) ) {
-    //     return res.sendError( `Select up to ${config?.revopTagging?.duplicate} items only`, 400 );
-    //   } else {
-    //     next();
-    //   }
-    // }
   } catch ( error ) {
     logger.error( { error: error, message: req.body, function: 'traffic-revop-getTaggingConfig' } );
     next();