tango-app-api-infra 3.9.25-vmsbug.2 → 3.9.26

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-infra",
-    "version": "3.9.25-vmsbug.2",
+    "version": "3.9.26",
     "description": "infra",
     "main": "index.js",
     "type": "module",

package/src/controllers/internalInfra.controller.js

@@ -452,11 +452,11 @@ export async function emailUserList( req, res ) {
         }
       }
       if ( getconfigs.ticketConfigs.infraReport.allowSpoc ) {
-        let spocList=[];
+        let spocList = [];
         let storelist = await findStore( { 'clientId': req.query.clientId, 'status': 'active', 'edge.firstFile': true }, { 'storeId': 1, 'storeProfile.timeZone': 1, 'spocDetails': 1 } );
         for ( let store of storelist ) {
-          if ( store.spocDetails&&store.spocDetails.length>0 ) {
-            if ( store.spocDetails[0].email!='' ) {
+          if ( store.spocDetails && store.spocDetails.length > 0 ) {
+            if ( store.spocDetails[0].email != '' ) {
               spocList.push( {
                 clientId: req.query.clientId,
                 ticketConfigs: getconfigs.ticketConfigs,
@@ -481,7 +481,7 @@ export async function emailUserList( req, res ) {
             userName: user.name,
             storeList: [],
           };
-          if ( user.stores&&user.stores.length>0 ) {
+          if ( user.stores && user.stores.length > 0 ) {
             let storelist = await findStore( { 'storeId': { $in: user.stores }, 'status': 'active', 'edge.firstFile': true }, { 'storeId': 1, 'storeProfile.timeZone': 1 } );
             obj.storeList = storelist;
           }
@@ -510,7 +510,7 @@ export async function emailUserList( req, res ) {
           user.storeList = [];
           for ( let group of user.assignedValue ) {
             let groupdata = await findOneGroup( { '_id': group, 'clientId': user.clientId } );
-            if ( groupdata&&groupdata.storeList ) {
+            if ( groupdata && groupdata.storeList ) {
               let storelist = await findStore( { 'storeId': { $in: groupdata.storeList }, 'status': 'active', 'edge.firstFile': true }, { 'storeId': 1, 'storeProfile.timeZone': 1 } );
               user.storeList = [ ...user.storeList, ...storelist ];
             }
@@ -529,7 +529,7 @@ export async function emailUserList( req, res ) {
             }
           }
         } else if ( user.ticketConfigs.infraReport.type && user.ticketConfigs.infraReport.type === 'defined' ) {
-          let times =await generateTimeIntervals( user.ticketConfigs.infraReport.startTime, user.ticketConfigs.infraReport.endTime, user.ticketConfigs.infraReport.interval );
+          let times = await generateTimeIntervals( user.ticketConfigs.infraReport.startTime, user.ticketConfigs.infraReport.endTime, user.ticketConfigs.infraReport.interval );
           for ( let store of user.storeList ) {
             const result = await checkStoreTimezoneMatchesInterval( times, store.storeProfile.timeZone );
             if ( result ) {
@@ -653,11 +653,11 @@ export async function emailUserListv2( req, res ) {
         }
       }
       if ( getconfigs.ticketConfigs.infraReport.allowSpoc ) {
-        let spocList=[];
+        let spocList = [];
         let storelist = await findStore( { 'clientId': req.query.clientId, 'status': 'active', 'edge.firstFile': true }, { 'storeId': 1, 'storeProfile.timeZone': 1, 'spocDetails': 1 } );
         for ( let store of storelist ) {
-          if ( store.spocDetails&&store.spocDetails.length>0 ) {
-            if ( store.spocDetails[0].email!='' ) {
+          if ( store.spocDetails && store.spocDetails.length > 0 ) {
+            if ( store.spocDetails[0].email != '' ) {
               spocList.push( {
                 clientId: req.query.clientId,
                 ticketConfigs: getconfigs.ticketConfigs,
@@ -682,14 +682,14 @@ export async function emailUserListv2( req, res ) {
             userName: user.name,
             storeList: [],
           };
-          if ( user.stores&&user.stores.length>0 ) {
+          if ( user.stores && user.stores.length > 0 ) {
             let storelist = await findStore( { 'storeId': { $in: user.stores }, 'status': 'active', 'edge.firstFile': true }, { 'storeId': 1, 'storeProfile.timeZone': 1 } );
             obj.storeList = storelist;
           }
           for ( let cluster of user.clusters ) {
             let clusterdata = await findOneCluster( { '_id': cluster, 'clientId': req.query.clientId } );
 
-            if ( clusterdata&&clusterdata.stores ) {
+            if ( clusterdata && clusterdata.stores ) {
               let stores = clusterdata.stores.map( ( data ) => data.storeId );
               let storelist = await findStore( { 'storeId': { $in: stores }, 'status': 'active', 'edge.firstFile': true }, { 'storeId': 1, 'storeProfile.timeZone': 1 } );
 
@@ -707,7 +707,7 @@ export async function emailUserListv2( req, res ) {
     for ( let user of clientList ) {
       if ( user.userType == 'client' ) {
         if ( user.role !== 'superadmin' ) {
-          let storeIds =new Set();
+          let storeIds = new Set();
           if ( user.assignedStores ) {
             storeIds = new Set( user.assignedStores.map( ( store ) => store.storeId ) );
           }
@@ -745,7 +745,7 @@ export async function emailUserListv2( req, res ) {
             }
           }
           let TeamMember = await findteams( { clientId: user.clientId, users: { $elemMatch: { email: user.email } } } );
-          if ( TeamMember&&TeamMember.length>0 ) {
+          if ( TeamMember && TeamMember.length > 0 ) {
             for ( let team of TeamMember ) {
               let clusterList = await findcluster( { clientId: user.clientId, teams: { $elemMatch: { name: team.teamName } } } );
               if ( clusterList.length > 0 ) {
@@ -756,7 +756,7 @@ export async function emailUserListv2( req, res ) {
             }
           }
           let TeamLeader = await findteams( { clientId: user.clientId, Teamlead: { $elemMatch: { email: user.email } } } );
-          if ( TeamLeader&&TeamLeader.length>0 ) {
+          if ( TeamLeader && TeamLeader.length > 0 ) {
             for ( let team of TeamLeader ) {
               let clusterList = await findcluster( { clientId: user.clientId, teams: { $elemMatch: { name: team.teamName } } } );
               if ( clusterList.length > 0 ) {
@@ -790,7 +790,7 @@ export async function emailUserListv2( req, res ) {
             }
           }
         } else if ( user.ticketConfigs.infraReport.type && user.ticketConfigs.infraReport.type === 'defined' ) {
-          let times =await generateTimeIntervals( user.ticketConfigs.infraReport.startTime, user.ticketConfigs.infraReport.endTime, user.ticketConfigs.infraReport.interval );
+          let times = await generateTimeIntervals( user.ticketConfigs.infraReport.startTime, user.ticketConfigs.infraReport.endTime, user.ticketConfigs.infraReport.interval );
           for ( let store of user.storeList ) {
             const result = await checkStoreTimezoneMatchesInterval( times, store.storeProfile.timeZone );
             if ( result ) {
@@ -941,7 +941,7 @@ export async function infraReportSent( req, res ) {
 
     let ticketList = await aggregateTangoTicket( query );
     const exportdata = [];
-    if ( ticketList&&ticketList.length>0 ) {
+    if ( ticketList && ticketList.length > 0 ) {
       for ( let element of ticketList ) {
         let clientuser = await findOneUser( { _id: element.ticketDetails.addressingClient } );
         let tangouser = await findOneUser( { _id: element.ticketDetails.addressingUser } );
@@ -953,7 +953,7 @@ export async function infraReportSent( req, res ) {
           'BrandName': element.basicDetails.clientName,
           'TicketCreatedDate & Time': dayjs( element.createdAt ).tz( 'Asia/Kolkata' ).format( 'YYYY-MM-DD HH:mm A' ),
           'StoreID': element.basicDetails.storeId,
-          'StoreCode': findstore.storeProfile&&findstore.storeProfile.storeCode?findstore.storeProfile.storeCode:'-',
+          'StoreCode': findstore.storeProfile && findstore.storeProfile.storeCode ? findstore.storeProfile.storeCode : '-',
           'StoreName': element.basicDetails.storeName,
           'PrimaryIssue ': element.primaryIssue,
           'SecondaryIssue': element.secondaryIssue,
@@ -1113,6 +1113,7 @@ export async function camAngleChangeReport( req, res ) {
               'Store Name': findStore.storeName,
               'Store Code': findStore.storeId,
               'Date Changed': formattedPreviousDay,
+              'Reason': stream?.reason?stream?.reason:'-',
               'ImageURL': {
                 url: Image,
                 label: 'Angle changed Image',
@@ -1208,7 +1209,7 @@ export async function edgeApplogsCheck( req, res ) {
       const errorLogList = await getOpenSearchData( JSON.parse( process.env.OPENSEARCH ).edgeAppSystemLogs, errorLog );
       let internetSlowcount = [];
       let result = [];
-      let apploginCount=[];
+      let apploginCount = [];
       function createLogCheck( error ) {
         return {
           code: error._source.log_code,
@@ -1243,7 +1244,7 @@ export async function edgeApplogsCheck( req, res ) {
       let newraray = apploginCount.reverse();
 
       let findissueEdgeApp = {};
-      if ( newraray.length>0 ) {
+      if ( newraray.length > 0 ) {
         result = [ ...result, ...[ newraray[0] ] ];
       }
       if ( result.length > 0 ) {
@@ -1436,7 +1437,7 @@ export async function edgeApplogsCheck( req, res ) {
               item.ticketId === ticket.ticketId,
             );
             if ( !existsInArray ) {
-              if ( diffInMinutes>60 &&diffInMinutes<=180 ) {
+              if ( diffInMinutes > 60 && diffInMinutes <= 180 ) {
                 findissueEdgeApp = {
                   ticketId: ticket.ticketId,
                   edgelog: findissue,
@@ -1479,86 +1480,330 @@ export async function edgeApplogsCheck( req, res ) {
     res.sendError( error, 500 );
   }
 }
+async function processTicket( ticket, opensearch ) {
+  const ticketResult = [];
+  const ticketNotAddressed = [];
+
+  const date = dayjs( ticket.createdAt ).format( 'YYYY-MM-DD' );
+  const istTimestamp = dayjs.utc( ticket.createdAt ).tz( 'Asia/Kolkata' ).format( 'HH:mm:ss' );
+  const ticketTime = dayjs( `${date} ${istTimestamp}` );
+
+  const RELEVANT_CODES = new Set( [ 1000, 1003, 1004, 1007, 1011, 1013, 1014, 1016, 1022, 1024, 1025, 1026, 1044, 1050, 1051, 1053, 1055, 1056, 1057, 1058 ] );
+
+  // ── Fetch logs from OpenSearch ─────────────────────────────────────────
+  const errorLogList = await getOpenSearchData( opensearch.edgeAppSystemLogs, {
+    size: 5000,
+    query: {
+      bool: {
+        must: [
+          { range: { log_code: { gte: 1000 } } },
+          { term: { 'store_date.keyword': dayjs( date ).format( 'DD-MM-YYYY' ) } },
+          { term: { 'storeId.keyword': ticket.basicDetails.storeId } },
+        ],
+      },
+    },
+    sort: [ { timestamp: { order: 'asc' } } ],
+  } );
+
+  // ── Classify logs into result and reference buckets ────────────────────
+  const result = [];
+  const resumeLogs = []; // 1010 — paired with 1011 (sleep mode)
+  const internetConnectedLogs = []; // 1006 — paired with 1007/2007 (internet down)
+  const loginLogs = []; // 1052/1054 — paired with 1058 and 1053
+
+  for ( const error of errorLogList.body.hits.hits ) {
+    const logCode = Number( error._source.log_code );
+    const log = { code: String( logCode ), edgelog: error._source.data };
+
+    if ( RELEVANT_CODES.has( logCode ) ) result.push( log );
+    if ( logCode === 1010 ) resumeLogs.push( log );
+    if ( logCode === 1006 ) internetConnectedLogs.push( log );
+    if ( logCode === 1052 || logCode === 1054 ) loginLogs.push( log );
+    if ( logCode > 2000 && logCode !== 2014 ) result.push( log );
+    if ( logCode === 1005 ) {
+      const megabytes = bytesToMB( error._source.data.upload_Speed.split( '.' )[0] );
+      if ( megabytes < 2 ) result.push( log );
+    }
+  }
+
+  if ( !result.length ) return { ticketResult, ticketNotAddressed };
+
+  // ── Helpers scoped to this ticket ──────────────────────────────────────
+  const codeSet = new Set( result.map( ( r ) => Number( r.code ) ) );
+  const logTime = ( time ) => dayjs( `${date} ${time}` );
+  const beforeTicket = ( time ) => logTime( time ).isBefore( ticketTime );
+  const refLogBefore = ( refLogs, targetTime ) =>
+    refLogs.find( ( l ) => logTime( l.edgelog.occuringTime ).isBefore( targetTime ) );
+
+  let storeData = null;
+  const getStore = async () => {
+    if ( !storeData ) storeData = await findOneStore( { storeId: ticket.basicDetails.storeId } );
+    return storeData;
+  };
+
+  const recordIssue = async ( primary, secondary, edgelog ) => {
+    const issue = { ticketId: ticket.ticketId, storeId: ticket.basicDetails.storeId, primary, secondary, edgelog };
+    const updateResult = await updateIssue( issue );
+    if ( updateResult?.skipped ) {
+      ticketNotAddressed.push( { ticketId: ticket.ticketId, storeId: ticket.basicDetails.storeId, storeName: ticket.basicDetails.storeName, reason: updateResult.reason } );
+    } else {
+      ticketResult.push( issue );
+    }
+  };
+
+  const appcrashcount = [];
+  const appservercount = [];
+  const logincount = [];
+
+  for ( const log of result ) {
+    if ( ticketResult.length || ticketNotAddressed.length ) break;
+
+    const code = Number( log.code );
+    const occursAt = log.edgelog?.occuringTime;
+
+    // ── System Issues ──────────────────────────────────────────────────
+
+    if ( code === 1003 && beforeTicket( occursAt ) ) {
+      await recordIssue( 'System Issues', [ 'Antivirus blocking' ], log );
+    }
+
+    if ( code === 1000 && beforeTicket( occursAt ) ) {
+      // Antivirus blocking: >= 3 app crashes within a 1-hour window
+      appcrashcount.push( logTime( occursAt ) );
+      const oneHourAgo = logTime( occursAt ).subtract( 1, 'hour' );
+      if ( appcrashcount.filter( ( t ) => t.isAfter( oneHourAgo ) ).length >= 3 ) {
+        await recordIssue( 'System Issues', [ 'Antivirus blocking' ], log );
+      }
+    }
+
+    if ( code === 1011 && beforeTicket( occursAt ) ) {
+      // Sleep mode: resume (1010) came more than 15 min after suspend (1011)
+      const suspendTime = logTime( occursAt );
+      const resumeLog = resumeLogs.find( ( r ) => logTime( r.edgelog.occuringTime ).isAfter( suspendTime ) );
+      if ( resumeLog ) {
+        const diffMin = logTime( resumeLog.edgelog.occuringTime ).diff( suspendTime, 'minute' );
+        if ( diffMin > 15 ) await recordIssue( 'System Issues', [ 'System is in Sleep Mode' ], log );
+      }
+    }
+
+    if ( code === 1051 && beforeTicket( occursAt ) ) {
+      // High utilization: any of CPU / memory / disk >= 90%
+      const cpu = Number( log.edgelog.cpu_usage ) || 0;
+      const memory = Number( log.edgelog.memory_usage ) || 0;
+      const disk = Number( log.edgelog.disk_usage ) || 0;
+      if ( cpu >= 90 || memory >= 90 || disk >= 90 ) {
+        await recordIssue( 'System Issues', [ 'System utilization high - CPU or memory or Disk' ], log );
+      }
+    }
+
+    if ( code === 1014 && beforeTicket( occursAt ) ) {
+      // Confirm mismatch occurred during store operating hours (in the store's registered timezone)
+      const store = await getStore();
+      const occurTimeInStoreZone = dayjs.tz( `${date} ${occursAt}`, 'Asia/Kolkata' ).tz( store.storeProfile.timeZone );
+      const storeOpenInStoreZone = dayjs.tz( `${date} ${store.storeProfile.open}`, store.storeProfile.timeZone );
+      const storeCloseInStoreZone = dayjs.tz( `${date} ${store.storeProfile.close}`, store.storeProfile.timeZone );
+      if ( occurTimeInStoreZone.isAfter( storeOpenInStoreZone ) && occurTimeInStoreZone.isBefore( storeCloseInStoreZone ) ) {
+        await recordIssue( 'System Issues', [ 'Date/Time Mismatch Issue' ], log );
+      }
+    }
+
+    // ── Camera Issues ──────────────────────────────────────────────────
+
+    if ( code === 2024 && beforeTicket( occursAt ) ) {
+      await recordIssue( 'Camera Issues', [ 'Camera Not working due Network disconnect' ], log.edgelog );
+    }
+
+    if ( code === 1024 && beforeTicket( log.edgelog?.data?.occuringTime ) ) {
+      //   1024 + 1050 + 1055  →  Network switched
+      //   1024 + 1055         →  Camera not working
+      //   1024 + 1056         →  RTSP / credential changed
+      let secondary;
+      if ( codeSet.has( 1050 ) && codeSet.has( 1055 ) ) secondary = 'Camera Not working because of Network switched';
+      else if ( codeSet.has( 1055 ) ) secondary = 'Camera Not working';
+      else if ( codeSet.has( 1056 ) ) secondary = 'RTSP URL not supported / Camera credential changed';
+      if ( secondary ) await recordIssue( 'Camera Issues', [ secondary ], log.edgelog?.data );
+    }
+
+    // ── Operational Issues ─────────────────────────────────────────────
+
+    if ( code === 1004 || code === 1013 ) {
+      // System turned on lately: app/system start >= 20 min after store open
+      const store = await getStore();
+      const diffMin = logTime( occursAt ).diff( logTime( store.storeProfile.open ), 'minute' );
+      if ( diffMin >= 20 ) await recordIssue( 'Store Operation Issues', [ 'System turned on lately' ], log );
+    }
+
+    if ( code === 1058 && beforeTicket( occursAt ) ) {
+      // User logged in lately: 1058 came > 5 min after last login event (1052/1054)
+      const loginLog = refLogBefore( loginLogs, logTime( occursAt ) );
+      if ( loginLog ) {
+        const diffMin = logTime( occursAt ).diff( logTime( loginLog.edgelog.occuringTime ), 'minute' );
+        if ( diffMin > 5 ) await recordIssue( 'Store Operation Issues', [ 'User logged in lately' ], log );
+      }
+    }
+
+    if ( code === 1053 && beforeTicket( occursAt ) ) {
+      // System turned off: shutdown (1053) came > 15 min after last login event (1052/1054)
+      const loginLog = refLogBefore( loginLogs, logTime( occursAt ) );
+      if ( loginLog ) {
+        const diffMin = logTime( occursAt ).diff( logTime( loginLog.edgelog.occuringTime ), 'minute' );
+        if ( diffMin > 15 ) await recordIssue( 'Store Operation Issues', [ 'System turned off' ], log );
+      }
+    }
+
+    // ── App Issues ─────────────────────────────────────────────────────
+
+    if ( code === 1025 && beforeTicket( occursAt ) ) {
+      await recordIssue( 'Application Issues', [ 'App Without Stream' ], log.edgelog );
+    }
+
+    if ( code === 1057 && beforeTicket( occursAt ) ) {
+      // App server issue: > 5 occurrences within a 1-hour window
+      appservercount.push( logTime( occursAt ) );
+      const oneHourAgo = logTime( occursAt ).subtract( 1, 'hour' );
+      if ( appservercount.filter( ( t ) => t.isAfter( oneHourAgo ) ).length > 5 ) {
+        await recordIssue( 'Application Issues', [ 'App server issue' ], log );
+      }
+    }
+
+    if ( code === 1016 && beforeTicket( occursAt ) ) {
+      await recordIssue( 'Application Issues', [ 'App login issue' ], log );
+    }
+
+    // ── Internet Issues ────────────────────────────────────────────────
+
+    if ( ( code === 1007 || code === 2007 ) && beforeTicket( occursAt ) ) {
+      // Internet not working: disconnect (1007/2007) came > 10 min after last connect (1006)
+      const connectedLog = refLogBefore( internetConnectedLogs, logTime( occursAt ) );
+      if ( connectedLog ) {
+        const diffMin = logTime( occursAt ).diff( logTime( connectedLog.edgelog.occuringTime ), 'minute' );
+        if ( diffMin > 10 ) await recordIssue( 'Internet Issues', [ 'Internet not working' ], log );
+      }
+    }
+
+    if ( code === 2004 ) {
+      // Internet not working (legacy): > 3 disconnects after store open and before ticket time
+      const store = await getStore();
+      const occurTime = logTime( occursAt );
+      if ( occurTime.isBefore( ticketTime ) && occurTime.isAfter( logTime( store.storeProfile.open ) ) ) {
+        logincount.push( occursAt );
+        if ( logincount.length > 3 ) await recordIssue( 'Internet Issues', [ 'Internet not working' ], log );
+      }
+    }
+
+    if ( ( code === 1026 || code === 1044 ) && beforeTicket( occursAt ) ) {
+      // Internet Slow: files pushed to cloud in 30 min <= 3
+      if ( ( Number( log.edgelog.files_pushed ) || 0 ) <= 3 ) {
+        await recordIssue( 'Internet Issues', [ 'Internet Slow' ], log );
+      }
+    }
+  }
+
+  return { ticketResult, ticketNotAddressed };
+}
+
+export async function edgeApplogsCheckv2( req, res ) {
+  try {
+    const opensearch = JSON.parse( process.env.OPENSEARCH );
+    const finalresult = [];
+    const notAddressed = [];
+
+    const ticketList = await findTangoTicket( {
+      'issueDate': new Date( req.body.issueDate ),
+      'status': { $ne: 'closed' },
+      'ticketDetails.issueStatus': 'notidentified',
+      'issueType': 'infra',
+    } );
+
+    // Process tickets in parallel chunks to avoid sequential bottleneck
+    const CHUNK_SIZE = 10;
+    for ( let i = 0; i < ticketList.length; i += CHUNK_SIZE ) {
+      const chunk = ticketList.slice( i, i + CHUNK_SIZE );
+      const chunkResults = await Promise.all( chunk.map( ( ticket ) => processTicket( ticket, opensearch ) ) );
+      for ( const { ticketResult, ticketNotAddressed } of chunkResults ) {
+        finalresult.push( ...ticketResult );
+        notAddressed.push( ...ticketNotAddressed );
+      }
+    }
+
+    res.sendSuccess( { count: finalresult.length, result: finalresult, notAddressedCount: notAddressed.length, notAddressed } );
+  } catch ( error ) {
+    logger.error( { error, function: 'edgeApplogsCheckv2' } );
+    res.sendError( error, 500 );
+  }
+}
+
 function bytesToMB( bytes ) {
   return bytes / ( 1024 * 1024 );
 }
 
 export async function updateIssue( data ) {
   try {
-    let Ticket = await findOneTangoTicket(
-        {
-          ticketId: data.ticketId,
-        },
-    );
-    if ( Ticket ) {
-      data.issueType = Ticket.issueType;
-      data.basicDetails = Ticket.basicDetails;
-      data.ticketDetails = Ticket.ticketDetails;
-      data.ticketActivity = Ticket.ticketActivity;
-      if ( data.primary && data.secondary && data.secondary.length ) {
-        let primaryReason = await findOneinfraReason( { name: data.primary } );
-        if ( !primaryReason ) {
-          return res.sendError( 'Primary Reason Not exists in database', 500 );
-        }
-        const secondary = [];
-        const steptoReslove = [];
-        for ( let i = 0; i < data.secondary.length; i++ ) {
-          let secondaryReason = await findOneinfraReason( { name: data.secondary[i] } );
-          if ( !secondaryReason ) {
-            return res.sendError( `secondary Reason - ${data.secondary[i]} Not exists in database`, 500 );
-          }
-          secondary.push( {
-            name: secondaryReason.name,
-          } );
-          let resolveSteps = [];
-          for ( let i = 0; i < secondaryReason.stepstoResolve.length; i++ ) {
-            resolveSteps.push( {
-              name: secondaryReason.stepstoResolve[i].name,
-            } );
-          }
-          steptoReslove.push( {
-            primaryIssue: secondaryReason.name,
-            secondaryIsssue: [ ...resolveSteps ],
-          } );
-        }
-
-        data.ticketActivity.push( {
-          actionType: 'issueUpdate',
-          actionBy: 'automated',
-          IdentifiedBy: 'Tango',
-          timeStamp: new Date(),
-          reasons: [ {
-            primaryIssue: primaryReason.name,
-            secondaryIssue: secondary,
-          } ],
-        },
-        );
+    const Ticket = await findOneTangoTicket( { ticketId: data.ticketId } );
+    if ( !Ticket ) return { success: true };
+
+    data.issueType = Ticket.issueType;
+    data.basicDetails = Ticket.basicDetails;
+    data.ticketDetails = Ticket.ticketDetails;
+    data.ticketActivity = Ticket.ticketActivity;
+
+    if ( data.primary && data.secondary && data.secondary.length ) {
+      const primaryReason = await findOneinfraReason( { name: data.primary } );
+      if ( !primaryReason ) {
+        logger.warn( { message: `Primary reason not found: ${data.primary}`, ticketId: data.ticketId } );
+        return { skipped: true, ticketId: data.ticketId, storeId: data.storeId, reason: `Primary reason not found: ${data.primary}` };
       }
-      if ( data.issueType == 'infra' ) {
-        let client = await findOneClient( { clientId: data.basicDetails.clientId }, { ticketConfigs: 1 } );
-        let statusCheckAlertTime = dayjs().add( client.ticketConfigs.statusCheckAlert, 'hours' ).format( 'YYYY-MM-DD hh:mm' );
-        data.ticketActivity.push( {
-          actionType: 'statusCheck',
-          timeStamp: statusCheckAlertTime,
-          actionBy: 'Tango',
-          IdentifiedBy: 'Tango',
-          statusCheckAlertTime: statusCheckAlertTime,
+
+      const secondary = [];
+      const steptoReslove = [];
+      for ( const secondaryName of data.secondary ) {
+        const secondaryReason = await findOneinfraReason( { name: secondaryName } );
+        if ( !secondaryReason ) {
+          logger.warn( { message: `Secondary reason not found: ${secondaryName}`, ticketId: data.ticketId } );
+          return { skipped: true, ticketId: data.ticketId, storeId: data.storeId, reason: `Secondary reason not found: ${secondaryName}` };
+        }
+        secondary.push( { name: secondaryReason.name } );
+        steptoReslove.push( {
+          primaryIssue: secondaryReason.name,
+          secondaryIsssue: secondaryReason.stepstoResolve.map( ( s ) => ( { name: s.name } ) ),
         } );
       }
-      let client = await findOneClient( { clientId: data.basicDetails.clientId } );
-      let refreshdate = dayjs().add( client.ticketConfigs.refreshAlert, 'days' );
-
-      let query = {
-        'ticketActivity': data.ticketActivity,
-        'ticketDetails.issueIdentifiedDate': new Date(),
-        'ticketDetails.issueStatus': 'identified',
-        'status': 'inprogress',
-        'ticketDetails.ticketRefreshTime': new Date( dayjs( refreshdate ).format( 'YYYY-MM-DD' ) ),
-      };
-      await updateOneTangoTicket( { ticketId: data.ticketId }, query );
+
+      data.ticketActivity.push( {
+        actionType: 'issueUpdate',
+        actionBy: 'automated',
+        IdentifiedBy: 'Tango',
+        timeStamp: new Date(),
+        reasons: [ { primaryIssue: primaryReason.name, secondaryIssue: secondary } ],
+      } );
+    }
+
+    if ( data.issueType == 'infra' ) {
+      const client = await findOneClient( { clientId: data.basicDetails.clientId }, { ticketConfigs: 1 } );
+      const statusCheckAlertTime = dayjs().add( client.ticketConfigs.statusCheckAlert, 'hours' ).format( 'YYYY-MM-DD hh:mm' );
+      data.ticketActivity.push( {
+        actionType: 'statusCheck',
+        timeStamp: statusCheckAlertTime,
+        actionBy: 'Tango',
+        IdentifiedBy: 'Tango',
+        statusCheckAlertTime,
+      } );
     }
+
+    const client = await findOneClient( { clientId: data.basicDetails.clientId } );
+    const refreshdate = dayjs().add( client.ticketConfigs.refreshAlert, 'days' );
+    await updateOneTangoTicket( { ticketId: data.ticketId }, {
+      'ticketActivity': data.ticketActivity,
+      'ticketDetails.issueIdentifiedDate': new Date(),
+      'ticketDetails.issueStatus': 'identified',
+      'status': 'inprogress',
+      'ticketDetails.ticketRefreshTime': new Date( dayjs( refreshdate ).format( 'YYYY-MM-DD' ) ),
+    } );
+
+    return { success: true };
   } catch ( error ) {
-    logger.error( { error: error, function: 'updateAutomaticIssue' } );
+    logger.error( { error, function: 'updateAutomaticIssue' } );
+    return { success: true }; // don't block the caller on unexpected errors
   }
 }