tango-app-api-infra 3.9.5-vms.78 → 3.9.5-vms.79

package/src/controllers/footfallDirectory.controllers.js

@@ -392,6 +392,85 @@ export async function tangoReviewTicket( req, res ) {
     const insertResult = await updateOpenSearchData( openSearch.footfallDirectory, id, { doc: record } );
 
     if ( insertResult && ( insertResult.statusCode === 201 || insertResult.statusCode === 200 ) ) {
+      if ( record.status = 'Closed' && inputData.ticketType !== 'internal' ) {
+        const query = {
+          storeId: inputData?.storeId,
+          isVideoStream: true,
+        };
+        const getStoreType = await countDocumnetsCamera( query );
+        const revopInfoQuery = {
+          size: 10000,
+          query: {
+            bool: {
+              must: [
+                {
+                  term: {
+                    'storeId.keyword': inputData.storeId,
+                  },
+                },
+                {
+                  term: {
+                    'dateString': inputData.dateString,
+                  },
+                },
+                {
+                  term: {
+                    'isParent': false,
+                  },
+                },
+                {
+                  term: {
+                    isChecked: true,
+                  },
+                },
+              ],
+            },
+          },
+          _source: [ 'tempId' ],
+
+        };
+        const revopInfo = await getOpenSearchData( openSearch.revop, revopInfoQuery );
+        // Get all tempIds from revopInfo response
+        const tempIds = revopInfo?.body?.hits?.hits?.map( ( hit ) => hit?._source?.tempId ).filter( Boolean ) || [];
+        // Prepare management eyeZone query based on storeId and dateString
+        const managerEyeZoneQuery = {
+          size: 1,
+          query: {
+            bool: {
+              must: [
+                {
+                  term: {
+                    'storeId.keyword': inputData.storeId,
+                  },
+                },
+                {
+                  term: {
+                    'storeDate': inputData.dateString,
+                  },
+                },
+              ],
+            },
+          },
+          _source: [ 'originalToTrackerCustomerMapping' ],
+        };
+
+        // Query the managerEyeZone index for the matching document
+        const managerEyeZoneResp = await getOpenSearchData( openSearch.managerEyeZone, managerEyeZoneQuery );
+        const managerEyeZoneHit = managerEyeZoneResp?.body?.hits?.hits?.[0]?._source;
+        // Extract originalToTrackerCustomerMapping if it exists
+        const mapping =
+            managerEyeZoneHit && managerEyeZoneHit.originalToTrackerCustomerMapping ?
+              managerEyeZoneHit.originalToTrackerCustomerMapping :
+              {};
+
+        // Find tempIds that exist in both revopInfo results and manager mapping
+        const temp = [];
+        tempIds.filter( ( tid ) => mapping[tid] !== null ? temp.push( { tempId: mapping[tid] } ) :'' );
+        const isSendMessge = await sendSqsMessage( inputData, temp, getStoreType, inputData.storeId );
+        if ( isSendMessge == true ) {
+          logger.info( '....1' );
+        }
+      }
       return res.sendSuccess( 'Ticket closed successfully' );
     } else {
       return res.sendError( 'Internal Server Error', 500 );
@@ -514,22 +593,6 @@ export async function tangoReviewAccuracyClosedTicket( req, res ) {
         } );
       }
 
