Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

6.9 KB
Raw Blame
from datetime import datetime
from http import HTTPStatus
from typing import Any, Never

from flask import Response, jsonify, request
from flask_restx import Resource
from pydantic import BaseModel, ValidationError, field_validator
from werkzeug.exceptions import BadRequest, NotFound, UnprocessableEntity

from controllers.common.schema import register_response_schema_models, register_schema_models
from controllers.console import console_ns
from controllers.console.flask_admission import console_account_admission
from controllers.console.wraps import setup_required
from extensions.ext_application_services import application_services
from fields.base import ResponseModel
from libs.helper import dump_response, to_timestamp
from machinery.context import RequestContext
from services.oauth_server_service import (
    OAuthServerClientNotFoundError,
    OAuthServerRequestError,
    OAuthServerUnauthorizedError,
)


class OAuthClientPayload(BaseModel):
    client_id: str


class OAuthProviderRequest(BaseModel):
    client_id: str
    redirect_uri: str


class OAuthTokenRequest(BaseModel):
    client_id: str
    grant_type: str
    code: str | None = None
    client_secret: str | None = None
    redirect_uri: str | None = None
    refresh_token: str | None = None


class OAuthProviderAppResponse(ResponseModel):
    app_icon: str
    app_label: dict[str, Any]
    scope: str
    auto_authorize: bool


class OAuthProviderAuthorizeResponse(ResponseModel):
    code: str


class OAuthProviderTokenResponse(ResponseModel):
    access_token: str
    token_type: str
    expires_in: int
    refresh_token: str


class OAuthProviderAccountResponse(ResponseModel):
    id: str
    name: str
    email: str
    avatar: str | None = None
    interface_language: str | None
    timezone: str | None
    created_at: int

    @field_validator("created_at", mode="before")
    @classmethod
    def _normalize_timestamp(cls, value: datetime | int) -> int:
        return to_timestamp(value)


register_schema_models(console_ns, OAuthClientPayload, OAuthProviderRequest, OAuthTokenRequest)
register_response_schema_models(
    console_ns,
    OAuthProviderAccountResponse,
    OAuthProviderAppResponse,
    OAuthProviderAuthorizeResponse,
    OAuthProviderTokenResponse,
)


def _parse_payload[PayloadT: BaseModel](model: type[PayloadT]) -> PayloadT:
    json_data = request.get_json()
    if json_data is None:
        raise BadRequest("client_id is required")
    try:
        return model.model_validate(json_data)
    except ValidationError as exc:
        raise UnprocessableEntity(exc.json()) from exc


def _raise_application_error(error: OAuthServerClientNotFoundError | OAuthServerRequestError) -> Never:
    if isinstance(error, OAuthServerClientNotFoundError):
        raise NotFound(str(error)) from error
    raise BadRequest(str(error)) from error


def _parse_bearer_access_token() -> tuple[str | None, str | None]:
    authorization_header = request.headers.get("Authorization")
    if not authorization_header:
        return None, "Authorization header is required"

    parts = authorization_header.strip().split(None, 1)
    if len(parts) != 2:
        return None, "Invalid Authorization header format"

    token_type, access_token = (part.strip() for part in parts)
    if token_type.lower() != "bearer":
        return None, "token_type is invalid"
    if not access_token:
        return None, "access_token is required"
    return access_token, None


def _unauthorized_response(error: str) -> Response:
    response = jsonify({"error": error})
    response.status_code = HTTPStatus.UNAUTHORIZED
    response.headers["WWW-Authenticate"] = "Bearer"
    return response


@console_ns.route("/oauth/provider")
class OAuthServerAppApi(Resource):
    @console_ns.expect(console_ns.models[OAuthProviderRequest.__name__])
    @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[OAuthProviderAppResponse.__name__])
    @setup_required
    def post(self):
        payload = _parse_payload(OAuthProviderRequest)
        try:
            provider = application_services().oauth_server.get_provider(
                client_id=payload.client_id,
                redirect_uri=payload.redirect_uri,
            )
        except (OAuthServerClientNotFoundError, OAuthServerRequestError) as error:
            _raise_application_error(error)
        return dump_response(OAuthProviderAppResponse, provider), HTTPStatus.OK


@console_ns.route("/oauth/provider/authorize")
class OAuthServerUserAuthorizeApi(Resource):
    @console_ns.expect(console_ns.models[OAuthClientPayload.__name__])
    @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[OAuthProviderAuthorizeResponse.__name__])
    @console_account_admission()
    def post(self, request_context: RequestContext):
        payload = _parse_payload(OAuthClientPayload)
        try:
            authorization = application_services().oauth_server.authorize(
                request_context,
                client_id=payload.client_id,
            )
        except OAuthServerClientNotFoundError as error:
            _raise_application_error(error)
        return dump_response(OAuthProviderAuthorizeResponse, authorization), HTTPStatus.OK


@console_ns.route("/oauth/provider/token")
class OAuthServerUserTokenApi(Resource):
    @console_ns.expect(console_ns.models[OAuthTokenRequest.__name__])
    @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[OAuthProviderTokenResponse.__name__])
    @setup_required
    def post(self):
        payload = _parse_payload(OAuthTokenRequest)
        try:
            tokens = application_services().oauth_server.exchange_token(
                client_id=payload.client_id,
                grant_type=payload.grant_type,
                code=payload.code,
                client_secret=payload.client_secret,
                redirect_uri=payload.redirect_uri,
                refresh_token=payload.refresh_token,
            )
        except (OAuthServerClientNotFoundError, OAuthServerRequestError) as error:
            _raise_application_error(error)
        return dump_response(OAuthProviderTokenResponse, tokens), HTTPStatus.OK


@console_ns.route("/oauth/provider/account")
class OAuthServerUserAccountApi(Resource):
    @console_ns.expect(console_ns.models[OAuthClientPayload.__name__])
    @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[OAuthProviderAccountResponse.__name__])
    @setup_required
    def post(self):
        payload = _parse_payload(OAuthClientPayload)
        access_token, header_error = _parse_bearer_access_token()
        try:
            account = application_services().oauth_server.get_account(
                client_id=payload.client_id,
                access_token=access_token,
            )
        except OAuthServerClientNotFoundError as error:
            _raise_application_error(error)
        except OAuthServerUnauthorizedError as error:
            return _unauthorized_response(header_error or str(error))
        return dump_response(OAuthProviderAccountResponse, account), HTTPStatus.OK