npm - tango-app-api-infra - Versions diffs - 3.9.5-vms.9 → 3.9.5-vms.90 - Mend

tango-app-api-infra 3.9.5-vms.9 → 3.9.5-vms.90

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/package.json +3 -2
package/src/controllers/footfallDirectory.controllers.js +3758 -682
package/src/dtos/footfallDirectory.dtos.js +188 -60
package/src/routes/footfallDirectory.routes.js +15 -5
package/src/services/storeAccuracyIssues.service.js +9 -0
package/src/validations/footfallDirectory.validation.js +1720 -90

package/src/controllers/footfallDirectory.controllers.js CHANGED Viewed

@@ -1,13 +1,15 @@
 import { chunkArray, download, logger, sendMessageToFIFOQueue, sendMessageToQueue } from 'tango-app-api-middleware';
-import { bulkUpdate, getOpenSearchById, getOpenSearchCount, getOpenSearchData, insertWithId, updateOpenSearchData, upsertOpenSearchData } from 'tango-app-api-middleware/src/utils/openSearch.js';
+import { bulkUpdate, getOpenSearchById, getOpenSearchCount, getOpenSearchData, insertWithId, updateOpenSearchData } from 'tango-app-api-middleware/src/utils/openSearch.js';
 import { findOneStore } from '../services/store.service.js';
 import { countDocumnetsCamera } from '../services/camera.service.js';
 import { findOneRevopDownload, upsertRevopDownload } from '../services/revopDownload.service.js';
 import dayjs from 'dayjs';
 import utc from 'dayjs/plugin/utc.js';
 import timezone from 'dayjs/plugin/timezone.js';
-import { findUser } from '../services/user.service.js';
+import { findOneClient } from '../services/client.service.js';
+import { findUser, findOneUser } from '../services/user.service.js';
+import { sendPushNotification } from 'tango-app-api-middleware';
+import { findStoreAccuracIssues, upsertStoreAccuracIssues } from '../services/storeAccuracyIssues.service.js';
 dayjs.extend( utc );
 dayjs.extend( timezone );
@@ -24,7 +26,7 @@ export async function createTicket( req, res ) {
     inputData.userName = req?.user?.userName;
     inputData.email = req?.user?.email;
     inputData.role = req?.user?.role;
-    inputData.status = 'open';
+    inputData.status = 'Open';
     inputData.duplicateACCount = 0;
     inputData.employeeACCount = 0;
     inputData.houseKeepingACCount = 0;
@@ -60,6 +62,643 @@ export async function createTicket( req, res ) {
   }
 }
