snow-flow 2.0.4 → 2.0.6

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
+      }
+    };
+  }
+  
+})();

package/servicenow/widgets/openai_incident_classifier/style.css

@@ -0,0 +1,354 @@
+.openai-incident-classifier-widget {
+  padding: 20px;
+  background: #ffffff;
+  border-radius: 8px;
+  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+  font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+}
+
+.widget-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 20px;
+  padding-bottom: 15px;
+  border-bottom: 1px solid #e0e0e0;
+}
+
+.widget-header h3 {
+  margin: 0;
+  color: #333;
+  font-size: 24px;
+  font-weight: 600;
+}
+
+.header-controls .btn {
+  padding: 8px 16px;
+  border-radius: 4px;
+  border: none;
+  cursor: pointer;
+  font-size: 14px;
+  transition: all 0.3s ease;
+}
+
+.btn-primary {
+  background-color: #007bff;
+  color: white;
+}
+
+.btn-primary:hover {
+  background-color: #0056b3;
+}
+
+.btn-primary:disabled {
+  background-color: #6c757d;
+  cursor: not-allowed;
+}
+
+.filters-section {
+  margin-bottom: 20px;
+  padding: 15px;
+  background: #f8f9fa;
+  border-radius: 6px;
+}
+
+.filters-section label {
+  font-weight: 500;
+  margin-bottom: 5px;
+  display: block;
+  color: #495057;
+}
+
+.form-control {
+  width: 100%;
+  padding: 8px 12px;
+  border: 1px solid #ced4da;
+  border-radius: 4px;
+  font-size: 14px;
+  transition: border-color 0.3s ease;
+}
+
+.form-control:focus {
+  outline: none;
+  border-color: #007bff;
+  box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
+}
+
+.loading-overlay {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 40px;
+  background: #f8f9fa;
+  border-radius: 6px;
+  margin: 20px 0;
+}
+
+.spinner {
+  width: 40px;
+  height: 40px;
+  border: 4px solid #f3f3f3;
+  border-top: 4px solid #007bff;
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+  margin-bottom: 15px;
+}
+
+@keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+
+.error-message {
+  background: #f8d7da;
+  color: #721c24;
+  padding: 15px;
+  border-radius: 4px;
+  margin: 20px 0;
+  border: 1px solid #f5c6cb;
+}
+
+.error-message i {
+  margin-right: 8px;
+}
+
+.statistics-cards {
+  margin-bottom: 30px;
+}
+
+.stat-card {
+  background: white;
+  border: 1px solid #e0e0e0;
+  border-radius: 8px;
+  padding: 20px;
+  text-align: center;
+  transition: transform 0.3s ease, box-shadow 0.3s ease;
+  height: 100px;
+}
+
+.stat-card:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+}
+
+.stat-value {
+  font-size: 28px;
+  font-weight: 700;
+  color: #007bff;
+  margin-bottom: 8px;
+}
+
+.stat-label {
+  font-size: 14px;
+  color: #6c757d;
+  font-weight: 500;
+}
+
+.charts-section {
+  margin-bottom: 30px;
+}
+
+.chart-container {
+  background: white;
+  border: 1px solid #e0e0e0;
+  border-radius: 8px;
+  padding: 20px;
+  margin-bottom: 20px;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05);
+}
+
+.chart-container h4 {
+  margin: 0 0 15px 0;
+  color: #333;
+  font-size: 18px;
+  font-weight: 600;
+  text-align: center;
+}
+
+.data-table-section {
+  margin-bottom: 20px;
+}
+
+.table {
+  width: 100%;
+  border-collapse: collapse;
+  margin-top: 15px;
+}
+
+.table th,
+.table td {
+  padding: 12px;
+  text-align: left;
+  border-bottom: 1px solid #e0e0e0;
+  font-size: 14px;
+}
+
+.table th {
+  background-color: #f8f9fa;
+  font-weight: 600;
+  color: #495057;
+}
+
+.table tbody tr:hover {
+  background-color: #f8f9fa;
+}
+
+.classification-badge {
+  display: inline-block;
+  padding: 4px 8px;
+  border-radius: 4px;
+  font-size: 12px;
+  font-weight: 500;
+  color: white;
+  text-transform: uppercase;
+}
+
+.badge-hardware { background-color: #dc3545; }
+.badge-software { background-color: #007bff; }
+.badge-network { background-color: #28a745; }
+.badge-security { background-color: #fd7e14; }
+.badge-access { background-color: #6f42c1; }
+.badge-other { background-color: #6c757d; }
+
+.confidence-bar {
+  position: relative;
+  height: 20px;
+  background: #e9ecef;
+  border-radius: 10px;
+  overflow: hidden;
+  min-width: 80px;
+}
+
+.confidence-fill {
+  height: 100%;
+  background: linear-gradient(90deg, #dc3545 0%, #ffc107 50%, #28a745 100%);
+  transition: width 0.3s ease;
+}
+
+.confidence-text {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  font-size: 12px;
+  font-weight: 500;
+  color: #333;
+}
+
+.priority-badge {
+  display: inline-block;
+  padding: 4px 8px;
+  border-radius: 4px;
+  font-size: 12px;
+  font-weight: 500;
+  color: white;
+}
+
+.priority-1 { background-color: #dc3545; }
+.priority-2 { background-color: #fd7e14; }
+.priority-3 { background-color: #ffc107; color: #333; }
+.priority-4 { background-color: #28a745; }
+
+.btn-sm {
+  padding: 4px 8px;
+  font-size: 12px;
+}
+
+.btn-secondary {
+  background-color: #6c757d;
+  color: white;
+}
+
+.btn-secondary:hover {
+  background-color: #5a6268;
+}
+
+.pagination-section {
+  margin-top: 20px;
+}
+
+.pagination {
+  display: flex;
+  justify-content: center;
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+
+.page-item {
+  margin: 0 2px;
+}
+
+.page-link {
+  display: block;
+  padding: 8px 12px;
+  text-decoration: none;
+  background: white;
+  border: 1px solid #dee2e6;
+  color: #007bff;
+  border-radius: 4px;
+  transition: all 0.3s ease;
+}
+
+.page-link:hover {
+  background-color: #e9ecef;
+  color: #0056b3;
+}
+
+.page-item.active .page-link {
+  background-color: #007bff;
+  color: white;
+  border-color: #007bff;
+}
+
+.page-item.disabled .page-link {
+  color: #6c757d;
+  pointer-events: none;
+  background-color: #fff;
+  border-color: #dee2e6;
+}
+
+.row {
+  display: flex;
+  flex-wrap: wrap;
+  margin: 0 -15px;
+}
+
+.col-md-3, .col-md-4 {
+  flex: 0 0 auto;
+  padding: 0 15px;
+}
+
+.col-md-3 {
+  width: 25%;
+}
+
+.col-md-4 {
+  width: 33.333333%;
+}
+
+@media (max-width: 768px) {
+  .col-md-3, .col-md-4 {
+    width: 100%;
+    margin-bottom: 15px;
+  }
+  
+  .widget-header {
+    flex-direction: column;
+    align-items: flex-start;
+  }
+  
+  .header-controls {
+    margin-top: 10px;
+  }
+  
+  .table {
+    font-size: 12px;
+  }
+  
+  .table th,
+  .table td {
+    padding: 8px;
+  }
+}