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.

25.4 KB
Raw Blame
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")