tango-app-api-infra 3.9.5-vms.83 → 3.9.5-vms.85

package/src/controllers/footfallDirectory.controllers.js

@@ -312,6 +312,33 @@ export async function tangoReviewTicket( req, res ) {
 
         record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
           ...temp ];
+
+        if ( Array.isArray( record.mappingInfo ) ) {
+          record.mappingInfo = record.mappingInfo.map( ( item ) => {
+            return {
+              ...item,
+              status: item.type === 'approve'? 'Tango Review Done':'Closed',
+            };
+          } );
+        }
+
+        record.mappingInfo.push(
+            {
+              type: 'finalRevision',
+              mode: inputData.mappingInfo?.mode,
+              revicedFootfall: revisedFootfall,
+              revicedPerc: inputData.mappingInfo?.revicedPerc,
+              count: inputData.mappingInfo?.count,
+              revisedDetail: inputData.mappingInfo?.revisedDetail,
+              status: 'Closed',
+              createdByEmail: req?.user?.email,
+              createdByUserName: req?.user?.userName,
+              createdByRole: req?.user?.role,
+              createdAt: new Date(),
+            },
+
+
+        );
       }
     } else {
       if ( Array.isArray( record.mappingInfo ) ) {
@@ -392,7 +419,7 @@ export async function tangoReviewTicket( req, res ) {
     const insertResult = await updateOpenSearchData( openSearch.footfallDirectory, id, { doc: record } );
 
     if ( insertResult && ( insertResult.statusCode === 201 || insertResult.statusCode === 200 ) ) {
-      if ( record.status = 'Closed' && inputData.ticketType !== 'internal' ) {
+      if ( ( record.status === 'Closed' || record.status === 'Open - Accuracy Issue' ) && inputData.ticketType !== 'internal' ) {
         const query = {
           storeId: inputData?.storeId,
           isVideoStream: true,
@@ -532,7 +559,7 @@ export async function tangoReviewAccuracyClosedTicket( req, res ) {
         },
       },
     };
-    if ( Ticket[0]?._source?.type != 'internal' ) {
+    if ( Ticket[0]?._source?.type !== 'internal' ) {
       getTicket.query.bool.must.push(
           {
             nested: {
@@ -576,22 +603,24 @@ export async function tangoReviewAccuracyClosedTicket( req, res ) {
           .filter( ( item ) => item.type === 'tangoreview' )
           .map( ( item ) => ( {
             ...item,
-            status: 'Closed',
+            status: 'Closed - Accuracy Issue',
             createdByEmail: req?.user?.email,
             createdByUserName: req?.user?.userName,
             createdByRole: req?.user?.role,
+            comments: inputData?.comments || '',
+            subComments: inputData?.subComments ||'',
           } ) );
 
       record.mappingInfo = [ ...ticketData?.[0]?._source?.mappingInfo.slice( 0, -1 ),
         ...temp ];
-      if ( Array.isArray( record.mappingInfo ) ) {
-        record.mappingInfo = record.mappingInfo.map( ( item ) => {
-          return {
-            ...item,
-            status: 'Closed',
-          };
-        } );
-      }
+      // if ( Array.isArray( record.mappingInfo ) ) {
+      //   record.mappingInfo = record.mappingInfo.map( ( item ) => {
+      //     return {
+      //       ...item,
+      //       status: 'Closed',
+      //     };
+      //   } );
+      // }
 
       record.mappingInfo.push(
           {
@@ -606,6 +635,8 @@ export async function tangoReviewAccuracyClosedTicket( req, res ) {
             createdByUserName: req?.user?.userName,
             createdByRole: req?.user?.role,
             createdAt: new Date(),
+            comments: inputData?.comments || '',
+            subComments: inputData?.subComments || '',
           },
       );
     }
@@ -871,9 +902,13 @@ export async function ticketSummary( req, res ) {
     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 getConfig = await findOneClient( { clientId: inputData?.clientId }, { footfallDirectoryConfigs: 1 } );
+    if ( !getConfig || getConfig ==null ) {
+      return res.sendError( 'this client not configured against footfall directory', 400 );
+    }
+    inputData.clientId = inputData?.clientId?.split( ',' );
     // 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 = {
@@ -890,6 +925,24 @@ export async function ticketSummary( req, res ) {
                       },
                     },
                   },
+
+                  {
+                    terms: {
+                      'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                        inputData.clientId :
+                        [ inputData.clientId ],
+                    },
+
+                  },
+
+                  {
+                    range: {
+                      reviced: {
+                        lt: parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview ),
+                      }
+                      ,
+                    },
+                  },
                   {
                     nested: {
                       path: 'mappingInfo',
@@ -952,20 +1005,7 @@ export async function ticketSummary( req, res ) {
               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; 
-  }
-          `,
-                    },
-                  },
+                  avg: 'reviced',
                 },
               },
             };
@@ -998,11 +1038,10 @@ export async function ticketSummary( req, res ) {
           // openInfraIssues: mappingInfo.status: 'Open Accuracy Issue'
           let openInfraIssues = 0;
 
-          let oiQ = buildStoreQueryWithStatus( baseStoreQuery, 'Open Accuracy Issue' );
+          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;
 
@@ -1032,14 +1071,9 @@ export async function ticketSummary( req, res ) {
           // 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 },
+              range: {
+                reviced: {
+                  gte: parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview ),
                 },
               },
             },
@@ -1054,14 +1088,9 @@ export async function ticketSummary( req, res ) {
 
           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 },
+              range: {
+                reviced: {
+                  lt: parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview ),
                 },
               },
             },
@@ -1097,23 +1126,48 @@ export async function ticketSummary( req, res ) {
                       },
                     },
                   },
+                  {
+                    terms: {
+                      'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                        inputData.clientId :
+                        [ inputData.clientId ],
+                    },
+
+                  },
+
+                ],
+              },
+            },
+          };
 
+          const internalOpen = {
+            size: 0,
+            query: {
+              bool: {
+                must: [
                   {
-                    nested: {
-                      path: 'mappingInfo',
-                      query: {
-                        bool: {
-                          must: [
-                            {
-                              terms: {
-                                'mappingInfo.type': [ 'tagging', 'review', 'approve', 'tangoreview' ],
-                              },
-                            },
-                          ],
-                        },
+                    'range': {
+                      'dateString': {
+                        'gte': inputData?.fromDate,
+                        'lte': inputData?.toDate,
+                        'format': 'yyyy-MM-dd',
                       },
                     },
                   },
+                  {
+                    terms: {
+                      'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                        inputData.clientId :
+                        [ inputData.clientId ],
+                    },
+
+                  },
+                  {
+                    terms: {
+                      'status.keyword': [ 'Open', 'Raised' ],
+                    },
+
+                  },
 
                 ],
               },
@@ -1123,20 +1177,32 @@ export async function ticketSummary( req, res ) {
           // 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
+            // Check if nested query exists, if not create it
             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,
+            if ( !nested ) {
+              // Create nested query structure
+              nested = {
+                nested: {
+                  path: 'mappingInfo',
+                  query: {
+                    bool: {
+                      must: [],
+                    },
+                  },
                 },
-              } );
+              };
+              q.query.bool.must.push( 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;
           }
 
@@ -1152,7 +1218,7 @@ export async function ticketSummary( req, res ) {
                 nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
 
               // add new filters
-              nested.nested.query.bool.must.push( ...filters );
+              q.query.bool.must.push( ...filters );
             }
 
             return {
@@ -1161,18 +1227,7 @@ export async function ticketSummary( req, res ) {
               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; 
-  }
-          `,
-                    },
+                    field: 'reviced',
                   },
                 },
               },
@@ -1193,13 +1248,14 @@ export async function ticketSummary( req, res ) {
           allInternalQuery.size = 0;
           const totalInternalResp = await getOpenSearchData( openSearch.footfallDirectory, allInternalQuery );
           totalInternalTickets = totalInternalResp?.body?.hits?.total?.value || 0;
+          logger.info( { totalInternalResp } );
 
           // openTickets: mappingInfo.status: 'Open'
           let openInternalTickets = 0;
 
-          let otQInternal = buildInternalQueryWithStatus( baseInternalQuery, 'Open' );
-          otQInternal.size = 0;
-          const openInternalResp = await getOpenSearchData( openSearch.footfallDirectory, otQInternal );
+          // let otQInternal = buildInternalQueryWithStatus( baseInternalQuery, 'Open' );
+          // otQInternal.size = 0;
+          const openInternalResp = await getOpenSearchData( openSearch.footfallDirectory, internalOpen );
           openInternalTickets = openInternalResp?.body?.hits?.total?.value || 0;
           // logger.info( { msd: '..............2', openResp } );
 
@@ -1207,11 +1263,12 @@ export async function ticketSummary( req, res ) {
           // openInfraIssues: mappingInfo.status: 'Open Accuracy Issue'
           let openInternalInfraIssues = 0;
 
-          let oiQinternal = buildInternalQueryWithStatus( baseInternalQuery, 'Open Accuracy Issue' );
+          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;
 
@@ -1241,14 +1298,9 @@ export async function ticketSummary( req, res ) {
           // 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 },
+              range: {
+                reviced: {
+                  gte: parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview ),
                 },
               },
             },
@@ -1263,14 +1315,9 @@ export async function ticketSummary( req, res ) {
 
           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 },
+              range: {
+                reviced: {
+                  lt: parseInt( getConfig?.footfallDirectoryConfigs?.tangoReview ),
                 },
               },
             },
@@ -1293,8 +1340,10 @@ export async function ticketSummary( req, res ) {
           break;
         default: '';
       }
-    } else if ( req?.user?.userType === 'client' ) {
+    } else if ( req?.user?.userType === 'tango' ) {
+      logger.info( { msg: '.........1', ticketsFeature, ticketsApproveFeature } );
       if ( ticketsFeature && !ticketsApproveFeature ) {
+        logger.info( '.........3' );
         const storeQuery = {
           size: 0,
           query: {
@@ -1309,6 +1358,14 @@ export async function ticketSummary( req, res ) {
                     },
                   },
                 },
+                {
+                  terms: {
+                    'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                      inputData.clientId :
+                      [ inputData.clientId ],
+                  },
+
+                },
                 {
                   nested: {
                     path: 'mappingInfo',
@@ -1371,20 +1428,7 @@ export async function ticketSummary( req, res ) {
             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; 
-}
-        `,
-                  },
-                },
+                avg: 'mappingInfo.reviced',
               },
             },
           };
@@ -1459,48 +1503,44 @@ try {
         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: {
+        // Calculate average ticket percentage: avg((reviced/footfallCount)*100) filtered by baseStoreQuery
+
+        // Build aggregation query for ticket percentage
+        let ticketPercentageAvg = 0;
+
+        let avgTicketPercentageQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+        avgTicketPercentageQuery.size = 0;
+        avgTicketPercentageQuery.aggs = {
+          avg_ticket_percentage: {
+            avg: {
               script: {
-                lang: 'painless',
                 source: `
-                  doc['revicedPerc.keyword'].size()!=0 &&
-                  Integer.parseInt(doc['revicedPerc.keyword'].value.replace('%','')) >= params.num
+                  if (doc.containsKey('reviced') && doc['reviced'].size()!=0 && 
+                      doc.containsKey('footfallCount') && doc['footfallCount'].size()!=0 && doc['footfallCount'].value != 0) {
+                    return (doc['reviced'].value / doc['footfallCount'].value) * 100;
+                  } else {
+                    return null;
+                  }
                 `,
-                params: { num: 85 },
+                lang: 'painless',
               },
             },
           },
+        };
 
+        const avgTicketPercentageResp = await getOpenSearchData( openSearch.footfallDirectory, avgTicketPercentageQuery );
 
-        ] );
-        const aboveResp = await getOpenSearchData( openSearch.footfallDirectory, aboveQ );
-        ticketAccuracyAbove = aboveResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+        ticketPercentageAvg = avgTicketPercentageResp?.body?.aggregations?.avg_ticket_percentage?.value?.toFixed( 2 ) || '0';
 
+        logger.info( { avgTicketPercentageResp } );
         // 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';
+        let ticketAccuracy = 0;
 
+        let belowQ = buildAggStoreQuery( baseStoreQuery );
+        logger.info( { belowQ } );
+        const accuracyResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
+        ticketAccuracy = accuracyResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+        logger.info( { accuracyResp } );
         // Final result object
         result = {
           totalTickets,
@@ -1509,465 +1549,435 @@ try {
           closedTickets,
           dueToday: dueToday,
           Expired: expiredTickets,
-          avgTicket: ticketAccuracyAbove+'%',
-          avgAccuracy: ticketAccuracyBelow+'%',
+          avgTicket: ticketPercentageAvg+'%',
+          avgAccuracy: ticketAccuracy+'%',
         };
-      }
-    } 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',
+      } else if ( ticketsFeature && ticketsApproveFeature ) {
+        logger.info( '.........2' );
+        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',
+                  {
+                    terms: {
+                      'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                        inputData.clientId :
+                        [ inputData.clientId ],
+                    },
+
+                  },
+                  {
+                    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 );
+          // 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;
+          }
 
-          if ( nested ) {
-            // remove old status filters
-            nested.nested.query.bool.must =
-              nested.nested.query.bool.must.filter( ( m ) => !( m.term && m.term['mappingInfo.status'] ) );
+          const buildAggStoreQuery = ( baseQuery, filters = [] ) => {
+            const q = JSON.parse( JSON.stringify( baseQuery ) );
 
-            // add new filters
-            nested.nested.query.bool.must.push( ...filters );
-          }
+            // locate nested section
+            const nested = q.query.bool.must.find( ( m ) => m.nested );
 
-          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; 
-  }
-        `,
-                  },
+            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: 'mappingInfo.reviced',
                 },
               },
-            },
+            };
           };
-        };
-
 
-        // Get OpenSearch connection
 
-        const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
-
-        // Total Tickets (all tickets with mappingInfo.type == tangoreview)
-        let totalTickets = 0;
+          // Get OpenSearch connection
 
-        let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
 
-        allQuery.size = 0;
-        const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
-        totalTickets = totalResp?.body?.hits?.total?.value || 0;
+          // Total Tickets (all tickets with mappingInfo.type == tangoreview)
+          let totalTickets = 0;
 
-        // openTickets: mappingInfo.status: 'Open'
-        let openTickets = 0;
+          let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
 
-        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 } );
+          allQuery.size = 0;
+          const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
+          totalTickets = totalResp?.body?.hits?.total?.value || 0;
 
+          // openTickets: mappingInfo.status: 'Open'
+          let openTickets = 0;
 
-        // inprogress: mappingInfo.status: 'in-Progress'
-        let inprogress = 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 } );
 
