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.

18.0 KB
Raw Blame
from collections.abc import Generator
from contextlib import contextmanager
from datetime import datetime
from uuid import UUID

from flask_restx import Resource
from pydantic import BaseModel, Field, computed_field, field_validator

from controllers.common.errors import ForbiddenError, InvalidArgumentError, NotFoundError
from controllers.common.schema import register_response_schema_models, register_schema_models
from controllers.console import console_ns
from controllers.console.app.error import AppNotFoundError
from controllers.console.flask_admission import console_account_admission
from controllers.console.wraps import model_validate
from enums.account import TenantAccountRole
from extensions.ext_application_services import application_services
from fields.base import ResponseModel
from fields.member_fields import AccountWithRole
from libs.external_api import error_responses
from libs.helper import build_avatar_url, dump_response, to_timestamp
from machinery.context import RequestContext
from services.app.workflow_comment_service import (
    InvalidMentionedUserIdError,
    InvalidWorkflowCommentContentError,
    WorkflowCommentAppNotFoundError,
    WorkflowCommentDraft,
    WorkflowCommentEdit,
    WorkflowCommentNotFoundError,
    WorkflowCommentPermissionError,
    WorkflowCommentReplyDraft,
    WorkflowCommentReplyNotFoundError,
)

# Same roles as the legacy `edit_permission_required` gate; like it, admission skips the role check under RBAC.
_EDIT_ROLES = frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR})


class WorkflowCommentCreatePayload(BaseModel):
    content: str = Field(..., description="Comment content")
    position_x: float = Field(..., description="Comment X position")
    position_y: float = Field(..., description="Comment Y position")
    mentioned_user_ids: list[str] = Field(default_factory=list, description="Mentioned user IDs")


class WorkflowCommentUpdatePayload(BaseModel):
    content: str = Field(..., description="Comment content")
    position_x: float | None = Field(default=None, description="Comment X position")
    position_y: float | None = Field(default=None, description="Comment Y position")
    mentioned_user_ids: list[str] | None = Field(
        default=None,
        description="Mentioned user IDs. Omit to keep existing mentions.",
    )


class WorkflowCommentReplyPayload(BaseModel):
    content: str = Field(..., description="Reply content")
    mentioned_user_ids: list[str] = Field(default_factory=list, description="Mentioned user IDs")


class WorkflowCommentMentionUsersPayload(BaseModel):
    users: list[AccountWithRole]


class WorkflowCommentAccount(ResponseModel):
    id: str
    name: str
    email: str
    avatar: str | None = Field(default=None, exclude=True)

    @computed_field(return_type=str | None)  # type: ignore[prop-decorator]
    @property
    def avatar_url(self) -> str | None:
        return build_avatar_url(self.avatar)


class WorkflowCommentReply(ResponseModel):
    id: str
    content: str
    created_by: str
    created_by_account: WorkflowCommentAccount | None = None
    created_at: int | None = None

    @field_validator("created_at", mode="before")
    @classmethod
    def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
        return to_timestamp(value)


class WorkflowCommentMention(ResponseModel):
    mentioned_user_id: str
    mentioned_user_account: WorkflowCommentAccount | None = None
    reply_id: str | None = None


class WorkflowCommentBasic(ResponseModel):
    id: str
    position_x: float
    position_y: float
    content: str
    created_by: str
    created_by_account: WorkflowCommentAccount | None = None
    created_at: int | None = None
    updated_at: int | None = None
    resolved: bool
    resolved_at: int | None = None
    resolved_by: str | None = None
    resolved_by_account: WorkflowCommentAccount | None = None
    reply_count: int
    mention_count: int
    participants: list[WorkflowCommentAccount]

    @field_validator("created_at", "updated_at", "resolved_at", mode="before")
    @classmethod
    def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
        return to_timestamp(value)


class WorkflowCommentBasicList(ResponseModel):
    data: list[WorkflowCommentBasic]


class WorkflowCommentDetail(ResponseModel):
    id: str
    position_x: float
    position_y: float
    content: str
    created_by: str
    created_by_account: WorkflowCommentAccount | None = None
    created_at: int | None = None
    updated_at: int | None = None
    resolved: bool
    resolved_at: int | None = None
    resolved_by: str | None = None
    resolved_by_account: WorkflowCommentAccount | None = None
    replies: list[WorkflowCommentReply]
    mentions: list[WorkflowCommentMention]

    @field_validator("created_at", "updated_at", "resolved_at", mode="before")
    @classmethod
    def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
        return to_timestamp(value)


