Переведены все запросы на клиенты

front/src/lib/clients/AuthClient.js

@@ -1,9 +1,45 @@
+import {api} from "./api";
+import {requests} from "../../requests";
+
 class AuthClient {
 
     async signOut() {
         localStorage.removeItem("token");
         return {};
     }
+
+    async login(request, setLoading, setError, checkSession) {
+        setLoading(true);
+        const response = await api().post(requests.auth.login, request);
+
+        if (response.data.error) {
+            setError(response.data.error);
+            setLoading(false);
+            return;
+        }
+
+        localStorage.setItem("token", response.data.token);
+
+        await checkSession?.();
+
+        window.location.reload();
+    }
+
+    loginByCode(code, checkSession) {
+        const request = {
+            byLogin: false,
+            code: code
+        }
+        api().post(requests.auth.login, request)
+            .then(async (response) => {
+                if (response.data.error) {
+                    return;
+                }
+                localStorage.setItem("token", response.data.token);
+                await checkSession?.();
+                window.location.reload();
+            })
+    }
 }
 
 export const authClient = new AuthClient();

front/src/lib/clients/BarClient.js

@@ -0,0 +1,63 @@
+import {api} from "./api";
+import {requests} from "../../requests";
+import {getComparator} from "../../components/core/getComparator";
+
+class BarClient {
+
+    getBarList(setBars, createError) {
+        api().get(requests.bar.all)
+            .then((r) => {
+                setBars(r.data.sort(getComparator("name")))
+            })
+            .catch(() => {
+                createError("Ошибка получения списков")
+            })
+    }
+
+    changeBar(id, bars, createWarning, createSuccess, createError, setBars) {
+        createWarning("Дождитесь окончания операции")
+        api().post(`${requests.bar.change}/${id}`)
+            .then(() => createSuccess("Список изменен"))
+            .catch(() => createError("Ошибка изменения активного списка"))
+
+        const newState = bars.map((b) => {
+            if (b.active) {
+                return {
+                    ...b, active: false
+                }
+            }
+            if (b.id === id) {
+                return {
+                    ...b, active: true
+                }
+            }
+            return b;
+        })
+        setBars(newState);
+    }
+
+    deleteBar(bar, bars, createError, createSuccess, setBars) {
+        if (bar.active) {
+            createError("Нельзя удалить активный бар!")
+            return;
+        }
+        api().delete(requests.bar.crud + bar.id)
+            .then(() => createSuccess("Список удален"))
+            .catch(() => createError("Ошибка удаления. Обновите страницу"))
+
+        setBars(bars.filter((b) => b.id !== bar.id));
+    }
+
+    createBar(name, bars, createSuccess, createError, setBars, setOpen) {
+        api().post(requests.bar.crud + name)
+            .then((r) => {
+                createSuccess("Cписок создан");
+                let state = bars;
+                state.push(r.data);
+                setBars(state)
+                setOpen(false)
+            }).catch(() => createError("Ошибка создания списка"))
+    }
+}
+
+export const barClient = new BarClient();

front/src/lib/clients/CategoryClient.js

@@ -0,0 +1,19 @@
+import {api} from "./api";
+import {requests} from "../../requests";
+import {getComparator} from "../../components/core/getComparator";
+
+class CategoryClient {
+
+    getCategoryList(setCategory, createError) {
+        api().get(requests.category.basic)
+            .then((r) => {
+                setCategory(r.data.sort(getComparator())
+                    .map((item, i) => {
+                        return {id: i, name: item}
+                    }))
+            })
+            .catch(() => createError("Ошибка получения категорий"))
+    }
+};
+
+export const categoryClient = new CategoryClient();

front/src/lib/clients/CocktailClient.js

