tango-app-api-infra 3.9.7 → 3.9.9

package/src/validations/footfallDirectory.validation.js

@@ -1,10 +1,71 @@
-import { getOpenSearchCount, logger } from 'tango-app-api-middleware';
+import { bulkUpdate, getOpenSearchCount, getOpenSearchData, insertWithId, logger, sendMessageToFIFOQueue, updateOpenSearchData, getOpenSearchById } 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 { aggregateClient, findOneClient } from '../services/client.service.js';
+import { updateOneUpsertVmsStoreRequest } from '../services/vmsStoreRequest.service.js';
+import { findOneUser, aggregateUser } from '../services/user.service.js';
+import { findteams } from '../services/teams.service.js';
+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
+      .map( ( hit ) => {
+        const source = hit?._source || {};
+        if ( Object.keys( source ).length === 0 ) {
+          return null;
+        }
+
+        const duplicateImages = Array.isArray( source.duplicateImage ) ?
+        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: source?.id,
+          clientId: source?.clientId,
+          storeId: source?.storeId,
+          tempId: source?.tempId,
+          dateString: source?.dateString,
+          timeRange: source?.timeRange,
+          processType: source?.processType,
+          revopsType: source?.revopsType,
+          entryTime: source?.entryTime,
+          exitTime: source?.exitTime,
+          filePath: source?.filePath,
+          status: source?.status,
+          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,
+          duplicateImage: duplicateImages,
+        };
+      } )
+      .filter( Boolean );
+}
 
 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: {
@@ -26,8 +87,8 @@ export async function isExist( req, res, next ) {
     };
 
     const getData = await getOpenSearchCount( opensearch.footfallDirectory, query );
-    const isExist = getData?.body?.count == 0? true : false;
-    logger.info( { isExist: isExist, count: getData?.body } );
+    const isExist = getData?.body?.count == 0 ? true : false;
+
     if ( isExist === true ) {
       next();
     } else {
@@ -42,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 },
       },
@@ -93,7 +154,7 @@ export async function getClusters( req, res, next ) {
     if ( getStores?.[0]?.stores?.length == 0 ) {
       return res.sendError( 'No data', 204 );
     }
-    logger.info( { getStores: getStores, length: getStores?.[0]?.stores?.length, stores: getStores?.[0]?.stores } );
+
     req.stores = getStores?.[0]?.stores;
     return next();
   } catch ( error ) {
@@ -129,3 +190,2549 @@ export async function isTicketExists( req, res, next ) {
   }
 }
 
