1109 lines
46 KiB
Python
1109 lines
46 KiB
Python
import logging
|
||
import json
|
||
import traceback
|
||
import uuid
|
||
from datetime import datetime
|
||
from django.db.models import Q, Max, Count
|
||
from django.http import HttpResponse, StreamingHttpResponse
|
||
from rest_framework import viewsets, status
|
||
from rest_framework.permissions import IsAuthenticated
|
||
from rest_framework.response import Response
|
||
from rest_framework.decorators import action
|
||
from apps.user.models import User
|
||
from apps.knowledge_base.models import KnowledgeBase
|
||
from apps.chat.models import ChatHistory, NegotiationChat
|
||
from apps.chat.serializers import ChatHistorySerializer
|
||
from apps.common.services.chat_service import ChatService
|
||
from apps.expertproducts.models import Negotiation
|
||
from apps.chat.services.chat_api import (
|
||
ExternalAPIError, stream_chat_answer, get_chat_answer, generate_conversation_title,
|
||
get_hit_test_documents, generate_conversation_title_from_deepseek
|
||
)
|
||
from apps.user.authentication import CustomTokenAuthentication
|
||
# from apps.permissions.services.permission_service import KnowledgeBasePermissionMixin
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# class ChatHistoryViewSet(KnowledgeBasePermissionMixin, viewsets.ModelViewSet):
|
||
class ChatHistoryViewSet(viewsets.ModelViewSet):
|
||
permission_classes = [IsAuthenticated]
|
||
authentication_classes = [CustomTokenAuthentication]
|
||
serializer_class = ChatHistorySerializer
|
||
queryset = ChatHistory.objects.all()
|
||
|
||
def check_knowledge_base_permission(self, kb, user, permission_type):
|
||
"""
|
||
兼容方法：始终返回True表示有权限
|
||
此方法替代了原来的权限检查，现在我们不再检查知识库权限
|
||
"""
|
||
return True
|
||
|
||
def get_queryset(self):
|
||
"""确保用户只能看到自己的未删除的聊天记录"""
|
||
user = self.request.user
|
||
queryset = ChatHistory.objects.filter(
|
||
user=user,
|
||
is_deleted=False
|
||
)
|
||
|
||
# 获取status筛选参数
|
||
status_filter = self.request.query_params.get('status')
|
||
if status_filter:
|
||
# 查找与谈判关联的对话ID
|
||
negotiation_chats = NegotiationChat.objects.filter(
|
||
negotiation__status=status_filter
|
||
).values_list('conversation_id', flat=True)
|
||
|
||
# 筛选这些对话ID对应的聊天记录
|
||
queryset = queryset.filter(conversation_id__in=negotiation_chats)
|
||
|
||
return queryset
|
||
|
||
def list(self, request):
|
||
"""获取对话列表概览"""
|
||
try:
|
||
page = int(request.query_params.get('page', 1))
|
||
page_size = int(request.query_params.get('page_size', 10))
|
||
|
||
latest_chats = self.get_queryset().values(
|
||
'conversation_id'
|
||
).annotate(
|
||
latest_id=Max('id'),
|
||
message_count=Count('id'),
|
||
last_message=Max('created_at')
|
||
).order_by('-last_message')
|
||
|
||
total = latest_chats.count()
|
||
start = (page - 1) * page_size
|
||
end = start + page_size
|
||
chats = latest_chats[start:end]
|
||
|
||
results = []
|
||
for chat in chats:
|
||
latest_record = ChatHistory.objects.get(id=chat['latest_id'])
|
||
dataset_info = []
|
||
if latest_record.metadata:
|
||
dataset_id_list = latest_record.metadata.get('dataset_id_list', [])
|
||
dataset_names = latest_record.metadata.get('dataset_names', [])
|
||
if dataset_id_list:
|
||
if dataset_names and len(dataset_names) == len(dataset_id_list):
|
||
dataset_info = [
|
||
{'id': str(id), 'name': name}
|
||
for id, name in zip(dataset_id_list, dataset_names)
|
||
]
|
||
else:
|
||
datasets = KnowledgeBase.objects.filter(id__in=dataset_id_list)
|
||
dataset_info = [
|
||
{'id': str(ds.id), 'name': ds.name}
|
||
for ds in datasets
|
||
]
|
||
|
||
results.append({
|
||
'conversation_id': chat['conversation_id'],
|
||
'message_count': chat['message_count'],
|
||
'last_message': latest_record.content,
|
||
'last_time': chat['last_message'].strftime('%Y-%m-%d %H:%M:%S'),
|
||
'dataset_id_list': [ds['id'] for ds in dataset_info],
|
||
'datasets': dataset_info
|
||
})
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': {
|
||
'total': total,
|
||
'page': page,
|
||
'page_size': page_size,
|
||
'results': results
|
||
}
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取聊天记录失败: {str(e)}")
|
||
import traceback
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'获取聊天记录失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
@action(detail=False, methods=['get'])
|
||
def conversation_detail(self, request):
|
||
"""获取特定对话的详细信息，并返回creator和product信息"""
|
||
try:
|
||
conversation_id = request.query_params.get('conversation_id')
|
||
if not conversation_id:
|
||
return Response({
|
||
'code': 400,
|
||
'message': '缺少conversation_id参数',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# 查找对话记录
|
||
chat_records = ChatHistory.objects.filter(
|
||
conversation_id=conversation_id,
|
||
is_deleted=False
|
||
).order_by('created_at')
|
||
|
||
if not chat_records.exists():
|
||
return Response({
|
||
'code': 404,
|
||
'message': '对话不存在或已被删除',
|
||
'data': None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
# 尝试查找关联的谈判记录
|
||
negotiation_chat = NegotiationChat.objects.filter(
|
||
conversation_id=conversation_id
|
||
).select_related('negotiation').first()
|
||
|
||
# 准备基本的返回数据
|
||
result = {
|
||
'conversation_id': conversation_id,
|
||
'messages': []
|
||
}
|
||
|
||
# 如果存在谈判关联，添加谈判相关信息
|
||
if negotiation_chat:
|
||
negotiation = negotiation_chat.negotiation
|
||
|
||
# 获取关联的达人信息
|
||
creator_id = negotiation_chat.creator_id
|
||
from apps.daren_detail.models import CreatorProfile
|
||
creator = CreatorProfile.objects.filter(id=creator_id).first()
|
||
|
||
# 获取关联的产品信息
|
||
product_id = negotiation_chat.product_id
|
||
from apps.brands.models import Product
|
||
product = Product.objects.filter(id=product_id).first()
|
||
|
||
# 添加谈判相关信息
|
||
result['negotiation'] = {
|
||
'id': str(negotiation.id),
|
||
'status': negotiation.status,
|
||
'current_round': negotiation.current_round,
|
||
'context': negotiation.context,
|
||
'creator': {
|
||
'id': creator.id if creator else None,
|
||
'name': creator.name if creator else "未知",
|
||
'email': creator.email if creator and hasattr(creator, 'email') else None
|
||
} if creator else {"id": None, "name": "未知"},
|
||
'product': {
|
||
'id': str(product.id) if product else None,
|
||
'name': product.name if product else "未知",
|
||
'description': product.description if product and hasattr(product, 'description') else "",
|
||
'brand': product.brand.name if product and hasattr(product, 'brand') else ""
|
||
} if product else {"id": None, "name": "未知"}
|
||
}
|
||
|
||
# 整理对话消息
|
||
for record in chat_records:
|
||
result['messages'].append({
|
||
'id': str(record.id),
|
||
'role': record.role,
|
||
'content': record.content,
|
||
'created_at': record.created_at.strftime('%Y-%m-%d %H:%M:%S'),
|
||
'metadata': record.metadata
|
||
})
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': result
|
||
})
|
||
|
||
except ValueError as e:
|
||
return Response({
|
||
'code': 404,
|
||
'message': str(e),
|
||
'data': None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
except Exception as e:
|
||
logger.error(f"获取对话详情失败: {str(e)}")
|
||
import traceback
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'获取对话详情失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
@action(detail=False, methods=['get'])
|
||
def available_datasets(self, request):
|
||
"""获取用户可访问的知识库列表"""
|
||
try:
|
||
user = request.user
|
||
# 直接返回所有知识库，不做权限检查
|
||
accessible_datasets = KnowledgeBase.objects.all()
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': [
|
||
{
|
||
'id': str(ds.id),
|
||
'name': ds.name,
|
||
'type': ds.type,
|
||
'department': ds.department,
|
||
'description': ds.desc
|
||
}
|
||
for ds in accessible_datasets
|
||
]
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取可用知识库列表失败: {str(e)}")
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'获取可用知识库列表失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
@action(detail=False, methods=['post'])
|
||
def create_conversation(self, request):
|
||
"""创建会话 - 关联到谈判ID"""
|
||
try:
|
||
data = request.data
|
||
|
||
# 检查谈判ID
|
||
negotiation_id = data.get('negotiation_id')
|
||
if not negotiation_id:
|
||
return Response({
|
||
'code': 400,
|
||
'message': '缺少必填字段: negotiation_id',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# 验证谈判存在性
|
||
try:
|
||
negotiation = Negotiation.objects.get(id=negotiation_id)
|
||
except Negotiation.DoesNotExist:
|
||
return Response({
|
||
'code': 404,
|
||
'message': f'谈判记录不存在: {negotiation_id}',
|
||
'data': None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
# 获取达人邮箱
|
||
creator = negotiation.creator
|
||
creator_email = creator.email if hasattr(creator, 'email') else None
|
||
|
||
# 创建一个新的会话ID
|
||
conversation_id = str(uuid.uuid4())
|
||
logger.info(f"创建新的会话ID: {conversation_id}")
|
||
|
||
# 创建谈判关联
|
||
NegotiationChat.objects.create(
|
||
negotiation=negotiation,
|
||
conversation_id=conversation_id,
|
||
creator_id=creator.id,
|
||
product_id=negotiation.product.id
|
||
)
|
||
|
||
# 准备metadata
|
||
metadata = {
|
||
'negotiation_id': str(negotiation_id),
|
||
'status': negotiation.status,
|
||
'creator_id': str(creator.id),
|
||
'creator_email': creator_email
|
||
}
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '会话创建成功',
|
||
'data': {
|
||
'conversation_id': conversation_id,
|
||
'negotiation_id': str(negotiation_id),
|
||
'status': negotiation.status,
|
||
'creator': {
|
||
'id': str(creator.id),
|
||
'name': creator.name if hasattr(creator, 'name') else "未知",
|
||
'email': creator_email
|
||
}
|
||
}
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"创建会话失败: {str(e)}")
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'创建会话失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
def create(self, request):
|
||
"""创建聊天记录"""
|
||
try:
|
||
chat_service = ChatService()
|
||
question_record, conversation_id, metadata, knowledge_bases, external_id_list = chat_service.create_chat_record(
|
||
request.user, request.data, request.data.get('conversation_id')
|
||
)
|
||
|
||
use_stream = request.data.get('stream', True)
|
||
title = request.data.get('title', 'New chat')
|
||
|
||
if use_stream:
|
||
def stream_response():
|
||
answer_record = ChatHistory.objects.create(
|
||
user=question_record.user,
|
||
knowledge_base=knowledge_bases[0],
|
||
conversation_id=conversation_id,
|
||
title=title,
|
||
parent_id=str(question_record.id),
|
||
role='assistant',
|
||
content="",
|
||
metadata=metadata
|
||
)
|
||
|
||
yield f"data: {json.dumps({'code': 200, 'message': '开始流式传输', 'data': {'id': str(answer_record.id), 'conversation_id': conversation_id, 'content': '', 'is_end': False}})}\n\n"
|
||
|
||
full_content = ""
|
||
for data in stream_chat_answer(conversation_id, request.data['question'], external_id_list, metadata):
|
||
parsed_data = json.loads(data[5:-2]) # 移除"data: "和"\n\n"
|
||
if parsed_data['code'] == 200 and 'content' in parsed_data['data']:
|
||
content_part = parsed_data['data']['content']
|
||
full_content += content_part
|
||
response_data = {
|
||
'code': 200,
|
||
'message': 'partial',
|
||
'data': {
|
||
'id': str(answer_record.id),
|
||
'conversation_id': conversation_id,
|
||
'title': title,
|
||
'content': content_part,
|
||
'is_end': parsed_data['data']['is_end']
|
||
}
|
||
}
|
||
yield f"data: {json.dumps(response_data)}\n\n"
|
||
|
||
if parsed_data['data']['is_end']:
|
||
answer_record.content = full_content.strip()
|
||
answer_record.save()
|
||
|
||
current_title = ChatHistory.objects.filter(
|
||
conversation_id=conversation_id
|
||
).exclude(
|
||
title__in=["New chat", "新对话", ""]
|
||
).values_list('title', flat=True).first()
|
||
|
||
if current_title:
|
||
title_updated = current_title
|
||
else:
|
||
try:
|
||
generated_title = generate_conversation_title(
|
||
request.data['question'], full_content.strip()
|
||
)
|
||
if generated_title:
|
||
ChatHistory.objects.filter(
|
||
conversation_id=conversation_id
|
||
).update(title=generated_title)
|
||
title_updated = generated_title
|
||
else:
|
||
title_updated = "新对话"
|
||
except ExternalAPIError as e:
|
||
logger.error(f"自动生成标题失败: {str(e)}")
|
||
title_updated = "新对话"
|
||
|
||
final_response = {
|
||
'code': 200,
|
||
'message': '完成',
|
||
'data': {
|
||
'id': str(answer_record.id),
|
||
'conversation_id': conversation_id,
|
||
'title': title_updated,
|
||
'dataset_id_list': metadata.get('dataset_id_list', []),
|
||
'dataset_names': metadata.get('dataset_names', []),
|
||
'role': 'assistant',
|
||
'content': full_content.strip(),
|
||
'created_at': answer_record.created_at.strftime('%Y-%m-%d %H:%M:%S'),
|
||
'is_end': True
|
||
}
|
||
}
|
||
yield f"data: {json.dumps(final_response)}\n\n"
|
||
break
|
||
elif parsed_data['code'] != 200:
|
||
yield data
|
||
break
|
||
|
||
if full_content:
|
||
try:
|
||
answer_record.content = full_content.strip()
|
||
answer_record.save()
|
||
except Exception as save_error:
|
||
logger.error(f"保存部分内容失败: {str(save_error)}")
|
||
|
||
response = StreamingHttpResponse(
|
||
stream_response(),
|
||
content_type='text/event-stream',
|
||
status=status.HTTP_201_CREATED
|
||
)
|
||
response['Cache-Control'] = 'no-cache, no-store'
|
||
response['Connection'] = 'keep-alive'
|
||
return response
|
||
else:
|
||
logger.info("使用非流式输出模式")
|
||
try:
|
||
answer = get_chat_answer(external_id_list, request.data['question'])
|
||
except ExternalAPIError as e:
|
||
logger.error(f"获取回答失败: {str(e)}")
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'获取回答失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
if answer is None:
|
||
return Response({
|
||
'code': 500,
|
||
'message': '获取回答失败',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
answer_record = ChatHistory.objects.create(
|
||
user=request.user,
|
||
knowledge_base=knowledge_bases[0],
|
||
conversation_id=conversation_id,
|
||
title=title,
|
||
parent_id=str(question_record.id),
|
||
role='assistant',
|
||
content=answer,
|
||
metadata=metadata
|
||
)
|
||
|
||
existing_records = ChatHistory.objects.filter(conversation_id=conversation_id)
|
||
should_generate_title = not existing_records.exclude(id=question_record.id).exists() and (not title or title == 'New chat')
|
||
if should_generate_title:
|
||
try:
|
||
generated_title = generate_conversation_title(
|
||
request.data['question'], answer
|
||
)
|
||
if generated_title:
|
||
ChatHistory.objects.filter(conversation_id=conversation_id).update(title=generated_title)
|
||
title = generated_title
|
||
except ExternalAPIError as e:
|
||
logger.error(f"自动生成标题失败: {str(e)}")
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '成功',
|
||
'data': {
|
||
'id': str(answer_record.id),
|
||
'conversation_id': conversation_id,
|
||
'title': title,
|
||
'dataset_id_list': metadata.get('dataset_id_list', []),
|
||
'dataset_names': metadata.get('dataset_names', []),
|
||
'role': 'assistant',
|
||
'content': answer,
|
||
'created_at': answer_record.created_at.strftime('%Y-%m-%d %H:%M:%S')
|
||
}
|
||
}, status=status.HTTP_201_CREATED)
|
||
|
||
except ValueError as e:
|
||
return Response({
|
||
'code': 400,
|
||
'message': str(e),
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
except Exception as e:
|
||
logger.error(f"创建聊天记录失败: {str(e)}")
|
||
import traceback
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'创建聊天记录失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
|
||
# @action(detail=False, methods=['post'])
|
||
# def hit_test(self, request):
|
||
# """获取问题与知识库文档的匹配度"""
|
||
# try:
|
||
# data = request.data
|
||
# if 'question' not in data or 'dataset_id_list' not in data or not data['dataset_id_list']:
|
||
# return Response({
|
||
# 'code': 400,
|
||
# 'message': '缺少必填字段: question 或 dataset_id_list',
|
||
# 'data': None
|
||
# }, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# question = data['question']
|
||
# dataset_ids = data['dataset_id_list']
|
||
# if not isinstance(dataset_ids, list):
|
||
# try:
|
||
# dataset_ids = json.loads(dataset_ids)
|
||
# if not isinstance(dataset_ids, list):
|
||
# dataset_ids = [dataset_ids]
|
||
# except (json.JSONDecodeError, TypeError):
|
||
# dataset_ids = [dataset_ids]
|
||
|
||
# external_id_list = []
|
||
# for kb_id in dataset_ids:
|
||
# kb = KnowledgeBase.objects.filter(id=kb_id).first()
|
||
# if not kb:
|
||
# return Response({
|
||
# 'code': 404,
|
||
# 'message': f'知识库不存在: {kb_id}',
|
||
# 'data': None
|
||
# }, status=status.HTTP_404_NOT_FOUND)
|
||
# if not self.check_knowledge_base_permission(kb, request.user, 'read'):
|
||
# return Response({
|
||
# 'code': 403,
|
||
# 'message': f'无权访问知识库: {kb.name}',
|
||
# 'data': None
|
||
# }, status=status.HTTP_403_FORBIDDEN)
|
||
# if kb.external_id:
|
||
# external_id_list.append(str(kb.external_id))
|
||
|
||
# if not external_id_list:
|
||
# return Response({
|
||
# 'code': 400,
|
||
# 'message': '没有有效的知识库external_id',
|
||
# 'data': None
|
||
# }, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# all_documents = []
|
||
# for dataset_id in external_id_list:
|
||
# try:
|
||
# doc_info = get_hit_test_documents(dataset_id, question)
|
||
# if doc_info:
|
||
# all_documents.extend(doc_info)
|
||
# except ExternalAPIError as e:
|
||
# logger.error(f"调用hit_test失败: 知识库ID={dataset_id}, 错误={str(e)}")
|
||
# continue # 宽松处理，跳过失败的知识库
|
||
|
||
# all_documents = sorted(all_documents, key=lambda x: x.get('similarity', 0), reverse=True)
|
||
# return Response({
|
||
# 'code': 200,
|
||
# 'message': '成功',
|
||
# 'data': {
|
||
# 'question': question,
|
||
# 'matched_documents': all_documents,
|
||
# 'total_count': len(all_documents)
|
||
# }
|
||
# })
|
||
|
||
# except Exception as e:
|
||
# logger.error(f"hit_test接口调用失败: {str(e)}")
|
||
# import traceback
|
||
# logger.error(traceback.format_exc())
|
||
# return Response({
|
||
# 'code': 500,
|
||
# 'message': f'hit_test接口调用失败: {str(e)}',
|
||
# 'data': None
|
||
# }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
def _highlight_keyword(self, text, keyword):
|
||
"""高亮关键词"""
|
||
if not keyword or not text:
|
||
return text
|
||
return text.replace(keyword, f'<em class="highlight">{keyword}</em>')
|
||
|
||
def update(self, request, pk=None):
|
||
"""更新聊天记录"""
|
||
try:
|
||
record = self.get_queryset().filter(id=pk).first()
|
||
if not record:
|
||
return Response({
|
||
'code': 404,
|
||
'message': '记录不存在或无权限',
|
||
'data': None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
data = request.data
|
||
updateable_fields = ['content', 'metadata']
|
||
if 'content' in data:
|
||
record.content = data['content']
|
||
if 'metadata' in data:
|
||
current_metadata = record.metadata or {}
|
||
current_metadata.update(data['metadata'])
|
||
record.metadata = current_metadata
|
||
|
||
record.save()
|
||
return Response({
|
||
'code': 200,
|
||
'message': '更新成功',
|
||
'data': {
|
||
'id': str(record.id),
|
||
'conversation_id': record.conversation_id,
|
||
'role': record.role,
|
||
'content': record.content,
|
||
'metadata': record.metadata,
|
||
'updated_at': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
||
}
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"更新聊天记录失败: {str(e)}")
|
||
import traceback
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'更新聊天记录失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
def destroy(self, request, pk=None):
|
||
"""删除聊天记录（软删除）"""
|
||
try:
|
||
record = self.get_queryset().filter(id=pk).first()
|
||
if not record:
|
||
return Response({
|
||
'code': 404,
|
||
'message': '记录不存在或无权限',
|
||
'data': None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
record.soft_delete()
|
||
return Response({
|
||
'code': 200,
|
||
'message': '删除成功',
|
||
'data': None
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"删除聊天记录失败: {str(e)}")
|
||
import traceback
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'删除聊天记录失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
@action(detail=False, methods=['get'])
|
||
def search(self, request):
|
||
"""搜索聊天记录"""
|
||
try:
|
||
keyword = request.query_params.get('keyword', '').strip()
|
||
dataset_id = request.query_params.get('dataset_id')
|
||
start_date = request.query_params.get('start_date')
|
||
end_date = request.query_params.get('end_date')
|
||
page = int(request.query_params.get('page', 1))
|
||
page_size = int(request.query_params.get('page_size', 10))
|
||
|
||
# 获取status筛选参数
|
||
status_filter = request.query_params.get('status')
|
||
|
||
query = self.get_queryset()
|
||
if keyword:
|
||
query = query.filter(
|
||
Q(content__icontains=keyword) |
|
||
Q(knowledge_base__name__icontains=keyword)
|
||
)
|
||
if dataset_id:
|
||
# 移除权限检查，直接筛选知识库ID
|
||
query = query.filter(knowledge_base__id=dataset_id)
|
||
|
||
# 添加status筛选条件
|
||
if status_filter:
|
||
# 查找与谈判关联的对话ID
|
||
negotiation_chats = NegotiationChat.objects.filter(
|
||
negotiation__status=status_filter
|
||
).values_list('conversation_id', flat=True)
|
||
|
||
# 筛选这些对话ID对应的聊天记录
|
||
query = query.filter(conversation_id__in=negotiation_chats)
|
||
|
||
if start_date:
|
||
query = query.filter(created_at__gte=start_date)
|
||
if end_date:
|
||
query = query.filter(created_at__lte=end_date)
|
||
|
||
total = query.count()
|
||
start = (page - 1) * page_size
|
||
end = start + page_size
|
||
records = query.order_by('-created_at')[start:end]
|
||
|
||
results = [
|
||
{
|
||
'id': str(record.id),
|
||
'conversation_id': record.conversation_id,
|
||
'dataset_id': str(record.knowledge_base.id),
|
||
'dataset_name': record.knowledge_base.name,
|
||
'role': record.role,
|
||
'content': record.content,
|
||
'created_at': record.created_at.strftime('%Y-%m-%d %H:%M:%S'),
|
||
'metadata': record.metadata,
|
||
'highlights': {'content': self._highlight_keyword(record.content, keyword)} if keyword else {}
|
||
}
|
||
for record in records
|
||
]
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '搜索成功',
|
||
'data': {
|
||
'total': total,
|
||
'page': page,
|
||
'page_size': page_size,
|
||
'results': results
|
||
}
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"搜索聊天记录失败: {str(e)}")
|
||
import traceback
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'搜索失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
@action(detail=False, methods=['delete'])
|
||
def delete_conversation(self, request):
|
||
"""通过conversation_id删除一组会话"""
|
||
try:
|
||
conversation_id = request.query_params.get('conversation_id')
|
||
if not conversation_id:
|
||
return Response({
|
||
'code': 400,
|
||
'message': '缺少必要参数: conversation_id',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
records = self.get_queryset().filter(conversation_id=conversation_id)
|
||
if not records.exists():
|
||
return Response({
|
||
'code': 404,
|
||
'message': '未找到该会话或无权限访问',
|
||
'data': None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
records_count = records.count()
|
||
for record in records:
|
||
record.soft_delete()
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '删除成功',
|
||
'data': {
|
||
'conversation_id': conversation_id,
|
||
'deleted_count': records_count
|
||
}
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"删除会话失败: {str(e)}")
|
||
import traceback
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'删除会话失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
@action(detail=False, methods=['get'], url_path='generate-conversation-title')
|
||
def generate_conversation_title(self, request):
|
||
"""更新会话标题"""
|
||
try:
|
||
conversation_id = request.query_params.get('conversation_id')
|
||
if not conversation_id:
|
||
return Response({
|
||
'code': 400,
|
||
'message': '缺少conversation_id参数',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# 检查对话是否存在
|
||
messages = self.get_queryset().filter(
|
||
conversation_id=conversation_id,
|
||
is_deleted=False,
|
||
user=request.user
|
||
).order_by('created_at')
|
||
|
||
if not messages.exists():
|
||
return Response({
|
||
'code': 404,
|
||
'message': '对话不存在或无权访问',
|
||
'data': None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
# 检查是否有自定义标题参数
|
||
custom_title = request.query_params.get('title')
|
||
if not custom_title:
|
||
return Response({
|
||
'code': 400,
|
||
'message': '缺少title参数',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# 更新所有相关记录的标题
|
||
ChatHistory.objects.filter(
|
||
conversation_id=conversation_id,
|
||
user=request.user
|
||
).update(title=custom_title)
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '更新会话标题成功',
|
||
'data': {
|
||
'conversation_id': conversation_id,
|
||
'title': custom_title
|
||
}
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"更新会话标题失败: {str(e)}")
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f"更新会话标题失败: {str(e)}",
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
@action(detail=False, methods=['post'])
|
||
def send_email_to_creator(self, request):
|
||
"""通过对话ID发送邮件给达人"""
|
||
try:
|
||
data = request.data
|
||
conversation_id = data.get('conversation_id')
|
||
|
||
if not conversation_id:
|
||
return Response({
|
||
'code': 400,
|
||
'message': '缺少必填字段: conversation_id',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# 验证邮件参数
|
||
subject = data.get('subject', '') # 设置默认主题
|
||
body = data.get('body')
|
||
from_email = data.get('from_email')
|
||
|
||
if not all([body, from_email]):
|
||
return Response({
|
||
'code': 400,
|
||
'message': '缺少必要的邮件参数，请提供body和from_email字段',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# 查找关联的谈判聊天记录
|
||
negotiation_chat = NegotiationChat.objects.filter(
|
||
conversation_id=conversation_id
|
||
).first()
|
||
|
||
if not negotiation_chat:
|
||
return Response({
|
||
'code': 404,
|
||
'message': f'找不到与对话ID关联的谈判聊天记录: {conversation_id}',
|
||
'data': None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
# 获取达人ID并查询达人信息
|
||
creator_id = negotiation_chat.creator_id
|
||
from apps.daren_detail.models import CreatorProfile
|
||
creator = CreatorProfile.objects.filter(id=creator_id).first()
|
||
|
||
if not creator:
|
||
return Response({
|
||
'code': 404,
|
||
'message': f'找不到达人信息: {creator_id}',
|
||
'data': None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
# 获取达人邮箱
|
||
creator_email = creator.email
|
||
|
||
if not creator_email:
|
||
return Response({
|
||
'code': 404,
|
||
'message': '达人没有关联的邮箱地址',
|
||
'data': None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
# 处理附件
|
||
attachments = []
|
||
for file_key, file_obj in request.FILES.items():
|
||
if file_obj:
|
||
# 保存临时文件
|
||
import os
|
||
from django.conf import settings
|
||
|
||
tmp_path = os.path.join(settings.MEDIA_ROOT, 'tmp', f'{file_key}_{file_obj.name}')
|
||
os.makedirs(os.path.dirname(tmp_path), exist_ok=True)
|
||
|
||
with open(tmp_path, 'wb+') as destination:
|
||
for chunk in file_obj.chunks():
|
||
destination.write(chunk)
|
||
|
||
attachments.append({
|
||
'path': tmp_path,
|
||
'filename': file_obj.name
|
||
})
|
||
|
||
# 直接调用Gmail服务发送邮件，而不是通过视图
|
||
from apps.gmail.services.gmail_service import GmailService
|
||
|
||
success, result = GmailService.send_email(
|
||
request.user,
|
||
from_email,
|
||
creator_email,
|
||
subject or f'与{creator.name}的谈判',
|
||
body or '',
|
||
attachments
|
||
)
|
||
|
||
if success:
|
||
# 发送成功后，将邮件记录添加到对话历史
|
||
# 查询一个有效的知识库ID
|
||
default_kb = KnowledgeBase.objects.first()
|
||
if not default_kb:
|
||
logger.warning("未找到有效的知识库，无法记录邮件发送历史")
|
||
# 返回成功但提示无法记录历史
|
||
return Response({
|
||
'code': 200,
|
||
'message': '邮件发送成功，但未能记录到对话历史',
|
||
'data': {
|
||
'conversation_id': conversation_id,
|
||
'creator_email': creator_email,
|
||
'creator_name': creator.name,
|
||
'message_id': result
|
||
}
|
||
})
|
||
|
||
ChatHistory.objects.create(
|
||
user=request.user,
|
||
knowledge_base=default_kb, # 使用查询到的默认知识库
|
||
conversation_id=conversation_id,
|
||
role='system',
|
||
content=f"发送邮件给 {creator.name}: {subject}\n\n{body}",
|
||
metadata={
|
||
'email_sent': True,
|
||
'to': creator_email,
|
||
'from': from_email,
|
||
'subject': subject,
|
||
'negotiation_id': str(negotiation_chat.negotiation.id) if negotiation_chat.negotiation else None,
|
||
'status': negotiation_chat.negotiation.status if negotiation_chat.negotiation else None,
|
||
'has_attachments': len(attachments) > 0
|
||
}
|
||
)
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '邮件发送成功',
|
||
'data': {
|
||
'conversation_id': conversation_id,
|
||
'creator_email': creator_email,
|
||
'creator_name': creator.name,
|
||
'message_id': result
|
||
}
|
||
})
|
||
else:
|
||
# 返回发送失败信息
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'邮件发送失败: {result}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
except Exception as e:
|
||
logger.error(f"发送邮件给达人失败: {str(e)}")
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'发送邮件给达人失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
@action(detail=False, methods=['get'])
|
||
def get_negotiation_chats(self, request):
|
||
"""获取谈判聊天列表，返回NegotiationChat表的数据及关联的达人和产品信息"""
|
||
try:
|
||
# 获取分页和筛选参数
|
||
page = int(request.query_params.get('page', 1))
|
||
page_size = int(request.query_params.get('page_size', 10))
|
||
status_filter = request.query_params.get('status')
|
||
|
||
# 查询NegotiationChat表
|
||
query = NegotiationChat.objects.all().select_related('negotiation')
|
||
|
||
# 如果提供了status参数，则过滤谈判状态
|
||
if status_filter:
|
||
query = query.filter(negotiation__status=status_filter)
|
||
|
||
# 获取总数量
|
||
total = query.count()
|
||
|
||
# 分页
|
||
start = (page - 1) * page_size
|
||
end = start + page_size
|
||
chats = query.order_by('-updated_at')[start:end]
|
||
|
||
results = []
|
||
for chat in chats:
|
||
# 获取关联的谈判
|
||
negotiation = chat.negotiation
|
||
|
||
# 获取关联的达人信息
|
||
creator_id = chat.creator_id
|
||
from apps.daren_detail.models import CreatorProfile
|
||
creator = CreatorProfile.objects.filter(id=creator_id).first()
|
||
|
||
# 获取关联的产品信息
|
||
product_id = chat.product_id
|
||
from apps.brands.models import Product
|
||
product = Product.objects.filter(id=product_id).first()
|
||
|
||
# 获取最新的聊天记录
|
||
latest_message = ChatHistory.objects.filter(
|
||
conversation_id=chat.conversation_id,
|
||
is_deleted=False
|
||
).order_by('-created_at').first()
|
||
|
||
# 计算聊天记录数量
|
||
message_count = ChatHistory.objects.filter(
|
||
conversation_id=chat.conversation_id,
|
||
is_deleted=False
|
||
).count()
|
||
|
||
# 构建响应数据
|
||
chat_data = {
|
||
'conversation_id': chat.conversation_id,
|
||
'negotiation_id': str(negotiation.id),
|
||
'negotiation_status': negotiation.status,
|
||
'current_round': negotiation.current_round,
|
||
'context': negotiation.context,
|
||
'creator': {
|
||
'id': creator.id if creator else None,
|
||
'name': creator.name if creator else "未知",
|
||
'email': creator.email if creator and hasattr(creator, 'email') else None,
|
||
} if creator else {"id": None, "name": "未知"},
|
||
'product': {
|
||
'id': str(product.id) if product else None,
|
||
'name': product.name if product else "未知",
|
||
'description': product.description if product and hasattr(product, 'description') else "",
|
||
'brand': product.brand.name if product and hasattr(product, 'brand') else ""
|
||
} if product else {"id": None, "name": "未知"},
|
||
'message_count': message_count,
|
||
'last_message': latest_message.content if latest_message else '',
|
||
'last_time': latest_message.created_at.strftime('%Y-%m-%d %H:%M:%S') if latest_message else chat.updated_at.strftime('%Y-%m-%d %H:%M:%S'),
|
||
'created_at': chat.created_at.strftime('%Y-%m-%d %H:%M:%S'),
|
||
'updated_at': chat.updated_at.strftime('%Y-%m-%d %H:%M:%S')
|
||
}
|
||
results.append(chat_data)
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '获取成功',
|
||
'data': {
|
||
'total': total,
|
||
'page': page,
|
||
'page_size': page_size,
|
||
'results': results
|
||
}
|
||
})
|
||
|
||
except Exception as e:
|
||
logger.error(f"获取谈判聊天列表失败: {str(e)}")
|
||
import traceback
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
'code': 500,
|
||
'message': f'获取谈判聊天列表失败: {str(e)}',
|
||
'data': None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|