tango-app-api-infra 3.9.5-vms.7 → 3.9.5-vms.70

package/src/validations/footfallDirectory.validation.js

@@ -1,9 +1,18 @@
-import { bulkUpdate, getOpenSearchCount, getOpenSearchData, insertWithId, logger } from 'tango-app-api-middleware';
+import { bulkUpdate, getOpenSearchCount, getOpenSearchData, insertWithId, logger, sendMessageToFIFOQueue, updateOpenSearchData } from 'tango-app-api-middleware';
 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 { updateOneUpsertVmsStoreRequest } from '../services/vmsStoreRequest.service.js';
+import { findOneUser, aggregateUser } from '../services/user.service.js';
+import { findteams } from '../services/teams.service.js';
+import { findcluster } from '../services/cluster.service.js';
+import { sendPushNotification } from 'tango-app-api-middleware';
+import dayjs from 'dayjs';
+import { sendSqsMessage } from '../controllers/footfallDirectory.controllers.js';
+import { countDocumnetsCamera } from '../services/camera.service.js';
+// import utc from 'dayjs/plugin/utc.js';
+// import timezone from 'dayjs/plugin/timezone.js';
 
 function formatRevopTaggingHits( hits = [] ) {
   return hits
@@ -14,19 +23,21 @@ function formatRevopTaggingHits( hits = [] ) {
         }
 
         const duplicateImages = Array.isArray( source.duplicateImage ) ?
-          source.duplicateImage.map( ( item ) => ( {
-            tempId: item?.tempId,
-            timeRange: item?.timeRange,
-            entryTime: item?.entryTime,
-            exitTime: item?.exitTime,
-            filePath: item?.filePath,
-            status: item?.status,
-            isChecked: Boolean( item?.isChecked ),
-          } ) ) :
-          [];
+        source.duplicateImage.map( ( item ) => ( {
+          id: item?.id,
+          tempId: item?.tempId,
+          timeRange: item?.timeRange,
+          entryTime: item?.entryTime,
+          exitTime: item?.exitTime,
+          filePath: item?.filePath,
+          status: item?.status,
+          action: item?.action,
+          isChecked: Boolean( item?.isChecked ),
+        } ) ) :
+        [];
 
         return {
-          id: hit?._id,
+          id: source?.id,
           clientId: source?.clientId,
           storeId: source?.storeId,
           tempId: source?.tempId,
@@ -41,11 +52,12 @@ function formatRevopTaggingHits( hits = [] ) {
           description: source?.description || '',
           isChecked: Boolean( source?.isChecked ),
           type: source?.type,
+          action: source?.action,
           parent: source?.parent ?? null,
           isParent: duplicateImages.length > 0 && !source?.parent,
           createdAt: source?.createdAt,
           updatedAt: source?.updatedAt,
-          data: duplicateImages,
+          duplicateImage: duplicateImages,
         };
       } )
       .filter( Boolean );
