Moved folders #405

bot/src/bot_graphql/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+bot sh-edraft.de Discord bot
+~~~~~~~~~~~~~~~~~~~
+
+Discord bot for customers of sh-edraft.de
+
+:copyright: (c) 2022 - 2023 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = "bot_graphql"
+__author__ = "Sven Heidemann"
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2022 - 2023 sh-edraft.de"
+__version__ = "1.2.0"
+
+from collections import namedtuple
+
+
+# imports
+
+VersionInfo = namedtuple("VersionInfo", "major minor micro")
+version_info = VersionInfo(major="1", minor="2", micro="0")

bot/src/bot_graphql/abc/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+bot sh-edraft.de Discord bot
+~~~~~~~~~~~~~~~~~~~
+
+Discord bot for customers of sh-edraft.de
+
+:copyright: (c) 2022 - 2023 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = "bot_graphql.abc"
+__author__ = "Sven Heidemann"
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2022 - 2023 sh-edraft.de"
+__version__ = "1.2.0"
+
+from collections import namedtuple
+
+
+# imports:
+
+VersionInfo = namedtuple("VersionInfo", "major minor micro")
+version_info = VersionInfo(major="1", minor="2", micro="0")

bot/src/bot_graphql/abc/data_query_abc.py

@@ -0,0 +1,19 @@
+from cpl_core.database import TableABC
+
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class DataQueryABC(QueryABC):
+    def __init__(self, name: str):
+        QueryABC.__init__(self, name)
+
+        self.set_field("createdAt", self.resolve_created_at)
+        self.set_field("modifiedAt", self.resolve_modified_at)
+
+    @staticmethod
+    def resolve_created_at(entry: TableABC, *_):
+        return entry.created_at
+
+    @staticmethod
+    def resolve_modified_at(entry: TableABC, *_):
+        return entry.modified_at

bot/src/bot_graphql/abc/data_query_with_history_abc.py

@@ -0,0 +1,42 @@
+from typing import Type
+
+from cpl_core.database.context import DatabaseContextABC
+from cpl_query.extension import List
+
+from bot_data.abc.history_table_abc import HistoryTableABC
+from bot_data.abc.table_with_id_abc import TableWithIdABC
+from bot_graphql.abc.data_query_abc import DataQueryABC
+
+
+class DataQueryWithHistoryABC(DataQueryABC):
+    def __init__(
+        self,
+        name: str,
+        table_name: str,
+        history_type: Type[HistoryTableABC],
+        db: DatabaseContextABC,
+    ):
+        self._table_name = table_name
+        self._history_type = history_type
+        self._db = db
+
+        DataQueryABC.__init__(self, name)
+
+        self.set_field("history", self.resolve_history)
+
+    def resolve_history(self, entry: TableWithIdABC, *_):
+        history = List(self._history_type)
+
+        results = self._db.select(
+            f"""
+            SELECT *
+            FROM {self._table_name}
+            WHERE Id = {entry.id}
+            ORDER BY DateTo DESC;
+            """
+        )
+
+        for result in results:
+            history.add(self._history_type(*result[1:], result[0]))
+
+        return history

bot/src/bot_graphql/abc/filter_abc.py

@@ -0,0 +1,60 @@
+import functools
+from abc import ABC, abstractmethod
+from inspect import signature, Parameter
+
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_query.extension import List
+
+
+class FilterABC(ABC):
+    def __init__(self):
+        ABC.__init__(self)
+
+    @abstractmethod
+    def from_dict(self, values: dict):
+        pass
+
+    @abstractmethod
+    def filter(self, query: List, *args) -> List:
+        pass
+
+    @staticmethod
+    @ServiceProviderABC.inject
+    def get_filter(f, values: dict, services: ServiceProviderABC):
+        sig = signature(f)
+        for param in sig.parameters.items():
+            parameter = param[1]
+            if (
+                parameter.name == "self"
+                or parameter.name == "cls"
+                or parameter.annotation == Parameter.empty
+            ):
+                continue
+
+            if issubclass(parameter.annotation, FilterABC):
+                filter = services.get_service(parameter.annotation)
+                filter.from_dict(values)
+                return filter @ staticmethod
+
+    @staticmethod
+    @ServiceProviderABC.inject
+    def get_collection_filter(
+        filter_type: type, values: dict, services: ServiceProviderABC
+    ):
+        filter: FilterABC = services.get_service(filter_type)
+        filter.from_dict(values)
+        return filter
+
+    @classmethod
+    def resolve_filter_annotation(cls, f=None):
+        if f is None:
+            return functools.partial(cls.resolve_filter_annotation)
+
+        @functools.wraps(f)
+        def decorator(*args, **kwargs):
+            if "filter" in kwargs:
+                kwargs["filter"] = cls.get_filter(f, kwargs["filter"])
+
+            return f(*args, **kwargs)
+
+        return decorator

bot/src/bot_graphql/abc/history_query_abc.py

@@ -0,0 +1,10 @@
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class HistoryQueryABC(QueryABC):
+    def __init__(self, name: str):
+        QueryABC.__init__(self, f"{name}History")
+
+        self.set_field("deleted", lambda x, *_: x.deleted)
+        self.set_field("dateFrom", lambda x, *_: x.date_from)
+        self.set_field("dateTo", lambda x, *_: x.date_to)

bot/src/bot_graphql/abc/query_abc.py

@@ -0,0 +1,287 @@
+from typing import Callable
+
+from ariadne import ObjectType
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_core.type import T
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_api.exception.service_error_code_enum import ServiceErrorCode
+from bot_api.exception.service_exception import ServiceException
+from bot_api.route.route import Route
+from bot_core.configuration.feature_flags_enum import FeatureFlagsEnum
+from bot_data.model.achievement import Achievement
+from bot_data.model.auth_role_enum import AuthRoleEnum
+from bot_data.model.auth_user import AuthUser
+from bot_data.model.auto_role import AutoRole
+from bot_data.model.auto_role_rule import AutoRoleRule
+from bot_data.model.client import Client
+from bot_data.model.known_user import KnownUser
+from bot_data.model.level import Level
+from bot_data.model.server import Server
+from bot_data.model.server_config import ServerConfig
+from bot_data.model.short_role_name import ShortRoleName
+from bot_data.model.user import User
+from bot_data.model.user_joined_game_server import UserJoinedGameServer
+from bot_data.model.user_joined_server import UserJoinedServer
+from bot_data.model.user_joined_voice_channel import UserJoinedVoiceChannel
+from bot_data.model.user_role_enum import UserRoleEnum
+from bot_graphql.abc.filter_abc import FilterABC
+from bot_graphql.filter.page import Page
+from bot_graphql.filter.sort import Sort
+from modules.permission.service.permission_service import PermissionService
+
+
+class QueryABC(ObjectType):
+    __abstract__ = True
+
+    def __init__(self, name: str):
+        ObjectType.__init__(self, name)
+
+    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"]
+                )
+            else:
+                kwargs["filter"] = None
+
+            if "page" in kwargs:
+                page = Page()
+                page.from_dict(kwargs["page"])
+                kwargs["page"] = page
+
+            if "sort" in kwargs:
+                sort = Sort()
+                sort.from_dict(kwargs["sort"])
+                kwargs["sort"] = sort
+
+            collection: List = get_collection(*args)
+            user = Route.get_user()
+
+            if user == "system" or user.auth_role == AuthRoleEnum.admin:
+                return self._resolve_collection(collection, *args, **kwargs)
+
+            for x in collection.to_list():
+                if not self._can_user_see_element(user, x):
+                    collection.remove(x)
+
+            return self._resolve_collection(collection, *args, **kwargs)
+
+        self.set_field(f"{name}s", wrapper)
+        self.set_field(f"{name}Count", lambda *args: wrapper(*args).count())
+
+    def _can_user_see_element(self, user: AuthUser, element: T) -> bool:
+        @ServiceProviderABC.inject
+        def get_services(services: ServiceProviderABC) -> ServiceProviderABC:
+            return services
+
+        services = get_services()
+        permissions: PermissionService = services.get_service(PermissionService)
+        bot: DiscordBotServiceABC = services.get_service(DiscordBotServiceABC)
+
+        if user.auth_role == AuthRoleEnum.admin:
+            return True
+
+        for u in user.users:
+            guild = bot.get_guild(u.server.discord_id)
+            if permissions.is_member_technician(guild.get_member(u.discord_id)):
+                return True
+
+        access = False
+        if type(element) == Achievement:
+            element: Achievement = element
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if (
+                    permissions.is_member_moderator(member)
+                    and u.server.id == element.server.id
+                ):
+                    access = True
+                    break
+
+        elif type(element) == AutoRole:
+            element: AutoRole = element
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if (
+                    permissions.is_member_moderator(member)
+                    and u.server.id == element.server.id
+                ):
+                    access = True
+                    break
+
+        elif type(element) == AutoRoleRule:
+            element: AutoRoleRule = element
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if (
+                    permissions.is_member_moderator(member)
+                    and u.server.id == element.auto_role.server.id
+                ):
+                    access = True
+                    break
+
+        elif type(element) == Client:
+            for u in user.users:
+                u: User = u
+                if u.server.id == element.server.id:
+                    access = True
+                    break
+
+        elif type(element) == KnownUser:
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if permissions.is_member_moderator(member):
+                    access = True
+                    break
+
+        elif type(element) == Level:
+            for u in user.users:
+                u: User = u
+                if u.server.id == element.server.id:
+                    access = True
+                    break
+
+        elif type(element) == Server:
+            for u in user.users:
+                u: User = u
+                if u.server.id == element.id:
+                    access = True
+                    break
+
+        elif type(element) == User:
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if u.id == element.id or permissions.is_member_moderator(member):
+                    access = True
+                    break
+
+        elif type(element) == UserJoinedServer:
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if u.id == element.user.id or permissions.is_member_moderator(member):
+                    access = True
+                    break
+
+        elif type(element) == UserJoinedVoiceChannel:
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if u.id == element.user.id or permissions.is_member_moderator(member):
+                    access = True
+                    break
+
+        elif type(element) == UserJoinedGameServer:
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if u.id == element.user.id or permissions.is_member_moderator(member):
+                    access = True
+                    break
+
+        elif type(element) == ServerConfig:
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if permissions.is_member_technician(member):
+                    access = True
+                    break
+
+        elif type(element) == ShortRoleName:
+            element: ShortRoleName = element
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if (
+                    permissions.is_member_moderator(member)
+                    and u.server.id == element.server.id
+                ):
+                    access = True
+                    break
+
+        elif (
+            type(element) == dict
+            and "key" in element
+            and element["key"] in [e.value for e in FeatureFlagsEnum]
+        ):
+            for u in user.users:
+                u: User = u
+                guild = bot.get_guild(u.server.discord_id)
+                member = guild.get_member(u.discord_id)
+                if permissions.is_member_technician(member):
+                    access = True
+                    break
+
+        return access
+
+    @ServiceProviderABC.inject
+    def _can_user_mutate_data(
+        self, server: Server, permission: UserRoleEnum, services: ServiceProviderABC
+    ):
+        permissions: PermissionService = services.get_service(PermissionService)
+        bot: DiscordBotServiceABC = services.get_service(DiscordBotServiceABC)
+
+        auth_user = Route.get_user()
+        if auth_user == "system" or auth_user.auth_role == AuthRoleEnum.admin:
+            return
+
+        member = bot.get_guild(server.discord_id).get_member(
+            auth_user.users.where(lambda x: x.server.id == server.id)
+            .single()
+            .discord_id
+        )
+
+        check_perm = lambda x: True
+        match permission:
+            case UserRoleEnum.moderator:
+                check_perm = lambda x: permissions.is_member_moderator(x)
+            case UserRoleEnum.admin:
+                check_perm = lambda x: permissions.is_member_admin(x)
+            case UserRoleEnum.technician:
+                check_perm = lambda x: permissions.is_member_technician(x)
+
+        if not check_perm(member):
+            ex = ServiceException(
+                ServiceErrorCode.Forbidden, f"User not allowed to mutate data"
+            )
+            raise ex
+
+    # @FilterABC.resolve_filter_annotation
+    def _resolve_collection(
+        self,
+        collection: List,
+        *_,
+        filter: FilterABC = None,
+        page: Page = None,
+        sort: Sort = None,
+    ):
+        if filter is not None:
+            collection = filter.filter(collection)
+
+        if sort is not None:
+            collection = sort.filter(collection)
+
+        if page is not None:
+            collection = page.filter(collection)
+
+        return collection

bot/src/bot_graphql/bot-graphql.json

@@ -0,0 +1,44 @@
+{
+  "ProjectSettings": {
+    "Name": "bot-data",
+    "Version": {
+      "Major": "1",
+      "Minor": "2",
+      "Micro": "0"
+    },
+    "Author": "Sven Heidemann",
+    "AuthorEmail": "sven.heidemann@sh-edraft.de",
+    "Description": "Keksdose bot - graphql",
+    "LongDescription": "Discord bot  for the Keksdose discord Server - graphql package",
+    "URL": "https://www.sh-edraft.de",
+    "CopyrightDate": "2023",
+    "CopyrightName": "sh-edraft.de",
+    "LicenseName": "MIT",
+    "LicenseDescription": "MIT, see LICENSE for more details.",
+    "Dependencies": [
+      "cpl-core==2022.12.0"
+    ],
+    "DevDependencies": [
+      "cpl-core==2022.12.0"
+    ],
+    "PythonVersion": ">=3.10.4",
+    "PythonPath": {},
+    "Classifiers": []
+  },
+  "BuildSettings": {
+    "ProjectType": "library",
+    "SourcePath": "",
+    "OutputPath": "../../dist",
+    "Main": "",
+    "EntryPoint": "",
+    "IncludePackageData": false,
+    "Included": [],
+    "Excluded": [
+      "*/__pycache__",
+      "*/logs",
+      "*/tests"
+    ],
+    "PackageData": {},
+    "ProjectReferences": []
+  }
+}

bot/src/bot_graphql/filter/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+bot sh-edraft.de Discord bot
+~~~~~~~~~~~~~~~~~~~
+
+Discord bot for customers of sh-edraft.de
+
+:copyright: (c) 2022 - 2023 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = "bot_graphql.filter"
+__author__ = "Sven Heidemann"
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2022 - 2023 sh-edraft.de"
+__version__ = "1.2.0"
+
+from collections import namedtuple
+
+
+# imports:
+
+VersionInfo = namedtuple("VersionInfo", "major minor micro")
+version_info = VersionInfo(major="1", minor="2", micro="0")

bot/src/bot_graphql/filter/achievement_filter.py

@@ -0,0 +1,81 @@
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_query.extension import List
+
+from bot_data.model.user import User
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class AchievementFilter(FilterABC):
+    def __init__(
+        self,
+        services: ServiceProviderABC,
+    ):
+        FilterABC.__init__(self)
+
+        self._services = services
+
+        self._id = None
+        self._name = None
+        self._description = None
+        self._attribute = None
+        self._operator = None
+        self._value = None
+        self._server = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "name" in values:
+            self._name = values["name"]
+
+        if "description" in values:
+            self._description = values["description"]
+
+        if "attribute" in values:
+            self._attribute = values["attribute"]
+
+        if "operator" in values:
+            self._operator = values["operator"]
+
+        if "value" in values:
+            self._value = values["value"]
+
+        if "server" in values:
+            from bot_graphql.filter.server_filter import ServerFilter
+
+            self._server: ServerFilter = self._services.get_service(ServerFilter)
+            self._server.from_dict(values["server"])
+
+    def filter(self, query: List[User]) -> List[User]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._name is not None:
+            query = query.where(lambda x: x.name == self._name or self._name in x.name)
+
+        if self._description is not None:
+            query = query.where(
+                lambda x: x.description == self._description
+                or self._description in x.description
+            )
+
+        if self._attribute is not None:
+            query = query.where(
+                lambda x: x.attribute == self._attribute
+                or self._attribute in x.attribute
+            )
+
+        if self._operator is not None:
+            query = query.where(lambda x: x.operator == self._operator)
+
+        if self._value is not None:
+            query = query.where(lambda x: x.value == self._value)
+
+        if self._server is not None:
+            servers = self._server.filter(query.select(lambda x: x.server)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.server.id in servers)
+
+        return query

bot/src/bot_graphql/filter/auto_role_filter.py

@@ -0,0 +1,71 @@
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_data.model.auto_role import AutoRole
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class AutoRoleFilter(FilterABC):
+    def __init__(
+        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"])
+
+        if "channelId" in values:
+            self._channel_id = int(values["channelId"])
+
+        if "channelName" in values:
+            self._channel_name = values["channelName"]
+
+        if "messageId" in values:
+            self._message_id = int(values["messageId"])
+
+        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:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._channel_id is not None:
+            query = query.where(
+                lambda x: x.discord_channel_id == self._channel_id
+                or str(self._channel_id) in str(x.discord_channel_id)
+            )
+
+        if self._channel_name is not None:
+            query = query.where(
+                lambda x: x.discord_channel_name == self._channel_name
+                or self._channel_name in x.discord_channel_name
+            )
+
+        if self._message_id is not None:
+            query = query.where(
+                lambda x: x.discord_message_id == self._message_id
+                or str(self._message_id) in str(x.discord_message_id)
+            )
+
+        if self._server is not None:
+            servers = self._server.filter(query.select(lambda x: x.server)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.server.id in servers)
+
+        return query

bot/src/bot_graphql/filter/auto_role_rule_filter.py

@@ -0,0 +1,65 @@
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_data.model.auto_role_rule import AutoRoleRule
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class AutoRoleRuleFilter(FilterABC):
+    def __init__(self, services: ServiceProviderABC, bot: DiscordBotServiceABC):
+        FilterABC.__init__(self)
+        self._services = services
+        self._bot = bot
+
+        self._id = None
+        self._emoji_name = None
+        self._role_id = None
+        self._role_name = None
+        self._auto_role = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "emojiName" in values:
+            self._emoji_name = values["emojiName"]
+
+        if "roleId" in values:
+            self._role_id = int(values["roleId"])
+
+        if "roleName" in values:
+            self._role_name = values["roleName"]
+
+        if "autoRole" in values:
+            from bot_graphql.filter.auto_role_filter import AutoRoleFilter
+
+            self._auto_role: AutoRoleFilter = self._services.get_service(AutoRoleFilter)
+            self._auto_role.from_dict(values["auto_role"])
+
+    def filter(self, query: List[AutoRoleRule]) -> List[AutoRoleRule]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._emoji_name is not None:
+            query = query.where(lambda x: x.emoji_name == self._emoji_name)
+
+        if self._role_id is not None:
+            query = query.where(lambda x: x.role_id == self._role_id)
+
+        if self._role_name is not None and self._role_id is not None:
+
+            def get_role_name(x: AutoRoleRule):
+                guild = self._bot.get_guild(x.auto_role.server.discord_id)
+                name = guild.get_role(x.role_id).name
+                return name == self._role_name or self._role_name in name
+
+            query = query.where(get_role_name)
+
+        if self._auto_role is not None:
+            auto_roles = self._auto_role.filter(
+                query.select(lambda x: x.game_server)
+            ).select(lambda x: x.id)
+            query = query.where(lambda x: x.game_server.id in auto_roles)
+
+        return query

bot/src/bot_graphql/filter/client_filter.py

@@ -0,0 +1,52 @@
+from cpl_query.extension import List
+
+from bot_data.model.client import Client
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class ClientFilter(FilterABC):
+    def __init__(self):
+        FilterABC.__init__(self)
+
+        self._id = None
+        self._discord_id = None
+        self._name = None
+        self._server = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "discordId" in values:
+            self._id = int(values["discordId"])
+
+        if "name" in values:
+            self._name = values["name"]
+
+        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[Client]) -> List[Client]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._discord_id is not None:
+            query = query.where(lambda x: x.id == self._discord_id)
+
+        if self._name is not None:
+            query = query.where(
+                lambda x: self._name.lower() == x.name.lower()
+                or self._name.lower() in x.name.lower()
+            )
+
+        if self._server is not None:
+            servers = self._server.filter(query.select(lambda x: x.server)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.server.id in servers)
+
+        return query

bot/src/bot_graphql/filter/level_filter.py

@@ -0,0 +1,47 @@
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_query.extension import List
+
+from bot_data.model.level import Level
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class LevelFilter(FilterABC):
+    def __init__(self, services: ServiceProviderABC):
+        FilterABC.__init__(self)
+
+        self._services = services
+
+        self._id = None
+        self._name = None
+        self._server = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "name" in values:
+            self._name = values["name"]
+
+        if "server" in values:
+            from bot_graphql.filter.server_filter import ServerFilter
+
+            self._server: ServerFilter = self._services.get_service(ServerFilter)
+            self._server.from_dict(values["server"])
+
+    def filter(self, query: List[Level]) -> List[Level]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._name is not None:
+            query = query.where(
+                lambda x: self._name.lower() == x.name.lower()
+                or self._name.lower() in x.name.lower()
+            )
+
+        if self._server is not None:
+            servers = self._server.filter(query.select(lambda x: x.server)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.server.id in servers)
+
+        return query