@@ -0,0 +1,201 @@
+import {api} from "./api";
+import {requests} from "../../requests";
+import {sortList} from "../../components/cocktails/sortingList";
+import {getComparator} from "../../components/core/getComparator";
+
+class CocktailClient {
+    emptyCocktailForEditPage = {
+        id: null,
+        name: "",
+        alcoholic: "",
+        category: "",
+        components: "",
+        glass: "",
+        image: "",
+        instructions: "",
+        isAllowed: false,
+        rating: {
+            rating: 0,
+            favourite: false
+        },
+        receipt: [],
+        tags: "",
+        video: ""
+    }
+
+    getMenu(setRows, setIsNew, setPage, setLoad, setIsEnd, isNew, rows, page, size, filter, createError) {
+        setLoad(true);
+
+        const request = {
+            ...filter,
+            sort: sortList.find((s) => s.name === filter.sorting).id,
+            page: page + 1,
+            size: size,
+            notHaveCount: Array.isArray(filter.iCount) ? null : filter.iCount
+        }
+
+        api().post(requests.cocktails.menu, request)
+            .then((r) => {
+                if (r.data.length === 0) {
+                    if (isNew) {
+                        setRows([]);
+                    }
+                    setIsEnd(true);
+                    setLoad(false);
+                    return;
+                }
+                const cocktails = isNew ? r.data : rows.concat(r.data);
+                setRows(cocktails);
+                setIsNew(false);
+                setPage(page + 1);
+                setLoad(false);
+            })
+            .catch((r) => {
+                setLoad(false);
+                createError("Ошибка загрузки данных от сервера Status:" + r.code)
+            })
+    }
+
+    async getCocktailByIngredient(ingredient, setCocktails) {
+        if(!ingredient) {
+            return
+        }
+        api().get(requests.cocktails.byIngredient + ingredient.id)
+            .then((r) => setCocktails(r.data))
+    }
+
+    getCocktailsForCalcPage(load,setLoad, setCocktails, setCocktailMap, createError) {
+        if (load) {
+            return;
+        }
+        api().get(requests.cocktails.calc)
+            .then((r) => {
+                const data = r.data;
+                if (data.length === 0) {
+                    setLoad(false);
+                    return;
+                }
+                setCocktails(data);
+                let map = [];
+                map = data.map((d) => map[d.id] = 1)
+                setCocktailMap(map);
+                setLoad(true);
+            })
+            .catch((r) => {
+                setLoad(true);
+                createError("Ошибка загрузки данных от сервера Status:" + r.code)
+            })
+    }
+
+    savePhoto(event, changeCocktailValue, getError) {
+        const file = event.target.files[0];
+        let formData = new FormData();
+        formData.append('file', file);
+        api().post(requests.cocktails.photo, formData)
+            .then((r) => changeCocktailValue("image", r.data))
+            .catch(() => getError())
+    }
+
+    deleteCocktailFromEdit(setCocktails, setCocktail, createError, cocktails, cocktail, emptyCocktail) {
+        api().delete(requests.cocktails.cocktail + cocktail.id)
+            .then(() => {
+                setCocktails(cocktails.filter((r) => r.id !== cocktail.id))
+                setCocktail(emptyCocktail);
+            })
+            .catch(() => createError("Ошибка удаления коктейля"))
+    }
+
+    deleteCocktail(id, rows, setRows, createSuccess, createError) {
+        api().delete(requests.cocktails.cocktail + id)
+            .then(() => {
+                setRows(rows.filter((r) => r.id !== id))
+                createSuccess("Коктейль удален")
+            })
+            .catch(() => createError("Ошибка удаления коктейля"))
+    }
+
+    saveChangeCocktail (cocktail, createError, createSuccess) {
+        api().patch(requests.cocktails.basic, cocktail)
+            .then((r) => {
+                if (!r.data.error) {
+                    createSuccess("Сохранено")
+                    return;
+                }
+                createError("Ошибка на сервере: " + r.data.error)
+            })
+            .catch(() => createError("Неизвестная ошибка"))
+    }
+
+    getOneCocktail (selected, setCocktail, getError, emptyCocktail) {
+        if (!selected) {
+            setCocktail(emptyCocktail);
+            return;
+        }
+        api().get(requests.cocktails.cocktail + selected)
+            .then((r) => {
+                setCocktail(r.data)
+            })
+            .catch(() => getError());
+    }
+
+    getSimpleList(setCocktails, setSelected, setLoading, createError, currentId) {
+        api().get(requests.cocktails.simple)
+            .then((r) => {
+                const arr = r.data.sort(getComparator("asc", "name"));
+                setCocktails(arr)
+
+                if (!currentId) {
+                    setLoading(false);
+                    return;
+                }
+                const currentCocktail = arr.find((r) => r.id === (currentId * 1));
+                if (!currentCocktail) {
+                    setLoading(false);
+                    return;
+                }
+                setSelected(currentCocktail.id);
+                setLoading(false);
+            })
+            .catch(() => createError("Ошибка получения данных"))
+    }
+
+    getCocktailForModal (row, setLoading, setCocktail, closeCocktail, getError) {
+        setLoading(true)
+        if (!row) {
+            setLoading(false)
+            return;
+        }
+        api().get(requests.cocktails.modal + row)
+            .then((r) => {
+                setCocktail(r.data)
+                setLoading(false)
+            })
+            .catch(() => {
+                getError();
+                setLoading(false)
+                closeCocktail();
+            })
+    }
+
+    changeFavourite(value, id, newState, setRows, createSuccess, createError) {
+        const url = `${requests.cocktails.favourite}${id}`;
+        const request = value ? api().put(url) : api().delete(url);
+
+        request
+            .then(() => {
+                setRows(newState);
+                createSuccess("Спасибо за оценку!")
+            }).catch(() => createError("Ошибка сохранения"))
+    }
+
+    changeRating(id, newState, value, setRows, createSuccess, createError) {
+        api().post(`${requests.cocktails.rating}${id}&rating=${value}`)
+            .then(() => {
+                setRows(newState);
+                createSuccess("Спасибо за оценку!")
+            }).catch(() => createError("Ошибка сохранения"))
+    }
+
+}
+
+export const cocktailClient = new CocktailClient();

