Fulfillment-Backend/routers/service.py

from io import BytesIO
from typing import Annotated

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

import enums.service
from backend.dependecies import SessionDependency
from backend.session import get_session
from generators.price_list_pdf_generator.generator import PriceListPdfGenerator
from generators.services_excel_generator import ServiceExcelExporter
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)],
        with_placeholders: bool = False
):
    return await ServiceService(session).get_all(with_placeholders)


@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)


@service_router.get(
    '/price-list',
    operation_id='get_price_list',
    # dependencies=[Depends(authorized_user)],
)
async def get_price_list(
        session: Annotated[AsyncSession, Depends(get_session)],
):
    pdf_file: BytesIO = await PriceListPdfGenerator(session).create_price_list_pdf()
    return Response(pdf_file.getvalue(), media_type='application/pdf')


# 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)


@service_router.post(
    '/categories/delete',
    response_model=ServiceDeleteCategoryResponse,
    operation_id="delete_service_category",
    dependencies=[Depends(authorized_user)]
)
async def delete_category(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: ServiceDeleteCategoryRequest
):
    return await ServiceService(session).delete_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 Exports

@service_router.get(
    '/export-list/pdf',
    operation_id='export_list_pdf',

)
async def export_list_pdf(
        session: SessionDependency,
):
    pdf_file: BytesIO = await PriceListPdfGenerator(session).create_price_list_pdf()
    return Response(pdf_file.getvalue(), media_type='application/pdf')


@service_router.get(
    '/export-list/excel',
    operation_id='export_list_excel',

)
async def export_list_excel(
        session: SessionDependency,
):
    excel_file: BytesIO = await ServiceExcelExporter(session).generate_excel()
    return Response(excel_file.getvalue(),
                    media_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')

# endregion