tango-app-api-infra 3.1.16 → 3.1.18

package/src/controllers/storeInfra.controlller.js

@@ -62,7 +62,12 @@ export async function storeTicketList( req, res ) {
           $filter: {
             input: '$ticketActivity',
             as: 'item',
-            cond: { $ne: [ '$$item.actionType', 'statusChange' ] },
+            cond: {
+              $and: [
+                { $ne: [ '$$item.actionType', 'statusChange' ] },
+                { $ne: [ '$$item.actionType', 'statusCheck' ] },
+              ],
+            },
           },
         },
         primaryIssue: {
@@ -284,173 +289,141 @@ export async function edgeAppLogTable( req, res ) {
   try {
     const store = await findOneStore( { storeId: req.body.storeId } );
     if ( !store ) {
-      return res.sendError( 'Stores Not fond', 204 );
+      return res.sendError( 'Store Not found', 204 );
     }
-    let startHour = store.storeProfile.open.split( ':' )[0];
-    let endHour = store.storeProfile.close.split( ':' )[0];
+
+    let startHour = parseInt( store.storeProfile.open.split( ':' )[0], 10 );
+    let endHour = parseInt( store.storeProfile.close.split( ':' )[0], 10 );
     const interval = 60; // 1 hour in minutes
     const timeSlots = generateTimeSlots( startHour, endHour, interval, req );
+
+    const date = dayjs( timeSlots[0].from ).format( 'DD-MM-YYYY' );
+    const storeId = req.body.storeId;
+
+    const internetSpeedQuery = {
+      size: 100,
+      query: {
+        bool: {
+          must: [
+            { term: { 'log_type.keyword': 'Application' } },
+            { term: { 'store_date.keyword': date } },
+            { term: { 'storeId.keyword': storeId } },
+            { term: { 'log_subtype.keyword': 'Speed_Test' } },
+          ],
+        },
+      },
+      sort: [ { timestamp: { order: 'desc' } } ],
+      _source: [ 'data.upload_Speed', 'data.occuringTime' ],
+    };
+
+    const fileCountQuery = {
+      size: 100,
+      query: {
+        bool: {
+          must: [
+            { term: { 'log_type.keyword': 'Application' } },
+            { term: { 'store_date.keyword': date } },
+            { term: { 'storeId.keyword': storeId } },
+            { term: { 'log_subtype.keyword': 'Zip_File_Count' } },
+          ],
+        },
+      },
+      sort: [ { timestamp: { order: 'desc' } } ],
+      _source: [ 'data.files_pushed', 'data.files_generated', 'data.occuringTime' ],
+    };
+
+    const downTimeQuery = {
+      size: 100,
+      query: {
+        bool: {
+          must: [
+            { term: { 'doc.date.keyword': date } },
+            { term: { 'doc.store_id.keyword': storeId } },
+          ],
+        },
+      },
+      _source: [ 'doc.streamwise_downtime', 'doc.hour' ],
+    };
+
+    // Execute all queries in parallel
+    const [ speedTestResult, fileCountResult, downtimeResult ] = await Promise.all( [
+      getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, internetSpeedQuery ),
+      getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, fileCountQuery ),
+      getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).downTimeHourly, downTimeQuery ),
+    ] );
+    // Process results
+    const speedTestData = speedTestResult?.body?.hits?.hits ?? [];
+    const fileCountData = fileCountResult?.body?.hits?.hits ?? [];
+    const downtimeData = downtimeResult?.body?.hits?.hits ?? [];
+
     for ( const obj of timeSlots ) {
+      const hour = obj.hour;
       obj.startTime = dayjs( obj.from ).format( 'hh:mm A' );
       obj.endTime = dayjs( obj.to ).format( 'hh:mm A' );
-      let internetSpeedQuery = {
-        'query': {
-          'bool': {
-            'must': [
-              {
-                'term': {
-                  'log_type.keyword': 'Application',
-                },
-              },
-              {
-                'term': {
-                  'store_date.keyword': dayjs( obj.from ).format( 'DD-MM-YYYY' ),
-                },
-              },
-              {
-                'term': {
-                  'storeId.keyword': req.body.storeId,
-                },
-              },
-              {
-                'term': {
-                  'log_subtype.keyword': 'Speed_Test',
-                },
-              },
-            ],
-          },
-        },
-        'sort': [
-          { 'timestamp': { 'order': 'desc' } },
-        ],
-      };
-      let speedTest = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, internetSpeedQuery );
-      if ( speedTest&& speedTest.body.hits && speedTest.body.hits.hits.length > 0 ) {
-        for ( const sourcedata of speedTest.body.hits.hits ) {
-          if ( sourcedata._source ) {
-            if ( Number( sourcedata._source.data.occuringTime.split( ':' )[0] )==obj.hour ) {
-              const megabytes = bytesToMB( sourcedata._source.data.upload_Speed.split( '.' )[0] ).toFixed( 2 );
-              obj.Internetspeed = megabytes+ ' MB/sec';
-            }
-          }
-        }
-      } else {
-        obj.Internetspeed = '';
-      }
-      let FileCountQuery = {
-        'size': 1000,
-        'query': {
-          'bool': {
-            'must': [
-              {
-                'term': {
-                  'log_type.keyword': 'Application',
-                },
-              },
-              {
-                'term': {
-                  'store_date.keyword': dayjs( obj.from ).format( 'DD-MM-YYYY' ),
-                },
-              },
-              {
-                'term': {
-                  'storeId.keyword': req.body.storeId,
-                },
-              },
-              {
-                'term': {
-                  'log_subtype.keyword': 'Zip_File_Count',
-                },
-              },
-            ],
 
-          },
-        },
+      // Internet speed
 
-        'sort': [
-          { 'timestamp': { 'order': 'desc' } },
-        ],
-      };
-      let newFilesCount = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, FileCountQuery );
-      if ( newFilesCount&& newFilesCount.body.hits && newFilesCount.body.hits.hits.length > 0 ) {
-        obj.files_pushed = 0;
-        obj.files_generated = 0;
-        for ( let sourcedata of newFilesCount.body.hits.hits ) {
-          if ( sourcedata._source ) {
-            if ( Number( sourcedata._source.data.occuringTime.split( ':' )[0] )==obj.hour ) {
-              obj.files_pushed = obj.files_pushed+Number( sourcedata._source.data.files_pushed );
-              obj.files_generated = obj.files_generated+Number( sourcedata._source.data.files_generated );
-            }
-          }
-        }
+      const speedTest = speedTestData.find(
+          ( item ) => Number( item._source.data.occuringTime.split( ':' )[0] ) === hour,
+      );
+      if ( speedTest&&speedTest._source.data.upload_Speed =='0 bytes' ) {
+        obj.Internetspeed = '0 MB/sec';
       } else {
-        obj.files_pushed = '';
-        obj.files_generated = '';
+        obj.Internetspeed = speedTest ? `${bytesToMB( speedTest._source.data.upload_Speed.split( '.' )[0] ).toFixed( 2 )} MB/sec` : '';
       }
-      let downTimeQuery = {
-        'size': 1,
-        'query': {
-          'bool': {
-            'must': [
-              {
-                'term': {
-                  'doc.date.keyword': dayjs( obj.from ).format( 'DD-MM-YYYY' ),
-                },
-              },
-              {
-                'term': {
-                  'doc.store_id.keyword': req.body.storeId,
-                },
-              },
-              {
-                'terms': {
-                  'doc.hour.keyword': [ obj.hour ],
-                },
-              },
-            ],
 
-          },
-        },
-      };
-      const downtime = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).downTimeHourly, downTimeQuery );
-      let streamwiseDowntime = downtime.body.hits.hits.length > 0 ? downtime.body.hits.hits[0]._source.doc.streamwise_downtime : [];
-      if ( streamwiseDowntime.length > 0 ) {
-        const sum = streamwiseDowntime.reduce( ( accumulator, currentValue ) => {
-          return accumulator + currentValue.down_time;
-        }, 0 );
-        const average = sum / streamwiseDowntime.length;
-        obj.downtime = Math.round( average );
+
+      // File counts
+      const fileCounts = fileCountData.filter(
+          ( item ) => Number( item._source.data.occuringTime.split( ':' )[0] ) === hour,
+      );
+      obj.files_pushed = fileCounts.reduce( ( sum, item ) => sum + Number( item._source.data.files_pushed ), 0 ) || '';
+      obj.files_generated = fileCounts.reduce( ( sum, item ) => sum + Number( item._source.data.files_generated ), 0 ) || '';
+
+      // Downtime
+
+      const downtime = downtimeData.find( ( item ) => Number( item._source.doc.hour ) === hour );
+
+      if ( downtime ) {
+        const streamwiseDowntime = downtime._source.doc.streamwise_downtime || [];
+        if ( streamwiseDowntime.length > 0 ) {
+          const sum = streamwiseDowntime.reduce( ( acc, cur ) => acc + cur.down_time, 0 );
+          const average = sum / streamwiseDowntime.length;
+          obj.downtime = Math.round( average );
+        } else {
+          obj.downtime = '';
+        }
       } else {
         obj.downtime = '';
       }
     }
