1270 lines
52 KiB
Python
1270 lines
52 KiB
Python
# apps/knowledge_base/views.py
|
||
import logging
|
||
import json
|
||
import traceback
|
||
from django.db.models import Q
|
||
from django.db import transaction
|
||
from django.utils import timezone
|
||
from django.http import Http404
|
||
from rest_framework import viewsets, status
|
||
from rest_framework.response import Response
|
||
from rest_framework.permissions import IsAuthenticated
|
||
from rest_framework.decorators import action
|
||
import requests
|
||
from apps.accounts.models import User
|
||
from apps.knowledge_base.models import KnowledgeBase, KnowledgeBaseDocument
|
||
from apps.permissions.models import KnowledgeBasePermission as KBPermissionModel
|
||
from apps.permissions.services.permission_service import KnowledgeBasePermissionMixin
|
||
from apps.knowledge_base.serializers import KnowledgeBaseSerializer, KnowledgeBaseDocumentSerializer
|
||
from apps.common.services.external_api_service import (
|
||
create_external_dataset, delete_external_dataset, call_split_api_multiple,
|
||
call_upload_api, call_delete_document_api, ExternalAPIError,
|
||
get_external_document_list, get_external_document_paragraphs,
|
||
call_delete_document_api
|
||
)
|
||
from daren_project import settings
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
class KnowledgeBaseViewSet(KnowledgeBasePermissionMixin, viewsets.ModelViewSet):
|
||
serializer_class = KnowledgeBaseSerializer
|
||
permission_classes = [IsAuthenticated]
|
||
|
||
def list(self, request, *args, **kwargs):
|
||
try:
|
||
queryset = self.get_queryset()
|
||
keyword = request.query_params.get('keyword', '')
|
||
|
||
if keyword:
|
||
query = Q(name__icontains=keyword) | Q(desc__icontains=keyword) | \
|
||
Q(department__icontains=keyword) | Q(group__icontains=keyword)
|
||
queryset = queryset.filter(query)
|
||
|
||
try:
|
||
page = int(request.query_params.get('page', 1))
|
||
page_size = int(request.query_params.get('page_size', 10))
|
||
except ValueError:
|
||
page = 1
|
||
page_size = 10
|
||
|
||
total = queryset.count()
|
||
start = (page - 1) * page_size
|
||
end = start + page_size
|
||
paginated_queryset = queryset[start:end]
|
||
|
||
serializer = self.get_serializer(paginated_queryset, many=True)
|
||
data = serializer.data
|
||
user = request.user
|
||
|
||
for item in data:
|
||
kb_type = item['type']
|
||
department = item.get('department')
|
||
group = item.get('group')
|
||
creator_id = item.get('user_id')
|
||
kb_id = item['id']
|
||
|
||
explicit_permission = KBPermissionModel.objects.filter(
|
||
knowledge_base_id=kb_id,
|
||
user=user,
|
||
status='active'
|
||
).first()
|
||
|
||
if explicit_permission:
|
||
item['permissions'] = {
|
||
'can_read': explicit_permission.can_read,
|
||
'can_edit': explicit_permission.can_edit,
|
||
'can_delete': explicit_permission.can_delete
|
||
}
|
||
item['expires_at'] = explicit_permission.expires_at.strftime("%Y-%m-%d %H:%M:%S") if explicit_permission.expires_at else None
|
||
else:
|
||
item['permissions'] = {
|
||
'can_read': self._can_read(kb_type, user, department, group, creator_id, kb_id),
|
||
'can_edit': self._can_edit(kb_type, user, department, group, creator_id, kb_id),
|
||
'can_delete': self._can_delete(kb_type, user, department, group, creator_id, kb_id)
|
||
}
|
||
item['expires_at'] = None if kb_type == 'admin' else None
|
||
|
||
if keyword:
|
||
if 'name' in item and keyword.lower() in item['name'].lower():
|
||
item['highlighted_name'] = item['name'].replace(
|
||
keyword, f'<em class="highlight">{keyword}</em>'
|
||
)
|
||
if 'desc' in item and item.get('desc') is not None:
|
||
desc_text = str(item['desc'])
|
||
if keyword.lower() in desc_text.lower():
|
||
item['highlighted_desc'] = desc_text.replace(
|
||
keyword, f'<em class="highlight">{keyword}</em>'
|
||
)
|
||
|
||
return Response({
|
||
"code": 200,
|
||
"message": "获取知识库列表成功",
|
||
"data": {
|
||
"total": total,
|
||
"page": page,
|
||
"page_size": page_size,
|
||
"keyword": keyword if keyword else None,
|
||
"items": data
|
||
}
|
||
})
|
||
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 get_queryset(self):
|
||
user = self.request.user
|
||
queryset = KnowledgeBase.objects.all()
|
||
permission_conditions = Q()
|
||
|
||
permission_conditions |= Q(type='admin')
|
||
permission_conditions |= Q(user_id=user.id)
|
||
|
||
active_permissions = KBPermissionModel.objects.filter(
|
||
user=user,
|
||
can_read=True,
|
||
status='active',
|
||
expires_at__gt=timezone.now()
|
||
).values_list('knowledge_base_id', flat=True)
|
||
|
||
if active_permissions:
|
||
permission_conditions |= Q(id__in=active_permissions)
|
||
|
||
if user.role == 'admin':
|
||
permission_conditions |= ~Q(type='private') | Q(user_id=user.id)
|
||
elif user.role == 'leader':
|
||
permission_conditions |= Q(type__in=['leader', 'member'], department=user.department)
|
||
elif user.role in ['member', 'user']:
|
||
permission_conditions |= Q(type='leader', department=user.department)
|
||
permission_conditions |= Q(type='member', department=user.department, group=user.group)
|
||
|
||
return queryset.filter(permission_conditions).distinct()
|
||
|
||
def create(self, request, *args, **kwargs):
|
||
try:
|
||
name = request.data.get('name')
|
||
if not name:
|
||
return Response({
|
||
'code': 400,
|
||
'message': '知识库名称不能为空',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
if KnowledgeBase.objects.filter(name=name).exists():
|
||
return Response({
|
||
'code': 400,
|
||
'message': f'知识库名称 "{name}" 已存在',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
user = request.user
|
||
type = request.data.get('type', 'private')
|
||
department = request.data.get('department')
|
||
group = request.data.get('group')
|
||
|
||
if type == 'admin':
|
||
department = None
|
||
group = None
|
||
elif type == 'secret':
|
||
if user.role != 'admin':
|
||
return Response({
|
||
'code': 403,
|
||
'message': '只有管理员可以创建保密级知识库',
|
||
'data': None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
department = None
|
||
group = None
|
||
elif type == 'leader':
|
||
if user.role != 'admin':
|
||
return Response({
|
||
'code': 403,
|
||
'message': '只有管理员可以创建组长级知识库',
|
||
'data': None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
if not department:
|
||
return Response({
|
||
'code': 400,
|
||
'message': '创建组长级知识库时必须指定部门',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
elif type == 'member':
|
||
if user.role not in ['admin', 'leader']:
|
||
return Response({
|
||
'code': 403,
|
||
'message': '只有管理员和组长可以创建成员级知识库',
|
||
'data': None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
if user.role == 'admin' and not department:
|
||
return Response({
|
||
'code': 400,
|
||
'message': '管理员创建成员知识库时必须指定部门',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
elif user.role == 'leader':
|
||
department = user.department
|
||
if not group:
|
||
return Response({
|
||
'code': 400,
|
||
'message': '创建成员知识库时必须指定组',
|
||
'data': None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
elif type == 'private':
|
||
department = None
|
||
group = None
|
||
|
||
data = request.data.copy()
|
||
data['department'] = department
|
||
data['group'] = group
|
||
|
||
serializer = self.get_serializer(data=data, context={'request': request})
|
||
if not serializer.is_valid():
|
||
logger.error(f"数据验证失败: {serializer.errors}")
|
||
return Response({
|
||
'code': 400,
|
||
'message': '数据验证失败',
|
||
'data': serializer.errors
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
with transaction.atomic():
|
||
knowledge_base = serializer.save()
|
||
logger.info(f"知识库创建成功: id={knowledge_base.id}, name={knowledge_base.name}, user_id={knowledge_base.user_id}")
|
||
|
||
external_id = create_external_dataset(knowledge_base)
|
||
logger.info(f"外部知识库创建成功，获取ID: {external_id}")
|
||
|
||
knowledge_base.external_id = external_id
|
||
knowledge_base.save()
|
||
logger.info(f"更新knowledge_base的external_id为: {external_id}")
|
||
|
||
KBPermissionModel.objects.create(
|
||
knowledge_base=knowledge_base,
|
||
user=request.user,
|
||
can_read=True,
|
||
can_edit=True,
|
||
can_delete=True,
|
||
granted_by=request.user,
|
||
status='active'
|
||
)
|
||
logger.info(f"创建者权限创建成功")
|
||
|
||
permissions = []
|
||
if type == 'admin':
|
||
users_query = User.objects.exclude(id=request.user.id)
|
||
permissions = [
|
||
KBPermissionModel(
|
||
knowledge_base=knowledge_base,
|
||
user=user,
|
||
can_read=True,
|
||
can_edit=True,
|
||
can_delete=True,
|
||
granted_by=request.user,
|
||
status='active'
|
||
) for user in users_query
|
||
]
|
||
elif type == 'secret':
|
||
users_query = User.objects.filter(role='admin').exclude(id=request.user.id)
|
||
permissions = [
|
||
KBPermissionModel(
|
||
knowledge_base=knowledge_base,
|
||
user=user,
|
||
can_read=True,
|
||
can_edit=self._can_edit(type, user),
|
||
can_delete=self._can_delete(type, user),
|
||
granted_by=request.user,
|
||
status='active'
|
||
) for user in users_query
|
||
]
|
||
elif type == 'leader':
|
||
users_query = User.objects.filter(
|
||
Q(role='admin') | Q(role='leader', department=department)
|
||
).exclude(id=request.user.id)
|
||
permissions = [
|
||
KBPermissionModel(
|
||
knowledge_base=knowledge_base,
|
||
user=user,
|
||
can_read=True,
|
||
can_edit=self._can_edit(type, user),
|
||
can_delete=self._can_delete(type, user),
|
||
granted_by=request.user,
|
||
status='active'
|
||
) for user in users_query
|
||
]
|
||
elif type == 'member':
|
||
users_query = User.objects.filter(
|
||
Q(role='admin') | Q(department=department, role='leader') |
|
||
Q(department=department, group=group, role='member')
|
||
).exclude(id=request.user.id)
|
||
permissions = [
|
||
KBPermissionModel(
|
||
knowledge_base=knowledge_base,
|
||
user=user,
|
||
can_read=True,
|
||
can_edit=self._can_edit(type, user),
|
||
can_delete=self._can_delete(type, user),
|
||
granted_by=request.user,
|
||
status='active'
|
||
) for user in users_query
|
||
]
|
||
|
||
if permissions:
|
||
KBPermissionModel.objects.bulk_create(permissions)
|
||
logger.info(f"{type}类型权限创建完成: {len(permissions)}条记录")
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '知识库创建成功',
|
||
'data': {
|
||
'knowledge_base': serializer.data,
|
||
'external_id': knowledge_base.external_id
|
||
}
|
||
})
|
||
|
||
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)
|
||
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 update(self, request, *args, **kwargs):
|
||
try:
|
||
instance = self.get_object()
|
||
user = request.user
|
||
|
||
if not self.check_knowledge_base_permission(instance, user, 'edit'):
|
||
return Response({
|
||
"code": 403,
|
||
"message": "没有编辑权限",
|
||
"data": None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
|
||
with transaction.atomic():
|
||
serializer = self.get_serializer(instance, data=request.data, partial=True)
|
||
serializer.is_valid(raise_exception=True)
|
||
self.perform_update(serializer)
|
||
|
||
if instance.external_id:
|
||
try:
|
||
api_data = {
|
||
"name": serializer.validated_data.get('name', instance.name),
|
||
"desc": serializer.validated_data.get('desc', instance.desc),
|
||
"type": "0",
|
||
"meta": {},
|
||
"documents": []
|
||
}
|
||
|
||
response = requests.put(
|
||
f'{settings.API_BASE_URL}/api/dataset/{instance.external_id}',
|
||
json=api_data,
|
||
headers={'Content-Type': 'application/json'},
|
||
)
|
||
|
||
if response.status_code != 200:
|
||
raise ExternalAPIError(f"更新外部知识库失败，状态码: {response.status_code}, 响应: {response.text}")
|
||
|
||
api_response = response.json()
|
||
if not api_response.get('code') == 200:
|
||
raise ExternalAPIError(f"更新外部知识库失败: {api_response.get('message', '未知错误')}")
|
||
|
||
logger.info(f"外部知识库更新成功: {instance.external_id}")
|
||
|
||
except requests.exceptions.Timeout:
|
||
raise ExternalAPIError("请求超时，请稍后重试")
|
||
except requests.exceptions.RequestException as e:
|
||
raise ExternalAPIError(f"API请求失败: {str(e)}")
|
||
except Exception as e:
|
||
raise ExternalAPIError(f"更新外部知识库失败: {str(e)}")
|
||
|
||
return Response({
|
||
"code": 200,
|
||
"message": "知识库更新成功",
|
||
"data": serializer.data
|
||
})
|
||
|
||
except Http404:
|
||
return Response({
|
||
"code": 404,
|
||
"message": "知识库不存在",
|
||
"data": None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
except ExternalAPIError as e:
|
||
logger.error(f"更新外部知识库失败: {str(e)}")
|
||
logger.error(traceback.format_exc())
|
||
return Response({
|
||
"code": 500,
|
||
"message": str(e),
|
||
"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)
|
||
|
||
def destroy(self, request, *args, **kwargs):
|
||
try:
|
||
instance = self.get_object()
|
||
user = request.user
|
||
|
||
if not self.check_knowledge_base_permission(instance, user, 'delete'):
|
||
return Response({
|
||
"code": 403,
|
||
"message": "没有删除权限",
|
||
"data": None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
|
||
external_delete_success = True
|
||
external_error_message = None
|
||
if instance.external_id:
|
||
external_delete_success = delete_external_dataset(instance.external_id)
|
||
if not external_delete_success:
|
||
external_error_message = "外部知识库删除失败"
|
||
logger.warning(f"外部知识库删除失败，将继续删除本地知识库: {external_error_message}")
|
||
|
||
self.perform_destroy(instance)
|
||
logger.info(f"本地知识库删除成功: id={instance.id}, name={instance.name}")
|
||
|
||
if not external_delete_success:
|
||
return Response({
|
||
"code": 200,
|
||
"message": f"知识库已删除，但外部知识库删除失败: {external_error_message}",
|
||
"data": None
|
||
})
|
||
|
||
return Response({
|
||
"code": 200,
|
||
"message": "知识库删除成功",
|
||
"data": None
|
||
})
|
||
|
||
except Http404:
|
||
return Response({
|
||
"code": 404,
|
||
"message": "知识库不存在",
|
||
"data": None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
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=True, methods=['get'])
|
||
def permissions(self, request, pk=None):
|
||
try:
|
||
instance = self.get_object()
|
||
user = request.user
|
||
|
||
permissions_data = {
|
||
"can_read": self.check_knowledge_base_permission(instance, user, 'read'),
|
||
"can_edit": self.check_knowledge_base_permission(instance, user, 'edit'),
|
||
"can_delete": self.check_knowledge_base_permission(instance, user, 'delete')
|
||
}
|
||
|
||
return Response({
|
||
"code": 200,
|
||
"message": "获取权限信息成功",
|
||
"data": {
|
||
"knowledge_base_id": instance.id,
|
||
"knowledge_base_name": instance.name,
|
||
"permissions": permissions_data
|
||
}
|
||
})
|
||
|
||
except Http404:
|
||
return Response({
|
||
"code": 404,
|
||
"message": "知识库不存在",
|
||
"data": None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
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 summary(self, request):
|
||
try:
|
||
user = request.user
|
||
queryset = KnowledgeBase.objects.exclude(type='secret')
|
||
summaries = []
|
||
|
||
for kb in queryset:
|
||
permissions = {
|
||
'can_read': self.check_knowledge_base_permission(kb, user, 'read'),
|
||
'can_edit': self.check_knowledge_base_permission(kb, user, 'edit'),
|
||
'can_delete': self.check_knowledge_base_permission(kb, user, 'delete')
|
||
}
|
||
|
||
explicit_permission = KBPermissionModel.objects.filter(
|
||
knowledge_base_id=kb.id,
|
||
user=user,
|
||
status='active'
|
||
).first()
|
||
|
||
expires_at = None
|
||
if explicit_permission:
|
||
expires_at = explicit_permission.expires_at.strftime("%Y-%m-%d %H:%M:%S") if explicit_permission.expires_at else None
|
||
elif kb.type == 'admin':
|
||
expires_at = None
|
||
|
||
summary = {
|
||
'id': str(kb.id),
|
||
'name': kb.name,
|
||
'desc': kb.desc,
|
||
'type': kb.type,
|
||
'department': kb.department,
|
||
'permissions': permissions,
|
||
'expires_at': expires_at
|
||
}
|
||
summaries.append(summary)
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '获取知识库概要信息成功',
|
||
'data': summaries
|
||
})
|
||
|
||
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 retrieve(self, request, *args, **kwargs):
|
||
try:
|
||
instance = self.get_object()
|
||
serializer = self.get_serializer(instance)
|
||
data = serializer.data
|
||
user = request.user
|
||
|
||
data['permissions'] = {
|
||
'can_read': self.check_knowledge_base_permission(instance, user, 'read'),
|
||
'can_edit': self.check_knowledge_base_permission(instance, user, 'edit'),
|
||
'can_delete': self.check_knowledge_base_permission(instance, user, 'delete')
|
||
}
|
||
|
||
explicit_permission = KBPermissionModel.objects.filter(
|
||
knowledge_base_id=instance.id,
|
||
user=user,
|
||
status='active'
|
||
).first()
|
||
|
||
if explicit_permission:
|
||
data['expires_at'] = explicit_permission.expires_at.strftime("%Y-%m-%d %H:%M:%S") if explicit_permission.expires_at else None
|
||
else:
|
||
data['expires_at'] = None if instance.type == 'admin' else None
|
||
|
||
return Response({
|
||
'code': 200,
|
||
'message': '获取知识库详情成功',
|
||
'data': data
|
||
})
|
||
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 search(self, request):
|
||
try:
|
||
keyword = request.query_params.get('keyword', '')
|
||
if not keyword:
|
||
return Response({
|
||
"code": 400,
|
||
"message": "搜索关键字不能为空",
|
||
"data": None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
try:
|
||
page = int(request.query_params.get('page', 1))
|
||
page_size = int(request.query_params.get('page_size', 10))
|
||
except ValueError:
|
||
page = 1
|
||
page_size = 10
|
||
|
||
query = Q(name__icontains=keyword) | Q(desc__icontains=keyword) | \
|
||
Q(department__icontains=keyword) | Q(group__icontains=keyword)
|
||
|
||
queryset = KnowledgeBase.objects.filter(query).exclude(type='secret')
|
||
user = request.user
|
||
|
||
active_permissions = KBPermissionModel.objects.filter(
|
||
user=user,
|
||
status='active',
|
||
expires_at__gt=timezone.now()
|
||
).select_related('knowledge_base')
|
||
|
||
permission_map = {
|
||
str(perm.knowledge_base.id): {
|
||
'can_read': perm.can_read,
|
||
'can_edit': perm.can_edit,
|
||
'can_delete': perm.can_delete
|
||
}
|
||
for perm in active_permissions
|
||
}
|
||
|
||
total = queryset.count()
|
||
start = (page - 1) * page_size
|
||
end = start + page_size
|
||
paginated_queryset = queryset[start:end]
|
||
|
||
serializer = self.get_serializer(paginated_queryset, many=True)
|
||
data = serializer.data
|
||
result_items = []
|
||
|
||
for item in data:
|
||
temp_kb = KnowledgeBase(
|
||
id=item['id'],
|
||
type=item['type'],
|
||
department=item.get('department'),
|
||
group=item.get('group'),
|
||
user_id=item.get('user_id')
|
||
)
|
||
|
||
explicit_permission = KBPermissionModel.objects.filter(
|
||
knowledge_base_id=item['id'],
|
||
user=user,
|
||
status='active'
|
||
).first()
|
||
|
||
if explicit_permission:
|
||
kb_permissions = {
|
||
'can_read': explicit_permission.can_read,
|
||
'can_edit': explicit_permission.can_edit,
|
||
'can_delete': explicit_permission.can_delete
|
||
}
|
||
item['expires_at'] = explicit_permission.expires_at.strftime("%Y-%m-%d %H:%M:%S") if explicit_permission.expires_at else None
|
||
else:
|
||
kb_permissions = {
|
||
'can_read': self.check_knowledge_base_permission(temp_kb, user, 'read'),
|
||
'can_edit': self.check_knowledge_base_permission(temp_kb, user, 'edit'),
|
||
'can_delete': self.check_knowledge_base_permission(temp_kb, user, 'delete')
|
||
}
|
||
item['expires_at'] = None if item['type'] == 'admin' else None
|
||
|
||
item['permissions'] = kb_permissions
|
||
|
||
if kb_permissions['can_read']:
|
||
result_items.append(item)
|
||
else:
|
||
summary_info = {
|
||
'id': item['id'],
|
||
'name': item['name'],
|
||
'type': item['type'],
|
||
'department': item.get('department'),
|
||
'permissions': kb_permissions
|
||
}
|
||
result_items.append(summary_info)
|
||
|
||
if 'name' in item and keyword.lower() in item['name'].lower():
|
||
item['highlighted_name'] = item['name'].replace(
|
||
keyword, f'<em class="highlight">{keyword}</em>'
|
||
)
|
||
if 'desc' in item and item.get('desc') is not None:
|
||
desc_text = str(item['desc'])
|
||
if keyword.lower() in desc_text.lower():
|
||
item['highlighted_desc'] = desc_text.replace(
|
||
keyword, f'<em class="highlight">{keyword}</em>'
|
||
)
|
||
|
||
return Response({
|
||
"code": 200,
|
||
"message": "搜索知识库成功",
|
||
"data": {
|
||
"total": total,
|
||
"page": page,
|
||
"page_size": page_size,
|
||
"keyword": keyword,
|
||
"items": result_items
|
||
}
|
||
})
|
||
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=True, methods=['post'])
|
||
def change_type(self, request, pk=None):
|
||
try:
|
||
instance = self.get_object()
|
||
user = request.user
|
||
|
||
if not self.check_knowledge_base_permission(instance, user, 'edit'):
|
||
return Response({
|
||
"code": 403,
|
||
"message": "没有修改权限",
|
||
"data": None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
|
||
new_type = request.data.get('type')
|
||
if not new_type:
|
||
return Response({
|
||
"code": 400,
|
||
"message": "新类型不能为空",
|
||
"data": None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
valid_types = ['private', 'admin', 'secret', 'leader', 'member']
|
||
if new_type not in valid_types:
|
||
return Response({
|
||
"code": 400,
|
||
"message": f"无效的知识库类型，可选值: {', '.join(valid_types)}",
|
||
"data": None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
if new_type == 'leader' and not user.role == 'admin':
|
||
if new_type not in ['private', 'member']:
|
||
return Response({
|
||
"code": 403,
|
||
"message": "组长只能将知识库设置为private或member类型",
|
||
"data": None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
|
||
department = request.data.get('department')
|
||
group = request.data.get('group')
|
||
|
||
if new_type == 'leader' and not user.role == 'admin':
|
||
if department and department != user.department:
|
||
return Response({
|
||
"code": 403,
|
||
"message": "组长只能为本部门设置知识库",
|
||
"data": None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
department = user.department
|
||
|
||
if new_type == 'leader':
|
||
if not department:
|
||
return Response({
|
||
"code": 400,
|
||
"message": "组长级知识库必须指定部门",
|
||
"data": None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
if new_type == 'member':
|
||
if not department:
|
||
return Response({
|
||
"code": 400,
|
||
"message": "成员级知识库必须指定部门",
|
||
"data": None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
if not group:
|
||
return Response({
|
||
"code": 400,
|
||
"message": "成员级知识库必须指定组",
|
||
"data": None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
if new_type in ['admin', 'secret']:
|
||
department = None
|
||
group = None
|
||
|
||
if new_type == 'private':
|
||
if department is None:
|
||
department = instance.department
|
||
if group is None:
|
||
group = instance.group
|
||
|
||
instance.type = new_type
|
||
instance.department = department
|
||
instance.group = group
|
||
instance.save()
|
||
|
||
return Response({
|
||
"code": 200,
|
||
"message": f"知识库类型已更新为{new_type}",
|
||
"data": {
|
||
"id": instance.id,
|
||
"name": instance.name,
|
||
"type": instance.type,
|
||
"department": instance.department,
|
||
"group": instance.group
|
||
}
|
||
})
|
||
|
||
except Http404:
|
||
return Response({
|
||
"code": 404,
|
||
"message": "知识库不存在",
|
||
"data": None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
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=True, methods=['post'])
|
||
def upload_document(self, request, pk=None):
|
||
try:
|
||
instance = self.get_object()
|
||
user = request.user
|
||
|
||
if not self.check_knowledge_base_permission(instance, user, 'edit'):
|
||
return Response({
|
||
"code": 403,
|
||
"message": "没有编辑权限",
|
||
"data": None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
|
||
logger.info(f"请求内容: {request.data}")
|
||
logger.info(f"请求FILES: {request.FILES}")
|
||
|
||
files = []
|
||
if 'files' in request.FILES:
|
||
files = request.FILES.getlist('files')
|
||
elif 'file' in request.FILES:
|
||
files = request.FILES.getlist('file')
|
||
elif any(key.startswith('files[') for key in request.FILES):
|
||
files = [file for key, file in request.FILES.items() if key.startswith('files[')]
|
||
elif any(key.startswith('file[') for key in request.FILES):
|
||
files = [file for key, file in request.FILES.items() if key.startswith('file[')]
|
||
elif len(request.FILES) > 0:
|
||
files = list(request.FILES.values())
|
||
|
||
if not files:
|
||
return Response({
|
||
"code": 400,
|
||
"message": "未找到上传文件，请确保表单字段名为'files'或'file'",
|
||
"data": {
|
||
"available_fields": list(request.FILES.keys())
|
||
}
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
logger.info(f"接收到 {len(files)} 个文件上传请求")
|
||
|
||
saved_documents = []
|
||
failed_documents = []
|
||
|
||
if not instance.external_id:
|
||
return Response({
|
||
"code": 400,
|
||
"message": "知识库没有有效的external_id，请先创建知识库",
|
||
"data": None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
try:
|
||
verify_url = f'{settings.API_BASE_URL}/api/dataset/{instance.external_id}'
|
||
verify_response = requests.get(verify_url)
|
||
if verify_response.status_code != 200:
|
||
logger.error(f"外部知识库不存在或无法访问: {instance.external_id}, 状态码: {verify_response.status_code}")
|
||
return Response({
|
||
"code": 404,
|
||
"message": f"外部知识库不存在或无法访问: {instance.external_id}",
|
||
"data": None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
verify_data = verify_response.json()
|
||
if verify_data.get('code') != 200:
|
||
logger.error(f"验证外部知识库失败: {verify_data.get('message')}")
|
||
return Response({
|
||
"code": verify_data.get('code', 500),
|
||
"message": f"验证外部知识库失败: {verify_data.get('message', '未知错误')}",
|
||
"data": None
|
||
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
|
||
|
||
logger.info(f"外部知识库验证成功: {instance.external_id}")
|
||
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)
|
||
|
||
# 批量处理所有文件
|
||
split_response = call_split_api_multiple(files)
|
||
if not split_response or split_response.get('code') != 200:
|
||
error_msg = f"文件分割失败: {split_response.get('message', '未知错误') if split_response else '请求失败'}"
|
||
logger.error(error_msg)
|
||
return Response({
|
||
"code": 400,
|
||
"message": error_msg,
|
||
"data": {
|
||
"uploaded_count": 0,
|
||
"failed_count": len(files),
|
||
"total_files": len(files),
|
||
"documents": [],
|
||
"failed_documents": [{"name": file.name, "error": error_msg} for file in files]
|
||
}
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# 处理分割结果
|
||
documents_data = split_response.get('data', [])
|
||
if not documents_data:
|
||
logger.warning(f"批量分割API未返回文档数据")
|
||
return Response({
|
||
"code": 400,
|
||
"message": "文件分割未返回有效数据",
|
||
"data": {
|
||
"uploaded_count": 0,
|
||
"failed_count": len(files),
|
||
"total_files": len(files),
|
||
"documents": [],
|
||
"failed_documents": [{"name": file.name, "error": "分割未返回有效数据"} for file in files]
|
||
}
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
logger.info(f"成功分割出 {len(documents_data)} 个文档，准备上传")
|
||
|
||
# 处理每个文档
|
||
for doc in documents_data:
|
||
doc_name = doc.get('name', '未命名文档')
|
||
doc_content = doc.get('content', [])
|
||
|
||
logger.info(f"处理文档: {doc_name}, 包含 {len(doc_content)} 个段落")
|
||
|
||
if not doc_content:
|
||
doc_content = [{
|
||
'title': '文档内容',
|
||
'content': '文件内容无法自动分割，请检查文件格式。'
|
||
}]
|
||
|
||
doc_data = {
|
||
"name": doc_name,
|
||
"paragraphs": []
|
||
}
|
||
|
||
for paragraph in doc_content:
|
||
doc_data["paragraphs"].append({
|
||
"content": paragraph.get('content', ''),
|
||
"title": paragraph.get('title', ''),
|
||
"is_active": True,
|
||
"problem_list": []
|
||
})
|
||
|
||
upload_response = call_upload_api(instance.external_id, doc_data)
|
||
|
||
if upload_response and upload_response.get('code') == 200 and upload_response.get('data'):
|
||
document_id = upload_response['data']['id']
|
||
doc_record = KnowledgeBaseDocument.objects.create(
|
||
knowledge_base=instance,
|
||
document_id=document_id,
|
||
document_name=doc_name,
|
||
external_id=document_id,
|
||
uploader_name=user.name
|
||
)
|
||
|
||
saved_documents.append({
|
||
"id": str(doc_record.id),
|
||
"name": doc_record.document_name,
|
||
"external_id": doc_record.external_id
|
||
})
|
||
|
||
logger.info(f"文档 '{doc_name}' 上传成功，ID: {document_id}")
|
||
else:
|
||
error_msg = upload_response.get('message', '未知错误') if upload_response else '上传API调用失败'
|
||
logger.error(f"文档 '{doc_name}' 上传失败: {error_msg}")
|
||
failed_documents.append({
|
||
"name": doc_name,
|
||
"error": error_msg
|
||
})
|
||
|
||
if saved_documents:
|
||
return Response({
|
||
"code": 200,
|
||
"message": f"文档上传完成，成功: {len(saved_documents)}，失败: {len(failed_documents)}",
|
||
"data": {
|
||
"uploaded_count": len(saved_documents),
|
||
"failed_count": len(failed_documents),
|
||
"total_files": len(files),
|
||
"documents": saved_documents,
|
||
"failed_documents": failed_documents
|
||
}
|
||
})
|
||
else:
|
||
return Response({
|
||
"code": 400,
|
||
"message": f"所有文档上传失败",
|
||
"data": {
|
||
"uploaded_count": 0,
|
||
"failed_count": len(failed_documents),
|
||
"total_files": len(files),
|
||
"documents": [],
|
||
"failed_documents": failed_documents
|
||
}
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
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=True, methods=['get'])
|
||
def documents(self, request, pk=None):
|
||
"""获取知识库的文档列表"""
|
||
try:
|
||
instance = self.get_object()
|
||
user = request.user
|
||
|
||
# 权限检查
|
||
if not self.check_knowledge_base_permission(instance, user, 'read'):
|
||
return Response({
|
||
"code": 403,
|
||
"message": "没有查看权限",
|
||
"data": None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
|
||
# 检查external_id是否存在
|
||
if not instance.external_id:
|
||
return Response({
|
||
"code": 400,
|
||
"message": "知识库没有有效的external_id",
|
||
"data": None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# 调用外部API获取文档列表
|
||
try:
|
||
external_documents = get_external_document_list(instance.external_id)
|
||
|
||
# 同步外部文档到本地数据库
|
||
for doc in external_documents:
|
||
external_id = doc.get('id')
|
||
doc_name = doc.get('name')
|
||
|
||
if external_id and doc_name:
|
||
kb_doc, created = KnowledgeBaseDocument.objects.update_or_create(
|
||
knowledge_base=instance,
|
||
external_id=external_id,
|
||
defaults={
|
||
'document_id': external_id,
|
||
'document_name': doc_name,
|
||
'status': 'active' if doc.get('is_active', True) else 'deleted'
|
||
}
|
||
)
|
||
|
||
if created:
|
||
logger.info(f"同步创建文档: {doc_name}, ID: {external_id}")
|
||
else:
|
||
logger.info(f"同步更新文档: {doc_name}, ID: {external_id}")
|
||
|
||
# 获取最新的本地文档数据
|
||
documents = KnowledgeBaseDocument.objects.filter(
|
||
knowledge_base=instance,
|
||
status='active'
|
||
).order_by('-create_time')
|
||
|
||
# 构建响应数据
|
||
documents_data = [{
|
||
"id": str(doc.id),
|
||
"document_id": doc.document_id,
|
||
"name": doc.document_name,
|
||
"external_id": doc.external_id,
|
||
"created_at": doc.create_time.strftime('%Y-%m-%d %H:%M:%S'),
|
||
"char_length": next((d.get('char_length', 0) for d in external_documents if d.get('id') == doc.external_id), 0),
|
||
"paragraph_count": next((d.get('paragraph_count', 0) for d in external_documents if d.get('id') == doc.external_id), 0),
|
||
"is_active": next((d.get('is_active', True) for d in external_documents if d.get('id') == doc.external_id), True),
|
||
"uploader_name": doc.uploader_name
|
||
} for doc in documents]
|
||
|
||
return Response({
|
||
"code": 200,
|
||
"message": "获取文档列表成功",
|
||
"data": documents_data
|
||
})
|
||
|
||
except ExternalAPIError as e:
|
||
logger.error(f"获取文档列表失败: {str(e)}")
|
||
return Response({
|
||
"code": 500,
|
||
"message": str(e),
|
||
"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=True, methods=['get'])
|
||
def document_content(self, request, pk=None):
|
||
"""获取文档内容 - 段落列表"""
|
||
try:
|
||
knowledge_base = self.get_object()
|
||
user = request.user
|
||
|
||
# 权限检查
|
||
if not self.check_knowledge_base_permission(knowledge_base, user, 'read'):
|
||
return Response({
|
||
"code": 403,
|
||
"message": "没有查看权限",
|
||
"data": None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
|
||
# 获取文档ID
|
||
document_id = request.query_params.get('document_id')
|
||
if not document_id:
|
||
return Response({
|
||
"code": 400,
|
||
"message": "缺少document_id参数",
|
||
"data": None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# 验证文档存在
|
||
document = KnowledgeBaseDocument.objects.filter(
|
||
knowledge_base=knowledge_base,
|
||
document_id=document_id,
|
||
status='active'
|
||
).first()
|
||
|
||
if not document:
|
||
return Response({
|
||
"code": 404,
|
||
"message": "文档不存在或已删除",
|
||
"data": None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
# 调用外部API获取文档段落内容
|
||
try:
|
||
paragraphs = get_external_document_paragraphs(knowledge_base.external_id, document.external_id)
|
||
|
||
# 直接返回外部API的段落数据
|
||
return Response({
|
||
"code": 200,
|
||
"message": "获取文档内容成功",
|
||
"data": {
|
||
"document_id": document_id,
|
||
"name": document.document_name,
|
||
"paragraphs": paragraphs
|
||
}
|
||
})
|
||
|
||
except ExternalAPIError as e:
|
||
logger.error(f"获取文档段落内容失败: {str(e)}")
|
||
return Response({
|
||
"code": 500,
|
||
"message": str(e),
|
||
"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=True, methods=['delete'])
|
||
def delete_document(self, request, pk=None):
|
||
"""删除知识库文档"""
|
||
try:
|
||
knowledge_base = self.get_object()
|
||
user = request.user
|
||
|
||
# 权限检查
|
||
if not self.check_knowledge_base_permission(knowledge_base, user, 'edit'):
|
||
return Response({
|
||
"code": 403,
|
||
"message": "没有编辑权限",
|
||
"data": None
|
||
}, status=status.HTTP_403_FORBIDDEN)
|
||
|
||
# 获取文档ID
|
||
document_id = request.query_params.get('document_id')
|
||
if not document_id:
|
||
return Response({
|
||
"code": 400,
|
||
"message": "缺少document_id参数",
|
||
"data": None
|
||
}, status=status.HTTP_400_BAD_REQUEST)
|
||
|
||
# 验证文档存在
|
||
document = KnowledgeBaseDocument.objects.filter(
|
||
knowledge_base=knowledge_base,
|
||
document_id=document_id,
|
||
status='active'
|
||
).first()
|
||
|
||
if not document:
|
||
return Response({
|
||
"code": 404,
|
||
"message": "文档不存在或已删除",
|
||
"data": None
|
||
}, status=status.HTTP_404_NOT_FOUND)
|
||
|
||
# 调用外部API删除文档
|
||
external_id = document.external_id
|
||
delete_result = call_delete_document_api(knowledge_base.external_id, external_id)
|
||
|
||
# 无论外部API结果如何，都更新本地状态
|
||
document.status = 'deleted'
|
||
document.save()
|
||
|
||
# 检查外部API结果
|
||
if delete_result.get('code') != 200:
|
||
logger.warning(f"外部API删除文档失败，但本地标记已更新: {delete_result.get('message')}")
|
||
return Response({
|
||
"code": 200,
|
||
"message": "文档在系统中已标记为删除，但外部API调用失败",
|
||
"data": {
|
||
"document_id": document_id,
|
||
"name": document.document_name,
|
||
"error": delete_result.get('message')
|
||
}
|
||
})
|
||
|
||
return Response({
|
||
"code": 200,
|
||
"message": "文档删除成功",
|
||
"data": {
|
||
"document_id": document_id,
|
||
"name": document.document_name
|
||
}
|
||
})
|
||
|
||
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)
|
||
|