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.

15.0 KB
Raw Blame
from http import HTTPStatus
from typing import Never
from uuid import UUID

import flask_login
from flask import make_response, request
from flask_restx import Resource
from pydantic import BaseModel, Field, field_validator

from controllers.common.fields import (
    SimpleResultDataResponse,
    SimpleResultMessageResponse,
    SimpleResultOptionalDataResponse,
    SimpleResultResponse,
)
from controllers.common.schema import register_response_schema_models, register_schema_models
from controllers.console import console_ns
from controllers.console.auth.error import (
    AuthenticationFailedError,
    EmailCodeError,
    EmailCodeLoginRateLimitExceededError,
    EmailCodeLoginServiceUnavailableError,
    EmailPasswordLoginLimitError,
    InvalidEmailError,
    InvalidTokenError,
    NormalizedEmailAlreadyInUseError,
    PasswordResetRateLimitExceededError,
    TurnstileServiceUnavailableError,
    TurnstileVerificationFailedError,
)
from controllers.console.error import (
    AccountBannedError,
    AccountInFreezeError,
    AccountNotFound,
    EmailDomainSuspendedError,
    EmailSendIpLimitError,
    InvalidAccountPasswordRequestError,
    NotAllowedCreateWorkspace,
    SeatsLimitExceeded,
    WorkspacesLimitExceeded,
)
from controllers.console.wraps import (
    decrypt_code_field,
    decrypt_password_field,
    email_password_login_enabled,
    model_validate,
    setup_required,
)
from extensions.ext_application_services import application_services
from libs.external_api import error_responses
from libs.helper import EmailStr, dump_response, extract_remote_ip
from libs.helper import timezone as validate_timezone_string
from libs.login import current_account_with_tenant_optional
from libs.token import (
    clear_access_token_from_cookie,
    clear_csrf_token_from_cookie,
    clear_refresh_token_from_cookie,
    extract_refresh_token,
    set_access_token_to_cookie,
    set_csrf_token_to_cookie,
    set_refresh_token_to_cookie,
)
from services import account_errors
from services.entities.account_entities import AccountSessionTokens
from services.entities.account_login_entities import EmailCodeLoginCommand, EmailCodeSendCommand, PasswordLoginCommand
from services.entities.auth_entities import LoginPayloadBase


class LoginPayload(LoginPayloadBase):
    remember_me: bool = Field(default=False, description="Remember me flag")
    invite_token: str | None = Field(default=None, description="Invitation token")


class EmailPayload(BaseModel):
    email: EmailStr = Field(...)
    language: str | None = Field(default=None)


class EmailCodeSendPayload(EmailPayload):
    turnstile_token: str | None = Field(
        default=None,
        max_length=2048,
        description="Cloudflare Turnstile token. Required at runtime for Dify Cloud.",
    )


class EmailCodeLoginPayload(BaseModel):
    email: EmailStr = Field(...)
    code: str
    token: UUID
    turnstile_token: str | None = Field(
        default=None,
        max_length=2048,
        description="Cloudflare Turnstile token for email-code verification.",
    )
    language: str | None = Field(default=None)
    timezone: str | None = Field(default=None)

    @field_validator("timezone")
    @classmethod
    def validate_timezone(cls, value: str | None) -> str | None:
        if value is None:
            return None
        return validate_timezone_string(value)


register_schema_models(console_ns, LoginPayload, EmailPayload, EmailCodeSendPayload, EmailCodeLoginPayload)
register_response_schema_models(
    console_ns,
    SimpleResultDataResponse,
    SimpleResultMessageResponse,
    SimpleResultOptionalDataResponse,
    SimpleResultResponse,
)


@console_ns.route("/login")
class LoginApi(Resource):
    """Resource for user login."""

    @error_responses(
        AccountBannedError,
        AccountInFreezeError,
        AccountNotFound,
        AuthenticationFailedError,
        EmailDomainSuspendedError,
        EmailPasswordLoginLimitError,
        InvalidAccountPasswordRequestError,
        InvalidEmailError,
        WorkspacesLimitExceeded,
    )
    @setup_required
    @email_password_login_enabled
    @console_ns.expect(console_ns.models[LoginPayload.__name__])
    @console_ns.response(200, "Success", console_ns.models[SimpleResultOptionalDataResponse.__name__])
    @decrypt_password_field
    @model_validate(LoginPayload)
    def post(self, req_data: LoginPayload):
        """Authenticate user and login."""
        try:
            result = application_services().accounts.authentication.login_with_password(
                PasswordLoginCommand(
                    email=req_data.email,
                    password=req_data.password,
                    invite_token=req_data.invite_token,
                    ip_address=extract_remote_ip(request),
                )
            )
        except account_errors.AccountApplicationError as error:
            _raise_password_login_error(error)

        if not result.workspace_found or result.tokens is None:
            return dump_response(
                SimpleResultOptionalDataResponse,
                {
                    "result": "fail",
                    "data": "workspace not found, please contact system admin to invite you to join in a workspace",
                },
            )
        return _token_response(result.tokens, SimpleResultOptionalDataResponse, {"result": "success"})


