Improved queries & filtering #162

# Conflicts:
#	kdb-bot/cpl-workspace.json
#	kdb-bot/src/bot/config
#	kdb-bot/src/bot/module_list.py
#	kdb-bot/src/bot_api/api.py
#	kdb-bot/src/bot_data/service/client_repository_service.py
#	kdb-bot/src/bot_data/service/server_repository_service.py

kdb-bot/.cpl/schematic_query.py

@@ -0,0 +1,34 @@
+from cpl_cli.abc.generate_schematic_abc import GenerateSchematicABC
+
+
+class query(GenerateSchematicABC):
+    def __init__(self, *args: str):
+        GenerateSchematicABC.__init__(self, *args)
+
+    def get_code(self) -> str:
+        import textwrap
+
+        code = textwrap.dedent(
+            """\
+        from bot_graphql.abc.data_query_abc import DataQueryABC
+        
+        
+        class $ClassName(DataQueryABC):
+            def __init__(self):
+                DataQueryABC.__init__(self, "Name")
+        
+                self.set_field("id", self.resolve_id)
+        
+            @staticmethod
+            def resolve_id(x, *_):
+                return x.id
+        """
+        )
+        return self.build_code_str(
+            code,
+            ClassName=self._class_name,
+        )
+
+    @classmethod
+    def register(cls):
+        GenerateSchematicABC.register(cls, "query", [])

kdb-bot/cpl-workspace.json

@@ -6,6 +6,7 @@
       "bot-api": "src/bot_api/bot-api.json",
       "bot-core": "src/bot_core/bot-core.json",
       "bot-data": "src/bot_data/bot-data.json",
+      "bot-graphql": "src/bot_graphql/bot-graphql.json",
       "auto-role": "src/modules/auto_role/auto-role.json",
       "base": "src/modules/base/base.json",
       "boot-log": "src/modules/boot_log/boot-log.json",

kdb-bot/src/bot/bot.json

@@ -16,7 +16,7 @@
     "LicenseName": "MIT",
     "LicenseDescription": "MIT, see LICENSE for more details.",
     "Dependencies": [
-      "cpl-core==2022.12.1.post2",
+      "cpl-core==2022.12.1.post3",
       "cpl-translation==2022.12.1",
       "cpl-query==2022.12.2.post1",
       "cpl-discord==2022.12.1.post2",
@@ -28,10 +28,11 @@
       "Flask-SocketIO==5.3.2",
       "eventlet==0.33.2",
       "requests-oauthlib==1.3.1",
-      "icmplib==3.0.3"
+      "icmplib==3.0.3",
+      "ariadne==0.17.1"
     ],
     "DevDependencies": [
-      "cpl-cli==2022.12.1.post2"
+      "cpl-cli==2022.12.1.post3"
     ],
     "PythonVersion": ">=3.10.4",
     "PythonPath": {},
@@ -55,6 +56,7 @@
       "../bot_api/bot-api.json",
       "../bot_core/bot-core.json",
       "../bot_data/bot-data.json",
+      "../bot_graphql/bot-graphql.json",
       "../modules/auto_role/auto-role.json",
       "../modules/base/base.json",
       "../modules/boot_log/boot-log.json",

kdb-bot/src/bot/module_list.py

@@ -4,6 +4,7 @@ from bot_api.api_module import ApiModule
 from bot_core.core_extension.core_extension_module import CoreExtensionModule
 from bot_core.core_module import CoreModule
 from bot_data.data_module import DataModule
+from bot_graphql.graphql_module import GraphQLModule
 from modules.auto_role.auto_role_module import AutoRoleModule
 from modules.base.base_module import BaseModule
 from modules.boot_log.boot_log_module import BootLogModule
