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

package/src/controllers/footfallDirectory.controllers.js

@@ -1,13 +1,14 @@
 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';
 dayjs.extend( utc );
 dayjs.extend( timezone );
 
@@ -60,6 +61,395 @@ 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`;
+    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;
+
+    // get store info by the storeId into mongo db
+    const getstoreName = await findOneStore( { storeId: inputData.storeId, status: 'active' }, { storeId: 1, storeName: 1, clientId: 1 } );
+
+    if ( !getstoreName || getstoreName == null ) {
+      return res.sendError( 'The store ID is either inActive or not found', 400 );
+    }
+
+    // get the footfall count from opensearch
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const dateString = `${inputData.storeId}_${inputData.dateString}`;
+    const getQuery = {
+      query: {
+        terms: {
+          _id: [ dateString ],
+        },
+      },
+      _source: [ 'footfall', 'date_string', 'store_id', 'down_time', 'footfall_count' ],
+      sort: [
+        {
+          date_iso: {
+            order: 'desc',
+          },
+        },
+      ],
+    };
+
+    const getFootfallCount = await getOpenSearchData( openSearch.footfall, getQuery );
+    const hits = getFootfallCount?.body?.hits?.hits || [];
+    if ( hits?.[0]?._source?.footfall_count <= 0 ) {
+      return res.sendError( 'You can’t create a ticket because this store has 0 footfall data' );
+    }
+
+    // get category details from the client level configuration
+    const getConfig = await findOneClient( { clientId: getstoreName.clientId }, { footfallDirectoryConfigs: 1 } );
+    if ( !getConfig || getConfig == null ) {
+      return res.sendError( 'The Client ID is either not configured or not found', 400 );
+    }
+    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: 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,
+
+    };
+
+
+    // Retrieve client footfallDirectoryConfigs revision
+    let isAutoCloseEnable = getConfig.footfallDirectoryConfigs.isAutoCloseEnable;
+    let autoCloseAccuracy = getConfig?.footfallDirectoryConfigs?.autoCloseAccuracy;
+
+    const getNumber = autoCloseAccuracy.split( '%' )[0];
+
+    let autoCloseAccuracyValue = parseFloat( ( autoCloseAccuracy || getNumber ).replace( '%', '' ) );
+    let revisedPercentage = inputData.mappingInfo?.revicedPerc;
+    const revised = Number( revisedPercentage?.split( '%' )[0] );
+    const tangoReview = Number( getConfig?.footfallDirectoryConfigs?.tangoReview?.split( '%' )[0] );
+    // If autoclose enabled and revisedPercentage meets/exceeds threshold, close ticket and skip revision
+    if (
+      isAutoCloseEnable === true &&
+      revisedPercentage >= autoCloseAccuracyValue
+    ) {
+      record.status = 'Closed';
+      // Only keep or modify mappingInfo items with type "review"
+      if ( Array.isArray( record.mappingInfo ) ) {
+        const temp = record.mappingInfo
+            .filter( ( item ) => item.type === '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,
+            } ) );
+
+        record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+          ...temp ];
+        // If updating the mapping config to mark [i].status as 'Closed'
+        // Make sure all relevant mappingInfo items of type 'approve' are set to status 'Closed'
+        if ( Array.isArray( record.mappingInfo ) ) {
+          record.mappingInfo = record.mappingInfo.map( ( item ) => {
+            return {
+              ...item,
+              status: 'Closed',
+            };
+          } );
+        }
+        // If no review mapping existed, push a new one
+        // if ( record.mappingInfo.length === 0 ) {
+        //   record.mappingInfo.push( {
+        //     type: 'tangoreview',
+        //     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,
+        //   } );
+        // }
+      }
+      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 ) {
+      // If ticket is closed, do not proceed with revision mapping
+
+      record.status = 'Closed - Accuracy Issue';
+      // Only keep or modify mappingInfo items with type "review"
+      if ( Array.isArray( record.mappingInfo ) ) {
+        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,
+            } ) );
+
+        record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+          ...temp ];
+        if ( Array.isArray( record.mappingInfo ) ) {
+          record.mappingInfo = record.mappingInfo.map( ( item ) => {
+            return {
+              ...item,
+              status: 'Closed',
+            };
+          } );
+        }
+        // If no review mapping existed, push a new one
+        // if ( record.mappingInfo.length === 0 ) {
+        //   record.mappingInfo.push( {
+        //     type: 'tangoreview',
+        //     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,
+        //   } );
+        // }
+      }
+    } else {
+      if ( Array.isArray( record.mappingInfo ) ) {
+        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,
+            } ) );
+
+        record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
+          ...temp ];
+        if ( Array.isArray( record.mappingInfo ) ) {
+          record.mappingInfo = record.mappingInfo.map( ( item ) => {
+            return {
+              ...item,
+              status: 'Closed',
+            };
+          } );
+        }
+        // If no review mapping existed, push a new one
+        // if ( record.mappingInfo.length === 0 ) {
+        //   record.mappingInfo.push( {
+        //     type: 'tangoreview',
+        //     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,
+        //   } );
+        // }
+      }
+      record.mappingInfo.push(
+          {
+            type: 'finalRevision',
+            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(),
+          },
+      );
+    }
+
+    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`;
+    if ( inputData.ticketType === 'internal' ) {
+      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 ) ) {
+      return res.sendSuccess( 'Ticket closed successfully' );
+    } else {
+      return res.sendError( 'Internal Server Error', 500 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: err, funtion: 'tangoReviewTicket' } );
+    return res.sendError( err, 500 );
+  }
+}
+
 async function bulkUpdateStatusToPending( indexName, inputData ) {
   const bulkBody = [];
 
@@ -195,7 +585,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,
@@ -220,10 +609,10 @@ export async function ticketSummary( req, res ) {
   try {
     let result = '';
     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 ) ) ) );
