Light Commands

// Emergency Command System for RCAMS
class EmergencyCommandSystem {
  constructor(apiUsername, apiPassword) {
    this.apiUsername = apiUsername;
    this.apiPassword = apiPassword;
    this.baseUrl = 'https://rcamsapi.spheronomics.com/api/v1';
  }
  
  // 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;
    }
  }
  
  // Logout 
  async logout() {
    if (!this.status) {
      console.error('Not logged in.');
      return false;
    }
    
    const response = await this.makeRequest('logout.php', {
    });
    
    if (response.status === 'ok') {
      console.log('Logout successful.');
      return true;
    } else {
      console.error('Logout failed:', response.message);
      return false;
    }
  }
  
  // Check if logged in
  isLoggedIn() {
    return this.status !== 'OK';
  }
  
  // Command methods
  async sendLightCommand(lightMac, command) {
    if (!this.isLoggedIn()) {
      throw new Error('Not logged in. Call login() first.');
    }
    
    return await this.makeRequest('lightcommands.php', {
      light_mac: lightMac,
      message: command
    });
  }
  
  async sendGroupCommand(groupId, command) {
    if (!this.isLoggedIn()) {
      throw new Error('Not logged in. Call login() first.');
    }
    
    return await this.makeRequest('groupcommands.php', {
      group_id: groupId,
      message: command
    });
  }
  
  async sendSchoolCommand(schoolId, command) {
    if (!this.isLoggedIn()) {
      throw new Error('Not logged in. Call login() first.');
    }
    
    return await this.makeRequest('lightcommandsclient.php', {
      school_id: schoolId,
      message: command
    });
  }
  
  async sendDistrictCommand(districtId, command) {
    if (!this.isLoggedIn()) {
      throw new Error('Not logged in. Call login() first.');
    }
    
    return await this.makeRequest('lightcommandsdistrict.php', {
      district_id: districtId,
      message: command
    });
  }
  
  // Command helper methods for specific emergency protocols
  async sendLockdown(target, targetId) {
    return await this.sendCommand(target, targetId, 'MODE:1');
  }
  
  async sendSecure(target, targetId) {
    return await this.sendCommand(target, targetId, 'MODE:2');
  }
  
  async sendTeamAssist(target, targetId) {
    return await this.sendCommand(target, targetId, 'MODE:3');
  }
  
  async sendEvacuate(target, targetId) {
    return await this.sendCommand(target, targetId, 'MODE:4');
  }
  
  async sendShelter(target, targetId) {
    return await this.sendCommand(target, targetId, 'MODE:5');
  }
  
  async sendHold(target, targetId) {
    return await this.sendCommand(target, targetId, 'MODE:6');
  }
  
  async sendAllClear(target, targetId) {
    return await this.sendCommand(target, targetId, 'MODE:0');
  }
  
  // Generic command dispatcher
  async sendCommand(target, targetId, command) {
    switch (target.toLowerCase()) {
      case 'light':
        return await this.sendLightCommand(targetId, command);
      case 'group':
        return await this.sendGroupCommand(targetId, command);
      case 'school':
        return await this.sendSchoolCommand(targetId, command);
      case 'district':
        return await this.sendDistrictCommand(targetId, command);
      default:
        throw new Error(`Invalid target type: ${target}. Must be 'light', 'group', 'school', or 'district'.`);
    }
  }
}

// Example usage:
/*
async function emergencyDrill() {
  // Initialize the system with API credentials
  const ecs = new EmergencyCommandSystem('your_api_username', 'your_api_password');
  
  try {
    // Login
    const loginSuccess = await ecs.login('your_email@example.com', 'your_secure_password');
    if (!loginSuccess) return;
    
    // Example: Run a lockdown drill for a specific school
    console.log('Starting lockdown drill...');
    const schoolId = '1';
    
    // Step 1: Send lockdown command to the school
    const lockdownResult = await ecs.sendLockdown('school', schoolId);
    console.log('Lockdown command result:', lockdownResult);
    
    // Wait 2 minutes
    console.log('Waiting 2 minutes...');
    await new Promise(resolve => setTimeout(resolve, 120000));
    
    // Step 2: Send all-clear command to end the drill
    console.log('Ending drill with all-clear command...');
    const allClearResult = await ecs.sendAllClear('school', schoolId);
    console.log('All-clear command result:', allClearResult);
    
    // Logout
    await ecs.logout();
    console.log('Drill completed successfully.');
  } catch (error) {
    console.error('Error during emergency drill:', error);
  }
}

// Run the drill (commented out for safety)
// emergencyDrill();
*/