feat: application node

Author: shaohuzhang1

apps/application/flow/step_node/application_node/impl/base_application_node.py

@@ -171,16 +171,19 @@ def save_context(self, details, workflow_manage):
         if self.node_params.get('is_result', False):
             self.answer_text = details.get('answer')
 
-    def execute(self, application_id, message, chat_id, chat_record_id, stream, re_chat, client_id, client_type,
+    def execute(self, application_id, message, chat_id, chat_record_id, stream, re_chat,
+                chat_user_id,
+                chat_user_type,
                 app_document_list=None, app_image_list=None, app_audio_list=None, child_node=None, node_data=None,
                 **kwargs) -> NodeResult:
-        from application.serializers.chat_message_serializers import ChatMessageSerializer
+        from chat.serializers.chat import ChatSerializers
         # 生成嵌入应用的chat_id
         current_chat_id = string_to_uuid(chat_id + application_id)
         Chat.objects.get_or_create(id=current_chat_id, defaults={
             'application_id': application_id,
             'abstract': message[0:1024],
-            'client_id': client_id,
+            'chat_user_id': chat_user_id,
+            'chat_user_type': chat_user_type
         })
         if app_document_list is None:
             app_document_list = []
@@ -197,22 +200,26 @@ def execute(self, application_id, message, chat_id, chat_record_id, stream, re_c
             child_node_value = child_node.get('child_node')
             application_node_dict = self.context.get('application_node_dict')
             reset_application_node_dict(application_node_dict, runtime_node_id, node_data)
+        response = ChatSerializers(data={
+            "chat_id": current_chat_id,
+            "chat_user_id": chat_user_id,
+            'chat_user_type': chat_user_type,
+            'application_id': application_id,
+            'debug': False
+        }).chat(instance=
+                {'message': message,
+                 're_chat': re_chat,
+                 'stream': stream,
+                 'document_list': app_document_list,
+                 'image_list': app_image_list,
+                 'audio_list': app_audio_list,
+                 'runtime_node_id': runtime_node_id,
+                 'chat_record_id': record_id,
+                 'child_node': child_node_value,
+                 'node_data': node_data,
+                 'form_data': kwargs}
+                )
 
-        response = ChatMessageSerializer(
-            data={'chat_id': current_chat_id, 'message': message,
-                  're_chat': re_chat,
-                  'stream': stream,
-                  'application_id': application_id,
-                  'client_id': client_id,
-                  'client_type': client_type,
-                  'document_list': app_document_list,
-                  'image_list': app_image_list,
-                  'audio_list': app_audio_list,
-                  'runtime_node_id': runtime_node_id,
-                  'chat_record_id': record_id,
-                  'child_node': child_node_value,
-                  'node_data': node_data,
-                  'form_data': kwargs}).chat()
         if response.status_code == 200:
             if stream:
                 content_generator = response.streaming_content

apps/chat/serializers/chat.py

@@ -274,6 +274,10 @@ def re_open_chat(self, chat_id: str):
         application = QuerySet(Application).filter(id=chat.application_id).first()
         if application is None:
             raise ChatException(500, _("Application does not exist"))
+        application_version = QuerySet(ApplicationVersion).filter(application_id=application.id).order_by(
+            '-create_time')[0:1].first()
+        if application_version is None:
+            raise ChatException(500, _("The application has not been published. Please use it after publishing."))
         if application.type == ApplicationTypeChoices.SIMPLE:
             return self.re_open_chat_simple(chat_id, application)
         else:
@@ -299,11 +303,6 @@ def re_open_chat_simple(self, chat_id, application):
         return chat_info
 
     def re_open_chat_work_flow(self, chat_id, application):
-        application_version = QuerySet(ApplicationVersion).filter(application_id=application.id).order_by(
-            '-create_time')[0:1].first()
-        if application_version is None:
-            raise ChatException(500, _("The application has not been published. Please use it after publishing."))
-
         chat_info = ChatInfo(chat_id, self.data.get('chat_user_id'), self.data.get('chat_user_type'), [], [],
                              application.id)
         chat_record_list = list(QuerySet(ChatRecord).filter(chat_id=chat_id).order_by('-create_time')[0:5])
@@ -334,6 +333,14 @@ def open(self):
         self.is_valid(raise_exception=True)
         application_id = self.data.get('application_id')
         application = QuerySet(Application).get(id=application_id)
+        debug = self.data.get("debug")
+        if not debug:
+            application_version = QuerySet(ApplicationVersion).filter(application_id=application_id).order_by(
+                '-create_time')[0:1].first()
+            if application_version is None:
+                raise AppApiException(500,
+                                      gettext(
+                                          "The application has not been published. Please use it after publishing."))
         if application.type == ApplicationTypeChoices.SIMPLE:
             return self.open_simple(application)
         else:
@@ -346,13 +353,6 @@ def open_work_flow(self, application):
         chat_user_type = self.data.get("chat_user_type")
         debug = self.data.get("debug")
         chat_id = str(uuid.uuid7())
-        if not debug:
-            application_version = QuerySet(ApplicationVersion).filter(application_id=application_id).order_by(
-                '-create_time')[0:1].first()
-            if application_version is None:
-                raise AppApiException(500,
-                                      gettext(
-                                          "The application has not been published. Please use it after publishing."))
         ChatInfo(chat_id, chat_user_id, chat_user_type, [],
                  [],
                  application_id, debug).set_cache()