+export async function createinternalTicket( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    let inputData = req.body;
+    let record = {
+      storeId: inputData.storeId,
+      type: 'internal',
+      dateString: inputData.dateString,
+      storeName: inputData?.storeName,
+      ticketName: inputData.ticketName || 'footfall-directory',
+      footfallCount: inputData.footfallCount,
+      clientId: inputData?.clientId,
+      ticketId: 'TE_FDT_' + new Date().valueOf(),
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      status: 'Open',
+      comments: inputData?.comments || '',
+      createdByEmail: req?.user?.email,
+      createdByUserName: req?.user?.userName,
+      createdByRole: req?.user?.role,
+      mappingInfo: [],
+    };
+    const id = `${inputData.storeId}_${inputData.dateString}_internal_footfall-directory-tagging`;
+    let getExistingOne = await getOpenSearchById( openSearch.footfallDirectory, id );
+    if ( getExistingOne?.body?._source ) {
+      return res.sendError( 'Ticket Already Exists', 500 );
+    }
+    const insertResult = await insertWithId( openSearch.footfallDirectory, id, record );
+    if ( insertResult && insertResult.statusCode === 201 ) {
+      return res.sendSuccess( 'Ticket raised successfully' );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, funtion: 'createinternalTicket' } );
+    return res.sendError( err, 500 );
+  }
+}
+export async function tangoReviewTicket( req, res ) {
+  try {
+    const inputData = req.body;
+    logger.info( { inputData, msg: '...........1' } );
+    // get store info by the storeId into mongo db
+    const getstoreName = await findOneStore( { storeId: inputData.storeId, status: 'active' }, { storeId: 1, storeName: 1, clientId: 1 } );
+    logger.info( { getstoreName, msg: '...........2' } );
+    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}`;
+    logger.info( { dateString, msg: '...........3' } );
+    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 );
+    logger.info( { getFootfallCount, msg: '...........4' } );
+    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' );
+    }
+    logger.info( { hits, msg: '...........5' } );
+    // get category details from the client level configuration
+    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1 } );
+    logger.info( { getConfig, msg: '...........6' } );
+    if ( !getConfig || getConfig == null ) {
+      return res.sendError( 'The Client ID is either not configured or not found', 400 );
+    }
+    let findQuery = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+          ],
+        },
+      },
+    };
+    let findTicket = await getOpenSearchData( openSearch.footfallDirectory, findQuery );
+    logger.info( { findTicket, msg: '...........7' } );
+    let Ticket = findTicket.body?.hits?.hits;
+    logger.info( { Ticket, msg: '...........8' } );
+    if ( Ticket.length === 0 ) {
+      return res.sendError( 'Ticket not found', 400 );
+    }
+    const getTicket = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+          ],
+        },
+      },
+    };
+    if ( Ticket[0]?._source?.type !== 'internal' ) {
+      getTicket.query.bool.must.push(
+          {
+            nested: {
+              path: 'mappingInfo',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'mappingInfo.type': 'tangoreview',
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+      );
+    }
+    const getFootfallticketData = await getOpenSearchData( openSearch.footfallDirectory, getTicket );
+    const ticketData = getFootfallticketData?.body?.hits?.hits;
+    logger.info( { ticketData, msg: '...........9' } );
+    if ( !ticketData || ticketData?.length == 0 ) {
+      return res.sendError( 'You don’t have any tagged images right now', 400 );
+    }
+    const record = {
+      status: parseInt( inputData?.mappingInfo?.[0]?.revicedPerc || 0 ) < parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview|| 0 ) ? 'Open - Accuracy Issue' : 'Closed',
+      revicedFootfall: inputData.mappingInfo?.[0]?.revicedFootfall,
+      revicedPerc: inputData.mappingInfo?.[0]?.revicedPerc,
+      mappingInfo: ticketData?.[0]?._source?.mappingInfo,
+      createdByEmail: req?.user?.email,
+      createdByUserName: req?.user?.userName,
+      createdByRole: req?.user?.role,
+    };
+    logger.info( { record, msg: '...........10' } );
+    // Retrieve client footfallDirectoryConfigs revision
+    let isAutoCloseEnable = getConfig.footfallDirectoryConfigs.isAutoCloseEnable;
+    let autoCloseAccuracy = getConfig?.footfallDirectoryConfigs?.autoCloseAccuracy;
+    logger.info( { isAutoCloseEnable, autoCloseAccuracy, msg: '...........11' } );
+    const getNumber = autoCloseAccuracy.split( '%' )[0];
+    logger.info( { getNumber, msg: '...........12' } );
+    let autoCloseAccuracyValue = parseFloat( ( autoCloseAccuracy || getNumber ).replace( '%', '' ) );
+    logger.info( { autoCloseAccuracyValue, msg: '...........13' } );
+    let revisedPercentage = inputData.mappingInfo?.revicedPerc;
+    logger.info( { revisedPercentage, msg: '...........14' } );
+    const revised = Number( revisedPercentage?.split( '%' )[0] );
+    logger.info( { revised, msg: '...........15' } );
+    const tangoReview = Number( getConfig?.footfallDirectoryConfigs?.tangoReview?.split( '%' )[0] );
+    // If autoclose enabled and revisedPercentage meets/exceeds threshold, close ticket and skip revision
+    logger.info( { tangoReview, msg: '...........16' } );
+    if (
+      isAutoCloseEnable === true &&
+      revisedPercentage >= autoCloseAccuracyValue
+    ) {
+      logger.info( { isAutoCloseEnable, revisedPercentage, autoCloseAccuracyValue, msg: '...........17' } );
+      record.status = 'Closed';
+      // Only keep or modify mappingInfo items with type "review"
+      if ( Array.isArray( record.mappingInfo ) ) {
+        logger.info( { msg: '...........18' } );
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === 'tangoreview' )
+            .map( ( item ) => ( {
+              ...item,
+              mode: inputData.mappingInfo?.mode,
+              revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+              revicedPerc: inputData.mappingInfo?.revicedPerc,
+              count: inputData.mappingInfo?.count,
+              revisedDetail: inputData.mappingInfo?.revisedDetail,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+              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: item.type === 'approve'? 'Tango Review Done':'Closed',
+            };
+          } );
+        }
+      }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            mode: inputData.mappingInfo?.mode,
+            revicedFootfall: revisedFootfall,
+            revicedPerc: inputData.mappingInfo?.revicedPerc,
+            count: inputData.mappingInfo?.count,
+            revisedDetail: inputData.mappingInfo?.revisedDetail,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            createdAt: new Date(),
+          },
+      );
+    } else if ( revised < tangoReview ) {
+      logger.info( { msg: '...........19', revised, tangoReview, status: record.status } );
+      // If ticket is closed, do not proceed with revision mapping
+      record.status = 'Open - Accuracy Issue';
+      // Only keep or modify mappingInfo items with type "review"
+      if ( Array.isArray( record.mappingInfo ) ) {
+        logger.info( { msg: '...........20', status: record.status } );
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === 'tangoreview' )
+            .map( ( item ) => ( {
+              ...item,
+              mode: inputData.mappingInfo?.mode,
+              revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+              revicedPerc: inputData.mappingInfo?.revicedPerc,
+              reviced: parseInt( inputData.mappingInfo?.revicedPerc ),
+              count: inputData.mappingInfo?.count,
+              revisedDetail: inputData.mappingInfo?.revisedDetail,
+              status: 'Open - Accuracy Issue',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+              createdAt: 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: item.type === 'approve'? 'Tango Review Done': item.type === 'tangoreview'? 'Open - Accuracy Issue': 'Closed',
+            };
+          } );
+        }
+        record.mappingInfo.push(
+            {
+              type: 'finalRevision',
+              mode: inputData.mappingInfo?.mode,
+              revicedFootfall: inputData.mappingInfo?.revisedFootfall,
+              revicedPerc: inputData.mappingInfo?.revicedPerc,
+              reviced: parseInt( inputData.mappingInfo?.revicedPerc ),
+              count: inputData.mappingInfo?.count,
+              revisedDetail: inputData.mappingInfo?.revisedDetail,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+              createdAt: new Date(),
+            },
+        );
+      }
+    } else {
+      if ( Array.isArray( record.mappingInfo ) ) {
+        logger.info( { msg: '...........21', status: record.status } );
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === 'tangoreview' )
+            .map( ( item ) => ( {
+              ...item,
+              mode: inputData.mappingInfo?.mode,
+              revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+              revicedPerc: inputData.mappingInfo?.revicedPerc,
+              reviced: parseInt( inputData.mappingInfo?.revicedPerc ),
+              count: inputData.mappingInfo?.count,
+              revisedDetail: inputData.mappingInfo?.revisedDetail,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+              createdAt: 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: item.type === 'approve'?'Tango Review Done': 'Closed',
+            };
+          } );
+        }
+      }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            mode: inputData.mappingInfo?.mode,
+            revicedFootfall: inputData.mappingInfo?.revicedFootfall,
+            revicedPerc: inputData.mappingInfo?.revicedPerc,
+            reviced: parseInt( inputData.mappingInfo?.revicedPerc ),
+            count: inputData.mappingInfo?.count,
+            revisedDetail: inputData.mappingInfo?.revisedDetail,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            createdAt: new Date(),
+          },
+      );
+    }
+    if ( Ticket[0]?._source?.type==='store' ) {
+      let findTagging = Ticket[0]?._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[0]?._source?.dateString ).format( 'DD MMM YYYY' );
+        let description = `Raised on ${createdOn}`;
+        let Data = {
+          'title': title,
+          'body': description,
+          'type': 'closed',
+          'date': Ticket[0]?._source?.dateString,
+          'storeId': Ticket[0]?._source?.storeId,
+          'clientId': Ticket[0]?._source?.clientId,
+          'ticketId': Ticket[0]?._source?.ticketId,
+        };
+        if ( userData && userData.fcmToken ) {
+          const fcmToken = userData.fcmToken;
+          await sendPushNotification( title, description, fcmToken, Data );
+        }
+      }
+    }
+    // return;
+    let id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
+    let getExistingOne = await getOpenSearchById( openSearch.footfallDirectory, id );
+    if ( inputData.ticketType === 'internal' &&!getExistingOne?.body?._source ) {
+      id = `${inputData.storeId}_${inputData.dateString}_internal_footfall-directory-tagging`;
+    }
+    const insertResult = await updateOpenSearchData( openSearch.footfallDirectory, id, { doc: record } );
+    if ( insertResult && ( insertResult.statusCode === 201 || insertResult.statusCode === 200 ) ) {
+      if ( ( record.status === 'Closed' || record.status === 'Open - Accuracy Issue' ) && inputData.ticketType !== 'internal' ) {
+        const query = {
+          storeId: inputData?.storeId,
+          isVideoStream: true,
+        };
+        const getStoreType = await countDocumnetsCamera( query );
+        // Get all tempIds from revopInfo response
+        const temp = [];
+        inputData?.mappingInfo?.revisedDetail?.map( ( hit ) => temp.push( { tempId: hit?.tempId } ) ) || [];
+        logger.info( { msg: '...........22', temp, revisedDetails: inputData?.revisedDetail } );
+        // Prepare management eyeZone query based on storeId and dateString
+        const isSendMessge = await sendSqsMessage( inputData, temp, getStoreType, inputData.storeId );
+        if ( isSendMessge === true ) {
+          logger.info( '....1' );
+        }
+      }
+      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: 'tangoReviewTicket' } );
+    return res.sendError( err, 500 );
+  }
+}
+export async function tangoReviewAccuracyClosedTicket( req, res ) {
+  try {
+    const inputData = req.body;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    let findQuery = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+          ],
+        },
+      },
+    };
+    let findTicket = await getOpenSearchData( openSearch.footfallDirectory, findQuery );
+    let Ticket = findTicket.body?.hits?.hits;
+    if ( Ticket.length === 0 ) {
+      return res.sendError( 'Ticket not found', 400 );
+    }
+    const getTicket = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+          ],
+        },
+      },
+    };
+    if ( Ticket[0]?._source?.type !== 'internal' ) {
+      getTicket.query.bool.must.push(
+          {
+            nested: {
+              path: 'mappingInfo',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'mappingInfo.type': 'tangoreview',
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+      );
+    }
+    const getFootfallticketData = await getOpenSearchData( openSearch.footfallDirectory, getTicket );
+    const ticketData = getFootfallticketData?.body?.hits?.hits;
+    if ( !ticketData || ticketData?.length == 0 ) {
+      return res.sendError( 'You don’t have any tagged images right now', 400 );
+    }
+    const record = {
+      status: 'Closed - Accuracy Issue',
+      createdByEmail: req?.user?.email,
+      createdByUserName: req?.user?.userName,
+      createdByRole: req?.user?.role,
+      mappingInfo: ticketData?.[0]?._source?.mappingInfo,
+    };
+    // If autoclose enabled and revisedPercentage meets/exceeds threshold, close ticket and skip revision
+    if ( Array.isArray( record.mappingInfo ) ) {
+      const temp = record.mappingInfo
+          .filter( ( item ) => item.type === 'tangoreview' )
+          .map( ( item ) => ( {
+            ...item,
+            status: 'Closed - Accuracy Issue',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            comments: inputData?.comments || '',
+            subComments: inputData?.subComments ||'',
+          } ) );
+      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',
+      //     };
+      //   } );
+      // }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            mode: 'web',
+            revicedFootfall: temp?.[0]?.revicedFootfall,
+            revicedPerc: temp?.[0].revicedPerc,
+            count: temp?.[0].count,
+            revisedDetail: temp?.[0]?.revisedDetail,
+            status: 'Closed',
+            createdByEmail: req?.user?.email,
+            createdByUserName: req?.user?.userName,
+            createdByRole: req?.user?.role,
+            createdAt: new Date(),
+            comments: inputData?.comments || '',
+            subComments: inputData?.subComments || '',
+          },
+      );
+    }
+    // return;
+    let 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 ) ) {
+      const query = {
+        storeId: inputData?.storeId,
+        isVideoStream: true,
+      };
+      const getStoreType = await countDocumnetsCamera( query );
+      const revopInfoQuery = {
+        size: 10000,
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'storeId.keyword': inputData.storeId,
+                },
+              },
+              {
+                term: {
+                  'dateString': inputData.dateString,
+                },
+              },
+              {
+                term: {
+                  'isParent': false,
+                },
+              },
+              {
+                term: {
+                  isChecked: true,
+                },
+              },
+            ],
+          },
+        },
+        _source: [ 'tempId' ],
+      };
+      const revopInfo = await getOpenSearchData( openSearch.revop, revopInfoQuery );
+      // Get all tempIds from revopInfo response
+      const tempIds = revopInfo?.body?.hits?.hits?.map( ( hit ) => hit?._source?.tempId ).filter( Boolean ) || [];
+      // Prepare management eyeZone query based on storeId and dateString
+      const managerEyeZoneQuery = {
+        size: 1,
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'storeId.keyword': inputData.storeId,
+                },
+              },
+              {
+                term: {
+                  'storeDate': inputData.dateString,
+                },
+              },
+            ],
+          },
+        },
+        _source: [ 'originalToTrackerCustomerMapping' ],
+      };
+      // Query the managerEyeZone index for the matching document
+      const managerEyeZoneResp = await getOpenSearchData( openSearch.managerEyeZone, managerEyeZoneQuery );
+      const managerEyeZoneHit = managerEyeZoneResp?.body?.hits?.hits?.[0]?._source;
+      // Extract originalToTrackerCustomerMapping if it exists
+      const mapping =
+            managerEyeZoneHit && managerEyeZoneHit.originalToTrackerCustomerMapping ?
+              managerEyeZoneHit.originalToTrackerCustomerMapping :
+              {};
+      // 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 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: 'tangoReviewAccuracyClosedTicket' } );
+    return res.sendError( err, 500 );
+  }
+}
 async function bulkUpdateStatusToPending( indexName, inputData ) {
   const bulkBody = [];
@@ -195,7 +834,6 @@ export async function ticketSummary1( req, res ) {
     const getData = await getOpenSearchData( openSearch.footfallDirectory, getQuery );
     const aggs = getData?.body?.aggregations;
-    logger.info( { aggs: aggs, body: getData?.body } );
     const result = {
       totalTickets: aggs.totalTicketCount.value,
@@ -218,426 +856,2424 @@ export async function ticketSummary1( req, res ) {
 export async function ticketSummary( req, res ) {
   try {
+    const inputData = req.query;
     let result = '';
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     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 ( req.user.userType =='tango' ) {
-      result ={
-        totalTickets: 0,
-        averageAccuracyOverAll: 0,
-        openTickets: 0,
-        openInfraIssues: 0,
-        inprogress: 0,
-        closedTickets: 0,
-        ticketAccuracyAbove: '0%',
-        ticketAccuracyBelow: '0%',
-      };
-    } else {
-      result = req.user.role === 'superadmin'?
-{
-  totalTickets: 0,
-  openTickets: 0,
-  inprogress: 0,
-  closedTickets: 0,
-  dueToday: 0,
-  Expired: 0,
-  underTangoReview: 0,
-  avgTicket: '0%',
-  avgAccuracy: '0%',
-} :
-req.user.role === 'user'? 'NA':
-ticketsFeature?
-{
-  totalTickets: 0,
-  openTickets: 0,
-  inprogress: 0,
-  closedTickets: 0,
-  dueToday: 0,
-  Expired: 0,
-  avgTicket: '0%',
-  avgAccuracy: '0%',
-}: 'NA';
+    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'reviewer' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+    const ticketsApproveFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'approver' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+    const getConfig = await findOneClient( { clientId: inputData?.clientId }, { footfallDirectoryConfigs: 1 } );
+    if ( !getConfig || getConfig ==null ) {
+      return res.sendError( 'this client not configured against footfall directory', 400 );
     }
+    inputData.clientId = inputData?.clientId?.split( ',' );
+    // const ticketsApproveFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'approver' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+    if ( req?.user?.userType === 'tango' ) {
+      switch ( inputData?.tangoType ) {
+        case 'store':
+          const storeQuery = {
+            size: 0,
+            query: {
+              bool: {
+                must: [
+                  {
+                    'range': {
+                      'dateString': {
+                        'gte': inputData?.fromDate,
+                        'lte': inputData?.toDate,
+                        'format': 'yyyy-MM-dd',
+                      },
+                    },
+                  },
-    return res.sendSuccess( { result: result } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, messgage: req.query } );
-    return res.sendSuccess( err, 500 );
-  }
-}
+                  {
+                    terms: {
+                      'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                        inputData.clientId :
+                        [ inputData.clientId ],
+                    },
-export async function ticketList1( req, res ) {
-  try {
-    const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const inputData = req.query;
-    const limit = inputData.limit || 10;
-    const offset = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
-    const order = inputData?.sortOrder || -1;
+                  },
-    inputData.clientId = inputData.clientId.split( ',' ); // convert strig to array
+                  {
+                    range: {
+                      reviced: {
+                        lt: parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview ),
+                      }
+                      ,
+                    },
+                  },
+                  {
+                    nested: {
+                      path: 'mappingInfo',
+                      query: {
+                        bool: {
+                          must: [
+                            {
+                              term: {
+                                'mappingInfo.type': 'tangoreview',
+                              },
+                            },
+                          ],
+                        },
+                      },
+                    },
+                  },
+                ],
+              },
+            },
+          };
+          // Helper function to clone deep and replace mappingInfo.status for openTickets/closed/etc
+          function buildStoreQueryWithStatus( baseQuery, statusValue ) {
+            let q = JSON.parse( JSON.stringify( baseQuery ) );
+            // Remove any previous mappingInfo.status term
+            let nested = q.query.bool.must.find( ( m ) => m.nested );
+            if ( nested ) {
+              // filter out all mappingInfo.status
+              nested.nested.query.bool.must = nested?.nested?.query?.bool?.must.filter( ( mustItem ) => {
+                return !( mustItem.term && mustItem.term['mappingInfo.status'] );
+              } );
+              // add desired status
+              nested.nested.query.bool.must.push( {
+                term: {
+                  'mappingInfo.status': statusValue,
+                },
+              } );
+            }
+            return q;
+          }
-    let filter = [
-      {
-        'range': {
-          'dateString': {
-            'gte': inputData.fromDate,
-            'lte': inputData.toDate,
+          const buildAggStoreQuery = ( baseQuery, filters = [] ) => {
+            const q = JSON.parse( JSON.stringify( baseQuery ) );
+            // locate nested section
+            const nested = q.query.bool.must.find( ( m ) => m.nested );
+            if ( nested ) {
+              // remove old status filters
+              nested.nested.query.bool.must =
+                nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
+              // add new filters
+              nested.nested.query.bool.must.push( ...filters );
+            }
+            return {
+              ...q,
+              size: 0,
+              aggs: {
+                avg_value: {
+                  avg: 'reviced',
+                },
+              },
+            };
+          };
+          // Get OpenSearch connection
+          const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
+          // Total Tickets (all tickets with mappingInfo.type == tangoreview)
+          let totalTickets = 0;
+          let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          allQuery.size = 0;
+          const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
+          totalTickets = totalResp?.body?.hits?.total?.value || 0;
+          // openTickets: mappingInfo.status: 'Open'
+          let openTickets = 0;
+          let otQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open' );
+          otQ.size = 0;
+          const openResp = await getOpenSearchData( openSearch.footfallDirectory, otQ );
+          openTickets = openResp?.body?.hits?.total?.value || 0;
+          // logger.info( { msd: '..............2', openResp } );
+          // openInfraIssues: mappingInfo.status: 'Open Accuracy Issue'
+          let openInfraIssues = 0;
+          let oiQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open - Accuracy Issue' );
+          oiQ.size = 0;
+          const infraResp = await getOpenSearchData( openSearch.footfallDirectory, oiQ );
+          openInfraIssues = infraResp?.body?.hits?.total?.value || 0;
+          // inprogress: mappingInfo.status: 'in-Progress'
+          let inprogress = 0;
+          let ipQ = buildStoreQueryWithStatus( baseStoreQuery, 'In-Progress' );
+          ipQ.size = 0;
+          const ipResp = await getOpenSearchData( openSearch.footfallDirectory, ipQ );
+          inprogress = ipResp?.body?.hits?.total?.value || 0;
+          // closedTickets: mappingInfo.status: 'closed'
+          let closedTickets = 0;
+          let clQ = buildStoreQueryWithStatus( baseStoreQuery, 'Closed' );
+          clQ.size = 0;
+          const clResp = await getOpenSearchData( openSearch.footfallDirectory, clQ );
+          closedTickets = clResp?.body?.hits?.total?.value || 0;
+          // Average revisedPerc (for all tangoreview)
+          let averageAccuracyOverAll = 0;
+          let avgQ = buildAggStoreQuery( baseStoreQuery );
+          const avgResp = await getOpenSearchData( openSearch.footfallDirectory, avgQ );
+          averageAccuracyOverAll = avgResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          // ticketAccuracyAbove: avg of revicedPerc > 85%
+          let ticketAccuracyAbove = 0;
+          // For this, add a filter on revicedPerc >= 85
+          let aboveQ = buildAggStoreQuery( baseStoreQuery, [
+            {
+              range: {
+                reviced: {
+                  gte: parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview ),
+                },
+              },
+            },
+          ] );
+          const aboveResp = await getOpenSearchData( openSearch.footfallDirectory, aboveQ );
+          ticketAccuracyAbove = aboveResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          // ticketAccuracyBelow: avg of revicedPerc < 85%
+          let ticketAccuracyBelow = 0;
+          let belowQ = buildAggStoreQuery( baseStoreQuery, [
+            {
+              range: {
+                reviced: {
+                  lt: parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview ),
+                },
+              },
+            },
+          ] );
+          const belowResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
+          ticketAccuracyBelow = belowResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          // Final result object
+          result = {
+            totalTickets,
+            averageAccuracyOverAll: averageAccuracyOverAll+'%',
+            openTickets,
+            openInfraIssues,
+            inprogress,
+            closedTickets,
+            ticketAccuracyAbove: ticketAccuracyAbove+'%',
+            ticketAccuracyBelow: ticketAccuracyBelow+'%',
+          };
+          break;
+        case 'internal':
+          const internalQuery = {
+            size: 0,
+            query: {
+              bool: {
+                must: [
+                  {
+                    'range': {
+                      'dateString': {
+                        'gte': inputData?.fromDate,
+                        'lte': inputData?.toDate,
+                        'format': 'yyyy-MM-dd',
+                      },
+                    },
+                  },
+                  {
+                    terms: {
+                      'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                        inputData.clientId :
+                        [ inputData.clientId ],
+                    },
+                  },
+                ],
+              },
+            },
+          };
+          const internalOpen = {
+            size: 0,
+            query: {
+              bool: {
+                must: [
+                  {
+                    'range': {
+                      'dateString': {
+                        'gte': inputData?.fromDate,
+                        'lte': inputData?.toDate,
+                        'format': 'yyyy-MM-dd',
+                      },
+                    },
+                  },
+                  {
+                    terms: {
+                      'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                        inputData.clientId :
+                        [ inputData.clientId ],
+                    },
+                  },
+                  {
+                    terms: {
+                      'status.keyword': [ 'Open', 'Raised' ],
+                    },
+                  },
+                ],
+              },
+            },
+          };
+          // Helper function to clone deep and replace mappingInfo.status for openTickets/closed/etc
+          function buildInternalQueryWithStatus( baseQuery, statusValue ) {
+            let q = JSON.parse( JSON.stringify( baseQuery ) );
+            // Check if nested query exists, if not create it
+            let nested = q.query.bool.must.find( ( m ) => m.nested );
+            if ( !nested ) {
+              // Create nested query structure
+              nested = {
+                nested: {
+                  path: 'mappingInfo',
+                  query: {
+                    bool: {
+                      must: [],
+                    },
+                  },
+                },
+              };
+              q.query.bool.must.push( nested );
+            }
+            // filter out all mappingInfo.status
+            nested.nested.query.bool.must = nested?.nested?.query?.bool?.must.filter( ( mustItem ) => {
+              return !( mustItem.term && mustItem.term['mappingInfo.status'] );
+            } );
+            // add desired status
+            nested.nested.query.bool.must.push( {
+              term: {
+                'mappingInfo.status': statusValue,
+              },
+            } );
+            return q;
+          }
+          const buildAggInternalQuery = ( baseQuery, filters = [] ) => {
+            const q = JSON.parse( JSON.stringify( baseQuery ) );
+            // locate nested section
+            const nested = q.query.bool.must.find( ( m ) => m.nested );
+            if ( nested ) {
+              // remove old status filters
+              nested.nested.query.bool.must =
+                nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
+              // add new filters
+              q.query.bool.must.push( ...filters );
+            }
+            return {
+              ...q,
+              size: 0,
+              aggs: {
+                avg_value: {
+                  avg: {
+                    field: 'reviced',
+                  },
+                },
+              },
+            };
+          };
+          // Get OpenSearch connection
+          const baseInternalQuery = JSON.parse( JSON.stringify( internalQuery ) );
+          // Total Tickets (all tickets with mappingInfo.type == tangoreview)
+          let totalInternalTickets = 0;
+          let allInternalQuery = JSON.parse( JSON.stringify( baseInternalQuery ) );
+          allInternalQuery.size = 0;
+          const totalInternalResp = await getOpenSearchData( openSearch.footfallDirectory, allInternalQuery );
+          totalInternalTickets = totalInternalResp?.body?.hits?.total?.value || 0;
+          logger.info( { totalInternalResp } );
+          // openTickets: mappingInfo.status: 'Open'
+          let openInternalTickets = 0;
+          // let otQInternal = buildInternalQueryWithStatus( baseInternalQuery, 'Open' );
+          // otQInternal.size = 0;
+          const openInternalResp = await getOpenSearchData( openSearch.footfallDirectory, internalOpen );
+          openInternalTickets = openInternalResp?.body?.hits?.total?.value || 0;
+          // logger.info( { msd: '..............2', openResp } );
+          // openInfraIssues: mappingInfo.status: 'Open Accuracy Issue'
+          let openInternalInfraIssues = 0;
+          let oiQinternal = buildInternalQueryWithStatus( baseInternalQuery, 'Open - Accuracy Issue' );
+          oiQinternal.size = 0;
+          const infraInternalResp = await getOpenSearchData( openSearch.footfallDirectory, oiQinternal );
+          openInternalInfraIssues = infraInternalResp?.body?.hits?.total?.value || 0;
+          // inprogress: mappingInfo.status: 'in-Progress'
+          let inprogressIntrenal = 0;
+          let ipQInternal = buildInternalQueryWithStatus( baseInternalQuery, 'In-Progress' );
+          ipQInternal.size = 0;
+          const ipInternalResp = await getOpenSearchData( openSearch.footfallDirectory, ipQInternal );
+          inprogressIntrenal = ipInternalResp?.body?.hits?.total?.value || 0;
+          // closedTickets: mappingInfo.status: 'closed'
+          let closedInternalTickets = 0;
+          let clQInternal = buildInternalQueryWithStatus( baseInternalQuery, 'Closed' );
+          clQInternal.size = 0;
+          const clInternalResp = await getOpenSearchData( openSearch.footfallDirectory, clQInternal );
+          closedInternalTickets = clInternalResp?.body?.hits?.total?.value || 0;
+          // Average revisedPerc (for all tangoreview)
+          let internalAverageAccuracyOverAll = 0;
+          let avgQInternal = buildAggInternalQuery( baseInternalQuery );
+          const avgInternalResp = await getOpenSearchData( openSearch.footfallDirectory, avgQInternal );
+          internalAverageAccuracyOverAll = avgInternalResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          // ticketAccuracyAbove: avg of revicedPerc > 85%
+          let internalTicketAccuracyAbove = 0;
+          // For this, add a filter on revicedPerc >= 85
+          let aboveQinternal = buildAggInternalQuery( baseInternalQuery, [
+            {
+              range: {
+                reviced: {
+                  gte: parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview ),
+                },
+              },
+            },
+          ] );
+          const aboveRespInternal = await getOpenSearchData( openSearch.footfallDirectory, aboveQinternal );
+          internalTicketAccuracyAbove = aboveRespInternal?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          // ticketAccuracyBelow: avg of revicedPerc < 85%
+          let internalTicketAccuracyBelow = 0;
+          let belowQIneranl = buildAggInternalQuery( baseInternalQuery, [
+            {
+              range: {
+                reviced: {
+                  lt: parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview ),
+                },
+              },
+            },
+          ] );
+          const belowRespInternal = await getOpenSearchData( openSearch.footfallDirectory, belowQIneranl );
+          internalTicketAccuracyBelow = belowRespInternal?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          // Final result object
+          result = {
+            totalTickets: totalInternalTickets,
+            averageAccuracyOverAll: internalAverageAccuracyOverAll+'%',
+            openTickets: openInternalTickets,
+            openInfraIssues: openInternalInfraIssues,
+            inprogress: inprogressIntrenal,
+            closedTickets: closedInternalTickets,
+            ticketAccuracyAbove: internalTicketAccuracyAbove+'%',
+            ticketAccuracyBelow: internalTicketAccuracyBelow+'%',
+          };
+          break;
+        default: '';
+      }
+    } else if ( req?.user?.userType !== 'tango' ) {
+      if ( ticketsFeature && !ticketsApproveFeature ) {
+        const storeQuery = {
+          size: 0,
+          query: {
+            bool: {
+              must: [
+                {
+                  'range': {
+                    'dateString': {
+                      'gte': inputData?.fromDate,
+                      'lte': inputData?.toDate,
+                      'format': 'yyyy-MM-dd',
+                    },
+                  },
+                },
+                {
+                  terms: {
+                    'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                      inputData.clientId :
+                      [ inputData.clientId ],
+                  },
+                },
+                {
+                  nested: {
+                    path: 'mappingInfo',
+                    query: {
+                      bool: {
+                        must: [
+                          {
+                            term: {
+                              'mappingInfo.type': 'review',
+                            },
+                          },
+                        ],
+                      },
+                    },
+                  },
+                },
+              ],
+            },
+          },
+        };
+        // Helper function to clone deep and replace mappingInfo.status for openTickets/closed/etc
+        function buildStoreQueryWithStatus( baseQuery, statusValue ) {
+          let q = JSON.parse( JSON.stringify( baseQuery ) );
+          // Remove any previous mappingInfo.status term
+          let nested = q.query.bool.must.find( ( m ) => m.nested );
+          if ( nested ) {
+            // filter out all mappingInfo.status
+            nested.nested.query.bool.must = nested?.nested?.query?.bool?.must.filter( ( mustItem ) => {
+              return !( mustItem.term && mustItem.term['mappingInfo.status'] );
+            } );
+            // add desired status
+            nested.nested.query.bool.must.push( {
+              term: {
+                'mappingInfo.status': statusValue,
+              },
+            } );
+          }
+          return q;
+        }
+        const buildAggStoreQuery = ( baseQuery, filters = [] ) => {
+          const q = JSON.parse( JSON.stringify( baseQuery ) );
+          // locate nested section
+          const nested = q.query.bool.must.find( ( m ) => m.nested );
+          if ( nested ) {
+            // remove old status filters
+            nested.nested.query.bool.must =
+              nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
+            // add new filters
+            nested.nested.query.bool.must.push( ...filters );
+          }
+          return {
+            ...q,
+            size: 0,
+            aggs: {
+              avg_value: {
+                avg: 'mappingInfo.reviced',
+              },
+            },
+          };
+        };
+        // Get OpenSearch connection
+        const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
+        // Total Tickets (all tickets with mappingInfo.type == tangoreview)
+        let totalTickets = 0;
+        let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+        allQuery.size = 0;
+        const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
+        totalTickets = totalResp?.body?.hits?.total?.value || 0;
+        // openTickets: mappingInfo.status: 'Open'
+        let openTickets = 0;
+        let otQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open' );
+        otQ.size = 0;
+        const openResp = await getOpenSearchData( openSearch.footfallDirectory, otQ );
+        openTickets = openResp?.body?.hits?.total?.value || 0;
+        // logger.info( { msd: '..............2', openResp } );
+        // inprogress: mappingInfo.status: 'in-Progress'
+        let inprogress = 0;
+        let ipQ = buildStoreQueryWithStatus( baseStoreQuery, 'In-Progress' );
+        ipQ.size = 0;
+        const ipResp = await getOpenSearchData( openSearch.footfallDirectory, ipQ );
+        inprogress = ipResp?.body?.hits?.total?.value || 0;
+        // closedTickets: mappingInfo.status: 'closed'
+        let closedTickets = 0;
+        let clQ = buildStoreQueryWithStatus( baseStoreQuery, 'Closed' );
+        clQ.size = 0;
+        const clResp = await getOpenSearchData( openSearch.footfallDirectory, clQ );
+        closedTickets = clResp?.body?.hits?.total?.value || 0;
+        let dueToday = 0;
+        let todayDateString = new Date().toISOString().slice( 0, 10 );
+        // Build a query for tickets with mappingInfo.dueDate == todayDateString
+        let dueTodayQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+        // Locate nested mappingInfo query
+        let nestedDue = dueTodayQuery.query.bool.must.find( ( m ) => m.nested );
+        if ( nestedDue ) {
+          // Remove any previous mappingInfo.dueDate term
+          nestedDue.nested.query.bool.must = nestedDue.nested.query.bool.must.filter(
+              ( mustItem ) => !( mustItem.term && mustItem.term['mappingInfo.dueDate'] ),
+          );
+          // Add new dueDate filter
+          nestedDue.nested.query.bool.must.push( {
+            term: { 'mappingInfo.dueDate': todayDateString },
+          } );
+        }
+        dueTodayQuery.size = 0;
+        const dueTodayResp = await getOpenSearchData( openSearch.footfallDirectory, dueTodayQuery );
+        dueToday = dueTodayResp?.body?.hits?.total?.value || 0;
+        // filter expired Tickets
+        let expiredTickets = 0;
+        let eQ = buildStoreQueryWithStatus( baseStoreQuery, 'Under Tango Review' );
+        eQ.size = 0;
+        const eResp = await getOpenSearchData( openSearch.footfallDirectory, eQ );
+        expiredTickets = eResp?.body?.hits?.total?.value || 0;
+        // Calculate average ticket percentage: avg((reviced/footfallCount)*100) filtered by baseStoreQuery
+        // Build aggregation query for ticket percentage
+        let ticketPercentageAvg = 0;
+        let avgTicketPercentageQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+        avgTicketPercentageQuery.size = 0;
+        avgTicketPercentageQuery.aggs = {
+          avg_ticket_percentage: {
+            avg: {
+              script: {
+                source: `
+                  if (doc.containsKey('reviced') && doc['reviced'].size()!=0 &&
+                      doc.containsKey('footfallCount') && doc['footfallCount'].size()!=0 && doc['footfallCount'].value != 0) {
+                    return (doc['reviced'].value / doc['footfallCount'].value) * 100;
+                  } else {
+                    return null;
+                  }
+                `,
+                lang: 'painless',
+              },
+            },
+          },
+        };
+        const avgTicketPercentageResp = await getOpenSearchData( openSearch.footfallDirectory, avgTicketPercentageQuery );
+        ticketPercentageAvg = avgTicketPercentageResp?.body?.aggregations?.avg_ticket_percentage?.value?.toFixed( 2 ) || '0';
+        logger.info( { avgTicketPercentageResp } );
+        // ticketAccuracyBelow: avg of revicedPerc < 85%
+        let ticketAccuracy = 0;
+        let belowQ = buildAggStoreQuery( baseStoreQuery );
+        logger.info( { belowQ } );
+        const accuracyResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
+        ticketAccuracy = accuracyResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+        logger.info( { accuracyResp } );
+        // Final result object
+        result = {
+          totalTickets,
+          openTickets,
+          inprogress,
+          closedTickets,
+          dueToday: dueToday,
+          Expired: expiredTickets,
+          avgTicket: ticketPercentageAvg+'%',
+          avgAccuracy: ticketAccuracy+'%',
+        };
+      } else if ( ticketsFeature && ticketsApproveFeature ) {
+        if ( inputData?.permissionType === 'review' ) {
+          const storeQuery = {
+            size: 0,
+            query: {
+              bool: {
+                must: [
+                  {
+                    'range': {
+                      'dateString': {
+                        'gte': inputData?.fromDate,
+                        'lte': inputData?.toDate,
+                        'format': 'yyyy-MM-dd',
+                      },
+                    },
+                  },
+                  {
+                    terms: {
+                      'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                        inputData.clientId :
+                        [ inputData.clientId ],
+                    },
+                  },
+                  {
+                    nested: {
+                      path: 'mappingInfo',
+                      query: {
+                        bool: {
+                          must: [
+                            {
+                              term: {
+                                'mappingInfo.type': 'review',
+                              },
+                            },
+                          ],
+                        },
+                      },
+                    },
+                  },
+                ],
+              },
+            },
+          };
+          // Helper function to clone deep and replace mappingInfo.status for openTickets/closed/etc
+          function buildStoreQueryWithStatus( baseQuery, statusValue ) {
+            let q = JSON.parse( JSON.stringify( baseQuery ) );
+            // Remove any previous mappingInfo.status term
+            let nested = q.query.bool.must.find( ( m ) => m.nested );
+            if ( nested ) {
+              // filter out all mappingInfo.status
+              nested.nested.query.bool.must = nested?.nested?.query?.bool?.must.filter( ( mustItem ) => {
+                return !( mustItem.term && mustItem.term['mappingInfo.status'] );
+              } );
+              // add desired status
+              nested.nested.query.bool.must.push( {
+                term: {
+                  'mappingInfo.status': statusValue,
+                },
+              } );
+            }
+            return q;
+          }
+          const buildAggStoreQuery = ( baseQuery, filters = [] ) => {
+            const q = JSON.parse( JSON.stringify( baseQuery ) );
+            // locate nested section
+            const nested = q.query.bool.must.find( ( m ) => m.nested );
+            if ( nested ) {
+              // remove old status filters
+              nested.nested.query.bool.must =
+                nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
+              // add new filters
+              nested.nested.query.bool.must.push( ...filters );
+            }
+            return {
+              ...q,
+              size: 0,
+              aggs: {
+                avg_value: {
+                  avg: 'mappingInfo.reviced',
+                },
+              },
+            };
+          };
+          // Get OpenSearch connection
+          const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
+          // Total Tickets (all tickets with mappingInfo.type == tangoreview)
+          let totalTickets = 0;
+          let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          allQuery.size = 0;
+          const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
+          totalTickets = totalResp?.body?.hits?.total?.value || 0;
+          // openTickets: mappingInfo.status: 'Open'
+          let openTickets = 0;
+          let otQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open' );
+          otQ.size = 0;
+          const openResp = await getOpenSearchData( openSearch.footfallDirectory, otQ );
+          openTickets = openResp?.body?.hits?.total?.value || 0;
+          // logger.info( { msd: '..............2', openResp } );
+          // inprogress: mappingInfo.status: 'in-Progress'
+          let inprogress = 0;
+          let ipQ = buildStoreQueryWithStatus( baseStoreQuery, 'In-Progress' );
+          ipQ.size = 0;
+          const ipResp = await getOpenSearchData( openSearch.footfallDirectory, ipQ );
+          inprogress = ipResp?.body?.hits?.total?.value || 0;
+          // closedTickets: mappingInfo.status: 'closed'
+          let closedTickets = 0;
+          let clQ = buildStoreQueryWithStatus( baseStoreQuery, 'Closed' );
+          clQ.size = 0;
+          const clResp = await getOpenSearchData( openSearch.footfallDirectory, clQ );
+          closedTickets = clResp?.body?.hits?.total?.value || 0;
+          let dueToday = 0;
+          let todayDateString = new Date().toISOString().slice( 0, 10 );
+          // Build a query for tickets with mappingInfo.dueDate == todayDateString
+          let dueTodayQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          // Locate nested mappingInfo query
+          let nestedDue = dueTodayQuery.query.bool.must.find( ( m ) => m.nested );
+          if ( nestedDue ) {
+            // Remove any previous mappingInfo.dueDate term
+            nestedDue.nested.query.bool.must = nestedDue.nested.query.bool.must.filter(
+                ( mustItem ) => !( mustItem.term && mustItem.term['mappingInfo.dueDate'] ),
+            );
+            // Add new dueDate filter
+            nestedDue.nested.query.bool.must.push( {
+              term: { 'mappingInfo.dueDate': todayDateString },
+            } );
+          }
+          dueTodayQuery.size = 0;
+          const dueTodayResp = await getOpenSearchData( openSearch.footfallDirectory, dueTodayQuery );
+          dueToday = dueTodayResp?.body?.hits?.total?.value || 0;
+          // filter expired Tickets
+          let expiredTickets = 0;
+          let eQ = buildStoreQueryWithStatus( baseStoreQuery, 'Under Tango Review' );
+          eQ.size = 0;
+          const eResp = await getOpenSearchData( openSearch.footfallDirectory, eQ );
+          expiredTickets = eResp?.body?.hits?.total?.value || 0;
+          // Calculate average ticket percentage: avg((reviced/footfallCount)*100) filtered by baseStoreQuery
+          // Build aggregation query for ticket percentage
+          let ticketPercentageAvg = 0;
+          let avgTicketPercentageQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          avgTicketPercentageQuery.size = 0;
+          avgTicketPercentageQuery.aggs = {
+            avg_ticket_percentage: {
+              avg: {
+                script: {
+                  source: `
+                    if (doc.containsKey('reviced') && doc['reviced'].size()!=0 &&
+                        doc.containsKey('footfallCount') && doc['footfallCount'].size()!=0 && doc['footfallCount'].value != 0) {
+                      return (doc['reviced'].value / doc['footfallCount'].value) * 100;
+                    } else {
+                      return null;
+                    }
+                  `,
+                  lang: 'painless',
+                },
+              },
+            },
+          };
+          const avgTicketPercentageResp = await getOpenSearchData( openSearch.footfallDirectory, avgTicketPercentageQuery );
+          ticketPercentageAvg = avgTicketPercentageResp?.body?.aggregations?.avg_ticket_percentage?.value?.toFixed( 2 ) || '0';
+          logger.info( { avgTicketPercentageResp } );
+          // ticketAccuracyBelow: avg of revicedPerc < 85%
+          let ticketAccuracy = 0;
+          let belowQ = buildAggStoreQuery( baseStoreQuery );
+          logger.info( { belowQ } );
+          const accuracyResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
+          ticketAccuracy = accuracyResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          logger.info( { accuracyResp } );
+          // Final result object
+          result = {
+            totalTickets,
+            openTickets,
+            inprogress,
+            closedTickets,
+            dueToday: dueToday,
+            Expired: expiredTickets,
+            avgTicket: ticketPercentageAvg+'%',
+            avgAccuracy: ticketAccuracy+'%',
+          };
+        } else {
+          const storeQuery = {
+            size: 0,
+            query: {
+              bool: {
+                must: [
+                  {
+                    'range': {
+                      'dateString': {
+                        'gte': inputData?.fromDate,
+                        'lte': inputData?.toDate,
+                        'format': 'yyyy-MM-dd',
+                      },
+                    },
+                  },
+                  {
+                    terms: {
+                      'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                        inputData.clientId :
+                        [ inputData.clientId ],
+                    },
+                  },
+                  {
+                    nested: {
+                      path: 'mappingInfo',
+                      query: {
+                        bool: {
+                          must: [
+                            {
+                              term: {
+                                'mappingInfo.type': inputData.permissionType === 'review'? 'review':'approve',
+                              },
+                            },
+                          ],
+                        },
+                      },
+                    },
+                  },
+                ],
+              },
+            },
+          };
+          // Helper function to clone deep and replace mappingInfo.status for openTickets/closed/etc
+          function buildStoreQueryWithStatus( baseQuery, statusValue ) {
+            let q = JSON.parse( JSON.stringify( baseQuery ) );
+            // Remove any previous mappingInfo.status term
+            let nested = q.query.bool.must.find( ( m ) => m.nested );
+            if ( nested ) {
+              // filter out all mappingInfo.status
+              nested.nested.query.bool.must = nested?.nested?.query?.bool?.must.filter( ( mustItem ) => {
+                return !( mustItem.term && mustItem.term['mappingInfo.status'] );
+              } );
+              // add desired status
+              nested.nested.query.bool.must.push( {
+                term: {
+                  'mappingInfo.status': statusValue,
+                },
+              } );
+            }
+            return q;
+          }
+          const buildAggStoreQuery = ( baseQuery, filters = [] ) => {
+            const q = JSON.parse( JSON.stringify( baseQuery ) );
+            // locate nested section
+            const nested = q.query.bool.must.find( ( m ) => m.nested );
+            if ( nested ) {
+              // remove old status filters
+              nested.nested.query.bool.must =
+                nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
+              // add new filters
+              nested.nested.query.bool.must.push( ...filters );
+            }
+            return {
+              ...q,
+              size: 0,
+              aggs: {
+                avg_value: {
+                  avg: 'mappingInfp.reviced',
+                },
+              },
+            };
+          };
+          // Get OpenSearch connection
+          const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
+          // Total Tickets (all tickets with mappingInfo.type == tangoreview)
+          let totalTickets = 0;
+          let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          allQuery.size = 0;
+          const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
+          totalTickets = totalResp?.body?.hits?.total?.value || 0;
+          // openTickets: mappingInfo.status: 'Open'
+          let openTickets = 0;
+          let otQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open' );
+          otQ.size = 0;
+          const openResp = await getOpenSearchData( openSearch.footfallDirectory, otQ );
+          openTickets = openResp?.body?.hits?.total?.value || 0;
+          // logger.info( { msd: '..............2', openResp } );
+          // inprogress: mappingInfo.status: 'in-Progress'
+          let inprogress = 0;
+          let ipQ = buildStoreQueryWithStatus( baseStoreQuery, 'In-Progress' );
+          ipQ.size = 0;
+          const ipResp = await getOpenSearchData( openSearch.footfallDirectory, ipQ );
+          inprogress = ipResp?.body?.hits?.total?.value || 0;
+          // closedTickets: mappingInfo.status: 'closed'
+          let closedTickets = 0;
+          let clQ = buildStoreQueryWithStatus( baseStoreQuery, 'Closed' );
+          clQ.size = 0;
+          const clResp = await getOpenSearchData( openSearch.footfallDirectory, clQ );
+          closedTickets = clResp?.body?.hits?.total?.value || 0;
+          // dueToday: Tickets whose dueDate is today (format 'yyyy-MM-dd')
+          let dueToday = 0;
+          let todayDateString = new Date().toISOString().slice( 0, 10 );
+          // Build a query for tickets with mappingInfo.dueDate == todayDateString
+          let dueTodayQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          // Locate nested mappingInfo query
+          let nestedDue = dueTodayQuery.query.bool.must.find( ( m ) => m.nested );
+          if ( nestedDue ) {
+            // Remove any previous mappingInfo.dueDate term
+            nestedDue.nested.query.bool.must = nestedDue.nested.query.bool.must.filter(
+                ( mustItem ) => !( mustItem.term && mustItem.term['mappingInfo.dueDate'] ),
+            );
+            // Add new dueDate filter
+            nestedDue.nested.query.bool.must.push( {
+              term: { 'mappingInfo.dueDate': todayDateString },
+            } );
+          }
+          dueTodayQuery.size = 0;
+          const dueTodayResp = await getOpenSearchData( openSearch.footfallDirectory, dueTodayQuery );
+          dueToday = dueTodayResp?.body?.hits?.total?.value || 0;
+          // filter expired Tickets
+          let expiredTickets = 0;
+          let eQ = buildStoreQueryWithStatus( baseStoreQuery, 'Under Tango Review' );
+          eQ.size = 0;
+          const eResp = await getOpenSearchData( openSearch.footfallDirectory, eQ );
+          expiredTickets = eResp?.body?.hits?.total?.value || 0;
+          // filter under tango review
+          let undertangoTickets = 0;
+          let utrQ = buildStoreQueryWithStatus( baseStoreQuery, 'Under Tango Review' );
+          utrQ.size = 0;
+          const utrResp = await getOpenSearchData( openSearch.footfallDirectory, utrQ );
+          undertangoTickets = utrResp?.body?.hits?.total?.value || 0;
+          let ticketPercentageAvg =0;
+          let avgTicketPercentageQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          avgTicketPercentageQuery.size = 0;
+          avgTicketPercentageQuery.aggs = {
+            avg_ticket_percentage: {
+              avg: {
+                script: {
+                  source: `
+                    if (doc.containsKey('reviced') && doc['reviced'].size()!=0 &&
+                        doc.containsKey('footfallCount') && doc['footfallCount'].size()!=0 && doc['footfallCount'].value != 0) {
+                      return (doc['reviced'].value / doc['footfallCount'].value) * 100;
+                    } else {
+                      return null;
+                    }
+                  `,
+                  lang: 'painless',
+                },
+              },
+            },
+          };
+          const avgTicketPercentageResp = await getOpenSearchData( openSearch.footfallDirectory, avgTicketPercentageQuery );
+          ticketPercentageAvg = avgTicketPercentageResp?.body?.aggregations?.avg_ticket_percentage?.value?.toFixed( 2 ) || '0';
+          logger.info( { avgTicketPercentageResp } );
+          let ticketAccuracy = 0;
+          let belowQ = buildAggStoreQuery( baseStoreQuery );
+          logger.info( { belowQ } );
+          const accuracyResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
+          ticketAccuracy = accuracyResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          logger.info( { accuracyResp } );
+          // Final result object
+          result = {
+            totalTickets,
+            openTickets,
+            inprogress,
+            closedTickets,
+            dueToday: dueToday,
+            Expired: expiredTickets,
+            underTangoReview: undertangoTickets,
+            avgTicket: ticketPercentageAvg+'%',
+            avgAccuracy: ticketAccuracy+'%',
+          };
+        }
+      }
+    }
+    return res.sendSuccess( { result: result } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, messgage: req.query } );
+    return res.sendSuccess( err, 500 );
+  }
+}
+export async function ticketList1( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.query;
+    const limit =inputData?.isExport ? 10000: inputData.limit || 10;
+    const offset = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
+    const order = inputData?.sortOrder || -1;
+    inputData.clientId = inputData.clientId.split( ',' ); // convert strig to array
+    let filter = [
+      {
+        'range': {
+          'dateString': {
+            'gte': inputData.fromDate,
+            'lte': inputData.toDate,
             'format': 'yyyy-MM-dd',
           },
         },
       },
-      {
+      {
+        terms: {
+          'clientId.keyword': Array.isArray( inputData.clientId ) ?
+            inputData.clientId :
+            [ inputData.clientId ],
+        },
+      },
+    ];
+    if ( inputData?.storeId ) {
+      filter.push(
+          {
+            terms: {
+              'storeId.keyword': Array.isArray( inputData.storeId ) ?
+              inputData.storeId :
+              [ inputData.storeId ],
+            },
+          },
+      );
+    }
+    let search = {
+      'must': filter,
+    };
+    if ( inputData.searchValue && inputData.searchValue !== '' ) {
+      search = {
+        'must': filter,
+        'should': [
+          {
+            'wildcard': {
+              'storeName.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'storeId.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'ticketId.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'status.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+        ],
+        'minimum_should_match': 1,
+      };
+    }
+    let searchQuery = {
+      '_source': [
+        'storeName',
+        'storeId',
+        'ticketId',
+        'createdAt',
+        'updatedAt',
+        'footfallCount',
+        'duplicateCount',
+        'employeeCount',
+        'houseKeepingCount',
+        'junkCount',
+        'employeeACCount',
+        'duplicateACCount',
+        'houseKeepingACCount',
+        'junkACCount',
+        'status',
+        'dateString',
+      ],
+      'from': offset,
+      'size': limit,
+      'query': {
+        'bool': search,
+      },
+      'sort': [
+        { dateString: { order: 'desc' } },
+      ],
+    };
+    if ( inputData.sortBy && inputData.sortBy !== '' ) {
+      let sortByValue = '';
+      if ( [ 'storeName', 'storeId', 'ticketId', 'status' ].includes( inputData?.sortBy ) ) {
+        sortByValue = `${inputData.sortBy}.keyword`;
+      } else {
+        sortByValue = inputData.sortBy;
+      }
+      searchQuery = {
+        '_source': [
+          'storeName',
+          'storeId',
+          'ticketId',
+          'createdAt',
+          'updatedAt',
+          'footfallCount',
+          'duplicateCount',
+          'employeeCount',
+          'houseKeepingCount',
+          'junkCount',
+          'status',
+          'employeeACCount',
+          'duplicateACCount',
+          'houseKeepingACCount',
+          'junkACCount',
+          'dateString',
+        ],
+        'from': offset,
+        'size': limit,
+        'query': {
+          'bool': search,
+        },
+        'sort': [
+          { [sortByValue]: { order: order === -1 ? 'desc' : 'asc' } },
+        ],
+      };
+    }
+    if ( inputData.isExport == true ) {
+      searchQuery = {
+        '_source': [
+          'storeName',
+          'storeId',
+          'ticketId',
+          'createdAt',
+          'updatedAt',
+          'footfallCount',
+          'duplicateCount',
+          'employeeACCount',
+          'duplicateACCount',
+          'employeeCount',
+          'houseKeepingACCount',
+          'houseKeepingCount',
+          'junkCount',
+          'junkACCount',
+          'status',
+          'dateString',
+        ],
+        'from': 0,
+        'size': 10000,
+        'query': {
+          'bool': search,
+        },
+        'sort': [
+          { 'storeName.keyword': { order: 'desc' } },
+        ],
+      };
+    }
+    const getData = await getOpenSearchData( openSearch.footfallDirectory, searchQuery );
+    const count = getData?.body?.hits?.total?.value;
+    if ( !count || count == 0 ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    const searchValue = getData?.body?.hits?.hits;
+    if ( !searchValue || searchValue?.length == 0 ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    if ( inputData.isExport == true ) {
+      const exportData = [];
+      for ( const item of searchValue ) {
+        exportData.push( {
+          'Store Name': item._source.storeName || '--',
+          'Store ID': item._source.storeId,
+          'Ticket raised on': dayjs( item._source.createdAt ).format( 'DD MMM, YYYY' ),
+          'Issue Date': dayjs( item._source.dateString ).format( 'DD MMM, YYYY' ),
+          'Total Footfalls': item._source.footfallCount,
+          'Duplicates': item?._source?.status === 'closed' ? item._source.duplicateACCount : item._source.duplicateCount,
+          'Employee/Staff': item?._source?.status === 'closed' ? item._source.employeeACCount : item._source.employeeCount,
+          'HouseKeeping': item?._source?.status === 'closed' ? item._source.houseKeepingACCount : item._source.houseKeepingCount,
+          'Junk': item?._source?.status === 'closed' ? ( item._source.junkACCount || 0 ) : ( item._source.junkCount || 0 ),
+          'Revised Footfall': item?._source?.status === 'closed' ? item._source.footfallCount - ( item._source.duplicateACCount + item._source.employeeACCount + item._source.houseKeepingACCount + ( item._source.junkACCount || 0 ) ) : item._source.footfallCount - ( item._source.duplicateCount + item._source.employeeCount + item._source.houseKeepingCount + ( item._source.junkCount || 0 ) ),
+          'Ticket%': item?._source?.status === 'closed' ? `${Math.round( ( ( item._source.duplicateACCount + item._source.employeeACCount + item._source.houseKeepingACCount + ( item?._source?.junkACCount || 0 ) ) / item._source.footfallCount ) * 100 ).toFixed( 0 )} %` : `${Math.round( ( ( item?._source?.duplicateCount + item?._source?.employeeCount + item?._source?.houseKeepingCount + ( item?._source?.junkCount || 0 ) ) / item?._source?.footfallCount ) * 100 ).toFixed( 0 )} %`,
+          'Status': item._source.status,
+        } );
+      }
+      return await download( exportData, res );
+    }
+    return res.sendSuccess( { result: searchValue, count: count } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, messgage: req.query } );
+    return res.sendSuccess( err, 500 );
+  }
+}
+export async function ticketList( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.query;
+    const userInfo = req.user;
+    const limit =inputData?.isExport? 10000: inputData?.limit || 10;
+    const offset = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
+    inputData.clientId = inputData?.clientId?.split( ',' ); // convert strig to array
+    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'reviewer' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+    const ticketsApproveFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'approver' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+    const searchQuery = {
+      size: limit, // or use parseInt(req.query.limit) for dynamic
+      from: offset, // or use parseInt(req.query.offset) for dynamic
+      sort: [ { 'createdAt': { order: 'desc' } } ],
+      query: {
+        bool: {
+          must: [
+            {
+              'range': {
+                'dateString': {
+                  'gte': inputData.fromDate,
+                  'lte': inputData.toDate,
+                  'format': 'yyyy-MM-dd',
+                },
+              },
+            },
+            {
+              terms: {
+                'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                  inputData.clientId :
+                  [ inputData.clientId ],
+              },
+            },
+          ],
+        },
+      },
+    };
+    if ( inputData.sortBy ) {
+      let sortOrder = inputData.sortOrder === 1 ? 'asc' : 'desc';
+      const stringKeywordFields = [ 'storeName', 'storeId', 'ticketId', 'status', 'type', 'clientId' ];
+      let sortField = inputData.sortBy == 'footfall' ? 'footfallCount' : inputData.sortBy == 'issueDate' ? 'dateString' : inputData.sortBy;
+      if ( stringKeywordFields.includes( sortField ) ) {
+        sortField = `${sortField}.keyword`;
+      }
+      // Remove default sort so we don't duplicate/conflict
+      searchQuery.sort = [
+        { [sortField]: { order: sortOrder } },
+      ];
+    }
+    // Example: Filtering by storeId if present in the query
+    if ( inputData.storeId ) {
+      inputData.storeId = inputData?.storeId?.split( ',' );
+      searchQuery.query.bool.must.push( {
         terms: {
-          'clientId.keyword': Array.isArray( inputData.clientId ) ?
-            inputData.clientId :
-           [ inputData.clientId ],
+          'storeId.keyword': Array.isArray( inputData.storeId ) ?
+            inputData.storeId :
+            [ inputData.storeId ],
         },
-      },
-    ];
+      } );
+    }
+    if ( inputData.status && inputData.status!=='' ) {
+      inputData.status = inputData?.status?.split( ',' );
+      if ( req.user.userType === 'tango' ) {
+        searchQuery.query.bool.must.push( {
+          terms: {
+            'status.keyword': Array.isArray( inputData?.status ) ?
+              inputData?.status :
+              [ inputData?.status ],
+          },
+        } );
+      } else if ( inputData?.permissionType === 'approve' ) {
+        searchQuery.query.bool.must.push( {
+          nested: {
+            path: 'mappingInfo',
+            query: {
+              bool: {
+                must: [
+                  {
+                    term: {
+                      'mappingInfo.type': 'approve',
+                    },
+                  },
+                  {
+                    term: {
+                      'mappingInfo.status': inputData.status[0],
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        } );
+      } else if ( inputData?.permissionType === 'review' ) {
+        searchQuery.query.bool.must.push( {
+          nested: {
+            path: 'mappingInfo',
+            query: {
+              bool: {
+                must: [
+                  {
+                    term: {
+                      'mappingInfo.type': 'review',
+                    },
+                  },
+                  {
+                    term: {
+                      'mappingInfo.status': inputData.status[0],
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        } );
+      } else if ( ticketsFeature ) {
+        searchQuery.query.bool.must.push( {
+          nested: {
+            path: 'mappingInfo',
+            query: {
+              bool: {
+                must: [
+                  {
+                    term: {
+                      'mappingInfo.type': 'review',
+                    },
+                  },
+                  {
+                    term: {
+                      'mappingInfo.status': inputData.status[0],
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        } );
+      } else if ( ticketsApproveFeature ) {
+        searchQuery.query.bool.must.push( {
+          nested: {
+            path: 'mappingInfo',
+            query: {
+              bool: {
+                must: [
+                  {
+                    term: {
+                      'mappingInfo.type': 'approve',
+                    },
+                  },
+                  {
+                    term: {
+                      'mappingInfo.status': inputData.status[0],
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        } );
+      }
+    }
+    if ( inputData.filterByStatus && inputData.filterByStatus!=='' ) {
+      inputData.filterByStatus = inputData?.filterByStatus?.split( ',' );
+      if ( req?.user?.userType === 'tango' ) {
+        {
+          switch ( inputData?.tangoType ) {
+            case 'store':
+              searchQuery.query.bool.must.push( {
+                nested: {
+                  path: 'mappingInfo',
+                  query: {
+                    bool: {
+                      must: [
+                        {
+                          term: {
+                            'mappingInfo.type': 'tangoreview',
+                          },
+                        },
+                        {
+                          terms: {
+                            'mappingInfo.status': inputData?.filterByStatus,
+                          },
+                        },
+                      ],
+                    },
+                  },
+                },
+              } );
+              break;
+            case 'internal':
+              searchQuery.query.bool.must.push( {
+                'terms': {
+                  'status.keyword': Array.isArray( inputData?.filterByStatus ) ?
+                    inputData?.filterByStatus :
+                    [ inputData?.filterByStatus ],
+                },
+              } );
+              break;
+              defaut:
+              searchQuery.query.bool.must.push( {
+                nested: {
+                  path: 'mappingInfo',
+                  query: {
+                    bool: {
+                      must: [
+                        {
+                          term: {
+                            'mappingInfo.type': 'tangoreview',
+                          },
+                        },
+                        {
+                          terms: {
+                            'mappingInfo.status': inputData?.filterByStatus,
+                          },
+                        },
+                      ],
+                    },
+                  },
+                },
+              } );
+          }
+        }
+      } else if ( ticketsFeature && !ticketsApproveFeature ) {
+        searchQuery.query.bool.must.push( {
+          nested: {
+            path: 'mappingInfo',
+            query: {
+              bool: {
+                must: [
+                  {
+                    term: {
+                      'mappingInfo.type': 'review',
+                    },
+                  },
+                  {
+                    terms: {
+                      'mappingInfo.status': inputData?.filterByStatus,
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        } );
+      } else if ( ticketsFeature && ticketsApproveFeature ) {
+        switch ( inputData.permisisionType ) {
+          case 'review':
+            searchQuery.query.bool.must.push( {
+              nested: {
+                path: 'mappingInfo',
+                query: {
+                  bool: {
+                    must: [
+                      {
+                        term: {
+                          'mappingInfo.type': 'review',
+                        },
+                      },
+                      {
+                        terms: {
+                          'mappingInfo.status': inputData?.filterByStatus,
+                        },
+                      },
+                    ],
+                  },
+                },
+              },
+            } );
+            break;
+          case 'approve':
+            searchQuery.query.bool.must.push( {
+              nested: {
+                path: 'mappingInfo',
+                query: {
+                  bool: {
+                    must: [
+                      {
+                        term: {
+                          'mappingInfo.type': 'approve',
+                        },
+                      },
+                      {
+                        terms: {
+                          'mappingInfo.status': inputData?.filterByStatus,
+                        },
+                      },
+                    ],
+                  },
+                },
+              },
+            } );
+          default: searchQuery.query.bool.must.push( {
+            nested: {
+              path: 'mappingInfo',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'mappingInfo.type': 'approve',
+                      },
+                    },
+                    {
+                      terms: {
+                        'mappingInfo.status': inputData?.filterByStatus,
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          } );
+        }
+      }
+    }
+    if ( inputData?.filterByStore && inputData?.filterByStore !== '' ) {
+      let percQuery = null;
+      const value = inputData.filterByStore;
+      // Helper function: remove trailing '%' and convert to number
+      const percValue = ( val ) => {
+        if ( typeof val === 'string' ) {
+          return parseFloat( val.replace( '%', '' ).trim() );
+        }
+        return parseFloat( val );
+      };
+      // Example filter values: "<90", "<=90", ">=90", "50 to 90"
+      if ( /^<=?\d+$/.test( value ) ) {
+        // "<90" or "<=90"
+        const num = percValue( value.replace( /[^\d]/g, '' ) );
+        const op = value.includes( '=' ) ? 'lte' : 'lt';
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) ${op === 'lt' ? '<' : '<='} params.num`,
+              params: { num },
+            },
+          },
+        };
+      } else if ( /^>=?\d+$/.test( value ) ) {
+        // ">=90"
+        const num = percValue( value.replace( /[^\d]/g, '' ) );
+        const op = value.includes( '=' ) ? 'gte' : 'gt';
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) ${op === 'gt' ? '>' : '>='} params.num`,
+              params: { num },
+            },
+          },
+        };
+      } else if ( /^(\d+)\s*to\s*(\d+)$/.test( value ) ) {
+        // "50 to 90"
+        const match = value.match( /^(\d+)\s*to\s*(\d+)$/ );
+        const from = percValue( match[1] );
+        const to = percValue( match[2] );
+        percQuery = {
+          script: {
+            script: {
+              source:
+                `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) >= params.from && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) <= params.to`,
+              params: { from, to },
+            },
+          },
+        };
+      }
+      // fallback: treat as exact match (e.g., "90")
+      if ( !percQuery && /^\d+$/.test( value ) ) {
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) == params.num`,
+              params: { num: percValue( value ) },
+            },
+          },
+        };
+      }
-    if ( inputData?.storeId ) {
-      filter.push(
-          {
-            terms: {
-              'storeId.keyword': Array.isArray( inputData.storeId ) ?
-              inputData.storeId :
-              [ inputData.storeId ],
+      if ( percQuery ) {
+        searchQuery.query.bool.must.push( {
+          nested: {
+            path: 'mappingInfo',
+            query: {
+              bool: {
+                must: [
+                  { term: { 'mappingInfo.type': 'tagging' } },
+                  percQuery,
+                ],
+              },
             },
           },
-      );
+        } );
+      }
     }
-    let search = {
-      'must': filter,
-    };
+    if ( inputData?.filterByReviewer && inputData?.filterByReviewer !== '' ) {
+      let percQuery = null;
+      const value = inputData.filterByReviewer;
-    if ( inputData.searchValue && inputData.searchValue !== '' ) {
-      search = {
-        'must': filter,
-        'should': [
-          {
-            'wildcard': {
-              'storeName.keyword': {
-                'value': `*${inputData.searchValue}*`,
-              },
+      // Helper function: remove trailing '%' and convert to number
+      const percValue = ( val ) => {
+        if ( typeof val === 'string' ) {
+          return parseFloat( val.replace( '%', '' ).trim() );
+        }
+        return parseFloat( val );
+      };
+      // Example filter values: "<90", "<=90", ">=90", "50 to 90"
+      if ( /^<=?\d+$/.test( value ) ) {
+        // "<90" or "<=90"
+        const num = percValue( value.replace( /[^\d]/g, '' ) );
+        const op = value.includes( '=' ) ? 'lte' : 'lt';
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) ${op === 'lt' ? '<' : '<='} params.num`,
+              params: { num },
             },
           },
-          {
-            'wildcard': {
-              'storeId.keyword': {
-                'value': `*${inputData.searchValue}*`,
-              },
+        };
+      } else if ( /^>=?\d+$/.test( value ) ) {
+        // ">=90"
+        const num = percValue( value.replace( /[^\d]/g, '' ) );
+        const op = value.includes( '=' ) ? 'gte' : 'gt';
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) ${op === 'gt' ? '>' : '>='} params.num`,
+              params: { num },
             },
           },
-          {
-            'wildcard': {
-              'ticketId.keyword': {
-                'value': `*${inputData.searchValue}*`,
-              },
+        };
+      } else if ( /^(\d+)\s*to\s*(\d+)$/.test( value ) ) {
+        // "50 to 90"
+        const match = value.match( /^(\d+)\s*to\s*(\d+)$/ );
+        const from = percValue( match[1] );
+        const to = percValue( match[2] );
+        percQuery = {
+          script: {
+            script: {
+              source:
+                `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) >= params.from && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) <= params.to`,
+              params: { from, to },
             },
           },
-          {
-            'wildcard': {
-              'status.keyword': {
-                'value': `*${inputData.searchValue}*`,
+        };
+      }
+      // fallback: treat as exact match (e.g., "90")
+      if ( !percQuery && /^\d+$/.test( value ) ) {
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) == params.num`,
+              params: { num: percValue( value ) },
+            },
+          },
+        };
+      }
+      if ( percQuery ) {
+        searchQuery.query.bool.must.push( {
+          nested: {
+            path: 'mappingInfo',
+            query: {
+              bool: {
+                must: [
+                  { term: { 'mappingInfo.type': 'review' } },
+                  percQuery,
+                ],
               },
             },
           },
+        } );
+      }
+    }
-        ],
-        'minimum_should_match': 1,
+    if ( inputData?.filterByApprover && inputData?.filterByApprover !== '' ) {
+      let percQuery = null;
+      const value = inputData.filterByApprover;
+      // Helper function: remove trailing '%' and convert to number
+      const percValue = ( val ) => {
+        if ( typeof val === 'string' ) {
+          return parseFloat( val.replace( '%', '' ).trim() );
+        }
+        return parseFloat( val );
       };
+      // Example filter values: "<90", "<=90", ">=90", "50 to 90"
+      if ( /^<=?\d+$/.test( value ) ) {
+        // "<90" or "<=90"
+        const num = percValue( value.replace( /[^\d]/g, '' ) );
+        const op = value.includes( '=' ) ? 'lte' : 'lt';
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) ${op === 'lt' ? '<' : '<='} params.num`,
+              params: { num },
+            },
+          },
+        };
+      } else if ( /^>=?\d+$/.test( value ) ) {
+        // ">=90"
+        const num = percValue( value.replace( /[^\d]/g, '' ) );
+        const op = value.includes( '=' ) ? 'gte' : 'gt';
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) ${op === 'gt' ? '>' : '>='} params.num`,
+              params: { num },
+            },
+          },
+        };
+      } else if ( /^(\d+)\s*to\s*(\d+)$/.test( value ) ) {
+        // "50 to 90"
+        const match = value.match( /^(\d+)\s*to\s*(\d+)$/ );
+        const from = percValue( match[1] );
+        const to = percValue( match[2] );
+        percQuery = {
+          script: {
+            script: {
+              source:
+                `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) >= params.from && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) <= params.to`,
+              params: { from, to },
+            },
+          },
+        };
+      }
+      // fallback: treat as exact match (e.g., "90")
+      if ( !percQuery && /^\d+$/.test( value ) ) {
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) == params.num`,
+              params: { num: percValue( value ) },
+            },
+          },
+        };
+      }
+      if ( percQuery ) {
+        searchQuery.query.bool.must.push( {
+          nested: {
+            path: 'mappingInfo',
+            query: {
+              bool: {
+                must: [
+                  { term: { 'mappingInfo.type': 'approve' } },
+                  percQuery,
+                ],
+              },
+            },
+          },
+        } );
+      }
     }
