zhuchaowe/maxkb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Support application、setting、user log recorder (#2617)

Browse Source
This commit is contained in:
shaohuzhang1 2025-03-19 15:45:10 +08:00 committed by GitHub
parent 7b51d08ea5
commit 470105f895
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
20 changed files with 250 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
apps/application/views/application_version_views.py
View File

@ -16,6 +16,7 @@ from application.swagger_api.application_version_api import ApplicationVersionAp
from common.auth import has_permissions, TokenAuth from common.auth import has_permissions, TokenAuth
from common.constants.permission_constants import PermissionConstants, CompareConstants, ViewPermission, RoleConstants, \ from common.constants.permission_constants import PermissionConstants, CompareConstants, ViewPermission, RoleConstants, \
Permission, Group, Operate Permission, Group, Operate
from common.log.log import log
from common.response import result from common.response import result
from django.utils.translation import gettext_lazy as _ from django.utils.translation import gettext_lazy as _
@ -30,6 +31,7 @@ class ApplicationVersionView(APIView):
responses=result.get_api_array_response(ApplicationVersionApi.get_response_body_api()), responses=result.get_api_array_response(ApplicationVersionApi.get_response_body_api()),
tags=[_('Application/Version')]) tags=[_('Application/Version')])
@has_permissions(PermissionConstants.APPLICATION_READ, compare=CompareConstants.AND) @has_permissions(PermissionConstants.APPLICATION_READ, compare=CompareConstants.AND)
@log(menu='Application', operate="Get the application list")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationVersionSerializer.Query( ApplicationVersionSerializer.Query(
@ -47,6 +49,7 @@ class ApplicationVersionView(APIView):
responses=result.get_page_api_response(ApplicationVersionApi.get_response_body_api()), responses=result.get_page_api_response(ApplicationVersionApi.get_response_body_api()),
tags=[_('Application/Version')]) tags=[_('Application/Version')])
@has_permissions(PermissionConstants.APPLICATION_READ, compare=CompareConstants.AND) @has_permissions(PermissionConstants.APPLICATION_READ, compare=CompareConstants.AND)
@log(menu='Application', operate="Get the list of application versions by page")
def get(self, request: Request, application_id: str, current_page: int, page_size: int): def get(self, request: Request, application_id: str, current_page: int, page_size: int):
return result.success( return result.success(
ApplicationVersionSerializer.Query( ApplicationVersionSerializer.Query(
@ -64,6 +67,7 @@ class ApplicationVersionView(APIView):
responses=result.get_api_response(ApplicationVersionApi.get_response_body_api()), responses=result.get_api_response(ApplicationVersionApi.get_response_body_api()),
tags=[_('Application/Version')]) tags=[_('Application/Version')])
@has_permissions(PermissionConstants.APPLICATION_READ, compare=CompareConstants.AND) @has_permissions(PermissionConstants.APPLICATION_READ, compare=CompareConstants.AND)
@log(menu='Application', operate="Get application version details")
def get(self, request: Request, application_id: str, work_flow_version_id: str): def get(self, request: Request, application_id: str, work_flow_version_id: str):
return result.success( return result.success(
ApplicationVersionSerializer.Operate( ApplicationVersionSerializer.Operate(
@ -82,6 +86,7 @@ class ApplicationVersionView(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Modify application version information")
def put(self, request: Request, application_id: str, work_flow_version_id: str): def put(self, request: Request, application_id: str, work_flow_version_id: str):
return result.success( return result.success(
ApplicationVersionSerializer.Operate( ApplicationVersionSerializer.Operate(

37
apps/application/views/application_views.py
View File

@ -9,8 +9,9 @@
from django.core import cache from django.core import cache
from django.http import HttpResponse from django.http import HttpResponse
from django.utils.translation import gettext_lazy as _ from django.utils.translation import gettext_lazy as _, gettext
from drf_yasg.utils import swagger_auto_schema from drf_yasg.utils import swagger_auto_schema
from langchain_core.prompts import PromptTemplate
from rest_framework.decorators import action from rest_framework.decorators import action
from rest_framework.parsers import MultiPartParser from rest_framework.parsers import MultiPartParser
from rest_framework.request import Request from rest_framework.request import Request
@ -50,6 +51,7 @@ class ApplicationStatistics(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="User Statistics")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationStatisticsSerializer(data={'application_id': application_id, ApplicationStatisticsSerializer(data={'application_id': application_id,
@ -74,6 +76,7 @@ class ApplicationStatistics(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="User demographic trends")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationStatisticsSerializer(data={'application_id': application_id, ApplicationStatisticsSerializer(data={'application_id': application_id,
@ -99,6 +102,7 @@ class ApplicationStatistics(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Conversation statistics")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationStatisticsSerializer(data={'application_id': application_id, ApplicationStatisticsSerializer(data={'application_id': application_id,
@ -124,6 +128,7 @@ class ApplicationStatistics(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Dialogue-related statistical trends")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationStatisticsSerializer(data={'application_id': application_id, ApplicationStatisticsSerializer(data={'application_id': application_id,
@ -153,6 +158,7 @@ class Application(APIView):
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND), PermissionConstants.APPLICATION_EDIT, compare=CompareConstants.AND), PermissionConstants.APPLICATION_EDIT,
compare=CompareConstants.AND) compare=CompareConstants.AND)
@log(menu='Application', operate="Modify application icon")
def put(self, request: Request, application_id: str): def put(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.IconOperate( ApplicationSerializer.IconOperate(
@ -169,6 +175,7 @@ class Application(APIView):
tags=[_("Application")] tags=[_("Application")]
) )
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu='Application', operate="Import Application")
def post(self, request: Request): def post(self, request: Request):
return result.success(ApplicationSerializer.Import( return result.success(ApplicationSerializer.Import(
data={'user_id': request.user.id, 'file': request.FILES.get('file')}).import_()) data={'user_id': request.user.id, 'file': request.FILES.get('file')}).import_())
@ -183,6 +190,7 @@ class Application(APIView):
) )
@has_permissions(lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE, @has_permissions(lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE,
dynamic_tag=keywords.get('application_id'))) dynamic_tag=keywords.get('application_id')))
@log(menu='Application', operate="Export Application")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return ApplicationSerializer.Operate( return ApplicationSerializer.Operate(
data={'application_id': application_id, 'user_id': request.user.id}).export() data={'application_id': application_id, 'user_id': request.user.id}).export()
@ -193,6 +201,7 @@ class Application(APIView):
operation_id=_("Get embedded js"), operation_id=_("Get embedded js"),
tags=[_("Application")], tags=[_("Application")],
manual_parameters=ApplicationApi.ApiKey.get_request_params_api()) manual_parameters=ApplicationApi.ApiKey.get_request_params_api())
@log(menu='Application', operate="Get embedded js")
def get(self, request: Request): def get(self, request: Request):
return ApplicationSerializer.Embed( return ApplicationSerializer.Embed(
data={'protocol': request.query_params.get('protocol'), 'token': request.query_params.get('token'), data={'protocol': request.query_params.get('protocol'), 'token': request.query_params.get('token'),
@ -211,6 +220,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Get a list of models")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.Operate( ApplicationSerializer.Operate(
@ -229,6 +239,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Get model parameter form")
def get(self, request: Request, application_id: str, model_id: str): def get(self, request: Request, application_id: str, model_id: str):
return result.success( return result.success(
ApplicationSerializer.Operate( ApplicationSerializer.Operate(
@ -247,6 +258,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Get a list of function libraries")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.Operate( ApplicationSerializer.Operate(
@ -266,6 +278,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Get library details")
def get(self, request: Request, application_id: str, function_lib_id: str): def get(self, request: Request, application_id: str, function_lib_id: str):
return result.success( return result.success(
ApplicationSerializer.Operate( ApplicationSerializer.Operate(
@ -284,6 +297,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Get the list of apps created by the current user")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.Operate( ApplicationSerializer.Operate(
@ -303,6 +317,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Get application data")
def get(self, request: Request, application_id: str, app_id: str): def get(self, request: Request, application_id: str, app_id: str):
return result.success( return result.success(
ApplicationSerializer.Operate( ApplicationSerializer.Operate(
@ -316,6 +331,7 @@ class Application(APIView):
@swagger_auto_schema(operation_summary=_("Get application related information"), @swagger_auto_schema(operation_summary=_("Get application related information"),
operation_id=_("Get application related information"), operation_id=_("Get application related information"),
tags=[_("Application/Chat")]) tags=[_("Application/Chat")])
@log(menu='Application', operate="Get application related information")
def get(self, request: Request): def get(self, request: Request):
if 'application_id' in request.auth.keywords: if 'application_id' in request.auth.keywords:
return result.success(ApplicationSerializer.Operate( return result.success(ApplicationSerializer.Operate(
@ -336,6 +352,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Add ApiKey")
def post(self, request: Request, application_id: str): def post(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.ApplicationKeySerializer( ApplicationSerializer.ApplicationKeySerializer(
@ -352,6 +369,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Get the application API_KEY list")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success(ApplicationSerializer.ApplicationKeySerializer( return result.success(ApplicationSerializer.ApplicationKeySerializer(
data={'application_id': application_id, 'user_id': request.user.id}).list()) data={'application_id': application_id, 'user_id': request.user.id}).list())
@ -371,6 +389,7 @@ class Application(APIView):
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND), PermissionConstants.APPLICATION_EDIT, compare=CompareConstants.AND), PermissionConstants.APPLICATION_EDIT,
compare=CompareConstants.AND) compare=CompareConstants.AND)
@log(menu='Application', operate="Modify application API_KEY")
def put(self, request: Request, application_id: str, api_key_id: str): def put(self, request: Request, application_id: str, api_key_id: str):
return result.success( return result.success(
ApplicationSerializer.ApplicationKeySerializer.Operate( ApplicationSerializer.ApplicationKeySerializer.Operate(
@ -388,6 +407,7 @@ class Application(APIView):
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND), PermissionConstants.APPLICATION_DELETE, compare=CompareConstants.AND), PermissionConstants.APPLICATION_DELETE,
compare=CompareConstants.AND) compare=CompareConstants.AND)
@log(menu='Application', operate="Delete Application API_KEY")
def delete(self, request: Request, application_id: str, api_key_id: str): def delete(self, request: Request, application_id: str, api_key_id: str):
return result.success( return result.success(
ApplicationSerializer.ApplicationKeySerializer.Operate( ApplicationSerializer.ApplicationKeySerializer.Operate(
@ -408,6 +428,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Modify Application AccessToken")
def put(self, request: Request, application_id: str): def put(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.AccessTokenSerializer(data={'application_id': application_id}).edit( ApplicationSerializer.AccessTokenSerializer(data={'application_id': application_id}).edit(
@ -424,6 +445,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Get the application AccessToken information")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.AccessTokenSerializer(data={'application_id': application_id}).one()) ApplicationSerializer.AccessTokenSerializer(data={'application_id': application_id}).one())
@ -459,6 +481,7 @@ class Application(APIView):
request_body=ApplicationApi.Create.get_request_body_api(), request_body=ApplicationApi.Create.get_request_body_api(),
tags=[_('Application')]) tags=[_('Application')])
@has_permissions(PermissionConstants.APPLICATION_CREATE, compare=CompareConstants.AND) @has_permissions(PermissionConstants.APPLICATION_CREATE, compare=CompareConstants.AND)
@log(menu='Application', operate="Create an application")
def post(self, request: Request): def post(self, request: Request):
return result.success(ApplicationSerializer.Create(data={'user_id': request.user.id}).insert(request.data)) return result.success(ApplicationSerializer.Create(data={'user_id': request.user.id}).insert(request.data))
@ -469,6 +492,7 @@ class Application(APIView):
responses=result.get_api_array_response(ApplicationApi.get_response_body_api()), responses=result.get_api_array_response(ApplicationApi.get_response_body_api()),
tags=[_('Application')]) tags=[_('Application')])
@has_permissions(PermissionConstants.APPLICATION_READ, compare=CompareConstants.AND) @has_permissions(PermissionConstants.APPLICATION_READ, compare=CompareConstants.AND)
@log(menu='Application', operate="Get the application list")
def get(self, request: Request): def get(self, request: Request):
return result.success( return result.success(
ApplicationSerializer.Query( ApplicationSerializer.Query(
@ -488,6 +512,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Hit Test List")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.HitTest(data={'id': application_id, 'user_id': request.user.id, ApplicationSerializer.HitTest(data={'id': application_id, 'user_id': request.user.id,
@ -513,6 +538,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Publishing an application")
def put(self, request: Request, application_id: str): def put(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.Operate( ApplicationSerializer.Operate(
@ -534,6 +560,7 @@ class Application(APIView):
compare=CompareConstants.AND), compare=CompareConstants.AND),
lambda r, k: Permission(group=Group.APPLICATION, operate=Operate.DELETE, lambda r, k: Permission(group=Group.APPLICATION, operate=Operate.DELETE,
dynamic_tag=k.get('application_id')), compare=CompareConstants.AND) dynamic_tag=k.get('application_id')), compare=CompareConstants.AND)
@log(menu='Application', operate="Deleting application")
def delete(self, request: Request, application_id: str): def delete(self, request: Request, application_id: str):
return result.success(ApplicationSerializer.Operate( return result.success(ApplicationSerializer.Operate(
data={'application_id': application_id, 'user_id': request.user.id}).delete( data={'application_id': application_id, 'user_id': request.user.id}).delete(
@ -551,6 +578,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.MANAGE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Modify the application")
def put(self, request: Request, application_id: str): def put(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.Operate( ApplicationSerializer.Operate(
@ -569,6 +597,7 @@ class Application(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Get application details")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success(ApplicationSerializer.Operate( return result.success(ApplicationSerializer.Operate(
data={'application_id': application_id, 'user_id': request.user.id}).one()) data={'application_id': application_id, 'user_id': request.user.id}).one())
@ -589,6 +618,7 @@ class Application(APIView):
dynamic_tag=keywords.get( dynamic_tag=keywords.get(
'application_id'))], 'application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="Get the knowledge base available to the current application")
def get(self, request: Request, application_id: str): def get(self, request: Request, application_id: str):
return result.success(ApplicationSerializer.Operate( return result.success(ApplicationSerializer.Operate(
data={'application_id': application_id, 'user_id': request.user.id}).list_dataset()) data={'application_id': application_id, 'user_id': request.user.id}).list_dataset())
@ -604,7 +634,7 @@ class Application(APIView):
responses=result.get_page_api_response(ApplicationApi.get_response_body_api()), responses=result.get_page_api_response(ApplicationApi.get_response_body_api()),
tags=[_('Application')]) tags=[_('Application')])
@has_permissions(PermissionConstants.APPLICATION_READ, compare=CompareConstants.AND) @has_permissions(PermissionConstants.APPLICATION_READ, compare=CompareConstants.AND)
@log(menu=_('Application'), operate=_("Get the application list by page")) @log(menu='Application', operate="Get the application list by page")
def get(self, request: Request, current_page: int, page_size: int): def get(self, request: Request, current_page: int, page_size: int):
return result.success( return result.success(
ApplicationSerializer.Query( ApplicationSerializer.Query(
@ -622,6 +652,7 @@ class Application(APIView):
dynamic_tag=keywords.get( dynamic_tag=keywords.get(
'application_id'))], 'application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="speech to text")
def post(self, request: Request, application_id: str): def post(self, request: Request, application_id: str):
return result.success( return result.success(
ApplicationSerializer.Operate(data={'application_id': application_id, 'user_id': request.user.id}) ApplicationSerializer.Operate(data={'application_id': application_id, 'user_id': request.user.id})
@ -644,6 +675,7 @@ class Application(APIView):
dynamic_tag=keywords.get( dynamic_tag=keywords.get(
'application_id'))], 'application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="text to speech")
def post(self, request: Request, application_id: str): def post(self, request: Request, application_id: str):
byte_data = ApplicationSerializer.Operate( byte_data = ApplicationSerializer.Operate(
data={'application_id': application_id, 'user_id': request.user.id}).text_to_speech( data={'application_id': application_id, 'user_id': request.user.id}).text_to_speech(
@ -662,6 +694,7 @@ class Application(APIView):
dynamic_tag=keywords.get( dynamic_tag=keywords.get(
'application_id'))], 'application_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='Application', operate="trial listening")
def post(self, request: Request, application_id: str): def post(self, request: Request, application_id: str):
byte_data = ApplicationSerializer.Operate( byte_data = ApplicationSerializer.Operate(
data={'application_id': application_id, 'user_id': request.user.id}).play_demo_text(request.data) data={'application_id': application_id, 'user_id': request.user.id}).play_demo_text(request.data)

14
apps/application/views/chat_views.py
View File

@ -23,6 +23,7 @@ from common.auth import TokenAuth, has_permissions, OpenAIKeyAuth
from common.constants.authentication_type import AuthenticationType from common.constants.authentication_type import AuthenticationType
from common.constants.permission_constants import Permission, Group, Operate, \ from common.constants.permission_constants import Permission, Group, Operate, \
RoleConstants, ViewPermission, CompareConstants RoleConstants, ViewPermission, CompareConstants
from common.log.log import log
from common.response import result from common.response import result
from common.util.common import query_params_to_single_dict from common.util.common import query_params_to_single_dict
from dataset.serializers.file_serializers import FileSerializer from dataset.serializers.file_serializers import FileSerializer
@ -177,6 +178,7 @@ class ChatView(APIView):
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND), compare=CompareConstants.AND),
compare=CompareConstants.AND) compare=CompareConstants.AND)
@log(menu='Application/Conversation Log', operate="Delete a conversation")
def delete(self, request: Request, application_id: str, chat_id: str): def delete(self, request: Request, application_id: str, chat_id: str):
return result.success( return result.success(
ChatSerializers.Operate( ChatSerializers.Operate(
@ -199,6 +201,7 @@ class ChatView(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))]) dynamic_tag=keywords.get('application_id'))])
) )
@log(menu='Application/Conversation Log', operate="Get client conversation list by paging")
def get(self, request: Request, application_id: str, current_page: int, page_size: int): def get(self, request: Request, application_id: str, current_page: int, page_size: int):
return result.success(ChatSerializers.ClientChatHistory( return result.success(ChatSerializers.ClientChatHistory(
data={'client_id': request.auth.client_id, 'application_id': application_id}).page( data={'client_id': request.auth.client_id, 'application_id': application_id}).page(
@ -218,6 +221,7 @@ class ChatView(APIView):
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND), compare=CompareConstants.AND),
compare=CompareConstants.AND) compare=CompareConstants.AND)
@log(menu='Application/Conversation Log', operate="Client deletes conversation")
def delete(self, request: Request, application_id: str, chat_id: str): def delete(self, request: Request, application_id: str, chat_id: str):
return result.success( return result.success(
ChatSerializers.Operate( ChatSerializers.Operate(
@ -235,6 +239,7 @@ class ChatView(APIView):
dynamic_tag=keywords.get('application_id'))], dynamic_tag=keywords.get('application_id'))],
compare=CompareConstants.AND), compare=CompareConstants.AND),
compare=CompareConstants.AND) compare=CompareConstants.AND)
@log(menu='Application/Conversation Log', operate="Client modifies dialogue summary")
def put(self, request: Request, application_id: str, chat_id: str): def put(self, request: Request, application_id: str, chat_id: str):
return result.success( return result.success(
ChatSerializers.Operate( ChatSerializers.Operate(
@ -256,6 +261,7 @@ class ChatView(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))]) dynamic_tag=keywords.get('application_id'))])
) )
@log(menu='Application/Conversation Log', operate="Get the conversation list by page")
def get(self, request: Request, application_id: str, current_page: int, page_size: int): def get(self, request: Request, application_id: str, current_page: int, page_size: int):
return result.success(ChatSerializers.Query( return result.success(ChatSerializers.Query(
data={**query_params_to_single_dict(request.query_params), 'application_id': application_id, data={**query_params_to_single_dict(request.query_params), 'application_id': application_id,
@ -281,6 +287,7 @@ class ChatView(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))]) dynamic_tag=keywords.get('application_id'))])
) )
@log(menu='Application/Conversation Log', operate="Get conversation record details")
def get(self, request: Request, application_id: str, chat_id: str, chat_record_id: str): def get(self, request: Request, application_id: str, chat_id: str, chat_record_id: str):
return result.success(ChatRecordSerializer.Operate( return result.success(ChatRecordSerializer.Operate(
data={'application_id': application_id, data={'application_id': application_id,
@ -299,6 +306,7 @@ class ChatView(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))]) dynamic_tag=keywords.get('application_id'))])
) )
@log(menu='Application/Conversation Log', operate="Get a list of conversation records")
def get(self, request: Request, application_id: str, chat_id: str): def get(self, request: Request, application_id: str, chat_id: str):
return result.success(ChatRecordSerializer.Query( return result.success(ChatRecordSerializer.Query(
data={'application_id': application_id, data={'application_id': application_id,
@ -320,6 +328,7 @@ class ChatView(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))]) dynamic_tag=keywords.get('application_id'))])
) )
@log(menu='Application/Conversation Log', operate="Get the conversation history list by page")
def get(self, request: Request, application_id: str, chat_id: str, current_page: int, page_size: int): def get(self, request: Request, application_id: str, chat_id: str, current_page: int, page_size: int):
return result.success(ChatRecordSerializer.Query( return result.success(ChatRecordSerializer.Query(
data={'application_id': application_id, data={'application_id': application_id,
@ -343,6 +352,7 @@ class ChatView(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))]) dynamic_tag=keywords.get('application_id'))])
) )
@log(menu='Application/Conversation Log', operate="Like, Dislike")
def put(self, request: Request, application_id: str, chat_id: str, chat_record_id: str): def put(self, request: Request, application_id: str, chat_id: str, chat_record_id: str):
return result.success(ChatRecordSerializer.Vote( return result.success(ChatRecordSerializer.Vote(
data={'vote_status': request.data.get('vote_status'), 'chat_id': chat_id, data={'vote_status': request.data.get('vote_status'), 'chat_id': chat_id,
@ -363,6 +373,7 @@ class ChatView(APIView):
[lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE, [lambda r, keywords: Permission(group=Group.APPLICATION, operate=Operate.USE,
dynamic_tag=keywords.get('application_id'))] dynamic_tag=keywords.get('application_id'))]
)) ))
@log(menu='Application/Conversation Log', operate="Get the list of marked paragraphs")
def get(self, request: Request, application_id: str, chat_id: str, chat_record_id: str): def get(self, request: Request, application_id: str, chat_id: str, chat_record_id: str):
return result.success(ChatRecordSerializer.ChatRecordImprove( return result.success(ChatRecordSerializer.ChatRecordImprove(
data={'chat_id': chat_id, 'chat_record_id': chat_record_id}).get()) data={'chat_id': chat_id, 'chat_record_id': chat_record_id}).get())
@ -390,6 +401,7 @@ class ChatView(APIView):
'dataset_id'))], 'dataset_id'))],
compare=CompareConstants.AND compare=CompareConstants.AND
), compare=CompareConstants.AND) ), compare=CompareConstants.AND)
@log(menu='Application/Conversation Log', operate="Annotation")
def put(self, request: Request, application_id: str, chat_id: str, chat_record_id: str, dataset_id: str, def put(self, request: Request, application_id: str, chat_id: str, chat_record_id: str, dataset_id: str,
document_id: str): document_id: str):
return result.success(ChatRecordSerializer.Improve( return result.success(ChatRecordSerializer.Improve(
@ -415,6 +427,7 @@ class ChatView(APIView):
'dataset_id'))], 'dataset_id'))],
compare=CompareConstants.AND compare=CompareConstants.AND
), compare=CompareConstants.AND) ), compare=CompareConstants.AND)
@log(menu='Application/Conversation Log', operate="Add to Knowledge Base")
def post(self, request: Request, application_id: str, dataset_id: str): def post(self, request: Request, application_id: str, dataset_id: str):
return result.success(ChatRecordSerializer.PostImprove().post_improve(request.data)) return result.success(ChatRecordSerializer.PostImprove().post_improve(request.data))
@ -440,6 +453,7 @@ class ChatView(APIView):
'dataset_id'))], 'dataset_id'))],
compare=CompareConstants.AND compare=CompareConstants.AND
), compare=CompareConstants.AND) ), compare=CompareConstants.AND)
@log(menu='Application/Conversation Log', operate="Delete a Annotation")
def delete(self, request: Request, application_id: str, chat_id: str, chat_record_id: str, def delete(self, request: Request, application_id: str, chat_id: str, chat_record_id: str,
dataset_id: str, dataset_id: str,
document_id: str, paragraph_id: str): document_id: str, paragraph_id: str):