-        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;
+          // inprogress: mappingInfo.status: 'in-Progress'
+          let inprogress = 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 ipQ = buildStoreQueryWithStatus( baseStoreQuery, 'In-Progress' );
+          ipQ.size = 0;
+          const ipResp = await getOpenSearchData( openSearch.footfallDirectory, ipQ );
+          inprogress = ipResp?.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 );
+          // closedTickets: mappingInfo.status: 'closed'
+          let closedTickets = 0;
 
-        // Build a query for tickets with mappingInfo.dueDate == todayDateString
-        let dueTodayQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
-        // Locate nested mappingInfo query
-        let nestedDue = dueTodayQuery.query.bool.must.find( ( m ) => m.nested );
-        if ( nestedDue ) {
-          // Remove any previous mappingInfo.dueDate term
-          nestedDue.nested.query.bool.must = nestedDue.nested.query.bool.must.filter(
-              ( mustItem ) => !( mustItem.term && mustItem.term['mappingInfo.dueDate'] ),
-          );
-          // Add new dueDate filter
-          nestedDue.nested.query.bool.must.push( {
-            term: { 'mappingInfo.dueDate': todayDateString },
-          } );
-        }
-        dueTodayQuery.size = 0;
-        const dueTodayResp = await getOpenSearchData( openSearch.footfallDirectory, dueTodayQuery );
-        dueToday = dueTodayResp?.body?.hits?.total?.value || 0;
+          let 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;
+          // 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 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;
+          // Calculate average ticket percentage: avg((reviced/footfallCount)*100) filtered by baseStoreQuery
 
