Configuration

import 'package:dio/dio.dart';
import 'package:flutter_dotenv/flutter_dotenv.dart';

class ApiClient {
  late Dio _dio;
  String? _authToken;
  
  ApiClient() {
    _dio = Dio(BaseOptions(
      baseUrl: dotenv.env['API_BASE_URL'] ?? '',
      connectTimeout: Duration(milliseconds: 30000),
      receiveTimeout: Duration(milliseconds: 30000),
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json',
      },
    ));
    
    // Add interceptors
    _dio.interceptors.add(InterceptorsWrapper(
      onRequest: (options, handler) {
        // Add auth token to all requests
        if (_authToken != null) {
          options.headers['Authorization'] = 'Bearer $_authToken';
        }
        return handler.next(options);
      },
      onError: (error, handler) {
        // Handle errors globally
        if (error.response?.statusCode == 401) {
          // Token expired - refresh or logout
          _handleUnauthorized();
        }
        return handler.next(error);
      },
    ));
  }
  
  void setAuthToken(String token) {
    _authToken = token;
  }
  
  void clearAuthToken() {
    _authToken = null;
  }
  
  Future<Response> get(String path, {Map<String, dynamic>? params}) {
    return _dio.get(path, queryParameters: params);
  }
  
  Future<Response> post(String path, {dynamic data}) {
    return _dio.post(path, data: data);
  }
  
  Future<Response> put(String path, {dynamic data}) {
    return _dio.put(path, data: data);
  }
  
  Future<Response> delete(String path) {
    return _dio.delete(path);
  }
  
  void _handleUnauthorized() {
    // Clear token and redirect to login
    clearAuthToken();
    // Navigate to login screen
  }
}

// Usage
final apiClient = ApiClient();
apiClient.setAuthToken('your_jwt_token');

// Make requests
final response = await apiClient.get('/devices');
final devices = response.data['data'];

#include <HTTPClient.h>
#include <WiFiClientSecure.h>

class GridovaAPI {
  private:
    String baseUrl;
    String authToken;
    WiFiClientSecure client;
    
  public:
    GridovaAPI(String url, String token) {
      baseUrl = url;
      authToken = token;
      client.setInsecure();  // Skip certificate validation (not recommended for production)
    }
    
    bool sendSensorData(String deviceId, float voltage, float current, float power) {
      HTTPClient http;
      
      String url = baseUrl + "/sensor-data";
      http.begin(client, url);
      http.addHeader("Content-Type", "application/json");
      http.addHeader("Authorization", "Bearer " + authToken);
      
      // Create JSON payload
      String payload = "{\"device_id\":\"" + deviceId + "\",";
      payload += "\"voltage\":" + String(voltage, 2) + ",";
      payload += "\"current\":" + String(current, 3) + ",";
      payload += "\"power\":" + String(power, 2) + "}";
      
      int httpCode = http.POST(payload);
      bool success = (httpCode >= 200 && httpCode < 300);
      
      if (!success) {
        Serial.printf("API Error: %d\n", httpCode);
      }
      
      http.end();
      return success;
    }
    
    bool controlRelay(String deviceId, int relay, bool state) {
      HTTPClient http;
      
      String url = baseUrl + "/relay/control";
      http.begin(client, url);
      http.addHeader("Content-Type", "application/json");
      http.addHeader("Authorization", "Bearer " + authToken);
      
      String payload = "{\"device_id\":\"" + deviceId + "\",";
      payload += "\"relay\":" + String(relay) + ",";
      payload += "\"state\":" + (state ? "true" : "false") + "}";
      
      int httpCode = http.POST(payload);
      bool success = (httpCode >= 200 && httpCode < 300);
      
      http.end();
      return success;
    }
};

// Usage
GridovaAPI api(API_URL, AUTH_TOKEN);
api.sendSensorData(DEVICE_ID, 220.5, 2.83, 623.81);

-- Create database
CREATE DATABASE gridova;

-- Create user
CREATE USER gridova_user WITH PASSWORD 'secure_password';

-- Grant privileges
GRANT ALL PRIVILEGES ON DATABASE gridova TO gridova_user;

-- Connect to database
\c gridova

-- Enable extensions
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pg_trgm";  -- For text search
CREATE EXTENSION IF NOT EXISTS "timescaledb";  -- For time-series data

-- Create main tables (example)
CREATE TABLE users (
  id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
  email VARCHAR(255) UNIQUE NOT NULL,
  name VARCHAR(255) NOT NULL,
  role VARCHAR(50) NOT NULL,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

CREATE TABLE devices (
  id VARCHAR(50) PRIMARY KEY,
  room_id UUID REFERENCES rooms(id),
  name VARCHAR(255) NOT NULL,
  status VARCHAR(20) DEFAULT 'offline',
  last_seen TIMESTAMP,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

-- Create hypertable for sensor data (TimescaleDB)
CREATE TABLE sensor_data (
  time TIMESTAMPTZ NOT NULL,
  device_id VARCHAR(50) NOT NULL,
  voltage DECIMAL(6,2),
  current DECIMAL(6,3),
  power DECIMAL(8,2),
  energy DECIMAL(10,3),
  frequency DECIMAL(5,2),
  power_factor DECIMAL(4,2)
);

SELECT create_hypertable('sensor_data', 'time');

-- Create indexes
CREATE INDEX idx_sensor_data_device_time 
  ON sensor_data (device_id, time DESC);

CREATE INDEX idx_devices_status 
  ON devices (status);

-- Set up automatic data retention (keep 30 days)
SELECT add_retention_policy('sensor_data', INTERVAL '30 days');

import { Pool } from 'pg';

const pool = new Pool({
  host: process.env.DB_HOST || 'localhost',
  port: parseInt(process.env.DB_PORT || '5432'),
  database: process.env.DB_NAME || 'gridova',
  user: process.env.DB_USER || 'gridova_user',
  password: process.env.DB_PASSWORD,
  
  // Connection pool settings
  min: 2,                    // Minimum connections
  max: 20,                   // Maximum connections
  idleTimeoutMillis: 30000,  // Close idle connections after 30s
  connectionTimeoutMillis: 2000,  // Timeout if connection takes > 2s
});

pool.on('error', (err) => {
  console.error('Unexpected error on idle client', err);
  process.exit(-1);
});

export default pool;