1
apps/common/log/log.py
View File

@ -75,6 +75,7 @@ def log(menu: str, operate, get_user=_get_user, get_ip_address=_get_ip_address,
return func(view, request, **kwargs) return func(view, request, **kwargs)
except Exception as e: except Exception as e:
status = 500 status = 500
raise e
finally: finally:
ip = get_ip_address(request) ip = get_ip_address(request)
user = get_user(request) user = get_user(request)

20
apps/common/util/common.py
View File

@ -24,6 +24,26 @@ from ..exception.app_exception import AppApiException
from ..models.db_model_manage import DBModelManage from ..models.db_model_manage import DBModelManage
def encryption(message: str):
"""
加密敏感字段数据 加密方式是 如果密码是 1234567890 那么给前端则是 123******890
:param message:
:return:
"""
max_pre_len = 8
max_post_len = 4
message_len = len(message)
pre_len = int(message_len / 5 * 2)
post_len = int(message_len / 5 * 1)
pre_str = "".join([message[index] for index in
range(0, max_pre_len if pre_len > max_pre_len else 1 if pre_len <= 0 else int(pre_len))])
end_str = "".join(
[message[index] for index in
range(message_len - (int(post_len) if pre_len < max_post_len else max_post_len), message_len)])
content = "***************"
return pre_str + content + end_str
def sub_array(array: List, item_num=10): def sub_array(array: List, item_num=10):
result = [] result = []
temp = [] temp = []

38
apps/dataset/views/dataset.py
View File

@ -32,8 +32,8 @@ class Dataset(APIView):
authentication_classes = [TokenAuth] authentication_classes = [TokenAuth]
@action(methods=['PUT'], detail=False) @action(methods=['PUT'], detail=False)
@swagger_auto_schema(operation_summary="同步Web站点知识库", @swagger_auto_schema(operation_summary=_("Synchronize the knowledge base of the website"),
operation_id="同步Web站点知识库", operation_id=_("Synchronize the knowledge base of the website"),
manual_parameters=DataSetSerializers.SyncWeb.get_request_params_api(), manual_parameters=DataSetSerializers.SyncWeb.get_request_params_api(),
responses=result.get_default_response(), responses=result.get_default_response(),
tags=[_('Knowledge Base')]) tags=[_('Knowledge Base')])
@ -43,7 +43,7 @@ class Dataset(APIView):
dynamic_tag=keywords.get('dataset_id'))], dynamic_tag=keywords.get('dataset_id'))],
compare=CompareConstants.AND), PermissionConstants.DATASET_EDIT, compare=CompareConstants.AND), PermissionConstants.DATASET_EDIT,
compare=CompareConstants.AND) compare=CompareConstants.AND)
@log(menu=_('Knowledge Base'), operate=_("同步Web站点知识库")) @log(menu='Knowledge Base', operate="Synchronize the knowledge base of the website")
def put(self, request: Request, dataset_id: str): def put(self, request: Request, dataset_id: str):
return result.success(DataSetSerializers.SyncWeb( return result.success(DataSetSerializers.SyncWeb(
data={'sync_type': request.query_params.get('sync_type'), 'id': dataset_id, data={'sync_type': request.query_params.get('sync_type'), 'id': dataset_id,
@ -54,15 +54,15 @@ class Dataset(APIView):
parser_classes = [MultiPartParser] parser_classes = [MultiPartParser]
@action(methods=['POST'], detail=False) @action(methods=['POST'], detail=False)
@swagger_auto_schema(operation_summary="创建QA知识库", @swagger_auto_schema(operation_summary=_("Create QA knowledge base"),
operation_id="创建QA知识库", operation_id=_("Create QA knowledge base"),
manual_parameters=DataSetSerializers.Create.CreateQASerializers.get_request_params_api(), manual_parameters=DataSetSerializers.Create.CreateQASerializers.get_request_params_api(),
responses=get_api_response( responses=get_api_response(
DataSetSerializers.Create.CreateQASerializers.get_response_body_api()), DataSetSerializers.Create.CreateQASerializers.get_response_body_api()),
tags=[_('Knowledge Base')] tags=[_('Knowledge Base')]
) )
@has_permissions(PermissionConstants.DATASET_CREATE, compare=CompareConstants.AND) @has_permissions(PermissionConstants.DATASET_CREATE, compare=CompareConstants.AND)
@log(menu=_('Knowledge Base'), operate=_("创建QA知识库")) @log(menu='Knowledge Base', operate="Create QA knowledge base")
def post(self, request: Request): def post(self, request: Request):
return result.success(DataSetSerializers.Create(data={'user_id': request.user.id}).save_qa({ return result.success(DataSetSerializers.Create(data={'user_id': request.user.id}).save_qa({
'file_list': request.FILES.getlist('file'), 'file_list': request.FILES.getlist('file'),
@ -82,7 +82,7 @@ class Dataset(APIView):
tags=[_('Knowledge Base')] tags=[_('Knowledge Base')]
) )
@has_permissions(PermissionConstants.DATASET_CREATE, compare=CompareConstants.AND) @has_permissions(PermissionConstants.DATASET_CREATE, compare=CompareConstants.AND)
@log(menu=_('Knowledge Base'), operate=_("Create a web site knowledge base")) @log(menu='Knowledge Base', operate="Create a web site knowledge base")
def post(self, request: Request): def post(self, request: Request):
return result.success(DataSetSerializers.Create(data={'user_id': request.user.id}).save_web(request.data)) return result.success(DataSetSerializers.Create(data={'user_id': request.user.id}).save_web(request.data))
@ -96,7 +96,7 @@ class Dataset(APIView):
responses=result.get_api_array_response( responses=result.get_api_array_response(
DataSetSerializers.Application.get_response_body_api()), DataSetSerializers.Application.get_response_body_api()),
tags=[_('Knowledge Base')]) tags=[_('Knowledge Base')])
@log(menu=_('Knowledge Base'), operate=_("Get a list of applications available in the knowledge base")) @log(menu='Knowledge Base', operate="Get a list of applications available in the knowledge base")
def get(self, request: Request, dataset_id: str): def get(self, request: Request, dataset_id: str):
return result.success(DataSetSerializers.Operate( return result.success(DataSetSerializers.Operate(
data={'id': dataset_id, 'user_id': str(request.user.id)}).list_application()) data={'id': dataset_id, 'user_id': str(request.user.id)}).list_application())
@ -108,7 +108,7 @@ class Dataset(APIView):
responses=result.get_api_array_response(DataSetSerializers.Query.get_response_body_api()), responses=result.get_api_array_response(DataSetSerializers.Query.get_response_body_api()),
tags=[_('Knowledge Base')]) tags=[_('Knowledge Base')])
@has_permissions(PermissionConstants.DATASET_READ, compare=CompareConstants.AND) @has_permissions(PermissionConstants.DATASET_READ, compare=CompareConstants.AND)
@log(menu=_('Knowledge Base'), operate=_("Get a list of knowledge bases")) @log(menu='Knowledge Base', operate="Get a list of knowledge bases")
def get(self, request: Request): def get(self, request: Request):
data = {key: str(value) for key, value in request.query_params.items()} data = {key: str(value) for key, value in request.query_params.items()}
d = DataSetSerializers.Query(data={**data, 'user_id': str(request.user.id)}) d = DataSetSerializers.Query(data={**data, 'user_id': str(request.user.id)})
@ -123,7 +123,7 @@ class Dataset(APIView):
tags=[_('Knowledge Base')] tags=[_('Knowledge Base')]
) )
@has_permissions(PermissionConstants.DATASET_CREATE, compare=CompareConstants.AND) @has_permissions(PermissionConstants.DATASET_CREATE, compare=CompareConstants.AND)
@log(menu=_('Knowledge Base'), operate=_("Create a knowledge base")) @log(menu='Knowledge Base', operate="Create a knowledge base")
def post(self, request: Request): def post(self, request: Request):
return result.success(DataSetSerializers.Create(data={'user_id': request.user.id}).save(request.data)) return result.success(DataSetSerializers.Create(data={'user_id': request.user.id}).save(request.data))
@ -137,7 +137,7 @@ class Dataset(APIView):
tags=[_('Knowledge Base')]) tags=[_('Knowledge Base')])
@has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.USE, @has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=keywords.get('dataset_id'))) dynamic_tag=keywords.get('dataset_id')))
@log(menu=_('Knowledge Base'), operate=_("Hit test list")) @log(menu='Knowledge Base', operate="Hit test list")
def get(self, request: Request, dataset_id: str): def get(self, request: Request, dataset_id: str):
return result.success( return result.success(
DataSetSerializers.HitTest(data={'id': dataset_id, 'user_id': request.user.id, DataSetSerializers.HitTest(data={'id': dataset_id, 'user_id': request.user.id,
@ -158,7 +158,7 @@ class Dataset(APIView):
) )
@has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.MANAGE, @has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=keywords.get('dataset_id'))) dynamic_tag=keywords.get('dataset_id')))
@log(menu=_('Knowledge Base'), operate=_("Re-vectorize")) @log(menu='Knowledge Base', operate="Re-vectorize")
def put(self, request: Request, dataset_id: str): def put(self, request: Request, dataset_id: str):
return result.success( return result.success(
DataSetSerializers.Operate(data={'id': dataset_id, 'user_id': request.user.id}).re_embedding()) DataSetSerializers.Operate(data={'id': dataset_id, 'user_id': request.user.id}).re_embedding())
@ -173,7 +173,7 @@ class Dataset(APIView):
) )
@has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.MANAGE, @has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=keywords.get('dataset_id'))) dynamic_tag=keywords.get('dataset_id')))
@log(menu=_('Knowledge Base'), operate=_("Export knowledge base")) @log(menu='Knowledge Base', operate="Export knowledge base")
def get(self, request: Request, dataset_id: str): def get(self, request: Request, dataset_id: str):
return DataSetSerializers.Operate(data={'id': dataset_id, 'user_id': request.user.id}).export_excel() return DataSetSerializers.Operate(data={'id': dataset_id, 'user_id': request.user.id}).export_excel()
@ -188,7 +188,7 @@ class Dataset(APIView):
) )
@has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.MANAGE, @has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=keywords.get('dataset_id'))) dynamic_tag=keywords.get('dataset_id')))
@log(menu=_('Knowledge Base'), operate=_("Export knowledge base containing images")) @log(menu='Knowledge Base', operate="Export knowledge base containing images")
def get(self, request: Request, dataset_id: str): def get(self, request: Request, dataset_id: str):
return DataSetSerializers.Operate(data={'id': dataset_id, 'user_id': request.user.id}).export_zip() return DataSetSerializers.Operate(data={'id': dataset_id, 'user_id': request.user.id}).export_zip()
@ -204,7 +204,7 @@ class Dataset(APIView):
dynamic_tag=keywords.get('dataset_id')), dynamic_tag=keywords.get('dataset_id')),
lambda r, k: Permission(group=Group.DATASET, operate=Operate.DELETE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.DELETE,
dynamic_tag=k.get('dataset_id')), compare=CompareConstants.AND) dynamic_tag=k.get('dataset_id')), compare=CompareConstants.AND)
@log(menu=_('Knowledge Base'), operate=_("Delete knowledge base")) @log(menu='Knowledge Base', operate="Delete knowledge base")
def delete(self, request: Request, dataset_id: str): def delete(self, request: Request, dataset_id: str):
operate = DataSetSerializers.Operate(data={'id': dataset_id}) operate = DataSetSerializers.Operate(data={'id': dataset_id})
return result.success(operate.delete()) return result.success(operate.delete())
@ -217,7 +217,7 @@ class Dataset(APIView):
tags=[_('Knowledge Base')]) tags=[_('Knowledge Base')])
@has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.USE, @has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=keywords.get('dataset_id'))) dynamic_tag=keywords.get('dataset_id')))
@log(menu=_('Knowledge Base'), operate=_("Query knowledge base details based on knowledge base id")) @log(menu='Knowledge Base', operate="Query knowledge base details based on knowledge base id")
def get(self, request: Request, dataset_id: str): def get(self, request: Request, dataset_id: str):
return result.success(DataSetSerializers.Operate(data={'id': dataset_id, 'user_id': request.user.id}).one( return result.success(DataSetSerializers.Operate(data={'id': dataset_id, 'user_id': request.user.id}).one(
user_id=request.user.id)) user_id=request.user.id))
@ -232,7 +232,7 @@ class Dataset(APIView):
) )
@has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.MANAGE, @has_permissions(lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=keywords.get('dataset_id'))) dynamic_tag=keywords.get('dataset_id')))
@log(menu=_('Knowledge Base'), operate=_("Modify knowledge base information")) @log(menu='Knowledge Base', operate="Modify knowledge base information")
def put(self, request: Request, dataset_id: str): def put(self, request: Request, dataset_id: str):
return result.success( return result.success(
DataSetSerializers.Operate(data={'id': dataset_id, 'user_id': request.user.id}).edit(request.data, DataSetSerializers.Operate(data={'id': dataset_id, 'user_id': request.user.id}).edit(request.data,
@ -250,7 +250,7 @@ class Dataset(APIView):
tags=[_('Knowledge Base')] tags=[_('Knowledge Base')]
) )
@has_permissions(PermissionConstants.DATASET_READ, compare=CompareConstants.AND) @has_permissions(PermissionConstants.DATASET_READ, compare=CompareConstants.AND)
@log(menu=_('Knowledge Base'), operate=_("Get the knowledge base paginated list")) @log(menu='Knowledge Base', operate="Get the knowledge base paginated list")
def get(self, request: Request, current_page, page_size): def get(self, request: Request, current_page, page_size):
d = DataSetSerializers.Query( d = DataSetSerializers.Query(
data={'name': request.query_params.get('name', None), 'desc': request.query_params.get("desc", None), data={'name': request.query_params.get('name', None), 'desc': request.query_params.get("desc", None),
@ -268,7 +268,7 @@ class Dataset(APIView):
[lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.MANAGE, [lambda r, keywords: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=keywords.get('dataset_id'))], dynamic_tag=keywords.get('dataset_id'))],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu=_('Knowledge Base'), operate=_("Get the model list of the knowledge base")) @log(menu='Knowledge Base', operate="Get the model list of the knowledge base")
def get(self, request: Request, dataset_id: str): def get(self, request: Request, dataset_id: str):
return result.success( return result.success(
ModelSerializer.Query( ModelSerializer.Query(

52
apps/dataset/views/document.py
View File

@ -32,7 +32,7 @@ class Template(APIView):
operation_id=_('Get QA template'), operation_id=_('Get QA template'),
manual_parameters=DocumentSerializers.Export.get_request_params_api(), manual_parameters=DocumentSerializers.Export.get_request_params_api(),
tags=[_('Knowledge Base/Documentation')]) tags=[_('Knowledge Base/Documentation')])
@log(menu=_('Knowledge Base/Documentation'), operate=_("Get QA template")) @log(menu='Knowledge Base/Documentation', operate="Get QA template")
def get(self, request: Request): def get(self, request: Request):
return DocumentSerializers.Export(data={'type': request.query_params.get('type')}).export(with_valid=True) return DocumentSerializers.Export(data={'type': request.query_params.get('type')}).export(with_valid=True)
@ -45,7 +45,7 @@ class TableTemplate(APIView):
operation_id=_('Get form template'), operation_id=_('Get form template'),
manual_parameters=DocumentSerializers.Export.get_request_params_api(), manual_parameters=DocumentSerializers.Export.get_request_params_api(),
tags=[_('Knowledge Base/Documentation')]) tags=[_('Knowledge Base/Documentation')])
@log(menu=_('Knowledge Base/Documentation'), operate=_("Get form template")) @log(menu='Knowledge Base/Documentation', operate="Get form template")
def get(self, request: Request): def get(self, request: Request):
return DocumentSerializers.Export(data={'type': request.query_params.get('type')}).table_export(with_valid=True) return DocumentSerializers.Export(data={'type': request.query_params.get('type')}).table_export(with_valid=True)
@ -63,7 +63,7 @@ class WebDocument(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Create Web site documents")) @log(menu='Knowledge Base/Documentation', operate="Create Web site documents")
def post(self, request: Request, dataset_id: str): def post(self, request: Request, dataset_id: str):
return result.success( return result.success(
DocumentSerializers.Create(data={'dataset_id': dataset_id}).save_web(request.data, with_valid=True)) DocumentSerializers.Create(data={'dataset_id': dataset_id}).save_web(request.data, with_valid=True))
@ -82,7 +82,7 @@ class QaDocument(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Import QA and create documentation")) @log(menu='Knowledge Base/Documentation', operate="Import QA and create documentation")
def post(self, request: Request, dataset_id: str): def post(self, request: Request, dataset_id: str):
return result.success( return result.success(
DocumentSerializers.Create(data={'dataset_id': dataset_id}).save_qa( DocumentSerializers.Create(data={'dataset_id': dataset_id}).save_qa(
@ -103,7 +103,7 @@ class TableDocument(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Import tables and create documents")) @log(menu='Knowledge Base/Documentation', operate="Import tables and create documents")
def post(self, request: Request, dataset_id: str): def post(self, request: Request, dataset_id: str):
return result.success( return result.success(
DocumentSerializers.Create(data={'dataset_id': dataset_id}).save_table( DocumentSerializers.Create(data={'dataset_id': dataset_id}).save_table(
@ -124,7 +124,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Document'), operate=_("Create document")) @log(menu='Knowledge Base/Document', operate="Create document")
def post(self, request: Request, dataset_id: str): def post(self, request: Request, dataset_id: str):
return result.success( return result.success(
DocumentSerializers.Create(data={'dataset_id': dataset_id}).save(request.data, with_valid=True)) DocumentSerializers.Create(data={'dataset_id': dataset_id}).save(request.data, with_valid=True))
@ -138,7 +138,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Document list")) @log(menu='Knowledge Base/Documentation', operate="Document list")
def get(self, request: Request, dataset_id: str): def get(self, request: Request, dataset_id: str):
d = DocumentSerializers.Query( d = DocumentSerializers.Query(
data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id}) data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id})
@ -159,7 +159,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Modify document hit processing methods in batches")) @log(menu='Knowledge Base/Documentation', operate="Modify document hit processing methods in batches")
def put(self, request: Request, dataset_id: str): def put(self, request: Request, dataset_id: str):
return result.success( return result.success(
DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_edit_hit_handling(request.data)) DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_edit_hit_handling(request.data))
@ -179,7 +179,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Create documents in batches")) @log(menu='Knowledge Base/Documentation', operate="Create documents in batches")
def post(self, request: Request, dataset_id: str): def post(self, request: Request, dataset_id: str):
return result.success(DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_save(request.data)) return result.success(DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_save(request.data))
@ -194,7 +194,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Batch sync documents")) @log(menu='Knowledge Base/Documentation', operate="Batch sync documents")
def put(self, request: Request, dataset_id: str): def put(self, request: Request, dataset_id: str):
return result.success(DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_sync(request.data)) return result.success(DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_sync(request.data))
@ -209,7 +209,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Delete documents in batches")) @log(menu='Knowledge Base/Documentation', operate="Delete documents in batches")
def delete(self, request: Request, dataset_id: str): def delete(self, request: Request, dataset_id: str):
return result.success(DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_delete(request.data)) return result.success(DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_delete(request.data))
@ -226,7 +226,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Synchronize web site types")) @log(menu='Knowledge Base/Documentation', operate="Synchronize web site types")
def put(self, request: Request, dataset_id: str, document_id: str): def put(self, request: Request, dataset_id: str, document_id: str):
return result.success( return result.success(
DocumentSerializers.Sync(data={'document_id': document_id, 'dataset_id': dataset_id}).sync( DocumentSerializers.Sync(data={'document_id': document_id, 'dataset_id': dataset_id}).sync(
@ -246,7 +246,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Cancel task")) @log(menu='Knowledge Base/Documentation', operate="Cancel task")
def put(self, request: Request, dataset_id: str, document_id: str): def put(self, request: Request, dataset_id: str, document_id: str):
return result.success( return result.success(
DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}).cancel( DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}).cancel(
@ -267,7 +267,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Cancel tasks in batches")) @log(menu='Knowledge Base/Documentation', operate="Cancel tasks in batches")
def put(self, request: Request, dataset_id: str): def put(self, request: Request, dataset_id: str):
return result.success( return result.success(
DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_cancel(request.data)) DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_cancel(request.data))
@ -286,7 +286,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Refresh document vector library")) @log(menu='Knowledge Base/Documentation', operate="Refresh document vector library")
def put(self, request: Request, dataset_id: str, document_id: str): def put(self, request: Request, dataset_id: str, document_id: str):
return result.success( return result.success(
DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}).refresh( DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}).refresh(
@ -307,7 +307,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Batch refresh document vector library")) @log(menu='Knowledge Base/Documentation', operate="Batch refresh document vector library")
def put(self, request: Request, dataset_id: str): def put(self, request: Request, dataset_id: str):
return result.success( return result.success(
DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_refresh(request.data)) DocumentSerializers.Batch(data={'dataset_id': dataset_id}).batch_refresh(request.data))
@ -330,7 +330,7 @@ class Document(APIView):
dynamic_tag=k.get('target_dataset_id')), dynamic_tag=k.get('target_dataset_id')),
compare=CompareConstants.AND compare=CompareConstants.AND
) )
@log(menu=_('Knowledge Base/Documentation'), operate=_("Migrate documents in batches")) @log(menu='Knowledge Base/Documentation', operate="Migrate documents in batches")
def put(self, request: Request, dataset_id: str, target_dataset_id: str): def put(self, request: Request, dataset_id: str, target_dataset_id: str):
return result.success( return result.success(
DocumentSerializers.Migrate( DocumentSerializers.Migrate(
@ -350,7 +350,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Export document")) @log(menu='Knowledge Base/Documentation', operate="Export document")
def get(self, request: Request, dataset_id: str, document_id: str): def get(self, request: Request, dataset_id: str, document_id: str):
return DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}).export() return DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}).export()
@ -365,7 +365,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Export Zip document")) @log(menu='Knowledge Base/Documentation', operate="Export Zip document")
def get(self, request: Request, dataset_id: str, document_id: str): def get(self, request: Request, dataset_id: str, document_id: str):
return DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}).export_zip() return DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}).export_zip()
@ -381,7 +381,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Get document details")) @log(menu='Knowledge Base/Documentation', operate="Get document details")
def get(self, request: Request, dataset_id: str, document_id: str): def get(self, request: Request, dataset_id: str, document_id: str):
operate = DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}) operate = DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id})
operate.is_valid(raise_exception=True) operate.is_valid(raise_exception=True)
@ -398,7 +398,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Modify document")) @log(menu='Knowledge Base/Documentation', operate="Modify document")
def put(self, request: Request, dataset_id: str, document_id: str): def put(self, request: Request, dataset_id: str, document_id: str):
return result.success( return result.success(
DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}).edit( DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}).edit(
@ -414,7 +414,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Delete document")) @log(menu='Knowledge Base/Documentation', operate="Delete document")
def delete(self, request: Request, dataset_id: str, document_id: str): def delete(self, request: Request, dataset_id: str, document_id: str):
operate = DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id}) operate = DocumentSerializers.Operate(data={'document_id': document_id, 'dataset_id': dataset_id})
operate.is_valid(raise_exception=True) operate.is_valid(raise_exception=True)
@ -427,7 +427,7 @@ class Document(APIView):
@swagger_auto_schema(operation_summary=_('Get a list of segment IDs'), @swagger_auto_schema(operation_summary=_('Get a list of segment IDs'),
operation_id=_('Get a list of segment IDs'), operation_id=_('Get a list of segment IDs'),
tags=[_('Knowledge Base/Documentation')]) tags=[_('Knowledge Base/Documentation')])
@log(menu=_('Knowledge Base/Documentation'), operate=_("Get a list of segment IDs")) @log(menu='Knowledge Base/Documentation', operate="Get a list of segment IDs")
def get(self, request: Request): def get(self, request: Request):
return result.success(DocumentSerializers.SplitPattern.list()) return result.success(DocumentSerializers.SplitPattern.list())
@ -440,7 +440,7 @@ class Document(APIView):
operation_id=_('Segmented document'), operation_id=_('Segmented document'),
manual_parameters=DocumentSerializers.Split.get_request_params_api(), manual_parameters=DocumentSerializers.Split.get_request_params_api(),
tags=[_('Knowledge Base/Documentation')]) tags=[_('Knowledge Base/Documentation')])
@log(menu=_('Knowledge Base/Documentation'), operate=_("Segmented document")) @log(menu='Knowledge Base/Documentation', operate="Segmented document")
def post(self, request: Request): def post(self, request: Request):
split_data = {'file': request.FILES.getlist('file')} split_data = {'file': request.FILES.getlist('file')}
request_data = request.data request_data = request.data
@ -468,7 +468,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Get the knowledge base paginated list")) @log(menu='Knowledge Base/Documentation', operate="Get the knowledge base paginated list")
def get(self, request: Request, dataset_id: str, current_page, page_size): def get(self, request: Request, dataset_id: str, current_page, page_size):
d = DocumentSerializers.Query( d = DocumentSerializers.Query(
data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id}) data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id})
@ -482,7 +482,7 @@ class Document(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation'), operate=_("Batch generate related documents")) @log(menu='Knowledge Base/Documentation', operate="Batch generate related documents")
def put(self, request: Request, dataset_id: str): def put(self, request: Request, dataset_id: str):
return result.success(DocumentSerializers.BatchGenerateRelated(data={'dataset_id': dataset_id}) return result.success(DocumentSerializers.BatchGenerateRelated(data={'dataset_id': dataset_id})
.batch_generate_related(request.data)) .batch_generate_related(request.data))

2
apps/dataset/views/file.py
View File

@ -33,7 +33,7 @@ class FileView(APIView):
required=True, required=True,
description=_('Upload file'))], description=_('Upload file'))],
tags=[_('file')]) tags=[_('file')])
@log(menu=_('file'), operate=_('Upload file')) @log(menu='file', operate='Upload file')
def post(self, request: Request): def post(self, request: Request):
return result.success(FileSerializer(data={'file': request.FILES.get('file')}).upload()) return result.success(FileSerializer(data={'file': request.FILES.get('file')}).upload())

