src/context/ReservoirContext.tsx - develop - GEOSHEV/StudLab

src/context/ReservoirContext.tsx
121 строка4 KB
George
Обновил: Линтер по всем файлам
21 мар 2025, 14:25
21 мар 2025, 14:252b503d4
import React, { useState, useEffect } from 'react';
import axios from 'axios';
import { ReservoirContext } from './ReservoirContextInstance';

const API_URL = '/api/reservoirs/';
const API_PRODUCT_URL = '/api/products/';

interface Reservoir {
    id: number;
    name: string;
    capacity: number;
    volume: number;
    productId: number;
    isLocked: boolean;
}

export function ReservoirProvider({ children }: { children: React.ReactNode }) {
    const [reservoirs, setReservoirs] = useState<Reservoir[]>([]);
    const [selectedReservoir, setSelectedReservoir] =
        useState<Reservoir | null>(null);

    const fetchReservoirs = async () => {
        try {
            const response = await axios.get<Reservoir[]>(API_URL);
            setReservoirs(response.data);
        } catch (error) {
            console.error('Error fetching reservoirs', error);
        }
    };

    const addReservoir = async (reservoir: Omit<Reservoir, 'id'>) => {
        try {
            const productsResponse =
                await axios.get<{ name: string; id: number }[]>(
                    API_PRODUCT_URL,
                );
            const products = productsResponse.data;

            const defaultProductId = products[0].id;

            const response = await axios.post<Reservoir>(API_URL, {
                ...reservoir,
                productId: defaultProductId,
            });

            setReservoirs(prev => [response.data, ...prev]);
        } catch (error) {
            console.error('Ошибка при добавлении резервуара', error);
        }
    };

    const updateReservoir = async (
        id: number,
        updates: Partial<Reservoir>,
    ): Promise<Reservoir | null> => {
        try {
            const response = await axios.put<Reservoir>(
                `${API_URL}/${id}`,
                updates,
            );
            setReservoirs(prev =>
                prev.map(res => (res.id === id ? response.data : res)),
            );
            setSelectedReservoir(response.data);
            return response.data;
        } catch (error) {
            console.error('Ошибка при обновлении резервуара', error);
            return null;
        }
    };

    const deleteReservoir = async (id: number) => {
        try {
            await axios.delete(`${API_URL}/${id}`);
            setReservoirs(prev => prev.filter(res => res.id !== id));
            setSelectedReservoir(null);
        } catch (error) {
            console.error('Error deleting reservoir', error);
        }
    };

    const toggleLock = async (id: number) => {
        try {
            const response = await axios.patch<Reservoir>(
                `${API_URL}/${id}/toggle-lock`,
            );
            setReservoirs(prev =>
                prev.map(res => (res.id === id ? response.data : res)),
            );
            setSelectedReservoir(response.data);
        } catch (error) {
            console.error('Error toggling lock', error);
        }
    };

    const selectReservoir = (reservoir: Reservoir) => {
        setSelectedReservoir(reservoir);
    };

    useEffect(() => {
        fetchReservoirs();
    }, []);

    return (
        <ReservoirContext.Provider
            value={{
                reservoirs,
                selectedReservoir,
                fetchReservoirs,
                addReservoir,
                updateReservoir,
                deleteReservoir,
                toggleLock,
                selectReservoir,
            }}
        >
            {children}
        </ReservoirContext.Provider>
    );
}
export { ReservoirContext, type Reservoir };