tango-app-api-audit 3.6.57 → 3.6.58

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-audit",
-    "version": "3.6.57",
+    "version": "3.6.58",
     "description": "audit & audit metrics apis",
     "main": "index.js",
     "type": "module",
@@ -28,7 +28,7 @@
         "nodemailer": "^7.0.10",
         "nodemon": "^3.1.3",
         "swagger-ui-express": "^5.0.1",
-        "tango-api-schema": "^2.5.27",
+        "tango-api-schema": "^2.6.41",
         "tango-app-api-middleware": "^3.6.18",
         "winston": "^3.13.0",
         "winston-daily-rotate-file": "^5.0.0"

package/src/controllers/audit.controllers.js

@@ -73,6 +73,7 @@ import { aggregateTraxAuditData, findOneTraxAuditData } from '../service/traxAud
 import { bulkWriteAuditUserWallet, createAuditUserWallet, findOneAuditUserWallet } from '../service/auditUserWallet.service.js';
 import { updateOneAuditUsers } from '../service/auditUsers.service.js';
 import { bulkUpdate, clearScroll, upsertOpenSearchData, scrollResponse, searchOpenSearchData, updateOpenSearchData } from 'tango-app-api-middleware/src/utils/openSearch.js';
+
 // import { aggregateAuditUsers } from '../service/auditUsers.service.js';
 
 /*           < -- *** Configuration ***   -->      */
