Light History

// Light History Analyzer for RCAMS
class LightHistoryAnalyzer {
  constructor(apiUsername, apiPassword) {
    this.apiUsername = apiUsername;
    this.apiPassword = apiPassword;
    this.baseUrl = 'https://rcamsapi.spheronomics.com/api/v1';
    this.historyData = null;
  }
  
  // Helper method for making API requests
  async makeRequest(endpoint, params) {
    // Create form data from params
    const json = {};
    for (const [key, value] of Object.entries(params)) {
      json[key] = value;
    }
    const jsonString = JSON.stringify(json);
    
    try {
      const response = await fetch(`${this.baseUrl}/${endpoint}`, {
        method: 'POST',
        headers: {
          'Authorization': 'Basic ' + btoa(`${this.apiUsername}:${this.apiPassword}`)
        },
        body: jsonString
      });
      
      return await response.json();
    } catch (error) {
      console.error(`API request to ${endpoint} failed:`, error);
      throw error;
    }
  }
  
  // Login 
  async login(username, password) {
    const response = await this.makeRequest('login.php', {
      user: username,
      pass: password
    });
    
    if (response.status === 'OK') {
      
      console.log('Login successful.');
      return true;
    } else {
      console.error('Login failed:', response.message);
      return false;
    }
  }
  
  // Check if logged in
  isLoggedIn() {
    return this.status !== "OK";
  }
  
  // Fetch light history
  async fetchHistory(filters = {}) {
    if (!this.isLoggedIn()) {
      throw new Error('Not logged in. Call login() first.');
    }
    
    const params = {};
    
    // Apply filters if provided
    if (filters.lightMac) params.light_mac = filters.lightMac;
    if (filters.schoolId) params.school_id = filters.schoolId;
    if (filters.groupId) params.group_id = filters.groupId;
    
    const response = await this.makeRequest('lighthistory.php', params);
    
    if (response.status === 'OK' || response.satus === 'OK') { // Handle both spelling variations
      this.historyData = response.data;
      return this.historyData;
    } else {
      throw new Error(`Failed to fetch history: ${response.message}`);
    }
  }
  
  // Process the hierarchical history data into a flat array
  getFlatHistoryArray() {
    if (!this.historyData) {
      throw new Error('No history data available. Call fetchHistory() first.');
    }
    
    const flatHistory = [];
    
    for (const schoolName in this.historyData) {
      const school = this.historyData[schoolName];
      
      for (const groupName in school) {
        const group = school[groupName];
        
        for (const lightName in group) {
          const light = group[lightName];
          
          light.history.forEach(entry => {
            flatHistory.push({
              school: schoolName,
              group: groupName,
              light: lightName,
              lightId: light.id,
              lightMac: light.mac,
              lightTopic: light.topic,
              commandId: entry.id,
              timestamp: new Date(entry.Timestamp),
              message: entry.message,
              result: entry.result,
              successful: entry.result === 'message published'
            });
          });
        }
      }
    }
    
    // Sort by timestamp, newest first
    return flatHistory.sort((a, b) => b.timestamp - a.timestamp);
  }
  
