Feat: Modify the style of the release confirmation box. (#13542)

### What problem does this PR solve?

Feat: Modify the style of the release confirmation box.

### Type of change


- [x] New Feature (non-breaking change which adds functionality)

---------

Co-authored-by: Yingfeng <yingfeng.zhang@gmail.com>
Co-authored-by: balibabu <assassin_cike@163.com>
Co-authored-by: 6ba3i <isbaaoui09@gmail.com>

api/apps/canvas_app.py

@@ -24,6 +24,7 @@ from api.db import CanvasCategory
 from api.db.services.canvas_service import CanvasTemplateService, UserCanvasService, API4ConversationService
 from api.db.services.document_service import DocumentService
 from api.db.services.file_service import FileService
+from api.db.services.knowledgebase_service import KnowledgebaseService
 from api.db.services.pipeline_operation_log_service import PipelineOperationLogService
 from api.db.services.task_service import queue_dataflow, CANVAS_DEBUG_DOC_ID, TaskService
 from api.db.services.user_service import TenantService
@@ -153,6 +154,11 @@ def get(canvas_id):
         c = c.to_dict()
         c["last_publish_time"] = last_publish_time
 
+    # For pipeline type, get associated datasets
+    if c.get("canvas_category") == CanvasCategory.DataFlow:
+        datasets = list(KnowledgebaseService.query(pipeline_id=canvas_id))
+        c["datasets"] = [{"id": d.id, "name": d.name, "avatar": d.avatar} for d in datasets]
+
     return get_json_result(data=c)
 
 

api/apps/sdk/session.py

@@ -87,19 +87,20 @@ async def create(tenant_id, chat_id):
 async def create_agent_session(tenant_id, agent_id):
     req = await get_request_json()
     user_id = req.get("user_id") or request.args.get("user_id", tenant_id)
-    release_mode = req.get("release", request.args.get("release", False))
-    e, cvs = UserCanvasService.get_by_id(agent_id)
-    if not e:
-        return get_error_data_result("Agent not found.")
+    release_mode = bool(req.get("release", request.args.get("release", False)))
+
     if not UserCanvasService.query(user_id=tenant_id, id=agent_id):
         return get_error_data_result("You cannot access the agent.")
-    if not isinstance(cvs.dsl, str):
-        cvs.dsl = json.dumps(cvs.dsl, ensure_ascii=False)
 
-    if release_mode and not bool(cvs.release):
-        raise PermissionError("No available published version")
+    try:
+        cvs, dsl = UserCanvasService.get_agent_dsl_with_release(agent_id, release_mode, tenant_id)
+    except LookupError:
+        return get_error_data_result("Agent not found.")
+    except PermissionError as e:
+        return get_error_data_result(str(e))
+
     session_id = get_uuid()
-    canvas = Canvas(cvs.dsl, tenant_id, agent_id, canvas_id=cvs.id)
+    canvas = Canvas(dsl, tenant_id, agent_id, canvas_id=cvs.id)
     canvas.reset()
 
     cvs.dsl = json.loads(str(canvas))

api/db/services/canvas_service.py

@@ -22,6 +22,7 @@ from api.db import CanvasCategory, TenantPermission
 from api.db.db_models import DB, CanvasTemplate, User, UserCanvas, API4Conversation, UserCanvasVersion
 from api.db.services.api_service import API4ConversationService
 from api.db.services.common_service import CommonService
+from api.db.services.user_canvas_version import UserCanvasVersionService
 from common.misc_utils import get_uuid
 from api.utils.api_utils import get_data_openai
 import tiktoken
@@ -204,6 +205,27 @@ class UserCanvasService(CommonService):
             return False
         return True
 
+    @classmethod
+    def get_agent_dsl_with_release(cls, agent_id, release_mode=False, tenant_id=None):
+        e, cvs = cls.get_by_id(agent_id)
+        if not e:
+            raise LookupError("Agent not found.")
+        if tenant_id and cvs.user_id != tenant_id:
+            raise PermissionError("You do not own the agent.")
+
+        if release_mode:
+            released_version = UserCanvasVersionService.get_latest_released(agent_id)
+            if not released_version:
+                raise PermissionError("No available published version")
+            dsl = released_version.dsl
+        else:
+            dsl = cvs.dsl
+
+        if not isinstance(dsl, str):
+            dsl = json.dumps(dsl, ensure_ascii=False)
+
+        return cvs, dsl
+
 
 async def completion(tenant_id, agent_id, session_id=None, **kwargs):
     query = kwargs.get("query", "") or kwargs.get("question", "")
@@ -223,28 +245,12 @@ async def completion(tenant_id, agent_id, session_id=None, **kwargs):
             conv.dsl = json.dumps(conv.dsl, ensure_ascii=False)
         canvas = Canvas(conv.dsl, tenant_id, agent_id, canvas_id=agent_id, custom_header=custom_header)
     else:
-        e, cvs = UserCanvasService.get_by_id(agent_id)
-        if not e:
-            raise LookupError("Agent not found.")
-        if cvs.user_id != tenant_id:
-            raise PermissionError("You do not own the agent.")
-        if release_mode == "true" and not bool(cvs.release):
-            raise PermissionError("No available published version")
-        if not isinstance(cvs.dsl, str):
-            cvs.dsl = json.dumps(cvs.dsl, ensure_ascii=False)
+        cvs, dsl = UserCanvasService.get_agent_dsl_with_release(agent_id, release_mode=release_mode == "true", tenant_id=tenant_id)
 
-        session_id=get_uuid()
-        canvas = Canvas(cvs.dsl, tenant_id, agent_id, canvas_id=cvs.id, custom_header=custom_header)
+        session_id = get_uuid()
+        canvas = Canvas(dsl, tenant_id, agent_id, canvas_id=cvs.id, custom_header=custom_header)
         canvas.reset()
-        conv = {
-            "id": session_id,
-            "dialog_id": cvs.id,
-            "user_id": user_id,
-            "message": [],
-            "source": "agent",
-            "dsl": cvs.dsl,
-            "reference": []
-        }
+        conv = {"id": session_id, "dialog_id": cvs.id, "user_id": user_id, "message": [], "source": "agent", "dsl": dsl, "reference": []}
         API4ConversationService.save(**conv)
         conv = API4Conversation(**conv)
 

api/db/services/user_canvas_version.py

@@ -89,6 +89,17 @@ class UserCanvasVersionService(CommonService):
         except Exception:
             return None
 
+    @classmethod
+    @DB.connection_context()
+    def get_latest_released(cls, user_canvas_id):
+        try:
+            return cls.model.select().where((cls.model.user_canvas_id == user_canvas_id) & (cls.model.release)).order_by(cls.model.create_time.desc()).first()
+        except DoesNotExist:
+            return None
+        except Exception as e:
+            logging.exception(e)
+            return None
+
     @classmethod
     @DB.connection_context()
     def save_or_replace_latest(cls, user_canvas_id, dsl, title=None, description=None, release=None):