+export async function isGrantedUsers( req, res, next ) {
+  try {
+    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 ) ) );
+
+        if ( ticketsFeature ) {
+          return next();
+        } else {
+          return res.sendError( 'Forbidden to this action', 403 );
+        }
+
+      case 'tango':
+        return next();
+      default:
+        return res.sendError( 'userType doesnot match', 400 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    return res.sendError( err, 500 );
+  }
+}
+
+export async function getConfig( req, res, next ) {
+  try {
+    const inputData = req.body;
+    const storeKey = inputData.storeId.split( '-' )[0];
+
+    const config = await findOneClient( { clientId: storeKey }, { footfallDirectoryConfigs: 1 } );
+    const accuracyBreach = config?.footfallDirectoryConfigs?.accuracyBreach;
+    req.accuracyBreach = accuracyBreach || '';
+    return next();
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    return res.sendError( err, 500 );
+  }
+}
+
+
+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();
+    }
+
+    const query = {
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData?.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData?.dateString,
+              },
+            },
+            {
+              term: {
+                'type': 'store',
+              },
+            },
+          ],
+        },
+      },
+    };
+
+    const getData = await getOpenSearchCount( openSearch.footfallDirectory, query );
+    const isExist = getData?.body?.count == 0 ? true : false;
+
+    if ( isExist !== true ) {
+      return res.sendError( 'The ticket is already exist', 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 category details from the client level configuration
+    const configQuery = [
+      {
+        $match: {
+          clientId: getstoreName?.clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
+              {
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
+              },
+              0,
+            ],
+          },
+        },
+      },
+
+      {
+        $project: {
+          config: 1,
+          effectiveLimitation: 1,
+          footfallDirectoryConfigs: 1,
+        },
+      },
+    ];
+
+
+    const config = await aggregateClient( configQuery );
+    const getConfig = config[0];
+    if ( !getConfig || getConfig == null ) {
+      return res.sendError( 'The Client ID is either not configured or not found', 400 );
+    }
+    const today = dayjs();
+    const diff = today.diff( inputData.dateString, 'day' );
+    const taggingDueDate = getConfig?.footfallDirectoryConfigs?.allowTicketCreation || 0;
+    if ( diff > taggingDueDate ) {
+      return res.sendError( 'Ticket Creation is not allowed beyond the due date', 400 );
+    }
+    // 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 ) ) ) );
+    if ( !ticketsFeature ) {
+      return res.sendError( 'Forbidden to Create Ticket', 403 );
+    }
+
+
+    // get the footfall count from 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 || [];
+    if ( hits?.[0]?._source?.footfall_count <= 0 ) {
+      return res.sendError( 'You can’t create a ticket because this store has 0 footfall data' );
+    }
+
+
+    // Get taggingLimitation from config (check both possible paths)
+    const taggingLimitation = getConfig?.effectiveLimitation?.values;
+    // 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,
+                },
+              },
+            ],
+          },
+        },
+        aggs: {
+          type_counts: {
+            terms: {
+              field: 'revopsType.keyword',
+              size: 50000,
+            },
+          },
+        },
+      };
+
+
+      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 create a ticket because footfall hasn’t changed', 400 );
+    }
+
+    const taggingData = {
+      size: 50000,
+      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 record = {
+      storeId: inputData.storeId,
+      type: 'store',
+      dateString: inputData.dateString,
+      storeName: getstoreName?.storeName,
+      ticketName: inputData.ticketName || 'footfall-directory',
+      footfallCount: footfallCount,
+      clientId: getstoreName?.clientId,
+      ticketId: 'TE_FDT_' + new Date().valueOf(),
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      status: 'Raised',
+      comments: inputData?.comments || '',
+      revicedFootfall: revisedFootfall,
+      revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+      reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+      mappingInfo: [
+        {
+          type: 'tagging',
+          mode: inputData.mode,
+          revicedFootfall: revisedFootfall,
+          revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+          reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+          count: tempAcc,
+          revisedDetail: formattedTaggingData,
+          status: 'Raised',
+          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 = 'Closed';
+      record.mappingInfo = [
+        {
+          type: 'tagging',
+          mode: inputData.mode,
+          revicedFootfall: revisedFootfall,
+          revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+          reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+          count: tempAcc,
+          revisedDetail: formattedTaggingData,
+          status: 'Closed',
+          createdByEmail: req?.user?.email,
+          createdByUserName: req?.user?.userName,
+          createdByRole: req?.user?.role,
+          updatedAt: new Date(),
+        },
+        {
+          type: 'finalRevision',
+          mode: inputData.mode,
+          revicedFootfall: revisedFootfall,
+          revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+          reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+          count: tempAcc,
+          revisedDetail: formattedTaggingData,
+          status: 'Closed',
+          createdByEmail: req?.user?.email,
+          createdByUserName: req?.user?.userName,
+          createdByRole: req?.user?.role,
+          updatedAt: new Date(),
+        },
+      ];
+    } else {
+      // If ticket is closed, do not proceed with revision mapping
+      let revisionArray = [];
+
+      revisionArray = getConfig?.footfallDirectoryConfigs?.revision || [];
+      const tangoDueDate = getConfig?.footfallDirectoryConfigs?.allowTangoReview || 0;
+      const approverDueDate = getConfig?.footfallDirectoryConfigs?.allowTangoApprove || 0;
+      const reviwerDueDate = getConfig?.footfallDirectoryConfigs?.allowTicketReview || 0;
+      // 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',
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Open',
+              dueDate: new Date( Date.now() + reviwerDueDate * 24 * 60 * 60 * 1000 ), // Current date plus 3 days
+              createdAt: new Date(),
+              updatedAt: new Date(),
+
+            };
+          } else if ( r.actionType === 'approver' && r.isChecked === true ) {
+            approverMapping = {
+              type: 'approve',
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Open',
+              dueDate: new Date( Date.now() + approverDueDate * 24 * 60 * 60 * 1000 ), // Current date plus 3 days
+              createdAt: new Date(),
+              updatedAt: new Date(),
+            };
+          } else if ( r.actionType === 'tango' && r.isChecked === true ) {
+            tangoReviewMapping = {
+              type: 'tangoreview',
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Open',
+              dueDate: new Date( Date.now() + tangoDueDate * 24 * 60 * 60 * 1000 ), // Current date plus 3 days
+              createdAt: new Date(),
+              updatedAt: new Date(),
+            };
+          }
+        }
+      }
+
+      // 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 );
+      }
+    }
+
+    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,
+            appName: 'tangoeye',
+          },
+        },
+      ];
+
+      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
+
+
+      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: 50000,
+          query: {
+            bool: {
+              must: [
+                {
+                  term: {
+                    'storeId.keyword': inputData.storeId,
+                  },
+                },
+                {
+                  term: {
+                    'dateString': inputData.dateString,
+                  },
+                },
+                {
+                  term: {
+                    'isParent': false,
+                  },
+                },
+              ],
+            },
+          },
+          _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: {
+                    'zoneId.keyword': 'Overall Store',
+                  },
+                },
+                {
+                  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 :
+            { tempId: '' };
+
+
+        // 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 ) {
+        const breachDays = Number( req.accuracyBreach.days );
+        const breachCount = Number( req.accuracyBreach.ticketCount );
+
+        // 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 formatDate = ( d ) =>
+          `${d.getFullYear()}-${String( d.getMonth() + 1 ).padStart( 2, '0' )}-${String( d.getDate() ).padStart( 2, '0' )}`;
+
+        // Compute current date object
+
+
+        // Calculate start date based on config days
+        // If 30 days: start from first day of current month
+        // If 60 days: start from first day of last month
+        const currentDateObj = new Date(); // Declare currentDateObj as today's date
+        const startDateObj = new Date( currentDateObj );
+
+        if ( breachDays === 30 ) {
+          // Consider within this month
+          startDateObj.setDate( 1 ); // First day of current month
+        } else if ( breachDays === 60 ) {
+          // Consider this month and last month
+          startDateObj.setMonth( startDateObj.getMonth() - 1 );
+          startDateObj.setDate( 1 ); // First day of last month
+        } else {
+          // For other values, calculate months from days
+          const breachMonths = Math.ceil( breachDays / 30 );
+          startDateObj.setMonth( startDateObj.getMonth() - breachMonths + 1 );
+          startDateObj.setDate( 1 );
+        }
+
+
+        const startDate = startDateObj;
+
+
+        const endDate = new Date;
+        // Query for tickets within this months window for this store and ticket name
+        const query = {
+          query: {
+            bool: {
+              must: [
+                { term: { 'storeId.keyword': storeId } },
+                { term: { 'ticketName.keyword': ticketName } },
+                { range: { createdAt: { gte: startDate, lte: endDate } } },
+              ],
+            },
+          },
+        };
+
+        // Search in OpenSearch for recent similar tickets
+        const breachTicketsResult = await getOpenSearchData( openSearch.footfallDirectory, query );
+        const tickets = breachTicketsResult?.body?.hits?.hits || [];
+
+        // Filter tickets where revised footfall percentage > config accuracy
+        let breachTicketsCount = 0;
+        for ( const ticket of tickets ) {
+          const source = ticket._source || {};
+          const footfallCount = source.footfallCount || 0;
+          const revicedFootfall = source.mappingInfo?.[0]?.revicedFootfall || 0;
+
+          // Calculate revised footfall percentage
+          let revisedPercentage = 0;
+          if ( footfallCount > 0 ) {
+            revisedPercentage = ( revicedFootfall / footfallCount ) * 100;
+          }
+
+          // Check if revised footfall percentage > config accuracy
+          if ( revisedPercentage > breachAccuracy ) {
+            breachTicketsCount++;
+          }
+        }
+
+        if ( breachTicketsCount >= breachCount ) {
+          // Calculate remaining future days in the config period
+          const futureDates = [];
+
+          // Calculate end date of config period
+          const configEndDateObj = new Date( currentDateObj );
+          if ( breachDays === 30 ) {
+            // End of current month
+            configEndDateObj.setMonth( configEndDateObj.getMonth() + 1 );
+            configEndDateObj.setDate( 0 ); // Last day of current month
+          } else if ( breachDays === 60 ) {
+            // End of next month
+            configEndDateObj.setMonth( configEndDateObj.getMonth() + 2 );
+            configEndDateObj.setDate( 0 ); // Last day of next month
+          } else {
+            // For other values, add the remaining days
+            const remainingDays = breachDays - ( Math.floor( ( currentDateObj - startDateObj ) / ( 1000 * 60 * 60 * 24 ) ) );
+            configEndDateObj.setDate( configEndDateObj.getDate() + remainingDays );
+          }
+
+          // Generate all dates from tomorrow until end of config period
+          const tomorrow = new Date( currentDateObj );
+          tomorrow.setDate( tomorrow.getDate() + 0 );
+
+          const dateIterator = new Date( tomorrow );
+          while ( dateIterator <= configEndDateObj ) {
+            futureDates.push( formatDate( dateIterator ) );
+            dateIterator.setDate( dateIterator.getDate() + 1 );
+          }
+          // Also check the past 3 days; for each day, if footfallDirectory index does not have a record for this storeId/dateString/type:"store", block that day too
+          // const missingPastDays = [];
+          for ( let delta = -3; delta < 0; delta++ ) {
+            const dateObj = new Date( currentDateObj );
+            dateObj.setDate( dateObj.getDate() + delta );
+            const dateStr = formatDate( dateObj );
+            // Query OpenSearch for this day
+            const pastQuery = {
+              query: {
+                bool: {
+                  must: [
+                    { term: { 'storeId.keyword': inputData?.storeId } },
+                    { term: { dateString: dateStr } },
+                    { term: { 'type.keyword': 'store' } },
+                  ],
+                },
+              },
+            };
+            // Use getOpenSearchData to check if exists
+            let found = false;
+
+            const searchRes = await getOpenSearchData( openSearch.footfallDirectory, pastQuery );
+            const foundHits = searchRes?.body?.hits?.hits || [];
+
+            if ( foundHits.length > 0 ) {
+              found = true;
+            } else {
+              found = false;
+            }
+
+            if ( !found ) {
+              const record = {
+                clientId: getstoreName?.clientId,
+                storeId: inputData?.storeId,
+                storeName: getstoreName?.storeName,
+                dateString: dateStr,
+                status: 'block',
+              };
+              await updateOneUpsertVmsStoreRequest( { storeId: inputData?.storeId, dateString: dateStr }, record );
+            }
+          }
+
+
+          // Insert a record for each future date
+          for ( const futureDateString of futureDates ) {
+            const record = {
+              clientId: getstoreName?.clientId,
+              storeId: inputData?.storeId,
+              storeName: getstoreName?.storeName,
+              dateString: futureDateString,
+              status: 'block',
+            };
+
+            await updateOneUpsertVmsStoreRequest( { storeId: inputData?.storeId, dateString: futureDateString }, record );
+          }
+        }
+      }
+      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: 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 || [];
+
+    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 configQuery = [
+      {
+        $match: {
+          clientId: getstoreName?.clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
+              {
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
+              },
+              0,
+            ],
+          },
+        },
+      },
+
+      {
+        $project: {
+          config: 1,
+          effectiveLimitation: 1,
+          footfallDirectoryConfigs: 1,
+        },
+      },
+    ];
+
+
+    const config = await aggregateClient( configQuery );
+    const getConfig = config[0];
+    if ( !getConfig || getConfig == null ) {
+      return res.sendError( 'The Client ID is either not configured or not found', 400 );
+    }
+
+
+    // Get taggingLimitation from config (check both possible paths)
+    const taggingLimitation = getConfig?.effectiveLimitation?.values;
+    // 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: 50000,
+      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: 50000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'type.keyword': 'store',
+              },
+            },
+            {
+              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 reviewDueDate = ticketData?.[0]?._source?.mappingInfo?.find( ( f ) => f.type === 'review' )?.dueDate;
+
+    if ( dayjs().isAfter( dayjs( reviewDueDate ), 'day' ) ) {
+      return res.sendError( 'Ticket Review is not allowed beyond the due date', 400 );
+    }
+
+    const record = {
+
+      status: 'Reviewer-Closed',
+      revicedFootfall: revisedFootfall,
+      revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+      reviced: Number( 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 ) + '%',
+            reviced: Number( 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[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 ) + '%',
+          reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+          count: tempAcc,
+          revisedDetail: formattedTaggingData,
+          status: 'Closed',
+          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];
+    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] );
+    // If autoclose enabled and revisedPercentage meets/exceeds threshold, close ticket and skip revision
+    if (
+      isAutoCloseEnable === true &&
+      revisedPercentage >= autoCloseAccuracyValue
+    ) {
+      record.status = '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 ) + '%',
+              reviced: Number( 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,
+
+              status: 'Closed',
+            } ) );
+        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 ) + '%',
+            reviced: Number( 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 ) + '%',
+            reviced: Number( 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(),
+            updatedAt: new Date(),
+          },
+      );
+    } else {
+      // If ticket is closed, do not proceed with revision mapping
+      let revisionArray = [];
+
+      revisionArray = getConfig?.footfallDirectoryConfigs?.revision || [];
+
+      const tangoDueDate = getConfig?.footfallDirectoryConfigs?.allowTangoReview || 0;
+      const approverDueDate = getConfig?.footfallDirectoryConfigs?.allowTangoApprove || 0;
+      const tangoApproved = getConfig?.footfallDirectoryConfigs?.tangoApproved || false;
+      // 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',
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Open',
+              dueDate: new Date( Date.now() + approverDueDate * 24 * 60 * 60 * 1000 ), // Current date plus 3 days
+              createdAt: new Date(),
+              updatedAt: new Date(),
+            };
+          } else if ( r.actionType === 'approver' && r.isChecked === false ) {
+            if ( revised < tangoReview ) {
+              if ( tangoApproved ) {
+                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 ) + '%',
+                        reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+                        count: tempAcc,
+                        revisedDetail: formattedTaggingData,
+                        status: 'Under Tango Review',
+                        createdByEmail: req?.user?.email,
+                        createdByUserName: req?.user?.userName,
+                        createdByRole: req?.user?.role,
+                        updatedAt: new Date(),
+                      } ) );
+
+                  record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+                    ...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 ) + '%',
+                      reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+                      count: tempAcc,
+                      revisedDetail: formattedTaggingData,
+                      status: 'Under Tango Review',
+                      createdByEmail: req?.user?.email,
+                      createdByUserName: req?.user?.userName,
+                      createdByRole: req?.user?.role,
+                      updatedAt: new Date(),
+                    } );
+                  }
+                }
+
+                // Find out which roles have isChecked true
+
+                // for ( const r of revisionArray ) {
+                //   if ( r.actionType === 'tango' && r.isChecked === true ) {
+                tangoReviewMapping = {
+                  type: 'tangoreview',
+                  count: tempAcc,
+                  revisedDetail: formattedTaggingData,
+                  status: 'Open',
+                  dueDate: new Date( Date.now() + tangoDueDate * 24 * 60 * 60 * 1000 ), // Current date plus 3 days
+                  createdAt: new Date(),
+                  updatedAt: new Date(),
+                };
+              //   }
+              // }
+              } else {
+                record.status ='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 ) + '%',
+                        reviced: Number( 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,
+                        status: 'Closed',
+
+                      } ) );
+                  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 ) + '%',
+                      reviced: Number( 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 ) + '%',
+                      reviced: Number( 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(),
+                      updatedAt: new Date(),
+                    },
+                );
+
+                tangoReviewMapping = {
+                  type: 'tangoreview',
+                  count: tempAcc,
+                  revisedDetail: formattedTaggingData,
+                  status: 'Open',
+                  dueDate: new Date( Date.now() + tangoDueDate * 24 * 60 * 60 * 1000 ), // Current date plus 3 days
+                  createdAt: new Date(),
+                  updatedAt: new Date(),
+                };
+              }
+            } else {
+              record.status ='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 ) + '%',
+                      reviced: Number( 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,
+                      status: 'Closed',
+
+                    } ) );
+                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 ) + '%',
+                    reviced: Number( 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 ) + '%',
+                    reviced: Number( 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(),
+                    updatedAt: new Date(),
+                  },
+              );
+            }
+          }
+        }
+      }
+      // 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 && record.status === 'Reviewer-Closed' ) {
+      let userQuery = [
+        {
+          $match: {
+            clientId: getstoreName.clientId,
+            role: 'admin',
+            isActive: true,
+            appName: 'tangoeye',
+          },
+        },
+      ];
+      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 ) {
+      if ( record.status === 'Closed' ) {
+        const query = {
+          storeId: inputData?.storeId,
+          isVideoStream: true,
+        };
+        const getStoreType = await countDocumnetsCamera( query );
+        const revopInfoQuery = {
+          size: 50000,
+          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: {
+                    'zoneId.keyword': 'Overall Store',
+                  },
+                },
+                {
+                  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 :
+            { tempId: '' };
+
+        // 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' );
+        }
+        const id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
+        let Ticket = await getOpenSearchById( openSearch.footfallDirectory, id );
+        if ( Ticket?.body?._source?.type === 'store' ) {
+          let findTagging = Ticket?.body?._source?.mappingInfo.filter( ( data ) => data.type === 'tagging' );
+          if ( findTagging?.length > 0 && findTagging[0].createdByEmail != '' ) {
+            let userData = await findOneUser( { email: findTagging[0]?.createdByEmail } );
+            let title = `Received response for the Footfall ticket raised.`;
+            let createdOn = dayjs( Ticket?.body?._source?.dateString ).format( 'DD MMM YYYY' );
+            let description = `Raised on ${createdOn}`;
+
+            let Data = {
+              'title': title,
+              'body': description,
+              'type': 'closed',
+              'date': Ticket?.body?._source?.dateString,
+              'storeId': Ticket?.body?._source?.storeId,
+              'clientId': Ticket?.body?._source?.clientId,
+              'ticketId': Ticket?.body?._source?.ticketId,
+            };
+            if ( userData && userData.fcmToken ) {
+              const fcmToken = userData.fcmToken;
+              await sendPushNotification( title, description, fcmToken, Data );
+            }
+          }
+        }
+      }
+      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: error, 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 || [];
+
+    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 configQuery = [
+      {
+        $match: {
+          clientId: getstoreName?.clientId,
+        },
+      },
+
+      // Convert all effectiveFrom to proper Date
+      {
+        $addFields: {
+          taggingLimitationWithDate: {
+            $map: {
+              input: '$footfallDirectoryConfigs.taggingLimitation',
+              as: 'item',
+              in: {
+                effectiveFrom: { $toDate: '$$item.effectiveFrom' },
+                values: '$$item.values',
+              },
+            },
+          },
+        },
+      },
+
+      // Filter items <= input date
+      {
+        $addFields: {
+          matchedLimitation: {
+            $filter: {
+              input: '$taggingLimitationWithDate',
+              as: 'item',
+              cond: {
+                $lte: [
+                  '$$item.effectiveFrom',
+                  { $toDate: inputData.dateString },
+                ],
+              },
+            },
+          },
+        },
+      },
+
+      // Sort DESC and pick ONLY top 1 -> latest effective record
+      {
+        $addFields: {
+          effectiveLimitation: {
+            $arrayElemAt: [
+              {
+                $slice: [
+                  {
+                    $sortArray: {
+                      input: '$matchedLimitation',
+                      sortBy: { effectiveFrom: -1 },
+                    },
+                  },
+                  1,
+                ],
+              },
+              0,
+            ],
+          },
+        },
+      },
+
+      {
+        $project: {
+          config: 1,
+          effectiveLimitation: 1,
+          footfallDirectoryConfigs: 1,
+        },
+      },
+    ];
+
+
+    const config = await aggregateClient( configQuery );
+    const getConfig = config[0];
+    if ( !getConfig || getConfig == null ) {
+      return res.sendError( 'The Client ID is either not configured or not found', 400 );
+    }
+
+    // Get taggingLimitation from config (check both possible paths)
+    const taggingLimitation = getConfig?.effectiveLimitation?.values;
+    // 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: 50000,
+            },
+          },
+        },
+      };
+
+
+      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 approve a ticket because footfall hasn’t changed', 400 );
+    // }
+
+    const taggingData = {
+      size: 50000,
+      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: 50000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'type.keyword': 'store',
+              },
+            },
+            {
+              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 approveDueDate = ticketData?.[0]?._source?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.dueDate;
+    if ( dayjs().isAfter( dayjs( approveDueDate ), 'day' ) ) {
+      return res.sendError( 'Ticket approve is not allowed beyond the due date', 400 );
+    }
+
+    const record = {
+
+      status: 'Closed',
+      revicedFootfall: revisedFootfall,
+      revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+      reviced: Number( 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];
+    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] );
+    const tangoApproved = getConfig?.footfallDirectoryConfigs?.tangoApproved || false;
+    const tangoDueDate = getConfig?.footfallDirectoryConfigs?.allowTangoReview || 0;
+
+    // If autoclose enabled and revisedPercentage meets/exceeds threshold, close ticket and skip revision
+
+    if (
+      isAutoCloseEnable === true &&
+      revisedPercentage >= autoCloseAccuracyValue
+    ) {
+      record.status = '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 ) + '%',
+              reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+              updatedAt: new Date(),
+              // createdAt: new Date(),
+            } ) );
+
+        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 ) + '%',
+            reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+            count: tempAcc,
+            revisedDetail: formattedTaggingData,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            updatedAt: new Date(),
+          } );
+        }
+      }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            mode: inputData.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+            reviced: Number( 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 ) {
+      let approverMapping = null;
+      let tangoReviewMapping = null;
+      if ( tangoApproved ) {
+        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 ) + '%',
+                reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+                count: tempAcc,
+                revisedDetail: formattedTaggingData,
+                status: 'Under Tango Review',
+                createdByEmail: req?.user?.email,
+                createdByUserName: req?.user?.userName,
+                createdByRole: req?.user?.role,
+                updatedAt: new Date(),
+              } ) );
+
+          record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+            ...temp ];
+
+          // 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 ) + '%',
+              reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Under Tango Review',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+              updatedAt: new Date(),
+            } );
+          }
+        }
+
+        // Find out which roles have isChecked true
+
+        // for ( const r of revisionArray ) {
+        //   if ( r.actionType === 'tango' && r.isChecked === true ) {
+
+        tangoReviewMapping = {
+          type: 'tangoreview',
+          count: tempAcc,
+          revisedDetail: formattedTaggingData,
+          status: 'Open',
+          dueDate: new Date( Date.now() + tangoDueDate * 24 * 60 * 60 * 1000 ), // Current date plus 3 days
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        };
+        //   }
+        // }
+      } else {
+        record.status ='Closed';
+
+        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 ) + '%',
+                reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+                count: tempAcc,
+                revisedDetail: formattedTaggingData,
+                status: 'Closed',
+                createdByEmail: req?.user?.email,
+                createdByUserName: req?.user?.userName,
+                createdByRole: req?.user?.role,
+                updatedAt: new Date(),
+              } ) );
+
+          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 ) + '%',
+              reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+              updatedAt: new Date(),
+            } );
+          }
+        }
+        record.mappingInfo.push(
+            {
+              type: 'finalRevision',
+              mode: inputData.mode,
+              revicedFootfall: revisedFootfall,
+              revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+              reviced: Number( 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(),
+              updatedAt: new Date(),
+            },
+        );
+        tangoReviewMapping = {
+          type: 'tangoreview',
+          count: tempAcc,
+          revisedDetail: formattedTaggingData,
+          status: 'Open',
+          dueDate: new Date( Date.now() + tangoDueDate * 24 * 60 * 60 * 1000 ), // Current date plus 3 days
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        };
+      }
+
+      if ( approverMapping ) {
+        // If approver and checked
+        record.mappingInfo.push( approverMapping );
+      } else if ( tangoReviewMapping ) {
+        // If none above, then tangoReview
+        record.mappingInfo.push( tangoReviewMapping );
+      }
+    } else {
+      record.status ='Closed';
+
+      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 ) + '%',
+              reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+              count: tempAcc,
+              revisedDetail: formattedTaggingData,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+              updatedAt: new Date(),
+            } ) );
+
+        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 ) + '%',
+            reviced: Number( Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) ),
+            count: tempAcc,
+            revisedDetail: formattedTaggingData,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            updatedAt: new Date(),
+          } );
+        }
+      }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            mode: inputData.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: Math.round( ( revisedFootfall / footfallCount ) * 100 || 0 ) + '%',
+            reviced: Number( 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(),
+            updatedAt: new Date(),
+          },
+      );
+    }
+    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,
+            appName: 'tangoeye',
+          },
+        },
+      ];
+      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': inputData.dateString,
+          'storeId': inputData.storeId,
+          'clientId': record.clientId?record.clientId:'',
+          'ticketId': record.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 );
+          }
+        }
+      }
+    }
+    // return;
+    const id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
+    logger.info( { status: id } );
+
+    const insertResult = await updateOpenSearchData( openSearch.footfallDirectory, id, { doc: record } );
+
+
+    if ( insertResult && ( insertResult.statusCode === 201 || insertResult.statusCode === 200 ) ) {
+      if ( record.status === 'Closed' ) {
+        const query = {
+          storeId: inputData?.storeId,
+          isVideoStream: true,
+        };
+        const getStoreType = await countDocumnetsCamera( query );
+        const revopInfoQuery = {
+          size: 50000,
+          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 );
+
+        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: {
+                    'zoneId.keyword': 'Overall Store',
+                  },
+                },
+                {
+                  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 :
+            { tempId: '' };
+
+
+        // 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' );
+        }
+        const id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
+        logger.info( { status: id } );
+
+        logger.info( { status: record.status } );
+        let Ticket = await getOpenSearchById( openSearch.footfallDirectory, id );
+        if ( Ticket?.body?._source?.type === 'store' ) {
+          let findTagging = Ticket?.body?._source?.mappingInfo.filter( ( data ) => data.type === 'tagging' );
+          if ( findTagging?.length > 0 && findTagging[0].createdByEmail != '' ) {
+            let userData = await findOneUser( { email: findTagging[0]?.createdByEmail } );
+            let title = `Received response for the Footfall ticket raised.`;
+            let createdOn = dayjs( Ticket?.body?._source?.dateString ).format( 'DD MMM YYYY' );
+            let description = `Raised on ${createdOn}`;
+
+            let Data = {
+              'title': title,
+              'body': description,
+              'type': 'closed',
+              'date': Ticket?.body?._source?.dateString,
+              'storeId': Ticket?.body?._source?.storeId,
+              'clientId': Ticket?.body?._source?.clientId,
+              'ticketId': Ticket?.body?._source?.ticketId,
+            };
+            if ( userData && userData.fcmToken ) {
+              const fcmToken = userData.fcmToken;
+              await sendPushNotification( title, description, fcmToken, Data );
+            }
+          }
+        }
+      }
+      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: error, funtion: 'ticketApprove' } );
+    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 );
+}
+