  // Generate a summary report
  generateSummaryReport() {
    if (!this.historyData) {
      throw new Error('No history data available. Call fetchHistory() first.');
    }
    
    const flatHistory = this.getFlatHistoryArray();
    const report = {
      totalCommands: flatHistory.length,
      successfulCommands: flatHistory.filter(entry => entry.successful).length,
      failedCommands: flatHistory.filter(entry => !entry.successful).length,
      commandTypes: {},
      schoolStats: {},
      timeDistribution: {
        lastHour: 0,
        lastDay: 0,
        lastWeek: 0,
        lastMonth: 0,
        older: 0
      }
    };
    
    // Calculate success rate
    report.successRate = report.totalCommands > 0 
      ? (report.successfulCommands / report.totalCommands * 100).toFixed(2) + '%' 
      : 'N/A';
    
    // Process command types
    flatHistory.forEach(entry => {
      // Extract command type (e.g., "MODE: 1" -> "MODE 1")
      const commandType = entry.message.replace(':', '');
      
      if (!report.commandTypes[commandType]) {
        report.commandTypes[commandType] = {
          count: 0,
          successful: 0,
          failed: 0
        };
      }
      
      report.commandTypes[commandType].count++;
      if (entry.successful) {
        report.commandTypes[commandType].successful++;
      } else {
        report.commandTypes[commandType].failed++;
      }
      
      // Process school stats
      if (!report.schoolStats[entry.school]) {
        report.schoolStats[entry.school] = {
          totalCommands: 0,
          successful: 0,
          failed: 0,
          groups: {}
        };
      }
      
      report.schoolStats[entry.school].totalCommands++;
      if (entry.successful) {
        report.schoolStats[entry.school].successful++;
      } else {
        report.schoolStats[entry.school].failed++;
      }
      
      // Process group stats within schools
      if (!report.schoolStats[entry.school].groups[entry.group]) {
        report.schoolStats[entry.school].groups[entry.group] = {
          totalCommands: 0,
          successful: 0,
          failed: 0
        };
      }
      
      report.schoolStats[entry.school].groups[entry.group].totalCommands++;
      if (entry.successful) {
        report.schoolStats[entry.school].groups[entry.group].successful++;
      } else {
        report.schoolStats[entry.school].groups[entry.group].failed++;
      }
      
      // Process time distribution
      const now = new Date();
      const commandTime = entry.timestamp;
      const diffInHours = (now - commandTime) / (1000 * 60 * 60);
      
      if (diffInHours <= 1) {
        report.timeDistribution.lastHour++;
      } else if (diffInHours <= 24) {
        report.timeDistribution.lastDay++;
      } else if (diffInHours <= 168) { // 7 days
        report.timeDistribution.lastWeek++;
      } else if (diffInHours <= 720) { // 30 days
        report.timeDistribution.lastMonth++;
      } else {
        report.timeDistribution.older++;
      }
    });
    
    return report;
  }
  
  // Get history for a specific light
  getLightHistory(lightMac) {
    const flatHistory = this.getFlatHistoryArray();
    return flatHistory.filter(entry => entry.lightMac === lightMac);
  }
  
  // Get recent commands (within last X hours)
  getRecentCommands(hours = 24) {
    const flatHistory = this.getFlatHistoryArray();
    const now = new Date();
    
    return flatHistory.filter(entry => {
      const diffInHours = (now - entry.timestamp) / (1000 * 60 * 60);
      return diffInHours <= hours;
    });
  }
  
  // Get commands of a specific type
  getCommandsByType(commandType) {
    const flatHistory = this.getFlatHistoryArray();
    return flatHistory.filter(entry => entry.message.includes(commandType));
  }
  
  // Get failed commands
  getFailedCommands() {
    const flatHistory = this.getFlatHistoryArray();
    return flatHistory.filter(entry => !entry.successful);
  }
}

// Example usage:
/*
async function analyzeHistory() {
  // Initialize the analyzer with API credentials
  const analyzer = new LightHistoryAnalyzer('api_username', 'api_password');
  
  try {
    // Login
    const loginSuccess = await analyzer.login('user@example.com', 'password123');
    if (!loginSuccess) return;
    
    // Fetch history for a specific school
    await analyzer.fetchHistory({ schoolId: '1' });
    
    // Generate and display summary report
    const report = analyzer.generateSummaryReport();
    console.log('Summary Report:', JSON.stringify(report, null, 2));
    
    // Get recent commands (last 24 hours)
    const recentCommands = analyzer.getRecentCommands(24);
    console.log(`Commands in the last 24 hours: ${recentCommands.length}`);
    
    // Get lockdown commands
    const lockdownCommands = analyzer.getCommandsByType('MODE: 1');
    console.log(`Lockdown commands: ${lockdownCommands.length}`);
    
    // Get failed commands
    const failedCommands = analyzer.getFailedCommands();
    console.log(`Failed commands: ${failedCommands.length}`);
    
    console.log('Analysis completed successfully.');
  } catch (error) {
    console.error('Error during analysis:', error);
  }
}

// Run the analysis
// analyzeHistory();
*/