-    let searchQuery = {
-      '_source': [
-        'storeName',
-        'storeId',
-        'ticketId',
-        'createdAt',
-        'updatedAt',
-        'footfallCount',
-        'duplicateCount',
-        'employeeCount',
-        'houseKeepingCount',
-        'junkCount',
-        'employeeACCount',
-        'duplicateACCount',
-        'houseKeepingACCount',
-        'junkACCount',
-        'status',
-        'dateString',
-      ],
-      'from': offset,
-      'size': limit,
-      'query': {
-        'bool': search,
-      },
-      'sort': [
-        { dateString: { order: 'desc' } },
-      ],
-    };
+    if ( inputData?.filterByTango && inputData?.filterByTango !== '' ) {
+      let percQuery = null;
+      const value = inputData.filterByTango;
-    if ( inputData.sortBy && inputData.sortBy !== '' ) {
-      let sortByValue = '';
+      // Helper function: remove trailing '%' and convert to number
+      const percValue = ( val ) => {
+        if ( typeof val === 'string' ) {
+          return parseFloat( val.replace( '%', '' ).trim() );
+        }
+        return parseFloat( val );
+      };
-      if ( [ 'storeName', 'storeId', 'ticketId', 'status' ].includes( inputData?.sortBy ) ) {
-        sortByValue = `${inputData.sortBy}.keyword`;
-      } else {
-        sortByValue = inputData.sortBy;
+      // Example filter values: "<90", "<=90", ">=90", "50 to 90"
+      if ( /^<=?\d+$/.test( value ) ) {
+        // "<90" or "<=90"
+        const num = percValue( value.replace( /[^\d]/g, '' ) );
+        const op = value.includes( '=' ) ? 'lte' : 'lt';
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) ${op === 'lt' ? '<' : '<='} params.num`,
+              params: { num },
+            },
+          },
+        };
+      } else if ( /^>=?\d+$/.test( value ) ) {
+        // ">=90"
+        const num = percValue( value.replace( /[^\d]/g, '' ) );
+        const op = value.includes( '=' ) ? 'gte' : 'gt';
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) ${op === 'gt' ? '>' : '>='} params.num`,
+              params: { num },
+            },
+          },
+        };
+      } else if ( /^(\d+)\s*to\s*(\d+)$/.test( value ) ) {
+        // "50 to 90"
+        const match = value.match( /^(\d+)\s*to\s*(\d+)$/ );
+        const from = percValue( match[1] );
+        const to = percValue( match[2] );
+        percQuery = {
+          script: {
+            script: {
+              source:
+                `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) >= params.from && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) <= params.to`,
+              params: { from, to },
+            },
+          },
+        };
+      }
+      // fallback: treat as exact match (e.g., "90")
+      if ( !percQuery && /^\d+$/.test( value ) ) {
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) == params.num`,
+              params: { num: percValue( value ) },
+            },
+          },
+        };
       }
+      if ( percQuery ) {
+        searchQuery.query.bool.must.push( {
+          nested: {
+            path: 'mappingInfo',
+            query: {
+              bool: {
+                must: [
+                  { term: { 'mappingInfo.type': 'tangoreview' } },
+                  percQuery,
+                ],
+              },
+            },
+          },
+        } );
+      }
+    }
-      searchQuery = {
-        '_source': [
-          'storeName',
-          'storeId',
-          'ticketId',
-          'createdAt',
-          'updatedAt',
-          'footfallCount',
-          'duplicateCount',
-          'employeeCount',
-          'houseKeepingCount',
-          'junkCount',
-          'status',
-          'employeeACCount',
-          'duplicateACCount',
-          'houseKeepingACCount',
-          'junkACCount',
-          'dateString',
-        ],
-        'from': offset,
-        'size': limit,
-        'query': {
-          'bool': search,
+    if ( inputData?.filterByReviewedBy && inputData?.filterByReviewedBy !== '' ) {
+      inputData.filterByReviewedBy = inputData?.filterByReviewedBy?.split( ',' );
+      searchQuery.query.bool.must.push( {
+        nested: {
+          path: 'mappingInfo',
+          query: {
+            bool: {
+              must: [
+                { term: { 'mappingInfo.type': 'review' } },
+                { terms: { 'mappingInfo.createdByEmail': inputData?.filterByReviewedBy } },
+              ],
+            },
+          },
         },
-        'sort': [
-          { [sortByValue]: { order: order === -1 ? 'desc' : 'asc' } },
-        ],
-      };
+      } );
     }
-    if ( inputData.isExport == true ) {
-      searchQuery = {
-        '_source': [
-          'storeName',
-          'storeId',
-          'ticketId',
-          'createdAt',
-          'updatedAt',
-          'footfallCount',
-          'duplicateCount',
-          'employeeACCount',
-          'duplicateACCount',
-          'employeeCount',
-          'houseKeepingACCount',
-          'houseKeepingCount',
-          'junkCount',
-          'junkACCount',
-          'status',
-          'dateString',
-        ],
-        'from': 0,
-        'size': 10000,
-        'query': {
-          'bool': search,
+    if ( inputData?.fileterByApprovedBy && inputData?.fileterByApprovedBy !== '' ) {
+      inputData.fileterByApprovedBy = inputData?.fileterByApprovedBy?.split( ',' );
+      searchQuery.query.bool.must.push( {
+        nested: {
+          path: 'mappingInfo',
+          query: {
+            bool: {
+              must: [
+                { term: { 'mappingInfo.type': 'approve' } },
+                { terms: { 'mappingInfo.createdByEmail': inputData?.fileterByApprovedBy } },
+              ],
+            },
+          },
         },
-        'sort': [
-          { 'storeName.keyword': { order: 'desc' } },
-        ],
-      };
-    }
-    const getData = await getOpenSearchData( openSearch.footfallDirectory, searchQuery );
-    const count = getData?.body?.hits?.total?.value;
-    if ( !count || count == 0 ) {
-      return res.sendError( 'No data found', 204 );
-    }
-    const searchValue = getData?.body?.hits?.hits;
-    if ( !searchValue || searchValue?.length == 0 ) {
-      return res.sendError( 'No data found', 204 );
+      } );
     }
-    if ( inputData.isExport == true ) {
-      const exportData = [];
-      for ( const item of searchValue ) {
-        exportData.push( {
-          'Store Name': item._source.storeName || '--',
-          'Store ID': item._source.storeId,
-          'Ticket raised on': dayjs( item._source.createdAt ).format( 'DD MMM, YYYY' ),
-          'Issue Date': dayjs( item._source.dateString ).format( 'DD MMM, YYYY' ),
-          'Total Footfalls': item._source.footfallCount,
-          'Duplicates': item?._source?.status === 'closed'? item._source.duplicateACCount : item._source.duplicateCount,
-          'Employee/Staff': item?._source?.status === 'closed'? item._source.employeeACCount : item._source.employeeCount,
-          'HouseKeeping': item?._source?.status === 'closed'? item._source.houseKeepingACCount : item._source.houseKeepingCount,
-          'Junk': item?._source?.status === 'closed'? ( item._source.junkACCount || 0 ) : ( item._source.junkCount|| 0 ),
-          'Revised Footfall': item?._source?.status === 'closed'? item._source.footfallCount - ( item._source.duplicateACCount + item._source.employeeACCount + item._source.houseKeepingACCount +( item._source.junkACCount || 0 ) ) : item._source.footfallCount - ( item._source.duplicateCount + item._source.employeeCount + item._source.houseKeepingCount + ( item._source.junkCount || 0 ) ),
-          'Ticket%': item?._source?.status === 'closed'?`${Math.round( ( ( item._source.duplicateACCount + item._source.employeeACCount + item._source.houseKeepingACCount + ( item?._source?.junkACCount || 0 ) )/ item._source.footfallCount )*100 ).toFixed( 0 )} %` : `${Math.round( ( ( item?._source?.duplicateCount + item?._source?.employeeCount + item?._source?.houseKeepingCount + ( item?._source?.junkCount || 0 ) )/ item?._source?.footfallCount )*100 ).toFixed( 0 )} %`,
-          'Status': item._source.status,
-        } );
-      }
-      return await download( exportData, res );
-    }
-    return res.sendSuccess( { result: searchValue, count: count } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, messgage: req.query } );
-    return res.sendSuccess( err, 500 );
-  }
-}
+    if ( req?.user?.userType === 'tango' && inputData.tangoType !== 'internal' ) {
+      searchQuery.query.bool.must.push(
+          {
+            term: {
+              'type.keyword': 'store',
+            },
+          },
+          {
+            range: {
+              reviced: {
+                lt: 85,
+              },
+            },
+          },
+          {
+            nested: {
+              path: 'mappingInfo',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'mappingInfo.type': 'tangoreview',
+                      },
+                    },
+                  ],
+                },
+              },
+            },
-export async function ticketList( req, res ) {
-  try {
-    const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const inputData= req.query;
-    const userInfo = req.user;
-    const limit =inputData?.limit || 10;
-    const offset = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
+          },
+      );
+    } else if ( req?.user?.userType === 'client' ) {
+      searchQuery.query.bool.must.push(
+          {
+            term: {
+              'type.keyword': 'store',
+            },
+          },
+          {
+            nested: {
+              path: 'mappingInfo',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'mappingInfo.type': ticketsFeature ? 'review' : ticketsApproveFeature ?
+                    'approve' : 'tagging',
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
-    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name =='reviewer' && ( m.isAdd==true || m.isEdit==true ) ) ) );
+      );
+    }
-    // Get ticket list from the footfallDirectory index in OpenSearch
-    // Assumes you have openSearch and getOpenSearchData available in this scope.
-    // `openSearch.footfallDirectory` is the index for the tickets.
-    // Uses req.query for any filter (add additional filtering logic per your requirements).
+    if ( inputData?.permissionType ) {
+      searchQuery.query.bool.must.push(
+          {
+            nested: {
+              path: 'mappingInfo',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'mappingInfo.type': inputData?.permissionType == 'review' ? 'review' :
+                        'approve',
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+      );
+    }
-    const searchQuery = {
+    if ( inputData.searchValue && inputData.searchValue !== '' ) {
+      searchQuery.query.bool['should'] = [];
+      searchQuery.query.bool.should = [
-      size: limit, // or use parseInt(req.query.limit) for dynamic
-      from: offset, // or use parseInt(req.query.offset) for dynamic
-      sort: [ { 'createdAt': { order: 'desc' } } ],
-      query: {
-        bool: {
-          must: [],
+        {
+          'wildcard': {
+            'storeName.keyword': {
+              'value': `*${inputData.searchValue}*`,
+            },
+          },
+        },
+        {
+          'wildcard': {
+            'storeId.keyword': {
+              'value': `*${inputData.searchValue}*`,
+            },
+          },
+        },
+        {
+          'wildcard': {
+            'ticketId.keyword': {
+              'value': `*${inputData.searchValue}*`,
+            },
+          },
         },
-      },
-    };
-    // Example: Filtering by storeId if present in the query
-    if ( inputData.storeId ) {
-      searchQuery.query.bool.must.push( {
-        term: { 'storeId.keyword': inputData.storeId },
-      } );
-    }
-    // Example: Filtering by status if provided
-    if ( inputData.status ) {
-      searchQuery.query.bool.must.push( {
-        term: { 'status.keyword': inputData.status },
-      } );
-    }
+      ];
+      searchQuery.query.bool['minimum_should_match'] = 1;
+    }
     // You can add more filters as needed
-    logger.info( { searchQuery, index: openSearch.footfallDirectory } );
     const searchResult = await getOpenSearchData( openSearch.footfallDirectory, searchQuery );
     const count = searchResult?.body?.hits?.total?.value || 0;
+    logger.info( { searchResult } );
     if ( count === 0 ) {
       return res.sendError( 'no data found', 204 );
     }
     const ticketListData = searchResult?.body?.hits?.hits?.map( ( hit ) => hit._source ) || [];
-    let temp =[];
-    if ( req.user.userType =='tango' ) {
-      if ( inputData.tangotype == 'store' ) {
-        for ( let item of ticketListData ) {
-          temp.push( {
-            ticketId: item?.ticketId,
-            storeId: item?.storeId,
-            storeName: item?.storeName,
-            ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
-            issueDate: item?.dateString,
-            dueDate: '',
-            footfall: item?.footfall,
-            storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
-            reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc|| '--',
-            approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc||'--',
-            tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
-            status: item?.status,
-          } );
+    let temp = [];
+    if ( req.user.userType === 'tango' ) {
+      if ( inputData.tangoType === 'store' ) {
+        if ( inputData?.isExport ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+              'Ticket ID': item?.ticketId,
+              'store Name': item?.storeName,
+              'store ID': item?.storeId,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Due Date': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.dueDate,
+              'Actual FF': item?.footfallCount,
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Approver (%)': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              'Tango (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Status': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
+              'Comments': item?.mappingInfo?.find( ( f ) => f.type === 'finalRevision' )?.comments || '--',
+              'Sub Comments': item?.mappingInfo?.find( ( f ) => f.type === 'finalRevision' )?.subComments || '--',
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.createdAt,
+              issueDate: item?.dateString,
+              dueDate: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.dueDate,
+              footfall: item?.footfallCount,
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              status: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
+              comments: item?.mappingInfo?.find( ( f ) => f.type === 'finalRevision' )?.comments || '--',
+              subComments: item?.mappingInfo?.find( ( f ) => f.type === 'finalRevision' )?.subComments || '--',
+            } );
+          }
         }
       } else {
-        for ( let item of ticketListData ) {
-          temp.push( {
-            ticketId: item?.ticketId,
-            storeId: item?.storeId,
-            storeName: item?.storeName,
-            ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
-            issueDate: item?.dateString,
-            footfall: item?.footfall,
-            dueDate: '',
-            type: item.type || 'store',
-            storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
-            reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc|| '--',
-            approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc||'--',
-            tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
-            status: item?.status,
-            tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
-          } );
+        if ( inputData?.isExport ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+              'Ticket ID': item?.ticketId,
+              'Store Name': item?.storeName,
+              'Store ID': item?.storeId,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Ticket Type': item?.type,
+              'Actual FF': item?.footfallCount,
+              // Use the dueDate from the last mappingInfo item whose type is NOT 'finalRevisoon'
+              'Due Date': ( () => {
+                if ( Array.isArray( item?.mappingInfo ) ) {
+                  const filtered = item.mappingInfo.filter( ( f ) => f.dueDate && f.type !== 'finalRevisoon' );
+                  return filtered.length > 0 ? filtered[filtered.length - 1].dueDate : '';
+                }
+                return '';
+              } )(),
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Approver (%)': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              'Tango (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Ticket Status': item?.status,
+              'Tango Status': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
+              issueDate: item?.dateString,
+              footfall: item?.footfallCount,
+              dueDate: ( () => {
+                if ( Array.isArray( item?.mappingInfo ) ) {
+                  const filtered = item.mappingInfo.filter( ( f ) => f.dueDate && f.type !== 'finalRevisoon' );
+                  return filtered.length > 0 ? filtered[filtered.length - 1].dueDate : '';
+                }
+                return '';
+              } )(),
+              type: item?.type || 'store',
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              status: item?.status,
+              tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
+            } );
+          }
         }
       }
     } else {
-      if ( req.user.role === 'superadmin' ) {
-        for ( let item of ticketListData ) {
-          temp.push( {
-            ticketId: item?.ticketId,
-            storeId: item?.storeId,
-            storeName: item?.storeName,
-            ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
-            issueDate: item?.dateString,
-            dueDate: '',
-            footfall: item?.footfall,
-            type: item.type || 'store',
-            storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
-            reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc|| '--',
-            approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc||'--',
-            tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
-            status: item?.status,
-            tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
-            approvedBy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdByEmail||'--',
-          } );
+      if ( inputData?.permissionType === 'approve' ) {
+        if ( inputData.exportData ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+              'Ticket ID': item?.ticketId,
+              'Store Name': item?.storeName,
+              'Store ID': item?.storeId,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Due Date': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.dueDate,
+              'Actual FF': item?.footfallCount,
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Approver (%)': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              'Tango (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Status': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.status || '--',
+              'Tango Status': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Approved by': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdByEmail || '--',
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdAt,
+              issueDate: item?.dateString,
+              dueDate: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.dueDate,
+              footfall: item?.footfallCount,
+              type: item.type || 'store',
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              status: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.status || '--',
+              tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              approvedBy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdByEmail || '--',
+            } );
+          }
+        }
+      } else if ( inputData?.permissionType === 'review' ) {
+        if ( inputData?.isExport ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+              'Ticket ID': item?.ticketId,
+              'Store Name': item?.storeName,
+              'Store ID': item?.storeId,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Actual FF': item?.footfallCount,
+              'Due Date': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.dueDate,
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Status': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.status || '--',
+              'Reviewed by': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdByEmail || '--',
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdAt,
+              issueDate: item?.dateString,
+              footfall: item?.footfallCount,
+              dueDate: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.dueDate,
+              type: item.type || 'store',
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              status: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.status || '--',
+              ReviewedBy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdByEmail || '--',
+            } );
+          }
         }
       } else if ( req.user.role === 'user' ) {
         temp = [];
       } else if ( ticketsFeature ) {
-        for ( let item of ticketListData ) {
-          temp.push( {
-            ticketId: item?.ticketId,
-            storeId: item?.storeId,
-            storeName: item?.storeName,
-            ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
-            issueDate: item?.dateString,
-            footfall: item?.footfall,
-            dueDate: '',
-            type: item.type || 'store',
-            storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
-            reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc|| '--',
-            status: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.status|| '--',
-            ReviewedBy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdByEmail||'--',
-          } );
+        if ( inputData?.isExport ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+              'Ticket ID': item?.ticketId,
+              'Store ID': item?.storeId,
+              'Store Name': item?.storeName,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Actual FF': item?.footfallCount,
+              'Due Date': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.dueDate,
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Status': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.status || '--',
+              'Reviewed by': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdByEmail || '--',
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdAt,
+              issueDate: item?.dateString,
+              footfall: item?.footfallCount,
+              dueDate: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.dueDate,
+              type: item.type || 'store',
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              status: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.status || '--',
+              ReviewedBy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdByEmail || '--',
+            } );
+          }
+        }
+      } else if ( ticketsApproveFeature ) {
+        if ( inputData.isExport ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+              'Ticket ID': item?.ticketId,
+              'Store Name': item?.storeName,
+              'Store ID': item?.storeId,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Due Date': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.dueDate,
+              'Actual FF': item?.footfallCount,
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Approver (%)': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              'Tango (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Status': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.status || '--',
+              'Tango Status': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Approved by': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdByEmail || '--',
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdAt,
+              issueDate: item?.dateString,
+              dueDate: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.dueDate,
+              footfall: item?.footfallCount,
+              type: item.type || 'store',
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              status: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.status || '--',
+              tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              approvedBy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdByEmail || '--',
+            } );
+          }
         }
       } else {
-        temp =[];
+        temp = [];
       }
     }
-    return res.sendSuccess( { result: temp } );
+    return res.sendSuccess( { result: temp, count: count } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
     logger.error( { error: error, messgage: req.query } );
@@ -649,149 +3285,19 @@ export async function getTickets( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
-    const limit = inputData.limit;
-    const skip = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
-    inputData.storeId = inputData.storeId.split( ',' ); // convert strig to array
-    logger.info( { inputData: inputData, limit: limit, skip: skip } );
-    let source = [ 'storeId', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'employeeCount', 'houseKeepingCount', 'duplicateCount', 'junkCount', 'junkACCount', 'comments', 'employee', 'houseKeeping', 'junk', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'junkStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'approverRole', 'approverUserName', 'approverEmail' ];
+    let source = [ 'storeId', 'type', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'employeeCount', 'houseKeepingCount', 'duplicateCount', 'junkCount', 'junkACCount', 'comments', 'employee', 'houseKeeping', 'junk', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'junkStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'approverRole', 'approverUserName', 'approverEmail', 'type' ];
     let filter = [
       {
-        range: {
-          dateString: {
-            gte: inputData.fromDate,
-            lte: inputData.toDate,
-            format: 'yyyy-MM-dd',
-          },
+        term: {
+          'ticketId.keyword': inputData.ticketId,
         },
       },
     ];
-    if ( inputData?.storeId ) {
-      filter.push(
-          {
-            terms: {
-              'storeId.keyword': Array.isArray( inputData.storeId ) ?
-            inputData.storeId :
-            inputData.storeId,
-            },
-          },
-      );
-    }
-    if ( inputData?.dateString ) {
-      filter.push(
-          {
-            term: {
-              'dateString': inputData.dateString,
-            },
-          },
-      );
-    }
-    if ( inputData.status ) {
-      filter.push(
-          {
-            term: {
-              'status.keyword': inputData.status,
-            },
-          },
-      );
-    }
-    if (
-      inputData.revopsType
-    ) {
-      inputData.revopsType === 'employee' ?
-        filter.push( {
-          range: {
-            employeeCount: {
-              gt: 0,
-            },
-          },
-        } ) :
-        inputData.revopsType === 'houseKeeping' ?
-          filter.push( {
-            range: {
-              houseKeepingCount: {
-                gt: 0,
-              },
-            },
-          } ) :
-              inputData.revopsType === 'junk' ?
-          filter.push( {
-            range: {
-              junkCount: {
-                gt: 0,
-              },
-            },
-          } ) :
-          filter.push( {
-            range: {
-              duplicateCount: {
-                gt: 0,
-              },
-            },
-          } );
-      source = inputData.revopsType == 'employee' ? [ 'storeId', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'employeeCount', 'comments', 'employee', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'email', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkStatus', 'junkACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
-        inputData.revopsType == 'houseKeeping' ? [ 'storeId', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'houseKeepingCount', 'comments', 'houseKeeping', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkStatus', 'junkACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
-        inputData.revopsType == 'duplicateImages' ? [ 'storeId', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'duplicateCount', 'comments', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkStatus', 'junkACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
-        inputData.revopsType == 'junk' ? [ 'storeId', 'dateString', 'ticketName', 'revicedFootfall', 'revicedPerc', 'mappingInfo', 'footfallCount', 'duplicateCount', 'comments', 'junk', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'email', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'junkCount', 'junkACCount', 'junkStatus', 'approverRole', 'approverUserName', 'approverEmail' ] : [];
-    }
-    if ( inputData.action ) {
-      filter.push( {
-        bool: {
-          should: [
-            {
-              constant_score: {
-                filter: { term: { 'houseKeepingStatus.keyword': inputData.action } },
-                boost: 1,
-                _name: 'matched_housekeeping',
-              },
-            },
-            {
-              constant_score: {
-                filter: { term: { 'employeeStatus.keyword': inputData.action } },
-                boost: 1,
-                _name: 'matched_employee',
-              },
-            },
-            {
-              constant_score: {
-                filter: { term: { 'duplicateStatus.keyword': inputData.action } },
-                boost: 1,
-                _name: 'matched_duplicate',
-              },
-            },
-            {
-              constant_score: {
-                filter: { term: { 'junkStatus.keyword': inputData.action } },
-                boost: 1,
-                _name: 'matched_junk',
-              },
-            },
-          ],
-          minimum_should_match: 1,
-        },
-      } );
-    }
-    let getRevCount = {};
-    if ( inputData.revopsType ) {
-      getRevCount = {
-        size: 0,
-        query: {
-          bool: {
-            filter: filter,
-          },
-        },
-        aggs: {
-          totalCount: {
-            sum: {
-              field: inputData.revopsType == 'employee' ? 'employeeCount' : inputData.revopsType == 'houseKeeping' ? 'houseKeepingCount' :inputData.revopsType == 'junk' ? 'junkCount': 'duplicateCount',
-            },
-          },
-        },
-      };
-    }
     const getCount = {
       query: {
         bool: {
@@ -802,20 +3308,14 @@ export async function getTickets( req, res ) {
     const geteDataCount = await getOpenSearchCount( openSearch.footfallDirectory, getCount );
-    const geteRevDataCount = inputData?.revopsType ? await getOpenSearchData( openSearch.footfallDirectory, getRevCount ) : null;
-    const revCount = inputData?.revopsType ? geteRevDataCount?.body?.aggregations?.totalCount?.value : 0;
-    const count = geteDataCount?.body?.count;
-    if ( !geteDataCount || count == 0 ) {
-      if ( inputData.storeId?.length > 0 ) {
-        const getStoreName = await findOneStore( { storeId: inputData.storeId }, { storeName: 1 } );
-        return res.sendError( `No Pending items in the selected dates for the store ${getStoreName?.storeName || ''}`, 400 );
-      }
-      return res.sendError( 'No data found', 204 );
+    if ( !geteDataCount ) {
+      return res.sendError( `No Pending items in the selected dates for the store`, 400 );
     }
     const getQuery = {
-      size: limit,
-      from: skip,
+      size: 1,
       query: {
         bool: {
           filter: filter,
@@ -825,14 +3325,9 @@ export async function getTickets( req, res ) {
     };
     const getData = await getOpenSearchData( openSearch.footfallDirectory, getQuery );
     const response = getData?.body?.hits?.hits;
     if ( !response || response.length == 0 ) {
-      if ( inputData.storeId?.length > 0 ) {
-        const getStoreName = await findOneStore( { storeId: inputData.storeId }, { storeName: 1 } );
-        return res.sendError( `No Pending items in the selected dates for the store ${getStoreName?.storeName || ''}`, 400 );
-      }
-      return res.sendError( 'No data', 204 );
+      return res.sendError( `No Pending items in the selected dates for the store`, 400 );
     }
     let temp = [];
     if ( inputData?.action ) {
@@ -870,29 +3365,31 @@ export async function getTickets( req, res ) {
           approverUserName: hit?._source?.approverUserName,
           approverEmail: hit?._source?.approverEmail,
           approverRole: hit?._source?.approverRole,
+          type: hit?._source?.type,
         };
         let result;
         const matched = hit.matched_queries;
         // Add only matched data array
-        if ( matched.includes( 'matched_employee' )&& ( !inputData.revopsType || inputData.revopsType == 'employee' ) ) {
+        if ( matched.includes( 'matched_employee' ) && ( !inputData.revopsType || inputData.revopsType == 'employee' ) ) {
           result = defaultData;
           result.employee = hit?._source?.employee;
           // result.type = 'employee';
           result.matched = matched;
         }
-        if ( matched.includes( 'matched_housekeeping' )&& ( !inputData.revopsType || inputData.revopsType == 'houseKeeping' ) ) {
+        if ( matched.includes( 'matched_housekeeping' ) && ( !inputData.revopsType || inputData.revopsType == 'houseKeeping' ) ) {
           result = defaultData;
           result.houseKeeping = hit?._source?.houseKeeping;
           result.matched = matched;
         }
-        if ( matched.includes( 'matched_duplicate' )&& ( !inputData.revopsType || inputData.revopsType == 'duplicateImages' ) ) {
+        if ( matched.includes( 'matched_duplicate' ) && ( !inputData.revopsType || inputData.revopsType == 'duplicateImages' ) ) {
           result = defaultData;
           result.duplicateImages = hit?._source?.duplicateImages;
           result.matched = matched;
         }
-        if ( matched.includes( 'matched_junk' )&& ( !inputData.revopsType || inputData.revopsType == 'junk' ) ) {
+        if ( matched.includes( 'matched_junk' ) && ( !inputData.revopsType || inputData.revopsType == 'junk' ) ) {
           result = defaultData;
           result.junk = hit?._source?.junk;
           result.matched = matched;
@@ -911,15 +3408,264 @@ export async function getTickets( req, res ) {
         }
       } );
     }
     const finalResponse = inputData.action ? temp : response;
+    const getRevopQuery = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            { term: { 'storeId.keyword': response?.[0]?._source?.storeId } }, // assuming inputData.storeId is an array
+            { term: { 'dateString': response?.[0]?._source?.dateString } },
+          ],
+        },
+      },
+    };
+    const revopResp = await getOpenSearchData( openSearch.revop, getRevopQuery );
+    // Map revopResp.body.hits.hits to revopSources
+    const revopSources = Array.isArray( revopResp?.body?.hits?.hits ) ?
+      revopResp?.body?.hits?.hits?.map( ( hit ) => hit._source ) :
+      [];
+    // Create a map of revopSources by id for quick lookup
+    const revopSourcesMap = new Map();
+    revopSources.forEach( ( item ) => {
+      if ( item?.id ) {
+        revopSourcesMap.set( String( item.id ), item );
+      }
+    } );
+    // Process revopSources to replace duplicateImage entries with full objects from the array
+    const processedRevopSources = revopSources.map( ( item ) => {
+      // Check if this is a duplicate parent item
+      if ( item?.revopsType === 'duplicate' && item?.isParent === true && Array.isArray( item?.duplicateImage ) ) {
+        // Map each duplicateImage entry to the full object from revopSources
+        const updatedDuplicateImage = item.duplicateImage.map( ( duplicateImg ) => {
+          const duplicateId = String( duplicateImg?.id );
+          // Find the full object in revopSources that matches this id
+          const fullObject = revopSourcesMap.get( duplicateId );
+          // Return the full object if found, otherwise return the original duplicateImg
+          return fullObject || duplicateImg;
+        } );
+        return {
+          ...item,
+          duplicateImage: updatedDuplicateImage,
+        };
+      }
+      // Return item as-is if it doesn't meet the criteria
+      return item;
+    } );
     if ( finalResponse?.length == 0 || !finalResponse ) {
       if ( inputData.storeId?.length > 0 ) {
-        const getStoreName = await findOneStore( { storeId: inputData.storeId }, { storeName: 1 } );
+        const getStoreName = await findOneStore( { storeId: response?.[0]?._source?.storeId }, { storeName: 1 } );
         return res.sendError( `No Pending items in the selected dates for the store ${getStoreName?.storeName || ''}`, 400 );
       }
       return res.sendError( 'No Data found', 204 );
     }
-    return res.sendSuccess( { result: finalResponse, count: count, revopCount: revCount } );
+    // replace the mappingInfo.revisedDetail with processedRevopSources
+    if ( Array.isArray( finalResponse ) ) {
+      for ( let item of finalResponse ) {
+        if (
+          item &&
+          item._source &&
+          item._source.mappingInfo
+        ) {
+          item._source.mappingInfo.revisedDetail = processedRevopSources;
+          const vmsCommentsLogIndex = openSearch.vmsCommentsLog || 'vms-comments-log-dev';
+          let commentsResponse = [];
+          const commentsFilter = [
+            { term: { 'storeId.keyword': item?._source?.storeId } },
+            { term: { dateString: item?._source?.dateString } },
+          ];
+          const commentsQuery = {
+            size: 10000,
+            sort: [
+              { createdAt: { order: 'desc' } }, // Sort descending by createdAt
+            ],
+            query: {
+              bool: {
+                filter: commentsFilter,
+              },
+            },
+          };
+          const commentsRes = await getOpenSearchData( vmsCommentsLogIndex, commentsQuery );
+          // If mappingInfo is an array, update revisedDetail for each mappingInfo object
+          if ( Array.isArray( item._source.mappingInfo ) ) {
+            item._source.mappingInfo.forEach( ( mappingObj ) => {
+              commentsResponse = commentsRes?.body?.hits?.hits?.map( ( hit ) => hit._source ) || [];
+              // Check if duplicate condition exists in commentsResponse
+              // Structure comments output
+              let commentsDetails = [];
+              const types = [ 'tagging', 'review', 'approve' ];
+              // Process each type
+              types.forEach( ( typeValue ) => {
+                if ( typeValue === 'tagging' ) {
+                  // For tagging, group by category and create separate objects for each category
+                  const taggingComments = commentsResponse.filter( ( c ) => c.type === typeValue );
+                  // Group by category
+                  const categoryGroups = {};
+                  taggingComments.forEach( ( c ) => {
+                    const category = c.category || 'other';
+                    if ( !categoryGroups[category] ) {
+                      categoryGroups[category] = [];
+                    }
+                    categoryGroups[category].push( c );
+                  } );
+                  // Create separate objects for each category
+                  Object.keys( categoryGroups ).forEach( ( category ) => {
+                    const categoryComments = categoryGroups[category];
+                    let parent = null;
+                    const comms = categoryComments.map( ( c ) => {
+                      if ( category === 'duplicate' ) {
+                        if ( !parent && c.parent ) {
+                          parent = c.parent;
+                        }
+                        return {
+                          createdByEmail: c.createdByEmail,
+                          createdByUserName: c.createdByUserName,
+                          createdByRole: c.createdByRole,
+                          message: c.message,
+                        };
+                      } else {
+                        return {
+                          id: c.id,
+                          tempId: c.tempId,
+                          timeRange: c.timeRange,
+                          entryTime: c.entryTime,
+                          exitTime: c.exitTime,
+                          filePath: c.filePath,
+                          isChecked: c.isChecked,
+                          createdAt: c.createdAt,
+                          message: c.message,
+                          createdByEmail: c.createdByEmail,
+                          createdByUserName: c.createdByUserName,
+                          createdByRole: c.createdByRole,
+                        };
+                      }
+                    } );
+                    const taggingObj = {
+                      category: category,
+                      type: typeValue,
+                      comments: comms,
+                    };
+                    // Add parent only for duplicate category
+                    if ( category === 'duplicate' && parent !== null ) {
+                      taggingObj.parent = parent;
+                    }
+                    commentsDetails.push( taggingObj );
+                  } );
+                } else if ( typeValue === 'review' || typeValue === 'approve' ) {
+                  // For review and approve, keep existing structure
+                  const comms = commentsResponse
+                      .filter( ( c ) => c.type === typeValue )
+                      .map( ( c ) => {
+                        if ( c.category === 'duplicate' ) {
+                          return {
+                            parent: c?.taggedImages[0]?._source?.parent,
+                            category: c.category,
+                            taggedImages: Array.isArray( c.taggedImages ) ?
+                                c.taggedImages.map( ( img ) => ( {
+                                  id: img?._source?.id,
+                                  tempId: img?._source?.tempId,
+                                  timeRange: img?._source?.timeRange,
+                                  entryTime: img?._source?.entryTime,
+                                  exitTime: img?._source?.exitTime,
+                                  filePath: img?._source?.filePath,
+                                  isChecked: img?._source?.isChecked,
+                                } ) ) :
+                                [],
+                            createdByEmail: c.createdByEmail,
+                            createdByUserName: c.createdByUserName,
+                            createdByRole: c.createdByRole,
+                            status: c.status,
+                            message: c.message,
+                          };
+                        } else {
+                          return {
+                            category: c.category,
+                            taggedImages: Array.isArray( c.taggedImages ) ?
+                                c.taggedImages.map( ( img ) => ( {
+                                  id: img?._source?.id,
+                                  tempId: img?._source?.tempId,
+                                  timeRange: img?._source?.timeRange,
+                                  entryTime: img?._source?.entryTime,
+                                  exitTime: img?._source?.exitTime,
+                                  filePath: img?._source?.filePath,
+                                  isChecked: img?._source?.isChecked,
+                                } ) ) :
+                                [],
+                            createdByEmail: c.createdByEmail,
+                            createdByUserName: c.createdByUserName,
+                            createdByRole: c.createdByRole,
+                            status: c.status,
+                            message: c.message,
+                          };
+                        }
+                      } );
+                  // Only add if there are comments
+                  if ( comms.length > 0 ) {
+                    commentsDetails.push( {
+                      type: typeValue,
+                      comments: comms,
+                    } );
+                  } else {
+                    // Add empty comments array if no comments
+                    commentsDetails.push( {
+                      type: typeValue,
+                      comments: [],
+                    } );
+                  }
+                }
+              } );
+              item._source.commentsDetails = commentsDetails;
+              if (
+                Object.prototype.hasOwnProperty.call( mappingObj, 'revisedDetail' ) &&
+                mappingObj.type !== 'tangoreview'
+              ) {
+                mappingObj.revisedDetail = processedRevopSources;
+              }
+            } );
+          } else {
+            item._source.mappingInfo.revisedDetail = processedRevopSources;
+          }
+        }
+      }
+    } else if (
+      finalResponse &&
+      finalResponse._source &&
+      finalResponse._source.mappingInfo
+    ) {
+      finalResponse._source.mappingInfo.revisedDetail = processedRevopSources;
+    }
+    return res.sendSuccess( { result: finalResponse } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
     logger.error( { error: error, messgage: req.query } );
@@ -991,7 +3737,7 @@ export async function updateTicketStatus( data, openSearch, temp, user ) {
         item.isChecked == true ? tempId.push( { tempId: item.tempId, timeRange: item.timeRange } ) : null;
         bulkBody.push(
             { update: { _index: openSearch.revop, _id: `${storeId}_${dateString}_${item.timeRange}_${item.tempId}` } },
-            { doc: { isChecked: item.isChecked, status: item?.isChecked == true? 'approved':'rejected' } },
+            { doc: { isChecked: item.isChecked, status: item?.isChecked == true ? 'approved' : 'rejected' } },
         );
       } );
     }
@@ -1006,11 +3752,11 @@ export async function updateTicketStatus( data, openSearch, temp, user ) {
     updateData.employee = updatedEmployee;
     await updateOpenSearchData( openSearch.footfallDirectory, _id, { doc: updateData } );
     for ( let employee of updateData?.employee ) {
-     ( employee.isChecked == true ) ? tempId.push( { tempId: employee.tempId, timeRange: employee.timeRange } ) : null;
-     bulkBody.push(
-         { update: { _index: openSearch.revop, _id: `${storeId}_${dateString}_${employee.timeRange}_${employee.tempId}` } },
-         { doc: { isChecked: employee.isChecked, status: employee?.isChecked == true? 'approved':'rejected' } },
-     );
+      ( employee.isChecked == true ) ? tempId.push( { tempId: employee.tempId, timeRange: employee.timeRange } ) : null;
+      bulkBody.push(
+          { update: { _index: openSearch.revop, _id: `${storeId}_${dateString}_${employee.timeRange}_${employee.tempId}` } },
+          { doc: { isChecked: employee.isChecked, status: employee?.isChecked == true ? 'approved' : 'rejected' } },
+      );
     }
     await updateOpenSearchData( openSearch.footfallDirectory, _id, { doc: { employeeACCount: tempId?.length || 0 } } );
   }
@@ -1029,7 +3775,7 @@ export async function updateTicketStatus( data, openSearch, temp, user ) {
       houseKeeping.isChecked == true ? tempId.push( { tempId: houseKeeping.tempId, timeRange: houseKeeping.timeRange } ) : null;
       bulkBody.push(
           { update: { _index: openSearch.revop, _id: `${storeId}_${dateString}_${houseKeeping.timeRange}_${houseKeeping.tempId}` } },
-          { doc: { isChecked: houseKeeping.isChecked, status: houseKeeping?.isChecked == true? 'approved':'rejected' } },
+          { doc: { isChecked: houseKeeping.isChecked, status: houseKeeping?.isChecked == true ? 'approved' : 'rejected' } },
       );
     }
     await updateOpenSearchData( openSearch.footfallDirectory, _id, { doc: { houseKeepingACCount: tempId?.length || 0 } } );
@@ -1050,7 +3796,7 @@ export async function updateTicketStatus( data, openSearch, temp, user ) {
       junk.isChecked == true ? tempId.push( { tempId: junk.tempId, timeRange: junk.timeRange } ) : null;
       bulkBody.push(
           { update: { _index: openSearch.revop, _id: `${storeId}_${dateString}_${junk.timeRange}_${junk.tempId}` } },
-          { doc: { isChecked: junk.isChecked, status: junk?.isChecked == true? 'approved':'rejected' } },
+          { doc: { isChecked: junk.isChecked, status: junk?.isChecked == true ? 'approved' : 'rejected' } },
       );
     }
     await updateOpenSearchData( openSearch.footfallDirectory, _id, { doc: { junkACCount: tempId?.length || 0 } } );
@@ -1075,7 +3821,7 @@ export async function updateTicketStatus( data, openSearch, temp, user ) {
     let getUpdateExistingOne = await getOpenSearchById( openSearch.footfallDirectory, _id );
     const tempIdList = await extractCheckedTempIds( getUpdateExistingOne?.body );
     const isSendMessge = await sendSqsMessage( data, tempIdList, getStoreType, storeId );
-    if ( isSendMessge ==true ) {
+    if ( isSendMessge == true ) {
       return true; // res.sendSuccess( 'Ticket has been updated successfully' );
     } else {
       return false; // res.sendError( 'No SQS message sent', 500 );
@@ -1138,7 +3884,7 @@ function updateEmployeeCheckFlags( existingEmployees, inputEmployees, status ) {
   // Step 2: Loop through all existing and update isChecked accordingly
   const updatedEmployees = existingEmployees.map( ( emp ) => ( {
     ...emp,
-    isChecked: status === 'rejected'? !checkedTempIds.has( emp.tempId ):checkedTempIds.has( emp.tempId ),
+    isChecked: status === 'rejected' ? !checkedTempIds.has( emp.tempId ) : checkedTempIds.has( emp.tempId ),
   } ) );
   return updatedEmployees;
@@ -1188,7 +3934,7 @@ function mergeDuplicateImagesWithUncheck( existingData, inputData, status ) {
 export async function sendSqsMessage( inputData, tempId, getStoreType, storeId ) {
   const sqs = JSON.parse( process.env.SQS );
   const openSearch = JSON.parse( process.env.OPENSEARCH );
-  const sqsName = getStoreType > 0? sqs.revopTrackTicket: sqs.revopTicket;
+  const sqsName = getStoreType > 0 ? sqs.revopTrackTicket : sqs.revopTicket;
   const sqsProduceQueue = getStoreType > 0 ? {
     QueueUrl: `${sqs.url}${sqsName}`,
     MessageBody: JSON.stringify( {
@@ -1216,12 +3962,11 @@ export async function sendSqsMessage( inputData, tempId, getStoreType, storeId )
     } ),
   };
-  const sqsQueue = getStoreType > 0? await sendMessageToFIFOQueue( sqsProduceQueue ):
-   await sendMessageToQueue(
-       sqsProduceQueue.QueueUrl,
-       sqsProduceQueue.MessageBody,
-   );
+  const sqsQueue = getStoreType > 0 ? await sendMessageToFIFOQueue( sqsProduceQueue ) :
+    await sendMessageToQueue(
+        sqsProduceQueue.QueueUrl,
+        sqsProduceQueue.MessageBody,
+    );
   if ( sqsQueue.statusCode ) {
     logger.error( {
       error: `${sqsQueue}`,
@@ -1229,7 +3974,7 @@ export async function sendSqsMessage( inputData, tempId, getStoreType, storeId )
     } );
     return false;
   } else {
-    const id =`${storeId}_${inputData.dateString.split( '-' ).reverse().join( '-' )}_${getStoreType > 0? 'live':'reduction'}_${Date.now()}`;
+    const id = `${storeId}_${inputData.dateString.split( '-' ).reverse().join( '-' )}_${getStoreType > 0 ? 'live' : 'reduction'}_${Date.now()}`;
     const logs = {
       QueueUrl: sqsProduceQueue.QueueUrl,
       MessageBody: sqsProduceQueue.MessageBody,
@@ -1279,13 +4024,7 @@ export async function getTaggedStores( req, res ) {
         },
       },
     ];
-    // if ( req?.user?.userType == 'client' && req?.user?.role !== 'superadmin' && req?.stores?.length > 0 ) {
-    //   filter.push(
-    //       {
-    //         terms: { 'storeId.keyword': req.stores },
-    //       },
-    //   );
-    // }
     filter.push(
         {
           terms: { 'storeId.keyword': req?.stores || [] },
@@ -1336,7 +4075,7 @@ export async function getTaggedStores( req, res ) {
                        + (doc.containsKey('employeeCount') && !doc['employeeCount'].empty ? doc['employeeCount'].value : 0)
                           + (doc.containsKey('junkCount') && !doc['junkCount'].empty ? doc['junkCount'].value : 0);
               `,
