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.

12.2 KB
Raw Blame
"""Inner API endpoints for the enterprise admin app list and app detail.

Called by the enterprise admin-api service. The list covers Studio-visible apps
across all workspaces with their publish state and invocation count; enterprise
joins its own data onto it by app id. The detail adds what only CE owns: the
app's published version, access points, and invocations.
"""

from http import HTTPStatus
from typing import Literal
from uuid import UUID

from flask_restx import Resource
from pydantic import BaseModel, Field, ValidationError, field_validator
from werkzeug.exceptions import BadRequest

from controllers.common.fields import SimpleMessageResponse
from controllers.common.schema import (
    query_params_from_model,
    query_params_from_request,
    register_response_schema_models,
)
from controllers.console.wraps import setup_required
from controllers.inner_api import inner_api_ns
from controllers.inner_api.wraps import enterprise_inner_api_only
from extensions.ext_application_services import application_services
from fields.base import ResponseModel
from libs.helper import to_timestamp
from models.model import AppMode
from services.app.enterprise_app_service import (
    EnterpriseAppApi,
    EnterpriseAppCreator,
    EnterpriseAppListParams,
    EnterpriseAppMCPServer,
    EnterpriseAppPublishedVersion,
    EnterpriseAppSite,
    EnterpriseAppTrigger,
)

EnterpriseAppListMode = Literal["completion", "workflow", "chat", "advanced-chat", "agent-chat", "agent"]
APP_LIST_QUERY_ARRAY_FIELDS = ("workspace_ids", "modes")


class EnterpriseAppListQuery(BaseModel):
    page: int = Field(default=1, ge=1, le=99999, description="Page number (1-99999)")
    limit: int = Field(default=20, ge=1, le=100, description="Page size (1-100)")
    workspace_ids: list[UUID] = Field(default_factory=list, description="Filter by workspace IDs (repeatable)")
    modes: list[EnterpriseAppListMode] = Field(default_factory=list, description="Filter by app modes (repeatable)")
    name: str | None = Field(default=None, max_length=255, description="Filter by app name substring")
    sort_by: Literal["created_at", "name"] = Field(default="created_at", description="Sort field")
    sort_order: Literal["asc", "desc"] = Field(default="desc", description="Sort direction")

    @field_validator("name", mode="before")
    @classmethod
    def blank_name_as_none(cls, value: object) -> object:
        return value.strip() or None if isinstance(value, str) else value


class EnterpriseAppCreatorResponse(ResponseModel):
    id: str
    name: str
    email: str


class EnterpriseAppResponse(ResponseModel):
    id: str
    name: str
    description: str
    mode: str
    icon_type: str | None
    icon: str | None
    icon_background: str | None
    workspace_id: str
    workspace_name: str | None
    created_by: EnterpriseAppCreatorResponse | None
    created_at: int
    updated_at: int


_INVOCATION_COUNT_DESCRIPTION = (
    "Invocations in the last 24h: published workflow runs (app-run, webhook, schedule, plugin) for "
    "workflow and advanced-chat apps, non-debugger messages for other apps"
)


_TRIGGER_ENTRY_ACCESS_DESCRIPTION = (
    "Null when the published workflow has a trigger entry, since trigger-entry workflows cannot be run through "
    "Web App, Service API, or MCP"
)


class EnterpriseAppListItemResponse(EnterpriseAppResponse):
    published: bool = Field(description="Whether the app detail reports a published_version")
    invocation_count_24h: int = Field(description=_INVOCATION_COUNT_DESCRIPTION)


class EnterpriseAppPaginationResponse(ResponseModel):
    page: int
    limit: int
    total: int
    has_more: bool
    data: list[EnterpriseAppListItemResponse]


class EnterpriseAppPublishedVersionResponse(ResponseModel):
    id: str
    version: str | None = Field(description="Workflow version string; null for Agent config snapshots")
    version_number: int | None = Field(
        description="The #N shown in Studio version history; null for unnumbered legacy workflows"
    )
    marked_name: str | None = Field(description="Workflow version name; null for Agent config snapshots")
    marked_comment: str | None = Field(description="Workflow version comment or Agent snapshot version note")
    created_by: EnterpriseAppCreatorResponse | None
    published_at: int


