Fulfillment-Backend/routers/deal.py

import base64
from io import BytesIO
from typing import Annotated

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

from backend.dependecies import SessionDependency, CurrentUserDependency
from backend.session import get_session
from generators.deal_pdf_generator.generator import DealPdfGenerator
from models import User
from schemas.barcode import GetDealProductsBarcodesPdfRequest, GetDealProductsBarcodesPdfResponse
from schemas.deal import *
from services.auth import get_current_user, authorized_user, guest_user
from services.barcode import BarcodeService
from services.billing import BillingService
from services.deal import DealService

deal_router = APIRouter(
    prefix='/deal',
    tags=['deal'],
)


# region Deal
@deal_router.post(
    '/create',
    dependencies=[Depends(authorized_user)]
)
async def create(
        request: DealCreateRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: Annotated[User, Depends(get_current_user)]
):
    return await DealService(session).create(request, user)


@deal_router.post(
    '/delete',
    response_model=DealDeleteResponse,
    operation_id='deleteDeal',
    dependencies=[Depends(authorized_user)]
)
async def delete(
        request: DealDeleteRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).delete(request)


@deal_router.post(
    '/complete',
    response_model=DealCompleteResponse,
    operation_id='completeDeal',
    dependencies=[Depends(authorized_user)]
)
async def complete(
        request: DealCompleteRequest,
        session: SessionDependency,
        user: CurrentUserDependency
):
    return await DealService(session).complete(user,request)

@deal_router.post(
    '/quickCreate',
    response_model=DealQuickCreateResponse,
    dependencies=[Depends(authorized_user)]
)
async def quick_create(
        request: DealQuickCreateRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: Annotated[User, Depends(get_current_user)]
):
    return await DealService(session).quick_create(request, user)


@deal_router.post(
    '/changeStatus',
    response_model=DealChangeStatusResponse,
    dependencies=[Depends(authorized_user)]
)
async def change_status(
        request: DealChangeStatusRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: Annotated[User, Depends(get_current_user)]
):
    return await DealService(session).change_status_manual(request, user)


@deal_router.get(
    '/summaries',
    response_model=DealSummaryResponse,
    operation_id='getDealSummaries',
    dependencies=[Depends(authorized_user)]
)
async def get_summary(
        session: Annotated[AsyncSession, Depends(get_session)],
        full: Optional[bool]
):
    return await DealService(session).get_summary(full)


@deal_router.post(
    '/summaries/reorder',
    response_model=DealSummaryResponse,
    operation_id='reorderDealSummaries',
    dependencies=[Depends(authorized_user)]
)
async def reorder(
        session: Annotated[AsyncSession, Depends(get_session)],
        request: DealSummaryReorderRequest,
        user: Annotated[User, Depends(get_current_user)]
):
    return await DealService(session).reorder(request, user)


@deal_router.get(
    '/get-all',
    response_model=DealGetAllResponse,
    operation_id='getAllDeals',
    dependencies=[Depends(authorized_user)]
)
async def get_all(
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).get_all()


# endpoint to get deal by id
@deal_router.get(
    '/get/{deal_id}',
    response_model=DealSchema,
    operation_id='getDealById',
    dependencies=[Depends(guest_user)]
)
async def get_deal_by_id(
        deal_id: int,
        user: CurrentUserDependency,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).get_by_id(user, deal_id)


@deal_router.post(
    '/update-general-info',
    response_model=DealUpdateGeneralInfoResponse,
    operation_id='updateDealGeneralInfo',
    dependencies=[Depends(authorized_user)]
)
async def update_general_info(
        request: DealUpdateGeneralInfoRequest,
        session: Annotated[AsyncSession, Depends(get_session)]
):
    return await DealService(session).update_general_info(request)


@deal_router.post(
    '/add-kit',
    response_model=DealAddKitResponse,
    operation_id='add_kit_to_deal'

)
async def add_kit_to_deal(
        session: SessionDependency,
        request: DealAddKitRequest
):
    return await DealService(session).add_kit_to_deal(request)


@deal_router.post(
    '/create-guest-url',
    response_model=DealCreateGuestUrlResponse,
    operation_id='create_deal_guest_url',
    dependencies=[Depends(authorized_user)]
)
async def create_guest_url(
        session: SessionDependency,
        request: DealCreateGuestUrlRequest,
        user: CurrentUserDependency
):
    return DealService(session).create_guest_url(user, request)


@deal_router.get(
    '/document/{deal_id}',
    operation_id='get_deal_document',
    # dependencies=[Depends(authorized_user)],
)
async def get_deal_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')


