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)