-                  lang: 'painless',
+                  lang: 'scripting',
                 },
               },
             },
@@ -1400,8 +4139,8 @@ export async function downloadTickets( req, res ) {
           {
             terms: {
               'storeId.keyword': Array.isArray( inputData.storeId ) ?
-            inputData.storeId :
-            inputData.storeId,
+              inputData.storeId :
+              inputData.storeId,
             },
           },
       );
@@ -1449,26 +4188,26 @@ export async function downloadTickets( req, res ) {
             },
           } ) :
-             inputData.revopsType === 'junk' ?
-          filter.push( {
-            range: {
-              junkCount: {
-                gt: 0,
+          inputData.revopsType === 'junk' ?
+            filter.push( {
+              range: {
+                junkCount: {
+                  gt: 0,
+                },
               },
-            },
-          } ):
+            } ) :
-          filter.push( {
-            range: {
-              duplicateCount: {
-                gt: 0,
+            filter.push( {
+              range: {
+                duplicateCount: {
+                  gt: 0,
+                },
               },
-            },
-          } );
+            } );
       source = inputData.revopsType == 'employee' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'employeeCount', 'comments', 'employee', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'junkStatus' ] :
         inputData.revopsType == 'houseKeeping' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'houseKeepingCount', 'comments', 'houseKeeping', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'junkStatus' ] :
           inputData.revopsType == 'duplicateImages' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'duplicateCount', 'comments', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'junkStatus' ] :
