Files
gsfdc/demo-dify/dify/api/controllers/console/auth/login.py
T
wuzilongandCursor 6519682885 chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动
演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-18 13:59:25 +08:00

376 lines
15 KiB
Python

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)