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.4 KB
Raw Blame
"""Plugin transport and compatibility boundaries for trigger OAuth."""

from collections.abc import Mapping

from pydantic import TypeAdapter

from core.plugin.entities.plugin_daemon import CredentialType
from core.plugin.impl.oauth import OAuthHandler
from core.plugin.plugin_service import PluginService
from core.trigger.entities.api_entities import SubscriptionBuilderApiEntity
from core.trigger.entities.entities import SubscriptionBuilderUpdater
from core.trigger.trigger_manager import TriggerManager
from models.provider_ids import TriggerProviderID
from services.plugin.dispatch_identity import PluginOAuthClientConfig
from services.plugin.oauth_service import OAuthProxyService
from services.trigger.oauth_client_service import TriggerOAuthProviderMetadata
from services.trigger.oauth_service import (
    TriggerOAuthCallbackRequest,
    TriggerOAuthContext,
    TriggerOAuthContextError,
    TriggerOAuthCredentials,
    TriggerOAuthProviderError,
)
from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService

_context_adapter = TypeAdapter(TriggerOAuthContext)


class PluginTriggerOAuthGateway:
    def __init__(self, *, oauth: OAuthHandler) -> None:
        self._oauth = oauth

    def get_metadata(self, *, tenant_id: str, provider_id: TriggerProviderID) -> TriggerOAuthProviderMetadata:
        provider = TriggerManager.get_trigger_provider(tenant_id, provider_id)
        return TriggerOAuthProviderMetadata(
            schema=provider.get_oauth_client_schema(),
            plugin_unique_identifier=provider.plugin_unique_identifier,
        )

    def is_verified(self, *, tenant_id: str, plugin_unique_identifier: str) -> bool:
        return PluginService.is_plugin_verified(tenant_id, plugin_unique_identifier)

    def authorization_url(
        self,
        *,
        tenant_id: str,
        user_id: str,
        provider_id: TriggerProviderID,
        redirect_uri: str,
        client_config: PluginOAuthClientConfig,
    ) -> str:
        try:
            result = self._oauth.get_authorization_url(
                tenant_id=tenant_id,
                user_id=user_id,
                plugin_id=provider_id.plugin_id,
                provider=provider_id.provider_name,
                redirect_uri=redirect_uri,
                system_credentials=dict(client_config.credentials),
                plugin_unique_identifier=client_config.plugin_unique_identifier,
            )
        except ValueError as error:
            raise TriggerOAuthProviderError("Failed to get the trigger provider's OAuth authorization URL.") from error
        return result.authorization_url

    def exchange_credentials(
        self,
        *,
        tenant_id: str,
        user_id: str,
        provider_id: TriggerProviderID,
        redirect_uri: str,
        client_config: PluginOAuthClientConfig,
        callback: TriggerOAuthCallbackRequest,
    ) -> TriggerOAuthCredentials:
        # Preserve the legacy raw request, including trailing '?' and header order.
        protocol = next(
            (value for name, value in callback.headers if name.lower().replace("-", "_") == "http_version"), "HTTP/1.1"
        )
        raw_request = f"{callback.method} {callback.full_path} {protocol}\r\n".encode()
        raw_request += b"".join(f"{name}: {value}\r\n".encode() for name, value in callback.headers)
        raw_request += b"\r\n" + callback.body
        try:
            result = self._oauth.get_credentials_from_raw_request(
                tenant_id=tenant_id,
                user_id=user_id,
                plugin_id=provider_id.plugin_id,
                provider=provider_id.provider_name,
                redirect_uri=redirect_uri,
                system_credentials=dict(client_config.credentials),
                plugin_unique_identifier=client_config.plugin_unique_identifier,
                raw_request=raw_request,
            )
        except ValueError as error:
            raise TriggerOAuthProviderError("Failed to get OAuth credentials from the trigger provider.") from error
        return TriggerOAuthCredentials(credentials=result.credentials, expires_at=result.expires_at)


class OAuthProxyContextGateway:
    """Retain the shared proxy format so in-flight callbacks survive deployment.

    TODO: Migrate the shared proxy owner to atomic consumption for all plugin
    OAuth callers; its existing GET/DELETE pair does not exclude concurrent replay.
    """

    max_age: int = OAuthProxyService.__MAX_AGE__

    def create(self, context: TriggerOAuthContext) -> str:
        return OAuthProxyService.create_proxy_context(
            user_id=context.user_id,
            tenant_id=context.tenant_id,
            plugin_id=context.plugin_id,
            provider=context.provider,
            extra_data={
                "subscription_builder_id": context.subscription_builder_id,
                "plugin_unique_identifier": context.plugin_unique_identifier,
            },
        )

    def consume(self, context_id: str) -> TriggerOAuthContext:
        try:
            context = OAuthProxyService.use_proxy_context(context_id)
            return _context_adapter.validate_python(context)
        except ValueError as error:
            raise TriggerOAuthContextError("Invalid or expired context_id") from error


class TriggerOAuthBuilderGateway:
    """Adapt OAuth credentials to the shared subscription builder lifecycle."""

    def __init__(self, *, builders: TriggerSubscriptionBuilderService) -> None:
        self._builders = builders

    def create(self, *, tenant_id: str, user_id: str, provider_id: TriggerProviderID) -> SubscriptionBuilderApiEntity:
        return self._builders.create_trigger_subscription_builder(
            tenant_id=tenant_id,
            user_id=user_id,
            provider_id=provider_id,
            credential_type=CredentialType.OAUTH2,
        )

    def set_credentials(
        self,
        *,
        context: TriggerOAuthContext,
        provider_id: TriggerProviderID,
        credentials: Mapping[str, object],
        expires_at: int,
    ) -> None:
        self._builders.update_trigger_subscription_builder(
            tenant_id=context.tenant_id,
            user_id=context.user_id,
            provider_id=provider_id,
            subscription_builder_id=context.subscription_builder_id,
            subscription_builder_updater=SubscriptionBuilderUpdater(
                credentials=credentials,
                credential_expires_at=expires_at,
            ),
        )