ipmi-fan-control/frontend/src/utils/api.ts

import axios from 'axios';
import type {
  User,
  Server,
  FanCurve,
  FanCurvePoint,
  TemperatureReading,
  FanReading,
  SensorReading,
  SystemLog,
  DashboardStats,
  ServerStatus,
  ServerSensors,
  FanControlCommand,
  AutoControlSettings,
  SSHSensorData,
  SystemInfo,
} from '../types';

const API_URL = import.meta.env.VITE_API_URL || '';

const api = axios.create({
  baseURL: `${API_URL}/api`,
  headers: {
    'Content-Type': 'application/json',
  },
});

// Request interceptor to add auth token
api.interceptors.request.use((config) => {
  const token = localStorage.getItem('token');
  if (token) {
    config.headers.Authorization = `Bearer ${token}`;
  }
  return config;
});

// Response interceptor to handle auth errors
api.interceptors.response.use(
  (response) => response,
  (error) => {
    if (error.response?.status === 401) {
      localStorage.removeItem('token');
      window.location.href = '/login';
    }
    return Promise.reject(error);
  }
);

// Auth API
export const authApi = {
  login: (username: string, password: string) =>
    api.post<{ access_token: string; token_type: string }>('/auth/login', {
      username,
      password,
    }),
  getMe: () => api.get<User>('/auth/me'),
};

// Setup API
export const setupApi = {
  getStatus: () => api.get<{ setup_complete: boolean }>('/setup/status'),
  completeSetup: (username: string, password: string, confirmPassword: string) =>
    api.post<User>('/setup/complete', {
      username,
      password,
      confirm_password: confirmPassword,
    }),
};

// Servers API
export const serversApi = {
  getAll: () => api.get<Server[]>('/servers'),
  getById: (id: number) => api.get<Server>(`/servers/${id}`),
  create: (data: {
    name: string;
    vendor: string;
    ipmi: {
      ipmi_host: string;
      ipmi_port: number;
      ipmi_username: string;
      ipmi_password: string;
    };
    ssh: {
      use_ssh: boolean;
      ssh_host?: string;
      ssh_port: number;
      ssh_username?: string;
      ssh_password?: string;
      ssh_key_file?: string;
    };
  }) => api.post<Server>('/servers', data),
  update: (id: number, data: any) =>
    api.put<Server>(`/servers/${id}`, data),
  delete: (id: number) => api.delete(`/servers/${id}`),
  getStatus: (id: number) => api.get<ServerStatus>(`/servers/${id}/status`),
  getSensors: (id: number) => api.get<ServerSensors>(`/servers/${id}/sensors`),
  getPower: (id: number) => api.get<Record<string, string>>(`/servers/${id}/power`),
  // SSH endpoints
  getSSHSensors: (id: number) => api.get<SSHSensorData>(`/servers/${id}/ssh/sensors`),
  getSSHSystemInfo: (id: number) => api.get<SystemInfo>(`/servers/${id}/ssh/system-info`),
  executeSSHCommand: (id: number, command: string) =>
    api.post<{ exit_code: number; stdout: string; stderr: string }>(`/servers/${id}/ssh/execute`, { command }),
};

// Fan Control API
export const fanControlApi = {
  enableManual: (serverId: number) =>
    api.post(`/servers/${serverId}/fans/manual/enable`),
  disableManual: (serverId: number) =>
    api.post(`/servers/${serverId}/fans/manual/disable`),
  setSpeed: (serverId: number, command: FanControlCommand) =>
    api.post(`/servers/${serverId}/fans/set`, command),
  enableAuto: (serverId: number, settings: AutoControlSettings) =>
    api.post(`/servers/${serverId}/auto-control/enable`, settings),
  disableAuto: (serverId: number) =>
    api.post(`/servers/${serverId}/auto-control/disable`),
};

// Fan Curves API
export const fanCurvesApi = {
  getAll: (serverId: number) =>
    api.get<FanCurve[]>(`/servers/${serverId}/fan-curves`),
  create: (
    serverId: number,
    data: {
      name: string;
      curve_data: FanCurvePoint[];
      sensor_source: string;
      is_active: boolean;
    }
  ) => api.post<FanCurve>(`/servers/${serverId}/fan-curves`, data),
  update: (
    serverId: number,
    curveId: number,
    data: {
      name: string;
      curve_data: FanCurvePoint[];
      sensor_source: string;
      is_active: boolean;
    }
  ) => api.put<FanCurve>(`/servers/${serverId}/fan-curves/${curveId}`, data),
  delete: (serverId: number, curveId: number) =>
    api.delete(`/servers/${serverId}/fan-curves/${curveId}`),
};

// Dashboard API
export const dashboardApi = {
  getStats: () => api.get<DashboardStats>('/dashboard/stats'),
  getServerData: (serverId: number) =>
    api.get<{
      server: Server;
      current_temperatures: TemperatureReading[];
      current_fans: FanReading[];
      recent_sensor_data: SensorReading[];
      recent_fan_data: FanReading[];
      power_consumption: Record<string, string> | null;
    }>(`/dashboard/servers/${serverId}`),
};

// Logs API
export const logsApi = {
  getAll: (params?: { server_id?: number; event_type?: string; limit?: number }) =>
    api.get<SystemLog[]>('/logs', { params }),
};

export default api;