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.

6.5 KB
Raw Blame
from dataclasses import asdict
from datetime import datetime
from http import HTTPStatus
from uuid import UUID

from flask_restx import Resource
from pydantic import BaseModel, field_validator

from configs import dify_config
from controllers.common.rbac import PlainApp, RBACCheck
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.app.error import AppNotFoundError, AppTriggerNotFoundError, WebhookTriggerNotFoundError
from controllers.console.flask_admission import console_account_admission
from controllers.console.wraps import RBACPermission, model_validate
from core.trigger.utils.endpoint import generate_webhook_trigger_endpoint
from enums.account import TenantAccountRole
from extensions.ext_application_services import application_services
from fields.base import ResponseModel
from libs.external_api import error_responses
from libs.helper import dump_response
from machinery.context import RequestContext
from models.enums import AppTriggerType
from services.app.console_service import ConsoleAppNotFoundError
from services.trigger.app_trigger_store import (
    AppTriggerNotFoundError as AppTriggerMissing,
)
from services.trigger.app_trigger_store import (
    AppTriggerRecord,
)
from services.trigger.app_trigger_store import (
    WebhookTriggerNotFoundError as WebhookTriggerMissing,
)


class WebhookTriggerQuery(BaseModel):
    node_id: str


class ParserEnable(BaseModel):
    trigger_id: str
    enable_trigger: bool


class WorkflowTriggerResponse(ResponseModel):
    id: str
    trigger_type: str
    title: str
    node_id: str
    provider_name: str
    icon: str
    status: str
    created_at: datetime | None = None
    updated_at: datetime | None = None

    @field_validator("id", "trigger_type", "title", "node_id", "provider_name", "icon", "status", mode="before")
    @classmethod
    def _normalize_string_fields(cls, value: object) -> str:
        if isinstance(value, str):
            return value
        return str(value)


class WorkflowTriggerListResponse(ResponseModel):
    data: list[WorkflowTriggerResponse]


class WebhookTriggerResponse(ResponseModel):
    id: str
    webhook_id: str
    webhook_url: str
    webhook_debug_url: str
    node_id: str
    created_at: datetime | None = None

    @field_validator("id", "webhook_id", "webhook_url", "webhook_debug_url", "node_id", mode="before")
    @classmethod
    def _normalize_string_fields(cls, value: object) -> str:
        if isinstance(value, str):
            return value
        return str(value)


register_schema_models(console_ns, WebhookTriggerQuery, ParserEnable)
register_response_schema_models(
    console_ns,
    WorkflowTriggerResponse,
    WorkflowTriggerListResponse,
    WebhookTriggerResponse,
)


def _with_trigger_icon(trigger: AppTriggerRecord) -> dict[str, object]:
    icon = ""
    if trigger.trigger_type == AppTriggerType.TRIGGER_PLUGIN:
        icon = (
            dify_config.CONSOLE_API_URL
            + "/console/api/workspaces/current/tool-provider/builtin/"
            + (trigger.provider_name or "")
            + "/icon"
        )
    return {**asdict(trigger), "icon": icon}


@console_ns.route("/apps/<uuid:app_id>/workflows/triggers/webhook")
class WebhookTriggerApi(Resource):
    @error_responses(AppNotFoundError, WebhookTriggerNotFoundError)
    @console_ns.doc(params=query_params_from_model(WebhookTriggerQuery))
    @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[WebhookTriggerResponse.__name__])
    @console_account_admission(rbac_checks=[RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp())])
    @model_validate(WebhookTriggerQuery)
    def get(self, req_data: WebhookTriggerQuery, context: RequestContext, app_id: UUID) -> dict[str, object]:
        """Get webhook trigger for a node"""
        try:
            webhook = application_services().apps.triggers.get_webhook(context, str(app_id), req_data.node_id)
        except ConsoleAppNotFoundError as error:
            raise AppNotFoundError(str(error)) from error
        except WebhookTriggerMissing as error:
            raise WebhookTriggerNotFoundError(str(error)) from error
        return dump_response(
            WebhookTriggerResponse,
            {
                **asdict(webhook),
                "webhook_url": generate_webhook_trigger_endpoint(webhook.webhook_id),
                "webhook_debug_url": generate_webhook_trigger_endpoint(webhook.webhook_id, debug=True),
            },
        )


@console_ns.route("/apps/<uuid:app_id>/triggers")
class AppTriggersApi(Resource):
    @error_responses(AppNotFoundError)
    @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[WorkflowTriggerListResponse.__name__])
    @console_account_admission(rbac_checks=[RBACCheck(RBACPermission.APP_VIEW_LAYOUT, PlainApp())])
    def get(self, context: RequestContext, app_id: UUID) -> dict[str, object]:
        """Get app triggers list"""
        try:
            triggers = application_services().apps.triggers.list_triggers(context, str(app_id))
        except ConsoleAppNotFoundError as error:
            raise AppNotFoundError(str(error)) from error
        return dump_response(
            WorkflowTriggerListResponse, {"data": [_with_trigger_icon(trigger) for trigger in triggers]}
        )


@console_ns.route("/apps/<uuid:app_id>/trigger-enable")
class AppTriggerEnableApi(Resource):
    @error_responses(AppNotFoundError, AppTriggerNotFoundError)
    @console_ns.expect(console_ns.models[ParserEnable.__name__])
    @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[WorkflowTriggerResponse.__name__])
    @console_account_admission(
        allowed_roles=frozenset({TenantAccountRole.OWNER, TenantAccountRole.ADMIN, TenantAccountRole.EDITOR}),
        rbac_checks=[RBACCheck(RBACPermission.APP_EDIT, PlainApp())],
    )
    @model_validate(ParserEnable)
    def post(self, req_data: ParserEnable, context: RequestContext, app_id: UUID) -> dict[str, object]:
        """Update app trigger (enable/disable)"""
        try:
            trigger = application_services().apps.triggers.set_enabled(
                context, str(app_id), req_data.trigger_id, enabled=req_data.enable_trigger
            )
        except ConsoleAppNotFoundError as error:
            raise AppNotFoundError(str(error)) from error
        except AppTriggerMissing as error:
            raise AppTriggerNotFoundError(str(error)) from error
        return dump_response(WorkflowTriggerResponse, _with_trigger_icon(trigger))