+    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 ={
+    if ( req.user.userType == 'tango' ) {
+      result = {
         totalTickets: 0,
         averageAccuracyOverAll: 0,
         openTickets: 0,
@@ -234,30 +623,30 @@ export async function ticketSummary( req, res ) {
         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';
+      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';
     }
 
     return res.sendSuccess( { result: result } );
@@ -293,7 +682,7 @@ export async function ticketList1( req, res ) {
         terms: {
           'clientId.keyword': Array.isArray( inputData.clientId ) ?
             inputData.clientId :
-           [ inputData.clientId ],
+            [ inputData.clientId ],
         },
       },
     ];
@@ -470,12 +859,12 @@ export async function ticketList1( req, res ) {
           '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 )} %`,
+          '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,
         } );
       }
@@ -491,825 +880,463 @@ export async function ticketList1( req, res ) {
 
 export async function ticketList( req, res ) {
   try {
-    let result = '';
-    const inputData= req.query;
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.query;
     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 ) ) ) );
+    const limit = inputData?.limit || 10;
+    const offset = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
+    inputData.clientId = inputData?.clientId?.split( ',' ); // convert strig to array
 
-    if ( req.user.userType =='tango' ) {
-      result =inputData.tangotype == 'store'?
 
+    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'reviewer' && ( m.isAdd == true || m.isEdit == true ) ) ) );
 
