refactor(trigger): enhance trigger provider deletion process and session management

api/controllers/console/workspace/trigger_providers.py

@@ -2,6 +2,7 @@ import logging
 
 from flask import make_response, redirect, request
 from flask_restx import Resource, reqparse
+from sqlalchemy.orm import Session
 from werkzeug.exceptions import BadRequest, Forbidden
 
 from configs import dify_config
@@ -11,11 +12,13 @@ from core.model_runtime.utils.encoders import jsonable_encoder
 from core.plugin.entities.plugin import TriggerProviderID
 from core.plugin.entities.plugin_daemon import CredentialType
 from core.plugin.impl.oauth import OAuthHandler
+from extensions.ext_database import db
 from libs.login import current_user, login_required
 from models.account import Account
 from services.plugin.oauth_service import OAuthProxyService
 from services.trigger.trigger_provider_service import TriggerProviderService
 from services.trigger.trigger_subscription_builder_service import TriggerSubscriptionBuilderService
+from services.workflow_plugin_trigger_service import WorkflowPluginTriggerService
 
 logger = logging.getLogger(__name__)
 
@@ -212,12 +215,21 @@ class TriggerSubscriptionDeleteApi(Resource):
             raise Forbidden()
 
         try:
-            result = TriggerProviderService.delete_trigger_provider(
+            with Session(db.engine) as session:
-                tenant_id=user.current_tenant_id,
+                # Delete trigger provider subscription
-                subscription_id=subscription_id,
+                TriggerProviderService.delete_trigger_provider(
-            )
+                    session=session,
-            return result
+                    tenant_id=user.current_tenant_id,
-
+                    subscription_id=subscription_id,
+                )
+                # Delete plugin triggers
+                WorkflowPluginTriggerService.delete_plugin_trigger_by_subscription(
+                    session=session,
+                    tenant_id=user.current_tenant_id,
+                    subscription_id=subscription_id,
+                )
+                session.commit()
+            return {"result": "success"}
         except ValueError as e:
             raise BadRequest(str(e))
         except Exception as e:

api/services/trigger/trigger_provider_service.py

@@ -162,34 +162,31 @@ class TriggerProviderService:
             raise ValueError(str(e))
 
     @classmethod
-    def delete_trigger_provider(cls, tenant_id: str, subscription_id: str) -> dict:
+    def delete_trigger_provider(cls, session: Session, tenant_id: str, subscription_id: str):
         """
-        Delete a trigger provider subscription.
+        Delete a trigger provider subscription within an existing session.
 
+        :param session: Database session
         :param tenant_id: Tenant ID
         :param subscription_id: Subscription instance ID
         :return: Success response
         """
-        with Session(db.engine) as session:
+        db_provider = session.query(TriggerSubscription).filter_by(tenant_id=tenant_id, id=subscription_id).first()
-            db_provider = session.query(TriggerSubscription).filter_by(tenant_id=tenant_id, id=subscription_id).first()
+        if not db_provider:
-            if not db_provider:
+            raise ValueError(f"Trigger provider subscription {subscription_id} not found")
-                raise ValueError(f"Trigger provider subscription {subscription_id} not found")
 
-            provider_controller = TriggerManager.get_trigger_provider(
+        provider_controller = TriggerManager.get_trigger_provider(
-                tenant_id, TriggerProviderID(db_provider.provider_id)
+            tenant_id, TriggerProviderID(db_provider.provider_id)
-            )
+        )
-            # Clear cache
+        # Clear cache
-            _, cache = create_trigger_provider_encrypter_for_subscription(
+        _, cache = create_trigger_provider_encrypter_for_subscription(
-                tenant_id=tenant_id,
+            tenant_id=tenant_id,
-                controller=provider_controller,
+            controller=provider_controller,
-                subscription=db_provider,
+            subscription=db_provider,
-            )
+        )
 
-            session.delete(db_provider)
+        session.delete(db_provider)
-            session.commit()
+        cache.delete()
-
-            cache.delete()
-            return {"result": "success"}
 
     @classmethod
     def refresh_oauth_token(

api/services/workflow_plugin_trigger_service.py

@@ -317,32 +317,32 @@ class WorkflowPluginTriggerService:
     @classmethod
     def delete_plugin_trigger_by_subscription(
         cls,
+        session: Session,
         tenant_id: str,
         subscription_id: str,
     ) -> None:
-        """Delete a plugin trigger by tenant_id and subscription_id
+        """Delete a plugin trigger by tenant_id and subscription_id within an existing session
 
         Args:
+            session: Database session
             tenant_id: The tenant ID
             subscription_id: The subscription ID
 
         Raises:
             NotFound: If plugin trigger not found
         """
-        with Session(db.engine) as session:
+        # Find plugin trigger using indexed columns
-            # Find plugin trigger using indexed columns
+        plugin_trigger = session.scalar(
-            plugin_trigger = session.scalar(
+            select(WorkflowPluginTrigger).where(
-                select(WorkflowPluginTrigger).where(
+                WorkflowPluginTrigger.tenant_id == tenant_id,
-                    WorkflowPluginTrigger.tenant_id == tenant_id,
+                WorkflowPluginTrigger.subscription_id == subscription_id,
-                    WorkflowPluginTrigger.subscription_id == subscription_id,
-                )
             )
+        )
 
-            if not plugin_trigger:
+        if not plugin_trigger:
-                raise NotFound("Plugin trigger not found")
+            raise NotFound("Plugin trigger not found")
 
-            session.delete(plugin_trigger)
+        session.delete(plugin_trigger)
-            session.commit()
 
     @classmethod
     def delete_all_by_subscription(