class WorkflowCommentCreate(ResponseModel):
    id: str
    created_at: int | None = None

    @field_validator("created_at", mode="before")
    @classmethod
    def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
        return to_timestamp(value)


class WorkflowCommentUpdate(ResponseModel):
    id: str
    updated_at: int | None = None

    @field_validator("updated_at", mode="before")
    @classmethod
    def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
        return to_timestamp(value)


class WorkflowCommentResolve(ResponseModel):
    id: str
    resolved: bool
    resolved_at: int | None = None
    resolved_by: str | None = None

    @field_validator("resolved_at", mode="before")
    @classmethod
    def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
        return to_timestamp(value)


class WorkflowCommentReplyCreate(ResponseModel):
    id: str
    created_at: int | None = None

    @field_validator("created_at", mode="before")
    @classmethod
    def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
        return to_timestamp(value)


class WorkflowCommentReplyUpdate(ResponseModel):
    id: str
    updated_at: int | None = None

    @field_validator("updated_at", mode="before")
    @classmethod
    def _normalize_timestamp(cls, value: datetime | int | None) -> int | None:
        return to_timestamp(value)


register_schema_models(
    console_ns,
    WorkflowCommentCreatePayload,
    WorkflowCommentUpdatePayload,
    WorkflowCommentReplyPayload,
)
register_response_schema_models(
    console_ns,
    AccountWithRole,
    WorkflowCommentMentionUsersPayload,
    WorkflowCommentAccount,
    WorkflowCommentReply,
    WorkflowCommentMention,
    WorkflowCommentBasic,
    WorkflowCommentBasicList,
    WorkflowCommentDetail,
    WorkflowCommentCreate,
    WorkflowCommentUpdate,
    WorkflowCommentResolve,
    WorkflowCommentReplyCreate,
    WorkflowCommentReplyUpdate,
)


@contextmanager
def _translate_errors() -> Generator[None]:
    """Map framework-neutral comment failures back to the existing transport errors."""
    try:
        yield
    except WorkflowCommentAppNotFoundError as error:
        raise AppNotFoundError() from error
    except (WorkflowCommentNotFoundError, WorkflowCommentReplyNotFoundError) as error:
        raise NotFoundError(str(error)) from error
    except WorkflowCommentPermissionError as error:
        raise ForbiddenError(str(error)) from error
    except (InvalidWorkflowCommentContentError, InvalidMentionedUserIdError) as error:
        raise InvalidArgumentError(str(error)) from error


@console_ns.route("/apps/<uuid:app_id>/workflow/comments")
class WorkflowCommentListApi(Resource):
    """API for listing and creating workflow comments."""

    @error_responses(AppNotFoundError, ForbiddenError)
    @console_ns.doc("list_workflow_comments")
    @console_ns.doc(description="Get all comments for a workflow")
    @console_ns.doc(params={"app_id": "Application ID"})
    @console_ns.response(200, "Comments retrieved successfully", console_ns.models[WorkflowCommentBasicList.__name__])
    @console_account_admission()
    def get(self, request_context: RequestContext, app_id: UUID):
        """Get all comments for a workflow."""
        with _translate_errors():
            comments = application_services().workflow_comments.list_comments(request_context, str(app_id))
        return dump_response(WorkflowCommentBasicList, {"data": comments})

    @error_responses(AppNotFoundError, ForbiddenError)
    @console_ns.doc("create_workflow_comment")
    @console_ns.doc(description="Create a new workflow comment")
    @console_ns.doc(params={"app_id": "Application ID"})
    @console_ns.expect(console_ns.models[WorkflowCommentCreatePayload.__name__])
    @console_ns.response(201, "Comment created successfully", console_ns.models[WorkflowCommentCreate.__name__])
    @console_account_admission(allowed_roles=_EDIT_ROLES)
    @model_validate(WorkflowCommentCreatePayload)
    def post(self, req_data: WorkflowCommentCreatePayload, request_context: RequestContext, app_id: UUID):
        """Create a new workflow comment."""
        with _translate_errors():
            result = application_services().workflow_comments.create_comment(
                request_context,
                str(app_id),
                WorkflowCommentDraft(
                    content=req_data.content,
                    position_x=req_data.position_x,
                    position_y=req_data.position_y,
                    mentioned_user_ids=tuple(req_data.mentioned_user_ids),
                ),
            )
        return dump_response(WorkflowCommentCreate, result), 201