-          inputData.revopsType == 'junk' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'junkCount', 'comments', 'junk', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'junkStatus' ] : [];
+            inputData.revopsType == 'junk' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'junkCount', 'comments', 'junk', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'junkStatus' ] : [];
     }
     if ( inputData.action ) {
@@ -1545,7 +4284,7 @@ export async function downloadTickets( req, res ) {
     let temp = [];
     if ( inputData?.action ) {
       response.map( ( hit ) => {
-        const defaultData ={
+        const defaultData = {
           storeId: hit._source.storeId,
           dateString: hit?._source?.dateString,
           ticketName: hit?._source?.ticketName,
@@ -1575,19 +4314,19 @@ export async function downloadTickets( req, res ) {
           // result.type = 'employee';
           result.matched = matched;
         }
-        if ( matched.includes( 'matched_housekeeping' )&& ( !inputData.revopsType || inputData.revopsType == 'houseKeeping' ) ) {
+        if ( matched.includes( 'matched_housekeeping' ) && ( !inputData.revopsType || inputData.revopsType == 'houseKeeping' ) ) {
           logger.info( { revop: inputData.revopsType } );
           result = defaultData;
           result.houseKeeping = hit?._source?.houseKeeping;
           result.matched = matched;
         }
-        if ( matched.includes( 'matched_duplicate' )&& ( !inputData.revopsType || inputData.revopsType == 'duplicateImages' ) ) {
+        if ( matched.includes( 'matched_duplicate' ) && ( !inputData.revopsType || inputData.revopsType == 'duplicateImages' ) ) {
           logger.info( { revop: inputData.revopsType } );
           result = defaultData;
           result.duplicateImages = hit?._source?.duplicateImages;
           result.matched = matched;
         }
-        if ( matched.includes( 'matched_junk' )&& ( !inputData.revopsType || inputData.revopsType == 'junk' ) ) {
+        if ( matched.includes( 'matched_junk' ) && ( !inputData.revopsType || inputData.revopsType == 'junk' ) ) {
           result = defaultData;
           result.junk = hit?._source?.junk;
           result.matched = matched;
@@ -1631,7 +4370,7 @@ export async function downloadTickets( req, res ) {
       revopsType: inputData?.revopsType,
       type: 'get-tickets',
     };
-    const record={
+    const record = {
       stores: inputData?.storeId,
       fromDate: inputData?.fromDate,
       toDate: inputData?.toDate,
@@ -1649,7 +4388,7 @@ export async function downloadTickets( req, res ) {
     const sqs = JSON.parse( process.env.SQS );
     const sqsName = sqs.revopDownload;
-    const sqsProduceQueue ={
+    const sqsProduceQueue = {
       QueueUrl: `${sqs.url}${sqsName}`,
       MessageBody: JSON.stringify( {
         _id: getId?._id,
@@ -1678,7 +4417,6 @@ export async function downloadTickets( req, res ) {
 }
 async function extractTempIds( document ) {
-  logger.info( { document: document } );
   const source = document?._source || {};
   const result = [];
@@ -1728,7 +4466,7 @@ export async function reviewerList( req, res ) {
           featureName: 'FootfallDirectory',
           modules: {
             $elemMatch: {
-              name: 'Reviewer',
+              name: inputData?.type === 'review' ? 'reviewer' : 'approver',
               $or: [ { isAdd: true }, { isEdit: true } ],
             },
           },
@@ -1737,7 +4475,7 @@ export async function reviewerList( req, res ) {
     };
     const getUserlist = await findUser( reviewerRoleQuery, { userName: 1, email: 1, role: 1 } );
-    return res.sendSuccess( getUserlist|| [] );
+    return res.sendSuccess( getUserlist || [] );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
     return res.sendError( err, 500 );
@@ -1747,6 +4485,7 @@ export async function reviewerList( req, res ) {
 export async function openTicketList( req, res ) {
   try {
     const inputData = req.body;
+    logger.info( { inputData } );
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     // INSERT_YOUR_CODE
@@ -1759,6 +4498,29 @@ export async function openTicketList( req, res ) {
           clientId: Array.isArray( clientId ) ? clientId : [ clientId ],
         },
       },
+      {
+        nested: {
+          path: 'mappingInfo',
+          query: {
+            bool: {
+              must: [
+                {
+                  term: {
+                    'mappingInfo.type': inputData.type,
+                  },
+                },
+                {
+                  term: {
+                    'mappingInfo.status': 'Open',
+                  },
+                },
+              ],
+            },
+          },
+        },
+      },
       {
         range: {
           dateString: {
@@ -1770,6 +4532,7 @@ export async function openTicketList( req, res ) {
       },
     ];
     const openSearchQuery = {
       size: 10000,
       query: {
@@ -1777,14 +4540,44 @@ export async function openTicketList( req, res ) {
           filter: filter,
         },
       },
-      _source: [ 'ticketId', 'storeName', 'revicedFootfall', 'footfallCount', 'revicedPerc' ],
+      _source: [ 'ticketId', 'storeName', 'storeId', 'dateString', 'revicedFootfall', 'footfallCount', 'revicedPerc', 'type' ],
     };
+    if ( inputData.searchValue && inputData.searchValue !== '' ) {
+      openSearchQuery.query.bool['should'] = [];
+      openSearchQuery.query.bool.should = [
+        {
+          'wildcard': {
+            'storeName.keyword': {
+              'value': `*${inputData.searchValue}*`,
+            },
+          },
+        },
+        {
+          'wildcard': {
+            'ticketId.keyword': {
+              'value': `*${inputData.searchValue}*`,
+            },
+          },
+        },
+      ];
+      openSearchQuery.query.bool['minimum_should_match'] = 1;
+    }
+    // INSERT_YOUR_CODE
+    // Add sorting by revicedPerc descending (highest revised accuracy first)
+    openSearchQuery.sort = [
+      { 'revicedPerc.keyword': { order: inputData?.sortOrder === 1 ? 'asc' : 'desc' } },
+    ];
     // Assuming getOpenSearchData and openSearch.footfallDirectoryTagging are available
     const result = await getOpenSearchData( openSearch.footfallDirectory, openSearchQuery );
     const getUserlist = result?.body?.hits?.hits?.map( ( hit ) => hit._source ) || [];
-    return res.sendSuccess( getUserlist|| [] );
+    return res.sendSuccess( getUserlist || [] );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
     logger.error( { error: error, function: 'openTicketList' } );
@@ -1797,73 +4590,32 @@ export async function assignTicket( req, res ) {
     const inputData = req.body;
     const openSearch = JSON.parse( process.env.OPENSEARCH );
-    // INSERT_YOUR_CODE
-    // Build the query to match storeId(s) and dateString range [fromDate, toDate], format: 'yyyy-mm-dd'
-    const { email, userName, role, actionType } = inputData;
-    // INSERT_YOUR_CODE
-    // Find and update mappingInfo fields for the provided ticketId and actionType
-    // Requires ticketId in inputData
-    const { ticketId } = inputData;
-    if ( !ticketId ) {
-      return res.sendError( 'ticketId is required', 400 );
-    }
-    // Build the OpenSearch update-by-query body
-    const updateBody = {
-      script: {
-        source: `
-          if (ctx._source.mappingInfo != null) {
-            for (int i = 0; i < ctx._source.mappingInfo.length; i++) {
-              if (ctx._source.mappingInfo[i].type == params.actionType) {
-                ctx._source.mappingInfo[i].createdByEmail = params.email;
-                ctx._source.mappingInfo[i].createdByUserName = params.userName;
-                ctx._source.mappingInfo[i].createdByRole = params.role;
-              }
-            }
-          }
-        `,
-        lang: 'painless',
-        params: {
-          email,
-          userName,
-          role,
-          actionType,
-        },
-      },
-      query: {
-        bool: {
-          must: [
-            { term: { 'ticketId.keyword': ticketId } },
-            {
-              nested: {
-                path: 'mappingInfo',
-                query: {
-                  bool: {
-                    must: [
-                      { match: { 'mappingInfo.type': actionType } },
-                    ],
-                  },
-                },
-              },
-            },
-          ],
-        },
-      },
-    };
-    // Call OpenSearch _update_by_query to update doc(s) where ticketId and mappingInfo[i].type == actionType
-    const response = await upsertOpenSearchData(
-        openSearch.footfallDirectory,
-        '11-1716_2025-11-20_footfall-directory-tagging',
-        updateBody, // custom arg to indicate passthrough for update-by-query, depends on helper implementation
-    );
+    const { email, userName, role, storeId, dateString } = inputData;
+    const _id = `${storeId}_${dateString}_footfall-directory-tagging`;
-    logger.info( { response } );
+    const getTicket = await getOpenSearchById( openSearch.footfallDirectory, _id );
+    if ( !getTicket ) {
+      return res.sendError( 'Ticket is not found', 400 );
+    }
+    const source = getTicket?.body?._source;
+    const mappingInfo = Array.isArray( source.mappingInfo ) ? source.mappingInfo : [];
+    if ( mappingInfo.length === 0 ) {
+      return res.sendError( 'Ticket is not found', 400 );
+    }
+    const lastIndex = mappingInfo.length - 1;
+    const lastEntry = mappingInfo[lastIndex];
+    if ( String( lastEntry.status ) !== 'In-Progress' ) {
+      return res.sendError( 'Ticket is not in progress', 400 );
+    }
-    return res.sendSuccess( { updated: response?.body?.updated ?? 0 } );
+    const currentTime = new Date();
+    const updatedMappingInfo = [ ...mappingInfo ];
+    updatedMappingInfo[lastIndex] = { ...lastEntry, createdByEmail: email, updatedAt: currentTime, createdByUserName: userName, createdByRole: role };
+    const updateResult = await updateOpenSearchData( openSearch.footfallDirectory, _id, { doc: { mappingInfo: updatedMappingInfo } } );
+    if ( !updateResult ) {
+      return res.sendError( 'Failed to update ticket', 400 );
+    }
+    return res.sendSuccess( { message: 'Ticket assigned successfully' } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
     logger.error( { error: error, function: 'assignTicket' } );
@@ -1874,11 +4626,13 @@ export async function assignTicket( req, res ) {
 export async function updateTempStatus( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const { id, status } = req.body;
+    const inputData = req.body;
+    const { id, type, status, comments } = inputData;
     // Use bulk update API via bucketing (batch update) -- fetch docs, then bulk-update
     // 1. Search for all documents matching the ticket IDs
     const searchBody = {
+      size: 10000,
       query: {
         bool: {
           must: [
@@ -1897,16 +4651,14 @@ export async function updateTempStatus( req, res ) {
         openSearch.revop,
         searchBody,
     );
-    logger.info( { searchResp: searchResp } );
     // Extract bulk IDs to update
     const hits = searchResp?.body?.hits?.hits ?? [];
-    logger.info( { hits: hits } );
     if ( !hits.length ) {
       return res.sendError( 'no data', 204 );
     }
-    // 2. Build bulk update commands
-    // Each doc: { update: { _id: ..., _index: ... } }, { doc: { status: status } }
     // 1. Get all IDs from hits
     const docIdToIndex = {};
@@ -1914,7 +4666,6 @@ export async function updateTempStatus( req, res ) {
       docIdToIndex[doc._id] = doc._index;
     } );
     const docIds = hits.map( ( doc ) => doc._id );
-    logger.info( { docIds } );
     // 2. Fetch all docs by ID to get 'actions' (in chunks if large)
     const getBody = [];
     for ( const doc of hits ) {
@@ -1922,71 +4673,76 @@ export async function updateTempStatus( req, res ) {
     }
     let mgetResp;
-    try {
-      mgetResp = await getOpenSearchData(
-          openSearch.revop,
-          {
-            query: {
-              ids: {
-                values: docIds,
-              },
+    mgetResp = await getOpenSearchData(
+        openSearch.revop,
+        {
+          size: 10000,
+          query: {
+            ids: {
+              values: docIds,
             },
-            _source: true,
           },
-      );
-    } catch ( err ) {
-      logger.error( { error: err } );
-      mgetResp = undefined;
-    }
-    logger.info( { mgetResp } );
+          _source: true,
+        },
+    );
     // (If you have a utility for multi-get, you may want to use that. Else, you might need to fetch each by ID.)
     // For fallback, fetch all source fields via another search
-    let fullDocs = [];
-    if ( mgetResp && mgetResp.body && mgetResp.body.docs && Array.isArray( mgetResp.body.docs ) ) {
-      fullDocs = mgetResp.body.docs;
-    } else if ( searchResp.body && searchResp.body.hits && searchResp.body.hits.hits ) {
-      // fallback: use searchResp docs (request _source above)
-      fullDocs = searchResp.body.hits.hits;
-    }
+    let fullDocs = mgetResp?.body?.hits?.hits || searchResp?.body?.hits?.hits || [];
     // 3. Prepare the new actions array for each doc, and set up bulk update payloads
     const reviewActions = [ 'approved', 'rejected' ];
     const docsToUpdate = [];
-    logger.info( { fullDocs: fullDocs } );
     for ( const doc of fullDocs ) {
       const source = doc._source || doc.fields || {}; // support mget and search hits
       let actions = Array.isArray( source.actions ) ? [ ...source.actions ] : [];
       if ( reviewActions.includes( status ) ) {
         // for review: update or push 'review'
         let found = false;
-        actions = actions.map( ( item ) => {
-          if ( item.actionType === 'review' ) {
-            found = true;
-            return { ...item, action: status };
-          }
-          return item;
-        } );
-        if ( !found ) {
-          actions.push( { actionType: 'review', action: status } );
-        }
-      } else {
-        // tagging: update or push 'tagging'
-        let found = false;
-        actions = actions.map( ( item ) => {
-          if ( item.actionType === 'tagging' ) {
-            found = true;
-            return { ...item, action: 'submitted' };
-          }
-          return item;
-        } );
-        if ( !found ) {
-          actions.push( { actionType: 'tagging', action: 'submitted' } );
+        switch ( type ) {
+          case 'review':
+            actions = actions.map( ( item ) => {
+              if ( item.actionType === 'review' ) {
+                found = true;
+                return { ...item, action: status };
+              }
+              return item;
+            } );
+            if ( !found ) {
+              actions.push( { actionType: 'review', action: status } );
+            }
+            break;
+          case 'approve':
+            actions = actions.map( ( item ) => {
+              if ( item.actionType === 'approve' ) {
+                found = true;
+                return { ...item, action: status };
+              }
+              return item;
+            } );
+            if ( !found ) {
+              actions.push( { actionType: 'approve', action: status } );
+            }
+            break;
+          default:
+            return res.sendError( 'wrong vaue', 400 );
         }
       }
+      let isChecked = true;
+      switch ( type ) {
+        case 'review':
+          isChecked = status === 'approved' ? true : false;
+          break;
+        case 'approve':
+          isChecked = status === 'approved' ? doc?._source?.isChecked : !doc?._source?.isChecked;
+          break;
+      }
       docsToUpdate.push( {
         _index: doc._index || docIdToIndex[doc._id],
         _id: doc._id,
         actions,
+        isChecked: isChecked,
+        comments: comments || '',
       } );
     }
     const bulkPayload = [];
@@ -1996,11 +4752,9 @@ export async function updateTempStatus( req, res ) {
         update: { _index: doc._index, _id: doc._id },
       } );
       bulkPayload.push( {
-        doc: { actions: doc.actions },
+        doc: { actions: doc.actions, isChecked: doc?.isChecked, comments: doc?.comments || '' },
       } );
     }
-    logger.info( { bulkPayload: bulkPayload } );
     // 3. Execute bulk update
     const bulkResp = await bulkUpdate( bulkPayload );
@@ -2008,8 +4762,50 @@ export async function updateTempStatus( req, res ) {
     // Count successes
     const updatedCount = bulkResp?.body?.items?.filter( ( item ) => item?.update?.result === 'updated' || item?.update?.result === 'noop' ).length ?? 0;
-    logger.info( { updated: updatedCount, by: 'updateTempStatus', ids: id } );
+    if ( inputData?.comments && inputData?.comments !== '' ) {
+      const id = `${inputData.storeId}_${inputData.dateString}_${Date.now()}`;
+      const searchBody1 = {
+        size: 10000,
+        query: {
+          bool: {
+            must: [
+              {
+                terms: {
+                  '_id': docIds,
+                },
+              },
+              {
+                term: {
+                  isParent: false,
+                },
+              },
+            ],
+          },
+        },
+      };
+      const getSearchResp = await getOpenSearchData(
+          openSearch.revop,
+          searchBody1,
+      );
+      const taggedImages = getSearchResp?.body?.hits?.hits?.length > 0 ? getSearchResp?.body?.hits?.hits : [];
+      const logs = {
+        type: inputData.type,
+        storeId: taggedImages?.[0]?._source?.storeId,
+        dateString: taggedImages?.[0]?._source?.dateString,
+        category: taggedImages?.[0]?._source?.revopsType || '',
+        taggedImages: taggedImages,
+        status: inputData?.status,
+        createdByEmail: req?.user?.email,
+        createdByUserName: req?.user?.userName,
+        createdByRole: req?.user?.role,
+        message: inputData.comments || '',
+        createdAt: new Date(),
+      };
+      await insertWithId( openSearch.vmsCommentsLog, id, logs );
+    }
     return res.sendSuccess( { updated: updatedCount } );
   } catch ( error ) {
     const err = error.message;
@@ -2018,3 +4814,283 @@ export async function updateTempStatus( req, res ) {
   }
 }
+export async function updateUserTicketStatus( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const { storeId, dateString } = req.body || {};
+    if ( !storeId || !dateString ) {
+      return res.sendError( 'storeId and dateString are required', 400 );
+    }
+    const docId = `${storeId}_${dateString}_footfall-directory-tagging`;
+    // Fetch existing ticket so we can validate mappingInfo state
+    const existingDoc = await getOpenSearchById( openSearch.footfallDirectory, docId );
+    const ticketSource = existingDoc?.body?._source;
+    if ( !ticketSource ) {
+      return res.sendError( 'Ticket not found', 404 );
+    }
+    const mappingInfo = Array.isArray( ticketSource.mappingInfo ) ? ticketSource.mappingInfo : [];
+    if ( mappingInfo.length === 0 ) {
+      return res.sendError( 'mappingInfo is missing for this ticket', 400 );
+    }
+    const lastIndex = mappingInfo.length - 1;
+    const lastEntry = mappingInfo[lastIndex];
+    if ( !lastEntry ) {
+      return res.sendError( 'Unable to determine current ticket status', 400 );
+    }
+    if ( String( lastEntry.status ).toLowerCase() !== 'open' ) {
+      return res.sendError( 'Ticket is already picked by another user', 409 );
+    }
+    const currentTime = new Date();
+    const updatedMappingInfo = [ ...mappingInfo ];
+    updatedMappingInfo[lastIndex] = {
+      ...lastEntry,
+      status: 'In-Progress',
+      updatedAt: currentTime,
+      createdAt: currentTime,
+      createdByRole: req?.user?.role || '',
+      createdByEmail: req?.user?.email || '',
+      createdByUserName: req?.user?.userName || '',
+    };
+    const updatePayload = {
+      doc: {
+        status: lastEntry?.type == 'review'? 'Reviewer In progress':lastEntry?.type == 'approve'? 'Approver In progress':ticketSource?.status,
+        mappingInfo: updatedMappingInfo,
+        updatedAt: currentTime,
+      },
+    };
+    const updateResult = await updateOpenSearchData(
+        openSearch.footfallDirectory,
+        docId,
+        updatePayload,
+    );
+    if ( !updateResult || !( updateResult.statusCode === 200 || updateResult.statusCode === 201 ) ) {
+      return res.sendError( 'Failed to update ticket status', 500 );
+    }
+    return res.sendSuccess( 'Ticket status updated successfully' );
+  } catch ( error ) {
+    const err = error.message;
+    logger.info( { error: err, function: 'updateUserTicketStatus' } );
+    return res.sendError( err, 500 );
+  }
+}
+export async function multiCloseTicket( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.body;
+    // inputData structure should include an array of items to close
+    // Accept both array or single ticket update
+    const tickets = Array.isArray( inputData.ticketList ) ? inputData.ticketList : [ inputData.ticketList ];
+    // const mode = inputData.mode || '';
+    if ( !tickets.length ) {
+      return res.sendError( 'No tickets provided', 400 );
+    }
+    const results = [];
+    for ( const ticket of tickets ) {
+      const { storeId, dateString } = ticket || {};
+      if ( !storeId || !dateString ) {
+        results.push( { storeId, dateString, success: false, error: 'Missing storeId or dateString' } );
+        continue;
+      }
+      // 1. Update the ticket document in footfallDirectory index
+      const docId = `${storeId}_${dateString}_footfall-directory-tagging`;
+      // Fetch existing doc to update mappingInfo
+      const doc = await getOpenSearchById( openSearch.footfallDirectory, docId );
+      const ticketSource = doc?.body?._source;
+      if ( !ticketSource || !ticketSource.mappingInfo ) {
+        results.push( { storeId, dateString, success: false, error: 'Ticket or mappingInfo missing' } );
+        continue;
+      }
+      let mappingInfoArray = Array.isArray( ticketSource.mappingInfo ) ? ticketSource.mappingInfo : [ ticketSource.mappingInfo ];
+      // Find all mappingInfo items matching type 'approve'
+      let updated = false;
+      let newMappingInfoArray = mappingInfoArray.map( ( mi, i ) => {
+        if ( mi?.type === 'approve' && mi?.status === 'Open' ) {
+          updated = true;
+          return {
+            ...mi,
+            status: 'Approver-Closed',
+            status: 'Closed', // following the user's instruction to set sttaus property (assumed typo, but explicitly used)
+            updatedAt: new Date(),
+          };
+        }
+        return mi;
+      } );
+      if ( !updated ) {
+        // None found to update
+        results.push( { storeId, dateString, success: false, error: `coudn't approve this store` } );
+        continue;
+      }
+      // Write update to footfallDirectory
+      const ticketUpdatePayload = {
+        doc: {
+          mappingInfo: newMappingInfoArray,
+          status: 'Approver-Closed', // status updated at top level as well
+          updatedAt: new Date(),
+        },
+      };
+      let ticketUpdateResult;
+      try {
+        ticketUpdateResult = await updateOpenSearchData( openSearch.footfallDirectory, docId, ticketUpdatePayload );
+        if ( !( ticketUpdateResult && ( ticketUpdateResult.statusCode === 200 || ticketUpdateResult.statusCode === 201 ) ) ) {
+          results.push( { storeId, dateString, success: false, error: 'Failed to update ticket' } );
+          continue;
+        }
+      } catch ( err ) {
+        results.push( { storeId, dateString, success: false, error: 'Failed to update ticket' } );
+        continue;
+      }
+      // For each ticket, update actions array for all matching image docs (storeId & dateString)
+      // Query to find all matching docs in revopTagging index with storeId and dateString
+      const revopImageQuery = {
+        size: 10000, // assume there won't be more than 1000 images per ticket
+        query: {
+          bool: {
+            must: [
+              { term: { 'storeId.keyword': storeId } },
+              { term: { dateString: dateString } },
+            ],
+          },
+        },
+      };
+      // Fetch matching docs
+      const searchRes = await getOpenSearchData( openSearch.revop, revopImageQuery );
+      const revopHits = searchRes?.body?.hits?.hits || [];
+      // Optimized: batch and parallelize image-doc updates to avoid long sequential waits
+      const BATCH_SIZE = 100;
+      const now = new Date();
+      for ( let i = 0; i < revopHits.length; i += BATCH_SIZE ) {
+        const batch = revopHits.slice( i, i + BATCH_SIZE );
+        const updatePromises = batch.map( async ( hit ) => {
+          const imageDocId = hit._id;
+          const imageSource = hit._source || {};
+          const imageActionsArray = Array.isArray( imageSource.actions ) ? [ ...imageSource.actions ] : [];
+          imageActionsArray.push( {
+            actionType: 'approve',
+            action: 'approved',
+          } );
+          const imageUpdatePayload = {
+            doc: {
+              actions: imageActionsArray,
+              updatedAt: now,
+            },
+          };
+          return updateOpenSearchData( openSearch.revop, imageDocId, imageUpdatePayload );
+        } );
+        // Wait for this batch to finish before starting the next one
+        await Promise.all( updatePromises );
+      }
+    }
+    if ( results && results?.length > 0 ) {
+      return res.sendError( results, 500 );
+    }
+    // Return batch summary
+  } catch ( error ) {
+    const err = error.message;
+    logger.info( { error: err, function: 'multiCloseTicket' } );
+    return res.sendError( err, 500 );
+  }
+}
+export async function checkTicketExists( req, res ) {
+  try {
+    let inputData = req.body;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    let findQuery = {
+      size: 10000,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                'storeId.keyword': inputData.storeId,
+              },
+            },
+            {
+              term: {
+                'dateString': inputData.dateString,
+              },
+            },
+          ],
+        },
+      },
+    };
+    let findTicket = await getOpenSearchData( openSearch.footfallDirectory, findQuery );
+    let Ticket = findTicket.body?.hits?.hits;
+    res.sendSuccess( Ticket );
+  } catch ( error ) {
+    const err = error.message;
+    logger.info( { error: err, function: 'checkTicketExists' } );
+    return res.sendError( err, 500 );
+  }
+}
+export async function getAccuracyIssues( req, res ) {
+  try {
+    const inputData = req.query;
+    const getIsues = await findStoreAccuracIssues( { clientId: inputData.clientId, isActive: true }, { issueName: 1 } );
+    // const mode = inputData.mode || '';
+    res.sendSuccess( { result: getIsues|| [] } );
+    // Return batch summary
+  } catch ( error ) {
+    const err = error.message;
+    logger.info( { error: err, function: 'getAccuracyIssues' } );
+    return res.sendError( err, 500 );
+  }
+}
+export async function updateAccuracyIssues( req, res ) {
+  try {
+    const inputData = req.query;
+    const getIsues = await upsertStoreAccuracIssues( { clientId: inputData.clientId, issueName: inputData?.issueName }, { issueName: inputData?.issueName, isActive: true } );
+    // const mode = inputData.mode || '';
+    res.sendSuccess( { result: getIsues|| [] } );
+    // Return batch summary
+  } catch ( error ) {
+    const err = error.message;
+    logger.info( { error: err, function: 'putAccuracyIssues' } );
+    return res.sendError( err, 500 );
+  }
+}