class EnterpriseAppSiteResponse(ResponseModel):
    enabled: bool
    code: str | None
    app_base_url: str | None


class EnterpriseAppApiResponse(ResponseModel):
    enabled: bool
    base_url: str | None
    api_key_count: int


class EnterpriseAppMCPServerResponse(ResponseModel):
    status: str
    server_code: str


class EnterpriseAppTriggerResponse(ResponseModel):
    id: str
    node_id: str | None
    title: str
    trigger_type: str
    provider_name: str | None
    status: str
    webhook_url: str | None


class EnterpriseAppDetailResponse(EnterpriseAppResponse):
    published_version: EnterpriseAppPublishedVersionResponse | None = Field(
        description=(
            "Version the app serves, unaffected by later unpublished draft edits; null when never published, "
            "and always for chat, completion, and agent-chat apps"
        )
    )
    published_version_count: int = Field(
        description="Number of entries in the app's Studio version history; 0 for apps without versions"
    )
    site: EnterpriseAppSiteResponse | None = Field(description=_TRIGGER_ENTRY_ACCESS_DESCRIPTION)
    api: EnterpriseAppApiResponse | None = Field(description=_TRIGGER_ENTRY_ACCESS_DESCRIPTION)
    mcp_server: EnterpriseAppMCPServerResponse | None = Field(
        description=f"{_TRIGGER_ENTRY_ACCESS_DESCRIPTION}, or when no MCP server was ever created"
    )
    triggers: list[EnterpriseAppTriggerResponse]
    last_invoked_at: int | None = Field(
        description="Latest invocation counted like invocation_count_24h, without the 24h limit"
    )
    invocation_count_24h: int = Field(description=_INVOCATION_COUNT_DESCRIPTION)
    failed_invocation_count_24h: int = Field(
        description=(
            "Invocations counted in invocation_count_24h that ended failed or partial-succeeded (workflow runs) "
            "or in error (messages); running and stopped runs are not failures"
        ),
    )


register_response_schema_models(inner_api_ns, EnterpriseAppPaginationResponse, EnterpriseAppDetailResponse)


def _creator_response(creator: EnterpriseAppCreator | None) -> EnterpriseAppCreatorResponse | None:
    if creator is None:
        return None
    return EnterpriseAppCreatorResponse(id=creator.id, name=creator.name, email=creator.email)


def _published_version_response(
    version: EnterpriseAppPublishedVersion | None,
) -> EnterpriseAppPublishedVersionResponse | None:
    if version is None:
        return None
    return EnterpriseAppPublishedVersionResponse(
        id=version.id,
        version=version.version,
        version_number=version.version_number,
        marked_name=version.marked_name,
        marked_comment=version.marked_comment,
        created_by=_creator_response(version.created_by),
        published_at=to_timestamp(version.published_at),
    )


def _site_response(site: EnterpriseAppSite | None) -> EnterpriseAppSiteResponse | None:
    if site is None:
        return None
    return EnterpriseAppSiteResponse(enabled=site.enabled, code=site.code, app_base_url=site.app_base_url)


def _api_response(api: EnterpriseAppApi | None) -> EnterpriseAppApiResponse | None:
    if api is None:
        return None
    return EnterpriseAppApiResponse(enabled=api.enabled, base_url=api.base_url, api_key_count=api.api_key_count)


def _mcp_server_response(server: EnterpriseAppMCPServer | None) -> EnterpriseAppMCPServerResponse | None:
    if server is None:
        return None
    return EnterpriseAppMCPServerResponse(status=server.status, server_code=server.server_code)


def _trigger_response(trigger: EnterpriseAppTrigger) -> EnterpriseAppTriggerResponse:
    return EnterpriseAppTriggerResponse(
        id=trigger.id,
        node_id=trigger.node_id,
        title=trigger.title,
        trigger_type=trigger.trigger_type,
        provider_name=trigger.provider_name,
        status=trigger.status,
        webhook_url=trigger.webhook_url,
    )


