from __future__ import annotations from datetime import datetime from http import HTTPStatus from typing import Annotated, Literal from flask import request from flask_restx import Resource from pydantic import BaseModel, ConfigDict, Field, RootModel, field_validator, model_validator from pydantic.json_schema import SkipJsonSchema from werkzeug.exceptions import NotFound from constants.languages import supported_language from controllers.common.fields import ( AvatarUrlResponse, SimpleResultDataResponse, SimpleResultResponse, VerificationTokenResponse, ) from controllers.common.schema import query_params_from_model, register_response_schema_models, register_schema_models from controllers.console import console_ns from controllers.console.auth.error import ( EmailAlreadyInUseError, EmailChangeLimitError, EmailChangeRateLimitExceededError, EmailCodeAccountDeletionRateLimitExceededError, EmailCodeError, InvalidEmailError, InvalidTokenError, ) from controllers.console.billing.error import ( BillingOperationFailedError, BillingRequestInProgressError, BillingUnavailableError, to_billing_request_error, ) from controllers.console.error import ( AccountInFreezeError, AccountNotFound, EducationActivateFailedError, EducationActivateLimitError, EducationVerifyFailedError, EducationVerifyLimitError, EmailDomainSuspendedError, EmailSendIpLimitError, InvalidAccountPasswordRequestError, ) from controllers.console.flask_admission import console_account_admission from controllers.console.workspace.error import ( AccountAlreadyInitedError, CurrentPasswordIncorrectError, InvalidAccountDeletionCodeError, InvalidInvitationCodeError, MissingInvitationCodeRequestError, RepeatPasswordNotMatchError, ) from controllers.console.wraps import model_validate, setup_required from extensions.ext_application_services import application_services from fields.base import ResponseModel from fields.member_fields import AccountResponse from libs.exception import BaseHTTPException from libs.external_api import error_responses from libs.helper import EmailStr, dump_response, extract_remote_ip, timezone, to_timestamp from machinery.context import RequestContext from services import account_errors from services.account_education_service import EDUCATION_EDITIONS from services.entities.account_entities import AccountProfileChanges from services.errors.billing import BillingUpstreamError class AccountInitPayload(BaseModel): interface_language: str timezone: str invitation_code: str | None = None @field_validator("interface_language") @classmethod def validate_language(cls, value: str) -> str: return supported_language(value) @field_validator("timezone") @classmethod def validate_timezone(cls, value: str) -> str: return timezone(value) class AccountAvatarQuery(BaseModel): avatar: str = Field(..., description="Avatar file ID") class AccountProfilePatchPayload(BaseModel): model_config = ConfigDict(extra="forbid") name: Annotated[str, Field(min_length=3, max_length=30)] | SkipJsonSchema[None] = None avatar: str | SkipJsonSchema[None] = None interface_language: str | SkipJsonSchema[None] = None interface_theme: Literal["light", "dark"] | SkipJsonSchema[None] = None timezone: str | SkipJsonSchema[None] = None @field_validator("*", mode="before") @classmethod def reject_null(cls, value: object) -> object: if value is None: raise ValueError("Account profile fields cannot be null") return value @field_validator("interface_language") @classmethod def validate_language(cls, value: str) -> str: return supported_language(value) @field_validator("timezone") @classmethod def validate_timezone(cls, value: str) -> str: return timezone(value) def to_changes(self) -> AccountProfileChanges: return AccountProfileChanges( name=self.name, avatar=self.avatar, interface_language=self.interface_language, interface_theme=self.interface_theme, timezone=self.timezone, ) class AccountPasswordPayload(BaseModel): password: str | None = None new_password: str repeat_new_password: str @model_validator(mode="after") def check_passwords_match(self) -> AccountPasswordPayload: if self.new_password != self.repeat_new_password: raise RepeatPasswordNotMatchError() return self class AccountDeletePayload(BaseModel): token: str code: str class AccountDeletionFeedbackPayload(BaseModel): email: EmailStr feedback: str class EducationActivatePayload(BaseModel): token: str institution: str role: str class EducationAutocompleteQuery(BaseModel): keywords: str page: int = 0 limit: int = 20 class ChangeEmailSendPayload(BaseModel): email: EmailStr language: str | None = None phase: str | None = None token: str | None = None class ChangeEmailValidityPayload(BaseModel): email: EmailStr code: str token: str class ChangeEmailResetPayload(BaseModel): new_email: EmailStr token: str class CheckEmailUniquePayload(BaseModel): email: EmailStr register_schema_models( console_ns, AccountInitPayload, AccountAvatarQuery, AccountProfilePatchPayload, AccountPasswordPayload, AccountDeletePayload, AccountDeletionFeedbackPayload, EducationActivatePayload, EducationAutocompleteQuery, ChangeEmailSendPayload, ChangeEmailValidityPayload, ChangeEmailResetPayload, CheckEmailUniquePayload, ) class AccountIntegrateResponse(ResponseModel): provider: str created_at: int | None = None is_bound: bool link: str | None = None @field_validator("created_at", mode="before") @classmethod def _normalize_created_at(cls, value: datetime | int | None) -> int | None: return to_timestamp(value) class AccountIntegrateListResponse(ResponseModel): data: list[AccountIntegrateResponse] class EducationVerifyEligibleResponse(ResponseModel): status: Literal["eligible"] token: str class EducationVerifyNotEligibleResponse(ResponseModel): status: Literal["not_eligible"] class EducationVerifyResponse( RootModel[ Annotated[ EducationVerifyEligibleResponse | EducationVerifyNotEligibleResponse, Field(discriminator="status"), ] ] ): """Education verification result: a token for an eligible account, none for an ineligible one.""" class EducationActivateResponse(ResponseModel): message: str class EducationStatusResponse(ResponseModel): result: bool is_student: bool expire_at: int | None allow_refresh: bool @field_validator("expire_at", mode="before") @classmethod def _normalize_expire_at(cls, value: datetime | int | None) -> int | None: return to_timestamp(value) class EducationAutocompleteResponse(ResponseModel): data: list[str] curr_page: int has_next: bool register_response_schema_models( console_ns, AccountResponse, AccountIntegrateResponse, AccountIntegrateListResponse, AvatarUrlResponse, EducationActivateResponse, EducationVerifyResponse, EducationStatusResponse, EducationAutocompleteResponse, SimpleResultDataResponse, SimpleResultResponse, VerificationTokenResponse, ) @console_ns.route("/account/init") class AccountInitApi(Resource): @error_responses( AccountAlreadyInitedError, AccountNotFound, InvalidInvitationCodeError, MissingInvitationCodeRequestError ) @console_ns.expect(console_ns.models[AccountInitPayload.__name__]) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[SimpleResultResponse.__name__]) @console_account_admission(require_initialized=False) @model_validate(AccountInitPayload) def post(self, args: AccountInitPayload, request_context: RequestContext): try: application_services().accounts.initialization.initialize( request_context, interface_language=args.interface_language, timezone=args.timezone, invitation_code=args.invitation_code, ) except account_errors.AccountAlreadyInitializedError as error: raise AccountAlreadyInitedError() from error except account_errors.MissingInvitationCodeError as error: raise MissingInvitationCodeRequestError() from error except account_errors.InvalidInvitationCodeError as error: raise InvalidInvitationCodeError() from error except account_errors.AccountNotFoundError as error: raise AccountNotFound() from error return SimpleResultResponse(result="success").model_dump(mode="json") @console_ns.route("/account/profile") class AccountProfileApi(Resource): @error_responses(AccountNotFound) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[AccountResponse.__name__]) @console_account_admission(require_valid_enterprise_license=True) def get(self, request_context: RequestContext): try: account = application_services().accounts.profile.get(request_context) except account_errors.AccountNotFoundError as error: raise AccountNotFound() from error return dump_response(AccountResponse, account) @error_responses(AccountNotFound) @console_ns.expect(console_ns.models[AccountProfilePatchPayload.__name__]) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[AccountResponse.__name__]) @console_account_admission() @model_validate(AccountProfilePatchPayload) def patch(self, args: AccountProfilePatchPayload, request_context: RequestContext): try: account = application_services().accounts.profile.update(request_context, args.to_changes()) except account_errors.AccountNotFoundError as error: raise AccountNotFound() from error return dump_response(AccountResponse, account) @console_ns.route("/account/avatar") class AccountAvatarApi(Resource): @console_ns.doc("get_account_avatar") @console_ns.doc(description="Get account avatar url") @console_ns.doc(params=query_params_from_model(AccountAvatarQuery)) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[AvatarUrlResponse.__name__]) @console_account_admission() @model_validate(AccountAvatarQuery) def get(self, args: AccountAvatarQuery, request_context: RequestContext): try: avatar_url = application_services().accounts.avatar.resolve(request_context, args.avatar) except account_errors.AvatarFileNotFoundError as error: raise NotFound("Avatar file not found") from error return AvatarUrlResponse(avatar_url=avatar_url).model_dump(mode="json") @console_ns.route("/account/password") class AccountPasswordApi(Resource): @error_responses(AccountNotFound, CurrentPasswordIncorrectError, InvalidAccountPasswordRequestError) @console_ns.expect(console_ns.models[AccountPasswordPayload.__name__]) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[AccountResponse.__name__]) @console_account_admission() @model_validate(AccountPasswordPayload) def post(self, args: AccountPasswordPayload, request_context: RequestContext): try: assert args.password is not None account = application_services().accounts.password.change( request_context, current_password=args.password, new_password=args.new_password, ) except account_errors.CurrentAccountPasswordIncorrectError as error: raise CurrentPasswordIncorrectError() from error except account_errors.InvalidAccountPasswordError as error: raise InvalidAccountPasswordRequestError(description=str(error)) from error except account_errors.AccountNotFoundError as error: raise AccountNotFound() from error return dump_response(AccountResponse, account) @console_ns.route("/account/integrates") class AccountIntegrateApi(Resource): @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[AccountIntegrateListResponse.__name__]) @console_account_admission() def get(self, request_context: RequestContext): base_url = request.url_root.rstrip("/") oauth_base_path = "/console/api/oauth/login" integrations = application_services().accounts.integrations.list(request_context) integrate_data = [ AccountIntegrateResponse( provider=integration.provider, created_at=to_timestamp(integration.created_at), is_bound=integration.is_bound, link=(None if integration.is_bound else f"{base_url}{oauth_base_path}/{integration.provider}"), ) for integration in integrations ] return AccountIntegrateListResponse(data=integrate_data).model_dump(mode="json") @console_ns.route("/account/delete/verify") class AccountDeleteVerifyApi(Resource): @error_responses(AccountNotFound, EmailCodeAccountDeletionRateLimitExceededError) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[SimpleResultDataResponse.__name__]) @console_account_admission() def get(self, request_context: RequestContext): try: token = application_services().accounts.deletion.issue_verification(request_context) except account_errors.AccountDeletionRateLimitError as error: raise EmailCodeAccountDeletionRateLimitExceededError(error.retry_after_minutes) from None except account_errors.AccountNotFoundError: raise AccountNotFound() from None return SimpleResultDataResponse(result="success", data=token).model_dump(mode="json") @console_ns.route("/account/delete") class AccountDeleteApi(Resource): @error_responses(InvalidAccountDeletionCodeError) @console_ns.expect(console_ns.models[AccountDeletePayload.__name__]) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[SimpleResultResponse.__name__]) @console_account_admission() @model_validate(AccountDeletePayload) def post(self, args: AccountDeletePayload, request_context: RequestContext): try: application_services().accounts.deletion.request_deletion( request_context, token=args.token, code=args.code, ) except account_errors.InvalidAccountDeletionVerificationError: raise InvalidAccountDeletionCodeError() from None return SimpleResultResponse(result="success").model_dump(mode="json") @console_ns.route("/account/delete/feedback") class AccountDeleteUpdateFeedbackApi(Resource): @console_ns.expect(console_ns.models[AccountDeletionFeedbackPayload.__name__]) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[SimpleResultResponse.__name__]) @setup_required @model_validate(AccountDeletionFeedbackPayload) def post(self, args: AccountDeletionFeedbackPayload): application_services().accounts.deletion_feedback.submit(email=args.email, feedback=args.feedback) return SimpleResultResponse(result="success").model_dump(mode="json") _EDUCATION_BILLING_ERRORS = ( account_errors.EducationVerificationFailedError, account_errors.EducationActivationFailedError, account_errors.EducationRequestInProgressError, BillingUpstreamError, ) def _education_billing_error( error: account_errors.EducationVerificationFailedError | account_errors.EducationActivationFailedError | account_errors.EducationRequestInProgressError | BillingUpstreamError, ) -> BaseHTTPException: if isinstance(error, account_errors.EducationVerificationFailedError): return EducationVerifyFailedError() if isinstance(error, account_errors.EducationActivationFailedError): return EducationActivateFailedError() if isinstance(error, account_errors.EducationRequestInProgressError): return BillingRequestInProgressError() return to_billing_request_error(error) @console_ns.route("/account/education/verify") class EducationVerifyApi(Resource): @error_responses( AccountNotFound, BillingOperationFailedError, BillingRequestInProgressError, BillingUnavailableError, EducationVerifyFailedError, EducationVerifyLimitError, ) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[EducationVerifyResponse.__name__]) @console_account_admission(editions=EDUCATION_EDITIONS) def get(self, request_context: RequestContext): try: verification = application_services().accounts.education.verify(request_context) except account_errors.AccountNotFoundError as error: raise AccountNotFound() from error except account_errors.EducationRateLimitExceededError as error: raise EducationVerifyLimitError() from error except _EDUCATION_BILLING_ERRORS as error: raise _education_billing_error(error) from error return dump_response(EducationVerifyResponse, verification) @console_ns.route("/account/education") class EducationApi(Resource): @error_responses( AccountNotFound, BillingOperationFailedError, BillingRequestInProgressError, BillingUnavailableError, EducationActivateFailedError, EducationActivateLimitError, ) @console_ns.expect(console_ns.models[EducationActivatePayload.__name__]) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[EducationActivateResponse.__name__]) @console_account_admission(editions=EDUCATION_EDITIONS) @model_validate(EducationActivatePayload) def post(self, args: EducationActivatePayload, request_context: RequestContext): try: activation = application_services().accounts.education.activate( request_context, token=args.token, institution=args.institution, role=args.role, ) except account_errors.AccountNotFoundError as error: raise AccountNotFound() from error except account_errors.EducationRateLimitExceededError as error: raise EducationActivateLimitError() from error except _EDUCATION_BILLING_ERRORS as error: raise _education_billing_error(error) from error return dump_response(EducationActivateResponse, activation) @error_responses(BillingOperationFailedError, BillingRequestInProgressError, BillingUnavailableError) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[EducationStatusResponse.__name__]) @console_account_admission(editions=EDUCATION_EDITIONS) def get(self, request_context: RequestContext): try: status = application_services().accounts.education.status(request_context) except _EDUCATION_BILLING_ERRORS as error: raise _education_billing_error(error) from error return dump_response(EducationStatusResponse, status) @console_ns.route("/account/education/autocomplete") class EducationAutoCompleteApi(Resource): @error_responses(BillingOperationFailedError, BillingUnavailableError) @console_ns.doc(params=query_params_from_model(EducationAutocompleteQuery)) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[EducationAutocompleteResponse.__name__]) @console_account_admission(editions=EDUCATION_EDITIONS) @model_validate(EducationAutocompleteQuery) def get(self, args: EducationAutocompleteQuery, request_context: RequestContext): try: institutions = application_services().accounts.education.autocomplete( request_context, keywords=args.keywords, page=args.page, limit=args.limit, ) except _EDUCATION_BILLING_ERRORS as error: raise _education_billing_error(error) from error return dump_response(EducationAutocompleteResponse, institutions) @console_ns.route("/account/change-email") class ChangeEmailSendEmailApi(Resource): @error_responses( AccountNotFound, EmailChangeRateLimitExceededError, EmailSendIpLimitError, InvalidEmailError, InvalidTokenError ) @console_ns.expect(console_ns.models[ChangeEmailSendPayload.__name__]) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[SimpleResultDataResponse.__name__]) @console_account_admission(require_change_email_enabled=True) @model_validate(ChangeEmailSendPayload) def post(self, args: ChangeEmailSendPayload, request_context: RequestContext): ip_address = extract_remote_ip(request) language = "zh-Hans" if args.language == "zh-Hans" else "en-US" try: token = application_services().accounts.change_email.send_code( request_context, requested_email=args.email, language=language, phase=args.phase, predecessor_token=args.token, ip_address=ip_address, ) except account_errors.ChangeEmailSendIPLimitedError: raise EmailSendIpLimitError() from None except account_errors.ChangeEmailSendRateLimitError as error: raise EmailChangeRateLimitExceededError(error.retry_after_minutes) from None except account_errors.InvalidChangeEmailTokenError: raise InvalidTokenError() from None except account_errors.InvalidChangeEmailAddressError: raise InvalidEmailError() from None except account_errors.AccountNotFoundError: raise AccountNotFound() from None return SimpleResultDataResponse(result="success", data=token).model_dump(mode="json") @console_ns.route("/account/change-email/validity") class ChangeEmailCheckApi(Resource): @error_responses(EmailChangeLimitError, EmailCodeError, InvalidEmailError, InvalidTokenError) @console_ns.expect(console_ns.models[ChangeEmailValidityPayload.__name__]) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[VerificationTokenResponse.__name__]) @console_account_admission(require_change_email_enabled=True) @model_validate(ChangeEmailValidityPayload) def post(self, args: ChangeEmailValidityPayload, request_context: RequestContext): try: verification = application_services().accounts.change_email.verify_code( request_context, email=args.email, code=args.code, token=args.token, ) except account_errors.ChangeEmailVerificationLimitError: raise EmailChangeLimitError() from None except account_errors.InvalidChangeEmailTokenError: raise InvalidTokenError() from None except account_errors.InvalidChangeEmailAddressError: raise InvalidEmailError() from None except account_errors.InvalidChangeEmailCodeError: raise EmailCodeError() from None return VerificationTokenResponse(is_valid=True, email=verification.email, token=verification.token).model_dump( mode="json" ) @console_ns.route("/account/change-email/reset") class ChangeEmailResetApi(Resource): @error_responses( AccountInFreezeError, AccountNotFound, EmailAlreadyInUseError, EmailDomainSuspendedError, InvalidTokenError ) @console_ns.expect(console_ns.models[ChangeEmailResetPayload.__name__]) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[AccountResponse.__name__]) @console_account_admission(require_change_email_enabled=True) @model_validate(ChangeEmailResetPayload) def post(self, args: ChangeEmailResetPayload, request_context: RequestContext): try: updated_account = application_services().accounts.change_email.reset( request_context, new_email=args.new_email, token=args.token, ) except account_errors.AccountEmailDomainSuspendedError: raise EmailDomainSuspendedError() from None except account_errors.AccountEmailFrozenError: raise AccountInFreezeError() from None except account_errors.AccountEmailAlreadyInUseError: raise EmailAlreadyInUseError() from None except account_errors.InvalidChangeEmailTokenError: raise InvalidTokenError() from None except account_errors.AccountNotFoundError: raise AccountNotFound() from None return dump_response(AccountResponse, updated_account) @console_ns.route("/account/change-email/check-email-unique") class CheckEmailUnique(Resource): @error_responses(AccountInFreezeError, EmailAlreadyInUseError, EmailDomainSuspendedError) @console_ns.expect(console_ns.models[CheckEmailUniquePayload.__name__]) @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[SimpleResultResponse.__name__]) @console_account_admission() @model_validate(CheckEmailUniquePayload) def post(self, args: CheckEmailUniquePayload, request_context: RequestContext): try: application_services().accounts.change_email.ensure_available(args.email) except account_errors.AccountEmailDomainSuspendedError: raise EmailDomainSuspendedError() from None except account_errors.AccountEmailFrozenError: raise AccountInFreezeError() from None except account_errors.AccountEmailAlreadyInUseError: raise EmailAlreadyInUseError() from None return SimpleResultResponse(result="success").model_dump(mode="json")