-      [
-        {
-          ticketId: 'TE_FDT_1763539990306',
-          storeId: '11-1716',
-          storeName: 'LKST1916',
-          ticketRaised: '2025-11-16',
-          issueDate: '2025-11-16',
-          dueDate: '2025-11-18',
-          footfall: 1200,
-          storeRevisedAccuracy: '98%',
-          reviewerRevisedAccuracy: '97%',
-          approverRevisedAccuracy: '98%',
-          tangoRevisedAccuracy: '98%',
-          status: 'Closed',
-        },
-        {
-          ticketId: 'TE_FDT_1763860421803',
-          storeId: '11-1716',
-          storeName: 'LKST1916',
-          ticketRaised: '2025-11-21',
-          issueDate: '2025-11-20',
-          dueDate: '2025-11-26',
-          footfall: 94,
-          storeRevisedAccuracy: '90%',
-          reviewerRevisedAccuracy: '--',
-          approverRevisedAccuracy: '--',
-          tangoRevisedAccuracy: '--',
-          status: 'Open',
-        },
-        {
-          ticketId: 'TE_FDT_1763711403163',
-          storeId: '11-1716',
-          storeName: 'LKST1916',
-          ticketRaised: '2025-11-20',
-          issueDate: '2025-11-19',
-          dueDate: 'Due Today',
-          footfall: 94,
-          storeRevisedAccuracy: '95%',
-          reviewerRevisedAccuracy: '--',
-          approverRevisedAccuracy: '--',
-          tangoRevisedAccuracy: '--',
-          status: 'Open',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990309',
-          storeId: '11-2000',
-          storeName: 'LKST2368',
-          ticketRaised: '2025-11-13',
-          issueDate: '2025-11-13',
-          dueDate: '2025-11-15',
-          footfall: 1280,
-          storeRevisedAccuracy: '98%',
-          reviewerRevisedAccuracy: '98%',
-          approverRevisedAccuracy: '97%',
-          tangoRevisedAccuracy: '97%',
-          status: 'Closed',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990310',
-          storeId: '11-2000',
-          storeName: 'LKST2368',
-          ticketRaised: '2025-11-14',
-          issueDate: '2025-11-14',
-          dueDate: '2025-11-16',
-          footfall: 1300,
-          storeRevisedAccuracy: '96%',
-          reviewerRevisedAccuracy: '95%',
-          approverRevisedAccuracy: '96%',
-          tangoRevisedAccuracy: '95%',
-          status: 'Open',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990311',
-          storeId: '11-2000',
-          storeName: 'LKST2368',
-          ticketRaised: '2025-11-15',
-          issueDate: '2025-11-15',
-          dueDate: '2025-11-17',
-          footfall: 1350,
-          storeRevisedAccuracy: '99%',
-          reviewerRevisedAccuracy: '98%',
-          approverRevisedAccuracy: '98%',
-          tangoRevisedAccuracy: '99%',
-          status: 'Closed',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990312',
-          storeId: '11-2000',
-          storeName: 'LKST2368',
-          ticketRaised: '2025-11-16',
-          issueDate: '2025-11-16',
-          dueDate: '2025-11-18',
-          footfall: 1400,
-          storeRevisedAccuracy: '97%',
-          reviewerRevisedAccuracy: '96%',
-          approverRevisedAccuracy: '97%',
-          tangoRevisedAccuracy: '96%',
-          status: 'Closed',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990313',
-          storeId: '11-10',
-          storeName: 'LKST80',
-          ticketRaised: '2023-11-14',
-          issueDate: '2023-11-14',
-          dueDate: '2023-11-16',
-          footfall: 900,
-          storeRevisedAccuracy: '95%',
-          reviewerRevisedAccuracy: '94%',
-          approverRevisedAccuracy: '95%',
-          tangoRevisedAccuracy: '95%',
-          status: 'Inprogress',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990314',
-          storeId: '11-10',
-          storeName: 'LKST80',
-          ticketRaised: '2023-11-15',
-          issueDate: '2023-11-15',
-          dueDate: '2023-11-17',
-          footfall: 1000,
-          storeRevisedAccuracy: '98%',
-          reviewerRevisedAccuracy: '97%',
-          approverRevisedAccuracy: '97%',
-          tangoRevisedAccuracy: '98%',
-          status: 'Closed',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990315',
-          storeId: '11-10',
-          storeName: 'LKST80',
-          ticketRaised: '2023-11-16',
-          issueDate: '2023-11-16',
-          dueDate: '2023-11-18',
-          footfall: 1050,
-          storeRevisedAccuracy: '96%',
-          reviewerRevisedAccuracy: '96%',
-          approverRevisedAccuracy: '96%',
-          tangoRevisedAccuracy: '97%',
-          status: 'Open',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990316',
-          storeId: '11-10',
-          storeName: 'LKST80',
-          ticketRaised: '2023-11-17',
-          issueDate: '2023-11-17',
-          dueDate: '2023-11-19',
-          footfall: 1100,
-          storeRevisedAccuracy: '97%',
-          reviewerRevisedAccuracy: '97%',
-          approverRevisedAccuracy: '97%',
-          tangoRevisedAccuracy: '97%',
-          status: 'Closed',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990317',
-          storeId: '12-1111',
-          storeName: 'LKST3030',
-          ticketRaised: '2025-10-12',
-          issueDate: '2025-10-12',
-          dueDate: '2025-10-14',
-          footfall: 1200,
-          storeRevisedAccuracy: '97%',
-          reviewerRevisedAccuracy: '97%',
-          approverRevisedAccuracy: '97%',
-          tangoRevisedAccuracy: '96%',
-          status: 'Open',
-        },
-        {
-          ticketId: 'TE_FDT_176353999018',
-          storeId: '12-1111',
-          storeName: 'LKST3030',
-          ticketRaised: '2025-10-13',
-          issueDate: '2025-10-13',
-          dueDate: '2025-10-15',
-          footfall: 1095,
-          storeRevisedAccuracy: '95%',
-          reviewerRevisedAccuracy: '96%',
-          approverRevisedAccuracy: '97%',
-          tangoRevisedAccuracy: '95%',
-          status: 'Open-Accuracy Issue',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990319',
-          storeId: '12-1111',
-          storeName: 'LKST3030',
-          ticketRaised: '2025-10-14',
-          issueDate: '2025-10-14',
-          dueDate: '2025-10-16',
-          footfall: 987,
-          storeRevisedAccuracy: '98%',
-          reviewerRevisedAccuracy: '99%',
-          approverRevisedAccuracy: '99%',
-          tangoRevisedAccuracy: '99%',
-          status: 'closed-Accuracy Issue',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990320',
-          storeId: '14-8002',
-          storeName: 'LKST4590',
-          ticketRaised: '2025-09-12',
-          issueDate: '2025-09-12',
-          dueDate: '2025-09-14',
-          footfall: 1080,
-          storeRevisedAccuracy: '98%',
-          reviewerRevisedAccuracy: '97%',
-          approverRevisedAccuracy: '99%',
-          tangoRevisedAccuracy: '99%',
-          status: 'Closed',
-        },
+    const ticketsApproveFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'approver' && ( m.isAdd == true || m.isEdit == true ) ) ) );
 
