backend/src/api/orders.py - master - FlysAt/DataFoundry

backend/src/api/orders.py
191 строка6 KB
AlexanderShmygol
fixed
17 май 2026, 14:28
17 май 2026, 14:28446906b
from io import BytesIO

from fastapi import APIRouter, Depends, File, Query, Request, UploadFile, status
from fastapi.responses import StreamingResponse
from sqlalchemy.ext.asyncio import AsyncSession

from src.core.db import get_db
from src.dependencies.auth import get_current_user
from src.api.services.order_export import OrderExportService
from src.api.services.label_studio import LabelStudioService
from src.api.services.order_dataset import OrderDatasetService
from src.models.order import OrderStatus, OperationType
from src.models.user import User
from src.schemas.label_studio import AnnotatedDatasetPreviewItemSchema, LabelStudioWorkspaceResponseSchema
from src.schemas.order_dataset import OrderDatasetInfoSchema, OrderDatasetResponseSchema
from src.schemas.order import (
    OrderCreateSchema,
    OrderUpdateSchema,
    OrderStatusUpdateSchema,
    OrderResponseSchema,
)
from src.api.services.order import OrderService

router = APIRouter(prefix="/orders", tags=["orders"])


@router.post("", response_model=OrderResponseSchema, status_code=status.HTTP_201_CREATED)
async def create_order(
    payload: OrderCreateSchema,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = OrderService(db)
    return await service.create_order(payload, current_user)


@router.get("", response_model=list[OrderResponseSchema])
async def list_orders(
    db: AsyncSession = Depends(get_db),
):
    service = OrderService(db)
    return await service.list_orders()


@router.get("/my", response_model=list[OrderResponseSchema])
async def list_my_orders(
    statuses: list[OrderStatus] | None = Query(default=None),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = OrderService(db)
    return await service.list_my_orders(current_user, statuses)


@router.get("/available", response_model=list[OrderResponseSchema])
async def list_available_orders(
    operation_type: OperationType | None = Query(default=None),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = OrderService(db)
    return await service.list_available_orders(current_user, operation_type)


@router.get("/{order_id}", response_model=OrderResponseSchema)
async def get_order(
    order_id: int,
    db: AsyncSession = Depends(get_db),
):
    service = OrderService(db)
    return await service.get_order(order_id)


@router.patch("/{order_id}", response_model=OrderResponseSchema)
async def update_order(
    order_id: int,
    payload: OrderUpdateSchema,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = OrderService(db)
    return await service.update_order(order_id, payload, current_user)


@router.patch("/{order_id}/status", response_model=OrderResponseSchema)
async def update_order_status(
    order_id: int,
    payload: OrderStatusUpdateSchema,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = OrderService(db)
    return await service.update_order_status(order_id, payload, current_user)


@router.delete("/{order_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_order(
    order_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = OrderService(db)
    await service.delete_order(order_id, current_user)


@router.post(
    "/{order_id}/dataset",
    response_model=OrderDatasetResponseSchema,
    status_code=status.HTTP_201_CREATED,
)
async def upload_order_dataset(
    order_id: int,
    dataset: UploadFile = File(...),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = OrderDatasetService(db)
    return await service.upload_dataset(order_id, dataset, current_user)


@router.get(
    "/{order_id}/dataset",
    response_model=OrderDatasetInfoSchema,
)
async def get_order_dataset_info(
    order_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = OrderDatasetService(db)
    return await service.get_dataset_info(order_id, current_user)


@router.post(
    "/{order_id}/labeling",
    response_model=LabelStudioWorkspaceResponseSchema,
    status_code=status.HTTP_201_CREATED,
)
async def open_labeling_workspace(
    order_id: int,
    request: Request,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = LabelStudioService(db)
    project = await service.open_workspace(order_id, current_user, request)
    task_count = await service.count_project_tasks(project.id)
    return LabelStudioWorkspaceResponseSchema(
        order_id=project.order_id,
        order_dataset_id=project.order_dataset_id,
        project_id=project.id,
        external_project_id=project.external_project_id,
        workspace_url=project.workspace_url,
        task_count=task_count,
        created_at=project.created_at,
    )


@router.get("/{order_id}/annotated-dataset")
async def download_annotated_dataset(
    order_id: int,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = OrderExportService(db)
    archive_bytes, filename = await service.build_annotated_dataset_archive(order_id, current_user)
    media_type = "application/json" if filename.endswith(".json") else "application/zip"
    return StreamingResponse(
        BytesIO(archive_bytes),
        media_type=media_type,
        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
    )


@router.get("/{order_id}/annotated-dataset/preview")
async def preview_annotated_dataset(
    order_id: int,
    request: Request,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_user),
):
    service = OrderExportService(db)
    result = await service.build_annotated_dataset_preview(order_id, current_user, request)
    if isinstance(result, tuple):
        preview_bytes, filename = result
        return StreamingResponse(
            BytesIO(preview_bytes),
            media_type="application/json",
            headers={"Content-Disposition": f'attachment; filename="{filename}"'},
        )
    return result