@inner_api_ns.route("/enterprise/apps")
class EnterpriseAppList(Resource):
    @setup_required
    @enterprise_inner_api_only
    @inner_api_ns.doc(
        "enterprise_app_list",
        params=query_params_from_model(EnterpriseAppListQuery),
        responses={HTTPStatus.BAD_REQUEST: "Invalid query parameters"},
    )
    @inner_api_ns.response(HTTPStatus.OK, "Success", inner_api_ns.models[EnterpriseAppPaginationResponse.__name__])
    def get(self):
        """List Studio-visible apps across all workspaces."""
        try:
            query = query_params_from_request(EnterpriseAppListQuery, list_fields=APP_LIST_QUERY_ARRAY_FIELDS)
        except ValidationError as exc:
            raise BadRequest(str(exc)) from exc

        result = application_services().apps.enterprise.list_apps(
            EnterpriseAppListParams(
                page=query.page,
                limit=query.limit,
                workspace_ids=[str(workspace_id) for workspace_id in query.workspace_ids],
                modes=[AppMode(mode) for mode in query.modes],
                name=query.name,
                sort_by=query.sort_by,
                sort_order=query.sort_order,
            )
        )
        return EnterpriseAppPaginationResponse(
            page=result.page,
            limit=result.per_page,
            total=result.total,
            has_more=result.has_next,
            data=[
                EnterpriseAppListItemResponse(
                    id=item.app.id,
                    name=item.app.name,
                    description=item.app.description,
                    mode=item.app.mode,
                    icon_type=item.app.icon_type,
                    icon=item.app.icon,
                    icon_background=item.app.icon_background,
                    workspace_id=item.app.workspace_id,
                    workspace_name=item.app.workspace_name,
                    created_by=_creator_response(item.app.created_by),
                    created_at=to_timestamp(item.app.created_at),
                    updated_at=to_timestamp(item.app.updated_at),
                    published=item.published,
                    invocation_count_24h=item.invocation_count,
                )
                for item in result.items
            ],
        ).model_dump(mode="json")


@inner_api_ns.route("/enterprise/apps/<uuid:app_id>")
class EnterpriseAppDetail(Resource):
    @setup_required
    @enterprise_inner_api_only
    @inner_api_ns.doc("enterprise_app_detail", responses={HTTPStatus.NOT_FOUND: "App not found"})
    @inner_api_ns.response(HTTPStatus.OK, "Success", inner_api_ns.models[EnterpriseAppDetailResponse.__name__])
    def get(self, app_id: UUID):
        """Get a Studio-visible app with its published version, access points, and invocations."""
        detail = application_services().apps.enterprise.get_app(str(app_id))
        if detail is None:
            return SimpleMessageResponse(message="app not found").model_dump(mode="json"), HTTPStatus.NOT_FOUND

        app = detail.app
        return EnterpriseAppDetailResponse(
            id=app.id,
            name=app.name,
            description=app.description,
            mode=app.mode,
            icon_type=app.icon_type,
            icon=app.icon,
            icon_background=app.icon_background,
            workspace_id=app.workspace_id,
            workspace_name=app.workspace_name,
            created_by=_creator_response(app.created_by),
            created_at=to_timestamp(app.created_at),
            updated_at=to_timestamp(app.updated_at),
            published_version=_published_version_response(detail.published_version),
            published_version_count=detail.published_version_count,
            site=_site_response(detail.site),
            api=_api_response(detail.api),
            mcp_server=_mcp_server_response(detail.mcp_server),
            triggers=[_trigger_response(trigger) for trigger in detail.triggers],
            last_invoked_at=to_timestamp(detail.last_invoked_at),
            invocation_count_24h=detail.invocation_count,
            failed_invocation_count_24h=detail.failed_invocation_count,
        ).model_dump(mode="json")