-      ] :
-      [
+    const searchQuery = {
 
-        {
-          ticketId: 'TE_FDT_1763860421803',
-          storeId: '11-1716',
-          storeName: 'LKST1916',
-          ticketRaised: '2025-11-21',
-          issueDate: '2025-11-20',
-          footfall: 94,
-          type: 'store',
-          storeRevisedAccuracy: '95%',
-          reviewerRevisedAccuracy: '--',
-          approverRevisedAccuracy: '--',
-          tangoRevisedAccuracy: '--',
-          status: 'Open',
-          tangoStatus: 'Open',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990307',
-          storeId: '11-1716',
-          storeName: 'LKST1916',
-          ticketRaised: '2025-11-13',
-          issueDate: '2025-11-13',
-          footfall: 1150,
-          type: 'store',
-          storeRevisedAccuracy: '99%',
-          reviewerRevisedAccuracy: '99%',
-          approverRevisedAccuracy: '98%',
-          tangoRevisedAccuracy: '97%',
-          status: 'Closed',
-          tangoStatus: 'open',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990308',
-          storeId: '11-1716',
-          storeName: 'LKST1916',
-          ticketRaised: '2025-11-14',
-          issueDate: '2025-11-14',
-          footfall: 1100,
-          type: 'store',
-          storeRevisedAccuracy: '97%',
-          reviewerRevisedAccuracy: '96%',
-          approverRevisedAccuracy: '97%',
-          status: 'Closed',
-          tangoStatus: 'In-Progress',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990309',
-          storeId: '11-2000',
-          storeName: 'LKST2368',
-          ticketRaised: '2025-11-13',
-          issueDate: '2025-11-13',
-          footfall: 1280,
-          type: 'internal',
-          storeRevisedAccuracy: '98%',
-          reviewerRevisedAccuracy: '98%',
-          approverRevisedAccuracy: '97%',
-          tangoRevisedAccuracy: '97%',
-          status: 'Closed-Accuracy Issue',
-          tangoStatus: 'Open',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990310',
-          storeId: '11-2000',
-          storeName: 'LKST2368',
-          ticketRaised: '2025-11-14',
-          issueDate: '2025-11-14',
-          footfall: 300,
-          type: 'store',
-          storeRevisedAccuracy: '96%',
-          reviewerRevisedAccuracy: '95%',
-          approverRevisedAccuracy: '96%',
-          tangoRevisedAccuracy: '95%',
-          status: 'Closed',
-          tangoStatus: 'In-Progress',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990311',
-          storeId: '11-2000',
-          storeName: 'LKST2368',
-          ticketRaised: '2025-11-15',
-          issueDate: '2025-11-15',
-          footfall: 350,
-          type: 'internal',
-          storeRevisedAccuracy: '99%',
-          reviewerRevisedAccuracy: '98%',
-          approverRevisedAccuracy: '98%',
-          tangoRevisedAccuracy: '99%',
-          status: 'Closed',
-          tangoStatus: 'In-Progress',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990312',
-          storeId: '11-2000',
-          storeName: 'LKST2368',
-          ticketRaised: '2025-11-16',
-          issueDate: '2025-11-16',
-          footfall: 400,
-          type: 'internal',
-          storeRevisedAccuracy: '97%',
-          reviewerRevisedAccuracy: '96%',
-          approverRevisedAccuracy: '97%',
-          tangoRevisedAccuracy: '96%',
-          status: 'Open-Accuracy Issue',
-          tangoStatus: 'Open',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990313',
-          storeId: '11-10',
-          storeName: 'LKST80',
-          ticketRaised: '2023-11-14',
-          issueDate: '2023-11-14',
-          footfall: 900,
-          type: 'internal',
-          storeRevisedAccuracy: '95%',
-          reviewerRevisedAccuracy: '94%',
-          approverRevisedAccuracy: '95%',
-          tangoRevisedAccuracy: '95%',
-          status: 'Closed',
-          tangoStatus: 'Closed',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990314',
-          storeId: '11-10',
-          storeName: 'LKST80',
-          ticketRaised: '2023-11-15',
-          issueDate: '2023-11-15',
-          type: 'store',
-          footfall: 100,
-          storeRevisedAccuracy: '98%',
-          reviewerRevisedAccuracy: '97%',
-          approverRevisedAccuracy: '97%',
-          tangoRevisedAccuracy: '98%',
-          status: 'closed-Accuracy Issue',
-          tangoStatus: 'Closed',
-        },
-        {
-          ticketId: 'TE_FDT_1763539990320',
-          storeId: '14-8002',
-          storeName: 'LKST4590',
-          ticketRaised: '2025-09-12',
-          issueDate: '2025-09-12',
-          type: 'internal',
-          footfall: 80,
-          storeRevisedAccuracy: '98%',
-          reviewerRevisedAccuracy: '97%',
-          approverRevisedAccuracy: '99%',
-          tangoRevisedAccuracy: '99%',
-          status: 'Closed-Accuracy Issue',
-          tangoStatus: 'Closed',
-        },
-      ];
-    } else {
-      result = req.user.role === 'superadmin'?
-[
-  {
-    ticketId: 'TE_FDT_1763539990320',
-    storeId: '11-1716',
-    storeName: 'LKST1916',
-    ticketRaised: '2025-11-13',
-    issueDate: '2025-11-12',
-    dueDate: '2025-11-14',
-    footfall: 60,
-    storeRevisedAccuracy: '45%',
-    reviewerRevisedAccuracy: '67%',
-    approverRevisedAccuracy: '87%',
-    tangoRevisedAccuracy: '93%',
-    status: 'Open',
-    approvedBy: '',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990321',
-    storeId: '11-1716',
-    storeName: 'LKST1916',
-    ticketRaised: '2025-11-11',
-    issueDate: '2025-11-10',
-    dueDate: '2025-11-12',
-    footfall: 69,
-    storeRevisedAccuracy: '79%',
-    reviewerRevisedAccuracy: '80%',
-    approverRevisedAccuracy: '90%',
-    tangoRevisedAccuracy: '90%',
-    status: 'In-Progress',
-    approvedBy: 'mu_mu@yopmail.com',
-  },
-  {
-    ticketId: 'TE_FDT_1763860421803',
-    storeId: '11-1716',
-    storeName: 'LKST1916',
-    ticketRaised: '2025-11-21',
-    issueDate: '2025-11-20',
-    dueDate: '2025-11-26',
-    footfall: 94,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '90%',
-    approverRevisedAccuracy: '90%',
-    tangoRevisedAccuracy: '90%',
-    status: 'Closed',
-    approvedBy: 'mu_mu@yopmail.com',
-  },
-  {
-    ticketId: 'TE_FDT_1763711403163',
-    storeId: '11-1716',
-    storeName: 'LKST1916',
-    ticketRaised: '2025-11-20',
-    issueDate: '2025-11-19',
-    dueDate: 'Due Today',
-    footfall: 94,
-    storeRevisedAccuracy: '95%',
-    reviewerRevisedAccuracy: '--',
-    approverRevisedAccuracy: '--',
-    tangoRevisedAccuracy: '--',
-    status: 'In-Progress',
-    approvedBy: 'mu_mu@yopmail.com',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990320',
-    storeId: '11-1716',
-    storeName: 'LKST1916',
-    ticketRaised: '2025-11-15',
-    issueDate: '2025-11-14',
-    dueDate: '2025-11-17',
-    footfall: 110,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '--',
-    approverRevisedAccuracy: '--',
-    tangoRevisedAccuracy: '--',
-    status: 'Open',
-    approvedBy: '',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990323',
-    storeId: '11-10',
-    storeName: 'LKST80',
-    ticketRaised: '2025-11-13',
-    issueDate: '2025-11-12',
-    dueDate: '2025-11-14',
-    footfall: 170,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '90%',
-    approverRevisedAccuracy: '--',
-    tangoRevisedAccuracy: '--',
-    status: 'Open',
-    approvedBy: '',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990328',
-    storeId: '11-10',
-    storeName: 'LKST80',
-    ticketRaised: '2025-11-12',
-    issueDate: '2025-11-11',
-    dueDate: '2025-11-14',
-    footfall: 170,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '90%',
-    approverRevisedAccuracy: '90%',
-    tangoRevisedAccuracy: '--',
-    status: 'Expired',
-    approvedBy: 'mu_mu@yopmail.com',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990330',
-    storeId: '11-10',
-    storeName: 'LKST80',
-    ticketRaised: '2025-11-18',
-    issueDate: '2025-11-15',
-    dueDate: 'Due Today',
-    footfall: 230,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '90%',
-    approverRevisedAccuracy: '90%',
-    tangoRevisedAccuracy: '90%',
-    status: 'Closed',
-    approvedBy: 'mu_mu@yopmail.com',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990332',
-    storeId: '11-10',
-    storeName: 'LKST80',
-    ticketRaised: '2025-11-17',
-    issueDate: '2025-11-16',
-    dueDate: '2025-11-20',
-    footfall: 812,
-    storeRevisedAccuracy: '80%',
-    reviewerRevisedAccuracy: '80%',
-    approverRevisedAccuracy: '80%',
-    tangoRevisedAccuracy: '--',
-    status: 'Open',
-    approvedBy: 'mu_mu@yopmail.com',
-  },
-  {
-    ticketId: 'TE_FDT_176353999034',
-    storeId: '11-2000',
-    storeName: 'LKST2368',
-    ticketRaised: '2025-11-15',
-    issueDate: '2025-11-14',
-    dueDate: '2025-11-19',
-    footfall: '',
-    storeRevisedAccuracy: '--',
-    reviewerRevisedAccuracy: '--',
-    approverRevisedAccuracy: '--',
-    tangoRevisedAccuracy: '--',
-    status: 'Open',
-    approvedBy: '',
-  },
-] :
-req.user.role === 'user'? 'NA':
-ticketsFeature?
-[
-  {
-    ticketId: 'TE_FDT_1763860421803',
-    storeId: '11-1716',
-    storeName: 'LKST1916',
-    ticketRaised: '2025-11-21',
-    issueDate: '2025-11-20',
-    dueDate: 'Due Today',
-    footfall: 90,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '0%',
-    status: 'Open',
-    ReviewedBy: '',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990346',
-    storeId: '11-2000',
-    storeName: 'LKST2368',
-    ticketRaised: '2025-11-21',
-    issueDate: '2025-11-20',
-    dueDate: '2025-11-26',
-    footfall: 90,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '--',
-    status: 'In-Progress',
-    ReviewedBy: 'mu_mu@yopmail.com',
-  },
-  {
-    ticketId: 'TE_FDT_176353999048',
-    storeId: '11-2000',
-    storeName: 'LKST2368',
-    ticketRaised: '2025-11-16',
-    issueDate: '2025-11-15',
-    dueDate: '2025-11-19',
-    footfall: 100,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '90%',
-    status: 'Closed',
-    ReviewedBy: 'ayyanar@yopmail.com',
-  },
-  {
-    ticketId: 'TE_FDT_176353999048',
-    storeId: '11-10',
-    storeName: 'LKST80',
-    ticketRaised: '2025-11-08',
-    issueDate: '2025-11-06',
-    dueDate: '2025-11-09',
-    footfall: 120,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '0%',
-    status: 'Expired',
-    ReviewedBy: '',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990341',
-    storeId: '11-2000',
-    storeName: 'LKST2368',
-    ticketRaised: '2025-11-6',
-    issueDate: '2025-11-15',
-    dueDate: 'Due Today',
-    footfall: 510,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '--',
-    status: 'Open',
-    ReviewedBy: '',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990340',
-    storeId: '11-10',
-    storeName: 'LKST80',
-    ticketRaised: '2025-11-14',
-    issueDate: '2025-11-12',
-    dueDate: '2025-11-15',
-    footfall: 100,
-    storeRevisedAccuracy: '0%',
-    reviewerRevisedAccuracy: '0%',
-    status: 'Expired',
-    ReviewedBy: '',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990339',
-    storeId: '11-2000',
-    storeName: 'LKST2368',
-    ticketRaised: '2025-11-16',
-    issueDate: '2025-11-15',
-    dueDate: '2025-11-17',
-    footfall: 140,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '90%',
-    status: 'Closed',
-    ReviewedBy: 'sornanithya@yopmail.com',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990337',
-    storeId: '11-10',
-    storeName: 'LKST80',
-    ticketRaised: '2025-11-16',
-    issueDate: '2025-11-15',
-    dueDate: '2025-11-18',
-    footfall: '',
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '--',
-    status: 'Expired',
-    ReviewedBy: '',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990338',
-    storeId: '11-2000',
-    storeName: 'LKST2368',
-    ticketRaised: '2025-11-17',
-    issueDate: '2025-11-16',
-    dueDate: 'Due today',
-    footfall: 110,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '--',
-    status: 'In-Progress',
-    ReviewedBy: 'vinoth@yopmail.com',
-  },
-  {
-    ticketId: 'TE_FDT_1763539990335',
-    storeId: '11-2000',
-    storeName: 'LKST2368',
-    ticketRaised: '2025-11-17',
-    issueDate: '2025-11-16',
-    dueDate: 'Due today',
-    footfall: 100,
-    storeRevisedAccuracy: '90%',
-    reviewerRevisedAccuracy: '0%',
-    status: 'In-Progress',
-    ReviewedBy: 'sornanithya@yopmail.com',
-  },
-]: 'NA';
-    }
+      size: limit, // or use parseInt(req.query.limit) for dynamic
+      from: offset, // or use parseInt(req.query.offset) for dynamic
+      sort: [ { 'createdAt': { order: 'desc' } } ],
 
