tango-app-api-infra 3.8.1-beta.2 → 3.8.1-beta.21

package/src/controllers/footfallDirectory.controllers.js

@@ -1,7 +1,9 @@
-import { download, logger } from 'tango-app-api-middleware';
-import { bulkUpdate, getOpenSearchCount, getOpenSearchData, insertWithId, updateOpenSearchData } from 'tango-app-api-middleware/src/utils/openSearch.js';
+import { chunkArray, download, logger, sendMessageToFIFOQueue, sendMessageToQueue } from 'tango-app-api-middleware';
+import { bulkUpdate, getOpenSearchById, getOpenSearchCount, getOpenSearchData, insertWithId, updateOpenSearchData } from 'tango-app-api-middleware/src/utils/openSearch.js';
 import { findOneStore } from '../services/store.service.js';
 import dayjs from 'dayjs';
+import { countDocumnetsCamera } from '../services/camera.service.js';
+import { findOneRevopDownload, upsertRevopDownload } from '../services/revopDownload.service.js';
 
 export async function createTicket( req, res ) {
   try {
@@ -10,11 +12,12 @@ export async function createTicket( req, res ) {
     const getStoreName = await findOneStore( { storeId: inputData.storeId }, { storeName: 1, _id: 0 } );
     inputData.ticketId = 'TE_FDT_' + new Date().valueOf();
     inputData.clientId = inputData?.storeId?.split( '-' )[0];
-    inputData.storeName =getStoreName?.storeName;
+    inputData.storeName = getStoreName?.storeName;
     inputData.createdAt = new Date();
     inputData.updatedAt = new Date();
-    inputData.userName = req.user.userName;
-    inputData.role = req.user.role;
+    inputData.userName = req?.user?.userName;
+    inputData.email = req?.user?.email;
+    inputData.role = req?.user?.role;
     inputData.status = 'open';
     if ( inputData.houseKeepingCount > 0 ) {
       inputData.houseKeepingStatus = 'pending';
@@ -67,12 +70,19 @@ async function bulkUpdateStatusToPending( indexName, inputData ) {
 
   // 3. Duplicate Images > data[]
   if ( inputData.duplicateCount > 0 ) {
+    let updatedDuplicateImages = [];
     for ( const dup of inputData.duplicateImages || [] ) {
       const id = `${inputData.storeId}_${inputData.dateString}_${dup.timeRange}_${dup.tempId}`;
-      const updatedDuplicateImages = ( dup.data || [] ).map( ( item ) => ( {
-        ...item,
-        status: 'pending',
-      } ) );
+      dup?.data?.map( ( item ) => {
+        updatedDuplicateImages.push( {
+          ...item,
+          status: 'pending',
+        } );
+        bulkBody.push(
+            { update: { _index: indexName, _id: `${inputData.storeId}_${inputData.dateString}_${item.timeRange}_${item.tempId}` } },
+            { doc: { status: 'pending' } },
+        );
+      } );
       bulkBody.push(
           { update: { _index: indexName, _id: id } },
           { doc: { status: 'pending', duplicateImage: updatedDuplicateImages } },
@@ -174,120 +184,211 @@ export async function ticketSummary( req, res ) {
 
 export async function ticketList( req, res ) {
   try {
-    // let count = 0;
-    // const array =[
-    //   { A: '3c88e8eb6d499a26d37ca075c390bd2d', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/101' },
-    //   { A: 'c3dd981f485ccd25221c7da704f35d24', B: 'rtsp://admin:Bli$$%40145@192.168.29.58/streaming/channels/101' },
-    //   { A: 'ee887e5546ab0e96ca0adbf8c2453c8d', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/1001' },
-    //   { A: 'a59ddeb30d158602d6c672994af2f79a', B: 'rtsp://admin:Bli$$%40145@192.168.29.58/streaming/channels/1001' },
-    //   { A: '1f3318280025f5456262b0322b806940', B: 'rtsp://admin:Bli$$%40145@192.168.29.58/streaming/channels/201' },
-    //   { A: '925a70751a0988793057148b20158186', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/201',
-    //   }, { A: 'd6d4ab301c322212fb612a7d9661b6be', B: 'rtsp://admin:Bli$$%40145@192.168.29.58/streaming/channels/301',
-    //   }, { A: 'cb09aeedfa5ade043922634eb1c35e46', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/301',
-    //   }, { A: '58f81e33f66ef7af15424c1dc44e7de1', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/401',
-    //   }, { A: '7ac8f73f02347d29f6f2bff3c52275f5', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/401',
-    //   }, { A: '9599acd19a48eb28957ad18e40a0a5b1', B: 'rtsp://admin:Bli$$%40145@192.168.29.58/streaming/channels/401',
-    //   }, { A: '36584a3ce215a5fbd1c0e6535201020c', B: 'rtsp://admin:Bli$$%40145@192.168.29.58/streaming/channels/501',
-    //   }, { A: 'cb7e91870e0a72d4eb691e2618aa5979', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/501',
-    //   }, { A: 'cd072627e6924df745cba004616ec3c9', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/601',
-    //   }, { A: 'a5891519a50f68a9d73a774539fe8496', B: 'rtsp://admin:Bli$$%40145@192.168.29.58/streaming/channels/601',
-    //   }, { A: '2008517125b03b1b9a66348e6d017523', B: 'rtsp://admin:Bli$$%40145@192.168.29.58/streaming/channels/701',
-    //   }, { A: '79fc93551b59f9ed07eab48d190ba7f4', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/701',
-    //   }, { A: '89365abcfc8dc663b26471d81a7f68eb', B: 'rtsp://admin:Bli$$%40145@192.168.29.58/streaming/channels/801',
-    //   }, { A: 'e9fb3b989a245994bd48b97287aad096', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/801',
-    //   }, { A: '4493fb6dc07611bab03630b154ca2483', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/801',
-    //   }, { A: 'e31caf56bb86f6e12377db006ac61756', B: 'rtsp://admin:Bli$$%40145@192.168.29.86/streaming/channels/901',
-    //   }, { A: 'fe66c637bc8da296485494e371f67b99', B: 'rtsp://admin:Bli$$%40145@192.168.29.58/streaming/channels/901' },
-    // ];
-
-    // for ( const item of array ) {
-    //   const a = await updateOneCamera( { streamName: item.A, clientId: '370' }, { RTSP: item.B } );
-    //   count++;
-    //   logger.info( { aaa: a, count: count } );
-    // }
-
-    // process.exit();
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
     const limit = inputData.limit || 10;
-    const skip= inputData.offset == 0? 0:( inputData.offset - 1 ) *limit || 0;
+    const offset = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
+    const order = inputData?.sortOrder || -1;
+
     inputData.clientId = inputData.clientId.split( ',' ); // convert strig to array
-    logger.info( { inputData: inputData, limit: limit, skip: skip } );
-    const getCount= {
-      query: {
-        bool: {
-          filter: [
-            { terms: { 'clientId.keyword': Array.isArray( inputData.clientId ) ?
-              inputData.clientId :
-              inputData.clientId } },
-            {
-              range: {
-                dateString: {
-                  gte: inputData.fromDate,
-                  lte: inputData.toDate,
-                  format: 'yyyy-MM-dd',
-                },
-              },
-            },
-          ],
+
+
+    let filter = [
+      {
+        'range': {
+          'dateString': {
+            'gte': inputData.fromDate,
+            'lte': inputData.toDate,
+            'format': 'yyyy-MM-dd',
+          },
         },
       },
-    };
+      {
+        terms: {
+          'clientId.keyword': Array.isArray( inputData.clientId ) ?
+            inputData.clientId :
+           [ inputData.clientId ],
+        },
+      },
+    ];
 
-    const geteDataCount = await getOpenSearchCount( openSearch.footfallDirectory, getCount );
-    if ( !geteDataCount || geteDataCount?.body?.count == 0 ) {
-      return res.sendError( 'No data found', 204 );
+    if ( inputData?.storeId ) {
+      filter.push(
+          {
+            terms: {
+              'storeId.keyword': Array.isArray( inputData.storeId ) ?
+              inputData.storeId :
+              [ inputData.storeId ],
+            },
+          },
+      );
     }
-    const getQuery = {
-      size: limit,
-      from: skip,
-      query: {
-        bool: {
-          filter: [
-            { terms: { 'clientId.keyword': Array.isArray( inputData.clientId ) ?
-              inputData.clientId :
-              inputData.clientId } },
-            {
-              range: {
-                dateString: {
-                  gte: inputData.fromDate,
-                  lte: inputData.toDate,
-                  format: 'yyyy-MM-dd',
-                },
+
+    let search = {
+      'must': filter,
+    };
+
+    if ( inputData.searchValue && inputData.searchValue !== '' ) {
+      search = {
+        'must': filter,
+        'should': [
+          {
+            'wildcard': {
+              'storeName.keyword': {
+                'value': `*${inputData.searchValue}*`,
               },
             },
-          ],
-        },
+          },
+          {
+            'wildcard': {
+              'storeId.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'ticketId.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+          {
+            'wildcard': {
+              'status.keyword': {
+                'value': `*${inputData.searchValue}*`,
+              },
+            },
+          },
+
+        ],
+        'minimum_should_match': 1,
+      };
+    }
+
+    let searchQuery = {
+      '_source': [
+        'storeName',
+        'storeId',
+        'ticketId',
+        'createdAt',
+        'updatedAt',
+        'footfallCount',
+        'duplicateCount',
+        'employeeCount',
+        'houseKeepingCount',
+        'employeeACCount',
+        'duplicateACCount',
+        'houseKeepingACCount',
+        'status',
+        'dateString',
+      ],
+      'from': offset,
+      'size': limit,
+      'query': {
+        'bool': search,
       },
-      _source: [ 'storeName', 'storeId', 'ticketId', 'createdAt', 'footfallCount', 'duplicateCount', 'employeeCount', 'houseKeepingCount', 'status', 'dateString' ],
+      'sort': [
+        { dateString: { order: 'desc' } },
+      ],
     };
 
-    const getData = await getOpenSearchData( openSearch.footfallDirectory, getQuery );
-    const response = getData?.body?.hits?.hits;
-    logger.info( { response: response, body: getData?.body, getData: getData, geteDataCount: geteDataCount } );
-
-
-    if ( inputData.isExport=== true ) {
-      const temp = [];
-      for ( const item of response ) {
-        temp.push( {
-          'Store Name': item.storeName,
-          'Store ID': item.storeId,
-          'Ticket ID': item.ticketId,
-          'Ticket raised on': dayjs( item.createdAt ).format( 'dd MMM, yyyy' ),
-          'Total Footfalls': item.footfallCount,
-          'Duplicates': item.duplicateCount,
-          'Employee/Staff': item.employeeCount,
-          'HouseKeeping': item.houseKeepingCount,
-          'Revised Footfalls': item.footfallCount-( item.duplicateCount+item.employeeCount+item.houseKeepingCount ),
-          'Status': item.status,
-        } );
+    if ( inputData.sortBy && inputData.sortBy !== '' ) {
+      let sortByValue = '';
+
+      if ( [ 'storeName', 'storeId', 'ticketId', 'status' ].includes( inputData?.sortBy ) ) {
+        sortByValue = `${inputData.sortBy}.keyword`;
+      } else {
+        sortByValue = inputData.sortBy;
       }
-      await download( temp, res );
-      return;
+
+
+      searchQuery = {
+        '_source': [
+          'storeName',
+          'storeId',
+          'ticketId',
+          'createdAt',
+          'updatedAt',
+          'footfallCount',
+          'duplicateCount',
+          'employeeCount',
+          'houseKeepingCount',
+          'status',
+          'employeeACCount',
+          'duplicateACCount',
+          'houseKeepingACCount',
+          'dateString',
+        ],
+        'from': offset,
+        'size': limit,
+        'query': {
+          'bool': search,
+        },
+        'sort': [
+          { [sortByValue]: { order: order === -1 ? 'desc' : 'asc' } },
+        ],
+      };
     }
 
-    return res.sendSuccess( { result: response, count: geteDataCount?.body?.count } );
+    if ( inputData.isExport == true ) {
+      searchQuery = {
+        '_source': [
+          'storeName',
+          'storeId',
+          'ticketId',
+          'createdAt',
+          'updatedAt',
+          'footfallCount',
+          'duplicateCount',
+          'employeeACCount',
+          'duplicateACCount',
+          'employeeCount',
+          'houseKeepingACCount',
+          'houseKeepingCount',
+          'status',
+          'dateString',
+        ],
+        'from': 0,
+        'size': 10000,
+        'query': {
+          'bool': search,
+        },
+        'sort': [
+          { 'storeName.keyword': { order: 'desc' } },
+        ],
+      };
+    }
+    const getData = await getOpenSearchData( openSearch.footfallDirectory, searchQuery );
+    const count = getData?.body?.hits?.total?.value;
+    if ( !count || count == 0 ) {
+      return res.sendError( 'No data found', 204 );
+    }
+    const searchValue = getData?.body?.hits?.hits;
+    if ( !searchValue || searchValue?.length == 0 ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    if ( inputData.isExport == true ) {
+      const exportData = [];
+      for ( const item of searchValue ) {
+        exportData.push( {
+          'Store Name': item._source.storeName || '--',
+          'Store ID': item._source.storeId,
+          'Ticket ID': item._source.ticketId,
+          'Ticket raised on': dayjs( item._source.createdAt ).format( 'DD MMM, YYYY' ),
+          'Total Footfalls': item._source.footfallCount,
+          'Duplicates': item._source.duplicateCount,
+          'Employee/Staff': item._source.employeeCount,
+          'HouseKeeping': item._source.houseKeepingCount,
+          'Revised Footfalls': item._source.footfallCount - ( item._source.duplicateCount + item._source.employeeCount + item._source.houseKeepingCount ),
+          'Status': item._source.status,
+          'Ticket%': item?._source?.status === 'closed'?Math.round( ( ( item._source.duplicateACCount + item._source.employeeACCount + item._source.houseKeepingACCount )/ item._source.footfallCount )*100 ).toFixed( 0 ) : 'NA',
+        } );
+      }
+      return await download( exportData, res );
+    }
+    return res.sendSuccess( { result: searchValue, count: count } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
     logger.error( { error: error, messgage: req.query } );
@@ -299,16 +400,13 @@ export async function getTickets( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
-    const limit = inputData.limit || 10;
-    const skip= inputData.offset == 0? 0:( inputData.offset - 1 ) *limit || 0;
+    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', 'footfallCount', 'employeeCount', 'houseKeepingCount', 'duplicateCount', 'comments', 'employee', 'houseKeeping', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'approverRole', 'approverUserName', 'approverEmail' ];
+    let filter = [
 
-    let filter =[
-      { terms: { 'storeId.keyword': Array.isArray( inputData.storeId ) ?
-              inputData.storeId :
-              inputData.storeId },
-      },
       {
         range: {
           dateString: {
@@ -319,6 +417,26 @@ export async function getTickets( req, res ) {
         },
       },
     ];
+    if ( inputData?.storeId ) {
+      filter.push(
+          {
+            terms: {
+              'storeId.keyword': Array.isArray( inputData.storeId ) ?
+            inputData.storeId :
+            inputData.storeId,
+            },
+          },
+      );
+    }
+    if ( inputData?.dateString ) {
+      filter.push(
+          {
+            term: {
+              'dateString': inputData.dateString,
+            },
+          },
+      );
+    }
     if ( inputData.status ) {
       filter.push(
           {
@@ -336,6 +454,32 @@ export async function getTickets( req, res ) {
           field: inputData.revopsType,
         },
       } );
+      inputData.revopsType === 'employee' ?
+        filter.push( {
+          range: {
+            employeeCount: {
+              gt: 0,
+            },
+          },
+        } ) :
+        inputData.revopsType === 'housekeeping' ?
+          filter.push( {
+            range: {
+              housekeepingCount: {
+                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', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCoun', 'duplicateACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
+        inputData.revopsType == 'houseKeeping' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'houseKeepingCount', 'comments', 'houseKeeping', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'approverRole', 'approverUserName', 'approverEmail' ] :
+          inputData.revopsType == 'duplicateImages' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'duplicateCount', 'comments', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus', 'houseKeepingACCount', 'houseKeepingCount', 'employeeCount', 'employeeACCount', 'duplicateCount', 'duplicateACCount', 'approverRole', 'approverUserName', 'approverEmail' ] : [];
     }
 
     if ( inputData.action ) {
@@ -343,27 +487,52 @@ export async function getTickets( req, res ) {
         bool: {
           should: [
             {
-              term: {
-                'houseKeepingStatus.keyword': inputData.action,
+              constant_score: {
+                filter: { term: { 'houseKeepingStatus.keyword': inputData.action } },
+                boost: 1,
+                _name: 'matched_housekeeping',
               },
             },
             {
-              term: {
-                'employeeStatus.keyword': inputData.action,
+              constant_score: {
+                filter: { term: { 'employeeStatus.keyword': inputData.action } },
+                boost: 1,
+                _name: 'matched_employee',
               },
             },
             {
-              term: {
-                'duplicateStatus.keyword': inputData.action,
+              constant_score: {
+                filter: { term: { 'duplicateStatus.keyword': inputData.action } },
+                boost: 1,
+                _name: 'matched_duplicate',
               },
             },
           ],
-          minimum_should_match: 1, // Ensures at least one should condition must match
+          minimum_should_match: 1,
         },
       } );
     }
 
-    const getCount= {
+
+    let getRevCount = {};
+    if ( inputData.revopsType ) {
+      getRevCount = {
+        size: 0,
+        query: {
+          bool: {
+            filter: filter,
+          },
+        },
+        aggs: {
+          totalCount: {
+            sum: {
+              field: inputData.revopsType == 'employee' ? 'employeeCount' : inputData.revopsType == 'houseKeeping' ? 'houseKeepingCount' : 'duplicateCount',
+            },
+          },
+        },
+      };
+    }
+    const getCount = {
       query: {
         bool: {
           filter: filter,
@@ -371,8 +540,12 @@ export async function getTickets( req, res ) {
       },
     };
 
+
     const geteDataCount = await getOpenSearchCount( openSearch.footfallDirectory, getCount );
-    if ( !geteDataCount || geteDataCount?.body?.count == 0 ) {
+    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 ) {
       return res.sendError( 'No data found', 204 );
     }
 
@@ -384,34 +557,88 @@ export async function getTickets( req, res ) {
           filter: filter,
         },
       },
+      _source: source,
     };
 
     const getData = await getOpenSearchData( openSearch.footfallDirectory, getQuery );
+
     const response = getData?.body?.hits?.hits;
-    logger.info( { response: response, body: getData?.body, getData: getData, geteDataCount: geteDataCount } );
-
-
-    if ( inputData.isExport=== true ) {
-      const temp = [];
-      for ( const item of response ) {
-        temp.push( {
-          'Store Name': item.storeName,
-          'Store ID': item.storeId,
-          'Ticket ID': item.ticketId,
-          'Ticket raised on': dayjs( item.createdAt ).format( 'dd MMM, yyyy' ),
-          'Total Footfalls': item.footfallCount,
-          'Duplicates': item.duplicateCount,
-          'Employee/Staff': item.employeeCount,
-          'HouseKeeping': item.houseKeepingCount,
-          'Revised Footfalls': item.footfallCount-( item.duplicateCount+item.employeeCount+item.houseKeepingCount ),
-          'Status': item.status,
-        } );
-      }
-      await download( temp, res );
-      return;
+    if ( !response || response.length == 0 ) {
+      return res.sendError( 'No data', 204 );
     }
+    let temp = [];
+    if ( inputData?.action ) {
+      response.map( ( hit ) => {
+        const defaultData = {
+          storeId: hit._source.storeId,
+          dateString: hit?._source?.dateString,
+          ticketName: hit?._source?.ticketName,
+          status: hit?._source?.status,
+          employeeStatus: hit?._source?.employeeStatus,
+          houseKeepingStatus: hit?._source?.houseKeepingStatus,
+          duplicateStatus: hit?._source?.duplicateStatus,
+          storeName: hit?._source?.storeName,
+          ticketId: hit?._source?.ticketId,
+          footfallCount: hit?._source?.footfallCount,
+          comments: hit?._source?.comments,
+          userName: hit?._source?.userName,
+          role: hit?._source?.role,
+          createdAt: hit?._source?.createdAt,
+          updatedAt: hit?._source?.updatedAt,
+          tempId: hit?._source?.tempId,
+          houseKeepingCount: hit?._source?.houseKeepingCount,
+          employeeCount: hit?._source?.employeeCount,
+          duplicateCount: hit?._source?.duplicateCount,
+          houseKeepingACCount: hit?._source?.houseKeepingACCount,
+          employeeACCount: hit?._source?.employeeACCount,
+          duplicateACCount: hit?._source?.duplicateACCount,
+          approverUserName: hit?._source?.approverUserName,
+          approverEmail: hit?._source?.approverEmail,
+          approverRole: hit?._source?.approverRole,
+
+
+        };
+        let result;
 
-    return res.sendSuccess( { result: response, count: geteDataCount?.body?.count } );
+        const matched = hit.matched_queries;
+        // Add only matched data array
+        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' ) ) {
+          result = defaultData;
+          result.houseKeeping = hit?._source?.houseKeeping;
+          // result.type = 'houseKeeping';
+          result.matched = matched;
+        }
+        if ( matched.includes( 'matched_duplicate' )&& ( !inputData.revopsType || inputData.revopsType == 'duplicateImages' ) ) {
+          result = defaultData;
+          result.duplicateImages = hit?._source?.duplicateImages;
+          // result.type = 'duplicateImages';
+          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;
+    if ( finalResponse?.length == 0 || !finalResponse ) {
+      return res.sendError( 'No Data found', 204 );
+    }
+    return res.sendSuccess( { result: finalResponse, count: count, revopCount: revCount } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
     logger.error( { error: error, messgage: req.query } );
@@ -421,45 +648,274 @@ export async function getTickets( req, res ) {
 
 export async function updateStatus( req, res ) {
   try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.body;
-    const id = req.query._id;
-    const splitId = id.split( '_' );
-    const storeId = splitId[0];
-    const dateString = splitId[1];
-    if ( inputData.duplicateStatus === 'approved' && inputData.employeeStatus === 'approved' && inputData.houseKeepingStatus === 'approved' ) {
-      inputData.status = 'closed';
-    }
-    await updateOpenSearchData( openSearch.footfallDirectory, id, { _doc: inputData } );
-    let bulkBody = [];
-    for ( let duplicate of inputData.duplicateImages ) {
+    let temp = [];
+    let result;
+    for ( let data of inputData?.data ) {
+      result = await updateTicketStatus( data, openSearch, temp, req.user );
+    }
+
+    if ( temp.length == inputData?.data?.length ) {
+      return res.sendSuccess( 'Ticket has been updated successfully' );
+    }
+    if ( result == false ) {
+      logger.info( { 'Note': `Queue Doesn't send` } );
+    }
+  } catch ( error ) {
+    const err = error.messgae || 'Internal Server Error';
+    logger.error( { error: error, data: req.body, function: 'infra-footfallDirectory-updateStatus' } );
+    return res.sendError( err, 500 );
+  }
+}
+export async function updateTicketStatus( data, openSearch, temp, user ) {
+  const id = data._id;
+  const splitId = id.split( '_' );
+  const storeId = splitId[0];
+  const dateString = splitId[1];
+  const {
+    duplicateStatus,
+    employeeStatus,
+    houseKeepingStatus,
+  } = data;
+  const statusList = [ duplicateStatus, employeeStatus, houseKeepingStatus ];
+  // Filter out undefined/null statuses
+  const existingStatuses = statusList.filter( ( status ) => status != null );
+
+  // Check if **none** of the existing statuses are 'pending'
+  const allNotPending = existingStatuses.every( ( status ) => status !== 'pending' );
+
+  if ( allNotPending && existingStatuses.length > 0 ) {
+    data.status = 'closed';
+    data.approverUserName = user?.userName || '';
+    data.approverEmail = user?.email || '';
+    data.approverRole = user?.role || '';
+  }
+  let tempId = [];
+  const { _id, ...updateData } = data;
+  let getExistingOne = await getOpenSearchById( openSearch.footfallDirectory, _id );
+  const source = getExistingOne?.body?._source;
+  let bulkBody = [];
+  if ( data?.duplicateImages?.length > 0 ) {
+    updateData.duplicateImages = await mergeDuplicateImagesWithUncheck( getExistingOne?.body?._source?.duplicateImages, data?.duplicateImages, data?.duplicateStatus );
+    logger.info( { updateData: updateData, existeg: getExistingOne?.body?._source?.duplicateImages, sttaus: data?.duplicateStatus } );
+    await updateOpenSearchData( openSearch.footfallDirectory, _id, { doc: updateData } );
+    for ( let duplicate of updateData?.duplicateImages ) {
       bulkBody.push(
           { update: { _index: openSearch.revop, _id: `${storeId}_${dateString}_${duplicate.timeRange}_${duplicate.tempId}` } },
-          { doc: { duplicateImage: duplicate.duplicateImage } },
+          { doc: { duplicateImage: duplicate.duplicateImages } },
       );
-      duplicate.map( ( item ) => {
+      duplicate?.data?.map( ( item ) => {
+        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 } },
+            { doc: { isChecked: item.isChecked, status: item?.isChecked == true? 'approved':'rejected' } },
         );
       } );
     }
-    for ( let employee of inputData.employee ) {
-      bulkBody.push(
-          { update: { _index: openSearch.revop, _id: `${storeId}_${dateString}_${employee.timeRange}_${employee.tempId}` } },
-          { doc: { isChecked: employee.isChecked } },
-      );
+    await updateOpenSearchData( openSearch.footfallDirectory, _id, { doc: { duplicateACCount: tempId?.length || 0 } } );
+  }
+  if ( data?.employee?.length > 0 ) {
+    const updatedEmployee = updateEmployeeCheckFlags(
+        source.employee,
+        updateData.employee,
+        data.employeeStatus,
+    );
+    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' } },
+     );
     }
-    for ( let houseKeeping of inputData.houseKeeping ) {
+    await updateOpenSearchData( openSearch.footfallDirectory, _id, { doc: { employeeACCount: tempId?.length || 0 } } );
+  }
+  if ( data?.houseKeeping?.length > 0 ) {
+    const updatedHouseKeeping = updateEmployeeCheckFlags(
+        source?.houseKeeping,
+        updateData?.houseKeeping,
+        data.houseKeepingStatus,
+    );
+    updateData.houseKeeping = updatedHouseKeeping;
+
+    await updateOpenSearchData( openSearch.footfallDirectory, _id, { doc: updateData } );
+
+
+    for ( let houseKeeping of updateData?.houseKeeping ) {
+      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 } },
+          { doc: { isChecked: houseKeeping.isChecked, status: houseKeeping?.isChecked == true? 'approved':'rejected' } },
       );
     }
-    return res.sendSuccess( 'ticket closed successfully' );
-  } catch ( error ) {
-    const err = error.messgae || 'Internal Server Error';
-    logger.error( { error: error, data: req.body, function: 'infra-footfallDirectory-updateStatus' } );
-    return res.sendError( err, 500 );
+    await updateOpenSearchData( openSearch.footfallDirectory, _id, { doc: { houseKeepingACCount: tempId?.length || 0 } } );
+  }
+  temp.push( storeId );
+  if ( bulkBody.length > 0 ) {
+    const res = await bulkUpdate( bulkBody );
+    if ( res?.errors ) {
+      logger.error( 'Bulk update errors:', res.items );
+      return { success: false, errors: res.items };
+    } else {
+      logger.error( 'Bulk status update successful.' );
+      // return { success: true };
+    }
+  }
+  if ( data.status == 'closed' ) {
+    const query = {
+      storeId: storeId,
+      isVideoStream: true,
+    };
+    const getStoreType = await countDocumnetsCamera( query );
+    const tempIdList = await extractCheckedTempIds( getExistingOne?.body );
+    const isSendMessge = await sendSqsMessage( data, tempIdList, getStoreType, storeId );
+    if ( isSendMessge ==true ) {
+      return true; // res.sendSuccess( 'Ticket has been updated successfully' );
+    } else {
+      return false; // res.sendError( 'No SQS message sent', 500 );
+    }
+  }
+}
+
+async function extractCheckedTempIds( document ) {
+  const source = document?._source || {};
+  const result = [];
+
+  //  Employee
+  if ( source.employeeACCount > 0 && Array.isArray( source.employee ) ) {
+    for ( const emp of source.employee ) {
+      if ( emp.isChecked === true ) {
+        result.push( { tempId: emp.tempId, timeRange: emp.timeRange } );
+      }
+    }
+  }
+
+  //  Housekeeping
+  if ( source.houseKeepingACCount > 0 && Array.isArray( source.houseKeeping ) ) {
+    for ( const hk of source.houseKeeping ) {
+      if ( hk.isChecked === true ) {
+        result.push( { tempId: hk.tempId, timeRange: hk.timeRange } );
+      }
+    }
+  }
+
+  //  Duplicate Images
+  if ( source.duplicateACCount > 0 && Array.isArray( source.duplicateImages ) ) {
+    for ( const image of source.duplicateImages ) {
+      if ( Array.isArray( image.data ) ) {
+        for ( const dup of image.data ) {
+          if ( dup.isChecked === true ) {
+            result.push( { tempId: dup.tempId, timeRange: dup.timeRange } );
+          }
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+
+function updateEmployeeCheckFlags( existingEmployees, inputEmployees, status ) {
+  // Step 1: Create a Set of tempIds from input (which are all isChecked: true)
+  const checkedTempIds = new Set( inputEmployees.map( ( emp ) => emp.tempId ) );
+
+  // 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 ),
+  } ) );
+
+  return updatedEmployees;
+}
+
+
+function mergeDuplicateImagesWithUncheck( existingData, inputData, status ) {
+  const inputImageMap = new Map();
+
+  // Step 1: Build map of parentTempId -> Set of selected childTempIds
+  for ( const parent of inputData ) {
+    const selectedChildIds = new Set(
+        ( parent.data || [] )
+            .filter( ( child ) => child.selected )
+            .map( ( child ) => child.tempId ),
+    );
+    inputImageMap.set( parent.tempId, selectedChildIds );
+  }
+
+  // Step 2: Merge isChecked correctly per parent-child match
+  return existingData.map( ( existingParent ) => {
+    const parentTempId = existingParent.tempId;
+
+    // Get selected children for this specific parent
+    const selectedChildIds = inputImageMap.get( parentTempId ) || new Set();
+
+    const updatedData = ( existingParent.data || [] ).map( ( child ) => {
+      return {
+        ...child,
+        isChecked:
+          status === 'approved' ? selectedChildIds.has( child.tempId ) : false,
+      };
+    } );
+
+    // Also update the parent isChecked if all children are false
+    const anyChildChecked = updatedData.some( ( child ) => child.isChecked );
+
+    return {
+      ...existingParent,
+      isChecked: anyChildChecked,
+      data: updatedData,
+    };
+  } );
+}
+
+
+export async function sendSqsMessage( inputData, tempId, getStoreType, storeId ) {
+  const sqs = JSON.parse( process.env.SQS );
+  const sqsName = getStoreType > 0? sqs.revopTrackTicket: sqs.revopTicket;
+  const sqsProduceQueue = getStoreType > 0 ? {
+    QueueUrl: `${sqs.url}${sqsName}`,
+    MessageBody: JSON.stringify( {
+      store_id: storeId,
+      store_date: inputData.dateString.split( '-' ).reverse().join( '-' ),
+      bucket_name: '',
+      zone_id: 'traffic_zone',
+      process_type: 'reduction',
+      revop_type: 'footfall',
+      temp_id: tempId,
+      time: Date.now(),
+    } ),
+    MessageGroupId: 'revops',
+    MessageDeduplicationId: Date.now().toString(),
+  } : {
+    QueueUrl: `${sqs.url}${sqsName}`,
+    MessageBody: JSON.stringify( {
+      store_id: storeId,
+      store_date: inputData.dateString.split( '-' ).reverse().join( '-' ),
+      bucket_name: '',
+      zone_id: 'traffic_zone',
+      process_type: 'reduction',
+      revop_type: 'footfall',
+      temp_id: tempId,
+
+    } ),
+  };
+  const sqsQueue = getStoreType > 0? await sendMessageToFIFOQueue( sqsProduceQueue ):
+   await sendMessageToQueue(
+       sqsProduceQueue.QueueUrl,
+       sqsProduceQueue.MessageBody,
+
+   );
+  if ( sqsQueue.statusCode ) {
+    logger.error( {
+      error: `${sqsQueue}`,
+      type: 'UPLOAD_ERROR',
+    } );
+    return false;
+  } else {
+    return true;
   }
 }
 
@@ -467,89 +923,442 @@ export async function getTaggedStores( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
-    const limit = inputData.limit || 10;
-    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 } );
-    const getCount= {
+    inputData.clientId = inputData?.clientId?.split( ',' );
+    logger.info( { inputData: inputData.clientId } );
+    let filter = [
+      {
+        terms: { 'clientId.keyword': inputData.clientId },
+      },
+      {
+        range: {
+          dateString: {
+            gte: inputData.fromDate,
+            lte: inputData.toDate,
+            format: 'yyyy-MM-dd',
+          },
+        },
+      },
+
+      {
+        exists: {
+          field: 'storeId',
+        },
+      },
+      {
+        exists: {
+          field: 'storeName',
+        },
+      },
+    ];
+    // 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 || [] },
+        },
+    );
+
+    if ( inputData.searchValue && inputData.searchValue !== '' ) {
+      filter.push( {
+        regexp: {
+          'storeName': {
+            value: `.*${inputData.searchValue.toLowerCase()}.*`,
+            flags: 'ALL',
+          },
+        },
+      } );
+    }
+    const getCount = {
+      size: 0,
       query: {
         bool: {
-          filter: [
-            { terms: { 'storeId.keyword': Array.isArray( inputData.storeId ) ?
-              inputData.storeId :
-              inputData.storeId } },
-            {
-              range: {
-                dateString: {
-                  gte: inputData.fromDate,
-                  lte: inputData.toDate,
-                  format: 'yyyy-MM-dd',
+          filter: filter,
+        },
+      },
+      aggs: {
+        unique_stores: {
+          composite: {
+            size: 1000,
+            sources: [
+              {
+                storeId: {
+                  terms: { field: 'storeId.keyword' },
+                },
+              },
+              {
+                storeName: {
+                  terms: { field: 'storeName.keyword' },
                 },
               },
+            ],
+          },
+          aggs: {
+            totalCount: {
+              sum: {
+                script: {
+                  source: `
+                  return (doc.containsKey('duplicateCount') ? doc['duplicateCount'].value : 0)
+                       + (doc.containsKey('houseKeepingCount') ? doc['houseKeepingCount'].value : 0)
+                       + (doc.containsKey('employeeCount') ? doc['employeeCount'].value : 0);
+              `,
+                  lang: 'painless',
+                },
+              },
+            },
+          },
+        },
+      },
+    };
+
+    let temp = [];
+
+    const geteDataCount = await getOpenSearchData( openSearch.footfallDirectory, getCount );
+    if ( !geteDataCount && geteDataCount?.body?.aggregations?.unique_stores?.buckets?.length > 0 ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    const response = geteDataCount?.body?.aggregations?.unique_stores?.buckets;
+    const sorted = sortByTotalCount( response, inputData.sortOrder );
+    sorted?.map( ( item ) => temp.push( { storeId: item.key.storeId, storeName: item.key.storeName, totalCount: item?.totalCount?.value } ) );
+
+    if ( response?.length > 0 ) {
+      return res.sendSuccess( { result: temp, count: response?.length } );
+    } else {
+      return res.sendError( 'NO Data', 204 );
+    }
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, messgage: req.query } );
+    return res.sendSuccess( err, 500 );
+  }
+}
+
+function sortByTotalCount( response, sortOrder = -1 ) {
+  return response.sort( ( a, b ) => {
+    const aVal = a.totalCount.value;
+    const bVal = b.totalCount.value;
+
+    return sortOrder === 1 ? aVal - bVal : bVal - aVal;
+  } );
+}
+
+export async function downloadTickets( 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', 'footfallCount', 'employeeCount', 'houseKeepingCount', 'duplicateCount', 'comments', 'employee', 'houseKeeping', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus' ];
+    let filter = [
+
+      {
+        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?.dateString ) {
+      filter.push(
+          {
+            term: {
+              'dateString': inputData.dateString,
+            },
+          },
+      );
+    }
+    if ( inputData.status ) {
+      filter.push(
+          {
+            term: {
+              'status.keyword': inputData.status,
+            },
+          },
+      );
+    }
+    if (
+      inputData.revopsType
+    ) {
+      filter.push( {
+        exists: {
+          field: inputData.revopsType,
+        },
+      } );
+      inputData.revopsType === 'employee' ?
+        filter.push( {
+          range: {
+            employeeCount: {
+              gt: 0,
+            },
+          },
+        } ) :
+        inputData.revopsType === 'housekeeping' ?
+          filter.push( {
+            range: {
+              housekeepingCount: {
+                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' ] :
+        inputData.revopsType == 'houseKeeping' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'houseKeepingCount', 'comments', 'houseKeeping', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus' ] :
+          inputData.revopsType == 'duplicateImages' ? [ 'storeId', 'dateString', 'ticketName', 'footfallCount', 'duplicateCount', 'comments', 'duplicateImages', 'ticketId', 'clientId', 'storeName', 'createdAt', 'updatedAt', 'userName', 'role', 'status', 'employeeStatus', 'houseKeepingStatus', 'duplicateStatus' ] : [];
+    }
+
+    if ( inputData.action ) {
+      filter.push( {
+        bool: {
+          should: [
+            {
+              constant_score: {
+                filter: { term: { 'houseKeepingStatus.keyword': inputData.action } },
+                boost: 1,
+                _name: 'matched_housekeeping',
+              },
+            },
+            {
+              constant_score: {
+                filter: { term: { 'employeeStatus.keyword': inputData.action } },
+                boost: 1,
+                _name: 'matched_employee',
+              },
+            },
+            {
+              constant_score: {
+                filter: { term: { 'duplicateStatus.keyword': inputData.action } },
+                boost: 1,
+                _name: 'matched_duplicate',
+              },
             },
           ],
+          minimum_should_match: 1,
+        },
+      } );
+    }
+
+
+    const getCount = {
+      query: {
+        bool: {
+          filter: filter,
         },
       },
     };
 
+
     const geteDataCount = await getOpenSearchCount( openSearch.footfallDirectory, getCount );
-    if ( !geteDataCount || geteDataCount?.body?.count == 0 ) {
+    const count = geteDataCount?.body?.count;
+    if ( !geteDataCount || count == 0 ) {
       return res.sendError( 'No data found', 204 );
     }
+
     const getQuery = {
       size: limit,
       from: skip,
       query: {
         bool: {
-          filter: [
-            { terms: { 'storeId.keyword': Array.isArray( inputData.storeId ) ?
-              inputData.storeId :
-              inputData.storeId } },
-            {
-              range: {
-                dateString: {
-                  gte: inputData.fromDate,
-                  lte: inputData.toDate,
-                  format: 'yyyy-MM-dd',
-                },
-              },
-            },
-          ],
+          filter: filter,
         },
       },
-      // _source: [ 'storeName', 'storeId', 'ticketId', 'createdAt', 'footfallCount', 'duplicateCount', 'employeeCount', 'houseKeepingCount', 'status', 'dateString' ],
+      _source: source,
     };
 
     const getData = await getOpenSearchData( openSearch.footfallDirectory, getQuery );
+
     const response = getData?.body?.hits?.hits;
-    logger.info( { response: response, body: getData?.body, getData: getData, geteDataCount: geteDataCount } );
-
-
-    if ( inputData.isExport=== true ) {
-      const temp = [];
-      for ( const item of response ) {
-        temp.push( {
-          'Store Name': item.storeName,
-          'Store ID': item.storeId,
-          'Ticket ID': item.ticketId,
-          'Ticket raised on': dayjs( item.createdAt ).format( 'dd MMM, yyyy' ),
-          'Total Footfalls': item.footfallCount,
-          'Duplicates': item.duplicateCount,
-          'Employee/Staff': item.employeeCount,
-          'HouseKeeping': item.houseKeepingCount,
-          'Revised Footfalls': item.footfallCount-( item.duplicateCount+item.employeeCount+item.houseKeepingCount ),
-          'Status': item.status,
-        } );
-      }
-      await download( temp, res );
-      return;
+    if ( !response || response.length == 0 ) {
+      return res.sendError( 'No data', 204 );
+    }
+    let temp = [];
+    if ( inputData?.action ) {
+      response.map( ( hit ) => {
+        const defaultData ={
+          storeId: hit._source.storeId,
+          dateString: hit?._source?.dateString,
+          ticketName: hit?._source?.ticketName,
+          status: hit?._source?.status,
+          employeeStatus: hit?._source?.employeeStatus,
+          houseKeepingStatus: hit?._source?.houseKeepingStatus,
+          duplicateStatus: hit?._source?.duplicateStatus,
+          storeName: hit?._source?.storeName,
+          ticketId: hit?._source?.ticketId,
+          footfallCount: hit?._source?.footfallCount,
+          comments: hit?._source?.comments,
+          userName: hit?._source?.userName,
+          role: hit?._source?.role,
+          createdAt: hit?._source?.createdAt,
+          updatedAt: hit?._source?.updatedAt,
+          tempId: hit?._source?.tempId,
+        };
+        let result;
+
+        const matched = hit.matched_queries;
+        // Add only matched data array
+        if ( matched.includes( 'matched_employee' ) && ( !inputData.revopsType || inputData.revopsType == 'employee' ) ) {
+          logger.info( { revop: inputData.revopsType } );
+          result = defaultData;
+          result.employee = hit?._source?.employee;
+          // result.type = 'employee';
+          result.matched = matched;
+        }
+        if ( matched.includes( 'matched_housekeeping' )&& ( !inputData.revopsType || inputData.revopsType == 'houseKeeping' ) ) {
+          logger.info( { revop: inputData.revopsType } );
+          result = defaultData;
+          result.houseKeeping = hit?._source?.houseKeeping;
+          // result.type = 'houseKeeping';
+          result.matched = matched;
+        }
+        if ( matched.includes( 'matched_duplicate' )&& ( !inputData.revopsType || inputData.revopsType == 'duplicateImages' ) ) {
+          logger.info( { revop: inputData.revopsType } );
+          result = defaultData;
+          result.duplicateImages = hit?._source?.duplicateImages;
+          // result.type = 'duplicateImages';
+          result.matched = matched;
+        }
+        if ( result ) {
+          logger.info( { revop: inputData.revopsType, result: result } );
+          const nested = [
+            {
+              _id: hit._id,
+              _index: hit._index,
+              _score: 0,
+              _source: result,
+            },
+          ];
+
+          temp.push( ...nested );
+        }
+      } );
+    }
+
+    const result = inputData.action ? temp : response;
+
+    if ( !result || result?.length == 0 ) {
+      return res.sendError( 'no data', 204 );
     }
+    let allResults = [];
+    const chunks = await chunkArray( result, 500 );
 
-    return res.sendSuccess( { result: response, count: geteDataCount?.body?.count } );
+    for ( const chunk of chunks ) {
+      const results = await Promise.all( chunk.map( extractTempIds ) );
+      allResults.push( ...results.flat() );
+    }
+    if ( allResults?.length == 0 ) {
+      return res.sendError( 'no data found', 204 );
+    }
+    const query = {
+      stores: { $in: inputData.storeId },
+      fromDate: inputData?.fromDate,
+      toDate: inputData?.toDate,
+      ticketStatus: inputData?.status,
+      ticketAction: inputData?.action,
+      revopsType: inputData?.revopsType,
+      type: 'get-tickets',
+    };
+    const record={
+      stores: inputData?.storeId,
+      fromDate: inputData?.fromDate,
+      toDate: inputData?.toDate,
+      ticketStatus: inputData?.status,
+      ticketAction: inputData?.action,
+      revopsType: inputData?.revopsType,
+      type: 'get-tickets',
+      userEmail: req?.user?.email,
+    };
+    await upsertRevopDownload( query, record );
+    const getId = await findOneRevopDownload( query, { _id: 1, status: 1 } );
+    if ( !getId ) {
+      return res.sendError( 'download record is missing', 400 );
+    }
+    const sqs = JSON.parse( process.env.SQS );
+    const sqsName = getStoreType > 0? sqs.revopTrackTicket: sqs.revopTicket;
+
+    const sqsProduceQueue ={
+      QueueUrl: `${sqs.url}${sqsName}`,
+      MessageBody: JSON.stringify( {
+        _id: getId?._id,
+        data: allResults,
+
+      } ),
+    };
+    const sqsQueue = await sendMessageToQueue(
+        sqsProduceQueue.QueueUrl,
+        sqsProduceQueue.MessageBody,
+
+    );
+    if ( sqsQueue.statusCode ) {
+      logger.error( {
+        error: `${sqsQueue}`,
+        type: 'UPLOAD_ERROR',
+      } );
+      return false;
+    }
+    return res.sendSuccess( { result: { status: getId?.status, outputFilePath: getId?.outputFilePath } } );
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, messgage: req.query } );
+    logger.error( { error: error, messgage: req.query, function: 'downloadTickets-infra-footfallDirectory' } );
     return res.sendSuccess( err, 500 );
   }
 }
 
+async function extractTempIds( document ) {
+  logger.info( { document: document } );
+  const source = document?._source || {};
+  const result = [];
+
+  //  Employee
+  if ( Array.isArray( source.employee ) ) {
+    for ( const emp of source.employee ) {
+      result.push( emp.filePath );
+    }
+  }
+
+  //  Housekeeping
+  if ( Array.isArray( source.houseKeeping ) ) {
+    for ( const hk of source.houseKeeping ) {
+      result.push( hk.filePath );
+    }
+  }
+
+  //  Duplicate Images
+  if ( Array.isArray( source.duplicateImages ) ) {
+    for ( const image of source.duplicateImages ) {
+      if ( Array.isArray( image.data ) ) {
+        for ( const dup of image.data ) {
+          result.push( dup.filePath );
+        }
+      }
+    }
+  }
+  return result;
+}
+
+