@console_ns.route("/apps/<uuid:app_id>/workflow/comments/<string:comment_id>")
class WorkflowCommentDetailApi(Resource):
    """API for managing individual workflow comments."""

    @error_responses(AppNotFoundError, ForbiddenError)
    @console_ns.doc("get_workflow_comment")
    @console_ns.doc(description="Get a specific workflow comment")
    @console_ns.doc(params={"app_id": "Application ID", "comment_id": "Comment ID"})
    @console_ns.response(200, "Comment retrieved successfully", console_ns.models[WorkflowCommentDetail.__name__])
    @console_account_admission()
    def get(self, request_context: RequestContext, app_id: UUID, comment_id: str):
        """Get a specific workflow comment."""
        with _translate_errors():
            comment = application_services().workflow_comments.get_comment(request_context, str(app_id), comment_id)
        return dump_response(WorkflowCommentDetail, comment)

    @error_responses(AppNotFoundError, ForbiddenError)
    @console_ns.doc("update_workflow_comment")
    @console_ns.doc(description="Update a workflow comment")
    @console_ns.doc(params={"app_id": "Application ID", "comment_id": "Comment ID"})
    @console_ns.expect(console_ns.models[WorkflowCommentUpdatePayload.__name__])
    @console_ns.response(200, "Comment updated successfully", console_ns.models[WorkflowCommentUpdate.__name__])
    @console_account_admission(allowed_roles=_EDIT_ROLES)
    @model_validate(WorkflowCommentUpdatePayload)
    def put(
        self,
        req_data: WorkflowCommentUpdatePayload,
        request_context: RequestContext,
        app_id: UUID,
        comment_id: str,
    ):
        """Update a workflow comment."""
        mentioned_user_ids = req_data.mentioned_user_ids
        with _translate_errors():
            result = application_services().workflow_comments.update_comment(
                request_context,
                str(app_id),
                comment_id,
                WorkflowCommentEdit(
                    content=req_data.content,
                    position_x=req_data.position_x,
                    position_y=req_data.position_y,
                    mentioned_user_ids=tuple(mentioned_user_ids) if mentioned_user_ids is not None else None,
                ),
            )
        return dump_response(WorkflowCommentUpdate, result)

    @error_responses(AppNotFoundError, ForbiddenError)
    @console_ns.doc("delete_workflow_comment")
    @console_ns.doc(description="Delete a workflow comment")
    @console_ns.doc(params={"app_id": "Application ID", "comment_id": "Comment ID"})
    @console_ns.response(204, "Comment deleted successfully")
    @console_account_admission(allowed_roles=_EDIT_ROLES)
    def delete(self, request_context: RequestContext, app_id: UUID, comment_id: str):
        """Delete a workflow comment."""
        with _translate_errors():
            application_services().workflow_comments.delete_comment(request_context, str(app_id), comment_id)
        return "", 204


@console_ns.route("/apps/<uuid:app_id>/workflow/comments/<string:comment_id>/resolve")
class WorkflowCommentResolveApi(Resource):
    """API for resolving and reopening workflow comments."""

    @error_responses(AppNotFoundError, ForbiddenError)
    @console_ns.doc("resolve_workflow_comment")
    @console_ns.doc(description="Resolve a workflow comment")
    @console_ns.doc(params={"app_id": "Application ID", "comment_id": "Comment ID"})
    @console_ns.response(200, "Comment resolved successfully", console_ns.models[WorkflowCommentResolve.__name__])
    @console_account_admission(allowed_roles=_EDIT_ROLES)
    def post(self, request_context: RequestContext, app_id: UUID, comment_id: str):
        """Resolve a workflow comment."""
        with _translate_errors():
            result = application_services().workflow_comments.resolve_comment(request_context, str(app_id), comment_id)
        return dump_response(WorkflowCommentResolve, result)


