connect/api/api/endpoints/ps_node.py

from fastapi import APIRouter, Depends, status

from sqlalchemy.ext.asyncio import AsyncConnection

from api.db.connection.session import get_connection_dep
from api.db.logic.account import get_user_by_login
from api.schemas.base import bearer_schema
from api.schemas.process.ps_node import Ps_NodeFrontResponse, Ps_NodeRequest, Ps_NodeDeleteRequest
from api.services.auth import get_current_user
from api.db.logic.ps_node import get_ps_node_by_id, check_node_connection
from api.db.logic.process_schema import get_process_schema_by_id
from api.services.user_role_validation import UserRoleValidator
from core import VorkNodeRegistry
from api.error import create_operation_error, create_access_error, create_validation_error, create_server_error
from api.services.endpoints.ps_node import PsNodeService


api_router = APIRouter(
    prefix="/ps_node",
    tags=["ps node"],
)


@api_router.delete("", dependencies=[Depends(bearer_schema)], status_code=status.HTTP_200_OK)
async def delete_ps_node_endpoint(
    ps_node_delete_data: Ps_NodeDeleteRequest,
    connection: AsyncConnection = Depends(get_connection_dep),
    current_user=Depends(get_current_user),
):
    process_schema = await get_process_schema_by_id(connection, ps_node_delete_data.schema_id)
    if process_schema is None:
        raise create_operation_error(
            message="Process schema not found",
            status_code=status.HTTP_404_NOT_FOUND,
            details={"schema_id": ps_node_delete_data.schema_id},
        )

    validator = UserRoleValidator(connection)
    try:
        await validator.validate_ownership(current_user, process_schema.creator_id)
    except Exception as e:
        raise create_access_error(
            message="Access denied",
            status_code=status.HTTP_403_FORBIDDEN,
            details={"user_id": current_user, "schema_creator_id": process_schema.creator_id, "reason": str(e)},
        )

    ps_node = await get_ps_node_by_id(connection, ps_node_delete_data.node_id)
    if ps_node is None:
        raise create_operation_error(
            message="PS node not found",
            status_code=status.HTTP_404_NOT_FOUND,
            details={"node_id": ps_node_delete_data.node_id},
        )

    next_ps_node = await get_ps_node_by_id(connection, ps_node_delete_data.next_node_id)
    if next_ps_node is None:
        raise create_operation_error(
            message="Next PS node not found",
            status_code=status.HTTP_400_BAD_REQUEST,
            details={"next_node_id": ps_node_delete_data.next_node_id},
        )

    service = PsNodeService(connection)
    try:
        result = await service.delete(ps_node_delete_data.next_node_id)
    except Exception as e:
        raise create_server_error(
            message="Failed to delete nodes",
            status_code=500,
            details={"error": str(e), "next_node_id": ps_node_delete_data.next_node_id},
        )

    return result


@api_router.post("", dependencies=[Depends(bearer_schema)], response_model=Ps_NodeFrontResponse)
async def create_ps_node_endpoint(
    ps_node: Ps_NodeRequest,
    connection: AsyncConnection = Depends(get_connection_dep),
    current_user=Depends(get_current_user),
):
    user_validation = await get_user_by_login(connection, current_user)

    process_schema = await get_process_schema_by_id(connection, ps_node.data["ps_id"])
    if process_schema is None:
        raise create_operation_error(
            message="Process schema not found",
            status_code=status.HTTP_404_NOT_FOUND,
            details={"schema_id": ps_node.data["ps_id"]},
        )

    validator = UserRoleValidator(connection)
    try:
        await validator.validate_ownership(current_user, process_schema.creator_id)
    except Exception as e:
        raise create_access_error(
            message="Access denied",
            status_code=status.HTTP_403_FORBIDDEN,
            details={"user_id": current_user, "schema_creator_id": process_schema.creator_id, "reason": str(e)},
        )

    registery = VorkNodeRegistry()

    vork_node = registery.get(ps_node.data["node_type"])

    if vork_node is None:
        raise create_operation_error(
            message="Node type not found",
            status_code=status.HTTP_404_NOT_FOUND,
            details={"node_type": ps_node.data["node_type"]},
        )

    try:
        node_instance = vork_node(data=ps_node.data, links=ps_node.links)
        node_instance_validated = node_instance.validate()
    except Exception as e:
        raise create_validation_error(
            message="Node validation failed",
            status_code=status.HTTP_400_BAD_REQUEST,
            details={"error": str(e)},
        )

    parent_id = node_instance_validated.parent_id
    target_ps_id = ps_node.data["ps_id"]

    parent_node = await get_ps_node_by_id(connection, parent_id)
    if parent_node is None:
        raise create_operation_error(
            message="Parent PS node not found",
            status_code=status.HTTP_404_NOT_FOUND,
            details={"parent_id": parent_id},
        )
    if parent_node.ps_id != target_ps_id:
        raise create_validation_error(
            message="Parent PS node belongs to another process schema",
            status_code=status.HTTP_400_BAD_REQUEST,
            details={"parent_id": parent_id, "expected_ps_id": target_ps_id, "actual_ps_id": parent_node.ps_id},
        )

    service = PsNodeService(connection)
    try:
        ps_node_front_response = await service.create(ps_node.data, ps_node.links, user_validation.id)
    except Exception as e:
        raise create_server_error(
            message="Failed to create node",
            status_code=500,
            details={"error": str(e)},
        )

    return ps_node_front_response