-    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 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 filter = [
+      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 ],
+              },
 
-      {
-        range: {
-          dateString: {
-            gte: inputData.fromDate,
-            lte: inputData.toDate,
-            format: 'yyyy-MM-dd',
-          },
+            },
+          ],
         },
       },
-    ];
-    if ( inputData?.storeId ) {
-      filter.push(
-          {
-            terms: {
-              'storeId.keyword': Array.isArray( inputData.storeId ) ?
-            inputData.storeId :
-            inputData.storeId,
-            },
-          },
-      );
+    };
+
+    if ( inputData.sortBy ) {
+      let sortOrder = inputData.sortOrder === 1 ? 'asc' : 'desc';
+
+      // Remove default sort so we don't duplicate/conflict
+      // INSERT_YOUR_CODE
+      // If sortBy is present, check if the field needs ".keyword" (for string fields like storeName, storeId, ticketId)
+      // This avoids OpenSearch errors about sorting on text fields.
+      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 } },
+      ];
     }
-    if ( inputData?.dateString ) {
-      filter.push(
-          {
-            term: {
-              'dateString': inputData.dateString,
-            },
-          },
-      );
+    // Example: Filtering by storeId if present in the query
+    if ( inputData.storeId ) {
+      inputData.storeId = inputData?.storeId?.split( ',' );
+      searchQuery.query.bool.must.push( {
+        terms: {
+          'storeId.keyword': Array.isArray( inputData.storeId ) ?
+            inputData.storeId :
+            [ inputData.storeId ],
+        },
+      } );
     }
-    if ( inputData.status ) {
-      filter.push(
-          {
-            term: {
-              'status.keyword': inputData.status,
-            },
+    if ( inputData.status && inputData.status!=='' ) {
+      inputData.status = inputData?.status?.split( ',' );
+      if ( req.user.userType === 'tango' ) {
+        searchQuery.query.bool.must.push( {
+          terms: {
+            'status': Array.isArray( inputData?.status ) ?
+              inputData?.status :
+              [ inputData?.status ],
           },
-      );
-    }
-    if (
-      inputData.revopsType
-    ) {
-      inputData.revopsType === 'employee' ?
-        filter.push( {
-          range: {
-            employeeCount: {
-              gt: 0,
+        } );
+      } 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],
+                    },
+                  },
+                ],
+              },
             },
           },
-        } ) :
-        inputData.revopsType === 'houseKeeping' ?
-          filter.push( {
-            range: {
-              houseKeepingCount: {
-                gt: 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],
+                    },
+                  },
+                ],
               },
             },
