feat: price by category

src/pages/ServicesPage/hooks/useServicePriceCategoriesList.tsx

@@ -0,0 +1,10 @@
+import ObjectList from "../../../hooks/objectList.tsx";
+import { ServiceService } from "../../../client";
+
+const useServicePriceCategoriesList = () => ObjectList({
+    queryFn: ServiceService.getAllPriceCategories,
+    getObjectsFn: (response) => response.priceCategories,
+    queryKey: "getAllPriceCategories",
+});
+
+export default useServicePriceCategoriesList;

src/pages/ServicesPage/hooks/useServicePriceCategoryState.tsx

@@ -0,0 +1,80 @@
+import UseObjectState from "../../../types/UseObjectState.ts";
+import { type ServicePriceCategorySchema, ServiceService } from "../../../client";
+import useServicePriceCategoriesList from "./useServicePriceCategoriesList.tsx";
+import { modals } from "@mantine/modals";
+import { notifications } from "../../../shared/lib/notifications.ts";
+
+const useServicePriceCategoryState = (): UseObjectState<ServicePriceCategorySchema> => {
+    const { objects, refetch } = useServicePriceCategoriesList();
+    const onCreateClick = () => {
+        modals.openContextModal({
+            modal: "servicePriceCategoryForm",
+            title: "Создание категории цен",
+            withCloseButton: false,
+            innerProps: {
+                onCreate,
+            },
+        });
+    };
+    const onCreate = (values: ServicePriceCategorySchema) => {
+        console.log(ServiceService);
+        ServiceService.createPriceCategory({
+            requestBody: {
+                name: values.name,
+            },
+        }).then(async ({ ok, message }) => {
+            notifications.guess(ok, { message: message });
+            if (!ok) return;
+            await refetch();
+        });
+    };
+    const onDelete = (item: ServicePriceCategorySchema) => {
+        modals.openConfirmModal({
+            title: "Удаление категории",
+            children: "Вы уверены, что хотите удалить категорию?",
+            onConfirm: () => {
+
+                ServiceService.deletePriceCategory({
+                    requestBody: {
+                        id: item.id,
+                    },
+                }).then(async ({ ok, message }) => {
+                    notifications.guess(ok, { message: message });
+                    if (!ok) return;
+                    await refetch();
+                });
+            },
+        });
+    };
+    const onChange = (item: ServicePriceCategorySchema) => {
+        modals.openContextModal({
+            modal: "servicePriceCategoryForm",
+            title: "Изменение категории цен",
+            withCloseButton: false,
+            innerProps: {
+                onChange: (values: ServicePriceCategorySchema) => {
+                    ServiceService.updatePriceCategory({
+                        requestBody: {
+                            id: item.id,
+                            name: values.name,
+                        },
+                    }).then(async ({ ok, message }) => {
+                        notifications.guess(ok, { message: message });
+                        if (!ok) return;
+                        await refetch();
+                    });
+                },
+                element: item,
+            },
+        });
+    };
+
+    return {
+        onCreateClick,
+        onCreate,
+        onDelete,
+        onChange,
+        objects,
+    };
+};
+export default useServicePriceCategoryState;

src/pages/ServicesPage/hooks/useServicesKitsState.tsx

@@ -0,0 +1,57 @@
+import { GetServiceKitSchema, ServiceService } from "../../../client";
+import { omit } from "lodash";
+import { notifications } from "../../../shared/lib/notifications.ts";
+import { modals } from "@mantine/modals";
+import useServicesKitsList from "./useServicesKitsList.tsx";
+
+const useServicesKitsState = () => {
+    const { objects: servicesKits, refetch: refetchKits } = useServicesKitsList();
+
+    const onKitCreate = (kit: GetServiceKitSchema) => {
+        ServiceService.createServicesKit({
+            requestBody: {
+                data: {
+                    ...omit(kit, ["services", "id"]),
+                    servicesIds: kit.services.map(service => service.id),
+                },
+            },
+        }).then(async ({ ok, message }) => {
+            notifications.guess(ok, { message: message });
+            if (!ok) return;
+            await refetchKits();
+        });
+    };
+
+    const onKitCreateClick = () => {
+        modals.openContextModal({
+            modal: "serviceKitModalForm",
+            title: "Создание набора услуг",
+            withCloseButton: false,
+            innerProps: {
+                onCreate: onKitCreate,
+            },
+        });
+    };
+    const onKitUpdate = (kit: GetServiceKitSchema) => {
+        ServiceService.updateServicesKit({
+            requestBody: {
+                data: {
+                    ...omit(kit, ["services"]),
+                    servicesIds: kit.services.map(service => service.id),
+                },
+            },
+        }).then(async ({ ok, message }) => {
+            notifications.guess(ok, { message: message });
+            if (!ok) return;
+            await refetchKits();
+        });
+    };
+
+    return {
+        onKitCreateClick,
+        onKitUpdate,
+        servicesKits,
+    };
+};
+
+export default useServicesKitsState;

src/pages/ServicesPage/hooks/useServicesState.tsx

@@ -0,0 +1,89 @@
+import { modals } from "@mantine/modals";
+import { ServiceCategorySchema, ServiceSchema, ServiceService } from "../../../client";
+import { notifications } from "../../../shared/lib/notifications.ts";
+import useServicesList from "./useServicesList.tsx";
+import { Text } from "@mantine/core";
+
+const useServicesState = () => {
+    const { services, refetch } = useServicesList();
+
+    const onCreateClick = () => {
+        modals.openContextModal({
+            modal: "createService",
+            title: "Создание услуги",
+            withCloseButton: false,
+            innerProps: {
+                onCreate,
+            },
+        });
+    };
+    const onCreate = (values: ServiceSchema) => {
+        ServiceService.createService({ requestBody: { service: values } })
+            .then(async ({ ok, message }) => {
+                notifications.guess(ok, { message: message });
+                if (!ok) return;
+                await refetch();
+            });
+    };
+
+    const onCreateCategoryClick = () => {
+        modals.openContextModal({
+            modal: "createServiceCategory",
+            title: "Создание категории",
+            withCloseButton: false,
+            innerProps: {
+                onCreate: onCategoryCreate,
+            },
+        });
+    };
+    const onCategoryCreate = (category: ServiceCategorySchema) => {
+        ServiceService.createServiceCategory({ requestBody: { category: category } })
+            .then(({ ok, message }) =>
+                notifications.guess(ok, { message: message }));
+    };
+
+    const onServiceDelete = (service: ServiceSchema) => {
+        modals.openConfirmModal({
+            title: "Удаление услуги",
+            children: (<Text>
+                Вы уверены, что хотите удалить услугу "{service.name}"?
+            </Text>),
+            onConfirm: () => {
+                ServiceService.deleteService({ requestBody: { serviceId: service.id } })
+                    .then(async ({ ok, message }) => {
+                        notifications.guess(ok, { message: message });
+                        if (!ok) return;
+                        await refetch();
+                    });
+            },
+            labels: {
+                confirm: "Удалить",
+                cancel: "Отмена",
+            },
+        });
+    };
+
+    const onServiceUpdate = (service: ServiceSchema) => {
+        ServiceService
+            .updateService({
+                requestBody: {
+                    data: service,
+                },
+            })
+            .then(async ({ ok, message }) => {
+                notifications.guess(ok, { message: message });
+                if (!ok) return;
+                await refetch();
+            });
+    };
+
+    return {
+        services,
+        onCreateClick,
+        onServiceDelete,
+        onServiceUpdate,
+        onCreateCategoryClick,
+    };
+};
+
+export default useServicesState;