@console_ns.route("/logout")
class LogoutApi(Resource):
    @setup_required
    @console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])
    def post(self):
        account, _ = current_account_with_tenant_optional()
        if account is not None:
            application_services().accounts.authentication.logout(account.id)
            flask_login.logout_user()

        response = make_response(dump_response(SimpleResultResponse, {"result": "success"}))
        clear_access_token_from_cookie(response)
        clear_refresh_token_from_cookie(response)
        clear_csrf_token_from_cookie(response)
        return response


@console_ns.route("/reset-password")
class ResetPasswordSendEmailApi(Resource):
    @error_responses(
        AccountBannedError, AccountInFreezeError, EmailDomainSuspendedError, PasswordResetRateLimitExceededError
    )
    @setup_required
    @email_password_login_enabled
    @console_ns.expect(console_ns.models[EmailPayload.__name__])
    @console_ns.response(200, "Success", console_ns.models[SimpleResultDataResponse.__name__])
    @model_validate(EmailPayload)
    def post(self, req_data: EmailPayload):
        try:
            token = application_services().accounts.authentication.send_reset_password_email(
                email=req_data.email,
                language=req_data.language,
                ip_address=extract_remote_ip(request),
            )
        except account_errors.AccountApplicationError as error:
            _raise_reset_password_email_error(error)
        return dump_response(SimpleResultDataResponse, {"result": "success", "data": token})


@console_ns.route("/email-code-login")
class EmailCodeLoginSendEmailApi(Resource):
    @error_responses(
        AccountBannedError,
        AccountInFreezeError,
        EmailCodeLoginRateLimitExceededError,
        EmailCodeLoginServiceUnavailableError,
        EmailDomainSuspendedError,
        EmailSendIpLimitError,
        TurnstileServiceUnavailableError,
        TurnstileVerificationFailedError,
    )
    @setup_required
    @console_ns.expect(console_ns.models[EmailCodeSendPayload.__name__])
    @console_ns.response(200, "Success", console_ns.models[SimpleResultDataResponse.__name__])
    @model_validate(EmailCodeSendPayload)
    def post(self, req_data: EmailCodeSendPayload):
        try:
            token = application_services().accounts.authentication.send_email_code(
                EmailCodeSendCommand(
                    email=req_data.email,
                    language=req_data.language,
                    turnstile_token=req_data.turnstile_token,
                    ip_address=extract_remote_ip(request),
                )
            )
        except account_errors.AccountApplicationError as error:
            _raise_email_code_send_error(error)
        return dump_response(SimpleResultDataResponse, {"result": "success", "data": token})


@console_ns.route("/email-code-login/validity")
class EmailCodeLoginApi(Resource):
    @error_responses(
        AccountBannedError,
        AccountInFreezeError,
        AccountNotFound,
        EmailCodeError,
        EmailCodeLoginServiceUnavailableError,
        EmailDomainSuspendedError,
        InvalidEmailError,
        InvalidTokenError,
        NormalizedEmailAlreadyInUseError,
        NotAllowedCreateWorkspace,
        SeatsLimitExceeded,
        TurnstileServiceUnavailableError,
        TurnstileVerificationFailedError,
        WorkspacesLimitExceeded,
    )
    @setup_required
    @console_ns.expect(console_ns.models[EmailCodeLoginPayload.__name__])
    @console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])
    @decrypt_code_field
    @model_validate(EmailCodeLoginPayload)
    def post(self, req_data: EmailCodeLoginPayload):
        try:
            tokens = application_services().accounts.authentication.login_with_email_code(
                EmailCodeLoginCommand(
                    email=req_data.email,
                    code=req_data.code,
                    token=str(req_data.token),
                    turnstile_token=req_data.turnstile_token,
                    language=req_data.language,
                    timezone=req_data.timezone,
                    ip_address=extract_remote_ip(request),
                )
            )
        except account_errors.AccountApplicationError as error:
            _raise_email_code_login_error(error)
        return _token_response(tokens, SimpleResultResponse, {"result": "success"})