-
-      // If no review mapping existed, push a new one
-      // if ( record.mappingInfo.length === 0 ) {
-      //   record.mappingInfo.push( {
-      //     type: 'tangoreview',
-      //     mode: inputData.mappingInfo?.mode,
-      //     revicedFootfall: temp?.mappingInfo?.revicedFootfall,
-      //     revicedPerc: temp?.mappingInfo?.revicedPerc,
-      //     count: temp?.mappingInfo?.count,
-      //     revisedDetail: temp?.mappingInfo?.revisedDetail,
-      //     status: 'Closed',
-      //     createdByEmail: req?.user?.email,
-      //     createdByUserName: req?.user?.userName,
-      //     createdByRole: req?.user?.role,
-      //   } );
-      // }
       record.mappingInfo.push(
           {
             type: 'finalRevision',
@@ -555,6 +618,84 @@ export async function tangoReviewAccuracyClosedTicket( req, res ) {
     const insertResult = await updateOpenSearchData( openSearch.footfallDirectory, id, { doc: record } );
 
     if ( insertResult && ( insertResult.statusCode === 201 || insertResult.statusCode === 200 ) ) {
+      const query = {
+        storeId: inputData?.storeId,
+        isVideoStream: true,
+      };
+      const getStoreType = await countDocumnetsCamera( query );
+      const revopInfoQuery = {
+        size: 10000,
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'storeId.keyword': inputData.storeId,
+                },
+              },
+              {
+                term: {
+                  'dateString': inputData.dateString,
+                },
+              },
+              {
+                term: {
+                  'isParent': false,
+                },
+              },
+              {
+                term: {
+                  isChecked: true,
+                },
+              },
+            ],
+          },
+        },
+        _source: [ 'tempId' ],
+
+      };
+      const revopInfo = await getOpenSearchData( openSearch.revop, revopInfoQuery );
+      // Get all tempIds from revopInfo response
+      const tempIds = revopInfo?.body?.hits?.hits?.map( ( hit ) => hit?._source?.tempId ).filter( Boolean ) || [];
+      // Prepare management eyeZone query based on storeId and dateString
+      const managerEyeZoneQuery = {
+        size: 1,
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'storeId.keyword': inputData.storeId,
+                },
+              },
+              {
+                term: {
+                  'storeDate': inputData.dateString,
+                },
+              },
+            ],
+          },
+        },
+        _source: [ 'originalToTrackerCustomerMapping' ],
+      };
+
+      // Query the managerEyeZone index for the matching document
+      const managerEyeZoneResp = await getOpenSearchData( openSearch.managerEyeZone, managerEyeZoneQuery );
+      const managerEyeZoneHit = managerEyeZoneResp?.body?.hits?.hits?.[0]?._source;
+      // Extract originalToTrackerCustomerMapping if it exists
+      const mapping =
+            managerEyeZoneHit && managerEyeZoneHit.originalToTrackerCustomerMapping ?
+              managerEyeZoneHit.originalToTrackerCustomerMapping :
+              {};
+
+      // Find tempIds that exist in both revopInfo results and manager mapping
+      const temp = [];
+      tempIds.filter( ( tid ) => mapping[tid] !== null ? temp.push( { tempId: mapping[tid] } ) :'' );
+      const isSendMessge = await sendSqsMessage( inputData, temp, getStoreType, inputData.storeId );
+      if ( isSendMessge == true ) {
+        logger.info( '....1' );
+      }
+
       return res.sendSuccess( 'Ticket closed successfully' );
     } else {
       return res.sendError( 'Internal Server Error', 500 );
@@ -1101,69 +1242,503 @@ export async function ticketSummary( req, res ) {
           let aboveQinternal = buildAggInternalQuery( baseInternalQuery, [
             {
               script: {
-                script: {
-                  lang: 'painless',
-                  source: `
-                    doc['revicedPerc.keyword'].size()!=0 &&
-                    Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) >= params.num
-                  `,
-                  params: { num: 85 },
-                },
+                script: {
+                  lang: 'painless',
+                  source: `
+                    doc['revicedPerc.keyword'].size()!=0 &&
+                    Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) >= params.num
+                  `,
+                  params: { num: 85 },
+                },
+              },
+            },
+
+
+          ] );
+          const aboveRespInternal = await getOpenSearchData( openSearch.footfallDirectory, aboveQinternal );
+          internalTicketAccuracyAbove = aboveRespInternal?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+
+          // ticketAccuracyBelow: avg of revicedPerc < 85%
+          let internalTicketAccuracyBelow = 0;
+
+          let belowQIneranl = buildAggInternalQuery( baseInternalQuery, [
+            {
+              script: {
+                script: {
+                  lang: 'painless',
+                  source: `
+                    doc['revicedPerc.keyword'].size()!=0 &&
+                    Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) < params.num
+                  `,
+                  params: { num: 85 },
+                },
+              },
+            },
+
+          ] );
+          const belowRespInternal = await getOpenSearchData( openSearch.footfallDirectory, belowQIneranl );
+          internalTicketAccuracyBelow = belowRespInternal?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+
+          // Final result object
+          result = {
+            totalTickets: totalInternalTickets,
+            averageAccuracyOverAll: internalAverageAccuracyOverAll+'%',
+            openTickets: openInternalTickets,
+            openInfraIssues: openInternalInfraIssues,
+            inprogress: inprogressIntrenal,
+            closedTickets: closedInternalTickets,
+            ticketAccuracyAbove: internalTicketAccuracyAbove+'%',
+            ticketAccuracyBelow: internalTicketAccuracyBelow+'%',
+          };
+          break;
+        default: '';
+      }
+    } else if ( req?.user?.userType === 'client' ) {
+      if ( ticketsFeature && !ticketsApproveFeature ) {
+        const storeQuery = {
+          size: 0,
+          query: {
+            bool: {
+              must: [
+                {
+                  'range': {
+                    'dateString': {
+                      'gte': inputData?.fromDate,
+                      'lte': inputData?.toDate,
+                      'format': 'yyyy-MM-dd',
+                    },
+                  },
+                },
+                {
+                  nested: {
+                    path: 'mappingInfo',
+                    query: {
+                      bool: {
+                        must: [
+                          {
+                            term: {
+                              'mappingInfo.type': 'review',
+                            },
+                          },
+                        ],
+                      },
+                    },
+                  },
+                },
+
+              ],
+            },
+          },
+        };
+
+        // Helper function to clone deep and replace mappingInfo.status for openTickets/closed/etc
+        function buildStoreQueryWithStatus( baseQuery, statusValue ) {
+          let q = JSON.parse( JSON.stringify( baseQuery ) );
+          // Remove any previous mappingInfo.status term
+          let nested = q.query.bool.must.find( ( m ) => m.nested );
+          if ( nested ) {
+            // filter out all mappingInfo.status
+            nested.nested.query.bool.must = nested?.nested?.query?.bool?.must.filter( ( mustItem ) => {
+              return !( mustItem.term && mustItem.term['mappingInfo.status'] );
+            } );
+            // add desired status
+            nested.nested.query.bool.must.push( {
+              term: {
+                'mappingInfo.status': statusValue,
+              },
+            } );
+          }
+          return q;
+        }
+
+        const buildAggStoreQuery = ( baseQuery, filters = [] ) => {
+          const q = JSON.parse( JSON.stringify( baseQuery ) );
+
+          // locate nested section
+          const nested = q.query.bool.must.find( ( m ) => m.nested );
+
+          if ( nested ) {
+            // remove old status filters
+            nested.nested.query.bool.must =
+              nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
+
+            // add new filters
+            nested.nested.query.bool.must.push( ...filters );
+          }
+
+          return {
+            ...q,
+            size: 0,
+            aggs: {
+              avg_value: {
+                avg: {
+                  script: {
+                    lang: 'painless',
+                    source: `
+          if (doc['revicedPerc.keyword'].size() == 0) return null;
+String v = doc['revicedPerc.keyword'].value.replace('%','');
+try {
+  return Double.parseDouble(v);
+} catch (Exception e) { 
+  return null; 
+}
+        `,
+                  },
+                },
+              },
+            },
+          };
+        };
+
+
+        // Get OpenSearch connection
+
+        const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
+
+        // Total Tickets (all tickets with mappingInfo.type == tangoreview)
+        let totalTickets = 0;
+
+        let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+
+        allQuery.size = 0;
+        const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
+        totalTickets = totalResp?.body?.hits?.total?.value || 0;
+
+        // openTickets: mappingInfo.status: 'Open'
+        let openTickets = 0;
+
+        let otQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open' );
+        otQ.size = 0;
+        const openResp = await getOpenSearchData( openSearch.footfallDirectory, otQ );
+        openTickets = openResp?.body?.hits?.total?.value || 0;
+        // logger.info( { msd: '..............2', openResp } );
+
+
+        // inprogress: mappingInfo.status: 'in-Progress'
+        let inprogress = 0;
+
+        let ipQ = buildStoreQueryWithStatus( baseStoreQuery, 'In-Progress' );
+        ipQ.size = 0;
+        const ipResp = await getOpenSearchData( openSearch.footfallDirectory, ipQ );
+        inprogress = ipResp?.body?.hits?.total?.value || 0;
+
+        // closedTickets: mappingInfo.status: 'closed'
+        let closedTickets = 0;
+
+        let clQ = buildStoreQueryWithStatus( baseStoreQuery, 'Closed' );
+        clQ.size = 0;
+        const clResp = await getOpenSearchData( openSearch.footfallDirectory, clQ );
+        closedTickets = clResp?.body?.hits?.total?.value || 0;
+
+        let dueToday = 0;
+        let todayDateString = new Date().toISOString().slice( 0, 10 );
+
+        // Build a query for tickets with mappingInfo.dueDate == todayDateString
+        let dueTodayQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+        // Locate nested mappingInfo query
+        let nestedDue = dueTodayQuery.query.bool.must.find( ( m ) => m.nested );
+        if ( nestedDue ) {
+          // Remove any previous mappingInfo.dueDate term
+          nestedDue.nested.query.bool.must = nestedDue.nested.query.bool.must.filter(
+              ( mustItem ) => !( mustItem.term && mustItem.term['mappingInfo.dueDate'] ),
+          );
+          // Add new dueDate filter
+          nestedDue.nested.query.bool.must.push( {
+            term: { 'mappingInfo.dueDate': todayDateString },
+          } );
+        }
+        dueTodayQuery.size = 0;
+        const dueTodayResp = await getOpenSearchData( openSearch.footfallDirectory, dueTodayQuery );
+        dueToday = dueTodayResp?.body?.hits?.total?.value || 0;
+
+        // filter expired Tickets
+        let expiredTickets = 0;
+
+        let eQ = buildStoreQueryWithStatus( baseStoreQuery, 'Under Tango Review' );
+        eQ.size = 0;
+        const eResp = await getOpenSearchData( openSearch.footfallDirectory, eQ );
+        expiredTickets = eResp?.body?.hits?.total?.value || 0;
+
+        let ticketAccuracyAbove = 0;
+        // For this, add a filter on revicedPerc >= 85
+        let aboveQ = buildAggStoreQuery( baseStoreQuery, [
+          {
+            script: {
+              script: {
+                lang: 'painless',
+                source: `
+                  doc['revicedPerc.keyword'].size()!=0 &&
+                  Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) >= params.num
+                `,
+                params: { num: 85 },
+              },
+            },
+          },
+
+
+        ] );
+        const aboveResp = await getOpenSearchData( openSearch.footfallDirectory, aboveQ );
+        ticketAccuracyAbove = aboveResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+
+        // ticketAccuracyBelow: avg of revicedPerc < 85%
+        let ticketAccuracyBelow = 0;
+
+        let belowQ = buildAggStoreQuery( baseStoreQuery, [
+          {
+            script: {
+              script: {
+                lang: 'painless',
+                source: `
+                  doc['revicedPerc.keyword'].size()!=0 &&
+                  Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) < params.num
+                `,
+                params: { num: 85 },
+              },
+            },
+          },
+
+        ] );
+        const belowResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
+        ticketAccuracyBelow = belowResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+
+        // Final result object
+        result = {
+          totalTickets,
+          openTickets,
+          inprogress,
+          closedTickets,
+          dueToday: dueToday,
+          Expired: expiredTickets,
+          avgTicket: ticketAccuracyAbove+'%',
+          avgAccuracy: ticketAccuracyBelow+'%',
+        };
+      }
+    } else if ( ticketsFeature && ticketsApproveFeature ) {
+      if ( inputData?.permissionType === 'review' ) {
+        const storeQuery = {
+          size: 0,
+          query: {
+            bool: {
+              must: [
+                {
+                  'range': {
+                    'dateString': {
+                      'gte': inputData?.fromDate,
+                      'lte': inputData?.toDate,
+                      'format': 'yyyy-MM-dd',
+                    },
+                  },
+                },
+                {
+                  nested: {
+                    path: 'mappingInfo',
+                    query: {
+                      bool: {
+                        must: [
+                          {
+                            term: {
+                              'mappingInfo.type': inputData.permissionType === 'review'? 'review':'approve',
+                            },
+                          },
+                        ],
+                      },
+                    },
+                  },
+                },
+
+              ],
+            },
+          },
+        };
+
+        // Helper function to clone deep and replace mappingInfo.status for openTickets/closed/etc
+        function buildStoreQueryWithStatus( baseQuery, statusValue ) {
+          let q = JSON.parse( JSON.stringify( baseQuery ) );
+          // Remove any previous mappingInfo.status term
+          let nested = q.query.bool.must.find( ( m ) => m.nested );
+          if ( nested ) {
+            // filter out all mappingInfo.status
+            nested.nested.query.bool.must = nested?.nested?.query?.bool?.must.filter( ( mustItem ) => {
+              return !( mustItem.term && mustItem.term['mappingInfo.status'] );
+            } );
+            // add desired status
+            nested.nested.query.bool.must.push( {
+              term: {
+                'mappingInfo.status': statusValue,
+              },
+            } );
+          }
+          return q;
+        }
+
+        const buildAggStoreQuery = ( baseQuery, filters = [] ) => {
+          const q = JSON.parse( JSON.stringify( baseQuery ) );
+
+          // locate nested section
+          const nested = q.query.bool.must.find( ( m ) => m.nested );
+
+          if ( nested ) {
+            // remove old status filters
+            nested.nested.query.bool.must =
+              nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
+
+            // add new filters
+            nested.nested.query.bool.must.push( ...filters );
+          }
+
+          return {
+            ...q,
+            size: 0,
+            aggs: {
+              avg_value: {
+                avg: {
+                  script: {
+                    lang: 'painless',
+                    source: `
+          if (doc['revicedPerc.keyword'].size() == 0) return null;
+  String v = doc['revicedPerc.keyword'].value.replace('%','');
+  try {
+  return Double.parseDouble(v);
+  } catch (Exception e) { 
+  return null; 
+  }
+        `,
+                  },
+                },
+              },
+            },
+          };
+        };
+
+
+        // Get OpenSearch connection
+
+        const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
+
+        // Total Tickets (all tickets with mappingInfo.type == tangoreview)
+        let totalTickets = 0;
+
+        let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+
+        allQuery.size = 0;
+        const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
+        totalTickets = totalResp?.body?.hits?.total?.value || 0;
+
+        // openTickets: mappingInfo.status: 'Open'
+        let openTickets = 0;
+
+        let otQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open' );
+        otQ.size = 0;
+        const openResp = await getOpenSearchData( openSearch.footfallDirectory, otQ );
+        openTickets = openResp?.body?.hits?.total?.value || 0;
+        // logger.info( { msd: '..............2', openResp } );
+
+
+        // inprogress: mappingInfo.status: 'in-Progress'
+        let inprogress = 0;
+
+        let ipQ = buildStoreQueryWithStatus( baseStoreQuery, 'In-Progress' );
+        ipQ.size = 0;
+        const ipResp = await getOpenSearchData( openSearch.footfallDirectory, ipQ );
+        inprogress = ipResp?.body?.hits?.total?.value || 0;
+
+        // closedTickets: mappingInfo.status: 'closed'
+        let closedTickets = 0;
+
+        let clQ = buildStoreQueryWithStatus( baseStoreQuery, 'Closed' );
+        clQ.size = 0;
+        const clResp = await getOpenSearchData( openSearch.footfallDirectory, clQ );
+        closedTickets = clResp?.body?.hits?.total?.value || 0;
+        // Average revisedPerc (for all tangoreview)
+
+        // dueToday: Tickets whose dueDate is today (format 'yyyy-MM-dd')
+        let dueToday = 0;
+        let todayDateString = new Date().toISOString().slice( 0, 10 );
+
+        // Build a query for tickets with mappingInfo.dueDate == todayDateString
+        let dueTodayQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+        // Locate nested mappingInfo query
+        let nestedDue = dueTodayQuery.query.bool.must.find( ( m ) => m.nested );
+        if ( nestedDue ) {
+          // Remove any previous mappingInfo.dueDate term
+          nestedDue.nested.query.bool.must = nestedDue.nested.query.bool.must.filter(
+              ( mustItem ) => !( mustItem.term && mustItem.term['mappingInfo.dueDate'] ),
+          );
+          // Add new dueDate filter
+          nestedDue.nested.query.bool.must.push( {
+            term: { 'mappingInfo.dueDate': todayDateString },
+          } );
+        }
+        dueTodayQuery.size = 0;
+        const dueTodayResp = await getOpenSearchData( openSearch.footfallDirectory, dueTodayQuery );
+        dueToday = dueTodayResp?.body?.hits?.total?.value || 0;
+
+
+        // filter expired Tickets
+        let expiredTickets = 0;
+
+        let eQ = buildStoreQueryWithStatus( baseStoreQuery, 'Under Tango Review' );
+        eQ.size = 0;
+        const eResp = await getOpenSearchData( openSearch.footfallDirectory, eQ );
+        expiredTickets = eResp?.body?.hits?.total?.value || 0;
+
+        // ticketAccuracyAbove: avg of revicedPerc > 85%
+        let ticketAccuracyAbove = 0;
+
+
+        // For this, add a filter on revicedPerc >= 85
+        let aboveQ = buildAggStoreQuery( baseStoreQuery, [
+          {
+            script: {
+              script: {
+                lang: 'painless',
+                source: `
+                  doc['revicedPerc.keyword'].size()!=0 &&
+                  Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) >= params.num
+                `,
+                params: { num: 85 },
               },
             },
+          },
 
 
-          ] );
-          const aboveRespInternal = await getOpenSearchData( openSearch.footfallDirectory, aboveQinternal );
-          internalTicketAccuracyAbove = aboveRespInternal?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+        ] );
+        const aboveResp = await getOpenSearchData( openSearch.footfallDirectory, aboveQ );
+        ticketAccuracyAbove = aboveResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
 
