tango-app-api-audit 3.5.25 → 3.5.27

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-audit",
-    "version": "3.5.25",
+    "version": "3.5.27",
     "description": "audit & audit metrics apis",
     "main": "index.js",
     "type": "module",

package/src/controllers/eyeTestAudit.controllers.js

@@ -7,7 +7,7 @@ import timezone from 'dayjs/plugin/timezone.js';
 import 'dayjs/locale/en.js';
 import { findOneEyeTestConfig, updateOneEyeTestConfig } from '../service/eyeTestConfiguration.service.js';
 import { ObjectId } from 'mongodb';
-import { aggregateClusters } from '../service/clusters.service.js';
+import { aggregateClusters, findOneClusters } from '../service/clusters.service.js';
 
 dayjs.extend( utc );
 dayjs.extend( timezone );
@@ -1081,6 +1081,56 @@ export async function userAuditedData( req, res ) {
 export async function summaryList( req, res ) {
   try {
     const inputData = req.body;
+    if ( inputData.clientId !== '11' ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    const openSearch = JSON.parse( process.env.OPENSEARCH );
+    const limit = inputData.limit || 10;
+    const offset = inputData.offset ? ( inputData.offset - 1 ) * limit : 0;
+
+    const sortBy = inputData?.sortBy ? [ 'coveredStepsAI', 'trustScore', 'date' ].includes( inputData.sortBy ) ? inputData.sortBy :`${inputData.sortBy}.keyword` : 'storeName.keyword';
+    const order = inputData?.sortOrder || -1;
+
+    let filter= [
+      {
+        'range': {
+          'date': {
+            'gte': new Date( inputData.fromDate ),
+            'lte': new Date( inputData.toDate ),
+          },
+        },
+      },
+
+    ];
+    if ( inputData.demographics && inputData.demographics.length > 0 ) {
+      filter.push( {
+        'terms': {
+          'visitorsType.keyword': inputData.demographics,
+        },
+      } );
+    }
+    if ( inputData.type && inputData.type!='' ) {
+      filter.push( {
+        'term': {
+          'type.keyword': inputData.type,
+        },
+
+      } );
+    }
+    if ( inputData.storeId && inputData.storeId.length > 0 ) {
+      filter.push( {
+
+        'terms': {
+          'storeId.keyword': inputData.storeId,
+        },
+
+      } );
+    } else {
+      return res.sendError( 'No data found', 204 );
+    }
+
+
     if ( inputData.keyType === 'rm' ) {
       return res.sendSuccess( { result: [
         {
@@ -1095,224 +1145,338 @@ export async function summaryList( req, res ) {
 
       ], count: 1 } );
     } else if ( inputData.keyType === 'cluster' ) {
-      return res.sendSuccess( { result: [
+      const clusterQuery =[
+        { $match: { 'Teamlead.email': { $in: inputData.RMList } } },
+        { $unwind: { path: '$stores', preserveNullAndEmptyArrays: true } },
         {
-          RMName: '',
-          clusterName: '',
-          storeName: '',
-          totalFiles: 0,
-          completedFiles: 0,
-          tangoScore: 0,
-          trustScore: 0,
+          $group: {
+            _id: '$clusterName',
+            clusterName: { $first: '$clusterName' },
+            store: { $addToSet: '$stores.storeId' },
+
+          },
         },
+        { $project: {
+          RMName: inputData?.RMList[0],
+          clusterName: 1,
+          storesCount: { $size: '$store' },
+          store: 1,
+        } },
+      ];
+      const getCluster = await aggregateClusters( clusterQuery );
+      logger.info( { getCluster: getCluster } );
+      if ( !getCluster || getCluster?.length == 0 ) {
+        return res.sendError( 'No data', 400 );
+      }
+      const temp =[];
+      for ( const [ i, cluster ] of getCluster.entries() ) {
+        logger.info( { cluster: cluster } );
+        temp.push( cluster );
+        const getClusterQuery= {
+          'size': 0,
+          'query': {
+            'bool': {
+              'must': [
+                { 'terms': { 'storeId.keyword': cluster?.store } },
+                { 'term': { 'type.keyword': inputData?.type } },
+                {
+                  'range': {
+                    'date': {
+                      'gte': inputData?.fromDate,
+                      'lte': inputData?.toDate,
+                    },
+                  },
+                },
 
-      ], count: 1 } );
-    } else {
-      return res.sendSuccess( { result: [
-        {
-          'fileDate': '2025-08-19',
-          'comment': '',
-          'subComment': '',
-          'date': '2025-08-19T00:00:00.000+00:00',
-          'storeName': 'LKST886',
-          'storeId': '11-995',
-          'type': 'physical',
-          'optumId': '184812',
-          'queueId': '106906147',
-          'engagementId': '',
-          'totalSteps': 6,
-          'coveredStepsAI': 5,
-          'testDuration': 420,
-          'auditStatus': 'Yet-to-Audit',
-          'userId': null,
-          'visitorsType': 'adult',
-          'inputBucketName': 'tango-eye-test-output',
-          'filePath': 'eye-test/2025-08-19/11-995/106906147_184812.mp4',
-          'startTime': '',
-          'endTime': '',
-          'displayName': '',
-          'testStartTime': '17:13:34',
-          'testEndTime': '17:20:34',
-          'createdAt': '2025-08-20T08:05:28.188Z',
-          'updatedAt': '2025-08-20T08:05:28.188Z',
-          'steps': [
-            {
-              'processName': 'Distance-VA-Check',
-              'AIStatus': true,
-              'predictedTranscript': '',
-            },
-            {
-              'processName': 'DuoChrome-Test',
-              'AIStatus': true,
-              'predictedTranscript': '',
-            },
-            {
-              'processName': 'Torchlight',
-              'AIStatus': true,
-              'predictedTranscript': '',
+              ],
             },
-            {
-              'processName': 'JCC',
-              'AIStatus': true,
-              'predictedTranscript': '',
+          },
+          'aggs': {
+            'total_count': {
+              'value_count': { 'field': '_id' },
             },
-            {
-              'processName': 'Near-VA-Check',
-              'AIStatus': true,
-              'predictedTranscript': '',
+            'avg_complianceScore': {
+              'avg': { 'field': 'ComplianceScore' },
             },
-            {
-              'processName': 'Prescription-Verification',
-              'AIStatus': false,
-              'predictedTranscript': '',
+            'audited_trustScore': {
+              'filter': { 'terms': { 'auditStatus.keyword': [ 'Audited', 'reAudited' ] } },
+              'aggs': {
+                'avg_trustScore': {
+                  'avg': { 'field': 'trustScore' },
+                },
+                'totalCount': {
+                  'value_count': { 'field': '_id' },
+                },
+              },
             },
-          ],
+          },
+        };
+        const getResponse = await getOpenSearchData( openSearch.EyeTestInput, getClusterQuery );
+        logger.info( { getResponse: getResponse } );
+        if ( getResponse?.body?.aggregations ) {
+          delete temp[i].store;
+          delete temp[i]._id;
+          temp[i].totalFiles = getResponse?.body?.aggregations?.total_count?.value || 0,
+          temp[i].completedFiles=getResponse?.body?.aggregations?.audited_trustScore?.totalCount?.value || 0;
+          temp[i].complianceScore = getResponse?.body?.aggregations?.avg_complianceScore?.value || 0;
+          temp[i].trustScore =getResponse?.body?.aggregations?.audited_trustScore?.totalCount?.value || 'NA';
+          logger.info( { getResponse: getResponse, ms: '........1' } );
+        }
+      }
+
+      return res.sendSuccess( { result: temp, count: getCluster?.length || 0 } );
+    } else {
+      let search ={
+        'must': filter,
+      };
+      if ( inputData.searchValue && inputData.searchValue !== '' ) {
+        if ( inputData.type&&inputData.type==='remote' ) {
+          search ={
+            'must': filter,
+            'should': [
+              {
+                'wildcard': {
+                  'storeName.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+              {
+                'wildcard': {
+                  'storeId.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+              {
+                'wildcard': {
+                  'engagementId.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+
+              {
+                'wildcard': {
+                  'auditStatus.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+            ],
+            'minimum_should_match': 1,
+          };
+        } else {
+          search ={
+            'must': filter,
+            'should': [
+              {
+                'wildcard': {
+                  'storeName.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+              {
+                'wildcard': {
+                  'storeId.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+              {
+                'wildcard': {
+                  'engagementId.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+              {
+                'wildcard': {
+                  'queueId.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+              {
+                'wildcard': {
+                  'optumId.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+              {
+                'wildcard': {
+                  'visitorsType.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+
+              {
+                'wildcard': {
+                  'auditStatus.keyword': {
+                    'value': `*${inputData.searchValue}*`,
+                  },
+                },
+              },
+            ],
+            'minimum_should_match': 1,
+          };
+        }
+      }
+
+      let searchQuery={
+        'from': offset,
+        'size': limit,
+        'query': {
+          'bool': search,
         },
-        {
-          'fileDate': '2025-08-18',
-          'comment': '',
-          'subComment': '',
-          'date': '2025-08-18T00:00:00.000+00:00',
-          'storeName': 'LKST80',
-          'storeId': '11-10',
-          'type': 'physical',
-          'optumId': '164980',
-          'queueId': '106772967',
-          'engagementId': '',
-          'totalSteps': 6,
-          'coveredStepsAI': 4,
-          'testDuration': 580,
-          'auditStatus': 'Yet-to-Audit',
-          'userId': null,
-          'visitorsType': 'adult',
-          'inputBucketName': 'tango-eye-test-output',
-          'filePath': 'eye-test/2025-08-18/11-10/106772967_164980.mp4',
-          'startTime': '',
-          'endTime': '',
-          'displayName': '',
-          'testStartTime': '12:25:32',
-          'testEndTime': '12:35:12',
-          'createdAt': '2025-08-19T11:56:55.822Z',
-          'updatedAt': '2025-08-19T11:56:55.822Z',
-          'steps': [
-            {
-              'processName': 'Distance-VA-Check',
-              'AIStatus': true,
-              'predictedTranscript': '',
-            },
-            {
-              'processName': 'DuoChrome-Test',
-              'AIStatus': true,
-              'predictedTranscript': '',
-            },
-            {
-              'processName': 'Prescription-Verification',
-              'AIStatus': true,
-              'predictedTranscript': '',
-            },
-            {
-              'processName': 'Near-VA-Check',
-              'AIStatus': true,
-              'predictedTranscript': '',
-            },
-            {
-              'processName': 'Torchlight',
-              'AIStatus': false,
-              'predictedTranscript': '',
-            },
-            {
-              'processName': 'JCC',
-              'AIStatus': false,
-              'predictedTranscript': '',
-            },
+        'sort': [
+          { date: { order: 'desc' } },
+        ],
+      };
+
+      if ( sortBy && sortBy !== '' ) {
+        searchQuery={
+          'from': offset,
+          'size': limit,
+          'query': {
+            'bool': search,
+          },
+          'sort': [
+            { [sortBy]: { order: order === -1 ?'desc':'asc' } },
+            { '_id': 'asc' },
           ],
+        };
+      }
+
+      if ( inputData.isExport==true ) {
+        searchQuery={
+          'from': 0,
+          'size': 10000,
+          'query': {
+            'bool': search,
+          },
+          'sort': [
+            { 'storeName.keyword': { order: 'desc' } },
+          ],
+        };
+      // allResult =await fetchAllDocuments( openSearch.EyeTestInput, search );
+      }
+
+      const countQuery = {
+        query: {
+          bool: search,
         },
-        {
-          'fileDate': '2025-08-19',
-          'comment': 'Possible Fake Video',
-          'subComment': 'Customer not inside clinic within 120 seconds.',
-          'date': '2025-08-19T00:00:00.000+00:00',
-          'storeName': 'LKST1362',
-          'storeId': '11-1563',
-          'type': 'physical',
-          'optumId': '131354',
-          'queueId': '106907022',
-          'engagementId': '',
-          'totalSteps': 6,
-          'coveredStepsAI': 0,
-          'testDuration': 555,
-          'auditStatus': 'Yet-to-Audit',
-          'userId': null,
-          'visitorsType': 'adult',
-          'inputBucketName': 'tango-eye-test-output',
-          'filePath': 'eye-test/2025-08-19/11-1563/106907022_131354.mp4',
-          'startTime': '',
-          'endTime': '',
-          'displayName': '',
-          'testStartTime': '17:31:57',
-          'testEndTime': '17:41:12',
-          'createdAt': '2025-08-20T10:24:15.169Z',
-          'updatedAt': '2025-08-20T10:24:15.169Z',
-          'steps': [],
-        },
-        {
-          'fileDate': '2025-08-19',
-          'comment': 'Possible Fake Video',
-          'subComment': 'Customer not inside clinic within 120 seconds.',
-          'date': '2025-08-19T00:00:00.000+00:00',
-          'storeName': 'LKST1158',
-          'storeId': '11-1003',
-          'type': 'physical',
-          'optumId': '174254',
-          'queueId': '106907580',
-          'engagementId': '',
-          'totalSteps': 6,
-          'coveredStepsAI': 0,
-          'testDuration': 834,
-          'auditStatus': 'Yet-to-Audit',
-          'userId': null,
-          'visitorsType': 'adult',
-          'inputBucketName': 'tango-eye-test-output',
-          'filePath': 'eye-test/2025-08-19/11-1003/106907580_174254.mp4',
-          'startTime': '',
-          'endTime': '',
-          'displayName': '',
-          'testStartTime': '17:21:42',
-          'testEndTime': '17:35:36',
-          'createdAt': '2025-08-20T09:52:29.116Z',
-          'updatedAt': '2025-08-20T09:52:29.116Z',
-          'steps': [],
-        },
-        {
-          'fileDate': '2025-08-19',
-          'comment': 'Possible Fake Video',
-          'subComment': 'Customer not inside clinic within 120 seconds.',
-          'date': '2025-08-19T00:00:00.000+00:00',
-          'storeName': 'LKST1158',
-          'storeId': '11-1003',
-          'type': 'physical',
-          'optumId': '174254',
-          'queueId': '106878780',
-          'engagementId': '',
-          'totalSteps': 6,
-          'coveredStepsAI': 0,
-          'testDuration': 335,
-          'auditStatus': 'Yet-to-Audit',
-          'userId': null,
-          'visitorsType': 'adult',
-          'inputBucketName': 'tango-eye-test-output',
-          'filePath': 'eye-test/2025-08-19/11-1003/106878780_174254.mp4',
-          'startTime': '',
-          'endTime': '',
-          'displayName': '',
-          'testStartTime': '13:08:43',
-          'testEndTime': '13:14:18',
-          'createdAt': '2025-08-20T09:47:06.812Z',
-          'updatedAt': '2025-08-20T09:47:06.812Z',
-          'steps': [],
-        },
+      };
+
+      const result = await getOpenSearchData( openSearch.EyeTestInput, searchQuery );
+      const getCount = inputData.isExport==true? null:await getOpenSearchCount( openSearch.EyeTestInput, countQuery );
+      const count =inputData.isExport==true?null: getCount?.body?.count;
+      const searchValue = result?.body?.hits?.hits;
+      const temp =[];
+      if ( !searchValue || searchValue?.length == 0 ) {
+        return res.sendError( 'No data found', 204 );
+      }
+      if ( inputData.isExport == true ) {
+        const chunkedMappingData = await chunkArray( searchValue, 10 );
+        const promises = chunkedMappingData.map( async ( chunk ) => {
+          const exportData = [];
+          for ( const element of chunk ) {
+            const testDuration = element?._source?.testDuration;
+            const minutes = Math.floor( testDuration / 60 );
+            const seconds = testDuration % 60;
+            const minutes1 =minutes> 1? `${minutes} mins` : `${minutes} min`;
+            const seconds1 = seconds > 1? `${minutes} secs`: seconds == 1? `${minutes} sec` : '';
+            const duration =`${minutes1} ${seconds1}`;
+            let userName = '';
+            if ( element?._source?.userId&&element?._source?.userId!='' ) {
+              userName = await findOneUser( { _id: element?._source?.userId }, { _id: 0, userName: 1 } );
+            }
+
+            let RMName = '';
+            let clusterName='';
+            if ( element?._source?.storeId&&element?._source?.storeId!='' ) {
+              const getCluster = await findOneClusters( { 'stores.storeId': element?._source?.storeId }, { Teamlead: 1, clusterName: 1 } );
+              RMName =( getCluster && getCluster.Teamlead?.length > 0 )? getCluster?.Teamlead?.[0]?.email : '';
+              clusterName = getCluster?.clusterName;
+            }
+            if ( element?._source?.type == 'physical' ) {
+              exportData.push( {
+                'Date': dayjs( element?._source?.date ).format( 'D MMM, YYYY' ),
+                'RM Name': RMName,
+                'Cluster Name': clusterName,
+                'Store Name': element?._source?.storeName,
+                'Store ID': element?._source?.storeId || 'Un Assigned',
+                'Store Name': element?._source?.storeName ||'Un Assigned',
+                'Optum ID': element?._source?.optumId,
+                'Queue ID': element?._source?.queueId,
+                'Compliance Score': element?._source?.totalSteps>0 ? Math.round( ( element?._source?.coveredStepsAI/ element?._source?.totalSteps )*100 ): 0,
+                'Steps Covered By AI': element?._source?.coveredStepsAI || 0,
+                'Trust Score': element?._source?.trustScore || 0,
+                'Visitor Type': element?._source?.visitorsType,
+                'Test Duration': duration || '',
+                'Audit Status': element?._source?.auditStatus || '',
+                'Audited By': userName?.userName || '',
+
+              } );
+            } else {
+              exportData.push( {
+                'Date': dayjs( element?._source?.date ).format( 'D MMM, YYYY' ),
+                'Cluster Name': clusterName,
+                'Store Name': element?._source?.storeName,
+                'Store Name': element?._source?.storeName,
+                'Store ID': element?._source?.storeId || 'Un Assigned',
+                'Store Name': element?._source?.storeName ||'Un Assigned',
+                'Engagement ID': element?._source?.engagementId,
+                'Compliance Score': element?._source?.totalSteps>0 ? Math.round( ( element?._source?.coveredStepsAI/ element?._source?.totalSteps )*100 ): 0,
+                'Steps Covered By AI': element?._source?.coveredStepsAI || 0,
+                'Trust Score': element?._source?.trustScore ||0,
+                'Test Duration': duration || '',
+                'Audit Status': element?._source?.auditStatus || '',
+                'Audited By': userName?.userName || '',
+
+              } );
+            }
+          }
+          return exportData;
+        } );
+        const mappedArrays = await Promise.all( promises );
+        const result = mappedArrays.flat();
+        await download( result, res );
+        return;
+      } else {
+        for ( const [ i, item ] of searchValue.entries() ) {
+          temp.push( item?._source );
+          logger.info( { source: item } );
+          let userName='';
+          if ( item?._source?.userId&&item?._source?.userId!='' ) {
+            userName = await findOneUser( { _id: item?._source?.userId }, { _id: 0, userName: 1 } );
+          }
+          let RMName = '';
+          let clusterName='';
+          if ( item?._source?.storeId&&item?._source?.storeId!='' ) {
+            const getCluster = await findOneClusters( { 'stores.storeId': item?._source?.storeId }, { Teamlead: 1, clusterName: 1 } );
+            RMName =( getCluster && getCluster.Teamlead?.length > 0 )? getCluster?.Teamlead?.[0]?.email : '';
+            clusterName = getCluster?.clusterName;
+          }
+          logger.info( { RMName: RMName } );
+          const testDuration = item?._source?.testDuration;
+          const minutes = Math.floor( testDuration / 60 );
+          const seconds = testDuration % 60;
+          temp[i].complianceScore = item?._source?.totalSteps>0 ? Math.round( ( item?._source?.coveredStepsAI/ item?._source?.totalSteps )*100 ): 0;
+          temp[i].min = minutes;
+          temp[i].sec = seconds;
+          temp[i].auditedBy = userName?.userName || '';
+          temp[i].date = dayjs( item?._source?.date ).format( 'D MMM, YYYY' );
+          temp[i].RMName = RMName;
+          temp[i].clusterName =clusterName;
+        }
+        logger.info( { temp: temp } );
+      }
 
-      ], count: 14 } );
+      return res.sendSuccess( { result: temp, count: count } );
     }
   } catch ( error ) {
     const err = error.message || 'Internal Server Error';

package/src/service/clusters.service.js

@@ -5,6 +5,10 @@ export function aggregateClusters( query ) {
   return clusterModel.aggregate( query, { collation: { locale: 'en', strength: 2 } } );
 }
 
-export function findClusters( query ) {
+export function findClusters( query, field ) {
   return clusterModel.find( query, field );
 }
+
+export function findOneClusters( query, field ) {
+  return clusterModel.findOne( query, field ).sort( { _id: -1 } );
+}