3
apps/dataset/views/image.py
View File

@ -33,7 +33,7 @@ class Image(APIView):
required=True, required=True,
description=_('Upload image'))], description=_('Upload image'))],
tags=[_('Image')]) tags=[_('Image')])
@log(menu=_('Image'), operate=_('Upload image')) @log(menu='Image', operate='Upload image')
def post(self, request: Request): def post(self, request: Request):
return result.success(ImageSerializer(data={'image': request.FILES.get('file')}).upload()) return result.success(ImageSerializer(data={'image': request.FILES.get('file')}).upload())
@ -42,6 +42,5 @@ class Image(APIView):
@swagger_auto_schema(operation_summary=_('Get Image'), @swagger_auto_schema(operation_summary=_('Get Image'),
operation_id=_('Get Image'), operation_id=_('Get Image'),
tags=[_('Image')]) tags=[_('Image')])
@log(menu=_('Image'), operate=_('Get Image'))
def get(self, request: Request, image_id: str): def get(self, request: Request, image_id: str):
return ImageSerializer.Operate(data={'id': image_id}).get() return ImageSerializer.Operate(data={'id': image_id}).get()

26
apps/dataset/views/paragraph.py
View File

@ -34,7 +34,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Paragraph list')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Paragraph list')
def get(self, request: Request, dataset_id: str, document_id: str): def get(self, request: Request, dataset_id: str, document_id: str):
q = ParagraphSerializers.Query( q = ParagraphSerializers.Query(
data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id, data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id,
@ -52,7 +52,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Create Paragraph')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Create Paragraph')
def post(self, request: Request, dataset_id: str, document_id: str): def post(self, request: Request, dataset_id: str, document_id: str):
return result.success( return result.success(
ParagraphSerializers.Create(data={'dataset_id': dataset_id, 'document_id': document_id}).save(request.data)) ParagraphSerializers.Create(data={'dataset_id': dataset_id, 'document_id': document_id}).save(request.data))
@ -70,7 +70,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Add associated questions')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Add associated questions')
def post(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str): def post(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str):
return result.success(ParagraphSerializers.Problem( return result.success(ParagraphSerializers.Problem(
data={"dataset_id": dataset_id, 'document_id': document_id, 'paragraph_id': paragraph_id}).save( data={"dataset_id": dataset_id, 'document_id': document_id, 'paragraph_id': paragraph_id}).save(
@ -86,7 +86,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Get a list of paragraph questions')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Get a list of paragraph questions')
def get(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str): def get(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str):
return result.success(ParagraphSerializers.Problem( return result.success(ParagraphSerializers.Problem(
data={"dataset_id": dataset_id, 'document_id': document_id, 'paragraph_id': paragraph_id}).list( data={"dataset_id": dataset_id, 'document_id': document_id, 'paragraph_id': paragraph_id}).list(
@ -104,7 +104,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Disassociation issue')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Disassociation issue')
def put(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str, problem_id: str): def put(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str, problem_id: str):
return result.success(ParagraphSerializers.Association( return result.success(ParagraphSerializers.Association(
data={'dataset_id': dataset_id, 'document_id': document_id, 'paragraph_id': paragraph_id, data={'dataset_id': dataset_id, 'document_id': document_id, 'paragraph_id': paragraph_id,
@ -122,7 +122,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Related questions')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Related questions')
def put(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str, problem_id: str): def put(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str, problem_id: str):
return result.success(ParagraphSerializers.Association( return result.success(ParagraphSerializers.Association(
data={'dataset_id': dataset_id, 'document_id': document_id, 'paragraph_id': paragraph_id, data={'dataset_id': dataset_id, 'document_id': document_id, 'paragraph_id': paragraph_id,
@ -141,7 +141,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Modify paragraph data')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Modify paragraph data')
def put(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str): def put(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str):
o = ParagraphSerializers.Operate( o = ParagraphSerializers.Operate(
data={"paragraph_id": paragraph_id, 'dataset_id': dataset_id, 'document_id': document_id}) data={"paragraph_id": paragraph_id, 'dataset_id': dataset_id, 'document_id': document_id})
@ -157,7 +157,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Get paragraph details')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Get paragraph details')
def get(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str): def get(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str):
o = ParagraphSerializers.Operate( o = ParagraphSerializers.Operate(
data={"dataset_id": dataset_id, 'document_id': document_id, "paragraph_id": paragraph_id}) data={"dataset_id": dataset_id, 'document_id': document_id, "paragraph_id": paragraph_id})
@ -173,7 +173,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Delete paragraph')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Delete paragraph')
def delete(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str): def delete(self, request: Request, dataset_id: str, document_id: str, paragraph_id: str):
o = ParagraphSerializers.Operate( o = ParagraphSerializers.Operate(
data={"dataset_id": dataset_id, 'document_id': document_id, "paragraph_id": paragraph_id}) data={"dataset_id": dataset_id, 'document_id': document_id, "paragraph_id": paragraph_id})
@ -194,7 +194,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Delete paragraphs in batches')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Delete paragraphs in batches')
def delete(self, request: Request, dataset_id: str, document_id: str): def delete(self, request: Request, dataset_id: str, document_id: str):
return result.success(ParagraphSerializers.Batch( return result.success(ParagraphSerializers.Batch(
data={"dataset_id": dataset_id, 'document_id': document_id}).batch_delete(request.data)) data={"dataset_id": dataset_id, 'document_id': document_id}).batch_delete(request.data))
@ -217,7 +217,7 @@ class Paragraph(APIView):
dynamic_tag=k.get('target_dataset_id')), dynamic_tag=k.get('target_dataset_id')),
compare=CompareConstants.AND compare=CompareConstants.AND
) )
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Migrate paragraphs in batches')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Migrate paragraphs in batches')
def put(self, request: Request, dataset_id: str, target_dataset_id: str, document_id: str, target_document_id): def put(self, request: Request, dataset_id: str, target_dataset_id: str, document_id: str, target_document_id):
return result.success( return result.success(
ParagraphSerializers.Migrate( ParagraphSerializers.Migrate(
@ -239,7 +239,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Get paragraph list by pagination')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Get paragraph list by pagination')
def get(self, request: Request, dataset_id: str, document_id: str, current_page, page_size): def get(self, request: Request, dataset_id: str, document_id: str, current_page, page_size):
d = ParagraphSerializers.Query( d = ParagraphSerializers.Query(
data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id, data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id,
@ -254,7 +254,7 @@ class Paragraph(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph'), operate=_('Batch generate related')) @log(menu='Knowledge Base/Documentation/Paragraph', operate='Batch generate related')
def put(self, request: Request, dataset_id: str, document_id: str): def put(self, request: Request, dataset_id: str, document_id: str):
return result.success( return result.success(
ParagraphSerializers.BatchGenerateRelated(data={'dataset_id': dataset_id, 'document_id': document_id}) ParagraphSerializers.BatchGenerateRelated(data={'dataset_id': dataset_id, 'document_id': document_id})

16
apps/dataset/views/problem.py
View File

@ -34,7 +34,7 @@ class Problem(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph/Question'), operate=_('Question list')) @log(menu='Knowledge Base/Documentation/Paragraph/Question', operate='Question list')
def get(self, request: Request, dataset_id: str): def get(self, request: Request, dataset_id: str):
q = ProblemSerializers.Query( q = ProblemSerializers.Query(
data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id}) data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id})
@ -51,7 +51,7 @@ class Problem(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph/Question'), operate=_('Create question')) @log(menu='Knowledge Base/Documentation/Paragraph/Question', operate='Create question')
def post(self, request: Request, dataset_id: str): def post(self, request: Request, dataset_id: str):
return result.success( return result.success(
ProblemSerializers.Create( ProblemSerializers.Create(
@ -69,7 +69,7 @@ class Problem(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph/Question'), operate=_('Get a list of associated paragraphs')) @log(menu='Knowledge Base/Documentation/Paragraph/Question', operate='Get a list of associated paragraphs')
def get(self, request: Request, dataset_id: str, problem_id: str): def get(self, request: Request, dataset_id: str, problem_id: str):
return result.success(ProblemSerializers.Operate( return result.success(ProblemSerializers.Operate(
data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id, data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id,
@ -89,7 +89,7 @@ class Problem(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph/Question'), operate=_('Batch deletion issues')) @log(menu='Knowledge Base/Documentation/Paragraph/Question', operate='Batch deletion issues')
def delete(self, request: Request, dataset_id: str): def delete(self, request: Request, dataset_id: str):
return result.success( return result.success(
ProblemSerializers.BatchOperate(data={'dataset_id': dataset_id}).delete(request.data)) ProblemSerializers.BatchOperate(data={'dataset_id': dataset_id}).delete(request.data))
@ -104,7 +104,7 @@ class Problem(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph/Question'), operate=_('Batch associated paragraphs')) @log(menu='Knowledge Base/Documentation/Paragraph/Question', operate='Batch associated paragraphs')
def post(self, request: Request, dataset_id: str): def post(self, request: Request, dataset_id: str):
return result.success( return result.success(
ProblemSerializers.BatchOperate(data={'dataset_id': dataset_id}).association(request.data)) ProblemSerializers.BatchOperate(data={'dataset_id': dataset_id}).association(request.data))
@ -121,7 +121,7 @@ class Problem(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph/Question'), operate=_('Delete question')) @log(menu='Knowledge Base/Documentation/Paragraph/Question', operate='Delete question')
def delete(self, request: Request, dataset_id: str, problem_id: str): def delete(self, request: Request, dataset_id: str, problem_id: str):
return result.success(ProblemSerializers.Operate( return result.success(ProblemSerializers.Operate(
data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id, data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id,
@ -137,7 +137,7 @@ class Problem(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.MANAGE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph/Question'), operate=_('Modify question')) @log(menu='Knowledge Base/Documentation/Paragraph/Question', operate='Modify question')
def put(self, request: Request, dataset_id: str, problem_id: str): def put(self, request: Request, dataset_id: str, problem_id: str):
return result.success(ProblemSerializers.Operate( return result.success(ProblemSerializers.Operate(
data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id, data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id,
@ -156,7 +156,7 @@ class Problem(APIView):
@has_permissions( @has_permissions(
lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE, lambda r, k: Permission(group=Group.DATASET, operate=Operate.USE,
dynamic_tag=k.get('dataset_id'))) dynamic_tag=k.get('dataset_id')))
@log(menu=_('Knowledge Base/Documentation/Paragraph/Question'), operate=_('Get the list of questions by page')) @log(menu='Knowledge Base/Documentation/Paragraph/Question', operate='Get the list of questions by page')
def get(self, request: Request, dataset_id: str, current_page, page_size): def get(self, request: Request, dataset_id: str, current_page, page_size):
d = ProblemSerializers.Query( d = ProblemSerializers.Query(
data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id}) data={**query_params_to_single_dict(request.query_params), 'dataset_id': dataset_id})

22
apps/function_lib/views/function_lib_views.py
View File

@ -30,7 +30,7 @@ class FunctionLibView(APIView):
tags=[_('Function')], tags=[_('Function')],
manual_parameters=FunctionLibApi.Query.get_request_params_api()) manual_parameters=FunctionLibApi.Query.get_request_params_api())
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Get function list")) @log(menu='Function', operate="Get function list")
def get(self, request: Request): def get(self, request: Request):
return result.success( return result.success(
FunctionLibSerializer.Query( FunctionLibSerializer.Query(
@ -45,7 +45,7 @@ class FunctionLibView(APIView):
request_body=FunctionLibApi.Create.get_request_body_api(), request_body=FunctionLibApi.Create.get_request_body_api(),
tags=[_('Function')]) tags=[_('Function')])
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Create function")) @log(menu='Function', operate="Create function")
def post(self, request: Request): def post(self, request: Request):
return result.success(FunctionLibSerializer.Create(data={'user_id': request.user.id}).insert(request.data)) return result.success(FunctionLibSerializer.Create(data={'user_id': request.user.id}).insert(request.data))
@ -58,7 +58,7 @@ class FunctionLibView(APIView):
request_body=FunctionLibApi.Debug.get_request_body_api(), request_body=FunctionLibApi.Debug.get_request_body_api(),
tags=[_('Function')]) tags=[_('Function')])
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Debug function")) @log(menu='Function', operate="Debug function")
def post(self, request: Request): def post(self, request: Request):
return result.success( return result.success(
FunctionLibSerializer.Debug(data={'user_id': request.user.id}).debug( FunctionLibSerializer.Debug(data={'user_id': request.user.id}).debug(
@ -73,7 +73,7 @@ class FunctionLibView(APIView):
request_body=FunctionLibApi.Edit.get_request_body_api(), request_body=FunctionLibApi.Edit.get_request_body_api(),
tags=[_('Function')]) tags=[_('Function')])
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Update function")) @log(menu='Function', operate="Update function")
def put(self, request: Request, function_lib_id: str): def put(self, request: Request, function_lib_id: str):
return result.success( return result.success(
FunctionLibSerializer.Operate(data={'user_id': request.user.id, 'id': function_lib_id}).edit( FunctionLibSerializer.Operate(data={'user_id': request.user.id, 'id': function_lib_id}).edit(
@ -84,7 +84,7 @@ class FunctionLibView(APIView):
operation_id=_('Delete function'), operation_id=_('Delete function'),
tags=[_('Function')]) tags=[_('Function')])
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Delete function")) @log(menu='Function', operate="Delete function")
def delete(self, request: Request, function_lib_id: str): def delete(self, request: Request, function_lib_id: str):
return result.success( return result.success(
FunctionLibSerializer.Operate(data={'user_id': request.user.id, 'id': function_lib_id}).delete()) FunctionLibSerializer.Operate(data={'user_id': request.user.id, 'id': function_lib_id}).delete())
@ -94,7 +94,7 @@ class FunctionLibView(APIView):
operation_id=_('Get function details'), operation_id=_('Get function details'),
tags=[_('Function')]) tags=[_('Function')])
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Get function details")) @log(menu='Function', operate="Get function details")
def get(self, request: Request, function_lib_id: str): def get(self, request: Request, function_lib_id: str):
return result.success( return result.success(
FunctionLibSerializer.Operate(data={'user_id': request.user.id, 'id': function_lib_id}).one()) FunctionLibSerializer.Operate(data={'user_id': request.user.id, 'id': function_lib_id}).one())
@ -110,7 +110,7 @@ class FunctionLibView(APIView):
responses=result.get_page_api_response(FunctionLibApi.get_response_body_api()), responses=result.get_page_api_response(FunctionLibApi.get_response_body_api()),
tags=[_('Function')]) tags=[_('Function')])
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Get function list by pagination")) @log(menu='Function', operate="Get function list by pagination")
def get(self, request: Request, current_page: int, page_size: int): def get(self, request: Request, current_page: int, page_size: int):
return result.success( return result.success(
FunctionLibSerializer.Query( FunctionLibSerializer.Query(
@ -131,7 +131,7 @@ class FunctionLibView(APIView):
tags=[_("function")] tags=[_("function")]
) )
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Import function")) @log(menu='Function', operate="Import function")
def post(self, request: Request): def post(self, request: Request):
return result.success(FunctionLibSerializer.Import( return result.success(FunctionLibSerializer.Import(
data={'user_id': request.user.id, 'file': request.FILES.get('file')}).import_()) data={'user_id': request.user.id, 'file': request.FILES.get('file')}).import_())
@ -145,7 +145,7 @@ class FunctionLibView(APIView):
tags=[_("function")] tags=[_("function")]
) )
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Export function")) @log(menu='Function', operate="Export function")
def get(self, request: Request, id: str): def get(self, request: Request, id: str):
return FunctionLibSerializer.Operate( return FunctionLibSerializer.Operate(
data={'id': id, 'user_id': request.user.id}).export() data={'id': id, 'user_id': request.user.id}).export()
@ -156,7 +156,7 @@ class FunctionLibView(APIView):
@action(methods=['PUT'], detail=False) @action(methods=['PUT'], detail=False)
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Edit icon")) @log(menu='Function', operate="Edit icon")
def put(self, request: Request, id: str): def put(self, request: Request, id: str):
return result.success( return result.success(
FunctionLibSerializer.IconOperate( FunctionLibSerializer.IconOperate(
@ -168,7 +168,7 @@ class FunctionLibView(APIView):
@action(methods=['POST'], detail=False) @action(methods=['POST'], detail=False)
@has_permissions(RoleConstants.ADMIN, RoleConstants.USER) @has_permissions(RoleConstants.ADMIN, RoleConstants.USER)
@log(menu=_('Function'), operate=_("Add internal function")) @log(menu='Function', operate="Add internal function")
def post(self, request: Request, id: str): def post(self, request: Request, id: str):
return result.success( return result.success(
FunctionLibSerializer.InternalFunction( FunctionLibSerializer.InternalFunction(

6
apps/locales/en_US/LC_MESSAGES/django.po
View File

@ -6767,3 +6767,9 @@ msgstr ""
msgid "Is it ascending order" msgid "Is it ascending order"
msgstr "" msgstr ""
msgid "Create QA knowledge base"
msgstr ""
msgid "Synchronize the knowledge base of the website"
msgstr ""

6
apps/locales/zh_CN/LC_MESSAGES/django.po
View File

@ -6906,3 +6906,9 @@ msgstr "网络繁忙，请稍后再试。"
msgid "Is it ascending order" msgid "Is it ascending order"
msgstr "是否升序" msgstr "是否升序"
msgid "Create QA knowledge base"
msgstr "创建QA知识库"
msgid "Synchronize the knowledge base of the website"
msgstr "同步Web站点知识库"

6
apps/locales/zh_Hant/LC_MESSAGES/django.po
View File

@ -6918,3 +6918,9 @@ msgstr "網絡繁忙，請稍後再試。"
msgid "Is it ascending order" msgid "Is it ascending order"
msgstr "是否昇冪" msgstr "是否昇冪"
msgid "Create QA knowledge base"
msgstr "創建QA知識庫"
msgid "Synchronize the knowledge base of the website"
msgstr "同步Web網站知識庫"

15
apps/setting/models_provider/base_model_provider.py
View File

@ -16,6 +16,8 @@ from pydantic.v1 import BaseModel
from common.exception.app_exception import AppApiException from common.exception.app_exception import AppApiException
from django.utils.translation import gettext_lazy as _ from django.utils.translation import gettext_lazy as _
from common.util.common import encryption
class DownModelChunkStatus(Enum): class DownModelChunkStatus(Enum):
success = "success" success = "success"
@ -137,18 +139,7 @@ class BaseModelCredential(ABC):
:param message: :param message:
:return: :return:
""" """
max_pre_len = 8 return encryption(message)
max_post_len = 4
message_len = len(message)
pre_len = int(message_len / 5 * 2)
post_len = int(message_len / 5 * 1)
pre_str = "".join([message[index] for index in
range(0, max_pre_len if pre_len > max_pre_len else 1 if pre_len <= 0 else int(pre_len))])
end_str = "".join(
[message[index] for index in
range(message_len - (int(post_len) if pre_len < max_post_len else max_post_len), message_len)])
content = "***************"
return pre_str + content + end_str
class ModelTypeConst(Enum): class ModelTypeConst(Enum):

7
apps/setting/views/Team.py
View File

@ -13,6 +13,7 @@ from rest_framework.views import Request
from common.auth import TokenAuth, has_permissions from common.auth import TokenAuth, has_permissions
from common.constants.permission_constants import PermissionConstants from common.constants.permission_constants import PermissionConstants
from common.log.log import log
from common.response import result from common.response import result
from setting.serializers.team_serializers import TeamMemberSerializer, get_response_body_api, \ from setting.serializers.team_serializers import TeamMemberSerializer, get_response_body_api, \
UpdateTeamMemberPermissionSerializer UpdateTeamMemberPermissionSerializer
@ -28,6 +29,7 @@ class TeamMember(APIView):
responses=result.get_api_response(get_response_body_api()), responses=result.get_api_response(get_response_body_api()),
tags=[_('team')]) tags=[_('team')])
@has_permissions(PermissionConstants.TEAM_READ) @has_permissions(PermissionConstants.TEAM_READ)
@log(menu='team', operate='Get a list of team members')
def get(self, request: Request): def get(self, request: Request):
return result.success(TeamMemberSerializer(data={'team_id': str(request.user.id)}).list_member()) return result.success(TeamMemberSerializer(data={'team_id': str(request.user.id)}).list_member())
@ -37,6 +39,7 @@ class TeamMember(APIView):
request_body=TeamMemberSerializer().get_request_body_api(), request_body=TeamMemberSerializer().get_request_body_api(),
tags=[_('team')]) tags=[_('team')])
@has_permissions(PermissionConstants.TEAM_CREATE) @has_permissions(PermissionConstants.TEAM_CREATE)
@log(menu='team', operate='Add member')
def post(self, request: Request): def post(self, request: Request):
team = TeamMemberSerializer(data={'team_id': str(request.user.id)}) team = TeamMemberSerializer(data={'team_id': str(request.user.id)})
return result.success((team.add_member(**request.data))) return result.success((team.add_member(**request.data)))
@ -50,6 +53,7 @@ class TeamMember(APIView):
request_body=TeamMemberSerializer.get_bach_request_body_api(), request_body=TeamMemberSerializer.get_bach_request_body_api(),
tags=[_('team')]) tags=[_('team')])
@has_permissions(PermissionConstants.TEAM_CREATE) @has_permissions(PermissionConstants.TEAM_CREATE)
@log(menu='team', operate='Add members in batches')
def post(self, request: Request): def post(self, request: Request):
return result.success( return result.success(
TeamMemberSerializer(data={'team_id': request.user.id}).batch_add_member(request.data)) TeamMemberSerializer(data={'team_id': request.user.id}).batch_add_member(request.data))
@ -63,6 +67,7 @@ class TeamMember(APIView):
manual_parameters=TeamMemberSerializer.Operate.get_request_params_api(), manual_parameters=TeamMemberSerializer.Operate.get_request_params_api(),
tags=[_('team')]) tags=[_('team')])
@has_permissions(PermissionConstants.TEAM_READ) @has_permissions(PermissionConstants.TEAM_READ)
@log(menu='team', operate='Get team member permissions')
def get(self, request: Request, member_id: str): def get(self, request: Request, member_id: str):
return result.success(TeamMemberSerializer.Operate( return result.success(TeamMemberSerializer.Operate(
data={'member_id': member_id, 'team_id': str(request.user.id)}).list_member_permission()) data={'member_id': member_id, 'team_id': str(request.user.id)}).list_member_permission())
@ -75,6 +80,7 @@ class TeamMember(APIView):
tags=[_('team')] tags=[_('team')]
) )
@has_permissions(PermissionConstants.TEAM_EDIT) @has_permissions(PermissionConstants.TEAM_EDIT)
@log(menu='team', operate='Update team member permissions')
def put(self, request: Request, member_id: str): def put(self, request: Request, member_id: str):
return result.success(TeamMemberSerializer.Operate( return result.success(TeamMemberSerializer.Operate(
data={'member_id': member_id, 'team_id': str(request.user.id)}).edit(request.data)) data={'member_id': member_id, 'team_id': str(request.user.id)}).edit(request.data))
@ -86,6 +92,7 @@ class TeamMember(APIView):
tags=[_('team')] tags=[_('team')]
) )
@has_permissions(PermissionConstants.TEAM_DELETE) @has_permissions(PermissionConstants.TEAM_DELETE)
@log(menu='team', operate='Remove member')
def delete(self, request: Request, member_id: str): def delete(self, request: Request, member_id: str):
return result.success(TeamMemberSerializer.Operate( return result.success(TeamMemberSerializer.Operate(
data={'member_id': member_id, 'team_id': str(request.user.id)}).delete()) data={'member_id': member_id, 'team_id': str(request.user.id)}).delete())

30
apps/setting/views/model.py
View File

@ -13,10 +13,12 @@ from rest_framework.views import Request
from common.auth import TokenAuth, has_permissions from common.auth import TokenAuth, has_permissions
from common.constants.permission_constants import PermissionConstants from common.constants.permission_constants import PermissionConstants
from common.log.log import log
from common.response import result from common.response import result
from common.util.common import query_params_to_single_dict from common.util.common import query_params_to_single_dict
from setting.models_provider.constants.model_provider_constants import ModelProvideConstants from setting.models_provider.constants.model_provider_constants import ModelProvideConstants
from setting.serializers.provider_serializers import ProviderSerializer, ModelSerializer, get_default_model_params_setting from setting.serializers.provider_serializers import ProviderSerializer, ModelSerializer, \
get_default_model_params_setting
from setting.swagger_api.provide_api import ProvideApi, ModelCreateApi, ModelQueryApi, ModelEditApi from setting.swagger_api.provide_api import ProvideApi, ModelCreateApi, ModelQueryApi, ModelEditApi
from django.utils.translation import gettext_lazy as _ from django.utils.translation import gettext_lazy as _
@ -30,6 +32,7 @@ class Model(APIView):
request_body=ModelCreateApi.get_request_body_api() request_body=ModelCreateApi.get_request_body_api()
, tags=[_('model')]) , tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_CREATE) @has_permissions(PermissionConstants.MODEL_CREATE)
@log(menu='model', operate='Create model')
def post(self, request: Request): def post(self, request: Request):
return result.success( return result.success(
ModelSerializer.Create(data={**request.data, 'user_id': str(request.user.id)}).insert(request.user.id, ModelSerializer.Create(data={**request.data, 'user_id': str(request.user.id)}).insert(request.user.id,
@ -41,6 +44,7 @@ class Model(APIView):
request_body=ModelCreateApi.get_request_body_api() request_body=ModelCreateApi.get_request_body_api()
, tags=[_('model')]) , tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_CREATE) @has_permissions(PermissionConstants.MODEL_CREATE)
@log(menu='model', operate='Download model, trial only with Ollama platform')
def put(self, request: Request): def put(self, request: Request):
return result.success( return result.success(
ModelSerializer.Create(data={**request.data, 'user_id': str(request.user.id)}).insert(request.user.id, ModelSerializer.Create(data={**request.data, 'user_id': str(request.user.id)}).insert(request.user.id,
@ -52,6 +56,7 @@ class Model(APIView):
manual_parameters=ModelQueryApi.get_request_params_api() manual_parameters=ModelQueryApi.get_request_params_api()
, tags=[_('model')]) , tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
@log(menu='model', operate='Get model list')
def get(self, request: Request): def get(self, request: Request):
return result.success( return result.success(
ModelSerializer.Query( ModelSerializer.Query(
@ -62,10 +67,14 @@ class Model(APIView):
authentication_classes = [TokenAuth] authentication_classes = [TokenAuth]
@action(methods=['GET'], detail=False) @action(methods=['GET'], detail=False)
@swagger_auto_schema(operation_summary=_('Query model meta information, this interface does not carry authentication information'), @swagger_auto_schema(operation_summary=_(
operation_id=_('Query model meta information, this interface does not carry authentication information'), 'Query model meta information, this interface does not carry authentication information'),
tags=[_('model')]) operation_id=_(
'Query model meta information, this interface does not carry authentication information'),
tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
@log(menu='model',
operate='Query model meta information, this interface does not carry authentication information')
def get(self, request: Request, model_id: str): def get(self, request: Request, model_id: str):
return result.success( return result.success(
ModelSerializer.Operate(data={'id': model_id, 'user_id': request.user.id}).one_meta(with_valid=True)) ModelSerializer.Operate(data={'id': model_id, 'user_id': request.user.id}).one_meta(with_valid=True))
@ -78,6 +87,8 @@ class Model(APIView):
operation_id=_('Pause model download'), operation_id=_('Pause model download'),
tags=[_('model')]) tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_CREATE) @has_permissions(PermissionConstants.MODEL_CREATE)
@log(menu='model',
operate='Pause model download')
def put(self, request: Request, model_id: str): def put(self, request: Request, model_id: str):
return result.success( return result.success(
ModelSerializer.Operate(data={'id': model_id, 'user_id': request.user.id}).pause_download()) ModelSerializer.Operate(data={'id': model_id, 'user_id': request.user.id}).pause_download())
@ -91,6 +102,7 @@ class Model(APIView):
manual_parameters=ProvideApi.ModelForm.get_request_params_api(), manual_parameters=ProvideApi.ModelForm.get_request_params_api(),
tags=[_('model')]) tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
@log(menu='model', operate='Get model parameter form')
def get(self, request: Request, model_id: str): def get(self, request: Request, model_id: str):
return result.success( return result.success(
ModelSerializer.ModelParams(data={'id': model_id, 'user_id': request.user.id}).get_model_params()) ModelSerializer.ModelParams(data={'id': model_id, 'user_id': request.user.id}).get_model_params())
@ -101,6 +113,7 @@ class Model(APIView):
manual_parameters=ProvideApi.ModelForm.get_request_params_api(), manual_parameters=ProvideApi.ModelForm.get_request_params_api(),
tags=[_('model')]) tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
@log(menu='model', operate='Save model parameter form')
def put(self, request: Request, model_id: str): def put(self, request: Request, model_id: str):
return result.success( return result.success(
ModelSerializer.ModelParamsForm(data={'id': model_id, 'user_id': request.user.id}) ModelSerializer.ModelParamsForm(data={'id': model_id, 'user_id': request.user.id})
@ -115,6 +128,7 @@ class Model(APIView):
request_body=ModelEditApi.get_request_body_api() request_body=ModelEditApi.get_request_body_api()
, tags=[_('model')]) , tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_CREATE) @has_permissions(PermissionConstants.MODEL_CREATE)
@log(menu='model', operate='Update model')
def put(self, request: Request, model_id: str): def put(self, request: Request, model_id: str):
return result.success( return result.success(
ModelSerializer.Operate(data={'id': model_id, 'user_id': request.user.id}).edit(request.data, ModelSerializer.Operate(data={'id': model_id, 'user_id': request.user.id}).edit(request.data,
@ -126,6 +140,7 @@ class Model(APIView):
responses=result.get_default_response() responses=result.get_default_response()
, tags=[_('model')]) , tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_DELETE) @has_permissions(PermissionConstants.MODEL_DELETE)
@log(menu='model', operate='Delete model')
def delete(self, request: Request, model_id: str): def delete(self, request: Request, model_id: str):
return result.success( return result.success(
ModelSerializer.Operate(data={'id': model_id, 'user_id': request.user.id}).delete()) ModelSerializer.Operate(data={'id': model_id, 'user_id': request.user.id}).delete())
@ -134,6 +149,7 @@ class Model(APIView):
@swagger_auto_schema(operation_summary=_('Query model details'), @swagger_auto_schema(operation_summary=_('Query model details'),
operation_id=_('Query model details'), operation_id=_('Query model details'),
tags=[_('model')]) tags=[_('model')])
@log(menu='model', operate='Query model details')
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
def get(self, request: Request, model_id: str): def get(self, request: Request, model_id: str):
return result.success( return result.success(
@ -153,6 +169,7 @@ class Provide(APIView):
request_body=ProvideApi.get_request_body_api() request_body=ProvideApi.get_request_body_api()
, tags=[_('model')]) , tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
@log(menu='model', operate='Call the supplier function to obtain form data')
def post(self, request: Request, provider: str, method: str): def post(self, request: Request, provider: str, method: str):
return result.success( return result.success(
ProviderSerializer(data={'provider': provider, 'method': method}).exec(request.data, with_valid=True)) ProviderSerializer(data={'provider': provider, 'method': method}).exec(request.data, with_valid=True))
@ -162,6 +179,7 @@ class Provide(APIView):
operation_id=_('Get a list of model suppliers') operation_id=_('Get a list of model suppliers')
, tags=[_('model')]) , tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
@log(menu='model', operate='Get a list of model suppliers')
def get(self, request: Request): def get(self, request: Request):
model_type = request.query_params.get('model_type') model_type = request.query_params.get('model_type')
if model_type: if model_type:
@ -185,6 +203,7 @@ class Provide(APIView):
responses=result.get_api_array_response(ProvideApi.ModelTypeList.get_response_body_api()) responses=result.get_api_array_response(ProvideApi.ModelTypeList.get_response_body_api())
, tags=[_('model')]) , tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
@log(menu='model', operate='Get a list of model types')
def get(self, request: Request): def get(self, request: Request):
provider = request.query_params.get('provider') provider = request.query_params.get('provider')
return result.success(ModelProvideConstants[provider].value.get_model_type_list()) return result.success(ModelProvideConstants[provider].value.get_model_type_list())
@ -200,6 +219,7 @@ class Provide(APIView):
, tags=[_('model')] , tags=[_('model')]
) )
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
@log(menu='model', operate='Get the model creation form')
def get(self, request: Request): def get(self, request: Request):
provider = request.query_params.get('provider') provider = request.query_params.get('provider')
model_type = request.query_params.get('model_type') model_type = request.query_params.get('model_type')
@ -219,6 +239,7 @@ class Provide(APIView):
, tags=[_('model')] , tags=[_('model')]
) )
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
@log(menu='model', operate='Get model default parameters')
def get(self, request: Request): def get(self, request: Request):
provider = request.query_params.get('provider') provider = request.query_params.get('provider')
model_type = request.query_params.get('model_type') model_type = request.query_params.get('model_type')
@ -235,6 +256,7 @@ class Provide(APIView):
manual_parameters=ProvideApi.ModelForm.get_request_params_api(), manual_parameters=ProvideApi.ModelForm.get_request_params_api(),
tags=[_('model')]) tags=[_('model')])
@has_permissions(PermissionConstants.MODEL_READ) @has_permissions(PermissionConstants.MODEL_READ)
@log(menu='model', operate='Get the model creation form')
def get(self, request: Request): def get(self, request: Request):
provider = request.query_params.get('provider') provider = request.query_params.get('provider')
model_type = request.query_params.get('model_type') model_type = request.query_params.get('model_type')

4
apps/setting/views/system_setting.py
View File

@ -14,6 +14,7 @@ from rest_framework.views import APIView
from common.auth import TokenAuth, has_permissions from common.auth import TokenAuth, has_permissions
from common.constants.permission_constants import RoleConstants from common.constants.permission_constants import RoleConstants
from common.log.log import log
from common.response import result from common.response import result
from setting.serializers.system_setting import SystemSettingSerializer from setting.serializers.system_setting import SystemSettingSerializer
from setting.swagger_api.system_setting import SystemSettingEmailApi from setting.swagger_api.system_setting import SystemSettingEmailApi
@ -30,6 +31,7 @@ class SystemSetting(APIView):
request_body=SystemSettingEmailApi.get_request_body_api(), tags=[_('Email settings')], request_body=SystemSettingEmailApi.get_request_body_api(), tags=[_('Email settings')],
responses=result.get_api_response(SystemSettingEmailApi.get_response_body_api())) responses=result.get_api_response(SystemSettingEmailApi.get_response_body_api()))
@has_permissions(RoleConstants.ADMIN) @has_permissions(RoleConstants.ADMIN)
@log(menu='Email settings', operate='Create or update email settings')
def put(self, request: Request): def put(self, request: Request):
return result.success( return result.success(
SystemSettingSerializer.EmailSerializer.Create( SystemSettingSerializer.EmailSerializer.Create(
@ -42,6 +44,7 @@ class SystemSetting(APIView):
responses=result.get_default_response(), responses=result.get_default_response(),
tags=[_('Email settings')]) tags=[_('Email settings')])
@has_permissions(RoleConstants.ADMIN) @has_permissions(RoleConstants.ADMIN)
@log(menu='Email settings', operate='Test email settings')
def post(self, request: Request): def post(self, request: Request):
return result.success( return result.success(
SystemSettingSerializer.EmailSerializer.Create( SystemSettingSerializer.EmailSerializer.Create(
@ -53,6 +56,7 @@ class SystemSetting(APIView):
responses=result.get_api_response(SystemSettingEmailApi.get_response_body_api()), responses=result.get_api_response(SystemSettingEmailApi.get_response_body_api()),
tags=[_('Email settings')]) tags=[_('Email settings')])
@has_permissions(RoleConstants.ADMIN) @has_permissions(RoleConstants.ADMIN)
@log(menu='Email settings', operate='Get email settings')
def get(self, request: Request): def get(self, request: Request):
return result.success( return result.success(
SystemSettingSerializer.EmailSerializer.one()) SystemSettingSerializer.EmailSerializer.one())

36
apps/users/views/user.py
View File

@ -18,7 +18,9 @@ from rest_framework.views import Request
from common.auth.authenticate import TokenAuth from common.auth.authenticate import TokenAuth
from common.auth.authentication import has_permissions from common.auth.authentication import has_permissions
from common.constants.permission_constants import PermissionConstants, CompareConstants, ViewPermission, RoleConstants from common.constants.permission_constants import PermissionConstants, CompareConstants, ViewPermission, RoleConstants
from common.log.log import log
from common.response import result from common.response import result
from common.util.common import encryption
from smartdoc.settings import JWT_AUTH from smartdoc.settings import JWT_AUTH
from users.serializers.user_serializers import RegisterSerializer, LoginSerializer, CheckCodeSerializer, \ from users.serializers.user_serializers import RegisterSerializer, LoginSerializer, CheckCodeSerializer, \
RePasswordSerializer, \ RePasswordSerializer, \
@ -36,6 +38,7 @@ class Profile(APIView):
operation_id=_("Get MaxKB related information"), operation_id=_("Get MaxKB related information"),
responses=result.get_api_response(SystemSerializer.get_response_body_api()), responses=result.get_api_response(SystemSerializer.get_response_body_api()),
tags=[_('System parameters')]) tags=[_('System parameters')])
@log(menu='System parameters', operate='Get MaxKB related information')
def get(self, request: Request): def get(self, request: Request):
return result.success(SystemSerializer.get_profile()) return result.success(SystemSerializer.get_profile())
@ -49,6 +52,7 @@ class User(APIView):
responses=result.get_api_response(UserProfile.get_response_body_api()), responses=result.get_api_response(UserProfile.get_response_body_api()),
tags=[]) tags=[])
@has_permissions(PermissionConstants.USER_READ) @has_permissions(PermissionConstants.USER_READ)
@log(menu='User', operate='Get current user information')
def get(self, request: Request): def get(self, request: Request):
return result.success(UserProfile.get_user_profile(request.user)) return result.success(UserProfile.get_user_profile(request.user))
@ -62,6 +66,7 @@ class User(APIView):
responses=result.get_api_array_response(UserSerializer.Query.get_response_body_api()), responses=result.get_api_array_response(UserSerializer.Query.get_response_body_api()),
tags=[_("User")]) tags=[_("User")])
@has_permissions(PermissionConstants.USER_READ) @has_permissions(PermissionConstants.USER_READ)
@log(menu='User', operate='Get user list')
def get(self, request: Request): def get(self, request: Request):
return result.success( return result.success(
UserSerializer.Query(data={'email_or_username': request.query_params.get('email_or_username')}).list()) UserSerializer.Query(data={'email_or_username': request.query_params.get('email_or_username')}).list())
@ -83,6 +88,7 @@ class SwitchUserLanguageView(APIView):
), ),
responses=RePasswordSerializer().get_response_body_api(), responses=RePasswordSerializer().get_response_body_api(),
tags=[_("User")]) tags=[_("User")])
@log(menu='User', operate='Switch Language')
def post(self, request: Request): def post(self, request: Request):
data = {**request.data, 'user_id': request.user.id} data = {**request.data, 'user_id': request.user.id}
return result.success(SwitchLanguageSerializer(data=data).switch()) return result.success(SwitchLanguageSerializer(data=data).switch())
@ -108,6 +114,7 @@ class ResetCurrentUserPasswordView(APIView):
), ),
responses=RePasswordSerializer().get_response_body_api(), responses=RePasswordSerializer().get_response_body_api(),
tags=[_("User")]) tags=[_("User")])
@log(menu='User', operate='Modify current user password')
def post(self, request: Request): def post(self, request: Request):
data = {'email': request.user.email} data = {'email': request.user.email}
data.update(request.data) data.update(request.data)
@ -127,6 +134,7 @@ class SendEmailToCurrentUserView(APIView):
operation_id=_("Send email to current user"), operation_id=_("Send email to current user"),
responses=SendEmailSerializer().get_response_body_api(), responses=SendEmailSerializer().get_response_body_api(),
tags=[_("User")]) tags=[_("User")])
@log(menu='User', operate='Send email to current user')
def post(self, request: Request): def post(self, request: Request):
serializer_obj = SendEmailSerializer(data={'email': request.user.email, 'type': "reset_password"}) serializer_obj = SendEmailSerializer(data={'email': request.user.email, 'type': "reset_password"})
if serializer_obj.is_valid(raise_exception=True): if serializer_obj.is_valid(raise_exception=True):
@ -142,11 +150,23 @@ class Logout(APIView):
operation_id=_("Sign out"), operation_id=_("Sign out"),
responses=SendEmailSerializer().get_response_body_api(), responses=SendEmailSerializer().get_response_body_api(),
tags=[_("User")]) tags=[_("User")])
@log(menu='User', operate='Sign out')
def post(self, request: Request): def post(self, request: Request):
token_cache.delete(request.META.get('HTTP_AUTHORIZATION')) token_cache.delete(request.META.get('HTTP_AUTHORIZATION'))
return result.success(True) return result.success(True)
def _get_details(request):
path = request.path
body = request.data
query = request.query_params
return {
'path': path,
'body': {**body, 'password': encryption(body.get('password', ''))},
'query': query
}
class Login(APIView): class Login(APIView):
@action(methods=['POST'], detail=False) @action(methods=['POST'], detail=False)
@ -156,6 +176,8 @@ class Login(APIView):
responses=LoginSerializer().get_response_body_api(), responses=LoginSerializer().get_response_body_api(),
security=[], security=[],
tags=[_("User")]) tags=[_("User")])
@log(menu='User', operate='Log in', get_user=lambda r: {'user_name': r.data.get('username', None)},
get_details=_get_details)
def post(self, request: Request): def post(self, request: Request):
login_request = LoginSerializer(data=request.data) login_request = LoginSerializer(data=request.data)
# 校验请求参数 # 校验请求参数
@ -175,6 +197,7 @@ class Register(APIView):
responses=RegisterSerializer().get_response_body_api(), responses=RegisterSerializer().get_response_body_api(),
security=[], security=[],
tags=[_("User")]) tags=[_("User")])
@log(menu='User', operate='User registration', get_user=lambda r: {'user_name': r.data.get('username', None)})
def post(self, request: Request): def post(self, request: Request):
serializer_obj = RegisterSerializer(data=request.data) serializer_obj = RegisterSerializer(data=request.data)
if serializer_obj.is_valid(raise_exception=True): if serializer_obj.is_valid(raise_exception=True):
@ -192,6 +215,8 @@ class RePasswordView(APIView):
responses=RePasswordSerializer().get_response_body_api(), responses=RePasswordSerializer().get_response_body_api(),
security=[], security=[],
tags=[_("User")]) tags=[_("User")])
@log(menu='User', operate='Change password',
get_user=lambda r: {'user_name': None, 'email': r.data.get('email', None)})
def post(self, request: Request): def post(self, request: Request):
serializer_obj = RePasswordSerializer(data=request.data) serializer_obj = RePasswordSerializer(data=request.data)
return result.success(serializer_obj.reset_password()) return result.success(serializer_obj.reset_password())
@ -207,6 +232,8 @@ class CheckCode(APIView):
responses=CheckCodeSerializer().get_response_body_api(), responses=CheckCodeSerializer().get_response_body_api(),
security=[], security=[],
tags=[_("User")]) tags=[_("User")])
@log(menu='User', operate='Check whether the verification code is correct',
get_user=lambda r: {'user_name': None, 'email': r.data.get('email', None)})
def post(self, request: Request): def post(self, request: Request):
return result.success(CheckCodeSerializer(data=request.data).is_valid(raise_exception=True)) return result.success(CheckCodeSerializer(data=request.data).is_valid(raise_exception=True))
@ -220,6 +247,8 @@ class SendEmail(APIView):
responses=SendEmailSerializer().get_response_body_api(), responses=SendEmailSerializer().get_response_body_api(),
security=[], security=[],
tags=[_("User")]) tags=[_("User")])
@log(menu='User', operate='Send email',
get_user=lambda r: {'user_name': None, 'email': r.data.get('email', None)})
def post(self, request: Request): def post(self, request: Request):
serializer_obj = SendEmailSerializer(data=request.data) serializer_obj = SendEmailSerializer(data=request.data)
if serializer_obj.is_valid(raise_exception=True): if serializer_obj.is_valid(raise_exception=True):
@ -240,6 +269,7 @@ class UserManage(APIView):
[RoleConstants.ADMIN], [RoleConstants.ADMIN],
[PermissionConstants.USER_READ], [PermissionConstants.USER_READ],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='User', operate='Add user')
def post(self, request: Request): def post(self, request: Request):
return result.success(UserManageSerializer().save(request.data)) return result.success(UserManageSerializer().save(request.data))
@ -257,6 +287,7 @@ class UserManage(APIView):
[RoleConstants.ADMIN], [RoleConstants.ADMIN],
[PermissionConstants.USER_READ], [PermissionConstants.USER_READ],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='User', operate='Get user paginated list')
def get(self, request: Request, current_page, page_size): def get(self, request: Request, current_page, page_size):
d = UserManageSerializer.Query( d = UserManageSerializer.Query(
data={'email_or_username': request.query_params.get('email_or_username', None), data={'email_or_username': request.query_params.get('email_or_username', None),
@ -277,6 +308,7 @@ class UserManage(APIView):
[RoleConstants.ADMIN], [RoleConstants.ADMIN],
[PermissionConstants.USER_READ], [PermissionConstants.USER_READ],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='User', operate='Change password')
def put(self, request: Request, user_id): def put(self, request: Request, user_id):
return result.success( return result.success(
UserManageSerializer.Operate(data={'id': user_id}).re_password(request.data, with_valid=True)) UserManageSerializer.Operate(data={'id': user_id}).re_password(request.data, with_valid=True))
@ -294,6 +326,7 @@ class UserManage(APIView):
[RoleConstants.ADMIN], [RoleConstants.ADMIN],
[PermissionConstants.USER_READ], [PermissionConstants.USER_READ],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='User', operate='Delete user')
def delete(self, request: Request, user_id): def delete(self, request: Request, user_id):
return result.success(UserManageSerializer.Operate(data={'id': user_id}).delete(with_valid=True)) return result.success(UserManageSerializer.Operate(data={'id': user_id}).delete(with_valid=True))
@ -308,6 +341,7 @@ class UserManage(APIView):
[RoleConstants.ADMIN], [RoleConstants.ADMIN],
[PermissionConstants.USER_READ], [PermissionConstants.USER_READ],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='User', operate='Get user information')
def get(self, request: Request, user_id): def get(self, request: Request, user_id):
return result.success(UserManageSerializer.Operate(data={'id': user_id}).one(with_valid=True)) return result.success(UserManageSerializer.Operate(data={'id': user_id}).one(with_valid=True))
@ -323,6 +357,7 @@ class UserManage(APIView):
[RoleConstants.ADMIN], [RoleConstants.ADMIN],
[PermissionConstants.USER_READ], [PermissionConstants.USER_READ],
compare=CompareConstants.AND)) compare=CompareConstants.AND))
@log(menu='User', operate='Update user information')
def put(self, request: Request, user_id): def put(self, request: Request, user_id):
return result.success( return result.success(
UserManageSerializer.Operate(data={'id': user_id}).edit(request.data, with_valid=True)) UserManageSerializer.Operate(data={'id': user_id}).edit(request.data, with_valid=True))
@ -337,5 +372,6 @@ class UserListView(APIView):
responses=result.get_api_array_response(UserSerializer.Query.get_response_body_api()), responses=result.get_api_array_response(UserSerializer.Query.get_response_body_api()),
tags=[_("User")]) tags=[_("User")])
@has_permissions(PermissionConstants.USER_READ) @has_permissions(PermissionConstants.USER_READ)
@log(menu='User', operate='Get user list by type')
def get(self, request: Request, type): def get(self, request: Request, type):
return result.success(UserSerializer().listByType(type, request.user.id)) return result.success(UserSerializer().listByType(type, request.user.id))