@@ -23,6 +24,7 @@ class ModuleList:
             [
                 CoreModule,  # has to be first!
                 DataModule,
+                GraphQLModule,
                 PermissionModule,
                 DatabaseModule,
                 AutoRoleModule,

kdb-bot/src/bot_api/api.py

@@ -1,4 +1,3 @@
-import re
 import sys
 import textwrap
 import uuid
@@ -16,7 +15,6 @@ from werkzeug.exceptions import NotFound
 
 from bot_api.configuration.api_settings import ApiSettings
 from bot_api.configuration.authentication_settings import AuthenticationSettings
-from bot_api.configuration.frontend_settings import FrontendSettings
 from bot_api.exception.service_error_code_enum import ServiceErrorCode
 from bot_api.exception.service_exception import ServiceException
 from bot_api.logging.api_logger import ApiLogger
@@ -30,7 +28,6 @@ class Api(Flask):
         logger: ApiLogger,
         services: ServiceProviderABC,
         api_settings: ApiSettings,
-        frontend_settings: FrontendSettings,
         auth_settings: AuthenticationSettings,
         *args,
         **kwargs,
@@ -146,20 +143,13 @@ class Api(Flask):
         return response
 
     def start(self):
-        self._logger.info(
-            __name__,
-            f"Starting API {self._api_settings.host}:{self._api_settings.port}",
-        )
+        self._logger.info(__name__, f"Starting API {self._api_settings.host}:{self._api_settings.port}")
         self._register_routes()
         self.secret_key = CredentialManager.decrypt(self._auth_settings.secret_key)
         # from waitress import serve
         # https://docs.pylonsproject.org/projects/waitress/en/stable/arguments.html
         # serve(self, host=self._apt_settings.host, port=self._apt_settings.port, threads=10, connection_limit=1000, channel_timeout=10)
-        wsgi.server(
-            eventlet.listen((self._api_settings.host, self._api_settings.port)),
-            self,
-            log_output=False,
-        )
+        wsgi.server(eventlet.listen((self._api_settings.host, self._api_settings.port)), self, log_output=False)
 
     def on_connect(self):
         self._logger.info(__name__, f"Client connected")

kdb-bot/src/bot_api/api_module.py

@@ -14,6 +14,7 @@ from bot_api.api_thread import ApiThread
 from bot_api.controller.auth_controller import AuthController
 from bot_api.controller.auth_discord_controller import AuthDiscordController
 from bot_api.controller.discord.server_controller import ServerController
+from bot_api.controller.grahpql_controller import GraphQLController
 from bot_api.controller.gui_controller import GuiController
 from bot_api.event.bot_api_on_ready_event import BotApiOnReadyEvent
 from bot_api.service.auth_service import AuthService
@@ -46,6 +47,7 @@ class ApiModule(ModuleABC):
         services.add_transient(GuiController)
         services.add_transient(DiscordService)
         services.add_transient(ServerController)
+        services.add_transient(GraphQLController)
 
         # cpl-discord
         self._dc.add_event(DiscordEventTypesEnum.on_ready.value, BotApiOnReadyEvent)

kdb-bot/src/bot_api/controller/grahpql_controller.py

@@ -0,0 +1,39 @@
+from ariadne import graphql_sync
+from ariadne.constants import PLAYGROUND_HTML
+from cpl_core.configuration import ConfigurationABC
+from cpl_core.environment import ApplicationEnvironmentABC
+from flask import request, jsonify
+
+from bot_api.logging.api_logger import ApiLogger
+from bot_api.route.route import Route
+from bot_graphql.schema import Schema
+
+
+class GraphQLController:
+    BasePath = f"/api/graphql"
+
+    def __init__(
+        self,
+        config: ConfigurationABC,
+        env: ApplicationEnvironmentABC,
+        logger: ApiLogger,
+        schema: Schema,
+    ):
+        self._config = config
+        self._env = env
+        self._logger = logger
+        self._schema = schema
+
+    @Route.get(f"{BasePath}/playground")
+    async def playground(self):
+        return PLAYGROUND_HTML, 200
+
+    @Route.post(f"{BasePath}")
+    async def graphql(self):
+        data = request.get_json()
+
+        # Note: Passing the request to the context is optional.
+        # In Flask, the current request is always accessible as flask.request
+        success, result = graphql_sync(self._schema.schema, data, context_value=request)
+
+        return jsonify(result), 200 if success else 400

kdb-bot/src/bot_data/abc/client_repository_abc.py

@@ -2,6 +2,7 @@ from abc import ABC, abstractmethod
 from typing import Optional
 
 from cpl_query.extension import List
+
 from bot_data.model.client import Client
 
 
@@ -22,6 +23,10 @@ class ClientRepositoryABC(ABC):
     def get_client_by_discord_id(self, discord_id: int) -> Client:
         pass
 
+    @abstractmethod
+    def get_clients_by_server_id(self, server_id: int) -> List[Client]:
+        pass
+
     @abstractmethod
     def find_client_by_discord_id(self, discord_id: int) -> Optional[Client]:
         pass

kdb-bot/src/bot_data/abc/user_repository_abc.py

@@ -27,6 +27,10 @@ class UserRepositoryABC(ABC):
     def get_users_by_discord_id(self, discord_id: int) -> List[User]:
         pass
 
+    @abstractmethod
+    def get_users_by_server_id(self, server_id: int) -> List[User]:
+        pass
+
     @abstractmethod
     def get_user_by_discord_id_and_server_id(self, discord_id: int, server_id: int) -> User:
         pass

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

@@ -1,8 +1,6 @@
 from datetime import datetime
-from typing import Optional
-from cpl_core.database import TableABC
 
-from bot_data.model.server import Server
+from cpl_core.database import TableABC
 
 
 class KnownUser(TableABC):

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

@@ -1,5 +1,6 @@
 from datetime import datetime
 from typing import Optional
+
 from cpl_core.database import TableABC
 
 from bot_data.model.server import Server
@@ -62,6 +63,15 @@ class User(TableABC):
         """
         )
 
+    @staticmethod
+    def get_select_by_server_id_string(server_id: int) -> str:
+        return str(
+            f"""
+            SELECT * FROM `Users`
+            WHERE `ServerId` = {server_id};
+        """
+        )
+
     @staticmethod
     def get_select_by_discord_id_string(id: int) -> str:
         return str(

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

@@ -38,6 +38,8 @@ class ClientRepositoryService(ClientRepositoryABC):
                     result[5],
                     result[6],
                     self._servers.get_server_by_id(result[7]),
+                    result[8],
+                    result[9],
                     id=result[0],
                 )
             )
@@ -55,9 +57,33 @@ class ClientRepositoryService(ClientRepositoryABC):
             result[5],
             result[6],
             self._servers.get_server_by_id(result[7]),
+            result[8],
+            result[9],
             id=result[0],
         )
 
+    def get_clients_by_server_id(self, server_id: int) -> List[Client]:
+        clients = List(Client)
+        self._logger.trace(__name__, f"Send SQL command: {Client.get_select_by_server_id_string(server_id)}")
+        results = self._context.select(Client.get_select_by_server_id_string(server_id))
+        for result in results:
+            clients.append(
+                Client(
+                    result[1],
+                    result[2],
+                    result[3],
+                    result[4],
+                    result[5],
+                    result[6],
+                    self._servers.get_server_by_id(result[7]),
+                    result[8],
+                    result[9],
+                    id=result[0],
+                )
+            )
+
+        return clients
+
     def get_client_by_discord_id(self, discord_id: int) -> Client:
         self._logger.trace(
             __name__,
@@ -72,6 +98,8 @@ class ClientRepositoryService(ClientRepositoryABC):
             result[5],
             result[6],
             self._servers.get_server_by_id(result[7]),
+            result[8],
+            result[9],
             id=result[0],
         )
 
@@ -94,6 +122,8 @@ class ClientRepositoryService(ClientRepositoryABC):
             result[5],
             result[6],
             self._servers.get_server_by_id(result[7]),
+            result[8],
+            result[9],
             id=result[0],
         )
 
@@ -116,6 +146,8 @@ class ClientRepositoryService(ClientRepositoryABC):
             result[5],
             result[6],
             self._servers.get_server_by_id(result[7]),
+            result[8],
+            result[9],
             id=result[0],
         )
 
@@ -138,6 +170,8 @@ class ClientRepositoryService(ClientRepositoryABC):
             result[5],
             result[6],
             self._servers.get_server_by_id(result[7]),
+            result[8],
+            result[9],
             id=result[0],
         )
 

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

@@ -22,7 +22,7 @@ class ServerRepositoryService(ServerRepositoryABC):
         self._logger.trace(__name__, f"Send SQL command: {Server.get_select_all_string()}")
         results = self._context.select(Server.get_select_all_string())
         for result in results:
-            servers.append(Server(result[1], id=result[0]))
+            servers.append(Server(result[1], result[2], result[3], id=result[0]))
 
         return servers
 
@@ -54,7 +54,7 @@ class ServerRepositoryService(ServerRepositoryABC):
     def get_server_by_id(self, server_id: int) -> Server:
         self._logger.trace(__name__, f"Send SQL command: {Server.get_select_by_id_string(server_id)}")
         result = self._context.select(Server.get_select_by_id_string(server_id))[0]
-        return Server(result[1], id=result[0])
+        return Server(result[1], result[2], result[3], id=result[0])
 
     def get_server_by_discord_id(self, discord_id: int) -> Server:
         self._logger.trace(
@@ -62,7 +62,7 @@ class ServerRepositoryService(ServerRepositoryABC):
             f"Send SQL command: {Server.get_select_by_discord_id_string(discord_id)}",
         )
         result = self._context.select(Server.get_select_by_discord_id_string(discord_id))[0]
-        return Server(result[1], id=result[0])
+        return Server(result[1], result[2], result[3], id=result[0])
 
     def find_server_by_discord_id(self, discord_id: int) -> Optional[Server]:
         self._logger.trace(

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

@@ -85,6 +85,25 @@ class UserRepositoryService(UserRepositoryABC):
 
         return users
 
+    def get_users_by_server_id(self, server_id: int) -> List[User]:
+        users = List(User)
+        self._logger.trace(
+            __name__,
+            f"Send SQL command: {User.get_select_by_server_id_string(server_id)}",
+        )
+        results = self._context.select(User.get_select_by_server_id_string(server_id))
+        for result in results:
+            users.append(
+                User(
+                    result[1],
+                    result[2],
+                    self._servers.get_server_by_id(result[3]),
+                    id=result[0],
+                )
+            )
+
+        return users
+
     def get_user_by_discord_id_and_server_id(self, discord_id: int, server_id: int) -> User:
         self._logger.trace(
             __name__,

kdb-bot/src/bot_graphql/__init__.py

@@ -0,0 +1 @@
+# imports

kdb-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("created_at", self.resolve_created_at)
+        self.set_field("modified_at", 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

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

@@ -0,0 +1,54 @@
+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

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

@@ -0,0 +1,50 @@
+from typing import Callable
+
+from ariadne import ObjectType
+from cpl_query.extension import List
+
+from bot_graphql.abc.filter_abc import FilterABC
+from bot_graphql.filter.page import Page
+from bot_graphql.filter.sort import Sort
+
+
+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
+
+            return self._resolve_collection(get_collection(*args), *args, **kwargs)
+
+        self.set_field(f"{name}s", wrapper)
+        self.set_field(f"{name}_count", lambda *args: get_collection(*args).count())
+
+    # @FilterABC.resolve_filter_annotation
+    def _resolve_collection(self, collection: List, *_, filter: FilterABC = None, page: Page = None, sort: Sort = None):
+        if filter is not None:
+            return filter.filter(collection)
+
+        if page is not None:
+            return page.filter(collection)
+
+        if sort is not None:
+            return sort.filter(collection)
+
+        return collection

kdb-bot/src/bot_graphql/bot-graphql.json

@@ -0,0 +1,44 @@
+{
+  "ProjectSettings": {
+    "Name": "bot-data",
+    "Version": {
+      "Major": "0",
+      "Minor": "1",
+      "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.1"
+    ],
+    "DevDependencies": [
+      "cpl-cli>=2022.12.1"
+    ],
+    "PythonVersion": ">=3.10.4",
+    "PythonPath": {},
+    "Classifiers": []
+  },
+  "BuildSettings": {
+    "ProjectType": "library",
+    "SourcePath": "",
+    "OutputPath": "../../dist",
+    "Main": "",
+    "EntryPoint": "",
+    "IncludePackageData": false,
+    "Included": [],
+    "Excluded": [
+      "*/__pycache__",
+      "*/logs",
+      "*/tests"
+    ],
+    "PackageData": {},
+    "ProjectReferences": []
+  }
+}

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

@@ -0,0 +1,38 @@
+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):
+        FilterABC.__init__(self)
+
+        self._id = None
+        self._channel_id = None
+        self._message_id = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = values["id"]
+
+        if "channel_id" in values:
+            self._channel_id = values["channel_id"]
+
+        if "message_id" in values:
+            self._message_id = values["message_id"]
+
+    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)
+
+        if self._message_id is not None:
+            query = query.where(lambda x: x.discord_message_id == self._message_id)
+
+        # if self._server_id is not None:
+        #     query = query.where(lambda x: x.server.server_id == self._server_id)
+
+        return query

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

@@ -0,0 +1,45 @@
+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):
+        FilterABC.__init__(self)
+
+        self._id = None
+        self._emoji_name = None
+        self._role_id = None
+        self._auto_role_id = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = values["id"]
+
+        if "emoji_name" in values:
+            self._emoji_name = values["emoji_name"]
+
+        if "role_id" in values:
+            self._role_id = values["role_id"]
+
+        if "auto_role_id" in values:
+            self._auto_role_id = values["auto_role_id"]
+
+    def filter(self, query: List[AutoRoleRule]) -> List[AutoRoleRule]:
+        if self._id is not None:
+            query = query.where(lambda x: x.auto_role_rule_id == self._id)
+
+        if self._auto_role_id is not None:
+            query = query.where(lambda x: x.auto_role_id == self._auto_role_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._server_id is not None:
+        #     query = query.where(lambda x: x.server.server_id == self._server_id)
+
+        return query

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

@@ -0,0 +1,29 @@
+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):
+        FilterABC.__init__(self)
+
+        self._id = None
+        self._name = None
+        self._server_id = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = values["id"]
+
+        if "name" in values:
+            self._name = values["name"]
+
+    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())
+
+        return query

kdb-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 "page_index" in values:
+            self._page_index = values["page_index"]
+
+        if "page_size" in values:
+            self._page_size = values["page_size"]
+
+    def filter(self, query: List, *args) -> List:
+        if self._page_size is not None and self._page_index is not None:
+            skip = self._page_size * self._page_index
+            result = query.skip(skip).take(self._page_size)
+            return result
+
+        return query

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

@@ -0,0 +1,46 @@
+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 "discord_id" in values:
+            self._discord_id = values["discord_id"]
+
+        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.server_id == self._id)
+
+        if self._discord_id is not None:
+            query = query.where(lambda x: x.discord_server_id == self._discord_id)
+
+        if self._name is not None:
+
+            def where_guild(x: Guild):
+                guild = bot.get_guild(x.discord_server_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

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

@@ -0,0 +1,20 @@
+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 "sort_direction" in values:
+            self._sort_direction = values["sort_direction"]
+
+        if "sort_column" in values:
+            self._sort_column = values["sort_column"]
+
+    def filter(self, query: List, *args) -> List:
+        return query

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

@@ -0,0 +1,74 @@
+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.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,
+    ):
+        FilterABC.__init__(self)
+
+        self._services = services
+        self._bot = bot
+        self._client_utils = client_utils
+        self._levels = levels
+
+        self._id = None
+        self._discord_id = None
+        self._name = None
+        self._xp = None
+        self._ontime = None
+        self._level: Optional[LevelFilter] = None
+
+    def from_dict(self, values: dict):
+        if "id" in values:
+            self._id = values["id"]
+        if "discord_id" in values:
+            self._discord_id = values["discord_id"]
+        if "name" in values:
+            self._name = values["name"]
+        if "xp" in values:
+            self._xp = values["xp"]
+        if "ontime" in values:
+            self._ontime = values["ontime"]
+        if "level" in values:
+            self._level: LevelFilter = self._services.get_service(LevelFilter)
+            self._level.from_dict(values["level"])
+
+    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)
+
+        if self._name is not None:
+            query = query.where(
+                lambda x: self._bot.get_user(x.discord_id).name == self._name
+                or self._name in self._bot.get_user(x.discord_id).name
+            )
+
+        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)
+
+        return query

kdb-bot/src/bot_graphql/graphql_module.py

@@ -0,0 +1,61 @@
+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_data.service.seeder_service import SeederService
+from bot_graphql.abc.filter_abc import FilterABC
+from bot_graphql.abc.query_abc import QueryABC
+from bot_graphql.filter.auto_role_filter import AutoRoleFilter
+from bot_graphql.filter.auto_role_rule_filter import AutoRoleRuleFilter
+from bot_graphql.filter.level_filter import LevelFilter
+from bot_graphql.filter.server_filter import ServerFilter
+from bot_graphql.filter.user_filter import UserFilter
+from bot_graphql.graphql_service import GraphQLService
+from bot_graphql.mutation import Mutation
+from bot_graphql.mutations.level_mutation import LevelMutation
+from bot_graphql.queries.auto_role_query import AutoRoleQuery
+from bot_graphql.queries.auto_role_rule_query import AutoRoleRuleQuery
+from bot_graphql.queries.client_query import ClientQuery
+from bot_graphql.queries.known_user_query import KnownUserQuery
+from bot_graphql.queries.level_query import LevelQuery
+from bot_graphql.queries.server_query import ServerQuery
+from bot_graphql.queries.user_joined_server_query import UserJoinedServerQuery
+from bot_graphql.queries.user_joined_voice_channel_query import UserJoinedVoiceChannelQuery
+from bot_graphql.queries.user_query import UserQuery
+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)
+        services.add_transient(QueryABC, ServerQuery)
+        services.add_transient(QueryABC, KnownUserQuery)
+        services.add_transient(QueryABC, LevelQuery)
+        services.add_transient(QueryABC, LevelMutation)
+        services.add_transient(QueryABC, ClientQuery)
+        services.add_transient(QueryABC, UserQuery)
+        services.add_transient(QueryABC, UserJoinedServerQuery)
+        services.add_transient(QueryABC, UserJoinedVoiceChannelQuery)
+        services.add_transient(QueryABC, AutoRoleQuery)
+        services.add_transient(QueryABC, AutoRoleRuleQuery)
+
+        services.add_singleton(FilterABC, AutoRoleFilter)
+        services.add_singleton(FilterABC, AutoRoleRuleFilter)
+        services.add_singleton(FilterABC, ServerFilter)
+        services.add_singleton(FilterABC, UserFilter)
+        services.add_singleton(FilterABC, LevelFilter)
+
+        services.add_transient(SeederService)

kdb-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

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

@@ -0,0 +1,13 @@
+type AutoRole implements TableQuery {
+    id: ID
+    channel_id: String
+    message_id: String
+
+    server: Server
+
+    auto_role_rules: [AutoRoleRule]
+    auto_role_rule_count: Int
+
+    created_at: String
+    modified_at: String
+}

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

@@ -0,0 +1,10 @@
+type AutoRoleRule implements TableQuery {
+    id: ID
+    emoji_name: String
+    role_id: String
+
+    auto_role: AutoRole
+
+    created_at: String
+    modified_at: String
+}

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

@@ -0,0 +1,14 @@
+interface TableQuery {
+    created_at: String
+    modified_at: String
+}
+
+input Page {
+    page_index: Int
+    page_size: Int
+}
+
+input Sort {
+    sort_direction: String
+    sort_column: String
+}

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

@@ -0,0 +1,15 @@
+type Client implements TableQuery {
+    id: ID
+    discord_id: String
+    name: String
+    sent_message_count: Int
+    received_message_count: Int
+    deleted_message_count: Int
+    received_command_count: Int
+    moved_users_count: Int
+
+    server: Server
+
+    created_at: String
+    modified_at: String
+}

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

@@ -0,0 +1,7 @@
+type KnownUser implements TableQuery {
+    id: ID
+    discord_id: String
+
+    created_at: String
+    modified_at: String
+}

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

@@ -0,0 +1,31 @@
+type Level implements TableQuery {
+    id: ID
+    name: String
+    color: String
+    min_xp: Int
+    permissions: String
+
+    server: Server
+
+    created_at: String
+    modified_at: String
+}
+
+input LevelFilter {
+    id: ID
+    name: String
+}
+
+type LevelMutation {
+    create_level(input: LevelInput!): Level
+    update_level(input: LevelInput!): Level
+    delete_level(id: ID): Level
+}
+
+input LevelInput {
+    name: String!
+    color: String!
+    min_xp: Int!
+    permissions: String!
+    server_id: ID!
+}

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

@@ -0,0 +1,3 @@
+type Mutation {
+    level: LevelMutation
+}

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

@@ -0,0 +1,28 @@
+type Query {
+    auto_roles: [AutoRole]
+    auto_role_count: Int
+
+    auto_role_rules: [AutoRole]
+    auto_role_rule_count: Int
+
+    clients: [Client]
+    client_count: Int
+
+    known_users: [KnownUser]
+    known_user_count: Int
+
+    levels(filter: LevelFilter, page: Page, sort: Sort): [Level]
+    level_count: Int
+
+    servers(filter: ServerFilter, page: Page, sort: Sort): [Server]
+    server_count: Int
+
+    user_joined_servers: [User]
+    user_joined_server_count: Int
+
+    user_joined_voice_channels: [User]
+    user_joined_voice_channel_count: Int
+
+    users(filter: UserFilter, page: Page, sort: Sort): [User]
+    user_count: Int
+}

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

@@ -0,0 +1,26 @@
+type Server implements TableQuery {
+    id: ID
+    discord_id: String
+    name: String
+
+    auto_roles: [AutoRole]
+    auto_role_count: Int
+
+    clients: [Client]
+    client_count: Int
+
+    users(filter: UserFilter): [User]
+    user_count: Int
+
+    levels: [Level]
+    level_count: Int
+
+    created_at: String
+    modified_at: String
+}
+
+input ServerFilter {
+    id: ID
+    discord_id: String
+    name: String
+}

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

@@ -0,0 +1,28 @@
+type User implements TableQuery {
+    id: ID
+    discord_id: String
+    name: String
+    xp: Int
+    ontime: Float
+    level: Level
+
+    joined_servers: [UserJoinedServer]
+    joined_server_count: Int
+
+    joined_voice_channels: [UserJoinedVoiceChannel]
+    joined_voice_channel_count: Int
+
+    server: Server
+
+    created_at: String
+    modified_at: String
+}
+
+input UserFilter {
+    id: ID
+    discord_id: String
+    name: String
+    xp: Int
+    ontime: Float
+    level: LevelFilter
+}

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

@@ -0,0 +1,10 @@
+type UserJoinedServer implements TableQuery {
+    id: ID
+    user: User
+    server: Server
+    joined_on: String
+    leaved_on: String
+
+    created_at: String
+    modified_at: String
+}

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

@@ -0,0 +1,11 @@
+type UserJoinedVoiceChannel implements TableQuery {
+    id: ID
+    channel_id: String
+    user: User
+    server: Server
+    joined_on: String
+    leaved_on: String
+
+    created_at: String
+    modified_at: String
+}

kdb-bot/src/bot_graphql/mutation.py

@@ -0,0 +1,14 @@
+from ariadne import MutationType
+
+from bot_graphql.mutations.level_mutation import LevelMutation
+
+
+class Mutation(MutationType):
+    def __init__(self, level_mutation: LevelMutation):
+        MutationType.__init__(self)
+
+        self._level_mutation = level_mutation
+        self.set_field("level", self.resolve_level)
+
+    def resolve_level(self, *_):
+        return self._level_mutation

kdb-bot/src/bot_graphql/mutations/level_mutation.py

@@ -0,0 +1,64 @@
+from cpl_core.database.context import DatabaseContextABC
+
+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_graphql.abc.query_abc import QueryABC
+
+
+class LevelMutation(QueryABC):
+    def __init__(
+        self,
+        servers: ServerRepositoryABC,
+        levels: LevelRepositoryABC,
+        db: DatabaseContextABC,
+    ):
+        QueryABC.__init__(self, "LevelMutation")
+
+        self._servers = servers
+        self._levels = levels
+        self._db = db
+
+        self.set_field("create_level", self.resolve_create_level)
+        self.set_field("update_level", self.resolve_create_level)
+        self.set_field("delete_level", self.resolve_create_level)
+
+    def resolve_create_level(self, *_, input: dict):
+        level = Level(
+            input["name"],
+            input["color"],
+            int(input["min_xp"]),
+            int(input["permissions"]),
+            self._servers.get_server_by_id(input["server_id"]),
+        )
+        self._levels.add_level(level)
+        self._db.save_changes()
+
+        def get_new_server(l: Level):
+            return (
+                l.name == level.name
+                and l.color == level.color
+                and l.min_xp == level.min_xp
+                and l.permissions == level.permissions
+            )
+
+        return self._levels.get_levels_by_server_id(level.server.server_id).where(get_new_server)
+
+    def resolve_update_level(self, *_, input):
+        level = self._levels.get_level_by_id(input.id)
+        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["min_xp"] if "min_xp" 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()
+
+        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._levels.delete_level(level)
+        self._db.save_changes()
+        return level

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

@@ -0,0 +1,43 @@
+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.data_query_abc import DataQueryABC
+from bot_graphql.filter.server_filter import ServerFilter
+
+
+class AutoRoleQuery(DataQueryABC):
+    def __init__(
+        self,
+        auto_role_rules: AutoRoleRepositoryABC,
+        servers: ServerRepositoryABC,
+    ):
+        DataQueryABC.__init__(self, "AutoRole")
+
+        self._auto_role_rules = auto_role_rules
+        self._servers = servers
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("channel_id", self.resolve_channel_id)
+        self.set_field("message_id", self.resolve_message_id)
+        self.set_field("server", self.resolve_server)
+        self._add_collection(
+            "auto_role_rule", lambda x, *_: self._auto_role_rules.get_auto_role_rules_by_auto_role_id(x.auto_role_id)
+        )
+
+    @staticmethod
+    def resolve_id(x: AutoRole, *_):
+        return x.auto_role_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, *_, 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)

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

@@ -0,0 +1,33 @@
+from bot_data.abc.auto_role_repository_abc import AutoRoleRepositoryABC
+from bot_data.model.auto_role_rule import AutoRoleRule
+from bot_graphql.abc.data_query_abc import DataQueryABC
+
+
+class AutoRoleRuleQuery(DataQueryABC):
+    def __init__(
+        self,
+        auto_roles: AutoRoleRepositoryABC,
+    ):
+        DataQueryABC.__init__(self, "AutoRoleRule")
+
+        self._auto_roles = auto_roles
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("emoji_name", self.resolve_emoji_name)
+        self.set_field("role_id", self.resolve_role_id)
+        self.set_field("auto_role", self.resolve_auto_role)
+
+    @staticmethod
+    def resolve_id(x: AutoRoleRule, *_):
+        return x.auto_role_rule_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 self._auto_roles.get_auto_role_by_id(x.auto_role_id)

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

@@ -0,0 +1,59 @@
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.model.client import Client
+from bot_graphql.abc.data_query_abc import DataQueryABC
+
+
+class ClientQuery(DataQueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+    ):
+        DataQueryABC.__init__(self, "Client")
+
+        self._bot = bot
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discord_id", self.resolve_discord_id)
+        self.set_field("name", self.resolve_name)
+        self.set_field("sent_message_count", self.resolve_sent_message_count)
+        self.set_field("received_message_count", self.resolve_received_message_count)
+        self.set_field("deleted_message_count", self.resolve_deleted_message_count)
+        self.set_field("received_command_count", self.resolve_received_command_count)
+        self.set_field("moved_users_count", self.resolve_moved_users_count)
+        self.set_field("server", self.resolve_server)
+
+    @staticmethod
+    def resolve_id(client: Client, *_):
+        return client.client_id
+
+    @staticmethod
+    def resolve_discord_id(client: Client, *_):
+        return client.discord_id
+
+    def resolve_name(self, client: Client, *_):
+        return self._bot.user.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

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

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

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

@@ -0,0 +1,38 @@
+from bot_data.model.level import Level
+from bot_graphql.abc.data_query_abc import DataQueryABC
+
+
+class LevelQuery(DataQueryABC):
+    def __init__(self):
+        DataQueryABC.__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("min_xp", 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

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

@@ -0,0 +1,53 @@
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_data.abc.auto_role_repository_abc import AutoRoleRepositoryABC
+from bot_data.abc.client_repository_abc import ClientRepositoryABC
+from bot_data.abc.level_repository_abc import LevelRepositoryABC
+from bot_data.abc.user_repository_abc import UserRepositoryABC
+from bot_data.model.server import Server
+from bot_graphql.abc.data_query_abc import DataQueryABC
+from bot_graphql.filter.user_filter import UserFilter
+
+
+class ServerQuery(DataQueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+        auto_roles: AutoRoleRepositoryABC,
+        clients: ClientRepositoryABC,
+        users: UserRepositoryABC,
+        levels: LevelRepositoryABC,
+    ):
+        DataQueryABC.__init__(self, "Server")
+
+        self._bot = bot
+        self._auto_roles = auto_roles
+        self._users = users
+        self._clients = clients
+        self._users = users
+        self._levels = levels
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discord_id", self.resolve_discord_id)
+        self.set_field("name", self.resolve_name)
+
+        self._add_collection(
+            "auto_role", lambda server, *_: self._auto_roles.get_auto_roles_by_server_id(server.server_id)
+        )
+        self._add_collection("client", lambda server, *_: self._clients.get_clients_by_server_id(server.server_id))
+        self._add_collection(
+            "user", lambda server, *_: self._users.get_users_by_server_id(server.server_id), UserFilter
+        )
+        self._add_collection("level", lambda server, *_: self._levels.get_levels_by_server_id(server.server_id))
+
+    @staticmethod
+    def resolve_id(server: Server, *_):
+        return server.server_id
+
+    @staticmethod
+    def resolve_discord_id(server: Server, *_):
+        return server.discord_server_id
+
+    def resolve_name(self, server: Server, *_):
+        guild = self._bot.get_guild(server.discord_server_id)
+        return None if guild is None else guild.name

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

@@ -0,0 +1,33 @@
+from bot_data.model.user_joined_server import UserJoinedServer
+from bot_graphql.abc.data_query_abc import DataQueryABC
+
+
+class UserJoinedServerQuery(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("server", self.resolve_server)
+        self.set_field("joined_on", self.resolve_joined_on)
+        self.set_field("leaved_on", self.resolve_leaved_on)
+
+    @staticmethod
+    def resolve_id(x: UserJoinedServer, *_):
+        return x.join_id
+
+    @staticmethod
+    def resolve_user(x: UserJoinedServer, *_):
+        return x.user
+
+    @staticmethod
+    def resolve_server(x: UserJoinedServer, *_):
+        return x.user.server
+
+    @staticmethod
+    def resolve_joined_on(x: UserJoinedServer, *_):
+        return x.joined_on
+
+    @staticmethod
+    def resolve_leaved_on(x: UserJoinedServer, *_):
+        return x.leaved_on

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

@@ -0,0 +1,38 @@
+from bot_data.model.user_joined_voice_channel import UserJoinedVoiceChannel
+from bot_graphql.abc.data_query_abc import DataQueryABC
+
+
+class UserJoinedVoiceChannelQuery(DataQueryABC):
+    def __init__(self):
+        DataQueryABC.__init__(self, "UserJoinedVoiceChannel")
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("channel_id", self.resolve_channel_id)
+        self.set_field("user", self.resolve_user)
+        self.set_field("server", self.resolve_server)
+        self.set_field("joined_on", self.resolve_joined_on)
+        self.set_field("leaved_on", self.resolve_leaved_on)
+
+    @staticmethod
+    def resolve_id(x: UserJoinedVoiceChannel, *_):
+        return x.join_id
+
+    @staticmethod
+    def resolve_channel_id(x: UserJoinedVoiceChannel, *_):
+        return x.dc_channel_id
+
+    @staticmethod
+    def resolve_user(x: UserJoinedVoiceChannel, *_):
+        return x.user
+
+    @staticmethod
+    def resolve_server(x: UserJoinedVoiceChannel, *_):
+        return x.user.server
+
+    @staticmethod
+    def resolve_joined_on(x: UserJoinedVoiceChannel, *_):
+        return x.joined_on
+
+    @staticmethod
+    def resolve_leaved_on(x: UserJoinedVoiceChannel, *_):
+        return x.leaved_on

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

@@ -0,0 +1,67 @@
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_core.abc.client_utils_abc import ClientUtilsABC
+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.model.user import User
+from bot_graphql.abc.data_query_abc import DataQueryABC
+from modules.level.service.level_service import LevelService
+
+
+class UserQuery(DataQueryABC):
+    def __init__(
+        self,
+        bot: DiscordBotServiceABC,
+        levels: LevelService,
+        client_utils: ClientUtilsABC,
+        ujs: UserJoinedServerRepositoryABC,
+        ujvs: UserJoinedVoiceChannelRepositoryABC,
+    ):
+        DataQueryABC.__init__(self, "User")
+
+        self._bot = bot
+        self._levels = levels
+        self._client_utils = client_utils
+        self._ujs = ujs
+        self._ujvs = ujvs
+
+        self.set_field("id", self.resolve_id)
+        self.set_field("discord_id", self.resolve_discord_id)
+        self.set_field("name", self.resolve_name)
+        self.set_field("xp", self.resolve_xp)
+        self.set_field("ontime", self.resolve_ontime)
+        self.set_field("level", self.resolve_level)
+        self._add_collection(
+            "joined_server", lambda user, *_: self._ujs.get_user_joined_servers_by_user_id(user.user_id)
+        )
+        self._add_collection(
+            "joined_voice_channel", lambda user, *_: self._ujvs.get_user_joined_voice_channels_by_user_id(user.user_id)
+        )
+        self.set_field("server", self.resolve_server)
+
+    @staticmethod
+    def resolve_id(user: User, *_):
+        return user.user_id
+
+    @staticmethod
+    def resolve_discord_id(user: User, *_):
+        return user.discord_id
+
+    def resolve_name(self, user: User, *_):
+        guild = self._bot.get_guild(user.server.discord_server_id)
+        user = guild.get_member(user.discord_id)
+        return None if user is None else user.name
+
+    @staticmethod
+    def resolve_xp(user: User, *_):
+        return user.xp
+
+    def resolve_ontime(self, user: User, *_):
+        return self._client_utils.get_ontime_for_user(user)
+
+    def resolve_level(self, user: User, *_):
+        return self._levels.get_level(user)
+
+    @staticmethod
+    def resolve_server(user: User, *_):
+        return user.server

kdb-bot/src/bot_graphql/query.py

@@ -0,0 +1,49 @@
+from bot_data.abc.auto_role_repository_abc import AutoRoleRepositoryABC
+from bot_data.abc.client_repository_abc import ClientRepositoryABC
+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.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_graphql.abc.query_abc import QueryABC
+from bot_graphql.filter.auto_role_filter import AutoRoleFilter
+from bot_graphql.filter.auto_role_rule_filter import AutoRoleRuleFilter
+from bot_graphql.filter.level_filter import LevelFilter
+from bot_graphql.filter.server_filter import ServerFilter
+from bot_graphql.filter.user_filter import UserFilter
+
+
+class Query(QueryABC):
+    def __init__(
+        self,
+        auto_roles: AutoRoleRepositoryABC,
+        clients: ClientRepositoryABC,
+        known_users: KnownUserRepositoryABC,
+        levels: LevelRepositoryABC,
+        servers: ServerRepositoryABC,
+        user_joined_servers: UserJoinedServerRepositoryABC,
+        user_joined_voice_channel: UserJoinedVoiceChannelRepositoryABC,
+        users: UserRepositoryABC,
+    ):
+        QueryABC.__init__(self, "Query")
+        self._auto_roles = auto_roles
+        self._clients = clients
+        self._known_users = known_users
+        self._levels = levels
+        self._servers = servers
+        self._user_joined_servers = user_joined_servers
+        self._user_joined_voice_channels = user_joined_voice_channel
+        self._users = users
+
+        self._add_collection("auto_role", lambda *_: self._auto_roles.get_auto_roles(), AutoRoleFilter)
+        self._add_collection("auto_role_rule", lambda *_: self._auto_roles.get_auto_role_rules(), AutoRoleRuleFilter)
+        self._add_collection("client", lambda *_: self._clients.get_clients())
+        self._add_collection("known_user", lambda *_: self._known_users.get_users())
+        self._add_collection("level", lambda *_: self._levels.get_levels(), LevelFilter)
+        self._add_collection("server", lambda *_: self._servers.get_servers(), ServerFilter)
+        self._add_collection("user_joined_server", lambda *_: self._user_joined_servers.get_user_joined_servers())
+        self._add_collection(
+            "user_joined_voice_channel", lambda *_: self._user_joined_voice_channels.get_user_joined_voice_channels()
+        )
+        self._add_collection("user", lambda *_: self._users.get_users(), UserFilter)

kdb-bot/src/bot_graphql/schema.py

@@ -0,0 +1,18 @@
+import os
+
+from ariadne import make_executable_schema, load_schema_from_path
+from graphql import GraphQLSchema
+
+from bot_graphql.abc.query_abc import QueryABC
+from bot_graphql.mutation import Mutation
+from bot_graphql.query import Query
+
+
+class Schema:
+    def __init__(self, query: Query, mutation: Mutation, queries: list[QueryABC]):
+        type_defs = load_schema_from_path(os.path.join(os.path.dirname(os.path.realpath(__file__)), "model/"))
+        self._schema = make_executable_schema(type_defs, query, mutation, *queries)
+
+    @property
+    def schema(self) -> GraphQLSchema:
+        return self._schema