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

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.9.5-vms.76",
+    "version": "3.9.5-vms.78",
     "description": "infra",
     "main": "index.js",
     "type": "module",
     "scripts": {
-        "start": "nodemon --exec \"eslint --fix . && node app.js\""
+        "start": "nodemon --exec \"eslint --fix . && node index.js\""
     },
     "engines": {
         "node": ">=18.10.0"

package/src/controllers/footfallDirectory.controllers.js

@@ -86,6 +86,10 @@ export async function createinternalTicket( req, res ) {
       mappingInfo: [],
     };
     const id = `${inputData.storeId}_${inputData.dateString}_internal_footfall-directory-tagging`;
+    let getExistingOne = await getOpenSearchById( openSearch.footfallDirectory, id );
+    if ( getExistingOne?.body?._source ) {
+      return res.sendError( 'Ticket Already Exists', 500 );
+    }
     const insertResult = await insertWithId( openSearch.footfallDirectory, id, record );
     if ( insertResult && insertResult.statusCode === 201 ) {
       return res.sendSuccess( 'Ticket raised successfully' );
@@ -380,7 +384,8 @@ export async function tangoReviewTicket( req, res ) {
     // return;
 
     let id = `${inputData.storeId}_${inputData.dateString}_footfall-directory-tagging`;
-    if ( inputData.ticketType === 'internal' ) {
+    let getExistingOne = await getOpenSearchById( openSearch.footfallDirectory, id );
+    if ( inputData.ticketType === 'internal' &&!getExistingOne?.body?._source ) {
       id = `${inputData.storeId}_${inputData.dateString}_internal_footfall-directory-tagging`;
     }
 
@@ -718,20 +723,858 @@ export async function ticketSummary1( req, res ) {
 
 export async function ticketSummary( req, res ) {
   try {
+    const inputData = req.query;
+
     let result = '';
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
     const userInfo = req.user;
     const ticketsFeature = userInfo?.rolespermission?.some( ( f ) => f.featureName === 'FootfallDirectory' && ( f.modules.find( ( m ) => m.name == 'reviewer' && ( m.isAdd == true || m.isEdit == true ) ) ) );
+    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' ) {
+    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: '';
+      }
+      // 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 ) {
+        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 } );
+
+
+        // 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 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: 0,
-        averageAccuracyOverAll: 0,
-        openTickets: 0,
-        openInfraIssues: 0,
-        inprogress: 0,
-        closedTickets: 0,
-        ticketAccuracyAbove: '0%',
-        ticketAccuracyBelow: '0%',
+        totalTickets,
+        averageAccuracyOverAll: averageAccuracyOverAll+'%',
+        openTickets,
+        openInfraIssues,
+        inprogress,
+        closedTickets,
+        ticketAccuracyAbove: ticketAccuracyAbove+'%',
+        ticketAccuracyBelow: ticketAccuracyBelow+'%',
       };
     } else {
       result = req.user.role === 'superadmin' ?
@@ -1317,6 +2160,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;
@@ -1624,7 +2548,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: {
@@ -2657,7 +3581,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',
                 },
               },
             },
@@ -3067,6 +3991,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

package/src/dtos/footfallDirectory.dtos.js

@@ -86,7 +86,8 @@ export const tangoReviewAccuracyClosedTicketValid = {
 
 export const ticketSummarySchema = Joi.object().keys( {
   clientId: Joi.string().required(),
-
+  tangoType: Joi.string().valid( 'store', 'internal' ).optional(),
+  permissionType: Joi.string().valid( 'approve', 'review' ).optional(),
   fromDate: Joi.string()
       .pattern( /^\d{4}-\d{2}-\d{2}$/, 'YYYY-MM-DD format' )
       .required()
@@ -159,6 +160,7 @@ export const ticketListSchema = Joi.object().keys( {
   tangoType: Joi.string().valid( 'store', 'internal', '' ).optional(),
   permissionType: Joi.string().valid( 'review', 'approve' ).optional(),
   filterByStatus: Joi.string().optional().allow( '' ),
+  filterByStore: Joi.string().optional().allow( '' ),
   filterByReviewer: Joi.string().optional().allow( '' ),
   filterByApprover: Joi.string().optional().allow( '' ),
   filterByTango: Joi.string().optional().allow( '' ),