-          } ) :
-              inputData.revopsType === 'junk' ?
-          filter.push( {
-            range: {
-              junkCount: {
-                gt: 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],
+                    },
+                  },
+                ],
               },
             },
-          } ) :
-          filter.push( {
-            range: {
-              duplicateCount: {
-                gt: 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],
+                    },
+                  },
+                ],
               },
             },
-          } );
-      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',
-              },
+    if ( req?.user?.userType == 'tango' && inputData.tangoType !== 'internal' ) {
+      searchQuery.query.bool.must.push(
+          {
+            term: {
+              'type.keyword': 'store',
             },
-            {
-              constant_score: {
-                filter: { term: { 'employeeStatus.keyword': inputData.action } },
-                boost: 1,
-                _name: 'matched_employee',
+          },
+          {
+            nested: {
+              path: 'mappingInfo',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'mappingInfo.type': 'tangoreview',
+                      },
+                    },
+
+                  ],
+                },
               },
             },
-            {
-              constant_score: {
-                filter: { term: { 'duplicateStatus.keyword': inputData.action } },
-                boost: 1,
-                _name: 'matched_duplicate',
+
+          },
+
+
+      );
+    } else if ( req?.user?.userType == 'client' && inputData.tangoType !== 'internal' ) {
+      searchQuery.query.bool.must.push(
+          {
+            term: {
+              'type.keyword': 'store',
+            },
+          },
+          {
+            nested: {
+              path: 'mappingInfo',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'mappingInfo.type': ticketsFeature ? 'review' : ticketsApproveFeature ?
+                    'approve' : 'tagging',
+                      },
+                    },
+
+                  ],
+                },
               },
             },