@console_ns.route("/refresh-token")
class RefreshTokenApi(Resource):
    @console_ns.response(200, "Success", console_ns.models[SimpleResultResponse.__name__])
    @console_ns.response(401, "Unauthorized", console_ns.models[SimpleResultMessageResponse.__name__])
    def post(self):
        refresh_token = extract_refresh_token(request)
        if not refresh_token:
            return dump_response(
                SimpleResultMessageResponse,
                {"result": "fail", "message": "No refresh token provided"},
            ), HTTPStatus.UNAUTHORIZED

        try:
            tokens = application_services().accounts.authentication.refresh(refresh_token)
        except account_errors.InvalidRefreshTokenError as error:
            return dump_response(
                SimpleResultMessageResponse,
                {"result": "fail", "message": str(error)},
            ), HTTPStatus.UNAUTHORIZED
        return _token_response(tokens, SimpleResultResponse, {"result": "success"})


def _token_response(tokens: AccountSessionTokens, response_model: type[BaseModel], data: object):
    # response-contract:ignore cookie-bearing Flask response
    response = make_response(dump_response(response_model, data))
    set_csrf_token_to_cookie(request, response, tokens.csrf_token)
    set_access_token_to_cookie(request, response, tokens.access_token)
    set_refresh_token_to_cookie(request, response, tokens.refresh_token)
    return response


def _raise_account_state_error(error: account_errors.AccountApplicationError) -> Never:
    """Translate the account-state errors every login flow checks first."""
    if isinstance(error, account_errors.AccountEmailDomainSuspendedError):
        raise EmailDomainSuspendedError() from error
    if isinstance(error, account_errors.AccountEmailFrozenError):
        raise AccountInFreezeError() from error
    if isinstance(error, account_errors.LoginAccountBannedError):
        raise AccountBannedError() from error
    raise error


def _raise_password_login_error(error: account_errors.AccountApplicationError) -> Never:
    if isinstance(error, account_errors.LoginRateLimitError):
        raise EmailPasswordLoginLimitError() from error
    if isinstance(error, account_errors.InvalidLoginCredentialsError):
        raise AuthenticationFailedError() from error
    if isinstance(error, account_errors.InvalidAccountPasswordError):
        raise InvalidAccountPasswordRequestError(description=str(error)) from error
    if isinstance(error, account_errors.InvalidLoginInvitationEmailError):
        raise InvalidEmailError() from error
    if isinstance(error, account_errors.LoginWorkspaceLimitError):
        raise WorkspacesLimitExceeded() from error
    if isinstance(error, account_errors.AccountNotFoundError):
        raise AccountNotFound() from error
    _raise_account_state_error(error)


def _raise_reset_password_email_error(error: account_errors.AccountApplicationError) -> Never:
    if isinstance(error, account_errors.ResetPasswordEmailRateLimitError):
        raise PasswordResetRateLimitExceededError(error.retry_after_minutes) from error
    _raise_account_state_error(error)


def _raise_email_code_send_error(error: account_errors.AccountApplicationError) -> Never:
    if isinstance(error, account_errors.EmailCodeSendIPLimitedError):
        raise EmailSendIpLimitError() from error
    if isinstance(error, account_errors.EmailCodeSendRateLimitError):
        raise EmailCodeLoginRateLimitExceededError(error.retry_after_minutes) from error
    if isinstance(error, account_errors.HumanVerificationRejectedError):
        raise TurnstileVerificationFailedError() from error
    if isinstance(error, account_errors.HumanVerificationUnavailableError):
        raise TurnstileServiceUnavailableError() from error
    if isinstance(error, account_errors.EmailCodeLoginUnavailableError):
        raise EmailCodeLoginServiceUnavailableError() from error
    _raise_account_state_error(error)


def _raise_email_code_login_error(error: account_errors.AccountApplicationError) -> Never:
    if isinstance(error, account_errors.InvalidEmailCodeTokenError):
        raise InvalidTokenError() from error
    if isinstance(error, account_errors.EmailCodeEmailMismatchError):
        raise InvalidEmailError() from error
    if isinstance(error, account_errors.InvalidEmailCodeError):
        raise EmailCodeError() from error
    if isinstance(error, account_errors.HumanVerificationRejectedError):
        raise TurnstileVerificationFailedError() from error
    if isinstance(error, account_errors.HumanVerificationUnavailableError):
        raise TurnstileServiceUnavailableError() from error
    if isinstance(error, account_errors.EmailCodeLoginUnavailableError):
        raise EmailCodeLoginServiceUnavailableError() from error
    if isinstance(error, account_errors.AccountNotFoundError):
        raise AccountNotFound() from error
    if isinstance(error, account_errors.LoginWorkspaceLimitError):
        raise WorkspacesLimitExceeded() from error
    if isinstance(error, account_errors.LoginWorkspaceCreationNotAllowedError):
        raise NotAllowedCreateWorkspace() from error
    if isinstance(error, account_errors.LoginSeatLimitError):
        raise SeatsLimitExceeded() from error
    if isinstance(error, account_errors.AccountNormalizedEmailAlreadyInUseError):
        raise NormalizedEmailAlreadyInUseError() from error
    _raise_account_state_error(error)