@deal_router.get(
    '/detailedDocument/{deal_id}',
    operation_id='get_deal_document_detailed',
    # dependencies=[Depends(authorized_user)],
)
async def get_detailed_deal_document(
        deal_id: int,
        session: Annotated[AsyncSession, Depends(get_session)],
):
    pdf_file: BytesIO = await DealPdfGenerator(session).create_detailed_deal_document_pdf(deal_id)
    return Response(pdf_file.getvalue(), media_type='application/pdf')


@deal_router.post(
    '/prefill',
    response_model=DealPrefillResponse,
    operation_id='prefill_deal',
    dependencies=[Depends(authorized_user)]
)
async def post_prefill_deal(
        session: SessionDependency,
        request: DealPrefillRequest,
        user: CurrentUserDependency
):
    return await DealService(session).prefill_deal(user, request)


# endregion

# region Deal services

@deal_router.post(
    '/services/add/multiple',
    response_model=DealAddServicesResponse,
    operation_id='addMultipleDealServices',
    dependencies=[Depends(guest_user)]
)
async def services_add(
        request: DealAddServicesRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
):
    return await DealService(session).add_services(request)


@deal_router.post(
    '/services/add',
    response_model=DealAddServiceResponse,
    operation_id='addDealService',
    dependencies=[Depends(guest_user)]
)
async def services_add(
        request: DealAddServiceRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await DealService(session).add_service(user, request)


@deal_router.post(
    '/services/update-quantity',
    response_model=DealUpdateServiceQuantityResponse,
    operation_id='updateDealServiceQuantity',
    dependencies=[Depends(guest_user)]
)
async def services_update_quantity(
        request: DealUpdateServiceQuantityRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency

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


@deal_router.post(
    '/services/update',
    response_model=DealUpdateServiceResponse,
    operation_id='updateDealService',
    dependencies=[Depends(guest_user)]
)
async def services_update(
        request: DealUpdateServiceRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await DealService(session).update_service(user, request)


@deal_router.post(
    '/services/delete',
    response_model=DealDeleteServiceResponse,
    operation_id='deleteDealService',
    dependencies=[Depends(guest_user)]
)
async def services_delete(
        request: DealDeleteServiceRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await DealService(session).delete_service(user, request)


@deal_router.post(
    '/services/delete/multiple',
    response_model=DealDeleteServicesResponse,
    operation_id='deleteMultipleDealServices',
    dependencies=[Depends(guest_user)]
)
async def services_delete(
        request: DealDeleteServicesRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await DealService(session).delete_services(user, request)


@deal_router.post(
    '/services/copy',
    response_model=DealServicesCopyResponse,
    operation_id='copy_product_services',
    dependencies=[Depends(guest_user)]
)
async def services_copy(
        session: SessionDependency,
        request: DealServicesCopyRequest,
        user: CurrentUserDependency
):
    return await DealService(session).copy_services(user, request)


# endregion

# region Deal products
@deal_router.post(
    '/products/update-quantity',
    response_model=DealUpdateProductQuantityResponse,
    operation_id='updateDealProductQuantity',
    dependencies=[Depends(guest_user)]
)
async def products_update(
        request: DealUpdateProductQuantityRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await DealService(session).update_product_quantity(user, request)


@deal_router.post(
    '/products/add',
    response_model=DealAddProductResponse,
    operation_id='addDealProduct',
    dependencies=[Depends(guest_user)]
)
async def products_add(
        request: DealAddProductRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await DealService(session).add_product(user, request)


@deal_router.post(
    '/products/delete',
    response_model=DealDeleteProductResponse,
    operation_id='deleteDealProduct',
    dependencies=[Depends(guest_user)]
)
async def products_delete(
        request: DealDeleteProductRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency

):
    return await DealService(session).delete_product(user, request)


@deal_router.post(
    '/products/delete/multiple',
    response_model=DealDeleteProductsResponse,
    operation_id='deleteMultipleDealProducts',
    dependencies=[Depends(guest_user)]
)
async def products_delete(
        request: DealDeleteProductsRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await DealService(session).delete_products(user, request)


@deal_router.post(
    '/product/update',
    response_model=DealUpdateProductResponse,
    operation_id='updateDealProduct',
    dependencies=[Depends(guest_user)]
)
async def products_update(
        request: DealUpdateProductRequest,
        session: Annotated[AsyncSession, Depends(get_session)],
        user: CurrentUserDependency
):
    return await DealService(session).update_product(user, request)


@deal_router.post(
    '/product/add-kit',
    response_model=DealProductAddKitResponse,
    operation_id='add_kit_to_deal_product',
    dependencies=[Depends(guest_user)]
)
async def add_kit_to_deal_product(
        session: SessionDependency,
        request: DealProductAddKitRequest,
        user: CurrentUserDependency
):
    return await DealService(session).add_kit_to_deal_product(user, request)


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

# endregion