front/src/lib/clients/GlassClient.js

@@ -0,0 +1,17 @@
+import {api} from "./api";
+import {requests} from "../../requests";
+import {getComparator} from "../../components/core/getComparator";
+
+class GlassClient {
+
+    getGlassList(setGlass, createError) {
+        api().get(requests.glass.list)
+            .then((r) => setGlass(r.data.sort(getComparator())
+                .map((item, i) => {
+                    return {id: i, name: item}
+                })))
+            .catch(() => createError("Ошибка получения посуды"))
+    }
+}
+
+export const glassClient = new GlassClient();

front/src/lib/clients/IngredientClient.js

@@ -0,0 +1,112 @@
+import {api} from "./api";
+import {requests} from "../../requests";
+import {getComparator} from "../../components/core/getComparator";
+
+class IngredientClient {
+
+    allList(currentId, setIngredients, setIngredient, createError) {
+        api().get(requests.ingredient.all)
+            .then((r) => {
+                const arr = r.data.sort(getComparator("asc", "name"));
+                setIngredients(arr)
+
+                if (!currentId) {
+                    return;
+                }
+                const currentIngredient = arr.find((r) => r.id === (currentId * 1));
+                if (!currentIngredient) {
+                    return;
+                }
+                setIngredient(currentIngredient);
+            })
+            .catch(() => createError("Ошибка получения данных"))
+    }
+
+    getType(setTypes) {
+        api().get(requests.ingredient.type)
+            .then((r) => setTypes(r.data.sort(getComparator("asc", "name"))))
+    }
+
+    findAll(setIngredients, createError) {
+        api().get(requests.ingredient.all)
+            .then((r) => setIngredients(r.data.sort(getComparator("asc", "name"))))
+            .catch(() => createError("Ошибка получения списка ингредиентов"))
+    }
+
+    getAllIngredients(setIngredients, setLoading, createError) {
+        api().get(requests.ingredient.all)
+            .then((r) => {
+                setIngredients(r.data)
+                setLoading(false);
+            })
+            .catch(() => {
+                createError("Ошибка получения списка ингредиентов");
+                setLoading(false);
+            })
+    }
+
+    changeIngredientIsHave(id, value, state, setIngredients, createError) {
+        const url = `${requests.ingredient.crud}?id=${id}`;
+        const request = value ? api().put(url) : api().delete(url);
+        request
+            .then(() => {
+                setIngredients(state);
+            })
+            .catch(() => {
+                createError("Ошибка изменения ингредиента");
+            });
+    }
+
+    deleteIngredientIsHave(id, createSuccess, createError) {
+        api().delete(`${requests.ingredient.crud}/${id}`)
+            .then(() => createSuccess("Ингредиент удален"))
+            .catch(() => createError("Ошибка удаления ингредиента. Перезагрузите страницу"))
+    }
+
+    saveIngredient(ingredient, createSuccess, createError) {
+        api().patch(requests.ingredient.crud, ingredient)
+            .then(() => createSuccess("Ингредиент сохранен"))
+            .catch(() => createError("Ошибка сохранения"))
+    }
+
+    findOne(id, selectIngredient, createError) {
+        api().get(`${requests.bar.ingredient}?id=${id}`)
+            .then((r) => {
+                selectIngredient(r.data)
+            })
+            .catch(() => createError("Ошибка получения информации об ингредиенте"))
+    }
+
+    changeIngredientInBar(ingredient, cocktail, setCocktail, createSuccess, createError) {
+        const url = `${requests.ingredient.crud}?id=${ingredient.id}`;
+        const request = ingredient.isHave ? api().delete(url) : api().put(url);
+        const value = !ingredient.isHave;
+        request.then(() => {
+            const newReceipts = cocktail.receipt.map((r) => {
+                if (r.ingredient.id !== ingredient.id) {
+                    return r;
+                }
+                return {
+                    ...r,
+                    ingredient: {
+                        ...ingredient,
+                        isHave: value
+                    }
+                }
+            })
+            setCocktail({
+                ...cocktail,
+                receipt: newReceipts
+            })
+            createSuccess("Сохранено")
+        }).catch(() => createError("Ошибка сохранения"))
+    }
+
+    findUnit(setUnits, createError) {
+        api().get(requests.unit)
+            .then((r) => setUnits(r.data.sort(getComparator("asc", "name"))))
+            .catch(() => createError("Ошибка получения единиц измерения"))
+    }
+}
+
+export const ingredientClient = new IngredientClient()