kdb-bot/src/bot_api/exception/service_error_code_enum.py

@@ -4,6 +4,7 @@ from werkzeug.exceptions import Unauthorized
 
 
 class ServiceErrorCode(Enum):
+
     Unknown = 0
 
     InvalidDependencies = 1

kdb-bot/src/bot_data/db_context.py

@@ -6,6 +6,7 @@ from bot_core.logging.database_logger import DatabaseLogger
 
 class DBContext(DatabaseContext):
     def __init__(self, logger: DatabaseLogger):
+
         self._logger = logger
 
         DatabaseContext.__init__(self)

kdb-bot/src/bot_data/model/auth_role_enum.py

@@ -2,5 +2,6 @@ from enum import Enum
 
 
 class AuthRoleEnum(Enum):
+
     normal = 0
     admin = 1

kdb-bot/src/bot_data/model/auto_role.py

@@ -3,13 +3,11 @@ from typing import Optional
 
 from cpl_core.database import TableABC
 
-from bot_data.model.server import Server
-
 
 class AutoRole(TableABC):
     def __init__(
         self,
-        server: Optional[Server],
+        server_id: int,
         dc_channel_id: int,
         dc_message_id: int,
         created_at: datetime = None,
@@ -17,7 +15,7 @@ class AutoRole(TableABC):
         id=0,
     ):
         self._auto_role_id = id
-        self._server = server
+        self._server_id = server_id
         self._discord_channel_id = dc_channel_id
         self._discord_message_id = dc_message_id
 
@@ -30,8 +28,8 @@ class AutoRole(TableABC):
         return self._auto_role_id
 
     @property
-    def server(self) -> Server:
+    def server_id(self) -> int:
-        return self._server
+        return self._server_id
 
     @property
     def discord_channel_id(self) -> int:
@@ -83,7 +81,7 @@ class AutoRole(TableABC):
             INSERT INTO `AutoRoles` (
                 `ServerId`, `DiscordChannelId`, `DiscordMessageId`, `CreatedAt`, `LastModifiedAt`
             ) VALUES (
-                {self._server.server_id},
+                {self._server_id},
                 {self._discord_channel_id},
                 {self._discord_message_id},
                 '{self._created_at}',
@@ -97,7 +95,7 @@ class AutoRole(TableABC):
         return str(
             f"""
             UPDATE `AutoRoles`
-            SET `ServerId` = {self._server.server_id},
+            SET `ServerId` = {self._server_id},
             `DiscordChannelId` = {self._discord_channel_id},
             `DiscordMessageId` = {self._discord_message_id},
             `LastModifiedAt` = '{self._modified_at}'

kdb-bot/src/bot_data/service/auto_role_repository_service.py

@@ -5,16 +5,14 @@ from cpl_query.extension import List
 
 from bot_core.logging.database_logger import DatabaseLogger
 from bot_data.abc.auto_role_repository_abc import AutoRoleRepositoryABC
-from bot_data.abc.server_repository_abc import ServerRepositoryABC
 from bot_data.model.auto_role import AutoRole
 from bot_data.model.auto_role_rule import AutoRoleRule
 
 
 class AutoRoleRepositoryService(AutoRoleRepositoryABC):
-    def __init__(self, logger: DatabaseLogger, db_context: DatabaseContextABC, servers: ServerRepositoryABC):
+    def __init__(self, logger: DatabaseLogger, db_context: DatabaseContextABC):
         self._logger = logger
         self._context = db_context
-        self._servers = servers
 
         AutoRoleRepositoryABC.__init__(self)
 
@@ -23,20 +21,14 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
         self._logger.trace(__name__, f"Send SQL command: {AutoRole.get_select_all_string()}")
         results = self._context.select(AutoRole.get_select_all_string())
         for result in results:
-            auto_roles.append(
+            auto_roles.append(AutoRole(result[1], result[2], result[3], result[4], result[5], id=result[0]))
-                AutoRole(
-                    self._servers.get_server_by_id(result[1]), result[2], result[3], result[4], result[5], id=result[0]
-                )
-            )
 
         return auto_roles
 
     def get_auto_role_by_id(self, id: int) -> AutoRole:
         self._logger.trace(__name__, f"Send SQL command: {AutoRole.get_select_by_id_string(id)}")
         result = self._context.select(AutoRole.get_select_by_id_string(id))[0]
-        return AutoRole(
+        return AutoRole(result[1], result[2], result[3], result[4], result[5], id=result[0])
-            self._servers.get_server_by_id(result[1]), result[2], result[3], result[4], result[5], id=result[0]
-        )
 
     def find_auto_role_by_id(self, id: int) -> Optional[AutoRole]:
         self._logger.trace(__name__, f"Send SQL command: {AutoRole.get_select_by_id_string(id)}")
@@ -46,20 +38,14 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
 
         result = result[0]
 
-        return AutoRole(
+        return AutoRole(result[1], result[2], result[3], result[4], result[5], id=result[0])
-            self._servers.get_server_by_id(result[1]), result[2], result[3], result[4], result[5], id=result[0]
-        )
 
     def get_auto_roles_by_server_id(self, id: int) -> List[AutoRole]:
         self._logger.trace(__name__, f"Send SQL command: {AutoRole.get_select_by_server_id_string(id)}")
         auto_roles = List(AutoRole)
         results = self._context.select(AutoRole.get_select_by_server_id_string(id))
         for result in results:
-            auto_roles.append(
+            auto_roles.append(AutoRole(result[1], result[2], result[3], result[4], result[5], id=result[0]))
-                AutoRole(
-                    self._servers.get_server_by_id(result[1]), result[2], result[3], result[4], result[5], id=result[0]
-                )
-            )
 
         return auto_roles
 
@@ -69,9 +55,7 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
             f"Send SQL command: {AutoRole.get_select_by_message_id_string(id)}",
         )
         result = self._context.select(AutoRole.get_select_by_message_id_string(id))[0]
-        return AutoRole(
+        return AutoRole(result[1], result[2], result[3], result[4], result[5], id=result[0])
-            self._servers.get_server_by_id(result[1]), result[2], result[3], result[4], result[5], id=result[0]
-        )
 
     def find_auto_role_by_message_id(self, id: int) -> Optional[AutoRole]:
         self._logger.trace(
@@ -84,9 +68,7 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
 
         result = result[0]
 
-        return AutoRole(
+        return AutoRole(result[1], result[2], result[3], result[4], result[5], id=result[0])
-            self._servers.get_server_by_id(result[1]), result[2], result[3], result[4], result[5], id=result[0]
-        )
 
     def add_auto_role(self, auto_role: AutoRole):
         self._logger.trace(__name__, f"Send SQL command: {auto_role.insert_string}")

kdb-bot/src/bot_graphql/abc/query_abc.py

@@ -14,7 +14,7 @@ class QueryABC(ObjectType):
     def __init__(self, name: str):
         ObjectType.__init__(self, name)
 
-    def add_collection(self, name: str, get_collection: Callable, filter_type: type = None):
+    def _add_collection(self, name: str, get_collection: Callable, filter_type: type = None):
         def wrapper(*args, **kwargs):
             if filter_type is not None and "filter" in kwargs:
                 kwargs["filter"] = FilterABC.get_collection_filter(filter_type, kwargs["filter"])

kdb-bot/src/bot_graphql/filter/auto_role_filter.py

@@ -1,4 +1,3 @@
-from cpl_discord.service import DiscordBotServiceABC
 from cpl_query.extension import List
 
 from bot_data.model.auto_role import AutoRole
@@ -6,39 +5,22 @@ from bot_graphql.abc.filter_abc import FilterABC
 
 
 class AutoRoleFilter(FilterABC):
-    def __init__(
+    def __init__(self):
-        self,
-        bot: DiscordBotServiceABC,
-    ):
         FilterABC.__init__(self)
 
-        self._bot = bot
-
         self._id = None
         self._channel_id = None
-        self._channel_name = None
         self._message_id = None
-        self._server = None
 
     def from_dict(self, values: dict):
         if "id" in values:
-            self._id = int(values["id"])
+            self._id = values["id"]
 
         if "channel_id" in values:
-            self._channel_id = int(values["channel_id"])
+            self._channel_id = values["channel_id"]
-
-        if "channel_name" in values:
-            self._channel_name = values["channel_name"]
 
         if "message_id" in values:
-            self._message_id = int(values["message_id"])
+            self._message_id = values["message_id"]
-
-        if "server" in values:
-            from bot_graphql.filter.server_filter import ServerFilter
-
-            server = ServerFilter()
-            server.from_dict(values["server"])
-            self._server = server
 
     def filter(self, query: List[AutoRole]) -> List[AutoRole]:
         if self._id is not None:
@@ -47,17 +29,10 @@ class AutoRoleFilter(FilterABC):
         if self._channel_id is not None:
             query = query.where(lambda x: x.discord_channel_id == self._channel_id)
 
-        if self._channel_name is not None and self._channel_id is not None:
-            query = query.where(
-                lambda x: self._bot.get_channel(x.discord_channel_id).name == self._channel_name
-                or self._channel_name in self._bot.get_channel(x.discord_channel_id).name
-            )
-
         if self._message_id is not None:
             query = query.where(lambda x: x.discord_message_id == self._message_id)
 
-        if self._server is not None:
+        # if self._server_id is not None:
-            servers = self._server.filter(query.select(lambda x: x.server)).select(lambda x: x.server_id)
+        #     query = query.where(lambda x: x.server.server_id == self._server_id)
-            query = query.where(lambda x: x.server.server_id in servers)
 
         return query

kdb-bot/src/bot_graphql/filter/auto_role_rule_filter.py

@@ -15,16 +15,16 @@ class AutoRoleRuleFilter(FilterABC):
 
     def from_dict(self, values: dict):
         if "id" in values:
-            self._id = int(values["id"])
+            self._id = values["id"]
 
         if "emoji_name" in values:
             self._emoji_name = values["emoji_name"]
 
         if "role_id" in values:
-            self._role_id = int(values["role_id"])
+            self._role_id = values["role_id"]
 
         if "auto_role_id" in values:
-            self._auto_role_id = int(values["auto_role_id"])
+            self._auto_role_id = values["auto_role_id"]
 
     def filter(self, query: List[AutoRoleRule]) -> List[AutoRoleRule]:
         if self._id is not None:

kdb-bot/src/bot_graphql/filter/level_filter.py

@@ -14,7 +14,7 @@ class LevelFilter(FilterABC):
 
     def from_dict(self, values: dict):
         if "id" in values:
-            self._id = int(values["id"])
+            self._id = values["id"]
 
         if "name" in values:
             self._name = values["name"]

kdb-bot/src/bot_graphql/filter/page.py

@@ -11,10 +11,10 @@ class Page(FilterABC):
 
     def from_dict(self, values: dict):
         if "page_index" in values:
-            self._page_index = int(values["page_index"])
+            self._page_index = values["page_index"]
 
         if "page_size" in values:
-            self._page_size = int(values["page_size"])
+            self._page_size = values["page_size"]
 
     def filter(self, query: List, *args) -> List:
         if self._page_size is not None and self._page_index is not None:

kdb-bot/src/bot_graphql/filter/server_filter.py

@@ -20,7 +20,7 @@ class ServerFilter(FilterABC):
             self._id = int(values["id"])
 
         if "discord_id" in values:
-            self._discord_id = int(values["discord_id"])
+            self._discord_id = values["discord_id"]
 
         if "name" in values:
             self._name = values["name"]

kdb-bot/src/bot_graphql/filter/user_filter.py

@@ -35,15 +35,15 @@ class UserFilter(FilterABC):
 
     def from_dict(self, values: dict):
         if "id" in values:
-            self._id = int(values["id"])
+            self._id = values["id"]
         if "discord_id" in values:
-            self._discord_id = int(values["discord_id"])
+            self._discord_id = values["discord_id"]
         if "name" in values:
             self._name = values["name"]
         if "xp" in values:
-            self._xp = int(values["xp"])
+            self._xp = values["xp"]
         if "ontime" in values:
-            self._ontime = int(values["ontime"])
+            self._ontime = values["ontime"]
         if "level" in values:
             self._level: LevelFilter = self._services.get_service(LevelFilter)
             self._level.from_dict(values["level"])

kdb-bot/src/bot_graphql/model/auto_role.gql

@@ -1,7 +1,6 @@
 type AutoRole implements TableQuery {
     id: ID
     channel_id: String
-    channel_name: String
     message_id: String
 
     server: Server
@@ -12,11 +11,3 @@ type AutoRole implements TableQuery {
     created_at: String
     modified_at: String
 }
-
-input AutoRoleFilter {
-    id: ID
-    channel_id: String
-    channel_name: String
-    message_id: String
-    server: ServerFilter
-}

kdb-bot/src/bot_graphql/model/auto_role_rule.gql

@@ -8,10 +8,3 @@ type AutoRoleRule implements TableQuery {
     created_at: String
     modified_at: String
 }
-
-input AutoRoleRuleFilter {
-    id: ID
-    emoji_name: String
-    role_id: String
-    auto_role: AutoRoleFilter
-}

kdb-bot/src/bot_graphql/model/client.gql

@@ -13,15 +13,3 @@ type Client implements TableQuery {
     created_at: String
     modified_at: String
 }
-
-input ClientFilter {
-    id: ID
-    discord_id: String
-    name: String
-    sent_message_count: Int
-    received_message_count: Int
-    deleted_message_count: Int
-    received_command_count: Int
-    moved_users_count: Int
-    server: ServerFilter
-}

kdb-bot/src/bot_graphql/model/query.gql

@@ -1,11 +1,11 @@
 type Query {
-    auto_roles(filter: AutoRoleFilter, page: Page, sort: Sort): [AutoRole]
+    auto_roles: [AutoRole]
     auto_role_count: Int
 
-    auto_role_rules(filter: AutoRoleRuleFilter, page: Page, sort: Sort): [AutoRole]
+    auto_role_rules: [AutoRole]
     auto_role_rule_count: Int
 
-    clients(filter: ClientFilter, page: Page, sort: Sort): [Client]
+    clients: [Client]
     client_count: Int
 
     known_users: [KnownUser]
@@ -17,10 +17,10 @@ type Query {
     servers(filter: ServerFilter, page: Page, sort: Sort): [Server]
     server_count: Int
 
-    user_joined_servers(filter: UserJoinedServerFilter, page: Page, sort: Sort): [User]
+    user_joined_servers: [User]
     user_joined_server_count: Int
 
-    user_joined_voice_channels(filter: UserJoinedVoiceChannelFilter, page: Page, sort: Sort): [User]
+    user_joined_voice_channels: [User]
     user_joined_voice_channel_count: Int
 
     users(filter: UserFilter, page: Page, sort: Sort): [User]

kdb-bot/src/bot_graphql/model/user_joined_server.gql

@@ -8,11 +8,3 @@ type UserJoinedServer implements TableQuery {
     created_at: String
     modified_at: String
 }
-
-input UserJoinedServerFilter  {
-    id: ID
-    user: UserFilter
-    server: ServerFilter
-    joined_on: String
-    leaved_on: String
-}

kdb-bot/src/bot_graphql/model/user_joined_voice_channel.gql

@@ -9,12 +9,3 @@ type UserJoinedVoiceChannel implements TableQuery {
     created_at: String
     modified_at: String
 }
-
-input UserJoinedVoiceChannelFilter {
-    id: ID
-    channel_id: String
-    user: UserFilter
-    server: ServerFilter
-    joined_on: String
-    leaved_on: String
-}

kdb-bot/src/bot_graphql/queries/auto_role_query.py

@@ -1,5 +1,3 @@
-from cpl_discord.service import DiscordBotServiceABC
-
 from bot_data.abc.auto_role_repository_abc import AutoRoleRepositoryABC
 from bot_data.abc.server_repository_abc import ServerRepositoryABC
 from bot_data.model.auto_role import AutoRole
@@ -10,22 +8,19 @@ from bot_graphql.filter.server_filter import ServerFilter
 class AutoRoleQuery(DataQueryABC):
     def __init__(
         self,
-        bot: DiscordBotServiceABC,
         auto_role_rules: AutoRoleRepositoryABC,
         servers: ServerRepositoryABC,
     ):
         DataQueryABC.__init__(self, "AutoRole")
 
-        self._bot = bot
         self._auto_role_rules = auto_role_rules
         self._servers = servers
 
         self.set_field("id", self.resolve_id)
         self.set_field("channel_id", self.resolve_channel_id)
-        self.set_field("channel_name", self.resolve_channel_name)
         self.set_field("message_id", self.resolve_message_id)
         self.set_field("server", self.resolve_server)
-        self.add_collection(
+        self._add_collection(
             "auto_role_rule", lambda x, *_: self._auto_role_rules.get_auto_role_rules_by_auto_role_id(x.auto_role_id)
         )
 
@@ -37,16 +32,12 @@ class AutoRoleQuery(DataQueryABC):
     def resolve_channel_id(x: AutoRole, *_):
         return x.discord_channel_id
 
-    def resolve_channel_name(self, x: AutoRole, *_):
-        channel = self._bot.get_channel(x.discord_channel_id)
-        return None if channel is None else channel.name
-
     @staticmethod
     def resolve_message_id(x: AutoRole, *_):
         return x.discord_message_id
 
     def resolve_server(self, x: AutoRole, *_, filter: ServerFilter = None):
         if filter is not None:
-            return filter.filter(self._servers.get_server_by_id(x.server.server_id))
+            return filter.filter(self._servers.get_server_by_id(x.server_id))
 
-        return self._servers.get_server_by_id(x.server.server_id)
+        return self._servers.get_server_by_id(x.server_id)

kdb-bot/src/bot_graphql/queries/server_query.py

@@ -31,12 +31,14 @@ class ServerQuery(DataQueryABC):
         self.set_field("discord_id", self.resolve_discord_id)
         self.set_field("name", self.resolve_name)
 
-        self.add_collection(
+        self._add_collection(
             "auto_role", lambda server, *_: self._auto_roles.get_auto_roles_by_server_id(server.server_id)
         )
-        self.add_collection("client", lambda server, *_: self._clients.get_clients_by_server_id(server.server_id))
+        self._add_collection("client", lambda server, *_: self._clients.get_clients_by_server_id(server.server_id))
-        self.add_collection("user", lambda server, *_: self._users.get_users_by_server_id(server.server_id), UserFilter)
+        self._add_collection(
-        self.add_collection("level", lambda server, *_: self._levels.get_levels_by_server_id(server.server_id))
+            "user", lambda server, *_: self._users.get_users_by_server_id(server.server_id), UserFilter
+        )
+        self._add_collection("level", lambda server, *_: self._levels.get_levels_by_server_id(server.server_id))
 
     @staticmethod
     def resolve_id(server: Server, *_):

kdb-bot/src/bot_graphql/queries/user_query.py

@@ -31,10 +31,10 @@ class UserQuery(DataQueryABC):
         self.set_field("xp", self.resolve_xp)
         self.set_field("ontime", self.resolve_ontime)
         self.set_field("level", self.resolve_level)
-        self.add_collection(
+        self._add_collection(
             "joined_server", lambda user, *_: self._ujs.get_user_joined_servers_by_user_id(user.user_id)
         )
-        self.add_collection(
+        self._add_collection(
             "joined_voice_channel", lambda user, *_: self._ujvs.get_user_joined_voice_channels_by_user_id(user.user_id)
         )
         self.set_field("server", self.resolve_server)

kdb-bot/src/bot_graphql/query.py

@@ -36,14 +36,14 @@ class Query(QueryABC):
         self._user_joined_voice_channels = user_joined_voice_channel
         self._users = users
 
-        self.add_collection("auto_role", lambda *_: self._auto_roles.get_auto_roles(), AutoRoleFilter)
+        self._add_collection("auto_role", lambda *_: self._auto_roles.get_auto_roles(), AutoRoleFilter)
-        self.add_collection("auto_role_rule", lambda *_: self._auto_roles.get_auto_role_rules(), AutoRoleRuleFilter)
+        self._add_collection("auto_role_rule", lambda *_: self._auto_roles.get_auto_role_rules(), AutoRoleRuleFilter)
-        self.add_collection("client", lambda *_: self._clients.get_clients())
+        self._add_collection("client", lambda *_: self._clients.get_clients())
-        self.add_collection("known_user", lambda *_: self._known_users.get_users())
+        self._add_collection("known_user", lambda *_: self._known_users.get_users())
-        self.add_collection("level", lambda *_: self._levels.get_levels(), LevelFilter)
+        self._add_collection("level", lambda *_: self._levels.get_levels(), LevelFilter)
-        self.add_collection("server", lambda *_: self._servers.get_servers(), ServerFilter)
+        self._add_collection("server", lambda *_: self._servers.get_servers(), ServerFilter)
-        self.add_collection("user_joined_server", lambda *_: self._user_joined_servers.get_user_joined_servers())
+        self._add_collection("user_joined_server", lambda *_: self._user_joined_servers.get_user_joined_servers())
-        self.add_collection(
+        self._add_collection(
             "user_joined_voice_channel", lambda *_: self._user_joined_voice_channels.get_user_joined_voice_channels()
         )
-        self.add_collection("user", lambda *_: self._users.get_users(), UserFilter)
+        self._add_collection("user", lambda *_: self._users.get_users(), UserFilter)

kdb-bot/src/modules/auto_role/command/auto_role_group.py

@@ -1,8 +1,9 @@
-from typing import List as TList
+from typing import List as TList, Optional, Any
 
 import discord
 from cpl_core.database.context import DatabaseContextABC
 from cpl_discord.command import DiscordCommandABC
+from cpl_discord.container import TextChannel
 from cpl_discord.service import DiscordBotServiceABC
 from cpl_query.extension import List
 from cpl_translation import TranslatePipe
@@ -137,10 +138,10 @@ class AutoRoleGroup(DiscordCommandABC):
             self._logger.trace(__name__, f"Finished command auto-role add")
             return
 
-        server = self._servers.get_server_by_discord_id(ctx.guild.id)
+        server_id = self._servers.get_server_by_discord_id(ctx.guild.id).server_id
-        self._auto_roles.add_auto_role(AutoRole(server, int(channel.id), int(message_id)))
+        self._auto_roles.add_auto_role(AutoRole(server_id, int(channel.id), int(message_id)))
         self._db_context.save_changes()
-        self._logger.info(__name__, f"Saved auto-role for message {message_id} at server {server}")
+        self._logger.info(__name__, f"Saved auto-role for message {message_id} at server {server_id}")
         await self._message_service.send_ctx_msg(
             ctx, self._t.transform("modules.auto_role.add.success").format(message_id)
         )

kdb-bot/src/modules/stats/ui/add_statistic_form.py

@@ -12,6 +12,7 @@ from bot_data.model.statistic import Statistic
 
 
 class AddStatisticForm(ui.Modal):
+
     description = ui.TextInput(label="Beschreibung", required=True)
     code = ui.TextInput(label="Code", required=True, style=TextStyle.long)
 

kdb-bot/tools/post_build/service/remove_config.py

@@ -16,6 +16,7 @@ class RemoveConfig:
         build: BuildSettings,
         post_build: PostBuildSettings,
     ):
+
         self._env = env
         self._workspace = ws
         self._project = project