feat: chat record

apps/chat/api/chat_api.py

@@ -9,8 +9,9 @@
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import OpenApiParameter
 
+from application.serializers.application_chat_record import ChatRecordSerializerModel
 from chat.serializers.chat import ChatMessageSerializers
-from chat.serializers.chat_record import HistoryChatRecordModel
+from chat.serializers.chat_record import HistoryChatModel
 from common.mixins.api_mixin import APIMixin
 from common.result import ResultSerializer, ResultPageSerializer
 
@@ -33,12 +34,22 @@ def get_request():
 
 class ApplicationCreateResponse(ResultSerializer):
     def get_data(self):
-        return HistoryChatRecordModel(many=True)
+        return HistoryChatModel(many=True)
 
 
 class PageApplicationCreateResponse(ResultPageSerializer):
     def get_data(self):
-        return HistoryChatRecordModel(many=True)
+        return HistoryChatModel(many=True)
+
+
+class ApplicationRecordResponse(ResultSerializer):
+    def get_data(self):
+        return ChatRecordSerializerModel(many=True)
+
+
+class PageApplicationRecordResponse(ResultPageSerializer):
+    def get_data(self):
+        return ChatRecordSerializerModel(many=True)
 
 
 class HistoricalConversationAPI(APIMixin):
@@ -59,3 +70,35 @@ def get_parameters():
     @staticmethod
     def get_response():
         return PageApplicationCreateResponse
+
+
+class HistoricalConversationRecordAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [OpenApiParameter(
+            name="chat_id",
+            description="对话id",
+            type=OpenApiTypes.STR,
+            location='path',
+            required=True,
+        )]
+
+    @staticmethod
+    def get_response():
+        return ApplicationRecordResponse
+
+
+class PageHistoricalConversationRecordAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [OpenApiParameter(
+            name="chat_id",
+            description="对话id",
+            type=OpenApiTypes.STR,
+            location='path',
+            required=True,
+        )]
+
+    @staticmethod
+    def get_response():
+        return PageApplicationRecordResponse

apps/chat/serializers/chat_record.py

@@ -14,6 +14,7 @@
 from rest_framework import serializers
 
 from application.models import VoteChoices, ChatRecord, Chat
+from application.serializers.application_chat_record import ChatRecordSerializerModel
 from common.db.search import page_search
 from common.exception.app_exception import AppApiException
 from common.utils.lock import try_lock, un_lock
@@ -24,7 +25,7 @@ class VoteRequest(serializers.Serializer):
                                           label=_("Bidding Status"))
 
 
-class HistoryChatRecordModel(serializers.ModelSerializer):
+class HistoryChatModel(serializers.ModelSerializer):
     class Meta:
         model = Chat
         fields = ['id',
@@ -76,7 +77,7 @@ def vote(self, instance: Dict, with_valid=True):
         return True
 
 
-class ChatRecordSerializer(serializers.Serializer):
+class HistoricalConversationSerializer(serializers.Serializer):
     application_id = serializers.UUIDField(required=True, label=_('Application ID'))
     chat_user_id = serializers.UUIDField(required=True, label=_('Chat User ID'))
 
@@ -88,8 +89,37 @@ def get_queryset(self):
     def list(self):
         self.is_valid(raise_exception=True)
         queryset = self.get_queryset()
-        return [HistoryChatRecordModel(r).data for r in queryset]
+        return [HistoryChatModel(r).data for r in queryset]
 
     def page(self, current_page, page_size):
         self.is_valid(raise_exception=True)
-        return page_search(current_page, page_size, self.get_queryset(), lambda r: HistoryChatRecordModel(r).data)
+        return page_search(current_page, page_size, self.get_queryset(), lambda r: HistoryChatModel(r).data)
+
+
+class HistoricalConversationRecordSerializer(serializers.Serializer):
+    application_id = serializers.UUIDField(required=True, label=_('Application ID'))
+    chat_id = serializers.UUIDField(required=True, label=_('Chat ID'))
+    chat_user_id = serializers.UUIDField(required=True, label=_('Chat User ID'))
+
+    def is_valid(self, *, raise_exception=False):
+        super().is_valid(raise_exception=True)
+        chat_user_id = self.data.get('chat_user_id')
+        application_id = self.data.get("application_id")
+        chat_id = self.data.get('chat_id')
+        chat_exist = QuerySet(Chat).filter(application_id=application_id, chat_user_id=chat_user_id,
+                                           id=chat_id).exists()
+        if not chat_exist:
+            raise AppApiException(500, _('Non-existent chatID'))
+
+    def get_queryset(self):
+        chat_id = self.data.get('chat_id')
+        return QuerySet(ChatRecord).filter(chat_id=chat_id).order_by('-create_time')
+
+    def list(self):
+        self.is_valid(raise_exception=True)
+        queryset = self.get_queryset()
+        return [ChatRecordSerializerModel(r).data for r in queryset]
+
+    def page(self, current_page, page_size):
+        self.is_valid(raise_exception=True)
+        return page_search(current_page, page_size, self.get_queryset(), lambda r: ChatRecordSerializerModel(r).data)

apps/chat/urls.py

@@ -16,5 +16,10 @@
     path('historical_conversation', views.HistoricalConversationView.as_view(), name='historical_conversation'),
     path('historical_conversation/<int:current_page>/<int:page_size>',
          views.HistoricalConversationView.PageView.as_view(),
-         name='historical_conversation')
+         name='historical_conversation'),
+    path('historical_conversation_record/<str:chat_id>', views.HistoricalConversationRecordView.as_view(),
+         name='historical_conversation_record'),
+    path('historical_conversation_record/<str:chat_id>/<int:current_page>/<int:page_size>',
+         views.HistoricalConversationRecordView.PageView.as_view(),
+         name='historical_conversation_record')
 ]