-            {
-              constant_score: {
-                filter: { term: { 'junkStatus.keyword': inputData.action } },
-                boost: 1,
-                _name: 'matched_junk',
+          },
+
+      );
+    }
+
+    if ( inputData?.permissionType ) {
+      searchQuery.query.bool.must.push(
+          {
+            nested: {
+              path: 'mappingInfo',
+              query: {
+                bool: {
+                  must: [
+                    {
+                      term: {
+                        'mappingInfo.type': inputData?.permissionType == 'review' ? 'review' :
+                        'approve',
+                      },
+                    },
+
+                  ],
+                },
               },
             },
-          ],
-          minimum_should_match: 1,
-        },
-      } );
+          },
+      );
     }
 
+    if ( inputData.searchValue && inputData.searchValue !== '' ) {
+      searchQuery.query.bool['should'] = [];
+      searchQuery.query.bool.should = [
 
-    let getRevCount = {};
-    if ( inputData.revopsType ) {
-      getRevCount = {
-        size: 0,
-        query: {
-          bool: {
-            filter: filter,
+        {
+          'wildcard': {
+            'storeName.keyword': {
+              'value': `*${inputData.searchValue}*`,
+            },
           },
         },
-        aggs: {
-          totalCount: {
-            sum: {
-              field: inputData.revopsType == 'employee' ? 'employeeCount' : inputData.revopsType == 'houseKeeping' ? 'houseKeepingCount' :inputData.revopsType == 'junk' ? 'junkCount': 'duplicateCount',
+        {
+          'wildcard': {
+            'storeId.keyword': {
+              'value': `*${inputData.searchValue}*`,
             },
           },
         },
-      };
+        {
+          'wildcard': {
+            'ticketId.keyword': {
+              'value': `*${inputData.searchValue}*`,
+            },
+          },
+        },
+
+
+      ];
+      searchQuery.query.bool['minimum_should_match'] = 1;
+    }
+    // You can add more filters as needed
+    const searchResult = await getOpenSearchData( openSearch.footfallDirectory, searchQuery );
+    const count = searchResult?.body?.hits?.total?.value || 0;
+
+    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?.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?.status,
+
+          } );
+        }
+      } 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: '',
+            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 || '--',
+
+          } );
+        }
+      }
+    } else {
+      if ( inputData?.permissionType === 'approve' ) {
+        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?.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' ) {
+        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: '',
+            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?.footfallCount,
+            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 ) {
+        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?.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 = [];
+      }
     }
