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..9d6522779f7 --- /dev/null +++ b/apps/system_manage/api/resource_chat_user.py @@ -0,0 +1,138 @@ +# 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..12729cf63ef --- /dev/null +++ b/apps/system_manage/api/resource_chat_user_group.py @@ -0,0 +1,92 @@ +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 diff --git a/apps/system_manage/serializers/chat_user_serializer.py b/apps/system_manage/serializers/chat_user_serializer.py index 22f10810c8f..279a1486c6d 100644 --- a/apps/system_manage/serializers/chat_user_serializer.py +++ b/apps/system_manage/serializers/chat_user_serializer.py @@ -4,7 +4,7 @@ from django.utils.translation import gettext_lazy as _ from rest_framework import serializers -from application.models import ApplicationAccessToken, ChatUserType +from application.models import ApplicationAccessToken from common.auth.common import ChatToken from common.auth.constants.operate_constants import Operate from common.constants.authentication_type import AuthenticationType 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..689d5004ef5 --- /dev/null +++ b/apps/system_manage/serializers/resource_chat_user.py @@ -0,0 +1,178 @@ +# 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..be593e5df94 --- /dev/null +++ b/apps/system_manage/serializers/resource_chat_user_group.py @@ -0,0 +1,132 @@ +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..f857af91886 100644 --- a/apps/system_manage/views/__init__.py +++ b/apps/system_manage/views/__init__.py @@ -1,11 +1,12 @@ # coding=utf-8 """ - @project: MaxKB - @Author：虎虎 - @file： __init__.py.py - @date：2025/4/16 19:07 - @desc: +@project: MaxKB +@Author：虎虎 +@file： __init__.py.py +@date：2025/4/16 19:07 +@desc: """ + from .user_resource_permission import * from .email_setting import * from .system_profile import * @@ -13,3 +14,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..70e9026a108 --- /dev/null +++ b/apps/system_manage/views/resource_chat_user.py @@ -0,0 +1,184 @@ +# 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) + ) diff --git a/apps/system_manage/views/user_group_resource_permission.py b/apps/system_manage/views/user_group_resource_permission.py index 50d96594065..d0c699a73c1 100644 --- a/apps/system_manage/views/user_group_resource_permission.py +++ b/apps/system_manage/views/user_group_resource_permission.py @@ -17,12 +17,9 @@ from common.auth import TokenAuth from common.auth.authentication import has_permissions from common.auth.constants.compare_constants import CompareConstants -from common.auth.constants.group_constants import Group -from common.auth.constants.operate_constants import Operate 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.log.log import log from system_manage.api.user_resource_permission import ( UserResourcePermissionAPI,