+          // Build aggregation query for ticket percentage
+          let ticketPercentageAvg = 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 },
+          let avgTicketPercentageQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          avgTicketPercentageQuery.size = 0;
+          avgTicketPercentageQuery.aggs = {
+            avg_ticket_percentage: {
+              avg: {
+                script: {
+                  source: `
+                    if (doc.containsKey('reviced') && doc['reviced'].size()!=0 && 
+                        doc.containsKey('footfallCount') && doc['footfallCount'].size()!=0 && doc['footfallCount'].value != 0) {
+                      return (doc['reviced'].value / doc['footfallCount'].value) * 100;
+                    } else {
+                      return null;
+                    }
+                  `,
+                  lang: 'painless',
+                },
               },
             },
-          },
-
-
-        ] );
-        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;
+          const avgTicketPercentageResp = await getOpenSearchData( openSearch.footfallDirectory, avgTicketPercentageQuery );
 
-        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 },
-              },
-            },
-          },
+          ticketPercentageAvg = avgTicketPercentageResp?.body?.aggregations?.avg_ticket_percentage?.value?.toFixed( 2 ) || '0';
 
-        ] );
-        const belowResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
-        ticketAccuracyBelow = belowResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          logger.info( { avgTicketPercentageResp } );
+          // ticketAccuracyBelow: avg of revicedPerc < 85%
+          let ticketAccuracy = 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',
+          let belowQ = buildAggStoreQuery( baseStoreQuery );
+          logger.info( { belowQ } );
+          const accuracyResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
+          ticketAccuracy = accuracyResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          logger.info( { accuracyResp } );
+          // Final result object
+          result = {
+            totalTickets,
+            openTickets,
+            inprogress,
+            closedTickets,
+            dueToday: dueToday,
+            Expired: expiredTickets,
+            avgTicket: ticketPercentageAvg+'%',
+            avgAccuracy: ticketAccuracy+'%',
+          };
+        } 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',
+                  {
+                    terms: {
+                      'clientId.keyword': Array.isArray( inputData.clientId ) ?
+                        inputData.clientId :
+                        [ inputData.clientId ],
+                    },
+
+                  },
+                  {
+                    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,
-              },
-            } );
+          // 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;
           }
