admin-panel/src/services/api.ts - master - netsvvir/treeRepo

admin-panel/src/services/api.ts
221 строка8 KB
netsvvir
Upload project
23 ноя 2025, 15:06
23 ноя 2025, 15:06ce0a46d
import axios from 'axios';
import { Area, AreaCreate } from '../types/area';
import { TreeType, TreeTypeCreate, TreeTypeUpdate } from '../types/treeTypes';
import { PlaqueType, PlaqueTypeCreate, PlaqueTypeUpdate } from '../types/plaqueType';



const API_BASE_URL = '/api';

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

export const areaService = {
    getAreas: async (): Promise<Area[]> => {
        const response = await api.get<Area[]>('/areas/');
        return response.data;
    },

    getArea: async (id: number): Promise<Area> => {
        const response = await api.get<Area>(`/areas/${id}`);
        return response.data;
    },

    createArea: async (area: AreaCreate): Promise<Area> => {
        const response = await api.post<Area>('/areas/', area);
        return response.data;
    },

    updateArea: async (id: number, area: AreaCreate): Promise<Area> => {
        const response = await api.put<Area>(`/areas/${id}`, area);
        return response.data;
    },

    deleteArea: async (id: number): Promise<void> => {
        await api.delete(`/areas/${id}`);
    },
};

export const treeTypesService = {
    getTreeTypes: async (): Promise<TreeType[]> => {
        try {
            const response = await api.get<TreeType[]>('/tree-types/');
            return response.data;
        } catch (error: any) {
            console.error('Error fetching tree types:', error);
            throw new Error(error.response?.data?.detail || '������ ��� �������� ����� ��������');
        }
    },

    getTreeType: async (id: number): Promise<TreeType> => {
        try {
            const response = await api.get<TreeType>(`/tree-types/${id}`);
            return response.data;
        } catch (error: any) {
            console.error('Error fetching tree type:', error);
            throw new Error(error.response?.data?.detail || '������ ��� �������� ���� ������');
        }
    },

    createTreeType: async (treeType: TreeTypeCreate): Promise<TreeType> => {
        try {
            // ��������� �� ���������
            if (!treeType.type_name || treeType.type_name.trim() === '') {
                throw new Error('�������� ���� ������ �����������');
            }

            if (treeType.base_price < 0) {
                throw new Error('���� �� ����� ���� �������������');
            }

            const response = await api.post<TreeType>('/tree-types/', treeType);
            return response.data;
        } catch (error: any) {
            console.error('Error creating tree type:', error);
            const errorMessage = error.response?.data?.detail || error.message || '������ ��� �������� ���� ������';
            throw new Error(errorMessage);
        }
    },

    updateTreeType: async (id: number, treeType: TreeTypeUpdate): Promise<TreeType> => {
        try {
            const response = await api.put<TreeType>(`/tree-types/${id}`, treeType);
            return response.data;
        } catch (error: any) {
            console.error('Error updating tree type:', error);
            throw new Error(error.response?.data?.detail || '������ ��� ���������� ���� ������');
        }
    },

    deleteTreeType: async (id: number): Promise<void> => {
        try {
            await api.delete(`/tree-types/${id}`);
        } catch (error: any) {
            console.error('Error deleting tree type:', error);
            throw new Error(error.response?.data?.detail || '������ ��� �������� ���� ������');
        }
    },
};

// �������������� ������� ��� ������ ��������� (���� �����)
export const plaqueTypesService = {
    getPlaqueTypes: async (): Promise<PlaqueType[]> => {
        try {
            const response = await api.get<PlaqueType[]>('/plaque-types/');
            return response.data;
        } catch (error: any) {
            console.error('Error fetching plaque types:', error);
            throw new Error(error.response?.data?.detail || '������ ��� �������� ����� ��������');
        }
    },

    getPlaqueType: async (id: number): Promise<PlaqueType> => {
        try {
            const response = await api.get<PlaqueType>(`/plaque-types/${id}`);
            return response.data;
        } catch (error: any) {
            console.error('Error fetching plaque type:', error);
            throw new Error(error.response?.data?.detail || '������ ��� �������� ���� ��������');
        }
    },

    createPlaqueType: async (plaqueType: PlaqueTypeCreate): Promise<PlaqueType> => {
        try {
            if (!plaqueType.type_name || plaqueType.type_name.trim() === '') {
                throw new Error('�������� ���� �������� �����������');
            }

            if (plaqueType.base_price < 0) {
                throw new Error('���� �� ����� ���� �������������');
            }

            const response = await api.post<PlaqueType>('/plaque-types/', plaqueType);
            return response.data;
        } catch (error: any) {
            console.error('Error creating plaque type:', error);
            const errorMessage = error.response?.data?.detail || error.message || '������ ��� �������� ���� ��������';
            throw new Error(errorMessage);
        }
    },

    updatePlaqueType: async (id: number, plaqueType: PlaqueTypeUpdate): Promise<PlaqueType> => {
        try {
            const response = await api.put<PlaqueType>(`/plaque-types/${id}`, plaqueType);
            return response.data;
        } catch (error: any) {
            console.error('Error updating plaque type:', error);
            throw new Error(error.response?.data?.detail || '������ ��� ���������� ���� ��������');
        }
    },

    deletePlaqueType: async (id: number): Promise<void> => {
        try {
            await api.delete(`/plaque-types/${id}`);
        } catch (error: any) {
            console.error('Error deleting plaque type:', error);
            throw new Error(error.response?.data?.detail || '������ ��� �������� ���� ��������');
        }
    },
};

export const plotsService = {
    getPlots: async () => {
        const response = await api.get('/plots/');
        return response.data;
    },

    getAvailablePlots: async () => {
        const response = await api.get('/plots/available/');
        return response.data;
    },
};

export const treesService = {
    getTrees: async () => {
        const response = await api.get('/trees/');
        return response.data;
    },

    getTree: async (id: number) => {
        const response = await api.get(`/trees/${id}`);
        return response.data;
    },

    getTreeWithDetails: async (id: number) => {
        const response = await api.get(`/trees/${id}/details`);
        return response.data;
    },

    createTree: async (treeData: any) => {
        const response = await api.post('/trees/', treeData);
        return response.data;
    },
};

export const statisticsService = {
    getAreaStatistics: async () => {
        const response = await api.get('/statistics/areas/');
        return response.data;
    },

    getUserStatistics: async (accountId: number) => {
        const response = await api.get(`/statistics/user/${accountId}`);
        return response.data;
    },

    getDashboardStats: async () => {
        const response = await api.get('/dashboard/stats');
        return response.data;
    },

    getRecentAreas: async (limit: number = 3) => {
        const response = await api.get(`/dashboard/recent-areas?limit=${limit}`);
        return response.data;
    },
};

export default api;