@console_ns.route("/apps/<uuid:app_id>/workflow/comments/<string:comment_id>/replies")
class WorkflowCommentReplyApi(Resource):
    """API for managing comment replies."""

    @error_responses(AppNotFoundError, ForbiddenError)
    @console_ns.doc("create_workflow_comment_reply")
    @console_ns.doc(description="Add a reply to a workflow comment")
    @console_ns.doc(params={"app_id": "Application ID", "comment_id": "Comment ID"})
    @console_ns.expect(console_ns.models[WorkflowCommentReplyPayload.__name__])
    @console_ns.response(201, "Reply created successfully", console_ns.models[WorkflowCommentReplyCreate.__name__])
    @console_account_admission(allowed_roles=_EDIT_ROLES)
    @model_validate(WorkflowCommentReplyPayload)
    def post(
        self,
        req_data: WorkflowCommentReplyPayload,
        request_context: RequestContext,
        app_id: UUID,
        comment_id: str,
    ):
        """Add a reply to a workflow comment."""
        with _translate_errors():
            result = application_services().workflow_comments.create_reply(
                request_context,
                str(app_id),
                comment_id,
                WorkflowCommentReplyDraft(
                    content=req_data.content,
                    mentioned_user_ids=tuple(req_data.mentioned_user_ids),
                ),
            )
        return dump_response(WorkflowCommentReplyCreate, result), 201


@console_ns.route("/apps/<uuid:app_id>/workflow/comments/<string:comment_id>/replies/<string:reply_id>")
class WorkflowCommentReplyDetailApi(Resource):
    """API for managing individual comment replies."""

    @error_responses(AppNotFoundError, ForbiddenError)
    @console_ns.doc("update_workflow_comment_reply")
    @console_ns.doc(description="Update a comment reply")
    @console_ns.doc(params={"app_id": "Application ID", "comment_id": "Comment ID", "reply_id": "Reply ID"})
    @console_ns.expect(console_ns.models[WorkflowCommentReplyPayload.__name__])
    @console_ns.response(200, "Reply updated successfully", console_ns.models[WorkflowCommentReplyUpdate.__name__])
    @console_account_admission(allowed_roles=_EDIT_ROLES)
    @model_validate(WorkflowCommentReplyPayload)
    def put(
        self,
        req_data: WorkflowCommentReplyPayload,
        request_context: RequestContext,
        app_id: UUID,
        comment_id: str,
        reply_id: str,
    ):
        """Update a comment reply."""
        with _translate_errors():
            result = application_services().workflow_comments.update_reply(
                request_context,
                str(app_id),
                comment_id,
                reply_id,
                WorkflowCommentReplyDraft(
                    content=req_data.content,
                    mentioned_user_ids=tuple(req_data.mentioned_user_ids),
                ),
            )
        return dump_response(WorkflowCommentReplyUpdate, result)

    @error_responses(AppNotFoundError, ForbiddenError)
    @console_ns.doc("delete_workflow_comment_reply")
    @console_ns.doc(description="Delete a comment reply")
    @console_ns.doc(params={"app_id": "Application ID", "comment_id": "Comment ID", "reply_id": "Reply ID"})
    @console_ns.response(204, "Reply deleted successfully")
    @console_account_admission(allowed_roles=_EDIT_ROLES)
    def delete(self, request_context: RequestContext, app_id: UUID, comment_id: str, reply_id: str):
        """Delete a comment reply."""
        with _translate_errors():
            application_services().workflow_comments.delete_reply(request_context, str(app_id), comment_id, reply_id)
        return "", 204


@console_ns.route("/apps/<uuid:app_id>/workflow/comments/mention-users")
class WorkflowCommentMentionUsersApi(Resource):
    """API for getting mentionable users for workflow comments."""

    @error_responses(AppNotFoundError, ForbiddenError)
    @console_ns.doc("workflow_comment_mention_users")
    @console_ns.doc(description="Get all users in current tenant for mentions")
    @console_ns.doc(params={"app_id": "Application ID"})
    @console_ns.response(
        200, "Mentionable users retrieved successfully", console_ns.models[WorkflowCommentMentionUsersPayload.__name__]
    )
    @console_account_admission()
    def get(self, request_context: RequestContext, app_id: UUID):
        """Get all users in current tenant for mentions."""
        services = application_services()
        with _translate_errors():
            services.workflow_comments.ensure_app(request_context, str(app_id))
        members = services.workspaces.member_queries.list_members(request_context.active_workspace_id)
        return dump_response(WorkflowCommentMentionUsersPayload, {"users": members}), 200