-          return q;
-        }
 
-        const buildAggStoreQuery = ( baseQuery, filters = [] ) => {
-          const q = JSON.parse( JSON.stringify( baseQuery ) );
+          const buildAggStoreQuery = ( baseQuery, filters = [] ) => {
+            const q = JSON.parse( JSON.stringify( baseQuery ) );
 
-          // locate nested section
-          const nested = q.query.bool.must.find( ( m ) => m.nested );
+            // 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'] ) );
+            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 );
-          }
+              // 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; 
-  }
-        `,
-                  },
+            return {
+              ...q,
+              size: 0,
+              aggs: {
+                avg_value: {
+                  avg: 'mappingInfp.reviced',
                 },
               },
-            },
+            };
           };
-        };
 
 
-        // Get OpenSearch connection
-
-        const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
+          // Get OpenSearch connection
 
-        // Total Tickets (all tickets with mappingInfo.type == tangoreview)
-        let totalTickets = 0;
+          const baseStoreQuery = JSON.parse( JSON.stringify( storeQuery ) );
 
-        let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          // Total Tickets (all tickets with mappingInfo.type == tangoreview)
+          let totalTickets = 0;
 
-        allQuery.size = 0;
-        const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
-        totalTickets = totalResp?.body?.hits?.total?.value || 0;
+          let allQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
 
-        // openTickets: mappingInfo.status: 'Open'
-        let openTickets = 0;
+          allQuery.size = 0;
+          const totalResp = await getOpenSearchData( openSearch.footfallDirectory, allQuery );
+          totalTickets = totalResp?.body?.hits?.total?.value || 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 } );
+          // 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;
+          // inprogress: mappingInfo.status: 'in-Progress'
+          let inprogress = 0;
 
-        // closedTickets: mappingInfo.status: 'closed'
-        let closedTickets = 0;
+          let ipQ = buildStoreQueryWithStatus( baseStoreQuery, 'In-Progress' );
+          ipQ.size = 0;
+          const ipResp = await getOpenSearchData( openSearch.footfallDirectory, ipQ );
+          inprogress = ipResp?.body?.hits?.total?.value || 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 );
+          // closedTickets: mappingInfo.status: 'closed'
+          let closedTickets = 0;
 
-        // Build a query for tickets with mappingInfo.dueDate == todayDateString
-        let dueTodayQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
-        // Locate nested mappingInfo query
-        let nestedDue = dueTodayQuery.query.bool.must.find( ( m ) => m.nested );
-        if ( nestedDue ) {
-          // Remove any previous mappingInfo.dueDate term
-          nestedDue.nested.query.bool.must = nestedDue.nested.query.bool.must.filter(
-              ( mustItem ) => !( mustItem.term && mustItem.term['mappingInfo.dueDate'] ),
-          );
-          // Add new dueDate filter
-          nestedDue.nested.query.bool.must.push( {
-            term: { 'mappingInfo.dueDate': todayDateString },
-          } );
-        }
-        dueTodayQuery.size = 0;
-        const dueTodayResp = await getOpenSearchData( openSearch.footfallDirectory, dueTodayQuery );
-        dueToday = dueTodayResp?.body?.hits?.total?.value || 0;
+          let 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;
 
 
-        // filter expired Tickets
-        let expiredTickets = 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 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
+          // filter under tango review
 
-        let undertangoTickets = 0;
+          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;
+          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 },
+          let ticketPercentageAvg =0;
+          let avgTicketPercentageQuery = JSON.parse( JSON.stringify( baseStoreQuery ) );
+          avgTicketPercentageQuery.size = 0;
+          avgTicketPercentageQuery.aggs = {
+            avg_ticket_percentage: {
+              avg: {
+                script: {
+                  source: `
+                    if (doc.containsKey('reviced') && doc['reviced'].size()!=0 && 
+                        doc.containsKey('footfallCount') && doc['footfallCount'].size()!=0 && doc['footfallCount'].value != 0) {
+                      return (doc['reviced'].value / doc['footfallCount'].value) * 100;
+                    } else {
+                      return null;
+                    }
+                  `,
+                  lang: 'painless',
+                },
               },
             },
-          },
-
+          };
 
-        ] );
+          const avgTicketPercentageResp = await getOpenSearchData( openSearch.footfallDirectory, avgTicketPercentageQuery );
 
-        const aboveResp = await getOpenSearchData( openSearch.footfallDirectory, aboveQ );
-        ticketAccuracyAbove = aboveResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          ticketPercentageAvg = avgTicketPercentageResp?.body?.aggregations?.avg_ticket_percentage?.value?.toFixed( 2 ) || '0';
+          logger.info( { avgTicketPercentageResp } );
+          let ticketAccuracy = 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,
-          underTangoReview: undertangoTickets,
-          avgTicket: ticketAccuracyAbove+'%',
-          avgAccuracy: ticketAccuracyBelow+'%',
-        };
+          let belowQ = buildAggStoreQuery( baseStoreQuery );
+          logger.info( { belowQ } );
+          const accuracyResp = await getOpenSearchData( openSearch.footfallDirectory, belowQ );
+          ticketAccuracy = accuracyResp?.body?.aggregations?.avg_value?.value?.toFixed( 2 ) || '0';
+          logger.info( { accuracyResp } );
+          // Final result object
+          result = {
+            totalTickets,
+            openTickets,
+            inprogress,
+            closedTickets,
+            dueToday: dueToday,
+            Expired: expiredTickets,
+            underTangoReview: undertangoTickets,
+            avgTicket: ticketPercentageAvg+'%',
+            avgAccuracy: ticketAccuracy+'%',
+          };
+        }
       }
     }
 
@@ -2209,7 +2219,6 @@ export async function ticketList( req, res ) {
     const offset = inputData.offset == 0 ? 0 : ( inputData.offset - 1 ) * limit || 0;
     inputData.clientId = inputData?.clientId?.split( ',' ); // convert strig to array
 
-
     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 ) ) ) );
@@ -3034,6 +3043,8 @@ export async function ticketList( req, res ) {
               '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 || '--',
+              'Comments': item?.mappingInfo?.find( ( f ) => f.type === 'finalRevision' )?.comments || '--',
+              'Sub Comments': item?.mappingInfo?.find( ( f ) => f.type === 'finalRevision' )?.subComments || '--',
 
             } );
           }
@@ -3054,6 +3065,8 @@ export async function ticketList( req, res ) {
               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 || '--',
+              comments: item?.mappingInfo?.find( ( f ) => f.type === 'finalRevision' )?.comments || '--',
+              subComments: item?.mappingInfo?.find( ( f ) => f.type === 'finalRevision' )?.subComments || '--',
 
             } );
           }
@@ -4891,7 +4904,7 @@ export async function updateUserTicketStatus( req, res ) {
 
     const updatePayload = {
       doc: {
-        status: 'In-Progress',
+        status: lastEntry?.type == 'review'? 'Reviewer In progress':lastEntry?.type == 'approve'? 'Approver In progress':ticketSource?.status,
         mappingInfo: updatedMappingInfo,
         updatedAt: currentTime,
       },