Kanban-Front/src/KBBoard/BoardLogic.js

import { useCallback } from 'react';
import { useNavigate } from 'react-router-dom';
import {
    //me,
    loadBoardDataAPI,
    createTaskAPI,
    createCategoryAPI,
    updateTaskAPI,
    updateCategoryAPI,
    deleteCategoryAPI,
    deleteTaskAPI,
    assignMemberAPI,
    unassignMemberAPI,
    addMemberAPI,
    deleteBoardsAPI,
    updateBoardsAPI
} from './BoardAPI';

export const useBoardLogic = (id, setError, setInfo, setCategories, setLoading) => {
    const navigate = useNavigate();

    const loadBoardData = useCallback(async () => {
        setLoading(true);
        try {
            setError('');
            const response = await loadBoardDataAPI(id);
            setInfo(response.data);
            setCategories(response.data.categories || []);
        } catch (err) {
            if (err.response?.data?.message === 'Token Error' ||
                err.response?.data?.message === 'Invalid Token') {
                setError('Вы не авторизованы');
                setTimeout(() => navigate('/login'), 1000);
            } else if (err.response?.data?.detail === "Доска не найдена.") {
                setError("Доска не существует");
                setTimeout(() => navigate('/kanban-boards-list'), 1000);
            } else {
                setError('Ошибка загрузки доски');
            }
        } finally {
            setLoading(false);
        }
    }, [id, setError, setInfo, setCategories, setLoading, navigate]);

    const checkOwner = useCallback((ownerId) => {
        return /*me()*/22 === ownerId
    }, []);

    const deleteBoards = useCallback(async (boardId, modalDelBoard) => {
        setLoading(true);
        try {
            await deleteBoardsAPI(boardId);
            modalDelBoard();
            navigate('/kanban-boards-list');
        } catch (err) {
            setError('Ошибка удаления доски: '+ (err.response?.data?.message || err.response?.data?.detail));
        } finally {
            setLoading(false);
        }
    }, [setLoading, setError]);

    const createTask = useCallback(async (taskCategori, taskTitle, taskDescription, modalCrTask) => {
        setLoading(true);
        try {
            const newTask = {
                category_id: taskCategori,
                title: taskTitle,
                description: taskDescription
            };
            await createTaskAPI(newTask);
            await loadBoardData();
            modalCrTask(null)();
        } catch (err) {
            console.error('Ошибка создания задачи:', err);
            setError('Ошибка создания задачи');
        } finally {
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const createCategory = useCallback(async (categoryTitle, modalCrCateg) => {
        setLoading(true);
        try {
            const newCategory = {
                board_id: id,
                title: categoryTitle
            };
            await createCategoryAPI(newCategory);
            await loadBoardData();
        } catch (err) {
            setError(err.response?.data?.message || 'Ошибка создания категории');
        } finally {
            modalCrCateg();
            setLoading(false);
        }
    }, [id, loadBoardData, setLoading, setError]);

    const editBoard = useCallback(async (editedBoardId, boardTitle, boardDescription, modalEditBoard) => {
        setLoading(true);
        try {
            await updateBoardsAPI({
                id: editedBoardId,
                update_method: 'title',
                value: boardTitle
            });
            await updateBoardsAPI({
                id: editedBoardId,
                update_method: 'description',
                value: boardDescription
            });
            await modalEditBoard();
            await loadBoardData();
        } catch (err) {
            setError(err.response?.data?.message || 'Ошибка редактирования доски');
        } finally {
            modalEditBoard();
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const editTask = useCallback(async (editedTaskId, taskTitle, taskDescription, taskCategory, modalEditTask) => {
        setLoading(true);
        try {
            await updateTaskAPI({
                id: editedTaskId,
                update_method: 'title',
                value: taskTitle
            });
            await updateTaskAPI({
                id: editedTaskId,
                update_method: 'description',
                value: taskDescription
            });
            await updateTaskAPI({
                id: editedTaskId,
                update_method: 'category',
                value: Number(taskCategory)
            });
            
            await loadBoardData();
            modalEditTask({}, null)();
        } catch (err) {
            console.error('Ошибка редактирования задачи:', err);
            setError('Ошибка редактирования задачи');
        } finally {
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const editCategory = useCallback(async (editedCategId, categoryTitle, modalEditCateg) => {
        setLoading(true);
        try {
            const updateData = {
                id: editedCategId,
                update_method: 'title',
                value: categoryTitle
            };
            await updateCategoryAPI(updateData);
            await loadBoardData();
        } catch (err) {
            console.error('Ошибка редактирования категории:', err);
            setError(err.response?.data?.message || 'Ошибка редактирования категории');
        } finally {
            modalEditCateg({})();
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const deleteCategory = useCallback(async (categoryId, modalDelCateg, modalEditCateg) => {
        setLoading(true);
        try {
            await deleteCategoryAPI(categoryId);
            await loadBoardData();
            modalDelCateg();
            modalEditCateg({})();
        } catch (err) {
            console.error('Ошибка удаления категории:', err);
            setError('Ошибка удаления категории');
        } finally {
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const deleteTask = useCallback(async (taskId, modalDelTask, modalEditTask) => {
        setLoading(true);
        try {
            await deleteTaskAPI(taskId);
            await loadBoardData();
            modalDelTask();
            modalEditTask({}, null)();
        } catch (err) {
            console.error('Ошибка удаления задачи:', err);
            setError('Ошибка удаления задачи');
        } finally {
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const assignMember = useCallback(async (editedTaskId, memberId, act, modalAssignMember) => {
        setLoading(true);
        try {
            if (act) {
                await assignMemberAPI({
                    id: editedTaskId, 
                    member_id: memberId
                });
            } else if (!act) {
                await unassignMemberAPI({
                    id: editedTaskId, 
                    member_id: memberId
                });
            }
            await loadBoardData();
            modalAssignMember();
        } catch {
            setError('Ошибка');
        } finally{
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    const addMember = useCallback(async (username, boardId, modalAddMember) => {
        setLoading(true);
        try {
            await addMemberAPI({
                username: username, 
                board_id: boardId
            });
            await loadBoardData();
            modalAddMember();
        } catch {
            setError('Ошибка');
        } finally{
            setLoading(false);
        }
    }, [loadBoardData, setLoading, setError]);

    return {
        loadBoardData,
        createTask,
        checkOwner,
        createCategory,
        editBoard,
        editTask,
        editCategory,
        deleteCategory,
        deleteTask,
        assignMember,
        addMember,
        deleteBoards
    };
};