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

package/src/controllers/footfallDirectory.controllers.js

@@ -385,22 +385,97 @@ export async function tangoReviewTicket( req, res ) {
 
     let id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
     let getExistingOne = await getOpenSearchById( openSearch.footfallDirectory, id );
-    console.log( '🚀 ~ tangoReviewTicket ~ getExistingOne:', getExistingOne );
-    if ( inputData.ticketType === 'internal'&&!getExistingOne?.body?._source ) {
+    if ( inputData.ticketType === 'internal' &&!getExistingOne?.body?._source ) {
       id = `${inputData.storeId}_${inputData.dateString}_internal_footfall-directory-tagging`;
     }
 
-
     const insertResult = await updateOpenSearchData( openSearch.footfallDirectory, id, { doc: record } );
-    console.log( insertResult );
 
     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 );
     }
   } catch ( error ) {
-    console.log( '🚀 ~ tangoReviewTicket ~ error:', error );
     const err = error.message || 'Internal Server Error';
     logger.error( { error: error, funtion: 'tangoReviewTicket' } );
     return res.sendError( err, 500 );
@@ -518,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',
@@ -559,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 );
@@ -628,145 +765,1210 @@ async function bulkUpdateStatusToPending( indexName, inputData ) {
     }
   }
 
-  // Final bulk call
-  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 };
-    }
-  } else {
-    logger.error( 'No data to update.' );
-    return { success: false, message: 'No updates needed' };
-  }
-}
+  // Final bulk call
+  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 };
+    }
+  } else {
+    logger.error( 'No data to update.' );
+    return { success: false, message: 'No updates needed' };
+  }
+}
+
+export async function ticketSummary1( req, res ) {
+  try {
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const inputData = req.query;
+    inputData.clientId = inputData.clientId.split( ',' ); // convert strig to array
+    const getQuery = {
+      size: 0,
+      query: {
+        bool: {
+          filter: [
+            { terms: { 'clientId.keyword': inputData.clientId } },
+            {
+              range: {
+                dateString: {
+                  gte: inputData.fromDate,
+                  lte: inputData.toDate,
+                },
+              },
+            },
+          ],
+        },
+      },
+      aggs: {
+        totalTicketCount: {
+          value_count: { field: '_id' },
+        },
+        openStatusCount: {
+          filter: {
+            term: { 'status.keyword': 'open' },
+          },
+        },
+        closeTicketCount: {
+          filter: {
+            term: { 'status.keyword': 'closed' },
+          },
+        },
+        duplicateCount: {
+          sum: {
+            field: 'duplicateCount',
+          },
+        },
+        employeeCount: {
+          sum: {
+            field: 'employeeCount',
+          },
+        },
+        houseKeepingCount: {
+          sum: {
+            field: 'houseKeepingCount',
+          },
+        },
+        junkCount: {
+          sum: {
+            field: 'junkCount',
+          },
+        },
+      },
+    };
+
+    const getData = await getOpenSearchData( openSearch.footfallDirectory, getQuery );
+    const aggs = getData?.body?.aggregations;
+
+    const result = {
+      totalTickets: aggs.totalTicketCount.value,
+      openTickets: aggs.openStatusCount.doc_count,
+      closedTickets: aggs.closeTicketCount.doc_count,
+      duplicateCount: aggs.duplicateCount.value,
+      employeeCount: aggs.employeeCount.value,
+      houseKeepingCount: aggs.houseKeepingCount.value,
+      junkCount: aggs.junkCount.value,
+      noShopper: aggs.duplicateCount.value + aggs.employeeCount.value + aggs.houseKeepingCount.value + aggs.junkCount.value,
+    };
+
+    return res.sendSuccess( { result: result } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { error: error, messgage: req.query } );
+    return res.sendSuccess( err, 500 );
+  }
+}
+
+export async function ticketSummary( req, res ) {
+  try {
+    const inputData = req.query;
+
+    let result = '';
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const userInfo = req.user;
+    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'reviewer' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+    const ticketsApproveFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'approver' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+
+    // const ticketsApproveFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'approver' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+    if ( req?.user?.userType === 'tango' ) {
+      switch ( inputData?.tangoType ) {
+        case 'store':
+          const storeQuery = {
+            size: 0,
+            query: {
+              bool: {
+                must: [
+                  {
+                    'range': {
+                      'dateString': {
+                        'gte': inputData?.fromDate,
+                        'lte': inputData?.toDate,
+                        'format': 'yyyy-MM-dd',
+                      },
+                    },
+                  },
+                  {
+                    nested: {
+                      path: 'mappingInfo',
+                      query: {
+                        bool: {
+                          must: [
+                            {
+                              term: {
+                                'mappingInfo.type': 'tangoreview',
+                              },
+                            },
+                          ],
+                        },
+                      },
+                    },
+                  },
+
+                ],
+              },
+            },
+          };
+
+          // Helper function to clone deep and replace mappingInfo.status for openTickets/closed/etc
+          function buildStoreQueryWithStatus( baseQuery, statusValue ) {
+            let q = JSON.parse( JSON.stringify( baseQuery ) );
+            // Remove any previous mappingInfo.status term
+            let nested = q.query.bool.must.find( ( m ) => m.nested );
+            if ( nested ) {
+              // filter out all mappingInfo.status
+              nested.nested.query.bool.must = nested?.nested?.query?.bool?.must.filter( ( mustItem ) => {
+                return !( mustItem.term && mustItem.term['mappingInfo.status'] );
+              } );
+              // add desired status
+              nested.nested.query.bool.must.push( {
+                term: {
+                  'mappingInfo.status': statusValue,
+                },
+              } );
+            }
+            return q;
+          }
+
+          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+'%',
+          };
+          break;
+        case 'internal':
+          const internalQuery = {
+            size: 0,
+            query: {
+              bool: {
+                must: [
+                  {
+                    'range': {
+                      'dateString': {
+                        'gte': inputData?.fromDate,
+                        'lte': inputData?.toDate,
+                        'format': 'yyyy-MM-dd',
+                      },
+                    },
+                  },
+
+                  {
+                    nested: {
+                      path: 'mappingInfo',
+                      query: {
+                        bool: {
+                          must: [
+                            {
+                              terms: {
+                                'mappingInfo.type': [ 'tagging', 'review', 'approve', 'tangoreview' ],
+                              },
+                            },
+                          ],
+                        },
+                      },
+                    },
+                  },
+
+                ],
+              },
+            },
+          };
+
+          // Helper function to clone deep and replace mappingInfo.status for openTickets/closed/etc
+          function buildInternalQueryWithStatus( 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 buildAggInternalQuery = ( baseQuery, filters = [] ) => {
+            const q = JSON.parse( JSON.stringify( baseQuery ) );
+
+            // locate nested section
+            const nested = q.query.bool.must.find( ( m ) => m.nested );
+
+            if ( nested ) {
+              // remove old status filters
+              nested.nested.query.bool.must =
+                nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
+
+              // add new filters
+              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 baseInternalQuery = JSON.parse( JSON.stringify( internalQuery ) );
+
+          // Total Tickets (all tickets with mappingInfo.type == tangoreview)
+          let totalInternalTickets = 0;
+
+          let allInternalQuery = JSON.parse( JSON.stringify( baseInternalQuery ) );
+
+          allInternalQuery.size = 0;
+          const totalInternalResp = await getOpenSearchData( openSearch.footfallDirectory, allInternalQuery );
+          totalInternalTickets = totalInternalResp?.body?.hits?.total?.value || 0;
+
+          // openTickets: mappingInfo.status: 'Open'
+          let openInternalTickets = 0;
+
+          let otQInternal = buildInternalQueryWithStatus( baseInternalQuery, 'Open' );
+          otQInternal.size = 0;
+          const openInternalResp = await getOpenSearchData( openSearch.footfallDirectory, otQInternal );
+          openInternalTickets = openInternalResp?.body?.hits?.total?.value || 0;
+          // logger.info( { msd: '..............2', openResp } );
+
+
+          // openInfraIssues: mappingInfo.status: 'Open Accuracy Issue'
+          let openInternalInfraIssues = 0;
+
+          let oiQinternal = buildInternalQueryWithStatus( baseInternalQuery, 'Open Accuracy Issue' );
+          oiQinternal.size = 0;
+          const infraInternalResp = await getOpenSearchData( openSearch.footfallDirectory, oiQinternal );
+          openInternalInfraIssues = infraInternalResp?.body?.hits?.total?.value || 0;
+
+          // inprogress: mappingInfo.status: 'in-Progress'
+          let inprogressIntrenal = 0;
+
+          let ipQInternal = buildInternalQueryWithStatus( baseInternalQuery, 'In-Progress' );
+          ipQInternal.size = 0;
+          const ipInternalResp = await getOpenSearchData( openSearch.footfallDirectory, ipQInternal );
+          inprogressIntrenal = ipInternalResp?.body?.hits?.total?.value || 0;
+
+          // closedTickets: mappingInfo.status: 'closed'
+          let closedInternalTickets = 0;
+
+          let clQInternal = buildInternalQueryWithStatus( baseInternalQuery, 'Closed' );
+          clQInternal.size = 0;
+          const clInternalResp = await getOpenSearchData( openSearch.footfallDirectory, clQInternal );
+          closedInternalTickets = clInternalResp?.body?.hits?.total?.value || 0;
+          // Average revisedPerc (for all tangoreview)
+          let internalAverageAccuracyOverAll = 0;
+
+          let avgQInternal = buildAggInternalQuery( baseInternalQuery );
+          const avgInternalResp = await getOpenSearchData( openSearch.footfallDirectory, avgQInternal );
+          internalAverageAccuracyOverAll = avgInternalResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+
+          // ticketAccuracyAbove: avg of revicedPerc > 85%
+          let internalTicketAccuracyAbove = 0;
+
+
+          // For this, add a filter on revicedPerc >= 85
+          let aboveQinternal = buildAggInternalQuery( baseInternalQuery, [
+            {
+              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';
+
+          // 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 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 {
+        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;
+        // 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;
+
 
-export async function ticketSummary1( req, res ) {
-  try {
-    const openSearch = JSON.parse( process.env.OPENSEARCH );
-    const inputData = req.query;
-    inputData.clientId = inputData.clientId.split( ',' ); // convert strig to array
-    const getQuery = {
-      size: 0,
-      query: {
-        bool: {
-          filter: [
-            { terms: { 'clientId.keyword': inputData.clientId } },
-            {
-              range: {
-                dateString: {
-                  gte: inputData.fromDate,
-                  lte: inputData.toDate,
-                },
+        // 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: {
+              script: {
+                lang: 'painless',
+                source: `
+                  doc['revicedPerc.keyword'].size()!=0 &&
+                  Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) >= params.num
+                `,
+                params: { num: 85 },
               },
             },
-          ],
-        },
-      },
-      aggs: {
-        totalTicketCount: {
-          value_count: { field: '_id' },
-        },
-        openStatusCount: {
-          filter: {
-            term: { 'status.keyword': 'open' },
-          },
-        },
-        closeTicketCount: {
-          filter: {
-            term: { 'status.keyword': 'closed' },
-          },
-        },
-        duplicateCount: {
-          sum: {
-            field: 'duplicateCount',
-          },
-        },
-        employeeCount: {
-          sum: {
-            field: 'employeeCount',
-          },
-        },
-        houseKeepingCount: {
-          sum: {
-            field: 'houseKeepingCount',
-          },
-        },
-        junkCount: {
-          sum: {
-            field: 'junkCount',
           },
-        },
-      },
-    };
 
-    const getData = await getOpenSearchData( openSearch.footfallDirectory, getQuery );
-    const aggs = getData?.body?.aggregations;
 
-    const result = {
-      totalTickets: aggs.totalTicketCount.value,
-      openTickets: aggs.openStatusCount.doc_count,
-      closedTickets: aggs.closeTicketCount.doc_count,
-      duplicateCount: aggs.duplicateCount.value,
-      employeeCount: aggs.employeeCount.value,
-      houseKeepingCount: aggs.houseKeepingCount.value,
-      junkCount: aggs.junkCount.value,
-      noShopper: aggs.duplicateCount.value + aggs.employeeCount.value + aggs.houseKeepingCount.value + aggs.junkCount.value,
-    };
+        ] );
 
-    return res.sendSuccess( { result: result } );
-  } catch ( error ) {
-    const err = error.message || 'Internal Server Error';
-    logger.error( { error: error, messgage: req.query } );
-    return res.sendSuccess( err, 500 );
-  }
-}
+        const aboveResp = await getOpenSearchData( openSearch.footfallDirectory, aboveQ );
+        ticketAccuracyAbove = aboveResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
 
-export async function ticketSummary( req, res ) {
-  try {
-    let result = '';
-    const userInfo = req.user;
-    const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'reviewer' && ( m.isAdd == true || m.isEdit == true ) ) ) );
-    // const ticketsApproveFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'approver' && ( m.isAdd == true || m.isEdit == true ) ) ) );
-    if ( req.user.userType == 'tango' ) {
-      result = {
-        totalTickets: 0,
-        averageAccuracyOverAll: 0,
-        openTickets: 0,
-        openInfraIssues: 0,
-        inprogress: 0,
-        closedTickets: 0,
-        ticketAccuracyAbove: '0%',
-        ticketAccuracyBelow: '0%',
-      };
-    } else {
-      result = req.user.role === 'superadmin' ?
-        {
-          totalTickets: 0,
-          openTickets: 0,
-          inprogress: 0,
-          closedTickets: 0,
-          dueToday: 0,
-          Expired: 0,
-          underTangoReview: 0,
-          avgTicket: '0%',
-          avgAccuracy: '0%',
-        } :
-        req.user.role === 'user' ? 'NA' :
-          ticketsFeature ?
-            {
-              totalTickets: 0,
-              openTickets: 0,
-              inprogress: 0,
-              closedTickets: 0,
-              dueToday: 0,
-              Expired: 0,
-              avgTicket: '0%',
-              avgAccuracy: '0%',
-            } : 'NA';
+        // 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,
+          underTangoReview: undertangoTickets,
+          avgTicket: ticketAccuracyAbove+'%',
+          avgAccuracy: ticketAccuracyBelow+'%',
+        };
+      }
     }
 
     return res.sendSuccess( { result: result } );
@@ -781,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;
 
@@ -1003,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
 
@@ -1326,6 +2528,87 @@ export async function ticketList( req, res ) {
       }
     }
 
+    if ( inputData?.filterByStore && inputData?.filterByStore !== '' ) {
+      let percQuery = null;
+      const value = inputData.filterByStore;
+
+      // Helper function: remove trailing '%' and convert to number
+      const percValue = ( val ) => {
+        if ( typeof val === 'string' ) {
+          return parseFloat( val.replace( '%', '' ).trim() );
+        }
+        return parseFloat( val );
+      };
+
+      // Example filter values: "<90", "<=90", ">=90", "50 to 90"
+      if ( /^<=?\d+$/.test( value ) ) {
+        // "<90" or "<=90"
+        const num = percValue( value.replace( /[^\d]/g, '' ) );
+        const op = value.includes( '=' ) ? 'lte' : 'lt';
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) ${op === 'lt' ? '<' : '<='} params.num`,
+              params: { num },
+            },
+          },
+        };
+      } else if ( /^>=?\d+$/.test( value ) ) {
+        // ">=90"
+        const num = percValue( value.replace( /[^\d]/g, '' ) );
+        const op = value.includes( '=' ) ? 'gte' : 'gt';
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) ${op === 'gt' ? '>' : '>='} params.num`,
+              params: { num },
+            },
+          },
+        };
+      } else if ( /^(\d+)\s*to\s*(\d+)$/.test( value ) ) {
+        // "50 to 90"
+        const match = value.match( /^(\d+)\s*to\s*(\d+)$/ );
+        const from = percValue( match[1] );
+        const to = percValue( match[2] );
+        percQuery = {
+          script: {
+            script: {
+              source:
+                `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) >= params.from && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) <= params.to`,
+              params: { from, to },
+            },
+          },
+        };
+      }
+      // fallback: treat as exact match (e.g., "90")
+      if ( !percQuery && /^\d+$/.test( value ) ) {
+        percQuery = {
+          script: {
+            script: {
+              source: `doc['mappingInfo.revicedPerc.keyword'].size()!=0 && Integer.parseInt(doc['mappingInfo.revicedPerc.keyword'].value.replace('%','')) == params.num`,
+              params: { num: percValue( value ) },
+            },
+          },
+        };
+      }
+
+      if ( percQuery ) {
+        searchQuery.query.bool.must.push( {
+          nested: {
+            path: 'mappingInfo',
+            query: {
+              bool: {
+                must: [
+                  { term: { 'mappingInfo.type': 'tagging' } },
+                  percQuery,
+                ],
+              },
+            },
+          },
+        } );
+      }
+    }
+
     if ( inputData?.filterByReviewer && inputData?.filterByReviewer !== '' ) {
       let percQuery = null;
       const value = inputData.filterByReviewer;
@@ -1633,7 +2916,7 @@ export async function ticketList( req, res ) {
 
 
       );
-    } else if ( req?.user?.userType === 'client' && inputData.tangoType !== 'internal' ) {
+    } else if ( req?.user?.userType === 'client' ) {
       searchQuery.query.bool.must.push(
           {
             term: {
@@ -1727,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 = [];
@@ -2666,7 +4097,7 @@ export async function getTaggedStores( req, res ) {
                        + (doc.containsKey('employeeCount') && !doc['employeeCount'].empty ? doc['employeeCount'].value : 0)
                           + (doc.containsKey('junkCount') && !doc['junkCount'].empty ? doc['junkCount'].value : 0);
               `,
-                  lang: 'painless',
+                  lang: 'scripting',
                 },
               },
             },
@@ -3076,6 +4507,7 @@ export async function reviewerList( req, res ) {
 export async function openTicketList( req, res ) {
   try {
     const inputData = req.body;
+    logger.info( { inputData } );
     const openSearch = JSON.parse( process.env.OPENSEARCH );
 
     // INSERT_YOUR_CODE
@@ -3122,6 +4554,7 @@ export async function openTicketList( req, res ) {
       },
     ];
 
+
     const openSearchQuery = {
       size: 10000,
       query: {
@@ -3131,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 = [