diff --git a/apps/homepage/serializers/homepage.py b/apps/homepage/serializers/homepage.py index 75d87810229..6bc2d592c6a 100644 --- a/apps/homepage/serializers/homepage.py +++ b/apps/homepage/serializers/homepage.py @@ -289,11 +289,9 @@ def aggregation(self, auth, with_valid=True): auth, data["user_id"], data.get("workspace_id") ), ) - return { - "total_tokens": query.aggregate( - total_tokens=Coalesce(Sum(F("message_tokens") + F("answer_tokens"), output_field=IntegerField()), 0) - )["total_tokens"] - } + return query.aggregate( + total_tokens=Coalesce(Sum(F("message_tokens") + F("answer_tokens"), output_field=IntegerField()), 0) + )["total_tokens"] class ChatRecordAggregation(serializers.Serializer): workspace_id = serializers.CharField(required=False, allow_null=True, label=_("Workspace ID")) @@ -312,7 +310,7 @@ def aggregation(self, auth, with_valid=True): auth, data["user_id"], data.get("workspace_id") ), ) - return {"total_count": query.aggregate(total_count=Count("id"))["total_count"]} + return {query.aggregate(total_count=Count("id"))["total_count"]} class ApplicationTokensRanking(serializers.Serializer): workspace_id = serializers.CharField(required=False, allow_null=True, label=_("Workspace ID")) @@ -371,7 +369,7 @@ def ranking(self, auth, current_page, page_size, with_valid=True): def export(self, auth, with_valid=True): if with_valid: self.is_valid(raise_exception=True) - tokens_total = SystemHomePageSerializer.TokensAggregation(data=self.data).aggregation(auth)["total_tokens"] + tokens_total = SystemHomePageSerializer.TokensAggregation(data=self.data).aggregation(auth) queryset = self.get_queryset(auth, with_valid=False) workbook = openpyxl.Workbook(write_only=True) worksheet = workbook.create_sheet(title="Sheet1") @@ -561,7 +559,7 @@ def ranking(self, auth, current_page, page_size, with_valid=True): def export(self, auth, with_valid=True): if with_valid: self.is_valid(raise_exception=True) - token_count = SystemHomePageSerializer.TokensAggregation(data=self.data).aggregation(auth)["total_tokens"] + token_count = SystemHomePageSerializer.TokensAggregation(data=self.data).aggregation(auth) queryset, asker_map = self.get_queryset(auth, with_valid=False) workbook = openpyxl.Workbook(write_only=True) worksheet = workbook.create_sheet(title="Sheet1") diff --git a/apps/system_manage/api/resource_chat_user.py b/apps/system_manage/api/resource_chat_user.py new file mode 100644 index 00000000000..db9f3decc58 --- /dev/null +++ b/apps/system_manage/api/resource_chat_user.py @@ -0,0 +1,122 @@ +# coding=utf-8 +""" + @project: MaxKB-xpack + @Author：虎虎 + @file： resource_chat_user.py + @date：2025/6/5 16:22 + @desc: +""" +from drf_spectacular.types import OpenApiTypes +from drf_spectacular.utils import OpenApiParameter + +from common.mixins.api_mixin import APIMixin +from common.result import ResultSerializer, ResultPageSerializer +from system_manage.serializers.resource_chat_user import ResourceChatUserResultSerializer, ResourceChatUserEditSerializer + + +class ResourceChatUserListResult(ResultSerializer): + def get_data(self): + return ResourceChatUserResultSerializer(many=True) + + +class ResourceChatUserPageListResult(ResultPageSerializer): + def get_data(self): + return ResourceChatUserResultSerializer(many=True) + + +class WorkspaceResourceChatUserListAPI(APIMixin): + @staticmethod + def get_parameters(): + return [OpenApiParameter( + name="workspace_id", + description="工作空间id", + type=OpenApiTypes.STR, + location='path', + required=True, + ), OpenApiParameter( + name="resource_type", + description="资源类型", + type=OpenApiTypes.STR, + location='path', + required=True, + ), OpenApiParameter( + name="resource_id", + description="资源id", + type=OpenApiTypes.STR, + location='path', + required=True, + ), OpenApiParameter( + name="user_group_id", + description="用户组id", + type=OpenApiTypes.STR, + location='path', + required=False, + ), OpenApiParameter( + name="username", + description="用户名", + type=OpenApiTypes.STR, + required=False, + ), OpenApiParameter( + name="nick_name", + description="昵称", + type=OpenApiTypes.STR, + required=False, + ), + OpenApiParameter( + name="source", + description="来源", + type=OpenApiTypes.STR, + required=False, + )] + + @staticmethod + def get_response(): + return ResourceChatUserListResult + + +class ResourceChatUserPageAPI(APIMixin): + @staticmethod + def get_parameters(): + return WorkspaceResourceChatUserListAPI.get_parameters() + + @staticmethod + def get_response(): + return ResourceChatUserPageListResult + + +class EditResourceChatUserAPI(APIMixin): + @staticmethod + def get_parameters(): + return [OpenApiParameter( + name="workspace_id", + description="工作空间id", + type=OpenApiTypes.STR, + location='path', + required=True, + ), OpenApiParameter( + name="resource_type", + description="资源类型", + type=OpenApiTypes.STR, + location='path', + required=True, + ), OpenApiParameter( + name="resource_id", + description="资源id", + type=OpenApiTypes.STR, + location='path', + required=True, + ), OpenApiParameter( + name="user_group_id", + description="用户组id", + type=OpenApiTypes.STR, + location='path', + required=False, + )] + + @staticmethod + def get_request(): + return ResourceChatUserEditSerializer + + @staticmethod + def get_response(): + pass diff --git a/apps/system_manage/api/resource_chat_user_group.py b/apps/system_manage/api/resource_chat_user_group.py new file mode 100644 index 00000000000..26ba552fec4 --- /dev/null +++ b/apps/system_manage/api/resource_chat_user_group.py @@ -0,0 +1,79 @@ +from drf_spectacular.types import OpenApiTypes +from drf_spectacular.utils import OpenApiParameter +from rest_framework import serializers +from django.utils.translation import gettext_lazy as _ + +from common.mixins.api_mixin import APIMixin +from common.result import ResultPageSerializer +from system_manage.models import UserGroup +from system_manage.serializers.resource_chat_user_group import ResourceChatUserGroupEditSerializer + + +class ResourceChatUserGroupListAPI(APIMixin): + @staticmethod + def get_parameters(): + return [OpenApiParameter( + name="workspace_id", + description="工作空间id", + type=OpenApiTypes.STR, + location='path', + required=True, + ),OpenApiParameter( + name="resource_type", + description="资源类型", + type=OpenApiTypes.STR, + location='path', + required=True, + ),OpenApiParameter( + name="resource_id", + description="资源id", + type=OpenApiTypes.STR, + location='path', + required=True, + ), OpenApiParameter( + name="user_group_name", + description="用户组名", + type=OpenApiTypes.STR, + required=False, + )] +class ResourceChatUserResultSerializer(serializers.ModelSerializer): + is_auth = serializers.BooleanField(required=True, label=_('is auth')) + + class Meta: + model = UserGroup + fields = '__all__' + +class ResourceChatUserGroupEditResult(ResultPageSerializer): + def get_data(self): + return ResourceChatUserResultSerializer() + +class ResourceChatUserGroupEditAPI(APIMixin): + @staticmethod + def get_parameters(): + return [OpenApiParameter( + name="workspace_id", + description="工作空间id", + type=OpenApiTypes.STR, + location='path', + required=True, + ), OpenApiParameter( + name="resource_type", + description="资源类型", + type=OpenApiTypes.STR, + location='path', + required=True, + ), OpenApiParameter( + name="resource_id", + description="资源id", + type=OpenApiTypes.STR, + location='path', + required=True, + ),] + + @staticmethod + def get_request(): + return ResourceChatUserGroupEditSerializer + + @staticmethod + def get_response(): + return \ No newline at end of file diff --git a/apps/system_manage/serializers/resource_chat_user.py b/apps/system_manage/serializers/resource_chat_user.py new file mode 100644 index 00000000000..bbb8e08f53e --- /dev/null +++ b/apps/system_manage/serializers/resource_chat_user.py @@ -0,0 +1,165 @@ +# coding=utf-8 +""" + @project: MaxKB-xpack + @Author：虎虎 + @file： resource_chat_user.py + @date：2025/6/5 16:25 + @desc: +""" +import os +from typing import List, Dict + +from django.db import models +from django.db.models import QuerySet, Q +from django.utils.translation import gettext_lazy as _ +from rest_framework import serializers + +from common.db.search import get_dynamics_model, native_page_search, native_search +from common.exception.app_exception import AppApiException +from common.utils.common import get_file_content +from maxkb.conf import PROJECT_DIR +from system_manage.models import ChatUser, ResourceChatUserAuthorize + + +class ResourceChatUserResultSerializer(serializers.ModelSerializer): + is_auth = serializers.BooleanField(required=True, label=_('is auth')) + + class Meta: + model = ChatUser + fields = '__all__' + + +class ResourceChatUserQuerySerializer(serializers.Serializer): + workspace_id = serializers.CharField(required=False, label=_('workspace id')) + resource_type = serializers.CharField(required=True, label=_('Resource type')) + resource_id = serializers.UUIDField(required=True, label=_('Resource id')) + username = serializers.CharField(required=False, allow_null=True, + label=_('Username')) + nick_name = serializers.CharField(required=False, allow_null=True, + label=_('Nickname')) + source = serializers.CharField(required=False, allow_null=True, + label=_('Source')) + + user_group_id = serializers.CharField(required=True, label=_('User group id')) + + def get_query_set(self): + username = self.data.get('username') + nick_name = self.data.get('nick_name') + source = self.data.get('source') + workspace_id = self.data.get("workspace_id") + user_group_id = self.data.get('user_group_id') + resource_id = self.data.get('resource_id') + resource_type = self.data.get('resource_type') + resource_chat_user_authorize_query_set = QuerySet(ResourceChatUserAuthorize).filter(resource_id=resource_id, + resource_type=resource_type) + query_set = QuerySet(model=get_dynamics_model({ + 'username': models.CharField(), + 'nick_name': models.CharField(), + 'source': models.CharField(), + "user_group_relation.group_id": models.CharField(), + 'create_time': models.DateTimeField() + })) + if username is not None: + query_set = query_set.filter( + Q(username__contains=username)) + if nick_name is not None: + query_set = query_set.filter( + Q(nick_name__contains=nick_name)) + if source is not None: + query_set = query_set.filter( + Q(source=source)) + if workspace_id is not None: + resource_chat_user_authorize_query_set = resource_chat_user_authorize_query_set.filter( + workspace_id=workspace_id) + else: + resource_chat_user_authorize_query_set = resource_chat_user_authorize_query_set.filter( + workspace_id__isnull=True) + if user_group_id is not None: + query_set = query_set.filter(**{'user_group_relation.group_id': user_group_id}) + query_set = query_set.order_by("-create_time") + return {'default_query_set': query_set, + 'resource_chat_user_authorize_query_set': resource_chat_user_authorize_query_set} + + def list(self): + self.is_valid(raise_exception=True) + return native_search( + self.get_query_set(), + select_string=get_file_content( + os.path.join(PROJECT_DIR, "apps", "system_manage", 'sql', 'list_resource_chat_user.sql') + ) + ) + + def page(self, current_page: int, page_size: int): + self.is_valid(raise_exception=True) + return native_page_search( + current_page, + page_size, + self.get_query_set(), + select_string=get_file_content( + os.path.join(PROJECT_DIR, "apps", "system_manage", 'sql', 'list_resource_chat_user.sql') + ), + post_records_handler=lambda r: r + ) + + +class ResourceChatUserEditItemSerializer(serializers.Serializer): + chat_user_id = serializers.UUIDField(required=True, label=_("Chat user id")) + is_auth = serializers.BooleanField(required=True, label=_("Is auth")) + + +class ResourceChatUserEditSerializer(serializers.ListSerializer): + child = ResourceChatUserEditItemSerializer(required=True) + + def is_valid(self, *, raise_exception=False): + super().is_valid(raise_exception=True) + chat_user_list = QuerySet(ChatUser).values('id').filter( + id__in=[instance.get('chat_user_id') for instance in self.data]) + if len(chat_user_list) != len(self.data): + raise AppApiException(500, "存在未知的chat_user_id") + + +class ResourceChatUserSerializer(serializers.Serializer): + workspace_id = serializers.CharField(required=False, label=_('workspace id')) + resource_type = serializers.CharField(required=True, label=_('Resource type')) + resource_id = serializers.UUIDField(required=True, label=_('Resource id')) + user_group_id = serializers.CharField(required=True, label=_('User group id')) + + def edit(self, instance_list: List[Dict]): + self.is_valid(raise_exception=True) + ResourceChatUserEditSerializer(data=instance_list).is_valid(raise_exception=True) + + workspace_id = self.data.get('workspace_id') + resource_id = self.data.get('resource_id') + resource_type = self.data.get('resource_type') + user_group_id = self.data.get('user_group_id') + resource_chat_user_authorize_list = [ + ResourceChatUserAuthorize(workspace_id=workspace_id, user_id=instance.get('chat_user_id'), + is_auth=instance.get('is_auth'), + user_group_id=user_group_id, + resource_id=resource_id, resource_type=resource_type) for instance in + instance_list] + QuerySet(ResourceChatUserAuthorize).filter( + user_id__in=[instance.get('chat_user_id') for instance in instance_list], resource_id=resource_id, + resource_type=resource_type).filter( + **({'user_group_id__isnull': True} if user_group_id is None else {'user_group_id': user_group_id})).delete() + old_resource_chat_user_authorize_list = [] + create_list = [] + update_list = [] + for resource_chat_user_authorize in resource_chat_user_authorize_list: + is_exist = False + for old_resource_chat_user_authorize in old_resource_chat_user_authorize_list: + if (resource_chat_user_authorize.resource_id == str(old_resource_chat_user_authorize.resource_id) and + resource_chat_user_authorize.user_id == str(old_resource_chat_user_authorize.user_id) + and str(resource_chat_user_authorize.user_group_id) == str( + old_resource_chat_user_authorize.user_group_id)): + old_resource_chat_user_authorize.is_auth = resource_chat_user_authorize.is_auth + update_list.append(old_resource_chat_user_authorize) + is_exist = True + break + if not is_exist: + create_list.append(resource_chat_user_authorize) + QuerySet(ResourceChatUserAuthorize).bulk_create(create_list) if len( + create_list) > 0 else None + QuerySet(ResourceChatUserAuthorize).bulk_update(update_list, ['is_auth']) if len( + update_list) > 0 else None + return True diff --git a/apps/system_manage/serializers/resource_chat_user_group.py b/apps/system_manage/serializers/resource_chat_user_group.py new file mode 100644 index 00000000000..0ec162c17f9 --- /dev/null +++ b/apps/system_manage/serializers/resource_chat_user_group.py @@ -0,0 +1,123 @@ +import os +from typing import List + +from django.db.models import QuerySet +from django.utils.translation import gettext_lazy as _ +from rest_framework import serializers + +from common.db.search import native_search, native_page_search +from common.exception.app_exception import AppApiException +from common.utils.common import get_file_content +from maxkb.conf import PROJECT_DIR +from system_manage.models import ResourceChatUserGroupAuthorize, UserGroup + + +class ResourceChatUserGroupQuerySerializer(serializers.Serializer): + workspace_id = serializers.CharField(required=False, label=_('workspace id')) + resource_type = serializers.CharField(required=True, label=_('Resource type')) + resource_id = serializers.UUIDField(required=True, label=_('Resource id')) + user_group_name = serializers.CharField(required=False, allow_null=True, allow_blank=True, + label=_('User group name')) + + def get_query_set(self): + workspace_id = self.data.get('workspace_id') + resource_type = self.data.get('resource_type') + resource_id = self.data.get('resource_id') + user_group_name = self.data.get('user_group_name') + + resource_chat_user_group_authorize_query_set = QuerySet( + ResourceChatUserGroupAuthorize).filter(resource_id=resource_id, + resource_type=resource_type) + query_set = QuerySet(UserGroup) + if user_group_name is not None: + query_set = query_set.filter(name__contains=user_group_name) + if workspace_id is not None: + resource_chat_user_group_authorize_query_set = resource_chat_user_group_authorize_query_set.filter( + workspace_id=workspace_id + ) + else: + resource_chat_user_group_authorize_query_set = resource_chat_user_group_authorize_query_set.filter( + workspace_id__isnull=True + ) + return {'default_query_set': query_set, + 'resource_chat_user_group_authorize_query_set': resource_chat_user_group_authorize_query_set + } + + def list(self): + self.is_valid(raise_exception=True) + return native_search( + self.get_query_set(), + select_string=get_file_content( + os.path.join(PROJECT_DIR, "apps", "system_manage", "sql", "list_resource_chat_user_group.sql") + )) + + def page(self, current_page: int, page_size: int): + self.is_valid(raise_exception=True) + return native_page_search( + current_page, + page_size, + self.get_query_set(), + select_string=get_file_content( + os.path.join(PROJECT_DIR, "apps", "system_manage", "sql", "list_resource_chat_user_group.sql") + ), + post_records_handler=lambda r: r + ) + + +class ResourceChatUserGroupEditItemSerializer(serializers.Serializer): + user_group_id = serializers.CharField(required=True, label=_('user_group_id')) + is_auth = serializers.BooleanField(required=True, label=_('is auth')) + + +class ResourceChatUserGroupEditSerializer(serializers.ListSerializer): + child = ResourceChatUserGroupEditItemSerializer(required=True) + + def is_valid(self, *, raise_exception=False): + super().is_valid(raise_exception=True) + user_group_list = QuerySet(UserGroup).values('id').filter( + id__in=[instance.get('user_group_id') for instance in self.data]) + if len(user_group_list) != len(self.data): + raise AppApiException(500, "存在未知的user_group_id") + + +class ResourceChatUserGroupSerializer(serializers.Serializer): + workspace_id = serializers.CharField(required=False, label=_('workspace id')) + resource_type = serializers.CharField(required=True, label=_('Resource type')) + resource_id = serializers.UUIDField(required=True, label=_('Resource id')) + + def edit(self, instance_list: List[dict]): + self.is_valid(raise_exception=True) + ResourceChatUserGroupEditSerializer(data=instance_list).is_valid(raise_exception=True) + + workspace_id = self.data.get('workspace_id') + resource_id = self.data.get('resource_id') + resource_type = self.data.get('resource_type') + resource_chat_user_group_authorize_list = [ + ResourceChatUserGroupAuthorize(workspace_id=workspace_id, + is_auth=instance.get('is_auth'), + user_group_id=instance.get('user_group_id'), + resource_id=resource_id, resource_type=resource_type + ) for instance in instance_list] + old_resource_chat_user_group_authorize_list = QuerySet(ResourceChatUserGroupAuthorize).filter( + user_group_id__in=[instance.get('user_group_id') for instance in instance_list], resource_id=resource_id, + resource_type=resource_type) + create_list = [] + update_list = [] + for resource_chat_user_group_authorize in resource_chat_user_group_authorize_list: + is_exist = False + for old_resource_chat_user_group_authorize in old_resource_chat_user_group_authorize_list: + if (resource_chat_user_group_authorize.resource_id == str( + old_resource_chat_user_group_authorize.resource_id) and + str(resource_chat_user_group_authorize.user_group_id) == str( + old_resource_chat_user_group_authorize.user_group_id)): + old_resource_chat_user_group_authorize.is_auth = resource_chat_user_group_authorize.is_auth + update_list.append(old_resource_chat_user_group_authorize) + is_exist = True + break + if not is_exist: + create_list.append(resource_chat_user_group_authorize) + QuerySet(ResourceChatUserGroupAuthorize).bulk_create(create_list) if len( + create_list) > 0 else None + QuerySet(ResourceChatUserGroupAuthorize).bulk_update(update_list, ['is_auth']) if len( + update_list) > 0 else None + return True diff --git a/apps/system_manage/sql/list_resource_chat_user.sql b/apps/system_manage/sql/list_resource_chat_user.sql new file mode 100644 index 00000000000..9ea643aacad --- /dev/null +++ b/apps/system_manage/sql/list_resource_chat_user.sql @@ -0,0 +1,12 @@ +SELECT chat_user.id, chat_user.username, chat_user.nick_name, chat_user.is_active, + chat_user.source, chat_user.create_time, + COALESCE(resource_chat_user_authorize.is_auth, false) AS is_auth +FROM chat_user + LEFT JOIN user_group_relation + ON chat_user.id = user_group_relation.user_id + + LEFT JOIN (SELECT * + FROM resource_chat_user_authorize ${resource_chat_user_authorize_query_set}) AS resource_chat_user_authorize + ON chat_user.id = resource_chat_user_authorize.user_id + AND resource_chat_user_authorize.user_group_id = user_group_relation.group_id + ${default_query_set} diff --git a/apps/system_manage/sql/list_resource_chat_user_group.sql b/apps/system_manage/sql/list_resource_chat_user_group.sql new file mode 100644 index 00000000000..09f141e3ba3 --- /dev/null +++ b/apps/system_manage/sql/list_resource_chat_user_group.sql @@ -0,0 +1,5 @@ +SELECT user_group.*, COALESCE(resource_chat_user_group_authorize.is_auth,false) as is_auth +FROM "user_group" + LEFT JOIN (SELECT * FROM resource_chat_user_group_authorize ${resource_chat_user_group_authorize_query_set}) resource_chat_user_group_authorize + ON user_group.id = resource_chat_user_group_authorize.user_group_id +${default_query_set} \ No newline at end of file diff --git a/apps/system_manage/urls.py b/apps/system_manage/urls.py index eba3e147583..d785c181384 100644 --- a/apps/system_manage/urls.py +++ b/apps/system_manage/urls.py @@ -16,6 +16,10 @@ path('workspace//resource_user_group_permission/resource//resource///', views.WorkspaceResourceUserGroupPermissionView.Page.as_view()), path('workspace//resource_mapping////', views.ResourceMappingView.as_view()), path('workspace//mapping_resource////', views.MappingResourceView.as_view()), + path('workspace////user_group_id/', views.ResourceChatUser.as_view()), + path('workspace////user_group_id///', views.ResourceChatUser.Page.as_view()), + path('workspace////user_group', views.ResourceChatUserGroup.as_view()), + path('workspace////user_group//', views.ResourceChatUserGroup.Page.as_view()), path('email_setting', views.SystemSetting.Email.as_view()), path('profile', views.SystemProfile.as_view()), path('system/chat_user', views.SystemChatUserView.as_view()), diff --git a/apps/system_manage/views/__init__.py b/apps/system_manage/views/__init__.py index d78a56454bf..39c083a359f 100644 --- a/apps/system_manage/views/__init__.py +++ b/apps/system_manage/views/__init__.py @@ -13,3 +13,5 @@ from .resource_mapping import * from .system_chat_user import * from .user_group_resource_permission import * +from .resource_chat_user import * +from .resource_chat_user_group import * diff --git a/apps/system_manage/views/resource_chat_user.py b/apps/system_manage/views/resource_chat_user.py new file mode 100644 index 00000000000..8892e4837d6 --- /dev/null +++ b/apps/system_manage/views/resource_chat_user.py @@ -0,0 +1,161 @@ +# coding=utf-8 +""" + @project: MaxKB-xpack + @Author：虎虎 + @file： resource_chat_user.py + @date：2025/6/5 16:21 + @desc: +""" +from django.utils.translation import gettext_lazy as _ +from drf_spectacular.utils import extend_schema +from rest_framework.request import Request +from rest_framework.views import APIView + +from common import result +from common.auth import TokenAuth +from common.auth.authentication import has_permissions +from common.auth.constants.compare_constants import CompareConstants +from common.auth.constants.permission_constants import PermissionConstants +from common.auth.constants.role_constants import RoleConstants +from common.auth.struct.aggregate_permission import ViewPermission +from common.auth.struct.permission import Permission + +from system_manage.api.resource_chat_user import WorkspaceResourceChatUserListAPI, EditResourceChatUserAPI, \ + ResourceChatUserPageAPI +from system_manage.serializers.resource_chat_user import ResourceChatUserQuerySerializer, ResourceChatUserSerializer + + +class ResourceChatUser(APIView): + authentication_classes = [TokenAuth] + + @extend_schema( + methods=['GET'], + description=_('Get Resource chat user List'), + summary=_('Get Resource chat user List'), + operation_id=_('Get Resource chat user List'), # type: ignore + parameters=WorkspaceResourceChatUserListAPI.get_parameters(), + responses=WorkspaceResourceChatUserListAPI.get_response(), + tags=[_('Chat user')] # type: ignore + ) + @has_permissions( + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_READ" + ].get_workspace_permission(), + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_READ" + ].get_workspace_permission_workspace_manage_role(), + ViewPermission( + [RoleConstants.USER.get_workspace_role()], + [ + lambda r, kwargs: Permission( + group=PermissionConstants[kwargs.get("resource_type").upper()].value.group, + sub_group=PermissionConstants[kwargs.get("resource_type").upper()].value.sub_group, + operate=PermissionConstants[kwargs.get("resource_type").upper()].value.operate, + bit_index=PermissionConstants[kwargs.get("resource_type").upper()].value.bit_index, + workspace_id=kwargs.get("workspace_id"), + resource_id=kwargs.get("resource_id"), + ) + ], + compare=CompareConstants.AND, + ), + RoleConstants.WORKSPACE_MANAGE.get_workspace_role(), + ) + def get(self, request: Request, workspace_id: str, resource_type: str, resource_id: str, user_group_id: str): + return result.success(ResourceChatUserQuerySerializer( + data={'workspace_id': workspace_id, + 'resource_id': resource_id, + 'resource_type': resource_type, + 'username': request.query_params.get('username'), + 'nick_name': request.query_params.get('nick_name'), + 'source': request.query_params.get('source'), + 'user_group_id': user_group_id}) + .list()) + + @extend_schema( + methods=['PUT'], + description=_('Edit Resource chat user List'), + summary=_('Edit Resource chat user List'), + operation_id=_('Edit Resource chat user List'), # type: ignore + parameters=EditResourceChatUserAPI.get_parameters(), + request=EditResourceChatUserAPI.get_request(), + responses=None, + tags=[_('Chat user')] # type: ignore + ) + @has_permissions( + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_EDIT" + ].get_workspace_permission(), + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_EDIT" + ].get_workspace_permission_workspace_manage_role(), + ViewPermission( + [RoleConstants.USER.get_workspace_role()], + [ + lambda r, kwargs: Permission( + group=PermissionConstants[kwargs.get("resource_type").upper()].value.group, + sub_group=PermissionConstants[kwargs.get("resource_type").upper()].value.sub_group, + operate=PermissionConstants[kwargs.get("resource_type").upper()].value.operate, + bit_index=PermissionConstants[kwargs.get("resource_type").upper()].value.bit_index, + workspace_id=kwargs.get("workspace_id"), + resource_id=kwargs.get("resource_id"), + ) + ], + compare=CompareConstants.AND, + ), + RoleConstants.WORKSPACE_MANAGE.get_workspace_role(), + ) + def put(self, request: Request, workspace_id: str, resource_type, resource_id: str, user_group_id: str): + return result.success(ResourceChatUserSerializer(data={ + 'workspace_id': workspace_id, + 'resource_id': resource_id, + 'resource_type': resource_type, + 'user_group_id': user_group_id + }).edit(request.data)) + + class Page(APIView): + authentication_classes = [TokenAuth] + + @extend_schema( + methods=['GET'], + description=_('Get Resource chat user page List'), + summary=_('Get Resource chat user page List'), + operation_id=_('Get Resource chat user page List'), # type: ignore + parameters=ResourceChatUserPageAPI.get_parameters(), + responses=ResourceChatUserPageAPI.get_response(), + tags=[_('Chat user')] # type: ignore + ) + @has_permissions( + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_READ" + ].get_workspace_permission(), + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_READ" + ].get_workspace_permission_workspace_manage_role(), + ViewPermission( + [RoleConstants.USER.get_workspace_role()], + [ + lambda r, kwargs: Permission( + group=PermissionConstants[kwargs.get("resource_type").upper()].value.group, + sub_group=PermissionConstants[kwargs.get("resource_type").upper()].value.sub_group, + operate=PermissionConstants[kwargs.get("resource_type").upper()].value.operate, + bit_index=PermissionConstants[kwargs.get("resource_type").upper()].value.bit_index, + workspace_id=kwargs.get("workspace_id"), + resource_id=kwargs.get("resource_id"), + ) + ], + compare=CompareConstants.AND, + ), + RoleConstants.WORKSPACE_MANAGE.get_workspace_role(), + ) + def get(self, request: Request, workspace_id: str, resource_type: str, resource_id: str, user_group_id: str, + current_page: int, + page_size: int): + return result.success(ResourceChatUserQuerySerializer( + data={'workspace_id': workspace_id, + 'resource_id': resource_id, + 'resource_type': resource_type, + 'username': request.query_params.get('username'), + 'nick_name': request.query_params.get('nick_name'), + 'source': request.query_params.get('source'), + 'user_group_id': user_group_id}) + .page(current_page, page_size)) diff --git a/apps/system_manage/views/resource_chat_user_group.py b/apps/system_manage/views/resource_chat_user_group.py new file mode 100644 index 00000000000..55c9d139731 --- /dev/null +++ b/apps/system_manage/views/resource_chat_user_group.py @@ -0,0 +1,172 @@ +from django.utils.translation import gettext_lazy as _ +from drf_spectacular.utils import extend_schema +from rest_framework.request import Request +from rest_framework.views import APIView + +from common.auth import TokenAuth +from common.auth.authentication import has_permissions +from common.auth.constants.compare_constants import CompareConstants +from common.auth.constants.permission_constants import PermissionConstants +from common.auth.constants.role_constants import RoleConstants +from common.auth.struct.aggregate_permission import ViewPermission +from common.auth.struct.permission import Permission + +from common.result import result +from system_manage.api.resource_chat_user_group import ResourceChatUserGroupListAPI, ResourceChatUserGroupEditAPI +from system_manage.serializers.resource_chat_user_group import ( + ResourceChatUserGroupQuerySerializer, + ResourceChatUserGroupSerializer, +) + + +class ResourceChatUserGroup(APIView): + authentication_classes = [TokenAuth] + + @extend_schema( + methods=["GET"], + description=_("Get Resource chat user group List"), + summary=_("Get Resource chat user group List"), + operation_id=_("Get Resource chat user group List"), # type: ignore + parameters=ResourceChatUserGroupListAPI.get_parameters(), + responses=None, + tags=[_("Chat user")], # type: ignore + ) + @has_permissions( + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_READ" + ].get_workspace_permission(), + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_READ" + ].get_workspace_permission_workspace_manage_role(), + ViewPermission( + [RoleConstants.USER.get_workspace_role()], + [ + lambda r, kwargs: Permission( + group=PermissionConstants[kwargs.get("resource_type").upper()].value.group, + sub_group=PermissionConstants[kwargs.get("resource_type").upper()].value.sub_group, + operate=PermissionConstants[kwargs.get("resource_type").upper()].value.operate, + bit_index=PermissionConstants[kwargs.get("resource_type").upper()].value.bit_index, + workspace_id=kwargs.get("workspace_id"), + resource_id=kwargs.get("resource_id"), + ) + ], + compare=CompareConstants.AND, + ), + RoleConstants.WORKSPACE_MANAGE.get_workspace_role(), + ) + def get( + self, + request: Request, + workspace_id: str, + resource_id: str, + resource_type: str, + ): + return result.success( + ResourceChatUserGroupQuerySerializer( + data={ + "workspace_id": workspace_id, + "resource_id": resource_id, + "resource_type": resource_type, + "user_group_name": request.query_params.get("user_group_name"), + } + ).list() + ) + + @extend_schema( + methods=["PUT"], + description=_("Edit Resource chat user group List"), + summary=_("Edit Resource chat user group List"), + operation_id=_("Edit Resource chat user group List"), # type: ignore + parameters=ResourceChatUserGroupEditAPI.get_parameters(), + request=ResourceChatUserGroupEditAPI.get_request(), + responses=ResourceChatUserGroupEditAPI.get_response(), + tags=[_("Chat user")], # type: ignore + ) + @has_permissions( + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_EDIT" + ].get_workspace_permission(), + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_EDIT" + ].get_workspace_permission_workspace_manage_role(), + ViewPermission( + [RoleConstants.USER.get_workspace_role()], + [ + lambda r, kwargs: Permission( + group=PermissionConstants[kwargs.get("resource_type").upper()].value.group, + sub_group=PermissionConstants[kwargs.get("resource_type").upper()].value.sub_group, + operate=PermissionConstants[kwargs.get("resource_type").upper()].value.operate, + bit_index=PermissionConstants[kwargs.get("resource_type").upper()].value.bit_index, + workspace_id=kwargs.get("workspace_id"), + resource_id=kwargs.get("resource_id"), + ) + ], + compare=CompareConstants.AND, + ), + RoleConstants.WORKSPACE_MANAGE.get_workspace_role(), + ) + def put(self, request: Request, workspace_id: str, resource_id: str, resource_type: str): + return result.success( + ResourceChatUserGroupSerializer( + data={ + "workspace_id": workspace_id, + "resource_id": resource_id, + "resource_type": resource_type, + } + ).edit(request.data) + ) + + class Page(APIView): + authentication_classes = [TokenAuth] + + @extend_schema( + methods=["GET"], + description=_("Get Resource chat user group page List"), + summary=_("Get Resource chat user page group List"), + operation_id=_("Get Resource chat user group page List"), # type: ignore + parameters=ResourceChatUserGroupListAPI.get_parameters(), + responses=None, + tags=[_("Chat user")], # type: ignore + ) + @has_permissions( + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_READ" + ].get_workspace_permission(), + lambda r, kwargs: PermissionConstants[ + f"{kwargs.get('resource_type').upper()}_CHAT_USER_READ" + ].get_workspace_permission_workspace_manage_role(), + ViewPermission( + [RoleConstants.USER.get_workspace_role()], + [ + lambda r, kwargs: Permission( + group=PermissionConstants[kwargs.get("resource_type").upper()].value.group, + sub_group=PermissionConstants[kwargs.get("resource_type").upper()].value.sub_group, + operate=PermissionConstants[kwargs.get("resource_type").upper()].value.operate, + bit_index=PermissionConstants[kwargs.get("resource_type").upper()].value.bit_index, + workspace_id=kwargs.get("workspace_id"), + resource_id=kwargs.get("resource_id"), + ) + ], + compare=CompareConstants.AND, + ), + RoleConstants.WORKSPACE_MANAGE.get_workspace_role(), + ) + def get( + self, + request: Request, + workspace_id: str, + resource_id: str, + resource_type: str, + current_page: int, + page_size: int, + ): + return result.success( + ResourceChatUserGroupQuerySerializer( + data={ + "workspace_id": workspace_id, + "resource_id": resource_id, + "resource_type": resource_type, + "user_group_name": request.query_params.get("user_group_name"), + } + ).page(current_page, page_size) + )