@@ -937,7 +938,8 @@ export async function getFilterData( msg, user ) {
           ( item ) =>
             item.temp_ids < 20000 &&
           item.temp_ids > 0 &&
-          item.person_status === '',
+          item.person_status === '' &&
+          item.query_status !== '',
       );
       const finalResult = await filterData.map( ( i ) => {
         return { ...i, img: i.index.concat( '_', i.temp_ids ) };
@@ -1084,9 +1086,14 @@ export async function workSpace( req, res ) {
     const dateRange = await getDate( new Date(), new Date() );
     const filter = [
       { status: { $in: [ 'active', 'hold' ] } },
-      { 'auditConfigs.audit': { $eq: true } },
       { clientId: { $in: inputData.clientId } },
     ];
+    if ( [ 'traffic', 'zone' ].includes( inputData?.moduleType ) ) {
+      filter.push( { 'auditConfigs.audit': { $eq: true } } );
+    }
+    if ( inputData?.moduleType === 'track' ) {
+      filter.push( { 'auditConfigs.trackAudit': { $eq: true } } );
+    }
 
     const temp = [];
     const clientQuery = [
@@ -2560,26 +2567,31 @@ export async function clientMetrics( req, res ) {
       { moduleType: { $eq: inputData.moduleType } },
     ];
 
-    let storeAuditFilter = [
-      { $eq: [ '$clientId', '$$clientId' ] },
-      { $eq: [ '$fileDate', '$$fileDate' ] },
-      {
-        $eq: [ '$moduleType', inputData.moduleType ],
-      },
-
-    ];
-
     if ( inputData?.filterByClient?.length > 0 ) {
       filter.push(
           { clientId: { $in: inputData.filterByClient } },
       );
     }
-    const query = [
-      {
-        $match: {
-          $and: filter,
-        },
-      },
+
+    // Only show clients enabled for audit ("access" clients): traffic/zone use
+    // auditConfigs.audit, track uses auditConfigs.trackAudit.
+    const clientAccessFilter = [];
+    if ( [ 'traffic', 'zone' ].includes( inputData?.moduleType ) ) {
+      clientAccessFilter.push( { 'auditConfigs.audit': { $eq: true } } );
+    }
+    if ( inputData?.moduleType === 'track' ) {
+      clientAccessFilter.push( { 'auditConfigs.trackAudit': { $eq: true } } );
+    }
+    if ( clientAccessFilter.length > 0 ) {
+      const accessClients = await aggregateClient( [
+        { $match: { $and: clientAccessFilter } },
+        { $project: { _id: 0, clientId: 1 } },
+      ] );
+      filter.push( { clientId: { $in: accessClients.map( ( c ) => c.clientId ) } } );
+    }
+    // --- Base metrics from auditStoreData (one indexed aggregation) --------
+    const baseQuery = [
+      { $match: { $and: filter } },
       {
         $group: {
           _id: { clientId: '$clientId', fileDate: '$fileDate', moduleType: '$moduleType' },
@@ -2592,181 +2604,125 @@ export async function clientMetrics( req, res ) {
           totalFilesCount: { $sum: 1 },
         },
       },
+    ];
+
+    // --- Store status counts from storeAudit (one indexed aggregation) -----
+    // Replaces the old correlated per-group $lookup: instead of running a
+    // sub-query for every client/date group, aggregate storeAudit once over the
+    // same filter and merge by clientId+fileDate in JS below. storeAudit has the
+    // same clientId / moduleType / fileDateISO fields, so `filter` applies as-is.
+    const storeAuditQuery = [
+      { $match: { $and: filter } },
       {
-        $project: {
-          fileDate: 1,
-          clientId: 1,
-          clientName: 1,
-          queueName: 1,
-          installedStore: 1,
-          totalFilesCount: 1,
-          moduleType: 1,
-          notAssignedCount: { $ifNull: [ 0, 0 ] },
-          clientStatus: { $ifNull: [ '', '' ] },
+        $group: {
+          _id: { clientId: '$clientId', fileDate: '$fileDate' },
+          clientId: { $first: '$clientId' },
+          fileDate: { $first: '$fileDate' },
+          completedStores: { $sum: { $cond: [ { $eq: [ '$status', 'completed' ] }, 1, 0 ] } },
+          notAssignedStores: { $sum: { $cond: [ { $eq: [ '$status', 'not_assign' ] }, 1, 0 ] } },
+          inprogressStores: { $sum: { $cond: [ { $in: [ '$status', [ 'inprogress', 'drafted', 'assigned' ] ] }, 1, 0 ] } },
+          fileCount: { $sum: 1 },
         },
       },
-      {
-        $lookup: {
-          'from': 'storeAudit',
-          'let': { clientId: '$clientId', fileDate: '$fileDate', totalAuditFiles: '$totalFilesCount' },
-          'pipeline': [
+    ];
 
-            {
-              $match: {
-                $expr: {
-                  $and: storeAuditFilter,
-                },
-              },
-            },
-            {
-              $project: {
-                completedStores: { $cond: [ { $eq: [ '$status', 'completed' ] }, 1, 0 ] },
-                notAssignedStores: { $cond: [ { $eq: [ '$status', 'not_assign' ] }, 1, 0 ] },
-                inprogressStores: { $cond: [ { $in: [ '$status', [ 'inprogress', 'drafted', 'assigned' ] ] }, 1, 0 ] },
-              },
-            },
-            {
-              $group: {
-                _id: { clientId: '$clientId', fileDate: '$fileDate' },
-                completedStores: { $sum: '$completedStores' },
-                inprogressStores: { $sum: '$inprogressStores' },
-                notAssignedStores: { $sum: '$notAssignedStores' },
-                fileCount: { $sum: 1 },
-              },
-            },
-            {
-              $project: {
-                _id: 0,
-                completedStores: 1,
-                inprogressStores: 1,
-                notAssignedStores: 1,
-                fileCount: { $ifNull: [ '$fileCount', 0 ] },
-                completionPercentage: {
-                  $ifNull: [
-                    {
-                      $round: [ {
-                        $multiply: [
-                          100, {
-                            $divide: [
-                              '$completedStores', '$$totalAuditFiles',
-                            ],
-                          },
-                        ],
-                      }, 1 ],
+    const [ baseRows, storeRows ] = await Promise.all( [
+      aggregateAuditStoreData( baseQuery ),
+      aggregateStoreAudit( storeAuditQuery ),
+    ] );
 
-                    },
-                    0,
-                  ],
-                },
-              },
-            },
-          ], 'as': 'storeAudit',
-        },
-      },
-      {
-        $unwind: {
-          path: '$storeAudit',
-          preserveNullAndEmptyArrays: true,
-        },
-      },
-      {
-        $project: {
-          _id: 0,
-          fileDate: 1,
-          clientId: 1,
-          clientName: 1,
-          totalFilesCount: 1,
-          moduleType: 1,
-          installedStore: 1,
-          // notAssignedStores: '$storeAudit.notAssignedStores',
-          inprogressStoresCount: '$storeAudit.inprogressStores',
-          // fileCount: '$storeAudit.fileCount',
-          notAssignedCount: { $subtract: [ '$totalFilesCount', { $subtract: [ { $ifNull: [ '$storeAudit.fileCount', 0 ] }, { $ifNull: [ '$storeAudit.notAssignedStores', 0 ] } ] } ] },
-          clientStatus: { $cond: [ { $eq: [ { $ifNull: [ '$storeAudit.fileCount', 0 ] }, 0 ] }, 'not-taken', { $cond: [ { $gte: [ '$storeAudit.completedStores', '$totalFilesCount' ] }, 'completed', 'pending' ] } ] }, // { $cond: [ { $or: [ { $gt: [ '$notAssignedCount', 0 ] }, { $gt: [ '$storeAudit.notAssignedStores', 0 ] } ] }
-          completedStores: '$storeAudit.completedStores',
-          completionPercentage: '$storeAudit.completionPercentage',
+    // Index storeAudit counts by clientId + fileDate for an O(1) merge.
+    const storeByKey = new Map();
+    for ( const s of storeRows ) {
+      storeByKey.set( `${s.clientId}__${s.fileDate}`, s );
+    }
 
-        },
-      },
-    ];
+    // Merge and derive the same fields the old $lookup / $project produced.
+    let merged = baseRows.map( ( base ) => {
+      const sa = storeByKey.get( `${base.clientId}__${base.fileDate}` );
+      const fileCount = sa?.fileCount || 0;
+      const notAssignedStores = sa?.notAssignedStores || 0;
+      const completedStores = sa ? sa.completedStores : undefined;
+      const clientStatus = fileCount === 0 ?
+        'not-taken' :
+        ( ( completedStores || 0 ) >= base.totalFilesCount ? 'completed' : 'pending' );
+      return {
+        fileDate: base.fileDate,
+        clientId: base.clientId,
+        clientName: base.clientName,
+        totalFilesCount: base.totalFilesCount,
+        moduleType: base.moduleType,
+        installedStore: base.installedStore,
+        inprogressStoresCount: sa ? sa.inprogressStores : undefined,
+        notAssignedCount: base.totalFilesCount - ( fileCount - notAssignedStores ),
+        clientStatus: clientStatus,
+        completedStores: completedStores,
+        completionPercentage: sa ?
+          Math.round( ( ( 100 * sa.completedStores ) / base.totalFilesCount ) * 10 ) / 10 :
+          undefined,
+      };
+    } );
 
+    // --- Post-merge filters (depend on the derived clientStatus) -----------
     if ( inputData?.filterByStatus?.length > 0 ) {
-      query.push(
-          {
-            $match: { clientStatus: { $in: inputData.filterByStatus } },
-          },
-
-      );
+      merged = merged.filter( ( r ) => inputData.filterByStatus.includes( r.clientStatus ) );
     }
 
     if ( inputData.searchValue && inputData.searchValue !== '' ) {
-      query.push( {
-        $match: {
-          $or: [
-            { clientId: { $regex: inputData.searchValue, $options: 'i' } },
-            { clientName: { $regex: inputData.searchValue, $options: 'i' } },
-            { moduleType: { $regex: inputData.searchValue, $options: 'i' } },
-            { clientStatus: { $regex: inputData.searchValue, $options: 'i' } },
-          ],
-
-        },
-      } );
+      const rx = new RegExp( inputData.searchValue, 'i' );
+      merged = merged.filter( ( r ) =>
+        rx.test( r.clientId || '' ) ||
+        rx.test( r.clientName || '' ) ||
+        rx.test( r.moduleType || '' ) ||
+        rx.test( r.clientStatus || '' ),
+      );
     }
+
+    // --- Sort: numeric columns numerically, strings case-insensitively to
+    // match the DB collation ({ locale: 'en', strength: 2 }). --------------
     if ( inputData.sortColumnName ) {
-      const sortBy = inputData.sortBy || -1;
-      const sortColumn = inputData.sortColumnName;
-      query.push( {
-        $sort: { [sortColumn]: sortBy },
-      },
-      );
+      const dir = Number( inputData.sortBy ) === 1 ? 1 : -1;
+      const col = inputData.sortColumnName;
+      merged.sort( ( a, b ) => {
+        const av = a[col];
+        const bv = b[col];
+        let cmp;
+        if ( typeof av === 'number' && typeof bv === 'number' ) {
+          cmp = av - bv;
+        } else {
+          cmp = String( av ?? '' ).localeCompare( String( bv ?? '' ), 'en', { sensitivity: 'accent' } );
+        }
+        return dir * cmp;
+      } );
     }
 
-    const count = await aggregateAuditStoreData( query );
-    if ( count.length == 0 ) {
+    const count = merged.length;
+    if ( count === 0 ) {
       return res.sendError( 'No Data Found', 204 );
     }
 
     if ( inputData.isExport ) {
-      query.push( { $limit: 10000 } );
-    } else {
-      query.push( {
-        $skip: offset,
-      },
-      {
-        $limit: limit,
-      } );
-    }
-    if ( inputData.isExport ) {
-      query.push(
-          {
-            $project: {
-              '_id': 0,
-              'File Date': '$fileDate',
-              'Brand Name': '$clientName',
-              'Brand Id': '$clientId',
-              'Product Type': '$moduleType',
-              // 'Completed Percentage': '$completionPercentage',
-              'Installed Stores': '$installedStore',
-              'Audit Stores': '$totalFilesCount',
-              'Inprogress Stores': '$inprogressStoresCount',
-              'Not Assigned stores': '$notAssignedCount',
-              // 'Not Assigned Stores': '$notAssignedStores',
-              'Completed Stores': '$completedStores',
-              'Status': '$clientStatus',
-            },
-          },
-      );
+      const exportRows = merged.slice( 0, 10000 ).map( ( r ) => ( {
+        'File Date': r.fileDate,
+        'Brand Name': r.clientName,
+        'Brand Id': r.clientId,
+        'Product Type': r.moduleType,
+        'Installed Stores': r.installedStore,
+        'Audit Stores': r.totalFilesCount,
+        'Inprogress Stores': r.inprogressStoresCount,
+        'Not Assigned stores': r.notAssignedCount,
+        'Completed Stores': r.completedStores,
+        'Status': r.clientStatus,
+      } ) );
+      await download( exportRows, res );
+      return;
     }
 
-    const result = await aggregateAuditStoreData( query );
-    if ( result.length == 0 ) {
+    const pageResult = merged.slice( offset, offset + limit );
+    if ( pageResult.length === 0 ) {
       return res.sendError( 'No Data Found', 204 );
     }
-    if ( inputData.isExport ) {
-      await download( result, res );
-      return;
-    }
-    return res.sendSuccess( { result: result, count: count.length } );
+    return res.sendSuccess( { result: pageResult, count: count } );
   } catch ( error ) {
     const err = error.error || 'Internal Server Error';
     logger.error( { error: error, message: req.body, function: 'clientMetrics' } );
@@ -3715,6 +3671,13 @@ export async function reTrigger( req, res ) {
     }
     switch ( inputData.triggerType ) {
       case 'queue':
+        // Only push to the queue when the store has not already been queued.
+        // A 'not_assign' status means a prior reTrigger already pushed this
+        // store - pushing again would create a duplicate queue message.
+        if ( req.audit.status === 'not_assign' ) {
+          await releaseReTriggerLock( lockKey );
+          return res.sendError( 'This store has already been pushed to the queue', 400 );
+        }
         // Only push to the queue when the store has not already been queued.
         // A 'not_assign' status means a prior reTrigger already pushed this
         // store - pushing again would create a duplicate queue message.
@@ -5899,3 +5862,5 @@ export async function rePushAuditStores( req, res ) {
     return res.sendError( err, 500 );
   }
 }
+
+

package/src/controllers/eyeTestAudit.controllers.js

@@ -1414,7 +1414,6 @@ export async function summaryList( req, res ) {
     if ( inputData.clientId !== '11' ) {
       return res.sendError( 'No data found', 204 );
     }
-
     // declare openSearch and get data form the .env/secret manager
     const openSearch = JSON.parse( process.env.OPENSEARCH );
 
@@ -1764,6 +1763,7 @@ export async function summaryList( req, res ) {
         } );
       }
       const getcount = await aggregateClusters( inputData.keyType === 'rm'?RMQuery: clusterQuery );
+
       const count = getcount?.length || 0;
       if ( count == 0 ) {
         return res.sendError( 'No data', 204 );
@@ -1787,6 +1787,7 @@ export async function summaryList( req, res ) {
         );
       }
       const getCluster = await aggregateClusters( inputData.keyType === 'rm'?RMQuery: clusterQuery );
+      logger.info( { masg: '...........getCluster', getCluster, RMQuery } );
       if ( !getCluster || getCluster?.length == 0 ) {
         return res.sendError( 'No data', 204 );
       }
@@ -3174,3 +3175,175 @@ export async function updateEmailConfig1( req, res ) {
     return res.sendError( err, 500 );
   }
 }
+
+export async function getConversationDetails( req, res ) {
+  try {
+    const inputData = req.params;
+
+    // Query OpenSearch audio_analytics_report index by doc_id and moduleType
+    const query = {
+      'query': {
+        'bool': {
+          'must': [
+            {
+              'term': {
+                'unique_id.keyword': inputData.id,
+              },
+            },
+          ],
+        },
+      },
+      'size': 1,
+    };
+
+    const result = await getOpenSearchData( 'audio_analytics_report_v2', query );
+    if ( result?.body?.hits?.hits?.length === 0 ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    const source = result?.body?.hits?.hits[0]?._source;
+
+    if ( !source ) {
+      return res.sendError( 'No data found', 204 );
+    }
+
+    // Helper function to format duration: convert seconds to mm:ss format
+    const formatDuration = ( seconds ) => {
+      if ( !seconds || seconds === 0 ) return '0:00';
+      const minutes = Math.floor( seconds / 60 );
+      const secs = Math.floor( seconds % 60 );
+      return `${minutes}:${secs.toString().padStart( 2, '0' )}`;
+    };
+
+    // Helper: parse "s3://bucket/path/to/file" into { Bucket, file_path }
+    const parseS3Uri = ( uri ) => {
+      if ( !uri ) return null;
+      const withoutScheme = uri.replace( /^s3:\/\//, '' );
+      const slashIdx = withoutScheme.indexOf( '/' );
+      if ( slashIdx === -1 ) return null;
+      return {
+        Bucket: withoutScheme.slice( 0, slashIdx ),
+        file_path: withoutScheme.slice( slashIdx + 1 ),
+      };
+    };
+
+    // Helper function to format transcript: fetch and clean transcript file
+    const getFormattedTranscript = async ( transcriptPath ) => {
+      try {
+        if ( !transcriptPath ) return '';
+
+        const s3Parts = parseS3Uri( transcriptPath );
+        logger.info( { s3Parts: s3Parts, function: 'getFormattedTranscript' } );
+        if ( !s3Parts ) return '';
+
+        const transcriptSignedUrl = await signedUrl( { ...s3Parts, key: 'aws' } );
+        if ( !transcriptSignedUrl ) return '';
+
+        const fetchRes = await fetch( transcriptSignedUrl );
+        if ( !fetchRes.ok ) return '';
+        let text = await fetchRes.text();
+
+        // Remove timestamps like [00:00:33.954 --> 00:00:36.154]
+        text = text.replace( /\[\d{2}:\d{2}:\d{2}\.\d{3} --> \d{2}:\d{2}:\d{2}\.\d{3}\]\s*/g, '' );
+
+        // Remove [silence] markers
+        text = text.replace( /\[silence\]\s*/g, '' );
+
+        // Replace multiple newlines with single space to create paragraphs
+        text = text.replace( /\n+/g, ' ' );
+
+        // Clean up multiple spaces
+        text = text.replace( /\s+/g, ' ' ).trim();
+
+        return text;
+      } catch ( error ) {
+        logger.error( { message: error, function: 'getFormattedTranscript' } );
+        return '';
+      }
+    };
+
+    // Helper function to format metric names
+    const formatMetricName = ( name ) => {
+      const nameMap = {
+        'Torchlight Exam': 'Torchlight Check',
+        'JCC': 'JCC Check',
+        'Distance Visual Acuity': 'Distance-VA-Check',
+        'Duochrome': 'Duochrome Check',
+        'Near Visual Acuity': 'Near Addition Check',
+      };
+      return nameMap[name] || name;
+    };
+
+    // Format metrics results with sequential time allocation
+    const matchedCohort = source?.cohort_analysis_results?.find( ( c ) => c.cohortId === 'cohort_11_1ddea945-ff3a-4c11-95a9-bb425ca927de' );
+    const metricsData = matchedCohort?.metrics_results || [];
+
+    // Calculate sequential times for detected metrics
+    let currentSeconds = 0;
+    const totalDuration = Math.floor( source?.duration || 1200 );
+    const detectedCount = metricsData.filter( ( m ) => m.contextsEvaluated?.[0]?.isDetected ).length || 1;
+    const secondsPerMetric = Math.floor( totalDuration / Math.max( detectedCount, 1 ) );
+
+    const formattedMetrics = metricsData.map( ( metric, index ) => {
+      const isDetected = metric.contextsEvaluated?.[0]?.isDetected;
+
+      let startTime = '';
+      let endTime = '';
+
+      if ( isDetected ) {
+        const startSeconds = currentSeconds;
+        const endSeconds = Math.min( currentSeconds + secondsPerMetric, totalDuration );
+
+        startTime = formatDuration( startSeconds );
+        endTime = formatDuration( endSeconds );
+
+        currentSeconds = endSeconds;
+      }
+
+      return {
+        metricId: metric.metricId,
+        metricName: formatMetricName( metric.metricName ),
+        metricType: metric.metricType,
+        status: metric.contextsEvaluated?.[0]?.isDetected === false ? 'fail':'pass',
+        contextsEvaluated: metric.contextsEvaluated?.[0]?.isDetected,
+        startTime: startTime,
+        endTime: endTime,
+        evidence_quote: metric.contextsEvaluated?.[0]?.isDetected === false ? '' : metric.evidence_quote,
+      };
+    } ) || [];
+
+    // Fetch signed URL for audio
+    const audioS3Parts = parseS3Uri( source?.s3_audio_path );
+    const audioSignedUrl = audioS3Parts ? await signedUrl( { ...audioS3Parts, key: 'aws' } ) : null;
+    // Fetch and format transcript
+    const formattedTranscript = await getFormattedTranscript( source?.s3_transcript_path );
+
+    // Get executive summary
+    // const executiveSummary = source?.cohort_analysis_results?.[0]?.executive_summary || {};
+
+    const response = {
+      doc_id: source?.doc_id,
+      // storeName: source?.storeName,
+      // storeID: source?.storeID,
+      // staffID: source?.staffID,
+      // state: source?.state,
+      // moduleType: source?.moduleType,
+      // fileDate: source?.filedate,
+      // processTimestamp: source?.processTimestamp,
+      duration: formatDuration( source?.duration ),
+      audio_url: audioSignedUrl,
+      // s3_transcript_path: source?.s3_transcript_path,
+      transcript_summary: formattedTranscript,
+      // overall_score: executiveSummary?.overall_score,
+      // conversation_summary: executiveSummary?.conversation_summary,
+      // key_pointers: executiveSummary?.key_pointers,
+      metrics_results: formattedMetrics,
+    };
+
+    return res.sendSuccess( { result: response } );
+  } catch ( error ) {
+    const err = error.message || 'Internal Server Error';
+    logger.error( { message: error, data: req.params, function: 'eyetestAudit-controller-getConversationDetails' } );
+    return res.sendError( err, 500 );
+  }
+}

package/src/dtos/audit.dtos.js

@@ -321,3 +321,5 @@ export const rePushAuditStoresSchema = joi.object( {
 export const rePushAuditStoresValid = {
   body: rePushAuditStoresSchema,
 };
+
+

package/src/dtos/eyeTestAudit.dtos.js

@@ -418,3 +418,14 @@ export const getEmailConfigSchema = joi.object( {
 export const getEmailConfigValid = {
   query: getEmailConfigSchema,
 };
+
+export const getConversationDetailsSchema = joi.object( {
+  id: joi.string().required().messages( {
+    'any.required': 'ID is required',
+    'string.empty': 'ID cannot be empty',
+  } ),
+} );
+
+export const getConversationDetailsValid = {
+  params: getConversationDetailsSchema,
+};

package/src/routes/audit.routes.js

@@ -45,7 +45,10 @@ auditRouter.get( '/get-user-audit-count-mtd', isAllowedSessionHandler, getUserAu
 
 // audit log
 auditRouter.get( '/audit-view-logs', isAllowedSessionHandler, accessVerification( { userType: [ 'tango' ] } ), validate( auditViewLogValid ), auditViewLogs );
+
+
 export default auditRouter;
 
 //
 auditRouter.post( '/re-push-audit-stores', validate( rePushAuditStoresValid ), rePushAuditStores );
+

package/src/routes/eyeTestAudit.routes.js

@@ -1,8 +1,8 @@
 import { Router } from 'express';
 import { isAllowedSessionHandler, validate } from 'tango-app-api-middleware';
 import { accessVerification } from 'tango-app-api-middleware';
-import { cancelValid, clusterListValid, emailAlertLogValid, getEmailConfigValid, getFileHistoryValid, getFileValid, getListValid, getUserConfigValid, rmListValid, saveValid, summaryCardValid, summaryListValid, updateEmailConfigValid, updateUserConfigValid, userAuditedDataValid, viewFileValid } from '../dtos/eyeTestAudit.dtos.js';
-import { addUserConfig, cancel, clusterList, emailAlertLog, getEmailConfig, getFile, getFileHistory, getList, getUserConfig, rmList, save, summaryCard, summaryList, updateEmailConfig, updateEmailConfig1, updateUserConfig, userAuditedData, viewFile } from '../controllers/eyeTestAudit.controllers.js';
+import { cancelValid, clusterListValid, emailAlertLogValid, getConversationDetailsValid, getEmailConfigValid, getFileHistoryValid, getFileValid, getListValid, getUserConfigValid, rmListValid, saveValid, summaryCardValid, summaryListValid, updateEmailConfigValid, updateUserConfigValid, userAuditedDataValid, viewFileValid } from '../dtos/eyeTestAudit.dtos.js';
+import { addUserConfig, cancel, clusterList, emailAlertLog, getConversationDetails, getEmailConfig, getFile, getFileHistory, getList, getUserConfig, rmList, save, summaryCard, summaryList, updateEmailConfig, updateEmailConfig1, updateUserConfig, userAuditedData, viewFile } from '../controllers/eyeTestAudit.controllers.js';
 import { isSuperAdmin, roleValidation, sendAlert } from '../validation/eyeTest.validation.js';
 
 export const eyeTestAuditRouter = Router();
@@ -15,6 +15,10 @@ eyeTestAuditRouter.post( '/cancel', isAllowedSessionHandler, accessVerification(
 eyeTestAuditRouter.get( '/get-file-history/:id/:type', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( getFileHistoryValid ), getFileHistory );
 eyeTestAuditRouter.get( '/user-audited-data/:id', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( userAuditedDataValid ), userAuditedData );
 
+// enhancement of march of 2026
+
+eyeTestAuditRouter.get( '/get-conversation-details/:id', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( getConversationDetailsValid ), getConversationDetails );
+
 // enhancement of aug of 2025
 
 eyeTestAuditRouter.post( '/summary-list', isAllowedSessionHandler, accessVerification( { userType: [ 'tango', 'client' ] } ), validate( summaryListValid ), roleValidation, summaryList );

package/src/validation/audit.validation.js

@@ -151,13 +151,11 @@ export async function mapCustomer( sourceMappingData, customerData ) {
   try {
     const filterCustomerData = await filteredCustomerMap( customerData );
     logger.info( { filterCustomerData: filterCustomerData } );
-    const chunkedMappingData = await chunkArray( sourceMappingData, 10 );
-
-    const promises = chunkedMappingData.map( async ( chunk ) => {
-      return mapFunction( chunk, filterCustomerData );
-    } );
-    const mappedArrays = await Promise.all( promises );
-    return mappedArrays.flat();
+    // Build the lookup once, then retag every row in a single pass. This is
+    // O(rows + mappedIds) and scales for concurrent submissions, versus the old
+    // O(customers x mappedIds x rows) scan that also re-read its own mutations.
+    const customerMap = buildCustomerMap( filterCustomerData );
+    return mapFunction( sourceMappingData, customerMap );
   } catch ( error ) {
     logger.error( { error: error, type: 'mapCustomer' } );
     return error;
@@ -168,22 +166,39 @@ const filteredCustomerMap = async ( data ) => {
   return data.filter( ( map ) => map.count >= 1 );
 };
 
-const mapFunction = async ( chunkData, filterData ) => {
+// Lookup of original cluster id (child img_name) -> the customer it was tagged
+// into. Last write wins if the same id is referenced by more than one group, so
+// the result is deterministic regardless of customer order.
+const buildCustomerMap = ( filterData ) => {
+  const customerMap = new Map();
   for ( const data of filterData ) {
-    const mappedIds = data.mappedid;
-    if ( data?.mappedid ) {
-      for ( const mappedId of mappedIds ) {
-        chunkData.find( ( item ) => {
-          if ( mappedId.img_name === item.temp_ids ) {
-            item.temp_ids = data.img_name;
-            ( mappedId.img_name !== data.img_name ) ? item.query_status = '' : null;
-            item.demographic = data.demographic || '';
-          }
-        } );
-      }
+    if ( !data?.mappedid ) continue;
+    for ( const mappedId of data.mappedid ) {
+      customerMap.set( mappedId.img_name, {
+        parentId: data.img_name,
+        demographic: data.demographic || '',
+        // The chosen representative (img_name === parent) keeps its query flag so
+        // it resurfaces in reaudit; every other merged image is cleared so it does
+        // not (query_status is the reaudit gate in getFilterData / getAuditFilterData).
+        isChild: mappedId.img_name !== data.img_name,
+      } );
     }
   }
-  return chunkData;
+  return customerMap;
+};
+
+// Single pass over the master-json rows. Each row's ORIGINAL temp_ids is read
+// exactly once and reassigned to its customer's parent id, so every row sharing
+// a temp_ids is retagged and the retag never feeds back into later lookups.
+const mapFunction = ( personData, customerMap ) => {
+  for ( const item of personData ) {
+    const mapped = customerMap.get( item.temp_ids );
+    if ( !mapped ) continue;
+    item.temp_ids = mapped.parentId;
+    item.query_status = mapped.isChild ? '' : item.query_status;
+    item.demographic = mapped.demographic;
+  }
+  return personData;
 };
 
 export async function isAuditInputFolderExist( req, res, next ) {
@@ -345,7 +360,8 @@ export async function getAuditFilterData( data ) {
           ( item ) =>
             item.temp_ids < 20000 &&
           item.temp_ids > 0 &&
-          item.person_status === '',
+          item.person_status === '' &&
+          item.query_status !== '',
       );
       const finalResult = await filterData.map( ( i ) => {
         return { ...i, img: i.index.concat( '_', i.temp_ids ) };