@@ -53,7 +65,7 @@ function formatRevopTaggingHits( hits = [] ) {
 
 export async function isExist( req, res, next ) {
   try {
-    const inputData=req.body;
+    const inputData = req.body;
     const opensearch = JSON.parse( process.env.OPENSEARCH );
     const query = {
       query: {
@@ -75,7 +87,7 @@ export async function isExist( req, res, next ) {
     };
 
     const getData = await getOpenSearchCount( opensearch.footfallDirectory, query );
-    const isExist = getData?.body?.count == 0? true : false;
+    const isExist = getData?.body?.count == 0 ? true : false;
     logger.info( { isExist: isExist, count: getData?.body } );
     if ( isExist === true ) {
       next();
@@ -91,12 +103,12 @@ export async function isExist( req, res, next ) {
 
 export async function getClusters( req, res, next ) {
   try {
-    const inputData=req.query;
+    const inputData = req.query;
     // const assignedStores = req.body.assignedStores;
     inputData.clientId = inputData?.clientId?.split( ',' );
     const clusters = inputData?.clusters?.split( ',' ); // convert strig to array
     // logger.info( { assignedStores, clusters } );
-    let filter =[
+    let filter = [
       {
         clientId: { $in: inputData.clientId },
       },
@@ -183,7 +195,7 @@ export async function isGrantedUsers( req, res, next ) {
     const userInfo = req?.user;
     switch ( userInfo.userType ) {
       case 'client':
-        const ticketsFeature = userInfo?.rolespermission?.find( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name =='creator' && m.isAdd==true ) || f.modules.find( ( m ) => m.name =='Reviewer' && m.isAdd==true ) || f.modules.find( ( m ) => m.name =='Approver' && m.isAdd==true ) ) );
+        const ticketsFeature = userInfo?.rolespermission?.find( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'creator' && m.isAdd == true ) || f.modules.find( ( m ) => m.name == 'reviewer' && m.isAdd == true ) || f.modules.find( ( m ) => m.name == 'approver' && m.isAdd == true ) ) );
         logger.info( { ticketsFeature } );
         if ( ticketsFeature ) {
           return next();
@@ -208,7 +220,6 @@ export async function getConfig( req, res, next ) {
     const storeKey = inputData.storeId.split( '-' )[0];
 
     const config = await findOneClient( { clientId: storeKey }, { footfallDirectoryConfigs: 1 } );
-    logger.info( { config, storeKey } );
     const accuracyBreach = config?.footfallDirectoryConfigs?.accuracyBreach;
     req.accuracyBreach = accuracyBreach || '';
     return next();
@@ -222,26 +233,26 @@ export async function getConfig( req, res, next ) {
 export async function ticketCreation( req, res, next ) {
   try {
     const inputData = req.body;
+    const sqs = JSON.parse( process.env.SQS );
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     if ( inputData?.type !== 'create' ) {
       return next();
     }
     // check the createtion permission from the user permission
     const userInfo = req?.user;
-    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name =='creator' && ( m.isAdd==true || m.isEdit==true ) ) ) );
-    logger.info( { ticketsFeature } );
+    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'creator' && ( m.isAdd == true || m.isEdit == true ) ) ) );
     if ( !ticketsFeature ) {
       return res.sendError( 'Forbidden to Create Ticket', 403 );
     }
 
     // get store info by the storeId into mongo db
     const getstoreName = await findOneStore( { storeId: inputData.storeId, status: 'active' }, { storeId: 1, storeName: 1, clientId: 1 } );
-    logger.info( { getstoreName } );
+
     if ( !getstoreName || getstoreName == null ) {
       return res.sendError( 'The store ID is either inActive or not found', 400 );
     }
 
     // get the footfall count from opensearch
-    const openSearch = JSON.parse( process.env.OPENSEARCH );
     const dateString = `${inputData.storeId}_${inputData.dateString}`;
     const getQuery = {
       query: {
@@ -261,23 +272,21 @@ export async function ticketCreation( req, res, next ) {
 
     const getFootfallCount = await getOpenSearchData( openSearch.footfall, getQuery );
     const hits = getFootfallCount?.body?.hits?.hits || [];
-    logger.info( { hits } );
     if ( hits?.[0]?._source?.footfall_count <= 0 ) {
       return res.sendError( 'You can’t create a ticket because this store has 0 footfall data' );
     }
 
     // get category details from the client level configuration
-    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1 } );
-    logger.info( { getConfig, ta123: getConfig?.footfallDirectoryConfigs } );
+    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1, clientId: 1 } );
     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;
-    logger.info( { taggingLimitation, tagginngs: getConfig?.footfallDirectoryConfigs } );
     // Initialize count object from taggingLimitation
-    const getCategory = taggingLimitation?.reduce( ( acc, item ) => {
+    const tempAcc = [];
+    taggingLimitation?.reduce( ( acc, item ) => {
       if ( item?.type ) {
         // Convert type to camelCase with "Count" suffix
         // e.g., "duplicate" -> "duplicateCount", "housekeeping" -> "houseKeepingCount"
@@ -289,11 +298,21 @@ export async function ticketCreation( req, res, next ) {
           // Convert first letter to lowercase and append "Count"
           key = typeLower.charAt( 0 ) + typeLower.slice( 1 ) + 'Count';
         }
-        acc[key] = 0;
+
+
+        // To change from an object to the desired array structure, assemble an array of objects:
+        tempAcc.push( {
+          name: item.name,
+          value: 0,
+          key: key,
+          type: item.type,
+        } );
+
+
+        return acc;
       }
-      return acc;
     }, {} ) || {};
-    logger.info( { getCategory } );
+
     // Query OpenSearch revop index to get actual counts for each type
     if ( taggingLimitation && taggingLimitation.length > 0 ) {
       const revopQuery = {
@@ -311,6 +330,16 @@ export async function ticketCreation( req, res, next ) {
                   'dateString': inputData.dateString,
                 },
               },
+              {
+                term: {
+                  'isParent': false,
+                },
+              },
+              {
+                term: {
+                  isChecked: true,
+                },
+              },
             ],
           },
         },
@@ -324,51 +353,38 @@ export async function ticketCreation( req, res, next ) {
         },
       };
 
-      try {
-        const revopData = await getOpenSearchData( openSearch.revop, revopQuery );
-        logger.info( { revopData: revopData } );
-        const buckets = revopData?.body?.aggregations?.type_counts?.buckets || [];
-
-        // Map OpenSearch revopsType values to count object keys
-        buckets.forEach( ( bucket ) => {
-          const revopsType = bucket.key?.toLowerCase();
-          const count = bucket.doc_count || 0;
-
-          // Map the revopsType to the correct count key
-          // Handle variations: duplicate, duplicateImages, duplicateimages
-          if ( revopsType === 'duplicate' ) {
-            if ( getCategory.hasOwnProperty( 'duplicateCount' ) ) {
-              getCategory.duplicateCount = count;
-            }
-          } else if ( revopsType === 'employee' ) {
-            if ( getCategory.hasOwnProperty( 'employeeCount' ) ) {
-              getCategory.employeeCount = count;
-            }
-          } else if ( revopsType === 'housekeeping' ) {
-            if ( getCategory.hasOwnProperty( 'houseKeepingCount' ) ) {
-              getCategory.houseKeepingCount = count;
-            }
-          } else if ( revopsType === 'junk' ) {
-            if ( getCategory.hasOwnProperty( 'junkCount' ) ) {
-              getCategory.junkCount = count;
-            }
+
+      const revopData = await getOpenSearchData( openSearch.revop, revopQuery );
+      const buckets = revopData?.body?.aggregations?.type_counts?.buckets || [];
+
+      // Map OpenSearch revopsType values to count object keys
+      buckets.forEach( ( bucket ) => {
+        const revopsType = bucket.key;
+        const count = bucket.doc_count || 0;
+
+
+        if ( Array.isArray( tempAcc ) ) {
+          // Find the tempAcc entry whose type (case-insensitive) matches revopsType
+          const accMatch = tempAcc.find(
+              ( acc ) =>
+                acc.type &&
+              acc.type === revopsType,
+          );
+
+          if ( accMatch && accMatch.key ) {
+            tempAcc.find( ( a ) => a.key === accMatch.key ).value = count;
           }
-        } );
-      } catch ( error ) {
-        logger.error( { error: error, message: 'Error fetching revop counts', function: 'footfallDirectoryTicket-ticketCreation' } );
-        // Continue with default 0 values if query fails
-      }
+        }
+      } );
     }
 
-    logger.info( { getCategory: getCategory } );
 
     // Calculate revisedFootfall: footfallCount - (sum of all counts)
-    const totalCount = ( getCategory.duplicateCount || 0 ) +
-                      ( getCategory.employeeCount || 0 ) +
-                      ( getCategory.houseKeepingCount || 0 ) +
-                      ( getCategory.junkCount || 0 );
+
+    const totalCount = Array.isArray( tempAcc ) ?
+      tempAcc.reduce( ( sum, acc ) => sum + ( acc.value || 0 ), 0 ) :
+      0;
     const footfallCount = hits?.[0]?._source?.footfall_count || 0;
-    logger.info( { footfallCount, totalCount } );
     const revisedFootfall = Math.max( 0, footfallCount - totalCount );
     if ( footfallCount - revisedFootfall == 0 ) {
       return res.sendError( 'Cannot create a ticket because footfall hasn’t changed', 400 );
@@ -400,117 +416,122 @@ export async function ticketCreation( req, res, next ) {
       return res.sendError( 'You don’t have any tagged images right now', 400 );
     }
     const formattedTaggingData = formatRevopTaggingHits( taggingImages );
-    logger.info( { revopTaggingData: formattedTaggingData } );
 
     const record = {
       storeId: inputData.storeId,
+      type: 'store',
       dateString: inputData.dateString,
       storeName: getstoreName?.storeName,
-      ticketName: inputData.ticketName|| 'footfall-directory',
+      ticketName: inputData.ticketName || 'footfall-directory',
       footfallCount: footfallCount,
       clientId: getstoreName?.clientId,
       ticketId: 'TE_FDT_' + new Date().valueOf(),
       createdAt: new Date(),
       updatedAt: new Date(),
-      status: 'raised',
+      status: 'Raised',
+      comments: inputData?.comments || '',
       revicedFootfall: revisedFootfall,
-      revicedPerc: Math.round( ( revisedFootfall/footfallCount ) * 100 || 0 ) + '%',
+      revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
       mappingInfo: [
         {
           type: 'tagging',
           mode: inputData.mode,
           revicedFootfall: revisedFootfall,
-          count: getCategory,
+          revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+          count: tempAcc,
           revisedDetail: formattedTaggingData,
-          status: 'raised',
+          status: 'Raised',
           createdByEmail: req?.user?.email,
           createdByUserName: req?.user?.userName,
           createdByRole: req?.user?.role,
+          createdAt: new Date(),
         },
       ],
     };
 
 
     // Retrieve client footfallDirectoryConfigs revision
-    let isAutoCloseEnable = false;
-    let autoCloseAccuracy = '95%';
-    try {
-      const clientData = await clientModel.findOne( { clientId: getstoreName?.clientId } ).lean();
-      if ( clientData?.footfallDirectoryConfigs ) {
-        isAutoCloseEnable = clientData.footfallDirectoryConfigs.isAutoCloseEnable ?? false;
-        autoCloseAccuracy = clientData.footfallDirectoryConfigs.autoCloseAccuracy || '95%';
-      }
-    } catch ( e ) {
-      isAutoCloseEnable = false;
-      autoCloseAccuracy = '95%';
-    }
+    let isAutoCloseEnable = getConfig?.footfallDirectoryConfigs?.isAutoCloseEnable; ;
+    let autoCloseAccuracy = getConfig?.footfallDirectoryConfigs?.autoCloseAccuracy; ;
 
-    let autoCloseAccuracyValue = parseFloat( ( autoCloseAccuracy || '95' ).replace( '%', '' ) );
-    let revisedPercentage = 0;
-    if ( typeof getCategory === 'number' && getCategory > 0 ) {
-      revisedPercentage = ( revisedFootfall / getCategory ) * 100;
-    }
+    const getNumber = autoCloseAccuracy.split( '%' )[0];
+
+    let autoCloseAccuracyValue = parseFloat( ( autoCloseAccuracy || getNumber ).replace( '%', '' ) );
+    let revisedPercentage = Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 );
 
     // If autoclose enabled and revisedPercentage meets/exceeds threshold, close ticket and skip revision
     if (
       isAutoCloseEnable === true &&
       revisedPercentage >= autoCloseAccuracyValue
     ) {
-      record.status = 'closed';
+      record.status = 'Closed';
       record.mappingInfo = [
         {
           type: 'tagging',
           mode: inputData.mode,
           revicedFootfall: revisedFootfall,
-          count: getCategory,
+          revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+          count: tempAcc,
+          revisedDetail: formattedTaggingData,
+          status: 'Closed',
+          createdByEmail: req?.user?.email,
+          createdByUserName: req?.user?.userName,
+          createdByRole: req?.user?.role,
+          createdAt: new Date(),
+        },
+        {
+          type: 'finalRevision',
+          mode: inputData.mode,
+          revicedFootfall: revisedFootfall,
+          revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+          count: tempAcc,
           revisedDetail: formattedTaggingData,
-          status: 'closed',
+          status: 'Closed',
           createdByEmail: req?.user?.email,
           createdByUserName: req?.user?.userName,
           createdByRole: req?.user?.role,
+          createdAt: new Date(),
         },
       ];
     } else {
-    // If ticket is closed, do not proceed with revision mapping
+      // If ticket is closed, do not proceed with revision mapping
       let revisionArray = [];
-      try {
-        const clientData = await clientModel.findOne( { clientId: getstoreName?.clientId } ).lean();
-        revisionArray = clientData?.footfallDirectoryConfigs?.revision || [];
-      } catch ( e ) {
-        revisionArray = [];
-      }
 
+      revisionArray = getConfig?.footfallDirectoryConfigs?.revision || [];
       // Default fallbacks
       let revisionMapping = null;
       let approverMapping = null;
       let tangoReviewMapping = null;
-
       // Find out which roles have isChecked true
       if ( Array.isArray( revisionArray ) && revisionArray.length > 0 ) {
         for ( const r of revisionArray ) {
           if ( r.actionType === 'reviewer' && r.isChecked === true ) {
             revisionMapping = {
               type: 'review',
-              revicedFootfall: revisedFootfall,
-              count: getCategory,
+              // revicedFootfall: revisedFootfall,
+              // revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              count: tempAcc,
               revisedDetail: formattedTaggingData,
-              status: 'open',
+              status: 'Open',
+
             };
           } else if ( r.actionType === 'approver' && r.isChecked === true ) {
             approverMapping = {
-              type: 'approver',
-              revicedFootfall: revisedFootfall,
-              count: getCategory,
+              type: 'approve',
+              // revicedFootfall: revisedFootfall,
+              // revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              count: tempAcc,
               revisedDetail: formattedTaggingData,
-              status: 'open',
+              status: 'Open',
             };
           } else if ( r.actionType === 'tango' && r.isChecked === true ) {
             tangoReviewMapping = {
-              type: 'tango-review',
-              revicedFootfall: revisedFootfall,
-              count: getCategory,
+              type: 'tangoreview',
+              // revicedFootfall: revisedFootfall,
+              // revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              count: tempAcc,
               revisedDetail: formattedTaggingData,
-              status: 'open',
+              status: 'Open',
             };
           }
         }
@@ -518,36 +539,179 @@ export async function ticketCreation( req, res, next ) {
 
       // Insert appropriate mappingInfo blocks
       if ( revisionMapping ) {
-      // If reviewer and checked
+        // If reviewer and checked
         record.mappingInfo.push( revisionMapping );
       } else if ( approverMapping ) {
-      // If approver and checked
+        // If approver and checked
         record.mappingInfo.push( approverMapping );
       } else if ( tangoReviewMapping ) {
-      // If none above, then tangoReview
+        // If none above, then tangoReview
         record.mappingInfo.push( tangoReviewMapping );
       }
     }
 
+    const revision = getConfig.footfallDirectoryConfigs?.revision ?? [];
+
+    const hasReviewer = revision.some(
+        ( data ) => data.actionType === 'reviewer' && data.isChecked === true,
+    );
+    const hasApprover = revision.some(
+        ( data ) => data.actionType === 'approver' && data.isChecked === true,
+    );
+
+    if ( hasReviewer || hasApprover ) {
+      const userQuery = [
+        {
+          $match: {
+            clientId: getstoreName.clientId,
+            role: 'admin',
+            isActive: true,
+          },
+        },
+      ];
+
+      const finduserList = await aggregateUser( userQuery );
+
+
+      const createdOn = dayjs().format( 'DD MMM YYYY' );
+      const title = `${getstoreName?.storeName} Have raised a ticket for a Footfall Mismatch`;
+      const description = `Created on ${createdOn}`;
+
+      const Data = {
+        title,
+        body: description,
+        type: 'create',
+        date: record.dateString,
+        storeId: record.storeId,
+        clientId: record.clientId,
+        ticketId: record.ticketId,
+      };
+
+      await Promise.all(
+          ( finduserList || [] ).map( async ( userData ) => {
+            const ticketsFeature = userData?.rolespermission?.some(
+                ( f ) =>
+                  f.featureName === 'FootfallDirectory' &&
+              f.modules?.some(
+                  ( m ) =>
+                    m.name === 'reviewer' && ( m.isAdd === true || m.isEdit === true ),
+              ),
+            );
+
+
+            if ( !ticketsFeature ) return;
+
+            const notifyUser = await getAssinedStore( userData, req.body.storeId );
+            if ( !notifyUser || !userData?.fcmToken ) return;
+
+            await sendPushNotification( title, description, userData.fcmToken, Data );
+          } ),
+      );
+    }
+
 
     const id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
     const insertResult = await insertWithId( openSearch.footfallDirectory, id, record );
     if ( insertResult && insertResult.statusCode === 201 ) {
       // After successful ticket creation, update status to "submitted" in revop index for the relevant records
-      try {
-        const bulkUpdateBody = taggingImages.map( ( img ) => [
-          { update: { _index: openSearch.revop, _id: img._id } },
-          { doc: { status: 'submitted' } },
-        ] ).flat();
-
-        if ( bulkUpdateBody.length > 0 ) {
-          await bulkUpdate( bulkUpdateBody ); // Optionally use a dedicated bulk helper if available
-        }
-      } catch ( updateErr ) {
-        logger.error( { error: updateErr, message: 'Failed to update status to submitted in revop index' } );
-        // Do not block the success response for this failure
+
+
+      const bulkUpdateBody = taggingImages.map( ( img ) => [
+        { update: { _index: openSearch.revop, _id: img._id } },
+        { doc: { status: 'submitted' } },
+      ] ).flat();
+
+      if ( bulkUpdateBody.length > 0 ) {
+        await bulkUpdate( bulkUpdateBody ); // Optionally use a dedicated bulk helper if available
       }
 
+      if ( record.status = 'Closed' ) {
+        const query = {
+          storeId: inputData?.storeId,
+          isVideoStream: true,
+        };
+        const getStoreType = await countDocumnetsCamera( query );
+        const revopInfoQuery = {
+          size: 10000,
+          query: {
+            bool: {
+              must: [
+                {
+                  term: {
+                    'storeId.keyword': inputData.storeId,
+                  },
+                },
+                {
+                  term: {
+                    'dateString': inputData.dateString,
+                  },
+                },
+                {
+                  term: {
+                    'isParent': false,
+                  },
+                },
+                {
+                  term: {
+                    isChecked: true,
+                  },
+                },
+              ],
+            },
+          },
+          _source: [ 'tempId' ],
+
+        };
+
+        const revopInfo = await getOpenSearchData( openSearch.revop, revopInfoQuery );
+
+        // Get all tempIds from revopInfo response
+        const tempIds =
+            revopInfo?.body?.hits?.hits?.map( ( hit ) => hit?._source?.tempId ).filter( Boolean ) || [];
+        // Prepare management eyeZone query based on storeId and dateString
+        const managerEyeZoneQuery = {
+          size: 1,
+          query: {
+            bool: {
+              must: [
+                {
+                  term: {
+                    'storeId.keyword': inputData.storeId,
+                  },
+                },
+                {
+                  term: {
+                    'storeDate': inputData.dateString,
+                  },
+                },
+              ],
+            },
+          },
+          _source: [ 'originalToTrackerCustomerMapping' ],
+        };
+
+        // Query the managerEyeZone index for the matching document
+        const managerEyeZoneResp = await getOpenSearchData( openSearch.managerEyeZone, managerEyeZoneQuery );
+        const managerEyeZoneHit = managerEyeZoneResp?.body?.hits?.hits?.[0]?._source;
+        // Extract originalToTrackerCustomerMapping if it exists
+        const mapping =
+            managerEyeZoneHit && managerEyeZoneHit.originalToTrackerCustomerMapping ?
+              managerEyeZoneHit.originalToTrackerCustomerMapping :
+              {};
+
+        // If you want to compare or find matching tempIds in the mapping
+        // The mapping is { "1": tempId1, ... }, so get values as array of tempIds
+        // const managerMappedTempIds = Object.values( mapping );
+
+        // Find tempIds that exist in both revopInfo results and manager mapping
+        const temp = [];
+        tempIds.filter( ( tid ) => mapping[tid] !== null ? temp.push( { tempId: mapping[tid] } ) :'' );
+        const isSendMessge = await sendSqsMessage( inputData, temp, getStoreType, inputData.storeId );
+        if ( isSendMessge == true ) {
+          logger.info( '....1' );
+          // return true; // res.sendSuccess( 'Ticket has been updated successfully' );
+        } // Example: log or use these tempIds for further logic
+      }
       // Check if ticketCount exceeds breach limit within config months and revised footfall percentage > config accuracy
 
       if ( req.accuracyBreach && req.accuracyBreach.ticketCount && req.accuracyBreach.days && req.accuracyBreach.accuracy ) {
@@ -557,7 +721,7 @@ export async function ticketCreation( req, res, next ) {
         // req.accuracyBreach.accuracy is a string like "95%", so remove "%" and convert to Number
         const breachAccuracy = Number( req.accuracyBreach.accuracy.replace( '%', '' ) );
         const storeId = inputData.storeId;
-        const ticketName =inputData.ticketName || 'footfall-directory'; // adjust if ticket name variable differs
+        const ticketName = inputData.ticketName || 'footfall-directory'; // adjust if ticket name variable differs
 
 
         const formatDate = ( d ) =>
@@ -671,14 +835,1064 @@ export async function ticketCreation( req, res, next ) {
           }
         }
       }
+      const sqsName = sqs.vmsPickleExtention;
+      const sqsProduceQueue = {
+        QueueUrl: `${sqs.url}${sqsName}`,
+        MessageBody: JSON.stringify( {
+          store_id: inputData?.storeId,
+          store_date: inputData?.dateString?.split( '-' ).reverse().join( '-' ),
+          primary: `${inputData?.storeId}_${inputData?.dateString}_${Date.now()}`,
+          time: new Date(),
+        } ),
+        MessageGroupId: 'revops-pickle',
+        MessageDeduplicationId: `${inputData?.storeId}_${inputData?.dateString}_${Date.now()}`,
+      };
+      const sqsQueue = await sendMessageToFIFOQueue( sqsProduceQueue );
+
+      if ( sqsQueue.statusCode ) {
+        logger.error( {
+          error: `${sqsQueue}`,
+          type: 'SQS_NOT_SEND_ERROR',
+        } );
+      }
+
 
       return res.sendSuccess( 'Ticket raised successfully' );
     }
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
-    logger.error( { error: err, funtion: 'ticketCreation' } );
+    logger.error( { error: error, funtion: 'ticketCreation' } );
     return res.sendError( err, 500 );
   }
 }
 
+export async function ticketReview( req, res, next ) {
+  try {
+    const inputData = req.body;
+    if ( inputData?.type !== 'review' ) {
+      return next();
+    }
+    // check the createtion permission from the user permission
+    const userInfo = req?.user;
+    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'reviewer' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+    if ( !ticketsFeature ) {
+      return res.sendError( 'Forbidden to Reiew this Ticket', 403 );
+    }
+
+    // get store info by the storeId into mongo db
+    const getstoreName = await findOneStore( { storeId: inputData.storeId, status: 'active' }, { storeId: 1, storeName: 1, clientId: 1 } );
+
+    if ( !getstoreName || getstoreName == null ) {
+      return res.sendError( 'The store ID is either inActive or not found', 400 );
+    }
+
+    // get the footfall count from opensearch
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const dateString = `${inputData.storeId}_${inputData.dateString}`;
+    const getQuery = {
+      query: {
+        terms: {
+          _id: [ dateString ],
+        },
+      },
+      _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
+      sort: [
+        {
+          date_iso: {
+            order: 'desc',
+          },
+        },
+      ],
+    };
+
+    const getFootfallCount = await getOpenSearchData( openSearch.footfall, getQuery );
+    const hits = getFootfallCount?.body?.hits?.hits || [];
+    logger.info( { hits } );
+    if ( hits?.[0]?._source?.footfall_count <= 0 ) {
+      return res.sendError( 'You can’t create a ticket because this store has 0 footfall data' );
+    }
+
+    // get category details from the client level configuration
+    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1 } );
+    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;
+    // Initialize count object from taggingLimitation
+    const tempAcc = [];
+    taggingLimitation?.reduce( ( acc, item ) => {
+      if ( item?.type ) {
+        // Convert type to camelCase with "Count" suffix
+        // e.g., "duplicate" -> "duplicateCount", "housekeeping" -> "houseKeepingCount"
+        const typeLower = item.type.toLowerCase();
+        let key;
+        if ( typeLower === 'housekeeping' ) {
+          key = 'houseKeepingCount';
+        } else {
+          // Convert first letter to lowercase and append "Count"
+          key = typeLower.charAt( 0 ) + typeLower.slice( 1 ) + 'Count';
+        }
+
+
+        // To change from an object to the desired array structure, assemble an array of objects:
+        tempAcc.push( {
+          name: item.name,
+          value: 0,
+          key: key,
+          type: item.type,
+        } );
+
+
+        return acc;
+      }
+    }, {} ) || {};
+
+    // Query OpenSearch revop index to get actual counts for each type
+    if ( taggingLimitation && taggingLimitation.length > 0 ) {
+      const revopQuery = {
+        size: 0,
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'storeId.keyword': inputData.storeId,
+                },
+              },
+              {
+                term: {
+                  'dateString': inputData.dateString,
+                },
+              },
+              {
+                term: {
+                  'isParent': false,
+                },
+              },
+              {
+                term: {
+                  isChecked: true,
+                },
+              },
+            ],
+          },
+        },
+        aggs: {
+          type_counts: {
+            terms: {
+              field: 'revopsType.keyword',
+              size: 100,
+            },
+          },
+        },
+      };
+
+
+      const revopData = await getOpenSearchData( openSearch.revop, revopQuery );
+      const buckets = revopData?.body?.aggregations?.type_counts?.buckets || [];
+
+      // Map OpenSearch revopsType values to count object keys
+      buckets.forEach( ( bucket ) => {
+        const revopsType = bucket.key;
+        const count = bucket.doc_count || 0;
+
+
+        if ( Array.isArray( tempAcc ) ) {
+          // Find the tempAcc entry whose type (case-insensitive) matches revopsType
+          const accMatch = tempAcc.find(
+              ( acc ) =>
+                acc.type &&
+              acc.type === revopsType,
+          );
+
+          if ( accMatch && accMatch.key ) {
+            tempAcc.find( ( a ) => a.key === accMatch.key ).value = count;
+          }
+        }
+      } );
+    }
+
+
+    // Calculate revisedFootfall: footfallCount - (sum of all counts)
+
+    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 ) {
+      return res.sendError( 'Cannot review a ticket because footfall hasn’t changed', 400 );
+    }
+    const taggingData = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    const revopTaggingData = await getOpenSearchData( openSearch.revop, taggingData );
+    const taggingImages = revopTaggingData?.body?.hits?.hits;
+    if ( !taggingImages || taggingImages?.length == 0 ) {
+      return res.sendError( 'You don’t have any tagged images right now', 400 );
+    }
+    const formattedTaggingData = formatRevopTaggingHits( taggingImages );
+
+    const getTicket = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    const getFootfallticketData = await getOpenSearchData( openSearch.footfallDirectory, getTicket );
+    const ticketData = getFootfallticketData?.body?.hits?.hits;
+    if ( !ticketData || ticketData?.length == 0 ) {
+      return res.sendError( 'You don’t have any tagged images right now', 400 );
+    }
+    const record = {
+
+      status: 'Reviewer-Closed',
+      revicedFootfall: revisedFootfall,
+      revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+      mappingInfo: ticketData?.[0]?._source?.mappingInfo,
+      // createdByEmail: req?.user?.email,
+      // createdByUserName: req?.user?.userName,
+      // createdByRole: req?.user?.role,
+
+    };
+
+    if ( Array.isArray( record.mappingInfo ) ) {
+      const temp = record.mappingInfo
+          .filter( ( item ) => item.type === 'review' )
+          .map( ( item ) => ( {
+            ...item,
+            mode: inputData.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+            count: tempAcc,
+            revisedDetail: formattedTaggingData,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            createdAt: new Date(),
+          } ) );
+      record.mappingInfo = [ ticketData?.[0]?._source?.mappingInfo[0], ...temp ];
+      // If no review mapping existed, push a new one
+      if ( record.mappingInfo.length === 0 ) {
+        record.mappingInfo.push( {
+          type: 'review',
+          mode: inputData.mode,
+          revicedFootfall: revisedFootfall,
+          revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+          count: tempAcc,
+          revisedDetail: formattedTaggingData,
+          status: 'Closed',
+          createdByEmail: req?.user?.email,
+          createdByUserName: req?.user?.userName,
+          createdByRole: req?.user?.role,
+          createdAt: new Date(),
+        } );
+      }
+    }
+
+
+    // Retrieve client footfallDirectoryConfigs revision
+    let isAutoCloseEnable = getConfig?.footfallDirectoryConfigs?.isAutoCloseEnable; ;
+    let autoCloseAccuracy = getConfig?.footfallDirectoryConfigs?.autoCloseAccuracy;
+
+
+    const getNumber = autoCloseAccuracy.split( '%' )[0];
+    let autoCloseAccuracyValue = parseFloat( ( autoCloseAccuracy || getNumber ).replace( '%', '' ) );
+    let revisedPercentage = Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 );
+
+
+    // If autoclose enabled and revisedPercentage meets/exceeds threshold, close ticket and skip revision
+    if (
+      isAutoCloseEnable === true &&
+      revisedPercentage >= autoCloseAccuracyValue
+    ) {
+      record.status = 'Reviewer-Closed';
+      // Only keep or modify mappingInfo items with type "review"
+      if ( Array.isArray( record.mappingInfo ) ) {
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === 'review' )
+            .map( ( item ) => ( {
+              ...item,
+              mode: inputData.mode,
+              revicedFootfall: revisedFootfall,
+              revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+            } ) );
+
+        const temp2 = record.mappingInfo
+            .filter( ( item ) => item.type === 'tagging' )
+            .map( ( item ) => ( {
+              ...item,
+              mode: inputData.mode,
+              // revicedFootfall: revisedFootfall,
+              // revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              // count: tempAcc,
+              // revisedDetail: formattedTaggingData,
+              status: 'Closed',
+              // createdByEmail: req?.user?.email,
+              // createdByUserName: req?.user?.userName,
+              // createdByRole: req?.user?.role,
+            } ) );
+        record.mappingInfo = [ ...temp2, ...temp ];
+        // If no review mapping existed, push a new one
+        if ( record.mappingInfo.length === 0 ) {
+          record.mappingInfo.push( {
+            type: 'review',
+            mode: inputData.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+            count: tempAcc,
+            revisedDetail: formattedTaggingData,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+          } );
+        }
+      }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            mode: inputData.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+            count: tempAcc,
+            revisedDetail: formattedTaggingData,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            createdAt: new Date(),
+          },
+      );
+    } else {
+      // If ticket is closed, do not proceed with revision mapping
+      let revisionArray = [];
+
+
+      revisionArray = getConfig?.footfallDirectoryConfigs?.revision || [];
+
+
+      // Default fallbacks
+      let revisionMapping = null;
+      let approverMapping = null;
+      let tangoReviewMapping = null;
+
+      // Find out which roles have isChecked true
+      if ( Array.isArray( revisionArray ) && revisionArray.length > 0 ) {
+        for ( const r of revisionArray ) {
+          if ( r.actionType === 'approver' && r.isChecked === true ) {
+            approverMapping = {
+              type: 'approve',
+              // revicedFootfall: revisedFootfall,
+              // revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Open',
+            };
+          } else if ( r.actionType === 'tango' && r.isChecked === true ) {
+            tangoReviewMapping = {
+              type: 'tangoreview',
+              // revicedFootfall: revisedFootfall,
+              // revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Open',
+            };
+          }
+        }
+      }
+
+      // Insert appropriate mappingInfo blocks
+      if ( revisionMapping ) {
+        // If reviewer and checked
+        record.mappingInfo.push( revisionMapping );
+      } else if ( approverMapping ) {
+        // If approver and checked
+        record.mappingInfo.push( approverMapping );
+      } else if ( tangoReviewMapping ) {
+        // If none above, then tangoReview
+        record.mappingInfo.push( tangoReviewMapping );
+      }
+    }
+
+    let checkreview = getConfig.footfallDirectoryConfigs.revision.filter( ( data ) => data.actionType === 'reviewer' && data.isChecked === true );
+
+
+    if ( checkreview.length > 0 ) {
+      let userQuery = [
+        {
+          $match: {
+            clientId: getstoreName.clientId,
+            role: 'admin',
+            isActive: true,
+          },
+        },
+      ];
+      let finduserList = await aggregateUser( userQuery );
+
+
+      // return;
+      for ( let userData of finduserList ) {
+        let title = `${getstoreName?.storeName} Have raised a ticket for a Footfall Mismatch`;
+        let createdOn = dayjs().format( 'DD MMM YYYY' );
+        let description = `Created on ${createdOn}`;
+
+        let Data = {
+          'title': title,
+          'body': description,
+          'type': 'review',
+          'date': record.dateString,
+          'storeId': record.storeId,
+          'clientId': record.clientId,
+          'ticketId': record.ticketId,
+        };
+        const ticketsFeature = userData?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'reviewer' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+
+        if ( ticketsFeature ) {
+          let notifyuser = await getAssinedStore( userData, req.body.storeId );
+          if ( userData && userData.fcmToken && notifyuser ) {
+            const fcmToken = userData.fcmToken;
+            await sendPushNotification( title, description, fcmToken, Data );
+          }
+        }
+      }
+    }
+
+    const id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
+    const insertResult = await updateOpenSearchData( openSearch.footfallDirectory, id, { doc: record } );
+
+    if ( insertResult && insertResult.statusCode === 201 || insertResult.statusCode === 200 ) {
+      return res.sendSuccess( 'Ticket closed successfully' );
+    } else {
+      return res.sendError( 'Internal Server Error', 500 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: err, funtion: 'ticketreview' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function ticketApprove( req, res, next ) {
+  try {
+    const inputData = req.body;
+    if ( inputData?.type !== 'approve' ) {
+      return next();
+    }
+    // check the createtion permission from the user permission
+    const userInfo = req?.user;
+    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'approver' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+    if ( !ticketsFeature ) {
+      return res.sendError( 'Forbidden to Approve this Ticket', 403 );
+    }
+
+    // get store info by the storeId into mongo db
+    const getstoreName = await findOneStore( { storeId: inputData.storeId, status: 'active' }, { storeId: 1, storeName: 1, clientId: 1 } );
+
+    if ( !getstoreName || getstoreName == null ) {
+      return res.sendError( 'The store ID is either inActive or not found', 400 );
+    }
+
+    // get the footfall count from opensearch
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const dateString = `${inputData.storeId}_${inputData.dateString}`;
+    const getQuery = {
+      query: {
+        terms: {
+          _id: [ dateString ],
+        },
+      },
+      _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
+      sort: [
+        {
+          date_iso: {
+            order: 'desc',
+          },
+        },
+      ],
+    };
+
+    const getFootfallCount = await getOpenSearchData( openSearch.footfall, getQuery );
+    const hits = getFootfallCount?.body?.hits?.hits || [];
+    logger.info( { hits } );
+    if ( hits?.[0]?._source?.footfall_count <= 0 ) {
+      return res.sendError( 'You can’t create a ticket because this store has 0 footfall data' );
+    }
+
+    // get category details from the client level configuration
+    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1 } );
+    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;
+    // Initialize count object from taggingLimitation
+    const tempAcc = [];
+    taggingLimitation?.reduce( ( acc, item ) => {
+      if ( item?.type ) {
+        // Convert type to camelCase with "Count" suffix
+        // e.g., "duplicate" -> "duplicateCount", "housekeeping" -> "houseKeepingCount"
+        const typeLower = item.type.toLowerCase();
+        let key;
+        if ( typeLower === 'housekeeping' ) {
+          key = 'houseKeepingCount';
+        } else {
+          // Convert first letter to lowercase and append "Count"
+          key = typeLower.charAt( 0 ) + typeLower.slice( 1 ) + 'Count';
+        }
+
+
+        // To change from an object to the desired array structure, assemble an array of objects:
+        tempAcc.push( {
+          name: item.name,
+          value: 0,
+          key: key,
+          type: item.type,
+        } );
+
+
+        return acc;
+      }
+    }, {} ) || {};
+
+    // Query OpenSearch revop index to get actual counts for each type
+    if ( taggingLimitation && taggingLimitation.length > 0 ) {
+      const revopQuery = {
+        size: 0,
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'storeId.keyword': inputData.storeId,
+                },
+              },
+              {
+                term: {
+                  'dateString': inputData.dateString,
+                },
+              },
+            ],
+          },
+        },
+        aggs: {
+          type_counts: {
+            terms: {
+              field: 'revopsType.keyword',
+              size: 100,
+            },
+          },
+        },
+      };
+
+
+      const revopData = await getOpenSearchData( openSearch.revop, revopQuery );
+      const buckets = revopData?.body?.aggregations?.type_counts?.buckets || [];
+
+      // Map OpenSearch revopsType values to count object keys
+      buckets.forEach( ( bucket ) => {
+        const revopsType = bucket.key;
+        const count = bucket.doc_count || 0;
+
+
+        if ( Array.isArray( tempAcc ) ) {
+          // Find the tempAcc entry whose type (case-insensitive) matches revopsType
+          const accMatch = tempAcc.find(
+              ( acc ) =>
+                acc.type &&
+              acc.type === revopsType,
+          );
+
+          if ( accMatch && accMatch.key ) {
+            tempAcc.find( ( a ) => a.key === accMatch.key ).value = count;
+          }
+        }
+      } );
+    }
+
+
+    // Calculate revisedFootfall: footfallCount - (sum of all counts)
+
+    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 );
+    logger.info( { footfallCount, revisedFootfall } );
+    if ( footfallCount - revisedFootfall == 0 ) {
+      return res.sendError( 'Cannot review a ticket because footfall hasn’t changed', 400 );
+    }
+
+    const taggingData = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+            {
+              term: {
+                'isParent': false,
+              },
+            },
+            {
+              term: {
+                isChecked: true,
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    const revopTaggingData = await getOpenSearchData( openSearch.revop, taggingData );
+    const taggingImages = revopTaggingData?.body?.hits?.hits;
+    if ( !taggingImages || taggingImages?.length == 0 ) {
+      return res.sendError( 'You don’t have any tagged images right now', 400 );
+    }
+
+    const formattedTaggingData = formatRevopTaggingHits( taggingImages );
+
+    const getTicket = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    const getFootfallticketData = await getOpenSearchData( openSearch.footfallDirectory, getTicket );
+    const ticketData = getFootfallticketData?.body?.hits?.hits;
+    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',
+      revicedFootfall: revisedFootfall,
+      revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+      mappingInfo: ticketData?.[0]?._source?.mappingInfo,
+      // createdByEmail: req?.user?.email,
+      // createdByUserName: req?.user?.userName,
+      // createdByRole: req?.user?.role,
+
+    };
+
+
+    // Retrieve client footfallDirectoryConfigs revision
+    let isAutoCloseEnable = getConfig.footfallDirectoryConfigs.isAutoCloseEnable;
+    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 &&
+      revisedPercentage >= autoCloseAccuracyValue
+    ) {
+      record.status = 'Approver-Closed';
+      // Only keep or modify mappingInfo items with type "review"
+      if ( Array.isArray( record.mappingInfo ) ) {
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === 'approve' )
+            .map( ( item ) => ( {
+              ...item,
+
+              mode: inputData.mode,
+              revicedFootfall: revisedFootfall,
+              revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+            } ) );
+
+        record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+          ...temp ];
+        // If updating the mapping config to mark [i].status as 'Closed'
+        // Make sure all relevant mappingInfo items of type 'approve' are set to status 'Closed'
+        if ( Array.isArray( record.mappingInfo ) ) {
+          record.mappingInfo = record.mappingInfo.map( ( item ) => {
+            return {
+              ...item,
+              status: 'Closed',
+            };
+          } );
+        }
+        // If no review mapping existed, push a new one
+        if ( record.mappingInfo.length === 0 ) {
+          record.mappingInfo.push( {
+            type: 'approve',
+            mode: inputData.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+            count: tempAcc,
+            revisedDetail: formattedTaggingData,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+          } );
+        }
+      }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            mode: inputData.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+            count: tempAcc,
+            revisedDetail: formattedTaggingData,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            createdAt: new Date(),
+          },
+      );
+    } else if ( revised < tangoReview ) {
+      // If ticket is closed, do not proceed with revision mapping
+
+      // Default fallbacks
+
+      let approverMapping = null;
+      let tangoReviewMapping = null;
+
+      record.status = 'Approver-Closed';
+      // Only keep or modify mappingInfo items with type "review"
+      if ( Array.isArray( record.mappingInfo ) ) {
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === 'approve' )
+            .map( ( item ) => ( {
+              ...item,
+              mode: inputData.mode,
+              revicedFootfall: revisedFootfall,
+              revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+            } ) );
+
+        record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+          ...temp ];
+        // if ( Array.isArray( record.mappingInfo ) ) {
+        //   record.mappingInfo = record.mappingInfo.map( ( item ) => {
+        //     return {
+        //       ...item,
+        //       status: 'Closed',
+        //     };
+        //   } );
+        // }
+        // If no review mapping existed, push a new one
+        if ( record.mappingInfo.length === 0 ) {
+          record.mappingInfo.push( {
+            type: 'approve',
+            mode: inputData.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+            count: tempAcc,
+            revisedDetail: formattedTaggingData,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+          } );
+        }
+      }
+
+      // Find out which roles have isChecked true
+
+      // for ( const r of revisionArray ) {
+      //   if ( r.actionType === 'tango' && r.isChecked === true ) {
+      tangoReviewMapping = {
+        type: 'tangoreview',
+        // revicedFootfall: revisedFootfall,
+        // revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+        count: tempAcc,
+        revisedDetail: formattedTaggingData,
+        status: 'Open',
+      };
+      //   }
+      // }
+
+
+      if ( approverMapping ) {
+        // If approver and checked
+        record.mappingInfo.push( approverMapping );
+      } else if ( tangoReviewMapping ) {
+        // If none above, then tangoReview
+        record.mappingInfo.push( tangoReviewMapping );
+      }
+    } else {
+      if ( Array.isArray( record.mappingInfo ) ) {
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === 'approve' )
+            .map( ( item ) => ( {
+              ...item,
+              mode: inputData.mode,
+              revicedFootfall: revisedFootfall,
+              revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+            } ) );
+
+        record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+          ...temp ];
+        if ( Array.isArray( record.mappingInfo ) ) {
+          record.mappingInfo = record.mappingInfo.map( ( item ) => {
+            return {
+              ...item,
+              status: 'Closed',
+            };
+          } );
+        }
+        // If no review mapping existed, push a new one
+        if ( record.mappingInfo.length === 0 ) {
+          record.mappingInfo.push( {
+            type: 'approve',
+            mode: inputData.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+            count: tempAcc,
+            revisedDetail: formattedTaggingData,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+          } );
+        }
+      }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            mode: inputData.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+            count: tempAcc,
+            revisedDetail: formattedTaggingData,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            createdAt: new Date(),
+          },
+      );
+    }
+    console.log( req.body, getConfig.footfallDirectoryConfigs.revision );
+    let checkapprove = getConfig.footfallDirectoryConfigs.revision.filter( ( data ) => data.actionType === 'approver' && data.isChecked === true );
+
+
+    if ( checkapprove.length > 0 ) {
+      let userQuery = [
+        {
+          $match: {
+            clientId: getstoreName.clientId,
+            role: 'admin',
+            isActive: true,
+          },
+        },
+      ];
+      let finduserList = await aggregateUser( userQuery );
+
+
+      for ( let userData of finduserList ) {
+        let title = `${getstoreName?.storeName} Have raised a ticket for a Footfall Mismatch`;
+        let createdOn = dayjs().format( 'DD MMM YYYY' );
+        let description = `Created on ${createdOn}`;
+
+        let Data = {
+          'title': title,
+          'body': description,
+          'type': 'approve',
+          'date': record.dateString,
+          'storeId': record.storeId,
+          'clientId': record.clientId,
+          'ticketId': record.ticketId,
+        };
+
+        const ticketsFeature = userData?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'approver' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+
+        if ( ticketsFeature ) {
+          let notifyuser = await getAssinedStore( userData, req.body.storeId );
+          if ( userData && userData.fcmToken && notifyuser ) {
+            const fcmToken = userData.fcmToken;
+            await sendPushNotification( title, description, fcmToken, Data );
+          }
+        }
+      }
+    }
+
+    const id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
+    const insertResult = await updateOpenSearchData( openSearch.footfallDirectory, id, { doc: record } );
+
+
+    if ( insertResult && ( insertResult.statusCode === 201 || insertResult.statusCode === 200 ) ) {
+      return res.sendSuccess( 'Ticket closed successfully' );
+    } else {
+      return res.sendError( 'Internal Server Error', 500 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: err, funtion: 'ticketCreation' } );
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function getAssinedStore( user, storeId ) {
+  if ( !user || user.userType !== 'client' || user.role === 'superadmin' ) {
+    return;
+  }
+
+  const clientId = user.clientId;
+  const storeIds = new Set(
+      user.assignedStores?.map( ( store ) => store.storeId ) ?? [],
+  );
+
+  const addClusterStores = ( clusters ) => {
+    if ( !clusters?.length ) return;
+    for ( const cluster of clusters ) {
+      cluster.stores?.forEach( ( store ) => storeIds.add( store.storeId ) );
+    }
+  };
+
+  // Fetch all top-level data in parallel
+  const [ clustersList, teamsList, teamMemberList ] = await Promise.all( [
+    findcluster( {
+      clientId,
+      Teamlead: { $elemMatch: { email: user.email } },
+    } ),
+    findteams( {
+      clientId,
+      Teamlead: { $elemMatch: { email: user.email } },
+    } ),
+    findteams( {
+      clientId,
+      users: { $elemMatch: { email: user.email } },
+    } ),
+  ] );
+
+  // 1) Clusters where this user is Teamlead
+  addClusterStores( clustersList );
+
+  // 2) Teams where this user is Teamlead → their users + their clusters
+  if ( teamsList?.length ) {
+    for ( const team of teamsList ) {
+      if ( !team.users?.length ) continue;
+
+      await Promise.all(
+          team.users.map( async ( teamUser ) => {
+            const foundUser = await findOneUser( { _id: teamUser.userId } );
+            if ( !foundUser ) return;
+
+            // Direct assigned stores of that user
+            if ( foundUser.assignedStores?.length ) {
+              foundUser.assignedStores.forEach( ( store ) =>
+                storeIds.add( store.storeId ),
+              );
+            }
+
+            // Clusters where this user is Teamlead
+            const userClustersList = await findcluster( {
+              clientId,
+              Teamlead: { $elemMatch: { email: foundUser.email } },
+            } );
+            addClusterStores( userClustersList );
+          } ),
+      );
+    }
+  }
+
+  // 3) Teams where this user is a member → clusters by teamName
+  if ( teamMemberList?.length ) {
+    for ( const team of teamMemberList ) {
+      const clusterList = await findcluster( {
+        clientId,
+        teams: { $elemMatch: { name: team.teamName } },
+      } );
+      addClusterStores( clusterList );
+    }
+  }
+
+  const assignedStores = Array.from( storeIds );
+
+  // Previously you returned `true` in both branches.
+  // Assuming you actually want to check membership:
+  return assignedStores.includes( storeId );
+}