-          // ticketAccuracyBelow: avg of revicedPerc < 85%
-          let internalTicketAccuracyBelow = 0;
+        // ticketAccuracyBelow: avg of revicedPerc < 85%
+        let ticketAccuracyBelow = 0;
 
-          let belowQIneranl = buildAggInternalQuery( baseInternalQuery, [
-            {
+        let belowQ = buildAggStoreQuery( baseStoreQuery, [
+          {
+            script: {
               script: {
-                script: {
-                  lang: 'painless',
-                  source: `
-                    doc['revicedPerc.keyword'].size()!=0 &&
-                    Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) < params.num
-                  `,
-                  params: { num: 85 },
-                },
+                lang: 'painless',
+                source: `
+                  doc['revicedPerc.keyword'].size()!=0 &&
+                  Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) < params.num
+                `,
+                params: { num: 85 },
               },
             },
+          },
 
-          ] );
-          const belowRespInternal = await getOpenSearchData( openSearch.footfallDirectory, belowQIneranl );
-          internalTicketAccuracyBelow = belowRespInternal?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+        ] );
+        const belowResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
+        ticketAccuracyBelow = belowResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
 
-          // Final result object
-          result = {
-            totalTickets: totalInternalTickets,
-            averageAccuracyOverAll: internalAverageAccuracyOverAll+'%',
-            openTickets: openInternalTickets,
-            openInfraIssues: openInternalInfraIssues,
-            inprogress: inprogressIntrenal,
-            closedTickets: closedInternalTickets,
-            ticketAccuracyAbove: internalTicketAccuracyAbove+'%',
-            ticketAccuracyBelow: internalTicketAccuracyBelow+'%',
-          };
-          break;
-        default: '';
-      }
-      // result = {
-      //   totalTickets: 0,
-      //   averageAccuracyOverAll: 0,
-      //   openTickets: 0,
-      //   openInfraIssues: 0,
-      //   inprogress: 0,
-      //   closedTickets: 0,
-      //   ticketAccuracyAbove: '0%',
-      //   ticketAccuracyBelow: '0%',
-      // };
-    } else if ( req?.user?.userType === 'client' ) {
-      if ( ticketsFeature && !ticketsApproveFeature ) {
+        // Final result object
+        result = {
+          totalTickets,
+          openTickets,
+          inprogress,
+          closedTickets,
+          dueToday: dueToday,
+          Expired: expiredTickets,
+          avgTicket: ticketAccuracyAbove+'%',
+          avgAccuracy: ticketAccuracyBelow+'%',
+        };
+      } else {
         const storeQuery = {
           size: 0,
           query: {
@@ -1186,7 +1761,7 @@ export async function ticketSummary( req, res ) {
                         must: [
                           {
                             term: {
-                              'mappingInfo.type': 'review',
+                              'mappingInfo.type': inputData.permissionType === 'review'? 'review':'approve',
                             },
                           },
                         ],
@@ -1245,12 +1820,12 @@ export async function ticketSummary( req, res ) {
                     lang: 'painless',
                     source: `
           if (doc['revicedPerc.keyword'].size() == 0) return null;
-String v = doc['revicedPerc.keyword'].value.replace('%','');
-try {
+  String v = doc['revicedPerc.keyword'].value.replace('%','');
+  try {
   return Double.parseDouble(v);
-} catch (Exception e) { 
+  } catch (Exception e) { 
   return null; 
-}
+  }
         `,
                   },
                 },
@@ -1283,14 +1858,6 @@ try {
         // logger.info( { msd: '..............2', openResp } );
 
 
-        // openInfraIssues: mappingInfo.status: 'Open Accuracy Issue'
-        let openInfraIssues = 0;
-
-        let oiQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open Accuracy Issue' );
-        oiQ.size = 0;
-        const infraResp = await getOpenSearchData( openSearch.footfallDirectory, oiQ );
-        openInfraIssues = infraResp?.body?.hits?.total?.value || 0;
-
         // inprogress: mappingInfo.status: 'in-Progress'
         let inprogress = 0;
 
@@ -1306,18 +1873,48 @@ try {
         clQ.size = 0;
         const clResp = await getOpenSearchData( openSearch.footfallDirectory, clQ );
         closedTickets = clResp?.body?.hits?.total?.value || 0;
-        // Average revisedPerc (for all tangoreview)
-        let averageAccuracyOverAll = 0;
+        // dueToday: Tickets whose dueDate is today (format 'yyyy-MM-dd')
+        let dueToday = 0;
+        let todayDateString = new Date().toISOString().slice( 0, 10 );
+
+        // Build a query for tickets with mappingInfo.dueDate == todayDateString
+        let dueTodayQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+        // Locate nested mappingInfo query
+        let nestedDue = dueTodayQuery.query.bool.must.find( ( m ) => m.nested );
+        if ( nestedDue ) {
+          // Remove any previous mappingInfo.dueDate term
+          nestedDue.nested.query.bool.must = nestedDue.nested.query.bool.must.filter(
+              ( mustItem ) => !( mustItem.term && mustItem.term['mappingInfo.dueDate'] ),
+          );
+          // Add new dueDate filter
+          nestedDue.nested.query.bool.must.push( {
+            term: { 'mappingInfo.dueDate': todayDateString },
+          } );
+        }
+        dueTodayQuery.size = 0;
+        const dueTodayResp = await getOpenSearchData( openSearch.footfallDirectory, dueTodayQuery );
+        dueToday = dueTodayResp?.body?.hits?.total?.value || 0;
 
-        let avgQ = buildAggStoreQuery( baseStoreQuery );
-        const avgResp = await getOpenSearchData( openSearch.footfallDirectory, avgQ );
-        averageAccuracyOverAll = avgResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
 
-        // ticketAccuracyAbove: avg of revicedPerc > 85%
-        let ticketAccuracyAbove = 0;
+        // filter expired Tickets
+        let expiredTickets = 0;
 
+        let eQ = buildStoreQueryWithStatus( baseStoreQuery, 'Under Tango Review' );
+        eQ.size = 0;
+        const eResp = await getOpenSearchData( openSearch.footfallDirectory, eQ );
+        expiredTickets = eResp?.body?.hits?.total?.value || 0;
+
+        // filter under tango review
+
+        let undertangoTickets = 0;
+
+        let utrQ = buildStoreQueryWithStatus( baseStoreQuery, 'Under Tango Review' );
+        utrQ.size = 0;
+        const utrResp = await getOpenSearchData( openSearch.footfallDirectory, utrQ );
+        undertangoTickets = utrResp?.body?.hits?.total?.value || 0;
 
         // For this, add a filter on revicedPerc >= 85
+        let ticketAccuracyAbove = 0;
         let aboveQ = buildAggStoreQuery( baseStoreQuery, [
           {
             script: {
@@ -1334,6 +1931,7 @@ try {
 
 
         ] );
+
         const aboveResp = await getOpenSearchData( openSearch.footfallDirectory, aboveQ );
         ticketAccuracyAbove = aboveResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
 
@@ -1361,246 +1959,16 @@ try {
         // Final result object
         result = {
           totalTickets,
-          averageAccuracyOverAll: averageAccuracyOverAll+'%',
           openTickets,
-          openInfraIssues,
           inprogress,
           closedTickets,
-          ticketAccuracyAbove: ticketAccuracyAbove+'%',
-          ticketAccuracyBelow: ticketAccuracyBelow+'%',
+          dueToday: dueToday,
+          Expired: expiredTickets,
+          underTangoReview: undertangoTickets,
+          avgTicket: ticketAccuracyAbove+'%',
+          avgAccuracy: ticketAccuracyBelow+'%',
         };
       }
-    } else if ( ticketsFeature && !ticketsApproveFeature ) {
-      const storeQuery = {
-        size: 0,
-        query: {
-          bool: {
-            must: [
-              {
-                'range': {
-                  'dateString': {
-                    'gte': inputData?.fromDate,
-                    'lte': inputData?.toDate,
-                    'format': 'yyyy-MM-dd',
-                  },
-                },
-              },
-              {
-                nested: {
-                  path: 'mappingInfo',
-                  query: {
-                    bool: {
-                      must: [
-                        {
-                          term: {
-                            'mappingInfo.type': inputData.permissionType === 'review'? 'review':'approve',
-                          },
-                        },
-                      ],
-                    },
-                  },
-                },
-              },
-
-            ],
-          },
-        },
-      };
-
-      // Helper function to clone deep and replace mappingInfo.status for openTickets/closed/etc
-      function buildStoreQueryWithStatus( baseQuery, statusValue ) {
-        let q = JSON.parse( JSON.stringify( baseQuery ) );
-        // Remove any previous mappingInfo.status term
-        let nested = q.query.bool.must.find( ( m ) => m.nested );
-        if ( nested ) {
-          // filter out all mappingInfo.status
-          nested.nested.query.bool.must = nested?.nested?.query?.bool?.must.filter( ( mustItem ) => {
-            return !( mustItem.term && mustItem.term['mappingInfo.status'] );
-          } );
-          // add desired status
-          nested.nested.query.bool.must.push( {
-            term: {
-              'mappingInfo.status': statusValue,
-            },
-          } );
-        }
-        return q;
-      }
-
-      const buildAggStoreQuery = ( baseQuery, filters = [] ) => {
-        const q = JSON.parse( JSON.stringify( baseQuery ) );
-
-        // locate nested section
-        const nested = q.query.bool.must.find( ( m ) => m.nested );
-
-        if ( nested ) {
-          // remove old status filters
-          nested.nested.query.bool.must =
-            nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
-
-          // add new filters
-          nested.nested.query.bool.must.push( ...filters );
-        }
-
-        return {
-          ...q,
-          size: 0,
-          aggs: {
-            avg_value: {
-              avg: {
-                script: {
-                  lang: 'painless',
-                  source: `
-        if (doc['revicedPerc.keyword'].size() == 0) return null;
-String v = doc['revicedPerc.keyword'].value.replace('%','');
-try {
-return Double.parseDouble(v);
-} catch (Exception e) { 
-return null; 
-}
-      `,
-                },
-              },
-            },
-          },
-        };
-      };
-
-
-      // Get OpenSearch connection
-
-      const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
-
-      // Total Tickets (all tickets with mappingInfo.type == tangoreview)
-      let totalTickets = 0;
-
-      let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
-
-      allQuery.size = 0;
-      const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
-      totalTickets = totalResp?.body?.hits?.total?.value || 0;
-
-      // openTickets: mappingInfo.status: 'Open'
-      let openTickets = 0;
-
-      let otQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open' );
-      otQ.size = 0;
-      const openResp = await getOpenSearchData( openSearch.footfallDirectory, otQ );
-      openTickets = openResp?.body?.hits?.total?.value || 0;
-      // logger.info( { msd: '..............2', openResp } );
-
-
-      // openInfraIssues: mappingInfo.status: 'Open Accuracy Issue'
-      let openInfraIssues = 0;
-
-      let oiQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open Accuracy Issue' );
-      oiQ.size = 0;
-      const infraResp = await getOpenSearchData( openSearch.footfallDirectory, oiQ );
-      openInfraIssues = infraResp?.body?.hits?.total?.value || 0;
-
-      // inprogress: mappingInfo.status: 'in-Progress'
-      let inprogress = 0;
-
-      let ipQ = buildStoreQueryWithStatus( baseStoreQuery, 'In-Progress' );
-      ipQ.size = 0;
-      const ipResp = await getOpenSearchData( openSearch.footfallDirectory, ipQ );
-      inprogress = ipResp?.body?.hits?.total?.value || 0;
-
-      // closedTickets: mappingInfo.status: 'closed'
-      let closedTickets = 0;
-
-      let clQ = buildStoreQueryWithStatus( baseStoreQuery, 'Closed' );
-      clQ.size = 0;
-      const clResp = await getOpenSearchData( openSearch.footfallDirectory, clQ );
-      closedTickets = clResp?.body?.hits?.total?.value || 0;
-      // Average revisedPerc (for all tangoreview)
-      let averageAccuracyOverAll = 0;
-
-      let avgQ = buildAggStoreQuery( baseStoreQuery );
-      const avgResp = await getOpenSearchData( openSearch.footfallDirectory, avgQ );
-      averageAccuracyOverAll = avgResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
-
-      // ticketAccuracyAbove: avg of revicedPerc > 85%
-      let ticketAccuracyAbove = 0;
-
-
-      // For this, add a filter on revicedPerc >= 85
-      let aboveQ = buildAggStoreQuery( baseStoreQuery, [
-        {
-          script: {
-            script: {
-              lang: 'painless',
-              source: `
-                doc['revicedPerc.keyword'].size()!=0 &&
-                Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) >= params.num
-              `,
-              params: { num: 85 },
-            },
-          },
-        },
-
-
-      ] );
-      const aboveResp = await getOpenSearchData( openSearch.footfallDirectory, aboveQ );
-      ticketAccuracyAbove = aboveResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
-
-      // ticketAccuracyBelow: avg of revicedPerc < 85%
-      let ticketAccuracyBelow = 0;
-
-      let belowQ = buildAggStoreQuery( baseStoreQuery, [
-        {
-          script: {
-            script: {
-              lang: 'painless',
-              source: `
-                doc['revicedPerc.keyword'].size()!=0 &&
-                Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) < params.num
-              `,
-              params: { num: 85 },
-            },
-          },
-        },
-
-      ] );
-      const belowResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
-      ticketAccuracyBelow = belowResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
-
-      // Final result object
-      result = {
-        totalTickets,
-        averageAccuracyOverAll: averageAccuracyOverAll+'%',
-        openTickets,
-        openInfraIssues,
-        inprogress,
-        closedTickets,
-        ticketAccuracyAbove: ticketAccuracyAbove+'%',
-        ticketAccuracyBelow: ticketAccuracyBelow+'%',
-      };
-    } 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';
     }
 
     return res.sendSuccess( { result: result } );
@@ -1615,7 +1983,7 @@ export async function ticketList1( req, res ) {
   try {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
-    const limit = inputData.limit || 10;
+    const limit =inputData?.isExport ? 10000: inputData.limit || 10;
     const offset = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
     const order = inputData?.sortOrder || -1;
 
@@ -1837,7 +2205,7 @@ export async function ticketList( req, res ) {
     const openSearch = JSON.parse( process.env.OPENSEARCH );
     const inputData = req.query;
     const userInfo = req.user;
-    const limit = inputData?.limit || 10;
+    const limit =inputData?.isExport? 10000: inputData?.limit || 10;
     const offset = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
     inputData.clientId = inputData?.clientId?.split( ',' ); // convert strig to array
 
@@ -2642,137 +3010,285 @@ export async function ticketList( req, res ) {
     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?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
+        if ( inputData?.isExport ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+
+              'Ticket ID': item?.ticketId,
+              'store Name': item?.storeName,
+              'store ID': item?.storeId,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Due Date': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.dueDate,
+              'Actual FF': item?.footfallCount,
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Approver (%)': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              'Tango (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Status': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
 
-          } );
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.createdAt,
+              issueDate: item?.dateString,
+              dueDate: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.dueDate,
+              footfall: item?.footfallCount,
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              status: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
+
+            } );
+          }
         }
       } 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' )?.status || '--',
+        if ( inputData?.isExport ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+
+              'Ticket ID': item?.ticketId,
+              'Store Name': item?.storeName,
+              'Store ID': item?.storeId,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Ticket Type': item?.type,
+              'Actual FF': item?.footfallCount,
+              // Use the dueDate from the last mappingInfo item whose type is NOT 'finalRevisoon'
+              'Due Date': ( () => {
+                if ( Array.isArray( item?.mappingInfo ) ) {
+                  const filtered = item.mappingInfo.filter( ( f ) => f.dueDate && f.type !== 'finalRevisoon' );
+                  return filtered.length > 0 ? filtered[filtered.length - 1].dueDate : '';
+                }
+                return '';
+              } )(),
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Approver (%)': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              'Tango (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Ticket Status': item?.status,
+              'Tango Status': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
 
-          } );
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
+              issueDate: item?.dateString,
+              footfall: item?.footfallCount,
+              dueDate: ( () => {
+                if ( Array.isArray( item?.mappingInfo ) ) {
+                  const filtered = item.mappingInfo.filter( ( f ) => f.dueDate && f.type !== 'finalRevisoon' );
+                  return filtered.length > 0 ? filtered[filtered.length - 1].dueDate : '';
+                }
+                return '';
+              } )(),
+              type: item?.type || 'store',
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              status: item?.status,
+              tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.status || '--',
+
+            } );
+          }
         }
       }
     } else {
       if ( 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 || '--',
+        if ( inputData.exportData ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+
+              'Ticket ID': item?.ticketId,
+              'Store Name': item?.storeName,
+              'Store ID': item?.storeId,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Due Date': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.dueDate,
+              'Actual FF': item?.footfallCount,
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Approver (%)': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              'Tango (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Status': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.status || '--',
+              'Tango Status': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Approved by': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdByEmail || '--',
 
-          } );
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdAt,
+              issueDate: item?.dateString,
+              dueDate: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.dueDate,
+              footfall: item?.footfallCount,
+              type: item.type || 'store',
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              status: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.status || '--',
+              tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              approvedBy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdByEmail || '--',
+
+            } );
+          }
         }
       } else if ( inputData?.permissionType === 'review' ) {
-        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 || '--',
+        if ( inputData?.isExport ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+
+              'Ticket ID': item?.ticketId,
+              'Store Name': item?.storeName,
+              'Store ID': item?.storeId,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Actual FF': item?.footfallCount,
+              'Due Date': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.dueDate,
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Status': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.status || '--',
+              'Reviewed by': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdByEmail || '--',
 
-          } );
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdAt,
+              issueDate: item?.dateString,
+              footfall: item?.footfallCount,
+              dueDate: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.dueDate,
+              type: item.type || 'store',
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              status: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.status || '--',
+              ReviewedBy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdByEmail || '--',
+
+            } );
+          }
         }
       } else if ( req.user.role === 'user' ) {
         temp = [];
       } else if ( ticketsFeature ) {
-        for ( let item of ticketListData ) {
-          temp.push( {
-
-            ticketId: item?.ticketId,
-            storeId: item?.storeId,
-            storeName: item?.storeName,
-            ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.createdAt,
-            issueDate: item?.dateString,
-            footfall: item?.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 || '--',
+        if ( inputData?.isExport ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+
+              'Ticket ID': item?.ticketId,
+              'Store ID': item?.storeId,
+              'Store Name': item?.storeName,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Actual FF': item?.footfallCount,
+              'Due Date': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.dueDate,
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Status': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.status || '--',
+              'Reviewed by': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdByEmail || '--',
 
-          } );
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdAt,
+              issueDate: item?.dateString,
+              footfall: item?.footfallCount,
+              dueDate: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.dueDate,
+              type: item.type || 'store',
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              status: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.status || '--',
+              ReviewedBy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.createdByEmail || '--',
+
+            } );
+          }
         }
       } else if ( ticketsApproveFeature ) {
-        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 || '--',
+        if ( inputData.isExport ) {
+          const exportData = [];
+          for ( let item of ticketListData ) {
+            exportData.push( {
+
+              'Ticket ID': item?.ticketId,
+              'Store Name': item?.storeName,
+              'Store ID': item?.storeId,
+              'Ticket Raised': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdAt,
+              'Issue Date': item?.dateString,
+              'Due Date': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.dueDate,
+              'Actual FF': item?.footfallCount,
+              'Store (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              'Reviewer (%)': item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              'Approver (%)': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              'Tango (%)': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Status': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.status || '--',
+              'Tango Status': item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              'Approved by': item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdByEmail || '--',
 
-          } );
+            } );
+          }
+          return await download( exportData, res );
+        } else {
+          for ( let item of ticketListData ) {
+            temp.push( {
+
+              ticketId: item?.ticketId,
+              storeId: item?.storeId,
+              storeName: item?.storeName,
+              ticketRaised: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdAt,
+              issueDate: item?.dateString,
+              dueDate: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.dueDate,
+              footfall: item?.footfallCount,
+              type: item.type || 'store',
+              storeRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tagging' )?.revicedPerc || '--',
+              reviewerRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'review' )?.revicedPerc || '--',
+              approverRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.revicedPerc || '--',
+              tangoRevisedAccuracy: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              status: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.status || '--',
+              tangoStatus: item?.mappingInfo?.find( ( f ) => f.type === 'tangoreview' )?.revicedPerc || '--',
+              approvedBy: item?.mappingInfo?.find( ( f ) => f.type === 'approve' )?.createdByEmail || '--',
+
+            } );
+          }
         }
       } else {
         temp = [];
@@ -4038,6 +4554,7 @@ export async function openTicketList( req, res ) {
       },
     ];
 
+
     const openSearchQuery = {
       size: 10000,
       query: {
@@ -4047,6 +4564,31 @@ export async function openTicketList( req, res ) {
       },
       _source: [ 'ticketId', 'storeName', 'storeId', 'dateString', 'revicedFootfall', 'footfallCount', 'revicedPerc', 'type' ],
     };
+
+    if ( inputData.searchValue && inputData.searchValue !== '' ) {
+      openSearchQuery.query.bool['should'] = [];
+      openSearchQuery.query.bool.should = [
+
+        {
+          'wildcard': {
+            'storeName.keyword': {
+              'value': `*${inputData.searchValue}*`,
+            },
+          },
+        },
+        {
+          'wildcard': {
+            'ticketId.keyword': {
+              'value': `*${inputData.searchValue}*`,
+            },
+          },
+        },
+
+
+      ];
+      openSearchQuery.query.bool['minimum_should_match'] = 1;
+    }
+
     // INSERT_YOUR_CODE
     // Add sorting by revicedPerc descending (highest revised accuracy first)
     openSearchQuery.sort = [