bot/src/bot_graphql/filter/page.py

@@ -0,0 +1,25 @@
+from cpl_query.extension import List
+
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class Page(FilterABC):
+    def __init__(self):
+        FilterABC.__init__(self)
+        self._page_index = None
+        self._page_size = None
+
+    def from_dict(self, values: dict):
+        if "pageIndex" in values:
+            self._page_index = int(values["pageIndex"])
+
+        if "pageSize" in values:
+            self._page_size = int(values["pageSize"])
+
+    def filter(self, query: List, *args) -> List:
+        if self._page_size is not None and self._page_index is not None:
+            skip = self._page_size * self._page_index
+            result = query.skip(skip).take(self._page_size)
+            return result
+
+        return query

bot/src/bot_graphql/filter/server_filter.py

@@ -0,0 +1,50 @@
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_discord.container import Guild
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_data.model.server import Server
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class ServerFilter(FilterABC):
+    def __init__(self):
+        FilterABC.__init__(self)
+
+        self._id = None
+        self._discord_id = None
+        self._name = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "discordId" in values:
+            self._discord_id = int(values["discordId"])
+
+        if "name" in values:
+            self._name = values["name"]
+
+    @ServiceProviderABC.inject
+    def filter(self, query: List[Server], bot: DiscordBotServiceABC) -> List[Server]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._discord_id is not None:
+            query = query.where(
+                lambda x: x.discord_id == self._discord_id
+                or str(self._discord_id) in str(x.discord_id)
+            )
+
+        if self._name is not None:
+
+            def where_guild(x: Guild):
+                guild = bot.get_guild(x.discord_id)
+                return guild is not None and (
+                    self._name.lower() == guild.name.lower()
+                    or self._name.lower() in guild.name.lower()
+                )
+
+            query = query.where(where_guild)
+
+        return query

bot/src/bot_graphql/filter/short_role_name_filter.py

@@ -0,0 +1,75 @@
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_data.model.short_role_name import ShortRoleName
+from bot_data.model.short_role_name_position_enum import ShortRoleNamePositionEnum
+from bot_data.model.user import User
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class ShortRoleNameFilter(FilterABC):
+    def __init__(self, bot: DiscordBotServiceABC):
+        FilterABC.__init__(self)
+        self._bot = bot
+
+        self._id = None
+        self._short_name = None
+        self._role_id = None
+        self._role_name = None
+        self._position = None
+        self._server = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "shortName" in values:
+            self._short_name = values["shortName"]
+
+        if "roleId" in values:
+            self._role_id = int(values["roleId"])
+
+        if "roleName" in values:
+            self._role_name = values["roleName"]
+
+        if "position" in values:
+            self._position = ShortRoleNamePositionEnum(values["position"])
+
+        if "server" in values:
+            from bot_graphql.filter.server_filter import ServerFilter
+
+            self._server: ServerFilter = self._services.get_service(ServerFilter)
+            self._server.from_dict(values["server"])
+
+    def filter(self, query: List[User]) -> List[User]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._short_name is not None:
+            query = query.where(
+                lambda x: x.short_name == self._short_name
+                or self._short_name in x.short_name
+            )
+
+        if self._role_id is not None:
+            query = query.where(lambda x: x.role_id == self._role_id)
+
+        if self._role_name is not None and self._role_id is not None:
+
+            def get_role_name(x: ShortRoleName):
+                guild = self._bot.get_guild(x.server.discord_id)
+                name = guild.get_role(x.role_id).name
+                return name == self._role_name or self._role_name in name
+
+            query = query.where(get_role_name)
+
+        if self._position is not None:
+            query = query.where(lambda x: x.position.value == self._position.value)
+
+        if self._server is not None:
+            servers = self._server.filter(query.select(lambda x: x.server)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.server.id in servers)
+
+        return query

bot/src/bot_graphql/filter/sort.py

@@ -0,0 +1,46 @@
+import functools
+
+from cpl_core.utils import String
+from cpl_query.extension import List
+
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class Sort(FilterABC):
+    def __init__(self):
+        FilterABC.__init__(self)
+
+        self._sort_direction = None
+        self._sort_column = None
+
+    def from_dict(self, values: dict):
+        if "sortDirection" in values:
+            self._sort_direction = values["sortDirection"]
+
+        if "sortColumn" in values:
+            self._sort_column = values["sortColumn"]
+
+    @staticmethod
+    def _rgetattr(obj, attr, *args):
+        def _getattr(obj, attr):
+            return getattr(obj, attr, *args)
+
+        return functools.reduce(_getattr, [obj] + attr.split("."))
+
+    def _by_column(self, x):
+        atr = self._rgetattr(x, String.convert_to_snake_case(self._sort_column), None)
+        if atr is None:
+            return ""
+        return atr
+
+    def filter(self, query: List, *args) -> List:
+        if self._sort_column is None:
+            return query
+
+        match self._sort_direction.lower() if self._sort_direction is not None else "ASC":
+            case "asc":
+                query = query.order_by(self._by_column)
+            case "desc":
+                query = query.order_by_descending(self._by_column)
+
+        return query

bot/src/bot_graphql/filter/user_filter.py

@@ -0,0 +1,123 @@
+from typing import Optional
+
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_core.abc.client_utils_abc import ClientUtilsABC
+from bot_data.abc.user_joined_server_repository_abc import UserJoinedServerRepositoryABC
+from bot_data.model.user import User
+from bot_graphql.abc.filter_abc import FilterABC
+from bot_graphql.filter.level_filter import LevelFilter
+from modules.level.service.level_service import LevelService
+
+
+class UserFilter(FilterABC):
+    def __init__(
+        self,
+        services: ServiceProviderABC,
+        bot: DiscordBotServiceABC,
+        client_utils: ClientUtilsABC,
+        levels: LevelService,
+        user_joined_servers: UserJoinedServerRepositoryABC,
+    ):
+        FilterABC.__init__(self)
+
+        self._services = services
+        self._bot = bot
+        self._client_utils = client_utils
+        self._levels = levels
+        self._user_joined_servers = user_joined_servers
+
+        self._id = None
+        self._discord_id = None
+        self._name = None
+        self._xp = None
+        self._ontime = None
+        self._level: Optional[LevelFilter] = None
+        self._server = None
+        self._left_server = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "discordId" in values:
+            self._discord_id = int(values["discordId"])
+
+        if "name" in values:
+            self._name = values["name"]
+
+        if "xp" in values:
+            self._xp = int(values["xp"])
+
+        if "ontime" in values:
+            self._ontime = int(values["ontime"])
+
+        if "level" in values:
+            self._level: LevelFilter = self._services.get_service(LevelFilter)
+            self._level.from_dict(values["level"])
+
+        if "server" in values:
+            from bot_graphql.filter.server_filter import ServerFilter
+
+            self._server: ServerFilter = self._services.get_service(ServerFilter)
+            self._server.from_dict(values["server"])
+
+        if "leftServer" in values:
+            self._left_server = values["leftServer"]
+
+    def filter(self, query: List[User]) -> List[User]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._discord_id is not None:
+            query = query.where(
+                lambda x: x.discord_id == self._discord_id
+                or str(self._discord_id) in str(x.discord_id)
+            )
+
+        if self._name is not None:
+
+            def _get_member(user: User):
+                guild = self._bot.get_guild(user.server.discord_id)
+                member = guild.get_member(user.discord_id)
+                return member is not None and (
+                    member.name == self._name or self._name in member.name
+                )
+
+            query = query.where(_get_member)
+
+        if self._xp is not None:
+            query = query.where(lambda x: x.xp == self._xp)
+
+        if self._ontime is not None:
+            query = query.where(
+                lambda x: self._client_utils.get_ontime_for_user(x) == self._ontime
+            )
+
+        if self._level is not None:
+            levels = self._level.filter(
+                query.select(lambda x: self._levels.get_level(x))
+            ).select(lambda x: x.id)
+            query = query.where(lambda x: self._levels.get_level(x).id in levels)
+
+        if self._server is not None:
+            servers = self._server.filter(query.select(lambda x: x.server)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.server.id in servers)
+
+        if self._left_server is not None:
+
+            def _has_user_left_server(user: User):
+                active_join = (
+                    self._user_joined_servers.find_active_user_joined_server_by_user_id(
+                        user.id
+                    )
+                )
+                return (active_join is None) == self._left_server
+
+            query = query.where(_has_user_left_server)
+
+        return query

bot/src/bot_graphql/filter/user_joined_game_server_filter.py

@@ -0,0 +1,50 @@
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_data.model.user_joined_game_server import UserJoinedGameServer
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class UserJoinedGameServerFilter(FilterABC):
+    def __init__(
+        self,
+        services: ServiceProviderABC,
+        bot: DiscordBotServiceABC,
+    ):
+        FilterABC.__init__(self)
+
+        self._services = services
+        self._bot = bot
+
+        self._id = None
+        self._game_server = None
+        self._user = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "gameServer" in values:
+            self._game_server = values["gameServer"]
+
+        if "user" in values:
+            from bot_graphql.filter.user_filter import UserFilter
+
+            self._user: UserFilter = self._services.get_service(UserFilter)
+            self._user.from_dict(values["user"])
+
+    def filter(self, query: List[UserJoinedGameServer]) -> List[UserJoinedGameServer]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._game_server is not None:
+            query = query.where(lambda x: x.game_server == self._game_server)
+
+        if self._user is not None:
+            users = self._user.filter(query.select(lambda x: x.user)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.user.id in users)
+
+        return query

bot/src/bot_graphql/filter/user_joined_server_filter.py

@@ -0,0 +1,63 @@
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_data.model.user_joined_server import UserJoinedServer
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class UserJoinedServerFilter(FilterABC):
+    def __init__(
+        self,
+        services: ServiceProviderABC,
+        bot: DiscordBotServiceABC,
+    ):
+        FilterABC.__init__(self)
+
+        self._services = services
+        self._bot = bot
+
+        self._id = None
+        self._user = None
+        self._joined_on = None
+        self._leaved_on = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "user" in values:
+            from bot_graphql.filter.user_filter import UserFilter
+
+            self._user: UserFilter = self._services.get_service(UserFilter)
+            self._user.from_dict(values["user"])
+
+        if "joinedOn" in values:
+            self._joined_on = values["joinedOn"]
+
+        if "leavedOn" in values:
+            self._leaved_on = values["leavedOn"]
+
+    def filter(self, query: List[UserJoinedServer]) -> List[UserJoinedServer]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._user is not None:
+            users = self._user.filter(query.select(lambda x: x.user)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.user.id in users)
+
+        if self._joined_on is not None:
+            query = query.where(
+                lambda x: x.joined_on == self._joined_on
+                or self._joined_on in x.joined_on
+            )
+
+        if self._leaved_on is not None:
+            query = query.where(
+                lambda x: x.leaved_on == self._leaved_on
+                or self._leaved_on in x.leaved_on
+            )
+
+        return query

bot/src/bot_graphql/filter/user_joined_voice_channel_filter.py

@@ -0,0 +1,84 @@
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_data.model.user_joined_voice_channel import UserJoinedVoiceChannel
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class UserJoinedVoiceChannelFilter(FilterABC):
+    def __init__(
+        self,
+        services: ServiceProviderABC,
+        bot: DiscordBotServiceABC,
+    ):
+        FilterABC.__init__(self)
+
+        self._services = services
+        self._bot = bot
+
+        self._id = None
+        self._channel_id = None
+        self._channel_name = None
+        self._user = None
+        self._joined_on = None
+        self._leaved_on = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "channelId" in values:
+            self._channel_id = int(values["channelId"])
+
+        if "channelName" in values:
+            self._channel_name = values["channelName"]
+
+        if "user" in values:
+            from bot_graphql.filter.user_filter import UserFilter
+
+            self._user: UserFilter = self._services.get_service(UserFilter)
+            self._user.from_dict(values["user"])
+
+        if "joinedOn" in values:
+            self._joined_on = values["joinedOn"]
+
+        if "leavedOn" in values:
+            self._leaved_on = values["leavedOn"]
+
+    def filter(
+        self, query: List[UserJoinedVoiceChannel]
+    ) -> List[UserJoinedVoiceChannel]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._channel_id is not None:
+            query = query.where(lambda x: x.channel_id == self._channel_id)
+
+        if self._channel_name is not None and self._channel_id is not None:
+
+            def get_channel_name(x: UserJoinedVoiceChannel):
+                name = self._bot.get_channel(x.channel_id).name
+                return name == self._channel_name or self._channel_name in name
+
+            query = query.where(get_channel_name)
+
+        if self._user is not None:
+            users = self._user.filter(query.select(lambda x: x.user)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.user.id in users)
+
+        if self._joined_on is not None:
+            query = query.where(
+                lambda x: x.joined_on == self._joined_on
+                or self._joined_on in x.joined_on
+            )
+
+        if self._leaved_on is not None:
+            query = query.where(
+                lambda x: x.leaved_on == self._leaved_on
+                or self._leaved_on in x.leaved_on
+            )
+
+        return query

bot/src/bot_graphql/filter/user_warning_filter.py

@@ -0,0 +1,63 @@
+from cpl_core.dependency_injection import ServiceProviderABC
+from cpl_query.extension import List
+
+from bot_data.model.user_warnings import UserWarnings
+from bot_graphql.abc.filter_abc import FilterABC
+
+
+class UserWarningFilter(FilterABC):
+    def __init__(
+        self,
+        services: ServiceProviderABC,
+    ):
+        FilterABC.__init__(self)
+
+        self._services = services
+
+        self._id = None
+        self._user = None
+        self._description = None
+        self._author = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = int(values["id"])
+
+        if "user" in values:
+            from bot_graphql.filter.user_filter import UserFilter
+
+            self._user: UserFilter = self._services.get_service(UserFilter)
+            self._user.from_dict(values["user"])
+
+        if "description" in values:
+            self._description = values["description"]
+
+        if "author" in values:
+            from bot_graphql.filter.user_filter import UserFilter
+
+            self._author: UserFilter = self._services.get_service(UserFilter)
+            self._author.from_dict(values["author"])
+
+    def filter(self, query: List[UserWarnings]) -> List[UserWarnings]:
+        if self._id is not None:
+            query = query.where(lambda x: x.id == self._id)
+
+        if self._user is not None:
+            users = self._user.filter(query.select(lambda x: x.user)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.id in users)
+
+        if self._description is not None:
+            query = query.where(
+                lambda x: x.description == self._description
+                or self._description in x.description
+            )
+
+        if self._author is not None:
+            users = self._author.filter(query.select(lambda x: x.author)).select(
+                lambda x: x.id
+            )
+            query = query.where(lambda x: x.id in users)
+
+        return query

bot/src/bot_graphql/graphql/achievement.gql

