frontend/src/services/api.ts - master - AtlasProgrammer/pp-heat-map

frontend/src/services/api.ts
160 строк5 KB
AtlasProgrammer
upload files frontend
07 ноя 2025, 13:02
07 ноя 2025, 13:02e56909e
import axios from 'axios';
import { AnalysisResult, SatelliteResult, FirmsResult } from '../types';
import { 
  mockAnalysisResult, 
  mockSatelliteImages, 
  mockFirmsData, 
  mockBackendStatus,
  generateMockAnomaly,
  generateMockFirePoint 
} from '../data/mockData';

const API_BASE_URL = process.env.REACT_APP_API_URL || 'http://localhost:8000';

const api = axios.create({
  baseURL: API_BASE_URL,
  timeout: 5000,
});

api.interceptors.request.use(
  (config) => {
    console.log(`Making ${config.method?.toUpperCase()} request to ${config.url}`);
    return config;
  },
  (error) => {
    return Promise.reject(error);
  }
);

api.interceptors.response.use(
  (response) => {
    return response;
  },
  (error) => {
    console.error('API Error:', error.response?.data || error.message);
    return Promise.reject(error);
  }
);

const isBackendAvailable = async (): Promise<boolean> => {
  try {
    await api.get('/ping/', { timeout: 2000 });
    return true;
  } catch {
    return false;
  }
};

export const apiService = {
  async ping() {
    try {
      const response = await api.get('/ping/');
      return response.data;
    } catch (error) {
      console.log('Backend недоступен, возвращаем моковые данные');
      return mockBackendStatus;
    }
  },

  async analyzeImage(file: File, threshold: number = 3, minArea: number = 10): Promise<AnalysisResult> {
    const backendAvailable = await isBackendAvailable();
    
    if (backendAvailable) {
      try {
        const formData = new FormData();
        formData.append('image', file);
        formData.append('threshold', threshold.toString());
        formData.append('minArea', minArea.toString());

        const response = await api.post('/analyze', formData, {
          headers: {
            'Content-Type': 'multipart/form-data',
          },
        });
        return response.data;
      } catch (error) {
        console.log('Ошибка анализа изображения, используем моковые данные');
      }
    }

    const mockResult = { ...mockAnalysisResult };
    const additionalAnomalies = Array.from({ length: Math.floor(Math.random() * 3) + 1 }, (_, i) => 
      generateMockAnomaly(mockResult.anomalies.length + i + 1)
    );
    mockResult.anomalies = [...mockResult.anomalies, ...additionalAnomalies];
    mockResult.stats.totalAnomalies = mockResult.anomalies.length;
    
    return mockResult;
  },

  async downloadSatelliteData(params: {
    date: string;
    lat: number;
    lon: number;
    bufferKm: number;
    resolution: number;
  }): Promise<SatelliteResult> {
    const backendAvailable = await isBackendAvailable();
    
    if (backendAvailable) {
      try {
        const response = await api.post('/satellite/download', params);
        return response.data;
      } catch (error) {
        console.log('Ошибка загрузки спутниковых данных, используем моковые данные');
      }
    }

    return {
      images: mockSatelliteImages,
      metadata: {
        date: params.date,
        location: { lat: params.lat, lon: params.lon },
        resolution: params.resolution,
        bufferKm: params.bufferKm
      }
    };
  },

  async loadFirmsData(params: {
    centerLat: number;
    centerLon: number;
    size: number;
    startDate: string;
    endDate: string;
    days: number;
  }): Promise<FirmsResult> {
    const backendAvailable = await isBackendAvailable();
    
    if (backendAvailable) {
      try {
        const response = await api.post('/firms/load', params);
        return response.data;
      } catch (error) {
        console.log('Ошибка загрузки FIRMS данных, используем моковые данные');
      }
    }

    const additionalPoints = Array.from({ length: Math.floor(Math.random() * 20) + 10 }, (_, i) => 
      generateMockFirePoint(mockFirmsData.points.length + i + 1)
    );

    return {
      points: [...mockFirmsData.points, ...additionalPoints],
      stats: {
        ...mockFirmsData.stats,
        total: mockFirmsData.points.length + additionalPoints.length,
        day: Math.floor((mockFirmsData.points.length + additionalPoints.length) * 0.6),
        night: Math.floor((mockFirmsData.points.length + additionalPoints.length) * 0.4),
        avgConfidence: 75.5
      },
      metadata: {
        center: { lat: params.centerLat, lon: params.centerLon },
        size: params.size,
        dateRange: { start: params.startDate, end: params.endDate }
      }
    };
  },
};

export default api;