Fulfillment-Backend/routers/card.py

import base64
from io import BytesIO
from typing import Annotated

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

from backend.dependecies import SessionDependency, CurrentUserDependency, PaginationDependency
from backend.session import get_session
from generators.deal_pdf_generator.generator import DealTechSpecPdfGenerator
from models import User
from parsers import DealParser
from schemas.barcode import GetCardProductsBarcodesPdfRequest, GetCardProductsBarcodesPdfResponse
from schemas.card import *
from services.auth import get_current_user, authorized_user, guest_user
from services.barcode import BarcodeService
from services.billing import BillingService
from services.card import CardsService

card_router = APIRouter(
    prefix='/card',
    tags=['card'],
)


# region Card

@card_router.post(
    '/delete',
    response_model=CardDeleteResponse,
    operation_id='deleteCard',
    dependencies=[Depends(authorized_user)]
)
async def delete(
        request: CardDeleteRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await CardsService(session).delete(request)


@card_router.post(
    '/complete',
    response_model=CardCompleteResponse,
    operation_id='completeCard',
    dependencies=[Depends(authorized_user)]
)
async def complete(
        request: CardCompleteRequest,
        session: SessionDependency,
        user: CurrentUserDependency
):
    return await CardsService(session).complete(user, request)


@card_router.post(
    '/quickCreate',
    response_model=CardQuickCreateResponse,
    dependencies=[Depends(authorized_user)]
)
async def quick_create(
        request: CardQuickCreateRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: Annotated[User, Depends(get_current_user)]
):
    return await CardsService(session).quick_create(request, user)


@card_router.post(
    '/changeStatus',
    response_model=CardChangeStatusResponse,
    dependencies=[Depends(authorized_user)]
)
async def change_status(
        request: CardChangeStatusRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: Annotated[User, Depends(get_current_user)]
):
    return await CardsService(session).change_status_manual(request, user)


@card_router.post(
    '/summaries',
    response_model=CardSummaryResponse,
    operation_id='getCardSummaries',
    dependencies=[Depends(authorized_user)]
)
async def get_summary(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: GetCardSummariesRequest,
        pagination: PaginationDependency,
):
    return await CardsService(session).get_summary(request, pagination)


@card_router.post(
    '/summaries/reorder',
    response_model=CardSummaryResponse,
    operation_id='reorderCardSummaries',
    dependencies=[Depends(authorized_user)]
)
async def reorder(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: CardSummaryReorderRequest,
        user: Annotated[User, Depends(get_current_user)]
):
    return await CardsService(session).reorder(request, user)


@card_router.get(
    '/get-all',
    response_model=CardGetAllResponse,
    operation_id='getAllCards',
    dependencies=[Depends(authorized_user)]
)
async def get_all(
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await CardsService(session).get_all()


# endpoint to get card by id
@card_router.get(
    '/get/{card_id}',
    response_model=CardSchema,
    operation_id='getCardById',
    dependencies=[Depends(guest_user)]
)
async def get_card_by_id(
        card_id: int,
        user: CurrentUserDependency,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await CardsService(session).get_by_id(user, card_id)


@card_router.post(
    '/update-general-info',
    response_model=CardUpdateGeneralInfoResponse,
    operation_id='update_card_general_info',
    dependencies=[Depends(authorized_user)]
)
async def update_general_info(
        request: CardUpdateGeneralInfoRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency,
):
    return await CardsService(session).update_general_info(request, user)


@card_router.post(
    '/update-products-and-services-general-info',
    response_model=ProductsAndServicesGeneralInfoResponse,
    operation_id='update_products_and_services_general_info',
    dependencies=[Depends(authorized_user)]
)
async def update_products_and_services_general_info(
        request: ProductsAndServicesGeneralInfoRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
):
    return await CardsService(session).update_products_and_services_general_info(request)


@card_router.post(
    '/update-card-manager',
    response_model=UpdateCardManagerResponse,
    operation_id='update_card_manager',
    dependencies=[Depends(authorized_user)]
)
async def update_card_manager(
        request: UpdateCardManagerRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
):
    return await CardsService(session).update_card_manager(request)


@card_router.post(
    '/update-card-client',
    response_model=UpdateCardClientResponse,
    operation_id='update_card_client',
    dependencies=[Depends(authorized_user)]
)
async def update_card_client(
        request: UpdateCardClientRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
):
    return await CardsService(session).update_card_client(request)

@card_router.post(
    '/add-kit',
    response_model=CardAddKitResponse,
    operation_id='add_kit_to_card'
)
async def add_kit_to_card(
        session: SessionDependency,
        request: CardAddKitRequest
):
    return await CardsService(session).add_kit_to_card(request)


@card_router.post(
    '/create-guest-url',
    response_model=CardCreateGuestUrlResponse,
    operation_id='create_deal_guest_url',
    dependencies=[Depends(authorized_user)]
)
async def create_guest_url(
        session: SessionDependency,
        request: CardCreateGuestUrlRequest,
        user: CurrentUserDependency
):
    return CardsService(session).create_guest_url(user, request)


@card_router.get(
    '/billing-document/{deal_id}',
    operation_id='get_billing_document',
    # dependencies=[Depends(authorized_user)],
)
async def get_billing_document(
        deal_id: int,
        session: Annotated[AsyncSession, Depends(get_session)],
):
    pdf_file: BytesIO = await BillingService(session).create_billing_document_pdf(deal_id)
    return Response(pdf_file.getvalue(), media_type='application/pdf')


@card_router.get(
    '/tech-spec/{deal_id}',
    operation_id='get_deal_tech_spec',
    # dependencies=[Depends(authorized_user)],
)
async def get_deal_tech_spec(
        deal_id: int,
        session: Annotated[AsyncSession, Depends(get_session)],
):
    pdf_file: BytesIO = await DealTechSpecPdfGenerator(session).create_deal_tech_spec_pdf(deal_id)
    return Response(pdf_file.getvalue(), media_type='application/pdf')


@card_router.post(
    '/prefill',
    response_model=CardPrefillResponse,
    operation_id='prefill_card',
    dependencies=[Depends(authorized_user)]
)
async def post_prefill_card(
        session: SessionDependency,
        request: CardPrefillRequest,
        user: CurrentUserDependency
):
    return await CardsService(session).prefill_card_products_and_services(user, request)


@card_router.post(
    '/recalculate-price',
    response_model=CardRecalculatePriceResponse,
    operation_id='recalculate_card_price',
)
async def recalculate_card_price(
        session: SessionDependency,
        request: CardRecalculatePriceRequest,
):
    return await CardsService(session).recalculate_price(request)


@card_router.post(
    '/employee',
    response_model=ManageEmployeeResponse,
    operation_id='manage_employee',
)
async def manage_employee(
        session: SessionDependency,
        request: ManageEmployeeRequest,
):
    return await CardsService(session).manage_employee(request)


@card_router.get(
    '/employee/available/{card_id}',
    response_model=GetAvailableEmployeesToAssignResponse,
    operation_id='get_available_employees_to_assign',
)
async def get_available_employees_to_assign(
        session: Annotated[AsyncSession, Depends(get_session)],
        card_id: int,
):
    return await CardsService(session).get_available_employees_to_assign(card_id)


@card_router.post(
    '/prefill/excel/parse',
    response_model=ParseCardsExcelResponse,
    operation_id='parse_deals_excel',
)
async def parse_deals_excel(
        session: Annotated[AsyncSession, Depends(get_session)],
        upload_file: UploadFile,
):
    file_bytes = upload_file.file.read()
    return await DealParser(session).parse(file_bytes)


@card_router.post(
    '/prefill/excel/create',
    response_model=CreateCardsFromExcelResponse,
    operation_id='create_deals_excel',
)
async def create_deals_from_excel(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: CreateCardsFromExcelRequest,
        user: CurrentUserDependency,
):
    return await CardsService(session).create_cards_from_excel(request, user)

# endregion

# region Card services

@card_router.post(
    '/services/add/multiple',
    response_model=CardAddServicesResponse,
    operation_id='add_multiple_card_services',
    dependencies=[Depends(guest_user)]
)
async def services_add(
        request: CardAddServicesRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
):
    return await CardsService(session).add_services(request)


@card_router.post(
    '/services/add',
    response_model=CardAddServiceResponse,
    operation_id='add_card_service',
    dependencies=[Depends(guest_user)]
)
async def services_add(
        request: CardAddServiceRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await CardsService(session).add_service(user, request)


@card_router.post(
    '/services/update-quantity',
    response_model=CardUpdateServiceQuantityResponse,
    operation_id='update_card_service_quantity',
    dependencies=[Depends(guest_user)]
)
async def services_update_quantity(
        request: CardUpdateServiceQuantityRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency

):
    return await CardsService(session).update_service_quantity(user, request)


@card_router.post(
    '/services/update',
    response_model=CardUpdateServiceResponse,
    operation_id='update_card_service',
    dependencies=[Depends(guest_user)]
)
async def services_update(
        request: CardUpdateServiceRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await CardsService(session).update_service(user, request)


@card_router.post(
    '/services/delete',
    response_model=CardDeleteServiceResponse,
    operation_id='delete_card_service',
    dependencies=[Depends(guest_user)]
)
async def services_delete(
        request: CardDeleteServiceRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await CardsService(session).delete_service(user, request)


@card_router.post(
    '/services/delete/multiple',
    response_model=CardDeleteServicesResponse,
    operation_id='delete_multiple_card_services',
    dependencies=[Depends(guest_user)]
)
async def services_delete(
        request: CardDeleteServicesRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await CardsService(session).delete_services(user, request)


@card_router.post(
    '/services/copy',
    response_model=CardServicesCopyResponse,
    operation_id='copy_product_services',
    dependencies=[Depends(guest_user)]
)
async def services_copy(
        session: SessionDependency,
        request: CardServicesCopyRequest,
        user: CurrentUserDependency
):
    return await CardsService(session).copy_services(user, request)


# endregion

# region Card products
@card_router.post(
    '/products/update-quantity',
    response_model=CardUpdateProductQuantityResponse,
    operation_id='update_card_product_quantity',
    dependencies=[Depends(guest_user)]
)
async def products_update(
        request: CardUpdateProductQuantityRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await CardsService(session).update_product_quantity(user, request)


@card_router.post(
    '/products/add',
    response_model=CardAddProductResponse,
    operation_id='add_card_product',
    dependencies=[Depends(guest_user)]
)
async def products_add(
        request: CardAddProductRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await CardsService(session).add_product(user, request)


@card_router.post(
    '/products/delete',
    response_model=CardDeleteProductResponse,
    operation_id='delete_card_product',
    dependencies=[Depends(guest_user)]
)
async def products_delete(
        request: CardDeleteProductRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await CardsService(session).delete_product(user, request)


@card_router.post(
    '/products/delete/multiple',
    response_model=CardDeleteProductsResponse,
    operation_id='delete_multiple_card_products',
    dependencies=[Depends(guest_user)]
)
async def products_delete(
        request: CardDeleteProductsRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await CardsService(session).delete_products(user, request)


@card_router.post(
    '/product/update',
    response_model=CardUpdateProductResponse,
    operation_id='update_card_product',
    dependencies=[Depends(guest_user)]
)
async def products_update(
        request: CardUpdateProductRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await CardsService(session).update_product(user, request)


@card_router.post(
    '/product/add-kit',
    response_model=CardProductAddKitResponse,
    operation_id='add_kit_to_card_product',
    dependencies=[Depends(guest_user)]
)
async def add_kit_to_card_product(
        session: SessionDependency,
        request: CardProductAddKitRequest,
        user: CurrentUserDependency
):
    return await CardsService(session).add_kit_to_card_product(user, request)


@card_router.post(
    '/barcodes/get-pdf',
    operation_id='get_card_products_barcodes_pdf',
    response_model=GetCardProductsBarcodesPdfResponse
)
async def get_card_products_barcodes_pdf(
        request: GetCardProductsBarcodesPdfRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    filename, pdf_buffer = await BarcodeService(session).get_card_barcodes_pdf(request)
    pdf_buffer: BytesIO
    base64_string = base64.b64encode(pdf_buffer.read()).decode('utf-8')
    return GetCardProductsBarcodesPdfResponse(
        base64_string=base64_string,
        filename=filename,
        mime_type='application/pdf'
    )


# endregion