+
+    return res.sendSuccess( { result: temp, 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 getTickets( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.query;
+
+
+    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 = [
+
+      {
+        term: {
+          'ticketId.keyword': inputData.ticketId,
+        },
+      },
+    ];
+
+
     const getCount = {
       query: {
         bool: {
@@ -1320,20 +1347,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,
@@ -1343,14 +1364,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 ) {
@@ -1388,56 +1404,307 @@ 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' ) ) {
-          result = defaultData;
-          result.junk = hit?._source?.junk;
-          result.matched = matched;
-        }
+        if ( matched.includes( 'matched_junk' ) && ( !inputData.revopsType || inputData.revopsType == 'junk' ) ) {
+          result = defaultData;
+          result.junk = hit?._source?.junk;
+          result.matched = matched;
+        }
+
+        if ( result ) {
+          const nested = [
+            {
+              _id: hit._id,
+              _index: hit._index,
+              _score: 0,
+              _source: result,
+            },
+          ];
+          temp.push( ...nested );
+        }
+      } );
+    }
+
+    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 ( result ) {
-          const nested = [
-            {
-              _id: hit._id,
-              _index: hit._index,
-              _score: 0,
-              _source: result,
-            },
-          ];
-          temp.push( ...nested );
-        }
-      } );
-    }
-    const finalResponse = inputData.action ? temp : response;
     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 } );
@@ -1509,7 +1776,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' } },
         );
       } );
     }
@@ -1524,11 +1791,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 } } );
   }
@@ -1547,7 +1814,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 } } );
@@ -1568,7 +1835,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 } } );
@@ -1593,7 +1860,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 );
@@ -1656,7 +1923,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;
@@ -1706,7 +1973,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( {
@@ -1734,12 +2001,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}`,
@@ -1747,7 +2013,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,
@@ -1797,13 +2063,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 || [] },
@@ -1918,8 +2178,8 @@ export async function downloadTickets( req, res ) {
           {
             terms: {
               'storeId.keyword': Array.isArray( inputData.storeId ) ?
-            inputData.storeId :
-            inputData.storeId,
+              inputData.storeId :
+              inputData.storeId,
             },
           },
       );
@@ -1967,26 +2227,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 ) {
@@ -2063,7 +2323,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,
@@ -2093,19 +2353,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;
@@ -2149,7 +2409,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,
@@ -2167,7 +2427,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,
@@ -2196,7 +2456,6 @@ export async function downloadTickets( req, res ) {
 }
 
 async function extractTempIds( document ) {
-  logger.info( { document: document } );
   const source = document?._source || {};
   const result = [];
 
@@ -2246,7 +2505,7 @@ export async function reviewerList( req, res ) {
           featureName: 'FootfallDirectory',
           modules: {
             $elemMatch: {
-              name: 'Reviewer',
+              name: inputData?.type === 'review' ? 'reviewer' : 'approver',
               $or: [ { isAdd: true }, { isEdit: true } ],
             },
           },
@@ -2255,7 +2514,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 );
@@ -2277,6 +2536,16 @@ export async function openTicketList( req, res ) {
           clientId: Array.isArray( clientId ) ? clientId : [ clientId ],
         },
       },
+      {
+        term: {
+          'mappingInfo.type': inputData.type,
+        },
+      },
+      {
+        term: {
+          'mappingInfo.status.keyword': 'Open',
+        },
+      },
       {
         range: {
           dateString: {
@@ -2295,14 +2564,19 @@ export async function openTicketList( req, res ) {
           filter: filter,
         },
       },
-      _source: [ 'ticketId', 'storeName', 'revicedFootfall', 'footfallCount', 'revicedPerc' ],
+      _source: [ 'ticketId', 'storeName', 'storeId', 'dateString', 'revicedFootfall', 'footfallCount', 'revicedPerc', 'type' ],
     };
+    // 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' } );
@@ -2315,73 +2589,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' } );
@@ -2392,11 +2625,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: [
@@ -2415,16 +2650,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 = {};
@@ -2432,7 +2665,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 ) {
@@ -2440,71 +2672,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 = [];
@@ -2514,11 +2751,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 );
@@ -2526,8 +2761,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;
@@ -2536,3 +2813,249 @@ 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,
+      createdByRole: req?.user?.role || '',
+      createdByEmail: req?.user?.email || '',
+      createdByUserName: req?.user?.userName || '',
+    };
+
+    const updatePayload = {
+      doc: {
+        status: 'In-Progress',
+        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 );
+  }
+}