apps/chat/views/chat_record.py

@@ -11,9 +11,11 @@
 from rest_framework.request import Request
 from rest_framework.views import APIView
 
-from chat.api.chat_api import HistoricalConversationAPI, PageHistoricalConversationAPI
+from chat.api.chat_api import HistoricalConversationAPI, PageHistoricalConversationAPI, \
+    PageHistoricalConversationRecordAPI, HistoricalConversationRecordAPI
 from chat.api.vote_api import VoteAPI
-from chat.serializers.chat_record import VoteSerializer, ChatRecordSerializer
+from chat.serializers.chat_record import VoteSerializer, HistoricalConversationSerializer, \
+    HistoricalConversationRecordSerializer
 from common import result
 from common.auth import TokenAuth
 
@@ -51,7 +53,7 @@ class HistoricalConversationView(APIView):
         tags=[_('Chat')]  # type: ignore
     )
     def get(self, request: Request):
-        return result.success(ChatRecordSerializer(
+        return result.success(HistoricalConversationSerializer(
             data={
                 'application_id': request.auth.application_id,
                 'chat_user_id': request.auth.chat_user_id,
@@ -70,8 +72,49 @@ class PageView(APIView):
             tags=[_('Chat')]  # type: ignore
         )
         def get(self, request: Request, current_page: int, page_size: int):
-            return result.success(ChatRecordSerializer(
+            return result.success(HistoricalConversationSerializer(
                 data={
                     'application_id': request.auth.application_id,
                     'chat_user_id': request.auth.chat_user_id,
                 }).page(current_page, page_size))
+
+
+class HistoricalConversationRecordView(APIView):
+    authentication_classes = [TokenAuth]
+
+    @extend_schema(
+        methods=['GET'],
+        description=_("Get historical conversation records"),
+        summary=_("Get historical conversation records"),
+        operation_id=_("Get historical conversation records"),  # type: ignore
+        parameters=HistoricalConversationRecordAPI.get_parameters(),
+        responses=HistoricalConversationRecordAPI.get_response(),
+        tags=[_('Chat')]  # type: ignore
+    )
+    def get(self, request: Request, chat_id: str):
+        return result.success(HistoricalConversationRecordSerializer(
+            data={
+                'chat_id': chat_id,
+                'application_id': request.auth.application_id,
+                'chat_user_id': request.auth.chat_user_id,
+            }).list())
+
+    class PageView(APIView):
+        authentication_classes = [TokenAuth]
+
+        @extend_schema(
+            methods=['GET'],
+            description=_("Get historical conversation records by page "),
+            summary=_("Get historical conversation records by page"),
+            operation_id=_("Get historical conversation records by page"),  # type: ignore
+            parameters=PageHistoricalConversationRecordAPI.get_parameters(),
+            responses=PageHistoricalConversationRecordAPI.get_response(),
+            tags=[_('Chat')]  # type: ignore
+        )
+        def get(self, request: Request, chat_id: str, current_page: int, page_size: int):
+            return result.success(HistoricalConversationRecordSerializer(
+                data={
+                    'chat_id': chat_id,
+                    'application_id': request.auth.application_id,
+                    'chat_user_id': request.auth.chat_user_id,
+                }).page(current_page, page_size))

apps/common/auth/handle/impl/user_token.py

@@ -216,7 +216,7 @@ def get_permission_list(user,
 
 
 def reset_workspace_role(role, workspace_id):
-    if role == RoleConstants.ADMIN.value.__str__():
+    if role == RoleConstants.ADMIN.value.__str__() or workspace_id is None:
         return role
     return f"{role}:/WORKSPACE/{workspace_id}"
 

ui/src/api/chat/chat.ts

@@ -189,6 +189,18 @@ const pageChat: (
 ) => Promise<Result<boolean>> = (current_page, page_size, loading) => {
   return get(`/historical_conversation/${current_page}/${page_size}`, undefined, loading)
 }
+const pageChatRecord: (
+  chat_id: string,
+  current_page: number,
+  page_size: number,
+  loading?: Ref<boolean>,
+) => Promise<Result<boolean>> = (chat_id, current_page, page_size, loading) => {
+  return get(
+    `/historical_conversation_record/${chat_id}/${current_page}/${page_size}`,
+    undefined,
+    loading,
+  )
+}
 export default {
   open,
   chat,
@@ -208,4 +220,5 @@ export default {
   passwordAuthentication,
   vote,
   pageChat,
+  pageChatRecord,
 }