+
     if ( req.body.export ) {
-      const exportdata = [];
-      timeSlots.forEach( ( element ) => {
-        exportdata.push( {
-          'Time Stamp': element.startTime+ '-'+ element.endTime,
-          'Downtime': element.ticketId,
-          'Avg Internet Speed': element.Date,
-          'Files Genarated': element.issueClosedDate,
-          'Files Pushed': element.primaryIssue,
-        } );
-      } );
-      await download( exportdata, res );
+      const exportData = timeSlots.map( ( element ) => ( {
+        'Time Stamp': `${element.startTime}-${element.endTime}`,
+        'Downtime': element.downtime?element.downtime +' Mins':'--',
+        'Avg Internet Speed': element.Internetspeed,
+        'Files Generated': element.files_generated,
+        'Files Pushed': element.files_pushed,
+      } ) );
+      await download( exportData, res );
       return;
     }
+
     res.sendSuccess( timeSlots );
   } catch ( error ) {
-    logger.error( { error: error, function: 'edgeAppLog' } );
+    logger.error( { error, function: 'edgeAppLog' } );
     return res.sendError( error, 500 );
   }
 }
+
 function bytesToMB( bytes ) {
   return bytes / ( 1024 * 1024 );
 }
 function generateTimeSlots( startHour, endHour, interval, req ) {
   try {
     const timeSlots = [];
-    for ( let hour = startHour; hour <= endHour; hour++ ) {
+    for ( let hour = startHour; hour < endHour; hour++ ) {
       for ( let minute = 0; minute < 60; minute += interval ) {
         let isoDate = new Date();
 
@@ -487,172 +460,154 @@ export async function viewedgeAppLog( req, res ) {
   try {
     const store = await findOneStore( { storeId: req.body.storeId } );
     if ( !store ) {
-      return res.sendError( 'Stores Not fond', 204 );
+      return res.sendError( 'Stores Not found', 204 );
     }
-    const inputDate = dayjs( req.body.Date ).format( 'YYYY-MM-DD' ); // Specify the date you want to add the times to
+    const inputDate = dayjs( req.body.Date ).format( 'DD-MM-YYYY' );
     const fromTime = req.body.from;
     const toTime = req.body.to;
     let response = {};
 
-
-    let appStartTimeQuery = {
-      'size': 1000,
-      'query': {
-        'bool': {
-          'must': [
-            {
-              'term': {
-                'log_type.keyword': 'Application',
-              },
-            },
-            {
-              'term': {
-                'store_date.keyword': dayjs( inputDate ).format( 'DD-MM-YYYY' ),
-              },
-            },
-            {
-              'term': {
-                'store_id.keyword': req.body.storeId,
-              },
-            },
-            {
-              'term': {
-                'log_subtype.keyword': 'AppStart_Time',
-              },
+    const queries = [
+      {
+        queryName: 'appStartTime',
+        query: {
+          size: 1,
+          query: {
+            bool: {
+              must: [
+                { term: { 'log_type.keyword': 'Application' } },
+                { term: { 'store_date.keyword': inputDate } },
+                { term: { 'storeId.keyword': req.body.storeId } },
+                { term: { 'log_subtype.keyword': 'AppStart_Time' } },
+                { term: { 'data.message.keyword': 'Login Success Event' } },
+              ],
             },
-          ],
-
+          },
         },
       },
-    };
-    const appStartTime = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, appStartTimeQuery );
-
-    response.appStartTime = appStartTime.body.hits.hits.length > 0 ? appStartTime.body.hits.hits[0]._source.data.occuringTime : '';
-
-    let appQuitTimeQuery = {
-      'size': 1,
-      'query': {
-        'bool': {
-          'must': [
-            {
-              'term': {
-                'log_type.keyword': 'Application',
-              },
-            },
-            {
-              'term': {
-                'store_date.keyword': dayjs( inputDate ).format( 'DD-MM-YYYY' ),
-              },
-            },
-            {
-              'term': {
-                'store_id.keyword': req.body.storeId,
-              },
-            },
-            {
-              'term': {
-                'log_subtype.keyword': 'App_Quit',
-              },
+      {
+        queryName: 'appQuitTime',
+        query: {
+          size: 1,
+          query: {
+            bool: {
+              must: [
+                { term: { 'log_type.keyword': 'Application' } },
+                { term: { 'store_date.keyword': inputDate } },
+                { term: { 'storeId.keyword': req.body.storeId } },
+                { term: { 'log_subtype.keyword': 'App_Quit_Time' } },
+                { term: { 'data.message.keyword': 'App Quit With password' } },
+              ],
             },
-          ],
-
+          },
+          sort: [ { timestamp: { order: 'desc' } } ],
         },
       },
-      'sort': [
-        { 'timestamp': { 'order': 'desc' } },
-      ],
-    };
-    const appQuitTime = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, appQuitTimeQuery );
-    if ( appQuitTime.body.hits.hits&&appQuitTime.body.hits.hits.length > 0 ) {
-      for ( const sourceData of appQuitTime.body.hits.hits ) {
-        if ( Number( sourceData._source.data.occuringTime.split( ':' )[0] )== Number( fromTime.split( ':' )[0] ) ) {
-          response.appQuitTime = appQuitTime.body.hits.hits.length > 0 ? sourceData._source.data.occuringTime : '';
-        }
-      }
-    }
-    let appCrashTimeQuery = {
-      'size': 1,
-      'query': {
-        'bool': {
-          'must': [
-            {
-              'term': {
-                'log_type.keyword': 'Application',
-              },
+      {
+        queryName: 'appCrashTime',
+        query: {
+          size: 1,
+          query: {
+            bool: {
+              must: [
+                { term: { 'log_type.keyword': 'Application' } },
+                { term: { 'store_date.keyword': inputDate } },
+                { term: { 'storeId.keyword': req.body.storeId } },
+                { term: { 'log_subtype.keyword': 'App_Close_Event' } },
+              ],
             },
-            {
-              'term': {
-                'store_date.keyword': dayjs( inputDate ).format( 'DD-MM-YYYY' ),
-              },
+          },
+          sort: [ { timestamp: { order: 'desc' } } ],
+        },
+      },
+      {
+        queryName: 'screenStatus',
+        query: {
+          size: 100,
+          query: {
+            bool: {
+              must: [
+                { term: { 'log_type.keyword': 'Application' } },
+                { term: { 'store_date.keyword': inputDate } },
+                { term: { 'storeId.keyword': req.body.storeId } },
+                { term: { 'log_subtype.keyword': 'System_Status' } },
+              ],
             },
-            {
-              'term': {
-                'store_id.keyword': req.body.storeId,
-              },
+          },
+          sort: [ { timestamp: { order: 'asc' } } ],
+        },
+      },
+      {
+        queryName: 'fileCount',
+        query: {
+          size: 100,
+          query: {
+            bool: {
+              must: [
+                { term: { 'log_type.keyword': 'Application' } },
+                { term: { 'store_date.keyword': inputDate } },
+                { term: { 'storeId.keyword': req.body.storeId } },
+                { term: { 'log_subtype.keyword': 'Zip_File_Count' } },
+              ],
             },
-            {
-              'term': {
-                'log_subtype.keyword': 'App_Crash',
-              },
+          },
+          sort: [ { timestamp: { order: 'desc' } } ],
+        },
+      },
+      {
+        queryName: 'antiVirus',
+        query: {
+          size: 100,
+          query: {
+            bool: {
+              must: [
+                { term: { 'log_type.keyword': 'Application' } },
+                { term: { 'store_date.keyword': inputDate } },
+                { term: { 'storeId.keyword': req.body.storeId } },
+                { term: { 'log_subtype.keyword': 'Anti_Virus' } },
+              ],
             },
-          ],
-
+          },
+          sort: [ { timestamp: { order: 'desc' } } ],
         },
       },
-      'sort': [
-        { 'timestamp': { 'order': 'desc' } },
-      ],
-    };
+    ];
 
-    const appCrashTime = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, appCrashTimeQuery );
-    if ( appCrashTime.body.hits.hits&&appCrashTime.body.hits.hits.length > 0 ) {
-      for ( const sourceData of appCrashTime.body.hits.hits ) {
-        if ( Number( sourceData._source.data.occuringTime.split( ':' )[0] )== Number( fromTime.split( ':' )[0] ) ) {
-          response.AppCrashtime = appCrashTime.body.hits.hits.length > 0 ? sourceData._source.data.occuringTime : '';
-        }
-      }
+    const fetchLogs = queries.map( ( q ) =>
+      getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, q.query ),
+    );
+
+    const results = await Promise.all( fetchLogs );
+
+    const appStartTimeResult = results[0];
+    const appQuitTimeResult = results[1];
+    const appCrashTimeResult = results[2];
+    const screenStatusResult = results[3];
+    const fileCountResult = results[4];
+    const antiVirusResult = results[5];
+
+    response.appStartTime = appStartTimeResult.body.hits.hits.length > 0 ? appStartTimeResult.body.hits.hits[0]._source.data.occuringTime : '';
+
+    if ( appQuitTimeResult.body.hits.hits && appQuitTimeResult.body.hits.hits.length > 0 ) {
+      const quitTime = appQuitTimeResult.body.hits.hits.find( ( sourceData ) =>
+        Number( sourceData._source.data.occuringTime.split( ':' )[0] ) === Number( fromTime.split( ':' )[0] ),
+      );
+      response.appQuitTime = quitTime ? quitTime._source.data.occuringTime : '';
     }
-    const screenStatus = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, {
-      'size': 1000,
-      'query': {
-        'bool': {
-          'must': [
-            {
-              'term': {
-                'log_type.keyword': 'Application',
-              },
-            },
-            {
-              'term': {
-                'store_date.keyword': dayjs( inputDate ).format( 'DD-MM-YYYY' ),
-              },
-            },
-            {
-              'term': {
-                'store_id.keyword': req.body.storeId,
-              },
-            },
-            {
-              'term': {
-                'log_subtype.keyword': 'System_Status',
-              },
-            },
-          ],
 
-        },
-      },
-      'sort': [
-        { 'timestamp': { 'order': 'asc' } },
-      ],
+    if ( appCrashTimeResult.body.hits.hits && appCrashTimeResult.body.hits.hits.length > 0 ) {
+      const crashTime = appCrashTimeResult.body.hits.hits.find( ( sourceData ) =>
+        Number( sourceData._source.data.occuringTime.split( ':' )[0] ) === Number( fromTime.split( ':' )[0] ),
+      );
+      response.AppCrashtime = crashTime ? crashTime._source.data.occuringTime : '';
+    }
 
-    } );
-    if ( screenStatus&& screenStatus.body.hits.hits&&screenStatus.body.hits.hits.length > 0 ) {
+    if ( screenStatusResult.body.hits.hits && screenStatusResult.body.hits.hits.length > 0 ) {
       let suspendedTime;
       let resumedTime;
       const differences = [];
-
-      for ( const sourceData of screenStatus.body.hits.hits ) {
-        if ( Number( sourceData._source.data.occuringTime.split( ':' )[0] )== Number( fromTime.split( ':' )[0] ) ) {
+      for ( const sourceData of screenStatusResult.body.hits.hits ) {
+        if ( Number( sourceData._source.data.occuringTime.split( ':' )[0] ) === Number( fromTime.split( ':' )[0] ) ) {
           if ( sourceData._source.data.message.trim() === 'SYSTEM SUSPENDED' ) {
             suspendedTime = sourceData._source.data.occuringTime;
           } else if ( sourceData._source.data.message.trim() === 'SYSTEM RESUMED' ) {
@@ -671,96 +626,30 @@ export async function viewedgeAppLog( req, res ) {
           }
         }
       }
-      response.screenStatus = differences.length>0?`${differences[0].minutes}Mins ${differences[0].seconds}Sec`:'';
+      response.screenStatus = differences.length > 0 ? `${differences[0].minutes}Mins ${differences[0].seconds}Sec` : '';
     }
-    const FileCountQuery = {
-      'size': 1000,
-      'query': {
-        'bool': {
-          'must': [
-            {
-              'term': {
-                'log_type.keyword': 'Application',
-              },
-            },
-            {
-              'term': {
-                'store_date.keyword': dayjs( inputDate ).format( 'DD-MM-YYYY' ),
-              },
-            },
-            {
-              'term': {
-                'storeId.keyword': req.body.storeId,
-              },
-            },
-            {
-              'term': {
-                'log_subtype.keyword': 'Zip_File_Count',
-              },
-            },
-          ],
-
-        },
-      },
 
-      'sort': [
-        { 'timestamp': { 'order': 'desc' } },
-      ],
-    };
-    const newFilesCount = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, FileCountQuery );
-    if ( newFilesCount&& newFilesCount.body.hits && newFilesCount.body.hits.hits.length > 0 ) {
+    if ( fileCountResult.body.hits.hits && fileCountResult.body.hits.hits.length > 0 ) {
       response.filesPushed = 0;
-      response.files_genrated = 0;
-      for ( const sourcedata of newFilesCount.body.hits.hits ) {
-        if ( sourcedata._source ) {
-          if ( Number( sourcedata._source.data.occuringTime.split( ':' )[0] )==Number( fromTime.split( ':' )[0] ) ) {
-            response.filesPushed = response.filesPushed+Number( sourcedata._source.data.files_pushed );
-            response.files_genrated = response.files_generated+Number( sourcedata._source.data.files_generated );
-          }
+      response.files_generated = 0;
+      for ( const sourceData of fileCountResult.body.hits.hits ) {
+        if ( sourceData._source && Number( sourceData._source.data.occuringTime.split( ':' )[0] ) === Number( fromTime.split( ':' )[0] ) ) {
+          response.filesPushed += Number( sourceData._source.data.files_pushed );
+          response.files_generated += Number( sourceData._source.data.files_generated );
         }
       }
     } else {
       response.filesPushed = '';
-      response.files_genrated = '';
+      response.files_generated = '';
     }
 
-
-    const antiVirus = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, {
-      'size': 1,
-      'query': {
-        'bool': {
-          'must': [
-            {
-              'term': {
-                'log_type.keyword': 'Application',
-              },
-            },
-            {
-              'term': {
-                'store_id.keyword': req.body.storeId,
-              },
-            },
-            {
-              'term': {
-                'store_date.keyword': dayjs( inputDate ).format( 'DD-MM-YYYY' ),
-              },
-            },
-            {
-              'term': {
-                'log_subtype.keyword': 'Anti_Virus',
-              },
-            },
-          ],
-
-        },
-      },
-      'sort': [
-        { 'timestamp': { 'order': 'desc' } },
-      ],
-    },
-    );
-    response.antiVirus = antiVirus.body.hits.hits.length > 0 && antiVirus.body.hits.hits[0]._source.data.message == 'st-launch-1.0.exe is deleted' ? antiVirus.body.hits.hits[0]._source.data.occuringTime : '';
-
+    if ( antiVirusResult.body.hits.hits && antiVirusResult.body.hits.hits.length > 0 ) {
+      const antivirusEvent = antiVirusResult.body.hits.hits.find( ( sourceData ) =>
+        Number( sourceData._source.data.occuringTime.split( ':' )[0] ) === Number( fromTime.split( ':' )[0] ) &&
+        sourceData._source.data.message === 'st-launch-1.0.exe is deleted',
+      );
+      response.antiVirus = antivirusEvent ? antivirusEvent._source.data.occuringTime : '';
+    }
 
     res.sendSuccess( response );
   } catch ( error ) {
@@ -769,6 +658,7 @@ export async function viewedgeAppLog( req, res ) {
   }
 }
 
+
 export async function cameraAngleChange( req, res ) {
   try {
     const angleChange = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).cameraAngleChange,
@@ -849,27 +739,30 @@ export async function datewiseDowntime( req, res ) {
   try {
     const store = await findOneStore( { storeId: req.body.storeId } );
     if ( !store ) {
-      return res.sendError( 'Stores Not fond', 204 );
+      return res.sendError( 'Store Not Found', 204 );
     }
-    let startHour = store.storeProfile.open.split( ':' )[0];
-    let endHour = store.storeProfile.close.split( ':' )[0];
-
-    let datesArray = getDatesArray( req.body.fromDate, req.body.toDate );
-    let paginatedDates = paginateArray( datesArray, req.body.offset, req.body.limit );
-    let result = [];
-    for ( const singleDate of paginatedDates ) {
-      let inputData = {
+
+    const startHour = parseInt( store.storeProfile.open.split( ':' )[0], 10 );
+    const endHour = parseInt( store.storeProfile.close.split( ':' )[0], 10 );
+
+    const datesArray = getDatesArray( req.body.fromDate, req.body.toDate );
+    const paginatedDates = paginateArray( datesArray, req.body.offset, req.body.limit );
+
+    const resultPromises = paginatedDates.map( ( singleDate ) => {
+      const inputData = {
         start: startHour,
         end: endHour,
         interval: 60,
       };
       req.body.Date = singleDate;
-      let storedata = await livecountCheck( inputData, req );
-      result.push( storedata[0] );
-    }
+      return livecountCheck( inputData, singleDate, req );
+    } );
+
+    const result = await Promise.all( resultPromises );
+
     res.sendSuccess( {
       count: datesArray.length,
-      data: result,
+      data: result.flat(), // Flatten the array of arrays
     } );
   } catch ( error ) {
     logger.error( { error: error, function: 'datewiseDowntime' } );
@@ -880,55 +773,47 @@ export async function streamwiseDowntime( req, res ) {
   try {
     const store = await findOneStore( { storeId: req.body.storeId } );
     if ( !store ) {
-      return res.sendError( 'Stores Not fond', 204 );
+      return res.sendError( 'Store not found', 204 );
     }
-    let startHour = store.storeProfile.open.split( ':' )[0];
-    let endHour = store.storeProfile.close.split( ':' )[0];
+
+    const startHour = store.storeProfile.open.split( ':' )[0];
+    const endHour = store.storeProfile.close.split( ':' )[0];
     const interval = 60; // 1 hour in minutes
     const TimeSlots = generateTimeSlots( startHour, endHour, interval, req );
-    let timewise = [];
-    for ( const obj of TimeSlots ) {
-      obj.startTime = dayjs( obj.from ).format( 'hh:mm A' );
-      obj.endTime = dayjs( obj.to ).format( 'hh:mm A' );
-      let downTimeQuery = {
-        'size': 1,
-        'query': {
-          'bool': {
-            'must': [
-              {
-                'term': {
-                  'doc.date.keyword': dayjs( obj.from ).format( 'DD-MM-YYYY' ),
-                },
-              },
-              {
-                'term': {
-                  'doc.store_id.keyword': req.body.storeId,
-                },
-              },
-              {
-                'term': {
-                  'doc.hour.keyword': obj.hour,
-                },
-              },
-            ],
 
+    const parsedOpenSearch = JSON.parse( process.env.OPENSEARCH );
+    const downTimeIndex = parsedOpenSearch.downTimeHourly;
+
+    const batchRequests = TimeSlots.map( async ( obj ) => {
+      const formattedDate = dayjs( obj.from ).format( 'DD-MM-YYYY' );
+      const downTimeQuery = {
+        size: 1,
+        query: {
+          bool: {
+            must: [
+              { term: { 'doc.date.keyword': formattedDate } },
+              { term: { 'doc.store_id.keyword': req.body.storeId } },
+              { term: { 'doc.hour.keyword': obj.hour } },
+            ],
           },
         },
       };
-      const downtime = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).downTimeHourly, downTimeQuery );
 
-      let streamwiseDowntime = downtime.body.hits.hits.length > 0 ? downtime.body.hits.hits[0]._source.doc.streamwise_downtime : [];
-      if ( streamwiseDowntime.length > 0 ) {
-        for ( let stream of streamwiseDowntime ) {
-          if ( stream.stream === req.body.stream ) {
-            obj.downTime= stream.down_time;
-          }
-        }
-      } else {
-        obj.downTime= '';
-      }
-      timewise.push( obj );
-    }
+      const downtime = await getOpenSearchData( downTimeIndex, downTimeQuery );
+      const streamwiseDowntime = downtime.body.hits.hits.length > 0 ?
+        downtime.body.hits.hits[0]._source.doc.streamwise_downtime : [];
+
+      const foundStream = streamwiseDowntime.find( ( stream ) => stream.stream === req.body.stream );
+      return {
+        startTime: dayjs( obj.from ).format( 'hh:mm A' ),
+        endTime: dayjs( obj.to ).format( 'hh:mm A' ),
+        downTime: foundStream ? foundStream.down_time : '',
+        hour: obj.hour,
+
+      };
+    } );
+
+    const timewise = await Promise.all( batchRequests );
     res.sendSuccess( timewise );
   } catch ( error ) {
     logger.error( { error: error, function: 'streamwiseDowntime' } );
@@ -936,73 +821,61 @@ export async function streamwiseDowntime( req, res ) {
   }
 }
 
-export async function livecountCheck( inputData, req ) {
-  return new Promise( async ( Resolve, Reject ) => {
-    try {
-      let TimeSlots = generateTimeSlots( inputData.start, inputData.end, inputData.interval, req );
-      let timewise = [];
-      for ( const obj of TimeSlots ) {
-        obj.startTime = dayjs( obj.from ).format( 'hh:mm A' );
-        obj.endTime = dayjs( obj.to ).format( 'hh:mm A' );
-        let downTimeQuery = {
-          'size': 1,
-          'query': {
-            'bool': {
-              'must': [
-                {
-                  'term': {
-                    'doc.date.keyword': dayjs( obj.from ).format( 'DD-MM-YYYY' ),
-                  },
-                },
-                {
-                  'term': {
-                    'doc.store_id.keyword': req.body.storeId,
-                  },
-                },
-                {
-                  'terms': {
-                    'doc.hour.keyword': [ obj.hour ],
-                  },
-                },
-              ],
 
-            },
+export async function livecountCheck( inputData, singleDate, req ) {
+  try {
+    const TimeSlots = generateTimeSlots( inputData.start, inputData.end, inputData.interval, req );
+
+    const queryPromises = TimeSlots.map( async ( obj ) => {
+      obj.startTime = dayjs( obj.from ).format( 'hh:mm A' );
+      obj.endTime = dayjs( obj.to ).format( 'hh:mm A' );
+
+      const downTimeQuery = {
+        size: 1,
+        query: {
+          bool: {
+            must: [
+              { term: { 'doc.date.keyword': dayjs( obj.from ).format( 'DD-MM-YYYY' ) } },
+              { term: { 'doc.store_id.keyword': req.body.storeId } },
+              { terms: { 'doc.hour.keyword': [ obj.hour ] } },
+            ],
           },
-        };
-        const downtime = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).downTimeHourly, downTimeQuery );
-        let streamwiseDowntime = downtime.body.hits.hits.length > 0 ? downtime.body.hits.hits[0]._source.doc.streamwise_downtime : [];
-        if ( streamwiseDowntime.length > 0 ) {
-          const sum = streamwiseDowntime.reduce( ( accumulator, currentValue ) => {
-            return accumulator + currentValue.down_time;
-          }, 0 );
-          const average = sum / streamwiseDowntime.length;
-          obj[obj.startTime + '-' + obj.endTime] = Math.round( average );
-        } else {
-          obj[obj.startTime + '-' + obj.endTime] = '';
-        }
+        },
+      };
 
-        timewise.push( obj );
+      const downtime = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).downTimeHourly, downTimeQuery );
+      const streamwiseDowntime = downtime.body.hits.hits.length > 0 ? downtime.body.hits.hits[0]._source.doc.streamwise_downtime : [];
+      if ( streamwiseDowntime.length > 0 ) {
+        const sum = streamwiseDowntime.reduce( ( accumulator, currentValue ) => accumulator + currentValue.down_time, 0 );
+        const average = sum / streamwiseDowntime.length;
+        obj[obj.startTime + '-' + obj.endTime] = Math.round( average );
+      } else {
+        obj[obj.startTime + '-' + obj.endTime] = '';
       }
-      const mergedData = {
-        Date: dayjs( req.body.Date ).format( 'YYYY-MM-DD' ),
-      };
-      timewise.forEach( ( obj ) => {
-        for ( const key in obj ) {
-          if ( key !== 'hour' && key !== 'from' && key !== 'to' && key !== 'startTime' && key !== 'endTime' && key !== 'clientId' ) {
-            if ( mergedData[key] ) {
-              mergedData[key] += obj[key];
-            } else {
-              mergedData[key] = obj[key];
-            }
+      return obj;
+    } );
+
+    const timewise = await Promise.all( queryPromises );
+
+
+    const mergedData = {
+      Date: dayjs( singleDate ).format( 'YYYY-MM-DD' ),
+    };
+
+    timewise.forEach( ( obj ) => {
+      for ( const key in obj ) {
+        if ( key !== 'hour' && key !== 'from' && key !== 'to' && key !== 'startTime' && key !== 'endTime' && key !== 'clientId' ) {
+          if ( mergedData[key] ) {
+            mergedData[key] += obj[key];
+          } else {
+            mergedData[key] = obj[key];
           }
         }
-      } );
+      }
+    } );
 
-      // Create an array with the merged data.
-      const mergedArray = [ mergedData ];
-      Resolve( mergedArray );
-    } catch ( err ) {
-      Reject( err );
-    }
-  } );
+    return [ mergedData ];
+  } catch ( err ) {
+    throw err;
+  }
 }