snow-flow 2.0.5 → 2.0.7

package/servicenow/widgets/openai_incident_classifier/client_controller.js

@@ -0,0 +1,284 @@
+function OpenAIIncidentClassifierController($scope, $http, spUtil) {
+  var c = this;
+  
+  // Initialize variables
+  c.incidents = [];
+  c.statistics = {
+    totalIncidents: 0,
+    classifiedIncidents: 0,
+    averageConfidence: 0,
+    processingTime: 0
+  };
+  c.isLoading = false;
+  c.error = null;
+  c.charts = {};
+  
+  // Date range and filtering
+  c.dateRange = {
+    start: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
+    end: new Date().toISOString().split('T')[0]
+  };
+  c.selectedPriority = '';
+  
+  // Pagination
+  c.pagination = {
+    currentPage: 1,
+    pageSize: 10,
+    totalPages: 1,
+    totalRecords: 0,
+    pages: []
+  };
+  
+  // Initialize widget
+  c.initialize = function() {
+    c.loadData();
+  };
+  
+  // Load data from server
+  c.loadData = function() {
+    c.isLoading = true;
+    c.error = null;
+    
+    var params = {
+      start_date: c.dateRange.start,
+      end_date: c.dateRange.end,
+      priority: c.selectedPriority,
+      page: c.pagination.currentPage,
+      page_size: c.pagination.pageSize
+    };
+    
+    $http.post('/api/now/sp/widget/' + c.widget.id, {
+      action: 'get_incidents',
+      params: params
+    }).then(function(response) {
+      if (response.data.result.success) {
+        c.incidents = response.data.result.incidents;
+        c.statistics = response.data.result.statistics;
+        c.pagination.totalRecords = response.data.result.total_records;
+        c.pagination.totalPages = Math.ceil(c.pagination.totalRecords / c.pagination.pageSize);
+        c.updatePaginationPages();
+        c.updateCharts();
+      } else {
+        c.error = response.data.result.error || 'Failed to load incidents';
+      }
+    }).catch(function(error) {
+      c.error = 'Error loading data: ' + (error.data && error.data.error ? error.data.error : error.message);
+    }).finally(function() {
+      c.isLoading = false;
+    });
+  };
+  
+  // Update pagination pages array
+  c.updatePaginationPages = function() {
+    c.pagination.pages = [];
+    var startPage = Math.max(1, c.pagination.currentPage - 2);
+    var endPage = Math.min(c.pagination.totalPages, c.pagination.currentPage + 2);
+    
+    for (var i = startPage; i <= endPage; i++) {
+      c.pagination.pages.push(i);
+    }
+  };
+  
+  // Go to specific page
+  c.goToPage = function(page) {
+    if (page >= 1 && page <= c.pagination.totalPages && page !== c.pagination.currentPage) {
+      c.pagination.currentPage = page;
+      c.loadData();
+    }
+  };
+  
+  // Date range change handler
+  c.onDateRangeChange = function() {
+    c.pagination.currentPage = 1;
+    c.loadData();
+  };
+  
+  // Priority change handler
+  c.onPriorityChange = function() {
+    c.pagination.currentPage = 1;
+    c.loadData();
+  };
+  
+  // Refresh data
+  c.refreshData = function() {
+    c.loadData();
+  };
+  
+  // Reclassify incident
+  c.reclassifyIncident = function(incident) {
+    c.isLoading = true;
+    
+    $http.post('/api/now/sp/widget/' + c.widget.id, {
+      action: 'reclassify_incident',
+      incident_id: incident.sys_id
+    }).then(function(response) {
+      if (response.data.result.success) {
+        spUtil.addInfoMessage('Incident reclassified successfully');
+        c.loadData();
+      } else {
+        c.error = response.data.result.error || 'Failed to reclassify incident';
+      }
+    }).catch(function(error) {
+      c.error = 'Error reclassifying incident: ' + (error.data && error.data.error ? error.data.error : error.message);
+    }).finally(function() {
+      c.isLoading = false;
+    });
+  };
+  
+  // Update charts
+  c.updateCharts = function() {
+    c.createClassificationChart();
+    c.createPriorityChart();
+    c.createTrendChart();
+  };
+  
+  // Create classification distribution chart
+  c.createClassificationChart = function() {
+    var ctx = document.getElementById('classificationChart');
+    if (!ctx) return;
+    
+    // Destroy existing chart
+    if (c.charts.classification) {
+      c.charts.classification.destroy();
+    }
+    
+    // Aggregate classification data
+    var classificationData = {};
+    c.incidents.forEach(function(incident) {
+      var classification = incident.ai_classification || 'Unclassified';
+      classificationData[classification] = (classificationData[classification] || 0) + 1;
+    });
+    
+    var labels = Object.keys(classificationData);
+    var data = Object.values(classificationData);
+    var colors = ['#dc3545', '#007bff', '#28a745', '#fd7e14', '#6f42c1', '#6c757d'];
+    
+    c.charts.classification = new Chart(ctx, {
+      type: 'doughnut',
+      data: {
+        labels: labels,
+        datasets: [{
+          data: data,
+          backgroundColor: colors.slice(0, labels.length),
+          borderWidth: 2,
+          borderColor: '#fff'
+        }]
+      },
+      options: {
+        responsive: true,
+        maintainAspectRatio: false,
+        plugins: {
+          legend: {
+            position: 'bottom'
+          }
+        }
+      }
+    });
+  };
+  
+  // Create priority distribution chart
+  c.createPriorityChart = function() {
+    var ctx = document.getElementById('priorityChart');
+    if (!ctx) return;
+    
+    // Destroy existing chart
+    if (c.charts.priority) {
+      c.charts.priority.destroy();
+    }
+    
+    // Aggregate priority data
+    var priorityData = {};
+    var priorityLabels = {'1': 'Critical', '2': 'High', '3': 'Moderate', '4': 'Low'};
+    
+    c.incidents.forEach(function(incident) {
+      var priority = incident.priority || '4';
+      var label = priorityLabels[priority] || 'Unknown';
+      priorityData[label] = (priorityData[label] || 0) + 1;
+    });
+    
+    var labels = Object.keys(priorityData);
+    var data = Object.values(priorityData);
+    var colors = ['#dc3545', '#fd7e14', '#ffc107', '#28a745'];
+    
+    c.charts.priority = new Chart(ctx, {
+      type: 'bar',
+      data: {
+        labels: labels,
+        datasets: [{
+          label: 'Number of Incidents',
+          data: data,
+          backgroundColor: colors.slice(0, labels.length),
+          borderWidth: 1
+        }]
+      },
+      options: {
+        responsive: true,
+        maintainAspectRatio: false,
+        scales: {
+          y: {
+            beginAtZero: true
+          }
+        }
+      }
+    });
+  };
+  
+  // Create trend chart
+  c.createTrendChart = function() {
+    var ctx = document.getElementById('trendChart');
+    if (!ctx) return;
+    
+    // Destroy existing chart
+    if (c.charts.trend) {
+      c.charts.trend.destroy();
+    }
+    
+    // Aggregate trend data by date
+    var trendData = {};
+    c.incidents.forEach(function(incident) {
+      var date = new Date(incident.created_date).toISOString().split('T')[0];
+      trendData[date] = (trendData[date] || 0) + 1;
+    });
+    
+    var labels = Object.keys(trendData).sort();
+    var data = labels.map(function(date) {
+      return trendData[date];
+    });
+    
+    c.charts.trend = new Chart(ctx, {
+      type: 'line',
+      data: {
+        labels: labels,
+        datasets: [{
+          label: 'Incidents per Day',
+          data: data,
+          borderColor: '#007bff',
+          backgroundColor: 'rgba(0, 123, 255, 0.1)',
+          borderWidth: 2,
+          fill: true
+        }]
+      },
+      options: {
+        responsive: true,
+        maintainAspectRatio: false,
+        scales: {
+          y: {
+            beginAtZero: true
+          }
+        }
+      }
+    });
+  };
+  
+  // Cleanup function
+  c.$onDestroy = function() {
+    Object.values(c.charts).forEach(function(chart) {
+      if (chart) {
+        chart.destroy();
+      }
+    });
+  };
+  
+  // Initialize widget when loaded
+  c.initialize();
+}

