Fulfillment-Backend/routers/service.py

from typing import Annotated

from fastapi import APIRouter, Depends
from sqlalchemy.ext.asyncio import AsyncSession

import enums.service
from backend.dependecies import SessionDependency
from backend.session import get_session
from schemas.base import BaseEnumListSchema
from schemas.service import *
from services.auth import guest_user, authorized_user
from services.service import ServiceService

service_router = APIRouter(
    prefix="/service",
    tags=['service'],
)


# region Services
@service_router.get(
    '/get-all',
    response_model=ServiceGetAllResponse,
    operation_id="get_all_services",
    dependencies=[Depends(guest_user)]

)
async def get_all(
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await ServiceService(session).get_all()


@service_router.post(
    '/create',
    response_model=ServiceCreateResponse,
    operation_id="create_service",
    dependencies=[Depends(authorized_user)]
)
async def create(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: ServiceCreateRequest
):
    return await ServiceService(session).create(request)


@service_router.post(
    '/update',
    response_model=ServiceUpdateResponse,
    operation_id="update_service",
    dependencies=[Depends(authorized_user)]
)
async def update(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: ServiceUpdateRequest
):
    return await ServiceService(session).update(request)


@service_router.post(
    '/delete',
    response_model=ServiceDeleteResponse,
    operation_id="delete_service",
    dependencies=[Depends(authorized_user)]
)
async def delete(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: ServiceDeleteRequest
):
    return await ServiceService(session).delete(request)


@service_router.post(
    '/reorder',
    response_model=ServiceReorderResponse,
    operation_id="reorder_service",

)
async def reorder(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: ServiceReorderRequest
):
    return await ServiceService(session).reorder(request)


# endregion

# region Categories

@service_router.get(
    '/categories/get-all',
    response_model=ServiceGetAllCategoriesResponse,
    operation_id="get_all_service_categories",
    dependencies=[Depends(guest_user)]
)
async def get_all_categories(
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await ServiceService(session).get_all_categories()


@service_router.post(
    '/categories/create',
    response_model=ServiceCreateCategoryResponse,
    operation_id="create_service_category",
    dependencies=[Depends(authorized_user)]
)
async def create_category(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: ServiceCreateCategoryRequest
):
    return await ServiceService(session).create_category(request)


@service_router.post(
    '/categories/update',
    response_model=ServiceUpdateCategoryResponse,
    operation_id="update_service_category",
    dependencies=[Depends(authorized_user)]
)
async def update_category(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: ServiceUpdateCategoryRequest
):
    return await ServiceService(session).update_category(request)


@service_router.post(
    '/categories/reorder',
    response_model=ServiceCategoryReorderResponse,
    operation_id="reorder_service_category",
    dependencies=[Depends(authorized_user)]
)
async def reorder_category(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: ServiceCategoryReorderRequest
):
    return await ServiceService(session).reorder_category(request)


# endregion

# region Types
@service_router.get(
    '/types/get-all',
    response_model=BaseEnumListSchema,
    operation_id="get_all_service_types",
    dependencies=[Depends(guest_user)]
)
async def get_all_service_types(
):
    result = []
    for key, value in enums.service.SERVICE_TYPE_LABELS.items():
        result.append({"id": key, "name": value})
    return BaseEnumListSchema(items=result)


# endregion

# region Kits

@service_router.get(
    '/kits/get-all',
    response_model=GetAllServicesKitsResponse,
    operation_id='get_all_services_kits',
    dependencies=[Depends(guest_user)]
)
async def get_all_services_kits(
        session: SessionDependency
):
    return await ServiceService(session).get_all_kits()


@service_router.post(
    '/kits/create',
    response_model=CreateServicesKitResponse,
    operation_id='create_services_kit',
    dependencies=[Depends(authorized_user)]
)
async def create_services_kit(
        session: SessionDependency,
        request: CreateServicesKitRequest
):
    return await ServiceService(session).create_kit(request)


@service_router.post(
    '/kits/update',
    response_model=UpdateServicesKitResponse,
    operation_id='update_services_kit',
    dependencies=[Depends(authorized_user)]
)
async def update_services_kit(
        session: SessionDependency,
        request: UpdateServicesKitRequest
):
    return await ServiceService(session).update_kit(request)


# endregion

# region Price Categories
# crud price categories
@service_router.get(
    '/price-categories/get-all',
    response_model=GetAllPriceCategoriesResponse,
    operation_id='get_all_price_categories',
    dependencies=[Depends(guest_user)]
)
async def get_all_price_categories(
        session: SessionDependency
):
    return await ServiceService(session).get_all_price_categories()


@service_router.post(
    '/price-categories/create',
    response_model=CreatePriceCategoryResponse,
    operation_id='create_price_category',
    dependencies=[Depends(authorized_user)]
)
async def create_price_category(
        session: SessionDependency,
        request: CreatePriceCategoryRequest
):
    return await ServiceService(session).create_price_category(request)


@service_router.post(
    '/price-categories/update',
    response_model=UpdatePriceCategoryResponse,
    operation_id='update_price_category',
    dependencies=[Depends(authorized_user)]
)
async def update_price_category(
        session: SessionDependency,
        request: UpdatePriceCategoryRequest
):
    return await ServiceService(session).update_price_category(request)


@service_router.post(
    '/price-categories/delete',
    response_model=DeletePriceCategoryResponse,
    operation_id='delete_price_category',
    dependencies=[Depends(authorized_user)]
)
async def delete_price_category(
        session: SessionDependency,
        request: DeletePriceCategoryRequest
):
    return await ServiceService(session).delete_price_category(request)

# endregion