@@ -0,0 +1,64 @@
+type AchievementAttribute {
+    name: String
+    type: String
+
+    createdAt: String
+    modifiedAt: String
+}
+
+type Achievement implements TableWithHistoryQuery {
+    id: ID
+    name: String
+    description: String
+    attribute: String
+    operator: String
+    value: String
+
+    server: Server
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [AchievementHistory]
+}
+
+type AchievementHistory implements HistoryTableQuery {
+    id: ID
+    name: String
+    description: String
+    attribute: String
+    operator: String
+    value: String
+
+    server: ID
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input AchievementFilter {
+    id: ID
+    name: String
+    description: String
+    attribute: String
+    operator: String
+    value: String
+    server: ServerFilter
+}
+
+type AchievementMutation {
+    createAchievement(input: AchievementInput!): Achievement
+    updateAchievement(input: AchievementInput!): Achievement
+    deleteAchievement(id: ID): Achievement
+}
+
+input AchievementInput {
+    id: ID
+    name: String
+    description: String
+    attribute: String
+    operator: String
+    value: String
+    serverId: ID
+}

bot/src/bot_graphql/graphql/autoRole.gql

@@ -0,0 +1,49 @@
+type AutoRole implements TableWithHistoryQuery {
+    id: ID
+    channelId: String
+    channelName: String
+    messageId: String
+
+    server: Server
+
+    autoRoleRuleCount: Int
+    autoRoleRules(filter: AutoRoleRuleFilter, page: Page, sort: Sort): [AutoRoleRule]
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [AutoRoleHistory]
+}
+
+type AutoRoleHistory implements HistoryTableQuery {
+    id: ID
+    channelId: String
+    messageId: String
+
+    server: ID
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input AutoRoleFilter {
+    id: ID
+    channelId: String
+    channelName: String
+    messageId: String
+    server: ServerFilter
+}
+
+type AutoRoleMutation {
+    createAutoRole(input: AutoRoleInput!): AutoRole
+    updateAutoRole(input: AutoRoleInput!): AutoRole
+    deleteAutoRole(id: ID): AutoRole
+}
+
+input AutoRoleInput {
+    id: ID
+    channelId: String
+    messageId: String
+    serverId: ID
+}

bot/src/bot_graphql/graphql/autoRoleRule.gql

@@ -0,0 +1,46 @@
+type AutoRoleRule implements TableWithHistoryQuery {
+    id: ID
+    emojiName: String
+    roleId: String
+    roleName: String
+
+    autoRole: AutoRole
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [AutoRoleRuleHistory]
+}
+
+type AutoRoleRuleHistory implements HistoryTableQuery {
+    id: ID
+    emojiName: String
+    roleId: String
+
+    autoRole: ID
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input AutoRoleRuleFilter {
+    id: ID
+    emojiName: String
+    roleId: String
+    roleName: String
+    autoRole: AutoRoleFilter
+}
+
+type AutoRoleRuleMutation {
+    createAutoRoleRule(input: AutoRoleRuleInput!): AutoRoleRule
+    updateAutoRoleRule(input: AutoRoleRuleInput!): AutoRoleRule
+    deleteAutoRoleRule(id: ID): AutoRoleRule
+}
+
+input AutoRoleRuleInput {
+    id: ID
+    emojiName: String
+    roleId: String
+    autoRoleId: ID
+}

bot/src/bot_graphql/graphql/base.gql

@@ -0,0 +1,31 @@
+interface TableQuery {
+    createdAt: String
+    modifiedAt: String
+}
+
+interface TableWithHistoryQuery {
+    createdAt: String
+    modifiedAt: String
+    history: [HistoryTableQuery]
+}
+
+interface HistoryTableQuery {
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input Page {
+    pageIndex: Int
+    pageSize: Int
+}
+
+input Sort {
+    sortDirection: SortDirection
+    sortColumn: String
+}
+
+enum SortDirection {
+    ASC
+    DESC
+}

bot/src/bot_graphql/graphql/client.gql

@@ -0,0 +1,41 @@
+type Client implements TableQuery {
+    id: ID
+    discordId: String
+    name: String
+    sentMessageCount: Int
+    receivedMessageCount: Int
+    deletedMessageCount: Int
+    receivedCommandCount: Int
+    movedUsersCount: Int
+
+    server: Server
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [ClientHistory]
+}
+
+type ClientHistory  implements HistoryTableQuery {
+    id: ID
+    discordId: String
+    name: String
+    sentMessageCount: Int
+    receivedMessageCount: Int
+    deletedMessageCount: Int
+    receivedCommandCount: Int
+    movedUsersCount: Int
+
+    server: ID
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input ClientFilter {
+    id: ID
+    discordId: String
+    name: String
+    server: ServerFilter
+}

bot/src/bot_graphql/graphql/discord.gql

@@ -0,0 +1,53 @@
+type Discord {
+    guilds(filter: GuildFilter): [Guild]
+    users(filter: DiscordUserFilter): [DiscordUser]
+}
+
+type Guild {
+    id: ID
+    name: String
+
+    channels(filter: ChannelFilter): [Channel]
+    roles: [Role]
+    emojis: [Emoji]
+}
+
+input GuildFilter {
+    id: ID
+    name: String
+}
+
+type Channel {
+    id: String
+    name: String
+    type: String
+}
+
+input ChannelFilter {
+    id: String
+    name: String
+    type: String
+}
+
+type Role {
+    id: String
+    name: String
+}
+
+type DiscordUser {
+    id: String
+    name: String
+    bot: Boolean
+}
+
+input DiscordUserFilter {
+    id: ID
+    name: String
+    bot: Boolean
+}
+
+type Emoji {
+    id: String
+    name: String
+    url: String
+}

bot/src/bot_graphql/graphql/featureFlags.gql

@@ -0,0 +1,9 @@
+type FeatureFlag {
+    key: String
+    value: Boolean
+}
+
+input FeatureFlagInput {
+    key: String
+    value: Boolean
+}

bot/src/bot_graphql/graphql/knownUser.gql

@@ -0,0 +1,18 @@
+type KnownUser implements TableWithHistoryQuery {
+    id: ID
+    discordId: String
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [KnownUserHistory]
+}
+
+type KnownUserHistory implements HistoryTableQuery {
+    id: ID
+    discordId: String
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}

bot/src/bot_graphql/graphql/level.gql

@@ -0,0 +1,49 @@
+type Level implements TableWithHistoryQuery {
+    id: ID
+    name: String
+    color: String
+    minXp: Int
+    permissions: String
+
+    server: Server
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [LevelHistory]
+}
+
+type LevelHistory implements HistoryTableQuery {
+    id: ID
+    name: String
+    color: String
+    minXp: Int
+    permissions: String
+
+    server: ID
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input LevelFilter {
+    id: ID
+    name: String
+    server: ServerFilter
+}
+
+type LevelMutation {
+    createLevel(input: LevelInput!): Level
+    updateLevel(input: LevelInput!): Level
+    deleteLevel(id: ID): Level
+}
+
+input LevelInput {
+    id: ID
+    name: String
+    color: String
+    minXp: Int
+    permissions: String
+    serverId: ID
+}

bot/src/bot_graphql/graphql/mutation.gql

@@ -0,0 +1,11 @@
+type Mutation {
+    autoRole: AutoRoleMutation
+    autoRoleRule: AutoRoleRuleMutation
+    level: LevelMutation
+    user: UserMutation
+    userJoinedGameServer: UserJoinedGameServerMutation
+    achievement: AchievementMutation
+    shortRoleName: ShortRoleNameMutation
+    technicianConfig: TechnicianConfigMutation
+    serverConfig: ServerConfigMutation
+}

bot/src/bot_graphql/graphql/query.gql

@@ -0,0 +1,50 @@
+type Query {
+    autoRoleCount: Int
+    autoRoles(filter: AutoRoleFilter, page: Page, sort: Sort): [AutoRole]
+
+    autoRoleRuleCount: Int
+    autoRoleRules(filter: AutoRoleRuleFilter, page: Page, sort: Sort): [AutoRoleRule]
+
+    clientCount: Int
+    clients(filter: ClientFilter, page: Page, sort: Sort): [Client]
+
+    knownUserCount: Int
+    knownUsers: [KnownUser]
+
+    levelCount: Int
+    levels(filter: LevelFilter, page: Page, sort: Sort): [Level]
+
+    serverCount: Int
+    servers(filter: ServerFilter, page: Page, sort: Sort): [Server]
+
+    gameServerCount: Int
+    gameServers: [GameServer]
+
+    userJoinedServerCount: Int
+    userJoinedServers(filter: UserJoinedServerFilter, page: Page, sort: Sort): [UserJoinedServer]
+
+    userJoinedVoiceChannelCount: Int
+    userJoinedVoiceChannels(filter: UserJoinedVoiceChannelFilter, page: Page, sort: Sort): [UserJoinedVoiceChannel]
+
+    userJoinedGameServerCount: Int
+    userJoinedGameServers(filter: UserJoinedGameServerFilter, page: Page, sort: Sort): [UserJoinedGameServer]
+
+    userCount: Int
+    users(filter: UserFilter, page: Page, sort: Sort): [User]
+
+    achievementCount: Int
+    achievements(filter: AchievementFilter, page: Page, sort: Sort): [Achievement]
+    achievementAttributes: [AchievementAttribute]
+    achievementOperators: [String]
+
+    shortRoleNameCount: Int
+    shortRoleNames(filter: ShortRoleNameFilter, page: Page, sort: Sort): [ShortRoleName]
+    shortRoleNamePositions: [String]
+
+    userWarningCount: Int
+    userWarnings(filter: UserWarningFilter, page: Page, sort: Sort): [UserWarning]
+
+    technicianConfig: TechnicianConfig
+    possibleFeatureFlags: [String]
+    discord: Discord
+}

bot/src/bot_graphql/graphql/server.gql

@@ -0,0 +1,61 @@
+type GameServer {
+    id: ID
+    name: String
+    server: Server
+
+    createdAt: String
+    modifiedAt: String
+}
+
+type Server implements TableWithHistoryQuery {
+    id: ID
+    discordId: String
+    name: String
+    iconURL: String
+
+    autoRoleCount: Int
+    autoRoles(filter: AutoRoleFilter, page: Page, sort: Sort): [AutoRole]
+
+    clientCount: Int
+    clients(filter: ClientFilter, page: Page, sort: Sort): [Client]
+
+    levelCount: Int
+    levels(filter: LevelFilter, page: Page, sort: Sort): [Level]
+
+    gameServerCount: Int
+    gameServers: [GameServer]
+
+    userCount: Int
+    users(filter: UserFilter, page: Page, sort: Sort): [User]
+
+    achievementCount: Int
+    achievements(filter: AchievementFilter, page: Page, sort: Sort): [Achievement]
+
+    shortRoleNameCount: Int
+    shortRoleNames(filter: ShortRoleNameFilter, page: Page, sort: Sort): [ShortRoleName]
+
+    config: ServerConfig
+    hasFeatureFlag(flag: String): FeatureFlag
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [HistoryTableQuery]
+}
+
+type ServerHistory implements HistoryTableQuery {
+    id: ID
+    discordId: String
+    name: String
+    iconURL: String
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input ServerFilter {
+    id: ID
+    discordId: String
+    name: String
+}

bot/src/bot_graphql/graphql/serverConfig.gql

@@ -0,0 +1,111 @@
+type ServerConfig implements TableWithHistoryQuery {
+    id: ID
+    messageDeleteTimer: Int
+    notificationChatId: String
+    maxVoiceStateHours: Int
+    xpPerMessage: Int
+    xpPerReaction: Int
+    maxMessageXpPerHour: Int
+    xpPerOntimeHour: Int
+    xpPerEventParticipation: Int
+    xpPerAchievement: Int
+    xpForBirthday: Int
+    afkCommandChannelId: String
+    helpVoiceChannelId: String
+    teamChannelId: String
+    loginMessageChannelId: String
+    defaultRoleId: String
+    shortRoleNameOnlySetHighestRole: Boolean
+    gameOfferNotificationChatId: String
+    featureFlagCount: Int
+    featureFlags: [FeatureFlag]
+
+    afkChannelIds: [String]
+    moderatorRoleIds: [String]
+    adminRoleIds: [String]
+
+    server: Server
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [ServerConfigHistory]
+}
+
+type ServerConfigHistory implements HistoryTableQuery {
+    id: ID
+    messageDeleteTimer: Int
+    notificationChatId: String
+    maxVoiceStateHours: Int
+    xpPerMessage: Int
+    xpPerReaction: Int
+    maxMessageXpPerHour: Int
+    xpPerOntimeHour: Int
+    xpPerEventParticipation: Int
+    xpPerAchievement: Int
+    xpForBirthday: Int
+    afkCommandChannelId: String
+    helpVoiceChannelId: String
+    teamChannelId: String
+    loginMessageChannelId: String
+    defaultRoleId: String
+    shortRoleNameOnlySetHighestRole: Boolean
+    gameOfferNotificationChatId: String
+    featureFlagCount: Int
+    featureFlags: [FeatureFlag]
+
+    serverId: ID
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+type ServerAFKChannelIdsConfigHistory implements HistoryTableQuery {
+    id: ID
+    channelId: String
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+type ServerTeamRoleIdsConfigHistory implements HistoryTableQuery {
+    id: ID
+    roleId: String
+    teamMemberType: String
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+type ServerConfigMutation {
+    updateServerConfig(input: ServerConfigInput!): ServerConfig
+}
+
+input ServerConfigInput {
+    id: ID
+    messageDeleteTimer: Int
+    notificationChatId: String
+    maxVoiceStateHours: Int
+    xpPerMessage: Int
+    xpPerReaction: Int
+    maxMessageXpPerHour: Int
+    xpPerOntimeHour: Int
+    xpPerEventParticipation: Int
+    xpPerAchievement: Int
+    xpForBirthday: Int
+    afkCommandChannelId: String
+    helpVoiceChannelId: String
+    teamChannelId: String
+    loginMessageChannelId: String
+    defaultRoleId: String
+    shortRoleNameOnlySetHighestRole: Boolean
+    gameOfferNotificationChatId: String
+    featureFlags: [FeatureFlagInput]
+
+    afkChannelIds: [String]
+    moderatorRoleIds: [String]
+    adminRoleIds: [String]
+}

bot/src/bot_graphql/graphql/shortRoleName.gql

@@ -0,0 +1,50 @@
+type ShortRoleName implements TableWithHistoryQuery {
+    id: ID
+    shortName: String
+    roleId: String
+    roleName: String
+    position: String
+
+    server: Server
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [ShortRoleNameHistory]
+}
+
+type ShortRoleNameHistory implements HistoryTableQuery {
+    id: ID
+    shortName: String
+    roleId: String
+    position: String
+
+    server: ID
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input ShortRoleNameFilter {
+    id: ID
+    shortName: String
+    roleId: String
+    roleName: String
+    position: String
+}
+
+type ShortRoleNameMutation {
+    createShortRoleName(input: ShortRoleNameInput!): ShortRoleName
+    updateShortRoleName(input: ShortRoleNameInput!): ShortRoleName
+    deleteShortRoleName(id: ID): ShortRoleName
+}
+
+input ShortRoleNameInput {
+    id: ID
+    shortName: String
+    roleId: String
+    roleName: String
+    position: String
+    serverId: ID
+}

bot/src/bot_graphql/graphql/technicianConfig.gql

@@ -0,0 +1,65 @@
+type TechnicianConfig implements TableWithHistoryQuery {
+    id: ID
+    helpCommandReferenceUrl: String
+    waitForRestart: Int
+    waitForShutdown: Int
+    cacheMaxMessages: Int
+    featureFlagCount: Int
+    featureFlags: [FeatureFlag]
+    pingURLs: [String]
+    technicianIds: [String]
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [TechnicianConfigHistory]
+    pingURLHistory: [TechnicianPingUrlConfigHistory]
+    technicianIdHistory: [TechnicianIdConfigHistory]
+}
+
+type TechnicianConfigHistory implements HistoryTableQuery {
+    id: ID
+    helpCommandReferenceUrl: String
+    waitForRestart: Int
+    waitForShutdown: Int
+    cacheMaxMessages: Int
+    featureFlagCount: Int
+    featureFlags: [FeatureFlag]
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+type TechnicianPingUrlConfigHistory implements HistoryTableQuery {
+    id: ID
+    url: String
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+type TechnicianIdConfigHistory implements HistoryTableQuery {
+    id: ID
+    technicianId: String
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+type TechnicianConfigMutation {
+    updateTechnicianConfig(input: TechnicianConfigInput!): TechnicianConfig
+}
+
+input TechnicianConfigInput {
+    id: ID
+    helpCommandReferenceUrl: String
+    waitForRestart: Int
+    waitForShutdown: Int
+    cacheMaxMessages: Int
+    featureFlags: [FeatureFlagInput]
+    pingURLs: [String]
+    technicianIds: [String]
+}

bot/src/bot_graphql/graphql/user.gql

@@ -0,0 +1,69 @@
+type User implements TableWithHistoryQuery {
+    id: ID
+    discordId: String
+    name: String
+    xp: Int
+    messageCount: Int
+    reactionCount: Int
+    birthday: String
+    ontime: Float
+    level: Level
+
+    joinedServers(filter: UserJoinedServerFilter, page: Page, sort: Sort): [UserJoinedServer]
+    joinedServerCount: Int
+
+    joinedVoiceChannels(filter: UserJoinedVoiceChannelFilter, page: Page, sort: Sort): [UserJoinedVoiceChannel]
+    joinedVoiceChannelCount: Int
+
+    userJoinedGameServerCount: Int
+    userJoinedGameServers(filter: UserJoinedGameServerFilter, page: Page, sort: Sort): [UserJoinedGameServer]
+
+    achievementCount: Int
+    achievements(filter: AchievementFilter, page: Page, sort: Sort): [Achievement]
+
+    userWarningCount: Int
+    userWarnings(filter: UserWarningFilter, page: Page, sort: Sort): [UserWarning]
+
+    server: Server
+    leftServer: Boolean
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [UserHistory]
+}
+
+type UserHistory implements HistoryTableQuery {
+    id: ID
+    discordId: String
+    xp: Int
+
+    server: ID
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input UserFilter {
+    id: ID
+    discordId: String
+    name: String
+    xp: Int
+    ontime: Float
+    level: LevelFilter
+    server: ServerFilter
+    leftServer: Boolean
+}
+
+type UserMutation {
+    updateUser(input: UserInput!): User
+}
+
+input UserInput {
+    id: ID
+    xp: Int
+    birthday: String
+    levelId: ID
+    userWarnings: [UserWarningInput]
+}

bot/src/bot_graphql/graphql/userJoinedGameServer.gql

@@ -0,0 +1,43 @@
+type UserJoinedGameServer implements TableWithHistoryQuery {
+    id: ID
+    gameServer: String
+    user: User
+    time: Float
+    joinedOn: String
+    leavedOn: String
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [UserJoinedGameServerHistory]
+}
+
+type UserJoinedGameServerHistory implements HistoryTableQuery {
+    id: ID
+    gameServer: String
+    user: ID
+    time: Float
+    joinedOn: String
+    leavedOn: String
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input UserJoinedGameServerFilter {
+    id: ID
+    gameServer: String
+    user: UserFilter
+    joinedOn: String
+    leavedOn: String
+}
+
+type UserJoinedGameServerMutation {
+    userJoined(input: UserJoinedGameServerInput!): UserJoinedGameServer
+    userLeft(input: UserJoinedGameServerInput!): UserJoinedGameServer
+}
+
+input UserJoinedGameServerInput {
+    ident: String!
+}

bot/src/bot_graphql/graphql/userJoinedServer.gql

@@ -0,0 +1,29 @@
+type UserJoinedServer implements TableWithHistoryQuery {
+    id: ID
+    user: User
+    joinedOn: String
+    leavedOn: String
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [UserJoinedServerHistory]
+}
+
+type UserJoinedServerHistory implements HistoryTableQuery {
+    id: ID
+    user: ID
+    joinedOn: String
+    leavedOn: String
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input UserJoinedServerFilter  {
+    id: ID
+    user: UserFilter
+    joinedOn: String
+    leavedOn: String
+}

bot/src/bot_graphql/graphql/userJoinedVoiceChannel.gql

@@ -0,0 +1,37 @@
+type UserJoinedVoiceChannel implements TableWithHistoryQuery {
+    id: ID
+    channelId: String
+    channelName: String
+    user: User
+    time: Float
+    joinedOn: String
+    leavedOn: String
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [UserJoinedVoiceChannelHistory]
+}
+
+type UserJoinedVoiceChannelHistory implements HistoryTableQuery {
+    id: ID
+    channelId: String
+    channelName: String
+    user: ID
+    time: Float
+    joinedOn: String
+    leavedOn: String
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input UserJoinedVoiceChannelFilter {
+    id: ID
+    channelId: String
+    channelName: String
+    user: UserFilter
+    joinedOn: String
+    leavedOn: String
+}

bot/src/bot_graphql/graphql/userWarning.gql

@@ -0,0 +1,34 @@
+type UserWarning implements TableWithHistoryQuery {
+    id: ID
+    user: User
+    description: String
+    author: User
+
+    createdAt: String
+    modifiedAt: String
+
+    history: [UserWarningHistory]
+}
+
+type UserWarningHistory implements HistoryTableQuery {
+    id: ID
+    user: ID
+    description: String
+    author: ID
+
+    deleted: Boolean
+    dateFrom: String
+    dateTo: String
+}
+
+input UserWarningFilter {
+    id: ID
+    user: UserFilter
+}
+
+input UserWarningInput {
+    id: ID
+    user: ID
+    description: String
+    author: ID
+}

bot/src/bot_graphql/graphql_module.py

@@ -0,0 +1,176 @@
+from cpl_core.configuration import ConfigurationABC
+from cpl_core.dependency_injection import ServiceCollectionABC
+from cpl_core.environment import ApplicationEnvironmentABC
+from cpl_discord.service.discord_collection_abc import DiscordCollectionABC
+
+from bot_core.abc.module_abc import ModuleABC
+from bot_core.configuration.feature_flags_enum import FeatureFlagsEnum
+from bot_graphql.abc.filter_abc import FilterABC
+from bot_graphql.abc.query_abc import QueryABC
+from bot_graphql.filter.achievement_filter import AchievementFilter
+from bot_graphql.filter.auto_role_filter import AutoRoleFilter
+from bot_graphql.filter.auto_role_rule_filter import AutoRoleRuleFilter
+from bot_graphql.filter.client_filter import ClientFilter
+from bot_graphql.filter.level_filter import LevelFilter
+from bot_graphql.filter.server_filter import ServerFilter
+from bot_graphql.filter.short_role_name_filter import ShortRoleNameFilter
+from bot_graphql.filter.user_filter import UserFilter
+from bot_graphql.filter.user_joined_game_server_filter import UserJoinedGameServerFilter
+from bot_graphql.filter.user_joined_server_filter import UserJoinedServerFilter
+from bot_graphql.filter.user_joined_voice_channel_filter import (
+    UserJoinedVoiceChannelFilter,
+)
+from bot_graphql.filter.user_warning_filter import UserWarningFilter
+from bot_graphql.graphql_service import GraphQLService
+from bot_graphql.mutation import Mutation
+from bot_graphql.mutations.achievement_mutation import AchievementMutation
+from bot_graphql.mutations.auto_role_mutation import AutoRoleMutation
+from bot_graphql.mutations.auto_role_rule_mutation import AutoRoleRuleMutation
+from bot_graphql.mutations.level_mutation import LevelMutation
+from bot_graphql.mutations.server_config_mutation import ServerConfigMutation
+from bot_graphql.mutations.short_role_name_mutation import ShortRoleNameMutation
+from bot_graphql.mutations.technician_config_mutation import TechnicianConfigMutation
+from bot_graphql.mutations.user_joined_game_server_mutation import (
+    UserJoinedGameServerMutation,
+)
+from bot_graphql.mutations.user_mutation import UserMutation
+from bot_graphql.queries.achievement_attribute_query import AchievementAttributeQuery
+from bot_graphql.queries.achievement_history_query import AchievementHistoryQuery
+from bot_graphql.queries.achievement_query import AchievementQuery
+from bot_graphql.queries.auto_role_history_query import AutoRoleHistoryQuery
+from bot_graphql.queries.auto_role_query import AutoRoleQuery
+from bot_graphql.queries.auto_role_rule_history_query import AutoRoleRuleHistoryQuery
+from bot_graphql.queries.auto_role_rule_query import AutoRoleRuleQuery
+from bot_graphql.queries.client_history_query import ClientHistoryQuery
+from bot_graphql.queries.client_query import ClientQuery
+from bot_graphql.queries.discord.channel_query import ChannelQuery
+from bot_graphql.queries.discord.discord_query import DiscordQuery
+from bot_graphql.queries.discord.discord_user_query import DiscordUserQuery
+from bot_graphql.queries.discord.emoji_query import EmojiQuery
+from bot_graphql.queries.discord.guild_query import GuildQuery
+from bot_graphql.queries.discord.role_query import RoleQuery
+from bot_graphql.queries.game_server_query import GameServerQuery
+from bot_graphql.queries.known_user_history_query import KnownUserHistoryQuery
+from bot_graphql.queries.known_user_query import KnownUserQuery
+from bot_graphql.queries.level_history_query import LevelHistoryQuery
+from bot_graphql.queries.level_query import LevelQuery
+from bot_graphql.queries.server_config_query import ServerConfigQuery
+from bot_graphql.queries.server_history_query import ServerHistoryQuery
+from bot_graphql.queries.server_query import ServerQuery
+from bot_graphql.queries.short_role_name_history_query import ShortRoleNameHistoryQuery
+from bot_graphql.queries.short_role_name_query import ShortRoleNameQuery
+from bot_graphql.queries.technician_config_history_query import (
+    TechnicianConfigHistoryQuery,
+)
+from bot_graphql.queries.technician_config_query import TechnicianConfigQuery
+from bot_graphql.queries.technician_id_config_history_query import (
+    TechnicianIdConfigHistoryQuery,
+)
+from bot_graphql.queries.technician_ping_url_config_history_query import (
+    TechnicianPingUrlConfigHistoryQuery,
+)
+from bot_graphql.queries.user_history_query import UserHistoryQuery
+from bot_graphql.queries.user_joined_game_server_history_query import (
+    UserJoinedGameServerHistoryQuery,
+)
+from bot_graphql.queries.user_joined_game_server_query import UserJoinedGameServerQuery
+from bot_graphql.queries.user_joined_server_history_query import (
+    UserJoinedServerHistoryQuery,
+)
+from bot_graphql.queries.user_joined_server_query import UserJoinedServerQuery
+from bot_graphql.queries.user_joined_voice_channel_history_query import (
+    UserJoinedVoiceChannelHistoryQuery,
+)
+from bot_graphql.queries.user_joined_voice_channel_query import (
+    UserJoinedVoiceChannelQuery,
+)
+from bot_graphql.queries.user_query import UserQuery
+from bot_graphql.queries.user_warning_history_query import UserWarningHistoryQuery
+from bot_graphql.queries.user_warning_query import UserWarningQuery
+from bot_graphql.query import Query
+from bot_graphql.schema import Schema
+
+
+class GraphQLModule(ModuleABC):
+    def __init__(self, dc: DiscordCollectionABC):
+        ModuleABC.__init__(self, dc, FeatureFlagsEnum.data_module)
+
+    def configure_configuration(
+        self, config: ConfigurationABC, env: ApplicationEnvironmentABC
+    ):
+        pass
+
+    def configure_services(
+        self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
+    ):
+        services.add_singleton(Schema)
+        services.add_singleton(GraphQLService)
+        services.add_singleton(Query)
+        services.add_singleton(Mutation)
+
+        # queries
+        services.add_transient(QueryABC, AchievementAttributeQuery)
+        services.add_transient(QueryABC, AchievementQuery)
+        services.add_transient(QueryABC, AchievementHistoryQuery)
+        services.add_transient(QueryABC, AutoRoleHistoryQuery)
+        services.add_transient(QueryABC, AutoRoleQuery)
+        services.add_transient(QueryABC, AutoRoleRuleHistoryQuery)
+        services.add_transient(QueryABC, AutoRoleRuleQuery)
+        services.add_transient(QueryABC, ClientHistoryQuery)
+        services.add_transient(QueryABC, ClientQuery)
+        services.add_transient(QueryABC, KnownUserHistoryQuery)
+        services.add_transient(QueryABC, KnownUserQuery)
+        services.add_transient(QueryABC, LevelHistoryQuery)
+        services.add_transient(QueryABC, LevelQuery)
+        services.add_transient(QueryABC, ServerConfigQuery)
+        services.add_transient(QueryABC, ServerHistoryQuery)
+        services.add_transient(QueryABC, ServerQuery)
+        services.add_transient(QueryABC, TechnicianConfigQuery)
+        services.add_transient(QueryABC, TechnicianConfigHistoryQuery)
+        services.add_transient(QueryABC, TechnicianPingUrlConfigHistoryQuery)
+        services.add_transient(QueryABC, TechnicianIdConfigHistoryQuery)
+        services.add_transient(QueryABC, GameServerQuery)
+        services.add_transient(QueryABC, UserHistoryQuery)
+        services.add_transient(QueryABC, UserQuery)
+        services.add_transient(QueryABC, UserJoinedServerHistoryQuery)
+        services.add_transient(QueryABC, UserJoinedServerQuery)
+        services.add_transient(QueryABC, UserJoinedVoiceChannelHistoryQuery)
+        services.add_transient(QueryABC, UserJoinedVoiceChannelQuery)
+        services.add_transient(QueryABC, UserJoinedGameServerHistoryQuery)
+        services.add_transient(QueryABC, UserJoinedGameServerQuery)
+        services.add_transient(QueryABC, ShortRoleNameHistoryQuery)
+        services.add_transient(QueryABC, ShortRoleNameQuery)
+        services.add_transient(QueryABC, UserWarningHistoryQuery)
+        services.add_transient(QueryABC, UserWarningQuery)
+
+        services.add_transient(QueryABC, DiscordQuery)
+        services.add_transient(QueryABC, GuildQuery)
+        services.add_transient(QueryABC, ChannelQuery)
+        services.add_transient(QueryABC, RoleQuery)
+        services.add_transient(QueryABC, EmojiQuery)
+        services.add_transient(QueryABC, DiscordUserQuery)
+
+        # filters
+        services.add_transient(FilterABC, AutoRoleFilter)
+        services.add_transient(FilterABC, AutoRoleRuleFilter)
+        services.add_transient(FilterABC, ClientFilter)
+        services.add_transient(FilterABC, LevelFilter)
+        services.add_transient(FilterABC, ServerFilter)
+        services.add_transient(FilterABC, UserFilter)
+        services.add_transient(FilterABC, AchievementFilter)
+        services.add_transient(FilterABC, UserJoinedServerFilter)
+        services.add_transient(FilterABC, UserJoinedVoiceChannelFilter)
+        services.add_transient(FilterABC, UserJoinedGameServerFilter)
+        services.add_transient(FilterABC, ShortRoleNameFilter)
+        services.add_transient(FilterABC, UserWarningFilter)
+
+        # mutations
+        services.add_transient(QueryABC, AutoRoleMutation)
+        services.add_transient(QueryABC, AutoRoleRuleMutation)
+        services.add_transient(QueryABC, LevelMutation)
+        services.add_transient(QueryABC, UserMutation)
+        services.add_transient(QueryABC, AchievementMutation)
+        services.add_transient(QueryABC, ShortRoleNameMutation)
+        services.add_transient(QueryABC, UserJoinedGameServerMutation)
+        services.add_transient(QueryABC, TechnicianConfigMutation)
+        services.add_transient(QueryABC, ServerConfigMutation)

bot/src/bot_graphql/graphql_service.py

@@ -0,0 +1,6 @@
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class GraphQLService:
+    def __init__(self, queries: list[QueryABC]):
+        self._queries = queries

bot/src/bot_graphql/model/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+bot sh-edraft.de Discord bot
+~~~~~~~~~~~~~~~~~~~
+
+Discord bot for customers of sh-edraft.de
+
+:copyright: (c) 2022 - 2023 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = "bot_graphql.model"
+__author__ = "Sven Heidemann"
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2022 - 2023 sh-edraft.de"
+__version__ = "1.2.0"
+
+from collections import namedtuple
+
+
+# imports
+
+VersionInfo = namedtuple("VersionInfo", "major minor micro")
+version_info = VersionInfo(major="1", minor="2", micro="0")

bot/src/bot_graphql/model/discord.py

@@ -0,0 +1,16 @@
+from cpl_query.extension import List
+from discord import Guild, User
+
+
+class Discord:
+    def __init__(self, guilds: List[Guild], users: List[User]):
+        self._guilds = guilds
+        self._users = users
+
+    @property
+    def guilds(self) -> List[Guild]:
+        return self._guilds
+
+    @property
+    def users(self) -> List[User]:
+        return self._users

bot/src/bot_graphql/mutation.py

@@ -0,0 +1,39 @@
+from ariadne import MutationType
+
+from bot_graphql.mutations.achievement_mutation import AchievementMutation
+from bot_graphql.mutations.auto_role_mutation import AutoRoleMutation
+from bot_graphql.mutations.auto_role_rule_mutation import AutoRoleRuleMutation
+from bot_graphql.mutations.level_mutation import LevelMutation
+from bot_graphql.mutations.server_config_mutation import ServerConfigMutation
+from bot_graphql.mutations.short_role_name_mutation import ShortRoleNameMutation
+from bot_graphql.mutations.technician_config_mutation import TechnicianConfigMutation
+from bot_graphql.mutations.user_joined_game_server_mutation import (
+    UserJoinedGameServerMutation,
+)
+from bot_graphql.mutations.user_mutation import UserMutation
+
+
+class Mutation(MutationType):
+    def __init__(
+        self,
+        auto_role_mutation: AutoRoleMutation,
+        auto_role_rule_mutation: AutoRoleRuleMutation,
+        level_mutation: LevelMutation,
+        user_mutation: UserMutation,
+        achievement_mutation: AchievementMutation,
+        user_joined_game_server: UserJoinedGameServerMutation,
+        technician_config: TechnicianConfigMutation,
+        server_config: ServerConfigMutation,
+        short_role_name_mutation: ShortRoleNameMutation,
+    ):
+        MutationType.__init__(self)
+
+        self.set_field("autoRole", lambda *_: auto_role_mutation)
+        self.set_field("autoRoleRule", lambda *_: auto_role_rule_mutation)
+        self.set_field("level", lambda *_: level_mutation)
+        self.set_field("user", lambda *_: user_mutation)
+        self.set_field("achievement", lambda *_: achievement_mutation)
+        self.set_field("userJoinedGameServer", lambda *_: user_joined_game_server)
+        self.set_field("shortRoleName", lambda *_: short_role_name_mutation)
+        self.set_field("technicianConfig", lambda *_: technician_config)
+        self.set_field("serverConfig", lambda *_: server_config)

bot/src/bot_graphql/mutations/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+bot sh-edraft.de Discord bot
+~~~~~~~~~~~~~~~~~~~
+
+Discord bot for customers of sh-edraft.de
+
+:copyright: (c) 2022 - 2023 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = "bot_graphql.mutations"
+__author__ = "Sven Heidemann"
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2022 - 2023 sh-edraft.de"
+__version__ = "1.2.0"
+
+from collections import namedtuple
+
+
+# imports:
+
+VersionInfo = namedtuple("VersionInfo", "major minor micro")
+version_info = VersionInfo(major="1", minor="2", micro="0")

bot/src/bot_graphql/mutations/achievement_mutation.py

@@ -0,0 +1,97 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.abc.achievement_repository_abc import AchievementRepositoryABC
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+from bot_data.model.achievement import Achievement
+from bot_data.model.user_role_enum import UserRoleEnum
+from bot_graphql.abc.query_abc import QueryABC
+from modules.permission.service.permission_service import PermissionService
+
+
+class AchievementMutation(QueryABC):
+    def __init__(
+        self,
+        servers: ServerRepositoryABC,
+        achievements: AchievementRepositoryABC,
+        bot: DiscordBotServiceABC,
+        db: DatabaseContextABC,
+        permissions: PermissionService,
+    ):
+        QueryABC.__init__(self, "AchievementMutation")
+
+        self._servers = servers
+        self._achievements = achievements
+        self._bot = bot
+        self._db = db
+        self._permissions = permissions
+
+        self.set_field("createAchievement", self.resolve_create_achievement)
+        self.set_field("updateAchievement", self.resolve_update_achievement)
+        self.set_field("deleteAchievement", self.resolve_delete_achievement)
+
+    def resolve_create_achievement(self, *_, input: dict):
+        server = self._servers.get_server_by_id(input["serverId"])
+        self._can_user_mutate_data(server, UserRoleEnum.admin)
+
+        achievement = Achievement(
+            input["name"],
+            input["description"],
+            input["attribute"],
+            input["operator"],
+            input["value"],
+            server,
+        )
+        self._achievements.add_achievement(achievement)
+        self._db.save_changes()
+
+        def get_new_achievement(a: Achievement):
+            return (
+                a.name == achievement.name
+                and a.description == achievement.description
+                and a.attribute == achievement.attribute
+                and a.operator == achievement.operator
+                and a.value == achievement.value
+                and a.server.id == server.id
+            )
+
+        return (
+            self._achievements.get_achievements_by_server_id(achievement.server.id)
+            .where(get_new_achievement)
+            .last()
+        )
+
+    def resolve_update_achievement(self, *_, input: dict):
+        achievement = self._achievements.get_achievement_by_id(input["id"])
+        self._can_user_mutate_data(achievement.server, UserRoleEnum.moderator)
+
+        achievement.name = input["name"] if "name" in input else achievement.name
+        achievement.description = (
+            input["description"] if "description" in input else achievement.description
+        )
+        achievement.attribute = (
+            input["attribute"] if "attribute" in input else achievement.attribute
+        )
+        achievement.operator = (
+            input["operator"] if "operator" in input else achievement.operator
+        )
+        achievement.value = input["value"] if "value" in input else achievement.value
+
+        self._achievements.update_achievement(achievement)
+        self._db.save_changes()
+
+        achievement = self._achievements.get_achievement_by_id(input["id"])
+        return achievement
+
+    def resolve_delete_achievement(self, *_, id: int):
+        achievement = self._achievements.get_achievement_by_id(id)
+        self._can_user_mutate_data(achievement.server, UserRoleEnum.admin)
+
+        joins = self._achievements.get_user_got_achievements_by_achievement_id(id)
+        for join in joins:
+            self._achievements.delete_user_got_achievement(join)
+
+        self._achievements.delete_achievement(achievement)
+        self._db.save_changes()
+
+        return achievement

bot/src/bot_graphql/mutations/auto_role_mutation.py

@@ -0,0 +1,74 @@
+from cpl_core.database.context import DatabaseContextABC
+
+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.user_role_enum import UserRoleEnum
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class AutoRoleMutation(QueryABC):
+    def __init__(
+        self,
+        servers: ServerRepositoryABC,
+        auto_roles: AutoRoleRepositoryABC,
+        db: DatabaseContextABC,
+    ):
+        QueryABC.__init__(self, "AutoRoleMutation")
+
+        self._servers = servers
+        self._auto_roles = auto_roles
+        self._db = db
+
+        self.set_field("createAutoRole", self.resolve_create_auto_role)
+        self.set_field("updateAutoRole", self.resolve_update_auto_role)
+        self.set_field("deleteAutoRole", self.resolve_delete_auto_role)
+
+    def resolve_create_auto_role(self, *_, input: dict):
+        auto_role = AutoRole(
+            self._servers.get_server_by_id(input["serverId"]),
+            input["channelId"],
+            input["messageId"],
+        )
+        self._can_user_mutate_data(auto_role.server, UserRoleEnum.moderator)
+
+        self._auto_roles.add_auto_role(auto_role)
+        self._db.save_changes()
+
+        def get_new(x: AutoRole):
+            return (
+                x.server.id == int(input["serverId"])
+                and x.discord_channel_id == int(input["channelId"])
+                and x.discord_message_id == int(input["messageId"])
+            )
+
+        return (
+            self._auto_roles.get_auto_roles_by_server_id(auto_role.server.id)
+            .where(get_new)
+            .last()
+        )
+
+    def resolve_update_auto_role(self, *_, input: dict):
+        auto_role = self._auto_roles.get_auto_role_by_id(input["id"])
+        self._can_user_mutate_data(auto_role.server, UserRoleEnum.moderator)
+
+        auto_role.discord_channel_id = (
+            input["channelId"] if "channelId" in input else auto_role.discord_channel_id
+        )
+        auto_role.discord_message_id = (
+            input["messageId"] if "messageId" in input else auto_role.discord_message_id
+        )
+
+        self._auto_roles.update_auto_role(auto_role)
+        self._db.save_changes()
+
+        auto_role = self._auto_roles.get_auto_role_by_id(input["id"])
+        return auto_role
+
+    def resolve_delete_auto_role(self, *_, id: int):
+        auto_role = self._auto_roles.get_auto_role_by_id(id)
+        self._can_user_mutate_data(auto_role.server, UserRoleEnum.moderator)
+
+        self._auto_roles.delete_auto_role(auto_role)
+        self._db.save_changes()
+        return auto_role

bot/src/bot_graphql/mutations/auto_role_rule_mutation.py

@@ -0,0 +1,104 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_core.abc.client_utils_abc import ClientUtilsABC
+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_rule import AutoRoleRule
+from bot_data.model.user_role_enum import UserRoleEnum
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class AutoRoleRuleMutation(QueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+        servers: ServerRepositoryABC,
+        auto_roles: AutoRoleRepositoryABC,
+        db: DatabaseContextABC,
+        client_utils: ClientUtilsABC,
+    ):
+        QueryABC.__init__(self, "AutoRoleRuleMutation")
+
+        self._bot = bot
+        self._servers = servers
+        self._auto_roles = auto_roles
+        self._db = db
+        self._client_utils = client_utils
+
+        self.set_field("createAutoRoleRule", self.resolve_create_auto_role_rule)
+        self.set_field("updateAutoRoleRule", self.resolve_update_auto_role_rule)
+        self.set_field("deleteAutoRoleRule", self.resolve_delete_auto_role_rule)
+
+    def resolve_create_auto_role_rule(self, *_, input: dict):
+        auto_role_rule = AutoRoleRule(
+            self._auto_roles.get_auto_role_by_id(input["autoRoleId"]),
+            input["emojiName"],
+            input["roleId"],
+        )
+        self._can_user_mutate_data(
+            auto_role_rule.auto_role.server, UserRoleEnum.moderator
+        )
+
+        self._auto_roles.add_auto_role_rule(auto_role_rule)
+        self._db.save_changes()
+
+        def get_new(x: AutoRoleRule):
+            return (
+                x.auto_role.id == int(input["autoRoleId"])
+                and x.emoji_name == input["emojiName"]
+                and x.role_id == int(input["roleId"])
+            )
+
+        self._bot.loop.create_task(
+            self._client_utils.react_to_message_by_auto_role_rule(
+                auto_role_rule.auto_role.discord_channel_id,
+                auto_role_rule.auto_role.discord_message_id,
+                auto_role_rule,
+                self._bot.get_guild(auto_role_rule.auto_role.server.discord_id),
+            )
+        )
+        return (
+            self._auto_roles.get_auto_role_rules_by_auto_role_id(
+                auto_role_rule.auto_role.id
+            )
+            .where(get_new)
+            .last()
+        )
+
+    def resolve_update_auto_role_rule(self, *_, input: dict):
+        auto_role_rule = self._auto_roles.get_auto_role_rule_by_id(input["id"])
+        self._can_user_mutate_data(
+            auto_role_rule.auto_role.server, UserRoleEnum.moderator
+        )
+
+        auto_role_rule.emoji_name = (
+            input["emojiName"] if "emojiName" in input else auto_role_rule.emoji_name
+        )
+        auto_role_rule.role_id = (
+            input["roleId"] if "roleId" in input else auto_role_rule.role_id
+        )
+
+        self._auto_roles.update_auto_role_rule(auto_role_rule)
+        self._db.save_changes()
+
+        auto_role_rule = self._auto_roles.get_auto_role_rule_by_id(input["id"])
+        self._bot.loop.create_task(
+            self._client_utils.react_to_message_by_auto_role_rule(
+                auto_role_rule.auto_role.discord_channel_id,
+                auto_role_rule.auto_role.discord_message_id,
+                auto_role_rule,
+                self._bot.get_guild(auto_role_rule.auto_role.server.discord_id),
+            )
+        )
+        return auto_role_rule
+
+    def resolve_delete_auto_role_rule(self, *_, id: int):
+        auto_role_rule = self._auto_roles.get_auto_role_rule_by_id(id)
+        self._can_user_mutate_data(
+            auto_role_rule.auto_role.server, UserRoleEnum.moderator
+        )
+
+        self._auto_roles.delete_auto_role_rule(auto_role_rule)
+        self._db.save_changes()
+        return auto_role_rule

bot/src/bot_graphql/mutations/level_mutation.py

@@ -0,0 +1,89 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.abc.level_repository_abc import LevelRepositoryABC
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+from bot_data.model.level import Level
+from bot_data.model.user_role_enum import UserRoleEnum
+from bot_graphql.abc.query_abc import QueryABC
+from modules.level.level_seeder import LevelSeeder
+
+
+class LevelMutation(QueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+        servers: ServerRepositoryABC,
+        levels: LevelRepositoryABC,
+        db: DatabaseContextABC,
+        level_seeder: LevelSeeder,
+    ):
+        QueryABC.__init__(self, "LevelMutation")
+
+        self._bot = bot
+        self._servers = servers
+        self._levels = levels
+        self._db = db
+        self._level_seeder = level_seeder
+
+        self.set_field("createLevel", self.resolve_create_level)
+        self.set_field("updateLevel", self.resolve_update_level)
+        self.set_field("deleteLevel", self.resolve_delete_level)
+
+    def resolve_create_level(self, *_, input: dict):
+        server = self._servers.get_server_by_id(input["serverId"])
+        self._can_user_mutate_data(server, UserRoleEnum.admin)
+
+        level = Level(
+            input["name"],
+            input["color"],
+            int(input["minXp"]),
+            int(input["permissions"]),
+            server,
+        )
+        self._levels.add_level(level)
+        self._db.save_changes()
+
+        def get_new_level(l: Level):
+            return (
+                l.name == level.name
+                and l.color == level.color
+                and l.min_xp == level.min_xp
+                and l.permissions == level.permissions
+                and l.server.id == server.id
+            )
+
+        self._bot.loop.create_task(self._level_seeder.seed())
+        return (
+            self._levels.get_levels_by_server_id(level.server.id)
+            .where(get_new_level)
+            .last()
+        )
+
+    def resolve_update_level(self, *_, input: dict):
+        level = self._levels.get_level_by_id(input["id"])
+        self._can_user_mutate_data(level.server, UserRoleEnum.admin)
+
+        level.name = input["name"] if "name" in input else level.name
+        level.color = input["color"] if "color" in input else level.color
+        level.min_xp = input["minXp"] if "minXp" in input else level.min_xp
+        level.permissions = (
+            input["permissions"] if "permissions" in input else level.permissions
+        )
+
+        self._levels.update_level(level)
+        self._db.save_changes()
+
+        self._bot.loop.create_task(self._level_seeder.seed())
+        level = self._levels.get_level_by_id(input["id"])
+        return level
+
+    def resolve_delete_level(self, *_, id: int):
+        level = self._levels.get_level_by_id(id)
+        self._can_user_mutate_data(level.server, UserRoleEnum.admin)
+
+        self._levels.delete_level(level)
+        self._db.save_changes()
+
+        self._bot.loop.create_task(self._level_seeder.seed())
+        return level

bot/src/bot_graphql/mutations/server_config_mutation.py

@@ -0,0 +1,240 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_api.logging.api_logger import ApiLogger
+from bot_api.route.route import Route
+from bot_core.service.config_service import ConfigService
+from bot_data.abc.server_config_repository_abc import ServerConfigRepositoryABC
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+from bot_data.model.server_afk_channel_ids_config import ServerAFKChannelIdsConfig
+from bot_data.model.server_config import ServerConfig
+from bot_data.model.server_team_role_ids_config import ServerTeamRoleIdsConfig
+from bot_data.model.team_member_type_enum import TeamMemberTypeEnum
+from bot_data.model.user_role_enum import UserRoleEnum
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class ServerConfigMutation(QueryABC):
+    def __init__(
+        self,
+        logger: ApiLogger,
+        bot: DiscordBotServiceABC,
+        servers: ServerRepositoryABC,
+        server_configs: ServerConfigRepositoryABC,
+        db: DatabaseContextABC,
+        config_service: ConfigService,
+    ):
+        QueryABC.__init__(self, "ServerConfigMutation")
+
+        self._logger = logger
+        self._bot = bot
+        self._servers = servers
+        self._server_configs = server_configs
+        self._db = db
+        self._config_service = config_service
+
+        self.set_field("updateServerConfig", self.resolve_update_server_config)
+
+    def resolve_update_server_config(self, *_, input: dict):
+        if "id" not in input:
+            raise ValueError("Id not set")
+
+        server_config = self._server_configs.get_server_config_by_id(int(input["id"]))
+        self._can_user_mutate_data(
+            Route.get_user().users[0].server, UserRoleEnum.technician
+        )
+
+        server_config.message_delete_timer = (
+            input["messageDeleteTimer"]
+            if "messageDeleteTimer" in input
+            else server_config.message_delete_timer
+        )
+        server_config.notification_chat_id = (
+            input["notificationChatId"]
+            if "notificationChatId" in input
+            else server_config.notification_chat_id
+        )
+        server_config.max_voice_state_hours = (
+            input["maxVoiceStateHours"]
+            if "maxVoiceStateHours" in input
+            else server_config.max_voice_state_hours
+        )
+        server_config.xp_per_message = (
+            input["xpPerMessage"]
+            if "xpPerMessage" in input
+            else server_config.xp_per_message
+        )
+        server_config.xp_per_reaction = (
+            input["xpPerReaction"]
+            if "xpPerReaction" in input
+            else server_config.xp_per_reaction
+        )
+        server_config.max_message_xp_per_hour = (
+            input["maxMessageXpPerHour"]
+            if "maxMessageXpPerHour" in input
+            else server_config.max_message_xp_per_hour
+        )
+        server_config.xp_per_ontime_hour = (
+            input["xpPerOntimeHour"]
+            if "xpPerOntimeHour" in input
+            else server_config.xp_per_ontime_hour
+        )
+        server_config.xp_per_event_participation = (
+            input["xpPerEventParticipation"]
+            if "xpPerEventParticipation" in input
+            else server_config.xp_per_event_participation
+        )
+        server_config.xp_per_achievement = (
+            input["xpPerAchievement"]
+            if "xpPerAchievement" in input
+            else server_config.xp_per_achievement
+        )
+        server_config.xp_for_birthday = (
+            input["xpForBirthday"]
+            if "xpForBirthday" in input
+            else server_config.xp_for_birthday
+        )
+        server_config.afk_command_channel_id = (
+            input["afkCommandChannelId"]
+            if "afkCommandChannelId" in input
+            else server_config.afk_command_channel_id
+        )
+        server_config.help_voice_channel_id = (
+            input["helpVoiceChannelId"]
+            if "helpVoiceChannelId" in input
+            else server_config.help_voice_channel_id
+        )
+        server_config.team_channel_id = (
+            input["teamChannelId"]
+            if "teamChannelId" in input
+            else server_config.team_channel_id
+        )
+        server_config.login_message_channel_id = (
+            input["loginMessageChannelId"]
+            if "loginMessageChannelId" in input
+            else server_config.login_message_channel_id
+        )
+        server_config.default_role_id = (
+            input["defaultRoleId"]
+            if "defaultRoleId" in input
+            else server_config.default_role_id
+        )
+        server_config.short_role_name_only_set_highest_role = (
+            input["shortRoleNameOnlySetHighestRole"]
+            if "shortRoleNameOnlySetHighestRole" in input
+            else server_config.short_role_name_only_set_highest_role
+        )
+        server_config.game_offer_notification_chat_id = (
+            input["gameOfferNotificationChatId"]
+            if "gameOfferNotificationChatId" in input
+            else server_config.game_offer_notification_chat_id
+        )
+        server_config.feature_flags = (
+            dict(
+                zip(
+                    [x["key"] for x in input["featureFlags"]],
+                    [x["value"] for x in input["featureFlags"]],
+                )
+            )
+            if "featureFlags" in input
+            else server_config.feature_flags
+        )
+        server_config.afk_channel_ids = (
+            List(int).extend([int(x) for x in input["afkChannelIds"]])
+            if "afkChannelIds" in input
+            else server_config.afk_channel_ids
+        )
+
+        team_role_ids = List(ServerTeamRoleIdsConfig)
+        if "moderatorRoleIds" in input:
+            team_role_ids.extend(
+                [
+                    ServerTeamRoleIdsConfig(
+                        x, TeamMemberTypeEnum.moderator, server_config.server.id
+                    )
+                    for x in input["moderatorRoleIds"]
+                ]
+            )
+        else:
+            team_role_ids.extend(
+                server_config.team_role_ids.where(
+                    lambda x: x.team_member_type == TeamMemberTypeEnum.moderator
+                )
+            )
+
+        if "adminRoleIds" in input:
+            team_role_ids.extend(
+                [
+                    ServerTeamRoleIdsConfig(
+                        x, TeamMemberTypeEnum.admin, server_config.server.id
+                    )
+                    for x in input["adminRoleIds"]
+                ]
+            )
+        else:
+            team_role_ids.extend(
+                server_config.team_role_ids.where(
+                    lambda x: x.team_member_type == TeamMemberTypeEnum.admin
+                )
+            )
+
+        self._server_configs.update_server_config(server_config)
+        if "afkChannelIds" in input:
+            self._update_afk_channel_ids(server_config)
+
+        if "moderatorRoleIds" in input or "adminRoleIds" in input:
+            server_config.team_role_ids = team_role_ids
+            self._update_team_role_ids(server_config)
+
+        self._db.save_changes()
+        self._bot.loop.create_task(
+            self._config_service.reload_server_config(server_config.server)
+        )
+        return server_config
+
+    def _update_afk_channel_ids(self, new_config: ServerConfig):
+        old_config = self._server_configs.get_server_config_by_server(
+            new_config.server.id
+        )
+        for channel_id in old_config.afk_channel_ids:
+            if channel_id in new_config.afk_channel_ids:
+                continue
+
+            self._server_configs.delete_server_afk_channel_config(
+                ServerAFKChannelIdsConfig(channel_id, new_config.server.id)
+            )
+
+        for channel_id in new_config.afk_channel_ids:
+            if channel_id in old_config.afk_channel_ids:
+                continue
+
+            self._server_configs.add_server_afk_channel_config(
+                ServerAFKChannelIdsConfig(channel_id, new_config.server.id)
+            )
+
+    def _update_team_role_ids(self, new_config: ServerConfig):
+        old_config = self._server_configs.get_server_config_by_server(
+            new_config.server.id
+        )
+        for role_id in old_config.team_role_ids:
+            if role_id.role_id in new_config.team_role_ids.select(
+                lambda x: int(x.role_id)
+            ):
+                continue
+
+            self._server_configs.delete_server_team_role_id_config(role_id)
+
+        for role_id in new_config.team_role_ids:
+            guild = self._bot.get_guild(new_config.server.discord_id)
+            role = guild.get_role(int(role_id.role_id))
+            if role is None:
+                raise ValueError(f"Invalid roleId")
+
+        for role_id in new_config.team_role_ids:
+            if role_id.role_id in old_config.team_role_ids.select(
+                lambda x: str(x.role_id)
+            ):
+                continue
+
+            self._server_configs.add_server_team_role_id_config(role_id)

bot/src/bot_graphql/mutations/short_role_name_mutation.py

@@ -0,0 +1,95 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+from bot_data.abc.short_role_name_repository_abc import ShortRoleNameRepositoryABC
+from bot_data.model.short_role_name import ShortRoleName
+from bot_data.model.user_role_enum import UserRoleEnum
+from bot_graphql.abc.query_abc import QueryABC
+from modules.permission.service.permission_service import PermissionService
+
+
+class ShortRoleNameMutation(QueryABC):
+    def __init__(
+        self,
+        servers: ServerRepositoryABC,
+        short_role_names: ShortRoleNameRepositoryABC,
+        bot: DiscordBotServiceABC,
+        db: DatabaseContextABC,
+        permissions: PermissionService,
+    ):
+        QueryABC.__init__(self, "ShortRoleNameMutation")
+
+        self._servers = servers
+        self._short_role_names = short_role_names
+        self._bot = bot
+        self._db = db
+        self._permissions = permissions
+
+        self.set_field("createShortRoleName", self.resolve_create_short_role_name)
+        self.set_field("updateShortRoleName", self.resolve_update_short_role_name)
+        self.set_field("deleteShortRoleName", self.resolve_delete_short_role_name)
+
+    def resolve_create_short_role_name(self, *_, input: dict):
+        server = self._servers.get_server_by_id(input["serverId"])
+        self._can_user_mutate_data(server, UserRoleEnum.admin)
+
+        short_role_name = ShortRoleName(
+            input["shortName"],
+            int(input["roleId"]),
+            input["position"],
+            server,
+        )
+
+        result = self._short_role_names.find_short_role_names_by_role_id(
+            short_role_name.role_id
+        )
+        if result.count() > 0:
+            raise ValueError("Short name for role already exists")
+
+        self._short_role_names.add_short_role_name(short_role_name)
+        self._db.save_changes()
+
+        def get_new_short_role_name(srn: ShortRoleName):
+            return (
+                srn.short_name == short_role_name.short_name
+                and srn.role_id == short_role_name.role_id
+                and srn.position.value == short_role_name.position
+            )
+
+        return (
+            self._short_role_names.get_short_role_names_by_server_id(
+                short_role_name.server.id
+            )
+            .where(get_new_short_role_name)
+            .last()
+        )
+
+    def resolve_update_short_role_name(self, *_, input: dict):
+        short_role_name = self._short_role_names.get_short_role_name_by_id(input["id"])
+        self._can_user_mutate_data(short_role_name.server, UserRoleEnum.moderator)
+
+        short_role_name.short_name = (
+            input["shortName"] if "shortName" in input else short_role_name.short_name
+        )
+        short_role_name.role_id = (
+            input["roleId"] if "roleId" in input else short_role_name.role_id
+        )
+        short_role_name.position = (
+            input["position"] if "position" in input else short_role_name.position
+        )
+
+        self._short_role_names.update_short_role_name(short_role_name)
+        self._db.save_changes()
+
+        short_role_name = self._short_role_names.get_short_role_name_by_id(input["id"])
+        return short_role_name
+
+    def resolve_delete_short_role_name(self, *_, id: int):
+        short_role_name = self._short_role_names.get_short_role_name_by_id(id)
+        self._can_user_mutate_data(short_role_name.server, UserRoleEnum.admin)
+
+        self._short_role_names.delete_short_role_name(short_role_name)
+        self._db.save_changes()
+
+        return short_role_name

bot/src/bot_graphql/mutations/technician_config_mutation.py

@@ -0,0 +1,146 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_api.logging.api_logger import ApiLogger
+from bot_api.route.route import Route
+from bot_core.service.config_service import ConfigService
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+from bot_data.abc.technician_config_repository_abc import TechnicianConfigRepositoryABC
+from bot_data.model.technician_config import TechnicianConfig
+from bot_data.model.technician_id_config import TechnicianIdConfig
+from bot_data.model.technician_ping_url_config import TechnicianPingUrlConfig
+from bot_data.model.user_role_enum import UserRoleEnum
+from bot_data.service.technician_config_seeder import TechnicianConfigSeeder
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class TechnicianConfigMutation(QueryABC):
+    def __init__(
+        self,
+        logger: ApiLogger,
+        bot: DiscordBotServiceABC,
+        servers: ServerRepositoryABC,
+        technician_configs: TechnicianConfigRepositoryABC,
+        db: DatabaseContextABC,
+        config_service: ConfigService,
+        tech_seeder: TechnicianConfigSeeder,
+    ):
+        QueryABC.__init__(self, "TechnicianConfigMutation")
+
+        self._logger = logger
+        self._bot = bot
+        self._servers = servers
+        self._technician_configs = technician_configs
+        self._db = db
+        self._config_service = config_service
+        self._tech_seeder = tech_seeder
+
+        self.set_field("updateTechnicianConfig", self.resolve_update_technician_config)
+
+    def resolve_update_technician_config(self, *_, input: dict):
+        if not self._technician_configs.does_technician_config_exists():
+            self._bot.loop.create_task(self._tech_seeder.seed())
+
+        technician_config = self._technician_configs.get_technician_config()
+        self._can_user_mutate_data(
+            Route.get_user().users[0].server, UserRoleEnum.technician
+        )
+
+        technician_config.help_command_reference_url = (
+            input["helpCommandReferenceUrl"]
+            if "helpCommandReferenceUrl" in input
+            else technician_config.help_command_reference_url
+        )
+        technician_config.wait_for_restart = (
+            input["waitForRestart"]
+            if "waitForRestart" in input
+            else technician_config.wait_for_restart
+        )
+        technician_config.wait_for_shutdown = (
+            input["waitForShutdown"]
+            if "waitForShutdown" in input
+            else technician_config.wait_for_shutdown
+        )
+        technician_config.cache_max_messages = (
+            input["cacheMaxMessages"]
+            if "cacheMaxMessages" in input
+            else technician_config.cache_max_messages
+        )
+        old_feature_flags = technician_config.feature_flags
+        technician_config.feature_flags = (
+            dict(
+                zip(
+                    [x["key"] for x in input["featureFlags"]],
+                    [x["value"] for x in input["featureFlags"]],
+                )
+            )
+            if "featureFlags" in input
+            else technician_config.feature_flags
+        )
+        for old_flag in old_feature_flags:
+            if old_flag not in technician_config.feature_flags:
+                technician_config.feature_flags[old_flag] = False
+
+        technician_config.ping_urls = (
+            List(str, input["pingURLs"])
+            if "pingURLs" in input
+            else technician_config.ping_urls
+        )
+        technician_config.technician_ids = (
+            List(int).extend([int(x) for x in input["technicianIds"]])
+            if "technicianIds" in input
+            else technician_config.technician_ids
+        )
+
+        self._technician_configs.update_technician_config(technician_config)
+        if "pingURLs" in input:
+            self._update_ping_urls(technician_config)
+
+        if "technicianIds" in input:
+            self._update_technician_ids(technician_config)
+
+        self._db.save_changes()
+        self._config_service.reload_technician_config()
+        return technician_config
+
+    def _update_ping_urls(self, new_config: TechnicianConfig):
+        old_config = self._technician_configs.get_technician_config()
+        for url in old_config.ping_urls:
+            if url in new_config.ping_urls:
+                continue
+
+            self._technician_configs.delete_technician_ping_url_config(
+                TechnicianPingUrlConfig(url)
+            )
+
+        for url in new_config.ping_urls:
+            if url in old_config.ping_urls:
+                continue
+
+            self._technician_configs.add_technician_ping_url_config(
+                TechnicianPingUrlConfig(url)
+            )
+
+    def _update_technician_ids(self, new_config: TechnicianConfig):
+        old_config = self._technician_configs.get_technician_config()
+        for technician_id in old_config.technician_ids:
+            if technician_id in new_config.technician_ids:
+                continue
+
+            self._technician_configs.delete_technician_id_config(
+                TechnicianIdConfig(technician_id)
+            )
+
+        for technician_id in new_config.technician_ids:
+            user = self._bot.get_user(technician_id)
+            if user is None:
+                raise ValueError(f"Invalid technicianId")
+
+        for technician_id in new_config.technician_ids:
+            if technician_id in old_config.technician_ids:
+                continue
+
+            self._technician_configs.add_technician_id_config(
+                TechnicianIdConfig(technician_id)
+            )

bot/src/bot_graphql/mutations/user_joined_game_server_mutation.py

@@ -0,0 +1,156 @@
+import hashlib
+from datetime import datetime
+from typing import Optional
+
+from cpl_core.configuration import ConfigurationABC
+from cpl_core.database.context import DatabaseContextABC
+from cpl_core.logging import LoggerABC
+from cpl_discord.service import DiscordBotServiceABC
+from flask import request
+
+from bot_api.configuration.authentication_settings import AuthenticationSettings
+from bot_core.configuration.feature_flags_enum import FeatureFlagsEnum
+from bot_core.configuration.feature_flags_settings import FeatureFlagsSettings
+from bot_data.abc.api_key_repository_abc import ApiKeyRepositoryABC
+from bot_data.abc.game_server_repository_abc import GameServerRepositoryABC
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+from bot_data.abc.user_game_ident_repository_abc import UserGameIdentRepositoryABC
+from bot_data.abc.user_joined_game_server_repository_abc import (
+    UserJoinedGameServerRepositoryABC,
+)
+from bot_data.abc.user_repository_abc import UserRepositoryABC
+from bot_data.model.api_key import ApiKey
+from bot_data.model.server_config import ServerConfig
+from bot_data.model.user_joined_game_server import UserJoinedGameServer
+from bot_data.model.user_role_enum import UserRoleEnum
+from bot_graphql.abc.query_abc import QueryABC
+from modules.permission.service.permission_service import PermissionService
+
+
+class UserJoinedGameServerMutation(QueryABC):
+    def __init__(
+        self,
+        config: ConfigurationABC,
+        logger: LoggerABC,
+        servers: ServerRepositoryABC,
+        users: UserRepositoryABC,
+        user_joined_game_servers: UserJoinedGameServerRepositoryABC,
+        api_keys: ApiKeyRepositoryABC,
+        game_servers: GameServerRepositoryABC,
+        user_game_idents: UserGameIdentRepositoryABC,
+        bot: DiscordBotServiceABC,
+        db: DatabaseContextABC,
+        permissions: PermissionService,
+        auth_settings: AuthenticationSettings,
+    ):
+        QueryABC.__init__(self, "UserJoinedGameServerMutation")
+
+        self._config = config
+        self._logger = logger
+        self._servers = servers
+        self._users = users
+        self._user_joined_game_servers = user_joined_game_servers
+        self._api_keys = api_keys
+        self._game_servers = game_servers
+        self._user_game_idents = user_game_idents
+        self._bot = bot
+        self._db = db
+        self._permissions = permissions
+        self._auth_settings = auth_settings
+
+        self.set_field("userJoined", self.resolve_user_joined)
+        self.set_field("userLeft", self.resolve_user_left)
+
+    def _get_api_key_str(self, api_key: ApiKey) -> str:
+        return hashlib.sha256(
+            f"{api_key.identifier}:{api_key.key}+{self._auth_settings.secret_key}".encode(
+                "utf-8"
+            )
+        ).hexdigest()
+
+    def _get_api_key(self) -> Optional[ApiKey]:
+        authorization = request.headers.get("Authorization").split()
+        if len(authorization) != 2:
+            return None
+
+        api_key_str = authorization[1]
+        return (
+            self._api_keys.get_api_keys()
+            .where(lambda key: self._get_api_key_str(key) == api_key_str)
+            .first_or_default()
+        )
+
+    def resolve_user_joined(self, *_, input: dict):
+        game_ident = self._user_game_idents.get_user_game_ident_by_ident(input["ident"])
+        user = game_ident.user
+
+        settings: ServerConfig = self._config.get_configuration(
+            f"ServerConfig_{user.server.discord_id}"
+        )
+        if not FeatureFlagsSettings.get_flag_from_dict(
+            settings.feature_flags, FeatureFlagsEnum.game_server
+        ):
+            raise Exception("Feature not activated")
+
+        self._can_user_mutate_data(user.server, UserRoleEnum.admin)
+
+        active = self._user_joined_game_servers.find_active_user_joined_game_server_by_user_id(
+            user.id
+        )
+        if active is not None:
+            self._logger.debug(
+                __name__,
+                f"Skip UserJoinedGameServer for user {user.id}. User already plays on {active.game_server}.",
+            )
+            return
+
+        new = UserJoinedGameServer(user, game_ident.game_server, datetime.now())
+        self._user_joined_game_servers.add_user_joined_game_server(new)
+        self._db.save_changes()
+
+        return self._user_joined_game_servers.get_active_user_joined_game_server_by_user_id(
+            user.id
+        )
+
+    def resolve_user_left(self, *_, input: dict):
+        game_ident = self._user_game_idents.find_user_game_ident_by_ident(
+            input["ident"]
+        )
+        if game_ident is None:
+            return
+        user = game_ident.user
+
+        settings: ServerConfig = self._config.get_configuration(
+            f"ServerConfig_{user.server.discord_id}"
+        )
+        if not FeatureFlagsSettings.get_flag_from_dict(
+            settings.feature_flags, FeatureFlagsEnum.game_server
+        ):
+            raise Exception("Feature not activated")
+
+        self._can_user_mutate_data(user.server, UserRoleEnum.admin)
+
+        active = self._user_joined_game_servers.find_active_user_joined_game_server_by_user_id(
+            user.id
+        )
+        if active is None:
+            return
+        active.leaved_on = datetime.now()
+
+        settings: ServerConfig = self._config.get_configuration(
+            f"ServerConfig_{user.server.discord_id}"
+        )
+
+        ontime = round((active.leaved_on - active.joined_on).total_seconds() / 3600, 2)
+        old_xp = user.xp
+        user.xp += round(ontime * settings.xp_per_ontime_hour)
+
+        self._user_joined_game_servers.update_user_joined_game_server(active)
+        self._users.update_user(user)
+        self._db.save_changes()
+        self._logger.debug(
+            __name__,
+            f"User {user} leaved_on {active.leaved_on}. Ontime: {ontime}h | xp: from {old_xp} to {user.xp}",
+        )
+
+        return active

bot/src/bot_graphql/mutations/user_mutation.py

@@ -0,0 +1,110 @@
+from datetime import datetime
+
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_api.route.route import Route
+from bot_data.abc.level_repository_abc import LevelRepositoryABC
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+from bot_data.abc.user_repository_abc import UserRepositoryABC
+from bot_data.abc.user_warnings_repository_abc import UserWarningsRepositoryABC
+from bot_data.model.user import User
+from bot_data.model.user_role_enum import UserRoleEnum
+from bot_graphql.abc.query_abc import QueryABC
+from modules.base.service.user_warnings_service import UserWarningsService
+from modules.level.service.level_service import LevelService
+from modules.permission.service.permission_service import PermissionService
+
+
+class UserMutation(QueryABC):
+    def __init__(
+        self,
+        servers: ServerRepositoryABC,
+        users: UserRepositoryABC,
+        bot: DiscordBotServiceABC,
+        db: DatabaseContextABC,
+        permissions: PermissionService,
+        levels: LevelRepositoryABC,
+        level_service: LevelService,
+        user_warnings: UserWarningsRepositoryABC,
+        user_warning_service: UserWarningsService,
+    ):
+        QueryABC.__init__(self, "UserMutation")
+
+        self._servers = servers
+        self._users = users
+        self._bot = bot
+        self._db = db
+        self._permissions = permissions
+        self._levels = levels
+        self._level_service = level_service
+        self._user_warnings = user_warnings
+        self._user_warning_service = user_warning_service
+
+        self.set_field("updateUser", self.resolve_update_user)
+
+    def resolve_update_user(self, *_, input: dict):
+        user = self._users.get_user_by_id(input["id"])
+
+        auth_user = Route.get_user()
+        member = self._bot.get_guild(user.server.discord_id).get_member(
+            auth_user.users.where(lambda x: x.server.id == user.server.id)
+            .single()
+            .discord_id
+        )
+        if member.id != user.discord_id:
+            self._can_user_mutate_data(user.server, UserRoleEnum.moderator)
+
+            new_xp = None
+            if "levelId" in input:
+                level = self._levels.get_level_by_id(input["levelId"])
+                if user.level.id != level.id:
+                    new_xp = level.min_xp
+
+            if "userWarnings" in input:
+                self._update_user_warning(user, input["userWarnings"])
+
+            user.xp = (
+                new_xp
+                if new_xp is not None
+                else input["xp"]
+                if "xp" in input
+                else user.xp
+            )
+
+        user.birthday = (
+            datetime.strptime(input["birthday"], "%d.%m.%Y")
+            if "birthday" in input
+            else user.birthday
+        )
+
+        self._users.update_user(user)
+        self._db.save_changes()
+        self._bot.loop.create_task(self._level_service.set_level(user))
+
+        user = self._users.get_user_by_id(input["id"])
+        return user
+
+    def _update_user_warning(self, user: User, new_warnings: dict):
+        old_warnings = self._user_warnings.get_user_warnings_by_user_id(user.id)
+        for warning in old_warnings:
+            if warning.id in [
+                int(x["id"]) if "id" in x else None for x in new_warnings
+            ]:
+                continue
+
+            self._user_warning_service.remove_warnings(warning.id)
+
+        for warning in new_warnings:
+            if "id" in warning and int(warning["id"]) in old_warnings.select(
+                lambda x: x.id
+            ):
+                continue
+
+            member = self._bot.get_guild(user.server.discord_id).get_member(
+                user.discord_id
+            )
+            author = self._users.get_user_by_id(int(warning["author"]))
+            self._user_warning_service.add_warnings(
+                member, warning["description"], author.discord_id
+            )

bot/src/bot_graphql/queries/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+bot sh-edraft.de Discord bot
+~~~~~~~~~~~~~~~~~~~
+
+Discord bot for customers of sh-edraft.de
+
+:copyright: (c) 2022 - 2023 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = "bot_graphql.queries"
+__author__ = "Sven Heidemann"
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2022 - 2023 sh-edraft.de"
+__version__ = "1.2.0"
+
+from collections import namedtuple
+
+
+# imports:
+
+VersionInfo = namedtuple("VersionInfo", "major minor micro")
+version_info = VersionInfo(major="1", minor="2", micro="0")

bot/src/bot_graphql/queries/achievement_attribute_query.py

@@ -0,0 +1,11 @@
+from bot_graphql.abc.data_query_abc import DataQueryABC
+
+
+class AchievementAttributeQuery(DataQueryABC):
+    def __init__(
+        self,
+    ):
+        DataQueryABC.__init__(self, "AchievementAttribute")
+
+        self.set_field("name", lambda x, *_: x.name)
+        self.set_field("type", lambda x, *_: x.type)

bot/src/bot_graphql/queries/achievement_history_query.py

@@ -0,0 +1,14 @@
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class AchievementHistoryQuery(HistoryQueryABC):
+    def __init__(self):
+        HistoryQueryABC.__init__(self, "Achievement")
+
+        self.set_field("id", lambda x, *_: x.id)
+        self.set_field("name", lambda x, *_: x.name)
+        self.set_field("description", lambda x, *_: x.description)
+        self.set_field("attribute", lambda x, *_: x.attribute)
+        self.set_field("operator", lambda x, *_: x.operator)
+        self.set_field("value", lambda x, *_: x.value)
+        self.set_field("server", lambda x, *_: x.server)

bot/src/bot_graphql/queries/achievement_query.py

@@ -0,0 +1,22 @@
+from cpl_core.database.context import DatabaseContextABC
+
+from bot_data.model.achievement_history import AchievementHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class AchievementQuery(DataQueryWithHistoryABC):
+    def __init__(
+        self,
+        db: DatabaseContextABC,
+    ):
+        DataQueryWithHistoryABC.__init__(
+            self, "Achievement", "AchievementsHistory", AchievementHistory, db
+        )
+
+        self.set_field("id", lambda x, *_: x.id)
+        self.set_field("name", lambda x, *_: x.name)
+        self.set_field("description", lambda x, *_: x.description)
+        self.set_field("attribute", lambda x, *_: x.attribute)
+        self.set_field("operator", lambda x, *_: x.operator)
+        self.set_field("value", lambda x, *_: x.value)
+        self.set_field("server", lambda x, *_: x.server)

bot/src/bot_graphql/queries/auto_role_history_query.py

@@ -0,0 +1,40 @@
+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
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class AutoRoleHistoryQuery(HistoryQueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+        auto_role_rules: AutoRoleRepositoryABC,
+        servers: ServerRepositoryABC,
+    ):
+        HistoryQueryABC.__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("channelId", self.resolve_channel_id)
+        self.set_field("messageId", self.resolve_message_id)
+        self.set_field("server", self.resolve_server)
+
+    @staticmethod
+    def resolve_id(x: AutoRole, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_channel_id(x: AutoRole, *_):
+        return x.discord_channel_id
+
+    @staticmethod
+    def resolve_message_id(x: AutoRole, *_):
+        return x.discord_message_id
+
+    def resolve_server(self, x: AutoRole, *_):
+        return x.server

bot/src/bot_graphql/queries/auto_role_query.py

@@ -0,0 +1,62 @@
+from cpl_core.database.context import DatabaseContextABC
+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
+from bot_data.model.auto_role_history import AutoRoleHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+from bot_graphql.filter.auto_role_filter import AutoRoleFilter
+from bot_graphql.filter.server_filter import ServerFilter
+
+
+class AutoRoleQuery(DataQueryWithHistoryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+        auto_role_rules: AutoRoleRepositoryABC,
+        servers: ServerRepositoryABC,
+        db: DatabaseContextABC,
+    ):
+        DataQueryWithHistoryABC.__init__(
+            self, "AutoRole", "AutoRolesHistory", AutoRoleHistory, db
+        )
+
+        self._bot = bot
+        self._auto_role_rules = auto_role_rules
+        self._servers = servers
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("channelId", self.resolve_channel_id)
+        self.set_field("channelName", self.resolve_channel_name)
+        self.set_field("messageId", self.resolve_message_id)
+        self.set_field("server", self.resolve_server)
+        self.add_collection(
+            "autoRoleRule",
+            lambda x, *_: self._auto_role_rules.get_auto_role_rules_by_auto_role_id(
+                x.id
+            ),
+            AutoRoleFilter,
+        )
+
+    @staticmethod
+    def resolve_id(x: AutoRole, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_channel_id(x: AutoRole, *_):
+        return x.discord_channel_id
+
+    @staticmethod
+    def resolve_channel_name(x: AutoRole, *_):
+        return x.discord_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.id))
+
+        return self._servers.get_server_by_id(x.server.id)

bot/src/bot_graphql/queries/auto_role_rule_history_query.py

@@ -0,0 +1,37 @@
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.abc.auto_role_repository_abc import AutoRoleRepositoryABC
+from bot_data.model.auto_role_rule import AutoRoleRule
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class AutoRoleRuleHistoryQuery(HistoryQueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+        auto_roles: AutoRoleRepositoryABC,
+    ):
+        HistoryQueryABC.__init__(self, "AutoRoleRule")
+
+        self._bot = bot
+        self._auto_roles = auto_roles
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("emojiName", self.resolve_emoji_name)
+        self.set_field("roleId", self.resolve_role_id)
+        self.set_field("autoRole", self.resolve_auto_role)
+
+    @staticmethod
+    def resolve_id(x: AutoRoleRule, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_emoji_name(x: AutoRoleRule, *_):
+        return x.emoji_name
+
+    @staticmethod
+    def resolve_role_id(x: AutoRoleRule, *_):
+        return x.role_id
+
+    def resolve_auto_role(self, x: AutoRoleRule, *_):
+        return x.auto_role

bot/src/bot_graphql/queries/auto_role_rule_query.py

@@ -0,0 +1,47 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.abc.auto_role_repository_abc import AutoRoleRepositoryABC
+from bot_data.model.auto_role_rule import AutoRoleRule
+from bot_data.model.auto_role_rule_history import AutoRoleRuleHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class AutoRoleRuleQuery(DataQueryWithHistoryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+        auto_roles: AutoRoleRepositoryABC,
+        db: DatabaseContextABC,
+    ):
+        DataQueryWithHistoryABC.__init__(
+            self, "AutoRoleRule", "AutoRoleRulesHistory", AutoRoleRuleHistory, db
+        )
+
+        self._bot = bot
+        self._auto_roles = auto_roles
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("emojiName", self.resolve_emoji_name)
+        self.set_field("roleId", self.resolve_role_id)
+        self.set_field("roleName", self.resolve_role_name)
+        self.set_field("autoRole", self.resolve_auto_role)
+
+    @staticmethod
+    def resolve_id(x: AutoRoleRule, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_emoji_name(x: AutoRoleRule, *_):
+        return x.emoji_name
+
+    @staticmethod
+    def resolve_role_id(x: AutoRoleRule, *_):
+        return x.role_id
+
+    @staticmethod
+    def resolve_role_name(x: AutoRoleRule, *_):
+        return x.role_name
+
+    def resolve_auto_role(self, x: AutoRoleRule, *_):
+        return self._auto_roles.get_auto_role_by_id(x.auto_role.id)

bot/src/bot_graphql/queries/client_history_query.py

@@ -0,0 +1,60 @@
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.model.client import Client
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class ClientHistoryQuery(HistoryQueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+    ):
+        HistoryQueryABC.__init__(self, "Client")
+
+        self._bot = bot
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discordId", self.resolve_discord_id)
+        self.set_field("name", self.resolve_name)
+        self.set_field("sentMessageCount", self.resolve_sent_message_count)
+        self.set_field("receivedMessageCount", self.resolve_received_message_count)
+        self.set_field("deletedMessageCount", self.resolve_deleted_message_count)
+        self.set_field("receivedCommandCount", self.resolve_received_command_count)
+        self.set_field("movedUsersCount", self.resolve_moved_users_count)
+        self.set_field("server", self.resolve_server)
+
+    @staticmethod
+    def resolve_id(client: Client, *_):
+        return client.id
+
+    @staticmethod
+    def resolve_discord_id(client: Client, *_):
+        return client.discord_id
+
+    @staticmethod
+    def resolve_name(client: Client, *_):
+        return client.name
+
+    @staticmethod
+    def resolve_sent_message_count(client: Client, *_):
+        return client.sent_message_count
+
+    @staticmethod
+    def resolve_received_message_count(client: Client, *_):
+        return client.received_command_count
+
+    @staticmethod
+    def resolve_deleted_message_count(client: Client, *_):
+        return client.deleted_message_count
+
+    @staticmethod
+    def resolve_received_command_count(client: Client, *_):
+        return client.received_command_count
+
+    @staticmethod
+    def resolve_moved_users_count(client: Client, *_):
+        return client.moved_users_count
+
+    @staticmethod
+    def resolve_server(client: Client, *_):
+        return client.server

bot/src/bot_graphql/queries/client_query.py

@@ -0,0 +1,61 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.model.client import Client
+from bot_data.model.client_history import ClientHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class ClientQuery(DataQueryWithHistoryABC):
+    def __init__(self, bot: DiscordBotServiceABC, db: DatabaseContextABC):
+        DataQueryWithHistoryABC.__init__(
+            self, "Client", "ClientsHistory", ClientHistory, db
+        )
+
+        self._bot = bot
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discordId", self.resolve_discord_id)
+        self.set_field("name", self.resolve_name)
+        self.set_field("sentMessageCount", self.resolve_sent_message_count)
+        self.set_field("receivedMessageCount", self.resolve_received_message_count)
+        self.set_field("deletedMessageCount", self.resolve_deleted_message_count)
+        self.set_field("receivedCommandCount", self.resolve_received_command_count)
+        self.set_field("movedUsersCount", self.resolve_moved_users_count)
+        self.set_field("server", self.resolve_server)
+
+    @staticmethod
+    def resolve_id(client: Client, *_):
+        return client.id
+
+    @staticmethod
+    def resolve_discord_id(client: Client, *_):
+        return client.discord_id
+
+    @staticmethod
+    def resolve_name(client: Client, *_):
+        return client.name
+
+    @staticmethod
+    def resolve_sent_message_count(client: Client, *_):
+        return client.sent_message_count
+
+    @staticmethod
+    def resolve_received_message_count(client: Client, *_):
+        return client.received_message_count
+
+    @staticmethod
+    def resolve_deleted_message_count(client: Client, *_):
+        return client.deleted_message_count
+
+    @staticmethod
+    def resolve_received_command_count(client: Client, *_):
+        return client.received_command_count
+
+    @staticmethod
+    def resolve_moved_users_count(client: Client, *_):
+        return client.moved_users_count
+
+    @staticmethod
+    def resolve_server(client: Client, *_):
+        return client.server

bot/src/bot_graphql/queries/discord/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+bot sh-edraft.de Discord bot
+~~~~~~~~~~~~~~~~~~~
+
+Discord bot for customers of sh-edraft.de
+
+:copyright: (c) 2022 - 2023 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = "bot_graphql.queries.discord"
+__author__ = "Sven Heidemann"
+__license__ = "MIT"
+__copyright__ = "Copyright (c) 2022 - 2023 sh-edraft.de"
+__version__ = "1.2.0"
+
+from collections import namedtuple
+
+
+# imports:
+
+VersionInfo = namedtuple("VersionInfo", "major minor micro")
+version_info = VersionInfo(major="1", minor="2", micro="0")

bot/src/bot_graphql/queries/discord/channel_query.py

@@ -0,0 +1,10 @@
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class ChannelQuery(QueryABC):
+    def __init__(self):
+        QueryABC.__init__(self, "Channel")
+
+        self.set_field("id", lambda c, *_: c.id)
+        self.set_field("name", lambda c, *_: c.name)
+        self.set_field("type", lambda c, *_: type(c).__name__)

bot/src/bot_graphql/queries/discord/discord_query.py

@@ -0,0 +1,48 @@
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class DiscordQuery(QueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+    ):
+        QueryABC.__init__(self, "Discord")
+
+        self._bot = bot
+
+        self.set_field("guilds", self._resolve_guilds)
+        self.set_field("users", self._resolve_users)
+
+    def _resolve_guilds(self, *_, filter=None):
+        guilds = self._bot.guilds
+
+        if filter is None:
+            return guilds
+
+        if "id" in filter:
+            guilds = self._bot.guilds.where(lambda g: g.id == int(filter["id"]))
+
+        if "name" in filter:
+            guilds = self._bot.guilds.where(lambda g: g.name == filter["name"])
+
+        return guilds
+
+    def _resolve_users(self, *_, filter=None):
+        users = List(any).extend(self._bot.users)
+
+        if filter is None:
+            return users
+
+        if "id" in filter:
+            users = users.where(lambda g: g.id == int(filter["id"]))
+
+        if "name" in filter:
+            users = users.where(lambda g: g.name == filter["name"])
+
+        if "bot" in filter:
+            users = users.where(lambda g: g.bot == bool(filter["bot"]))
+
+        return users

bot/src/bot_graphql/queries/discord/discord_user_query.py

@@ -0,0 +1,10 @@
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class DiscordUserQuery(QueryABC):
+    def __init__(self):
+        QueryABC.__init__(self, "DiscordUser")
+
+        self.set_field("id", lambda r, *_: r.id)
+        self.set_field("name", lambda r, *_: r.name)
+        self.set_field("bot", lambda r, *_: r.bot)

bot/src/bot_graphql/queries/discord/emoji_query.py

@@ -0,0 +1,10 @@
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class EmojiQuery(QueryABC):
+    def __init__(self):
+        QueryABC.__init__(self, "Emoji")
+
+        self.set_field("id", lambda e, *_: e.id)
+        self.set_field("name", lambda e, *_: e.name)
+        self.set_field("url", lambda e, *_: e.url)

bot/src/bot_graphql/queries/discord/guild_query.py

@@ -0,0 +1,44 @@
+import discord
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+from discord import Guild
+
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class GuildQuery(QueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+    ):
+        QueryABC.__init__(self, "Guild")
+
+        self._bot = bot
+
+        self.set_field("id", lambda g, *_: g.id)
+        self.set_field("name", lambda g, *_: g.name)
+        self.set_field("channels", self._resolve_channels)
+        self.set_field("roles", lambda g, *_: g.roles.order_by(lambda x: x.position))
+        self.set_field(
+            "emojis",
+            lambda g, *_: List(discord.Emoji, g.emojis).order_by_descending(
+                lambda x: x.created_at
+            ),
+        )
+
+    def _resolve_channels(self, g: Guild, *_, filter=None):
+        channels = List(any).extend(g.channels)
+
+        if filter is None:
+            return channels
+
+        if "id" in filter:
+            channels = channels.where(lambda c: c.id == int(filter["id"]))
+
+        if "name" in filter:
+            channels = channels.where(lambda c: c.id == filter["name"])
+
+        if "type" in filter:
+            channels = channels.where(lambda c: type(c).__name__ == filter["type"])
+
+        return channels.order_by(lambda x: x.position)

bot/src/bot_graphql/queries/discord/role_query.py

@@ -0,0 +1,9 @@
+from bot_graphql.abc.query_abc import QueryABC
+
+
+class RoleQuery(QueryABC):
+    def __init__(self):
+        QueryABC.__init__(self, "Role")
+
+        self.set_field("id", lambda r, *_: r.id)
+        self.set_field("name", lambda r, *_: r.name)

bot/src/bot_graphql/queries/game_server_query.py

@@ -0,0 +1,10 @@
+from bot_graphql.abc.data_query_abc import DataQueryABC
+
+
+class GameServerQuery(DataQueryABC):
+    def __init__(self):
+        DataQueryABC.__init__(self, "GameServer")
+
+        self.set_field("id", lambda x, *_: x.id)
+        self.set_field("name", lambda x, *_: x.name)
+        self.set_field("server", lambda x, *_: x.server)

bot/src/bot_graphql/queries/known_user_history_query.py

@@ -0,0 +1,18 @@
+from bot_data.model.known_user import KnownUser
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class KnownUserHistoryQuery(HistoryQueryABC):
+    def __init__(self):
+        HistoryQueryABC.__init__(self, "KnownUser")
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discordId", self.resolve_discord_id)
+
+    @staticmethod
+    def resolve_id(x: KnownUser, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_discord_id(x: KnownUser, *_):
+        return x.discord_id

bot/src/bot_graphql/queries/known_user_query.py

@@ -0,0 +1,23 @@
+from cpl_core.database.context import DatabaseContextABC
+
+from bot_data.model.known_user import KnownUser
+from bot_data.model.known_user_history import KnownUserHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class KnownUserQuery(DataQueryWithHistoryABC):
+    def __init__(self, db: DatabaseContextABC):
+        DataQueryWithHistoryABC.__init__(
+            self, "KnownUser", "KnownUsersHistory", KnownUserHistory, db
+        )
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discordId", self.resolve_discord_id)
+
+    @staticmethod
+    def resolve_id(x: KnownUser, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_discord_id(x: KnownUser, *_):
+        return x.discord_id

bot/src/bot_graphql/queries/level_history_query.py

@@ -0,0 +1,38 @@
+from bot_data.model.level import Level
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class LevelHistoryQuery(HistoryQueryABC):
+    def __init__(self):
+        HistoryQueryABC.__init__(self, "Level")
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("name", self.resolve_name)
+        self.set_field("color", self.resolve_color)
+        self.set_field("minXp", self.resolve_min_xp)
+        self.set_field("permissions", self.resolve_permissions)
+        self.set_field("server", self.resolve_server)
+
+    @staticmethod
+    def resolve_id(level: Level, *_):
+        return level.id
+
+    @staticmethod
+    def resolve_name(level: Level, *_):
+        return level.name
+
+    @staticmethod
+    def resolve_color(level: Level, *_):
+        return level.color
+
+    @staticmethod
+    def resolve_min_xp(level: Level, *_):
+        return level.min_xp
+
+    @staticmethod
+    def resolve_permissions(level: Level, *_):
+        return level.permissions
+
+    @staticmethod
+    def resolve_server(level: Level, *_):
+        return level.server

bot/src/bot_graphql/queries/level_query.py

@@ -0,0 +1,43 @@
+from cpl_core.database.context import DatabaseContextABC
+
+from bot_data.model.level import Level
+from bot_data.model.level_history import LevelHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class LevelQuery(DataQueryWithHistoryABC):
+    def __init__(self, db: DatabaseContextABC):
+        DataQueryWithHistoryABC.__init__(
+            self, "Level", "LevelsHistory", LevelHistory, db
+        )
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("name", self.resolve_name)
+        self.set_field("color", self.resolve_color)
+        self.set_field("minXp", self.resolve_min_xp)
+        self.set_field("permissions", self.resolve_permissions)
+        self.set_field("server", self.resolve_server)
+
+    @staticmethod
+    def resolve_id(level: Level, *_):
+        return level.id
+
+    @staticmethod
+    def resolve_name(level: Level, *_):
+        return level.name
+
+    @staticmethod
+    def resolve_color(level: Level, *_):
+        return level.color
+
+    @staticmethod
+    def resolve_min_xp(level: Level, *_):
+        return level.min_xp
+
+    @staticmethod
+    def resolve_permissions(level: Level, *_):
+        return level.permissions
+
+    @staticmethod
+    def resolve_server(level: Level, *_):
+        return level.server

bot/src/bot_graphql/queries/server_config_query.py

@@ -0,0 +1,79 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_query.extension import List
+
+from bot_data.model.server_config_history import ServerConfigHistory
+from bot_data.model.team_member_type_enum import TeamMemberTypeEnum
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class ServerConfigQuery(DataQueryWithHistoryABC):
+    def __init__(self, db: DatabaseContextABC):
+        DataQueryWithHistoryABC.__init__(
+            self, "ServerConfig", "CFG_ServerHistory", ServerConfigHistory, db
+        )
+
+        self.set_field("id", lambda config, *_: config.id)
+        self.set_field(
+            "messageDeleteTimer", lambda config, *_: config.message_delete_timer
+        )
+        self.set_field(
+            "notificationChatId", lambda config, *_: config.notification_chat_id
+        )
+        self.set_field(
+            "maxVoiceStateHours", lambda config, *_: config.max_voice_state_hours
+        )
+        self.set_field("xpPerMessage", lambda config, *_: config.xp_per_message)
+        self.set_field("xpPerReaction", lambda config, *_: config.xp_per_reaction)
+        self.set_field(
+            "maxMessageXpPerHour", lambda config, *_: config.max_message_xp_per_hour
+        )
+        self.set_field("xpPerOntimeHour", lambda config, *_: config.xp_per_ontime_hour)
+        self.set_field(
+            "xpPerEventParticipation",
+            lambda config, *_: config.xp_per_event_participation,
+        )
+        self.set_field("xpPerAchievement", lambda config, *_: config.xp_per_achievement)
+        self.set_field("xpForBirthday", lambda config, *_: config.xp_for_birthday)
+        self.set_field(
+            "afkCommandChannelId", lambda config, *_: config.afk_command_channel_id
+        )
+        self.set_field(
+            "helpVoiceChannelId", lambda config, *_: config.help_voice_channel_id
+        )
+        self.set_field("teamChannelId", lambda config, *_: config.team_channel_id)
+        self.set_field(
+            "loginMessageChannelId", lambda config, *_: config.login_message_channel_id
+        )
+        self.set_field("defaultRoleId", lambda config, *_: config.default_role_id)
+        self.set_field(
+            "shortRoleNameOnlySetHighestRole",
+            lambda config, *_: config.short_role_name_only_set_highest_role,
+        )
+        self.set_field(
+            "gameOfferNotificationChatId",
+            lambda config, *_: config.game_offer_notification_chat_id,
+        )
+        self.add_collection(
+            "featureFlag",
+            lambda config, *_: List(
+                any,
+                [
+                    {"key": x, "value": config.feature_flags[x]}
+                    for x in config.feature_flags
+                ],
+            ),
+        )
+        self.set_field("afkChannelIds", lambda config, *_: config.afk_channel_ids)
+        self.set_field(
+            "moderatorRoleIds",
+            lambda config, *_: config.team_role_ids.where(
+                lambda x: x.team_member_type == TeamMemberTypeEnum.moderator
+            ).select(lambda x: x.role_id),
+        )
+        self.set_field(
+            "adminRoleIds",
+            lambda config, *_: config.team_role_ids.where(
+                lambda x: x.team_member_type == TeamMemberTypeEnum.admin
+            ).select(lambda x: x.role_id),
+        )
+        self.set_field("server", lambda config, *_: config.server)

bot/src/bot_graphql/queries/server_history_query.py

@@ -0,0 +1,30 @@
+from bot_data.model.server import Server
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class ServerHistoryQuery(HistoryQueryABC):
+    def __init__(
+        self,
+    ):
+        HistoryQueryABC.__init__(self, "Server")
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discordId", self.resolve_discord_id)
+        self.set_field("name", self.resolve_name)
+        self.set_field("iconURL", self.resolve_icon_url)
+
+    @staticmethod
+    def resolve_id(server: Server, *_):
+        return server.id
+
+    @staticmethod
+    def resolve_discord_id(server: Server, *_):
+        return server.discord_id
+
+    @staticmethod
+    def resolve_name(server: Server, *_):
+        return server.name
+
+    @staticmethod
+    def resolve_icon_url(server: Server, *_):
+        return server.icon_url

bot/src/bot_graphql/queries/server_query.py

@@ -0,0 +1,140 @@
+from cpl_core.configuration import ConfigurationABC
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_core.configuration.feature_flags_enum import FeatureFlagsEnum
+from bot_core.configuration.feature_flags_settings import FeatureFlagsSettings
+from bot_data.abc.achievement_repository_abc import AchievementRepositoryABC
+from bot_data.abc.auto_role_repository_abc import AutoRoleRepositoryABC
+from bot_data.abc.client_repository_abc import ClientRepositoryABC
+from bot_data.abc.game_server_repository_abc import GameServerRepositoryABC
+from bot_data.abc.level_repository_abc import LevelRepositoryABC
+from bot_data.abc.server_config_repository_abc import ServerConfigRepositoryABC
+from bot_data.abc.short_role_name_repository_abc import ShortRoleNameRepositoryABC
+from bot_data.abc.user_joined_server_repository_abc import UserJoinedServerRepositoryABC
+from bot_data.abc.user_joined_voice_channel_repository_abc import (
+    UserJoinedVoiceChannelRepositoryABC,
+)
+from bot_data.abc.user_repository_abc import UserRepositoryABC
+from bot_data.model.server import Server
+from bot_data.model.server_config import ServerConfig
+from bot_data.model.server_history import ServerHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+from bot_graphql.filter.achievement_filter import AchievementFilter
+from bot_graphql.filter.auto_role_filter import AutoRoleFilter
+from bot_graphql.filter.client_filter import ClientFilter
+from bot_graphql.filter.level_filter import LevelFilter
+from bot_graphql.filter.short_role_name_filter import ShortRoleNameFilter
+from bot_graphql.filter.user_filter import UserFilter
+
+
+class ServerQuery(DataQueryWithHistoryABC):
+    def __init__(
+        self,
+        config: ConfigurationABC,
+        bot: DiscordBotServiceABC,
+        db: DatabaseContextABC,
+        auto_roles: AutoRoleRepositoryABC,
+        clients: ClientRepositoryABC,
+        levels: LevelRepositoryABC,
+        game_servers: GameServerRepositoryABC,
+        users: UserRepositoryABC,
+        ujs: UserJoinedServerRepositoryABC,
+        ujvs: UserJoinedVoiceChannelRepositoryABC,
+        achievements: AchievementRepositoryABC,
+        short_role_names: ShortRoleNameRepositoryABC,
+        server_configs: ServerConfigRepositoryABC,
+    ):
+        DataQueryWithHistoryABC.__init__(
+            self, "Server", "ServersHistory", ServerHistory, db
+        )
+
+        self._config = config
+        self._bot = bot
+        self._auto_roles = auto_roles
+        self._clients = clients
+        self._levels = levels
+        self._users = users
+        self._ujs = ujs
+        self._ujvs = ujvs
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discordId", self.resolve_discord_id)
+        self.set_field("name", self.resolve_name)
+        self.set_field("iconURL", self.resolve_icon_url)
+
+        self.add_collection(
+            "autoRole",
+            lambda server, *_: self._auto_roles.get_auto_roles_by_server_id(server.id),
+            AutoRoleFilter,
+        )
+        self.add_collection(
+            "client",
+            lambda server, *_: self._clients.get_clients_by_server_id(server.id),
+            ClientFilter,
+        )
+        self.add_collection(
+            "level",
+            lambda server, *_: self._levels.get_levels_by_server_id(server.id),
+            LevelFilter,
+        )
+        self.add_collection(
+            "user",
+            lambda server, *_: self._users.get_users_by_server_id(server.id),
+            UserFilter,
+        )
+        self.add_collection(
+            "gameServer",
+            lambda server, *_: game_servers.get_game_servers_by_server_id(server.id),
+        )
+        self.add_collection(
+            "achievement",
+            lambda server, *_: achievements.get_achievements_by_server_id(server.id),
+            AchievementFilter,
+        )
+        self.add_collection(
+            "shortRoleName",
+            lambda server, *_: short_role_names.get_short_role_names_by_server_id(
+                server.id
+            ),
+            ShortRoleNameFilter,
+        )
+        self.set_field(
+            "config",
+            lambda server, *_: server_configs.get_server_config_by_server(server.id),
+        )
+        self.set_field(
+            "hasFeatureFlag",
+            lambda server, *_, **kwargs: self._resolve_has_feature_flag(
+                server, *_, **kwargs
+            ),
+        )
+
+    @staticmethod
+    def resolve_id(server: Server, *_):
+        return server.id
+
+    @staticmethod
+    def resolve_discord_id(server: Server, *_):
+        return server.discord_id
+
+    @staticmethod
+    def resolve_name(server: Server, *_):
+        return server.name
+
+    @staticmethod
+    def resolve_icon_url(server: Server, *_):
+        return server.icon_url
+
+    def _resolve_has_feature_flag(self, server: Server, *_, **kwargs):
+        settings: ServerConfig = self._config.get_configuration(
+            f"ServerConfig_{server.discord_id}"
+        )
+        if "flag" not in kwargs:
+            return False
+        return {
+            "key": kwargs["flag"],
+            "value": FeatureFlagsSettings.get_flag_from_dict(
+                settings.feature_flags, FeatureFlagsEnum(kwargs["flag"])
+            ),
+        }

bot/src/bot_graphql/queries/short_role_name_history_query.py

@@ -0,0 +1,11 @@
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class ShortRoleNameHistoryQuery(HistoryQueryABC):
+    def __init__(self):
+        HistoryQueryABC.__init__(self, "ShortRoleName")
+
+        self.set_field("id", lambda x, *_: x.id)
+        self.set_field("shortName", lambda x, *_: x.shortName)
+        self.set_field("roleId", lambda x, *_: x.roleId)
+        self.set_field("position", lambda x, *_: x.position.value)

bot/src/bot_graphql/queries/short_role_name_query.py

@@ -0,0 +1,20 @@
+from cpl_core.database.context import DatabaseContextABC
+
+from bot_data.model.short_role_name_history import ShortRoleNameHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class ShortRoleNameQuery(DataQueryWithHistoryABC):
+    def __init__(
+        self,
+        db: DatabaseContextABC,
+    ):
+        DataQueryWithHistoryABC.__init__(
+            self, "ShortRoleName", "ShortRoleNamesHistory", ShortRoleNameHistory, db
+        )
+
+        self.set_field("id", lambda x, *_: x.id)
+        self.set_field("shortName", lambda x, *_: x.short_name)
+        self.set_field("roleId", lambda x, *_: x.role_id)
+        self.set_field("roleName", lambda x, *_: x.role_name)
+        self.set_field("position", lambda x, *_: x.position.value)

bot/src/bot_graphql/queries/technician_config_history_query.py

@@ -0,0 +1,26 @@
+from cpl_query.extension import List
+
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class TechnicianConfigHistoryQuery(HistoryQueryABC):
+    def __init__(self):
+        HistoryQueryABC.__init__(self, "TechnicianConfig")
+
+        self.set_field(
+            "helpCommandReferenceUrl",
+            lambda config, *_: config.help_command_reference_url,
+        )
+        self.set_field("waitForRestart", lambda config, *_: config.wait_for_restart)
+        self.set_field("waitForShutdown", lambda config, *_: config.wait_for_shutdown)
+        self.set_field("cacheMaxMessages", lambda config, *_: config.cache_max_messages)
+        self.add_collection(
+            "featureFlag",
+            lambda config, *_: List(
+                any,
+                [
+                    {"key": x, "value": config.feature_flags[x]}
+                    for x in config.feature_flags
+                ],
+            ),
+        )

bot/src/bot_graphql/queries/technician_config_query.py

@@ -0,0 +1,78 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_query.extension import List
+
+from bot_data.abc.table_with_id_abc import TableWithIdABC
+from bot_data.model.technician_config_history import TechnicianConfigHistory
+from bot_data.model.technician_id_config_history import TechnicianIdConfigHistory
+from bot_data.model.technician_ping_url_config_history import (
+    TechnicianPingUrlConfigHistory,
+)
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class TechnicianConfigQuery(DataQueryWithHistoryABC):
+    def __init__(self, db: DatabaseContextABC):
+        DataQueryWithHistoryABC.__init__(
+            self,
+            "TechnicianConfig",
+            "CFG_TechnicianHistory",
+            TechnicianConfigHistory,
+            db,
+        )
+
+        self.set_field(
+            "helpCommandReferenceUrl",
+            lambda config, *_: config.help_command_reference_url,
+        )
+        self.set_field("waitForRestart", lambda config, *_: config.wait_for_restart)
+        self.set_field("waitForShutdown", lambda config, *_: config.wait_for_shutdown)
+        self.set_field("cacheMaxMessages", lambda config, *_: config.cache_max_messages)
+        self.add_collection(
+            "featureFlag",
+            lambda config, *_: List(
+                any,
+                [
+                    {"key": x, "value": config.feature_flags[x]}
+                    for x in config.feature_flags
+                ],
+            ),
+        )
+        self.set_field("pingURLs", lambda config, *_: config.ping_urls)
+        self.set_field("technicianIds", lambda config, *_: config.technician_ids)
+
+        self.set_field("pingURLHistory", self.resolve_ping_url_history)
+        self.set_field("technicianIdHistory", self.resolve_technician_id_history)
+
+    def resolve_ping_url_history(self, entry: TableWithIdABC, *_):
+        history = List(TechnicianPingUrlConfigHistory)
+
+        results = self._db.select(
+            f"""
+                SELECT *
+                FROM CFG_TechnicianPingUrlsHistory
+                WHERE Id = {entry.id}
+                ORDER BY DateTo DESC;
+            """
+        )
+
+        for result in results:
+            history.add(TechnicianPingUrlConfigHistory(*result[1:], result[0]))
+
+        return history
+
+    def resolve_technician_id_history(self, entry: TableWithIdABC, *_):
+        history = List(TechnicianIdConfigHistory)
+
+        results = self._db.select(
+            f"""
+                SELECT *
+                FROM CFG_TechnicianIdsHistory
+                WHERE Id = {entry.id}
+                ORDER BY DateTo DESC;
+            """
+        )
+
+        for result in results:
+            history.add(TechnicianIdConfigHistory(*result[1:], result[0]))
+
+        return history

bot/src/bot_graphql/queries/technician_id_config_history_query.py

@@ -0,0 +1,8 @@
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class TechnicianIdConfigHistoryQuery(HistoryQueryABC):
+    def __init__(self):
+        HistoryQueryABC.__init__(self, "TechnicianIdConfig")
+
+        self.set_field("technicianId", lambda config, *_: config.technicianId)

bot/src/bot_graphql/queries/technician_ping_url_config_history_query.py

@@ -0,0 +1,8 @@
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class TechnicianPingUrlConfigHistoryQuery(HistoryQueryABC):
+    def __init__(self):
+        HistoryQueryABC.__init__(self, "TechnicianPingUrlConfig")
+
+        self.set_field("url", lambda config, *_: config.ping_url)

bot/src/bot_graphql/queries/user_history_query.py

@@ -0,0 +1,28 @@
+from bot_data.model.user import User
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class UserHistoryQuery(HistoryQueryABC):
+    def __init__(self):
+        HistoryQueryABC.__init__(self, "User")
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discordId", self.resolve_discord_id)
+        self.set_field("xp", self.resolve_xp)
+        self.set_field("server", self.resolve_server)
+
+    @staticmethod
+    def resolve_id(user: User, *_):
+        return user.id
+
+    @staticmethod
+    def resolve_discord_id(user: User, *_):
+        return user.discord_id
+
+    @staticmethod
+    def resolve_xp(user: User, *_):
+        return user.xp
+
+    @staticmethod
+    def resolve_server(user: User, *_):
+        return user.server

bot/src/bot_graphql/queries/user_joined_game_server_history_query.py

@@ -0,0 +1,41 @@
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.model.user_joined_game_server import UserJoinedGameServer
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class UserJoinedGameServerHistoryQuery(HistoryQueryABC):
+    def __init__(self, bot: DiscordBotServiceABC):
+        HistoryQueryABC.__init__(self, "UserJoinedGameServer")
+
+        self._bot = bot
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("gameServer", self.resolve_game_server)
+        self.set_field("user", self.resolve_user)
+        self.set_field("joinedOn", self.resolve_joined_on)
+        self.set_field("leavedOn", self.resolve_leaved_on)
+
+    @staticmethod
+    def resolve_id(x: UserJoinedGameServer, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_game_server(x: UserJoinedGameServer, *_):
+        return x.game_server.name
+
+    @staticmethod
+    def resolve_user(x: UserJoinedGameServer, *_):
+        return x.user
+
+    @staticmethod
+    def resolve_time(x: UserJoinedGameServer, *_):
+        return x.time
+
+    @staticmethod
+    def resolve_joined_on(x: UserJoinedGameServer, *_):
+        return x.joined_on
+
+    @staticmethod
+    def resolve_leaved_on(x: UserJoinedGameServer, *_):
+        return x.leaved_on

bot/src/bot_graphql/queries/user_joined_game_server_query.py

@@ -0,0 +1,49 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.model.user_joined_game_server import UserJoinedGameServer
+from bot_data.model.user_joined_game_server_history import UserJoinedGameServerHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class UserJoinedGameServerQuery(DataQueryWithHistoryABC):
+    def __init__(self, bot: DiscordBotServiceABC, db: DatabaseContextABC):
+        DataQueryWithHistoryABC.__init__(
+            self,
+            "UserJoinedGameServer",
+            "UserJoinedGameServersHistory",
+            UserJoinedGameServerHistory,
+            db,
+        )
+
+        self._bot = bot
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("gameServer", self.resolve_game_server)
+        self.set_field("user", self.resolve_user)
+        self.set_field("joinedOn", self.resolve_joined_on)
+        self.set_field("leavedOn", self.resolve_leaved_on)
+
+    @staticmethod
+    def resolve_id(x: UserJoinedGameServer, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_game_server(x: UserJoinedGameServer, *_):
+        return x.game_server.name
+
+    @staticmethod
+    def resolve_user(x: UserJoinedGameServer, *_):
+        return x.user
+
+    @staticmethod
+    def resolve_time(x: UserJoinedGameServer, *_):
+        return x.time
+
+    @staticmethod
+    def resolve_joined_on(x: UserJoinedGameServer, *_):
+        return x.joined_on
+
+    @staticmethod
+    def resolve_leaved_on(x: UserJoinedGameServer, *_):
+        return x.leaved_on

bot/src/bot_graphql/queries/user_joined_server_history_query.py

@@ -0,0 +1,28 @@
+from bot_data.model.user_joined_server import UserJoinedServer
+from bot_graphql.abc.data_query_abc import DataQueryABC
+
+
+class UserJoinedServerHistoryQuery(DataQueryABC):
+    def __init__(self):
+        DataQueryABC.__init__(self, "UserJoinedServer")
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("user", self.resolve_user)
+        self.set_field("joinedOn", self.resolve_joined_on)
+        self.set_field("leavedOn", self.resolve_leaved_on)
+
+    @staticmethod
+    def resolve_id(x: UserJoinedServer, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_user(x: UserJoinedServer, *_):
+        return x.user
+
+    @staticmethod
+    def resolve_joined_on(x: UserJoinedServer, *_):
+        return x.joined_on
+
+    @staticmethod
+    def resolve_leaved_on(x: UserJoinedServer, *_):
+        return x.leaved_on

bot/src/bot_graphql/queries/user_joined_server_query.py

@@ -0,0 +1,37 @@
+from cpl_core.database.context import DatabaseContextABC
+
+from bot_data.model.user_joined_server import UserJoinedServer
+from bot_data.model.user_joined_server_history import UserJoinedServerHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class UserJoinedServerQuery(DataQueryWithHistoryABC):
+    def __init__(self, db: DatabaseContextABC):
+        DataQueryWithHistoryABC.__init__(
+            self,
+            "UserJoinedServer",
+            "UserJoinedServersHistory",
+            UserJoinedServerHistory,
+            db,
+        )
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("user", self.resolve_user)
+        self.set_field("joinedOn", self.resolve_joined_on)
+        self.set_field("leavedOn", self.resolve_leaved_on)
+
+    @staticmethod
+    def resolve_id(x: UserJoinedServer, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_user(x: UserJoinedServer, *_):
+        return x.user
+
+    @staticmethod
+    def resolve_joined_on(x: UserJoinedServer, *_):
+        return x.joined_on
+
+    @staticmethod
+    def resolve_leaved_on(x: UserJoinedServer, *_):
+        return x.leaved_on

bot/src/bot_graphql/queries/user_joined_voice_channel_history_query.py

@@ -0,0 +1,47 @@
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.model.user_joined_voice_channel import UserJoinedVoiceChannel
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class UserJoinedVoiceChannelHistoryQuery(HistoryQueryABC):
+    def __init__(self, bot: DiscordBotServiceABC):
+        HistoryQueryABC.__init__(self, "UserJoinedVoiceChannel")
+
+        self._bot = bot
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("channelId", self.resolve_channel_id)
+        self.set_field("channelName", self.resolve_channel_name)
+        self.set_field("user", self.resolve_user)
+        self.set_field("time", self.resolve_time)
+        self.set_field("joinedOn", self.resolve_joined_on)
+        self.set_field("leavedOn", self.resolve_leaved_on)
+
+    @staticmethod
+    def resolve_id(x: UserJoinedVoiceChannel, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_channel_id(x: UserJoinedVoiceChannel, *_):
+        return x.channel_id
+
+    @staticmethod
+    def resolve_channel_name(x: UserJoinedVoiceChannel, *_):
+        return x.channel_name
+
+    @staticmethod
+    def resolve_user(x: UserJoinedVoiceChannel, *_):
+        return x.user
+
+    @staticmethod
+    def resolve_time(x: UserJoinedVoiceChannel, *_):
+        return x.time
+
+    @staticmethod
+    def resolve_joined_on(x: UserJoinedVoiceChannel, *_):
+        return x.joined_on
+
+    @staticmethod
+    def resolve_leaved_on(x: UserJoinedVoiceChannel, *_):
+        return x.leaved_on

bot/src/bot_graphql/queries/user_joined_voice_channel_query.py

@@ -0,0 +1,57 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.model.user_joined_voice_channel import UserJoinedVoiceChannel
+from bot_data.model.user_joined_voice_channel_history import (
+    UserJoinedVoiceChannelHistory,
+)
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class UserJoinedVoiceChannelQuery(DataQueryWithHistoryABC):
+    def __init__(self, bot: DiscordBotServiceABC, db: DatabaseContextABC):
+        DataQueryWithHistoryABC.__init__(
+            self,
+            "UserJoinedVoiceChannel",
+            "UserJoinedVoiceChannelsHistory",
+            UserJoinedVoiceChannelHistory,
+            db,
+        )
+
+        self._bot = bot
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("channelId", self.resolve_channel_id)
+        self.set_field("channelName", self.resolve_channel_name)
+        self.set_field("user", self.resolve_user)
+        self.set_field("time", self.resolve_time)
+        self.set_field("joinedOn", self.resolve_joined_on)
+        self.set_field("leavedOn", self.resolve_leaved_on)
+
+    @staticmethod
+    def resolve_id(x: UserJoinedVoiceChannel, *_):
+        return x.id
+
+    @staticmethod
+    def resolve_channel_id(x: UserJoinedVoiceChannel, *_):
+        return x.channel_id
+
+    @staticmethod
+    def resolve_channel_name(x: UserJoinedVoiceChannel, *_):
+        return x.channel_name
+
+    @staticmethod
+    def resolve_user(x: UserJoinedVoiceChannel, *_):
+        return x.user
+
+    @staticmethod
+    def resolve_time(x: UserJoinedVoiceChannel, *_):
+        return x.time
+
+    @staticmethod
+    def resolve_joined_on(x: UserJoinedVoiceChannel, *_):
+        return x.joined_on
+
+    @staticmethod
+    def resolve_leaved_on(x: UserJoinedVoiceChannel, *_):
+        return x.leaved_on

bot/src/bot_graphql/queries/user_query.py

@@ -0,0 +1,125 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_core.abc.client_utils_abc import ClientUtilsABC
+from bot_data.abc.achievement_repository_abc import AchievementRepositoryABC
+from bot_data.abc.user_joined_game_server_repository_abc import (
+    UserJoinedGameServerRepositoryABC,
+)
+from bot_data.abc.user_joined_server_repository_abc import UserJoinedServerRepositoryABC
+from bot_data.abc.user_joined_voice_channel_repository_abc import (
+    UserJoinedVoiceChannelRepositoryABC,
+)
+from bot_data.abc.user_warnings_repository_abc import UserWarningsRepositoryABC
+from bot_data.model.user import User
+from bot_data.model.user_history import UserHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+from bot_graphql.filter.achievement_filter import AchievementFilter
+from bot_graphql.filter.user_joined_game_server_filter import UserJoinedGameServerFilter
+from bot_graphql.filter.user_joined_server_filter import UserJoinedServerFilter
+from bot_graphql.filter.user_joined_voice_channel_filter import (
+    UserJoinedVoiceChannelFilter,
+)
+from bot_graphql.filter.user_warning_filter import UserWarningFilter
+from modules.level.service.level_service import LevelService
+from modules.permission.abc.permission_service_abc import PermissionServiceABC
+
+
+class UserQuery(DataQueryWithHistoryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+        db: DatabaseContextABC,
+        levels: LevelService,
+        client_utils: ClientUtilsABC,
+        ujs: UserJoinedServerRepositoryABC,
+        ujvs: UserJoinedVoiceChannelRepositoryABC,
+        user_joined_game_server: UserJoinedGameServerRepositoryABC,
+        permissions: PermissionServiceABC,
+        achievements: AchievementRepositoryABC,
+        user_warnings: UserWarningsRepositoryABC,
+    ):
+        DataQueryWithHistoryABC.__init__(self, "User", "UsersHistory", UserHistory, db)
+
+        self._bot = bot
+        self._levels = levels
+        self._client_utils = client_utils
+        self._user_joined_game_server = user_joined_game_server
+        self._ujs = ujs
+        self._ujvs = ujvs
+        self._permissions = permissions
+        self._achievements = achievements
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discordId", self.resolve_discord_id)
+        self.set_field("name", self.resolve_name)
+        self.set_field("xp", self.resolve_xp)
+        self.set_field("messageCount", lambda x, *_: x.message_count)
+        self.set_field("reactionCount", lambda x, *_: x.reaction_count)
+        self.set_field("birthday", lambda x, *_: x.birthday)
+        self.set_field("ontime", self.resolve_ontime)
+        self.set_field("level", self.resolve_level)
+        self.add_collection(
+            "joinedServer",
+            lambda user, *_: self._ujs.get_user_joined_servers_by_user_id(user.id),
+            UserJoinedServerFilter,
+        )
+        self.add_collection(
+            "joinedVoiceChannel",
+            lambda user, *_: self._ujvs.get_user_joined_voice_channels_by_user_id(
+                user.id
+            ),
+            UserJoinedVoiceChannelFilter,
+        )
+        self.add_collection(
+            "userJoinedGameServer",
+            lambda user, *_: self._user_joined_game_server.get_user_joined_game_servers_by_user_id(
+                user.id
+            ),
+            UserJoinedGameServerFilter,
+        )
+        self.add_collection(
+            "achievement",
+            lambda user, *_: achievements.get_achievements_by_user_id(user.id),
+            AchievementFilter,
+        )
+        self.add_collection(
+            "userWarning",
+            lambda user, *_: user_warnings.get_user_warnings_by_user_id(user.id),
+            UserWarningFilter,
+        )
+
+        self.set_field("server", self.resolve_server)
+        self.set_field("leftServer", self.resolve_left_server)
+
+    @staticmethod
+    def resolve_id(user: User, *_):
+        return user.id
+
+    @staticmethod
+    def resolve_discord_id(user: User, *_):
+        return user.discord_id
+
+    @staticmethod
+    def resolve_name(user: User, *_):
+        return user.name
+
+    @staticmethod
+    def resolve_xp(user: User, *_):
+        return user.xp
+
+    @staticmethod
+    def resolve_ontime(user: User, *_):
+        return user.ontime
+
+    @staticmethod
+    def resolve_level(user: User, *_):
+        return user.level
+
+    @staticmethod
+    def resolve_server(user: User, *_):
+        return user.server
+
+    @staticmethod
+    def resolve_left_server(user: User, *_):
+        return user.left_server

bot/src/bot_graphql/queries/user_warning_history_query.py

@@ -0,0 +1,11 @@
+from bot_graphql.abc.history_query_abc import HistoryQueryABC
+
+
+class UserWarningHistoryQuery(HistoryQueryABC):
+    def __init__(self):
+        HistoryQueryABC.__init__(self, "UserWarning")
+
+        self.set_field("id", lambda x, *_: x.id)
+        self.set_field("user", lambda x, *_: x.user)
+        self.set_field("description", lambda x, *_: x.description)
+        self.set_field("author", lambda x, *_: x.author)

bot/src/bot_graphql/queries/user_warning_query.py

@@ -0,0 +1,19 @@
+from cpl_core.database.context import DatabaseContextABC
+
+from bot_data.model.user_warnings_history import UserWarningsHistory
+from bot_graphql.abc.data_query_with_history_abc import DataQueryWithHistoryABC
+
+
+class UserWarningQuery(DataQueryWithHistoryABC):
+    def __init__(
+        self,
+        db: DatabaseContextABC,
+    ):
+        DataQueryWithHistoryABC.__init__(
+            self, "UserWarning", "UserWarningsHistory", UserWarningsHistory, db
+        )
+
+        self.set_field("id", lambda x, *_: x.id)
+        self.set_field("user", lambda x, *_: x.user)
+        self.set_field("description", lambda x, *_: x.description)
+        self.set_field("author", lambda x, *_: x.author)

bot/src/bot_graphql/query.py

@@ -0,0 +1,128 @@
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+
+from bot_core.configuration.feature_flags_enum import FeatureFlagsEnum
+from bot_data.abc.achievement_repository_abc import AchievementRepositoryABC
+from bot_data.abc.auto_role_repository_abc import AutoRoleRepositoryABC
+from bot_data.abc.client_repository_abc import ClientRepositoryABC
+from bot_data.abc.game_server_repository_abc import GameServerRepositoryABC
+from bot_data.abc.known_user_repository_abc import KnownUserRepositoryABC
+from bot_data.abc.level_repository_abc import LevelRepositoryABC
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+from bot_data.abc.short_role_name_repository_abc import ShortRoleNameRepositoryABC
+from bot_data.abc.technician_config_repository_abc import TechnicianConfigRepositoryABC
+from bot_data.abc.user_joined_game_server_repository_abc import (
+    UserJoinedGameServerRepositoryABC,
+)
+from bot_data.abc.user_joined_server_repository_abc import UserJoinedServerRepositoryABC
+from bot_data.abc.user_joined_voice_channel_repository_abc import (
+    UserJoinedVoiceChannelRepositoryABC,
+)
+from bot_data.abc.user_repository_abc import UserRepositoryABC
+from bot_data.abc.user_warnings_repository_abc import UserWarningsRepositoryABC
+from bot_data.model.short_role_name_position_enum import ShortRoleNamePositionEnum
+from bot_graphql.abc.query_abc import QueryABC
+from bot_graphql.filter.achievement_filter import AchievementFilter
+from bot_graphql.filter.auto_role_filter import AutoRoleFilter
+from bot_graphql.filter.auto_role_rule_filter import AutoRoleRuleFilter
+from bot_graphql.filter.client_filter import ClientFilter
+from bot_graphql.filter.level_filter import LevelFilter
+from bot_graphql.filter.server_filter import ServerFilter
+from bot_graphql.filter.short_role_name_filter import ShortRoleNameFilter
+from bot_graphql.filter.user_filter import UserFilter
+from bot_graphql.filter.user_joined_game_server_filter import UserJoinedGameServerFilter
+from bot_graphql.filter.user_joined_server_filter import UserJoinedServerFilter
+from bot_graphql.filter.user_joined_voice_channel_filter import (
+    UserJoinedVoiceChannelFilter,
+)
+from bot_graphql.filter.user_warning_filter import UserWarningFilter
+from bot_graphql.model.discord import Discord
+from modules.achievements.achievement_service import AchievementService
+
+
+class Query(QueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+        auto_roles: AutoRoleRepositoryABC,
+        clients: ClientRepositoryABC,
+        known_users: KnownUserRepositoryABC,
+        levels: LevelRepositoryABC,
+        servers: ServerRepositoryABC,
+        game_servers: GameServerRepositoryABC,
+        user_joined_servers: UserJoinedServerRepositoryABC,
+        user_joined_voice_channels: UserJoinedVoiceChannelRepositoryABC,
+        user_joined_game_server: UserJoinedGameServerRepositoryABC,
+        users: UserRepositoryABC,
+        achievements: AchievementRepositoryABC,
+        short_role_names: ShortRoleNameRepositoryABC,
+        user_warnings: UserWarningsRepositoryABC,
+        achievement_service: AchievementService,
+        technician_config: TechnicianConfigRepositoryABC,
+    ):
+        QueryABC.__init__(self, "Query")
+
+        self.add_collection(
+            "autoRole", lambda *_: auto_roles.get_auto_roles(), AutoRoleFilter
+        )
+        self.add_collection(
+            "autoRoleRule",
+            lambda *_: auto_roles.get_auto_role_rules(),
+            AutoRoleRuleFilter,
+        )
+        self.add_collection("client", lambda *_: clients.get_clients(), ClientFilter)
+        self.add_collection("knownUser", lambda *_: known_users.get_users())
+        self.add_collection("level", lambda *_: levels.get_levels(), LevelFilter)
+        self.add_collection("server", lambda *_: servers.get_servers(), ServerFilter)
+        self.add_collection("gameServer", lambda *_: game_servers.get_game_servers())
+        self.add_collection(
+            "userJoinedServer",
+            lambda *_: user_joined_servers.get_user_joined_servers(),
+            UserJoinedServerFilter,
+        )
+        self.add_collection(
+            "userJoinedVoiceChannel",
+            lambda *_: user_joined_voice_channels.get_user_joined_voice_channels(),
+            UserJoinedVoiceChannelFilter,
+        )
+        self.add_collection(
+            "userJoinedGameServer",
+            lambda *_: user_joined_game_server.get_user_joined_game_servers(),
+            UserJoinedGameServerFilter,
+        )
+        self.add_collection("user", lambda *_: users.get_users(), UserFilter)
+        self.add_collection(
+            "achievement", lambda *_: achievements.get_achievements(), AchievementFilter
+        )
+        self.add_collection(
+            "shortRoleName",
+            lambda *_: short_role_names.get_short_role_names(),
+            ShortRoleNameFilter,
+        )
+        self.add_collection(
+            "userWarning",
+            lambda *_: user_warnings.get_user_warnings(),
+            UserWarningFilter,
+        )
+
+        self.set_field(
+            "technicianConfig", lambda *_: technician_config.get_technician_config()
+        )
+
+        self.set_field(
+            "achievementAttributes", lambda *_: achievement_service.get_attributes()
+        )
+        self.set_field(
+            "achievementOperators", lambda *_: achievement_service.get_operators()
+        )
+        self.set_field(
+            "shortRoleNamePositions",
+            lambda *_: [x.value for x in ShortRoleNamePositionEnum],
+        )
+
+        self.set_field(
+            "possibleFeatureFlags", lambda *_: [e.value for e in FeatureFlagsEnum]
+        )
+        self.set_field(
+            "discord", lambda *_: Discord(bot.guilds, List(any).extend(bot.users))
+        )