package/servicenow/widgets/openai_incident_classifier/server_script.js

@@ -0,0 +1,314 @@
+(function() {
+  // Server-side script for OpenAI Incident Classification Widget
+  
+  var OpenAIIncidentClassifier = {
+    
+    // Main data processing function
+    processRequest: function(action, params) {
+      try {
+        switch (action) {
+          case 'get_incidents':
+            return this.getIncidents(params);
+          case 'reclassify_incident':
+            return this.reclassifyIncident(params.incident_id);
+          default:
+            return { success: false, error: 'Invalid action' };
+        }
+      } catch (error) {
+        gs.error('OpenAI Incident Classifier Error: ' + error.message);
+        return { success: false, error: error.message };
+      }
+    },
+    
+    // Get incidents with classification data
+    getIncidents: function(params) {
+      var startTime = new Date().getTime();
+      
+      try {
+        // Parse parameters
+        var startDate = params.start_date || this.getDateDaysAgo(7);
+        var endDate = params.end_date || this.getDateToday();
+        var priority = params.priority || '';
+        var page = parseInt(params.page) || 1;
+        var pageSize = parseInt(params.page_size) || 10;
+        
+        gs.log('Getting incidents: startDate=' + startDate + ', endDate=' + endDate + ', priority=' + priority, 'OpenAIIncidentClassifier');
+        
+        // Build query for incidents
+        var incidentGR = new GlideRecord('incident');
+        incidentGR.addQuery('sys_created_on', '>=', startDate);
+        incidentGR.addQuery('sys_created_on', '<=', endDate + ' 23:59:59');
+        
+        if (priority) {
+          incidentGR.addQuery('priority', priority);
+        }
+        
+        incidentGR.orderByDesc('sys_created_on');
+        incidentGR.query();
+      
+        var totalRecords = incidentGR.getRowCount();
+        var incidents = [];
+        var skip = (page - 1) * pageSize;
+        var count = 0;
+        
+        gs.log('Processing ' + totalRecords + ' total records, skip=' + skip + ', pageSize=' + pageSize, 'OpenAIIncidentClassifier');
+        
+        while (incidentGR.next()) {
+          if (count < skip) {
+            count++;
+            continue;
+          }
+          
+          if (incidents.length >= pageSize) {
+            break;
+          }
+          
+          var incident = this.processIncident(incidentGR);
+          incidents.push(incident);
+          count++;
+        }
+        
+        // Calculate statistics
+        var statistics = this.calculateStatistics(incidents);
+        statistics.processingTime = ((new Date().getTime() - startTime) / 1000).toFixed(2);
+        
+        gs.log('Successfully processed ' + incidents.length + ' incidents in ' + statistics.processingTime + 's', 'OpenAIIncidentClassifier');
+        
+        return {
+          success: true,
+          incidents: incidents,
+          statistics: statistics,
+          total_records: totalRecords
+        };
+      } catch (error) {
+        gs.error('Error getting incidents: ' + error.message, 'OpenAIIncidentClassifier');
+        return {
+          success: false,
+          error: 'Failed to get incidents: ' + error.message,
+          incidents: [],
+          statistics: { totalIncidents: 0, processingTime: 0 },
+          total_records: 0
+        };
+      }
+    },
+    
+    // Process individual incident
+    processIncident: function(incidentGR) {
+      var incident = {
+        sys_id: incidentGR.getUniqueValue(),
+        number: incidentGR.getDisplayValue('number'),
+        short_description: incidentGR.getDisplayValue('short_description'),
+        description: incidentGR.getDisplayValue('description'),
+        priority: incidentGR.getValue('priority'),
+        priority_label: incidentGR.getDisplayValue('priority'),
+        created_date: incidentGR.getDisplayValue('sys_created_on'),
+        ai_classification: incidentGR.getValue('u_ai_classification'),
+        ai_confidence: parseFloat(incidentGR.getValue('u_ai_confidence')) || 0,
+        ai_classification_date: incidentGR.getDisplayValue('u_ai_classification_date')
+      };
+      
+      // Classify if not already classified
+      if (!incident.ai_classification) {
+        var classification = this.classifyIncident(incident);
+        if (classification.success) {
+          incident.ai_classification = classification.category;
+          incident.ai_confidence = classification.confidence;
+          
+          // Update the incident record
+          this.updateIncidentClassification(incident.sys_id, classification);
+        } else {
+          incident.ai_classification = 'Other';
+          incident.ai_confidence = 50;
+        }
+      }
+      
+      return incident;
+    },
+    
+    // Classify incident using OpenAI or fallback logic
+    classifyIncident: function(incident) {
+      // Try OpenAI classification first
+      var openaiResult = this.classifyWithOpenAI(incident);
+      if (openaiResult.success) {
+        return openaiResult;
+      }
+      
+      // Fallback to rule-based classification
+      return this.classifyWithRules(incident);
+    },
+    
+    // Classify incident using OpenAI API
+    classifyWithOpenAI: function(incident) {
+      try {
+        var apiKey = gs.getProperty('x_openai.api_key');
+        if (!apiKey) {
+          return { success: false, error: 'OpenAI API key not configured' };
+        }
+        
+        var requestBody = {
+          model: 'gpt-3.5-turbo',
+          messages: [
+            {
+              role: 'system',
+              content: 'You are an IT incident classification expert. Classify incidents into these categories: Hardware, Software, Network, Security, Access, Other. Respond with JSON format: {"category": "category_name", "confidence": confidence_score_0_to_100, "reasoning": "brief_explanation"}'
+            },
+            {
+              role: 'user',
+              content: 'Classify this incident:\nTitle: ' + incident.short_description + '\nDescription: ' + incident.description
+            }
+          ],
+          max_tokens: 150,
+          temperature: 0.3
+        };
+        
+        var request = new sn_ws.RESTMessageV2();
+        request.setEndpoint('https://api.openai.com/v1/chat/completions');
+        request.setHttpMethod('POST');
+        request.setRequestHeader('Authorization', 'Bearer ' + apiKey);
+        request.setRequestHeader('Content-Type', 'application/json');
+        request.setRequestBody(JSON.stringify(requestBody));
+        
+        var response = request.execute();
+        var responseCode = response.getStatusCode();
+        
+        if (responseCode === 200) {
+          var responseBody = JSON.parse(response.getBody());
+          var content = responseBody.choices[0].message.content;
+          
+          try {
+            var result = JSON.parse(content);
+            return {
+              success: true,
+              category: result.category,
+              confidence: result.confidence,
+              reasoning: result.reasoning
+            };
+          } catch (parseError) {
+            return { success: false, error: 'Failed to parse OpenAI response' };
+          }
+        } else {
+          return { success: false, error: 'OpenAI API error: ' + responseCode };
+        }
+      } catch (error) {
+        return { success: false, error: 'OpenAI classification failed: ' + error.message };
+      }
+    },
+    
+    // Fallback rule-based classification
+    classifyWithRules: function(incident) {
+      var text = (incident.short_description + ' ' + incident.description).toLowerCase();
+      
+      // Hardware keywords
+      if (text.match(/hardware|computer|laptop|desktop|monitor|printer|mouse|keyboard|server|disk|memory|cpu/)) {
+        return { success: true, category: 'Hardware', confidence: 70, reasoning: 'Keyword-based classification' };
+      }
+      
+      // Software keywords
+      if (text.match(/software|application|program|system|error|bug|crash|install|update|patch/)) {
+        return { success: true, category: 'Software', confidence: 70, reasoning: 'Keyword-based classification' };
+      }
+      
+      // Network keywords
+      if (text.match(/network|internet|connection|wifi|ethernet|vpn|firewall|router|switch|bandwidth/)) {
+        return { success: true, category: 'Network', confidence: 70, reasoning: 'Keyword-based classification' };
+      }
+      
+      // Security keywords
+      if (text.match(/security|virus|malware|phishing|breach|unauthorized|password|access|permissions/)) {
+        return { success: true, category: 'Security', confidence: 70, reasoning: 'Keyword-based classification' };
+      }
+      
+      // Access keywords
+      if (text.match(/access|login|password|account|user|authentication|authorization|permission/)) {
+        return { success: true, category: 'Access', confidence: 70, reasoning: 'Keyword-based classification' };
+      }
+      
+      // Default to Other
+      return { success: true, category: 'Other', confidence: 50, reasoning: 'No specific keywords found' };
+    },
+    
+    // Update incident classification in database
+    updateIncidentClassification: function(incidentId, classification) {
+      var incidentGR = new GlideRecord('incident');
+      if (incidentGR.get(incidentId)) {
+        incidentGR.setValue('u_ai_classification', classification.category);
+        incidentGR.setValue('u_ai_confidence', classification.confidence);
+        incidentGR.setValue('u_ai_classification_date', new GlideDateTime());
+        incidentGR.update();
+      }
+    },
+    
+    // Reclassify incident
+    reclassifyIncident: function(incidentId) {
+      var incidentGR = new GlideRecord('incident');
+      if (!incidentGR.get(incidentId)) {
+        return { success: false, error: 'Incident not found' };
+      }
+      
+      var incident = {
+        sys_id: incidentGR.getUniqueValue(),
+        short_description: incidentGR.getDisplayValue('short_description'),
+        description: incidentGR.getDisplayValue('description')
+      };
+      
+      var classification = this.classifyIncident(incident);
+      if (classification.success) {
+        this.updateIncidentClassification(incidentId, classification);
+        return { success: true, message: 'Incident reclassified successfully' };
+      } else {
+        return { success: false, error: 'Failed to reclassify incident' };
+      }
+    },
+    
+    // Calculate statistics
+    calculateStatistics: function(incidents) {
+      var stats = {
+        totalIncidents: incidents.length,
+        classifiedIncidents: 0,
+        averageConfidence: 0,
+        processingTime: 0
+      };
+      
+      var totalConfidence = 0;
+      incidents.forEach(function(incident) {
+        if (incident.ai_classification && incident.ai_classification !== 'Other') {
+          stats.classifiedIncidents++;
+        }
+        totalConfidence += incident.ai_confidence;
+      });
+      
+      if (incidents.length > 0) {
+        stats.averageConfidence = Math.round(totalConfidence / incidents.length);
+      }
+      
+      return stats;
+    },
+    
+    // Utility functions
+    getDateDaysAgo: function(days) {
+      var date = new Date();
+      date.setDate(date.getDate() - days);
+      return date.toISOString().split('T')[0];
+    },
+    
+    getDateToday: function() {
+      return new Date().toISOString().split('T')[0];
+    }
+  };
+  
+  // Main execution based on input
+  if (input && input.action) {
+    data.result = OpenAIIncidentClassifier.processRequest(input.action, input.params || {});
+  } else {
+    // Default initialization
+    data.result = {
+      success: true,
+      message: 'Widget initialized successfully',
+      config: {
+        supports_openai: !!gs.getProperty('x_openai.api_key'),
+        fallback_enabled: true
+      }
+    };
+  }
+  
+})();