kdb-bot/src/bot/bot.json

@@ -28,9 +28,7 @@
       "Flask-SocketIO==5.3.2",
       "eventlet==0.33.2",
       "requests-oauthlib==1.3.1",
-      "icmplib==3.0.3",
-      "ariadne==0.17.0",
-      "ariadne-graphql-modules==0.7.0"
+      "icmplib==3.0.3"
     ],
     "DevDependencies": [
       "cpl-cli==2022.12.0"

kdb-bot/src/bot/config

@@ -1 +1 @@
-Subproject commit 64a551bcee7fbfb06ee724355b48baec1c8e8e3e
+Subproject commit f15e3ff82709bbd274b0645c2b13a482f67f75ff

kdb-bot/src/bot_api/api.py

@@ -1,3 +1,4 @@
+import re
 import sys
 import textwrap
 import uuid

kdb-bot/src/bot_api/api_module.py

@@ -14,7 +14,6 @@ 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
@@ -48,7 +47,6 @@ 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

@@ -1,44 +0,0 @@
-from ariadne import graphql_sync
-from ariadne.constants import PLAYGROUND_HTML
-from ariadne_graphql_modules import make_executable_schema
-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_data.abc.query_abc import QueryABC
-from bot_data.graphql.query import Query
-
-
-class GraphQLController:
-    BasePath = f'/api/graphql'
-
-    def __init__(
-            self,
-            config: ConfigurationABC,
-            env: ApplicationEnvironmentABC,
-            logger: ApiLogger,
-    ):
-        self._config = config
-        self._env = env
-        self._logger = logger
-
-    @Route.get(f'{BasePath}/playground')
-    async def playground(self):
-        return PLAYGROUND_HTML, 200
-
-    @Route.post(f'{BasePath}')
-    async def graphql(self):
-        QueryABC.init()
-        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(
-            make_executable_schema(Query),
-            data,
-            context_value=request
-        )
-
-        return jsonify(result), 200 if success else 400

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

@@ -1,64 +0,0 @@
-from ariadne_graphql_modules import ObjectType
-from cpl_core.dependency_injection import ServiceProviderABC
-from cpl_discord.service import DiscordBotServiceABC
-from cpl_query.extension import List
-
-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_abc import UserJoinedVoiceChannelRepositoryABC
-from bot_data.abc.user_repository_abc import UserRepositoryABC
-from bot_data.model.auto_role import AutoRole
-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.user import User
-from bot_data.model.user_joined_server import UserJoinedServer
-from bot_data.model.user_joined_voice_channel import UserJoinedVoiceChannel
-from modules.level.service.level_service import LevelService
-
-
-class QueryABC(ObjectType):
-    __abstract__ = True
-
-    _auto_roles: List[AutoRole]
-    _clients: List[Client]
-    _known_users: List[KnownUser]
-    _levels: List[Level]
-    _servers: List[Server]
-    _user_joined_servers: List[UserJoinedServer]
-    _user_joined_voice_channel: List[UserJoinedVoiceChannel]
-    _users: List[User]
-
-    _bot: DiscordBotServiceABC
-    _level_service: LevelService
-
-    @classmethod
-    @ServiceProviderABC.inject
-    def init(
-            cls,
-            auto_roles: AutoRoleRepositoryABC,
-            clients: ClientRepositoryABC,
-            known_users: KnownUserRepositoryABC,
-            levels: LevelRepositoryABC,
-            servers: ServerRepositoryABC,
-            user_joined_servers: UserJoinedServerRepositoryABC,
-            user_joined_voice_channel: UserJoinedVoiceChannelRepositoryABC,
-            users: UserRepositoryABC,
-            bot: DiscordBotServiceABC,
-            level_service: LevelService,
-    ):
-        cls._auto_roles = auto_roles.get_auto_roles()
-        cls._clients = clients.get_clients()
-        cls._known_users = known_users.get_users()
-        cls._levels = levels.get_levels()
-        cls._servers = servers.get_servers()
-        cls._user_joined_servers = user_joined_servers.get_user_joined_servers()
-        cls._user_joined_voice_channel = user_joined_voice_channel.get_user_joined_voice_channels()
-        cls._users = users.get_users()
-        cls._bot = bot
-        cls._level_service = level_service

kdb-bot/src/bot_data/graphql/model.gql

@@ -1,64 +0,0 @@
-type Query {
-    servers: [Server]
-    known_users: [User]
-}
-
-type Server {
-    id: ID
-    discord_id: String
-    clients: [Client]
-    members: [User]
-    level: [Level]
-}
-
-type Client {
-    id: ID
-    discord_id: String
-    sent_message_count: Int
-    received_message_count: Int
-    deleted_message_count: Int
-    received_command_count: Int
-    moved_users_count: Int
-
-    server: Server
-}
-
-type User {
-    id: ID
-    discord_id: String
-    name: String
-    xp: Int
-    ontime: Int
-    level: Level
-
-    joined_servers: [UserJoinedServer]
-    joined_voice_channel: [UserJoinedVoiceChannel]
-
-    server: Server
-}
-
-type UserJoinedServer {
-    id: ID
-    user: User
-    server: Server
-    joined_on: String
-    leaved_on: String
-}
-
-type UserJoinedVoiceChannel {
-    id: ID
-    channel_id: String
-    user: User
-    joined_on: String
-    leaved_on: String
-}
-
-type Level {
-    id: ID
-    name: String
-    color: String
-    min_xp: Int
-    permissions: String
-
-    server: Server
-}

kdb-bot/src/bot_data/graphql/query.py

@@ -1,17 +0,0 @@
-from ariadne import gql
-
-from bot_data.abc.query_abc import QueryABC
-from bot_data.graphql.types.server_query_type import ServerQueryType
-
-
-class Query(QueryABC):
-    __schema__ = gql("""
-        type Query {
-            servers: [Server]
-        }
-    """)
-    __requires__ = [ServerQueryType]
-
-    @classmethod
-    def resolve_servers(cls, *_):
-        return cls._servers

kdb-bot/src/bot_data/graphql/types/client_query_type.py

@@ -1,22 +0,0 @@
-from ariadne import gql
-
-from bot_data.abc.query_abc import QueryABC
-from bot_data.model.client import Client
-
-
-class ClientQueryType(QueryABC):
-    __schema__ = gql("""
-        type Client {
-            id: ID
-            discord_id: String
-            sent_message_count: Int
-            received_message_count: Int
-            deleted_message_count: Int
-            received_command_count: Int
-            moved_users_count: Int
-        }
-    """)
-
-    @classmethod
-    def resolve_id(cls, client: Client, *_):
-        return client.client_id

kdb-bot/src/bot_data/graphql/types/level_query_type.py

@@ -1,21 +0,0 @@
-from ariadne import gql
-
-from bot_data.abc.query_abc import QueryABC
-from bot_data.model.client import Client
-from bot_data.model.level import Level
-
-
-class LevelQueryType(QueryABC):
-    __schema__ = gql("""
-        type Level {
-            id: ID
-            name: String
-            color: String
-            min_xp: Int
-            permissions: String
-        }
-    """)
-
-    # @classmethod
-    # def resolve_id(cls, level: Level, *_):
-    #     return level.id

kdb-bot/src/bot_data/graphql/types/server_query_type.py

@@ -1,40 +0,0 @@
-from ariadne import gql
-
-from bot_data.abc.query_abc import QueryABC
-from bot_data.graphql.types.client_query_type import ClientQueryType
-from bot_data.graphql.types.level_query_type import LevelQueryType
-from bot_data.graphql.types.user_query_type import UserQueryType
-from bot_data.model.server import Server
-
-
-class ServerQueryType(QueryABC):
-    __schema__ = gql("""
-        type Server {
-            id: ID
-            discord_id: String
-            clients: [Client]
-            users: [User]
-            levels: [Level]
-        }
-    """)
-    __requires__ = [ClientQueryType, UserQueryType, LevelQueryType]
-
-    @classmethod
-    def resolve_id(cls, server: Server, *_):
-        return server.server_id
-
-    @classmethod
-    def resolve_discord_id(cls, server: Server, *_):
-        return server.discord_server_id
-
-    @classmethod
-    def resolve_clients(cls, server: Server, *_):
-        return cls._clients.where(lambda c: c.server.server_id == server.server_id)
-
-    @classmethod
-    def resolve_users(cls, server: Server, *_):
-        return cls._users.where(lambda u: u.server.server_id == server.server_id)
-
-    @classmethod
-    def resolve_levels(cls, server: Server, *_):
-        return cls._levels.where(lambda l: l.server.server_id == server.server_id)

kdb-bot/src/bot_data/graphql/types/user_query_type.py

@@ -1,39 +0,0 @@
-from ariadne import gql
-
-from bot_data.abc.query_abc import QueryABC
-from bot_data.graphql.types.level_query_type import LevelQueryType
-from bot_data.model.user import User
-
-
-class UserQueryType(QueryABC):
-    __schema__ = gql("""
-        type User {
-            id: ID
-            discord_id: String
-            name: String
-            xp: Int
-            ontime: Int
-            level: Level
-        }
-    """)
-    __requires__ = [LevelQueryType]
-
-    @classmethod
-    def resolve_id(cls, user: User, *_):
-        return user.user_id
-
-    @classmethod
-    def resolve_name(cls, user: User, *_):
-        return cls._bot.get_user(user.discord_id).name
-
-    @classmethod
-    def resolve_ontime(cls, user: User, *_):
-        return cls._user_joined_voice_channel.where(lambda ujvc: ujvc.user.user_id == user.user_id) \
-            .where(lambda x: x.leaved_on is not None and x.joined_on is not None) \
-            .sum(lambda join: round((join.leaved_on - join.joined_on).total_seconds() / 3600, 2))
-
-    @classmethod
-    def resolve_level(cls, user: User, *_):
-        levels = cls._levels.where(lambda l: l.server.server_id == user.server.server_id).order_by(lambda l: l.min_xp)
-        return levels.where(lambda l: user.xp >= l.min_xp).last_or_default()
-    

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

@@ -33,8 +33,6 @@ class ClientRepositoryService(ClientRepositoryABC):
                 result[5],
                 result[6],
                 self._servers.get_server_by_id(result[7]),
-                result[8],
-                result[9],
                 id=result[0]
             ))
 
@@ -51,8 +49,6 @@ class ClientRepositoryService(ClientRepositoryABC):
             result[5],
             result[6],
             self._servers.get_server_by_id(result[7]),
-            result[8],
-            result[9],
             id=result[0]
         )
 
@@ -67,8 +63,6 @@ class ClientRepositoryService(ClientRepositoryABC):
             result[5],
             result[6],
             self._servers.get_server_by_id(result[7]),
-            result[8],
-            result[9],
             id=result[0]
         )
 
@@ -77,9 +71,9 @@ class ClientRepositoryService(ClientRepositoryABC):
         result = self._context.select(Client.get_select_by_discord_id_string(discord_id))
         if result is None or len(result) == 0:
             return None
-
+        
         result = result[0]
-
+        
         return Client(
             result[1],
             result[2],
@@ -88,8 +82,6 @@ class ClientRepositoryService(ClientRepositoryABC):
             result[5],
             result[6],
             self._servers.get_server_by_id(result[7]),
-            result[8],
-            result[9],
             id=result[0]
         )
 
@@ -98,9 +90,9 @@ class ClientRepositoryService(ClientRepositoryABC):
         result = self._context.select(Client.get_select_by_server_id_string(discord_id))
         if result is None or len(result) == 0:
             return None
-
+        
         result = result[0]
-
+        
         return Client(
             result[1],
             result[2],
@@ -109,8 +101,6 @@ class ClientRepositoryService(ClientRepositoryABC):
             result[5],
             result[6],
             self._servers.get_server_by_id(result[7]),
-            result[8],
-            result[9],
             id=result[0]
         )
 
@@ -119,9 +109,9 @@ class ClientRepositoryService(ClientRepositoryABC):
         result = self._context.select(Client.get_select_by_discord_id_and_server_id_string(discord_id, server_id))
         if result is None or len(result) == 0:
             return None
-
+        
         result = result[0]
-
+        
         return Client(
             result[1],
             result[2],
@@ -130,19 +120,17 @@ class ClientRepositoryService(ClientRepositoryABC):
             result[5],
             result[6],
             self._servers.get_server_by_id(result[7]),
-            result[8],
-            result[9],
             id=result[0]
         )
-
+    
     def add_client(self, client: Client):
         self._logger.trace(__name__, f'Send SQL command: {client.insert_string}')
         self._context.cursor.execute(client.insert_string)
-
+    
     def update_client(self, client: Client):
         self._logger.trace(__name__, f'Send SQL command: {client.udpate_string}')
         self._context.cursor.execute(client.udpate_string)
-
+    
     def delete_client(self, client: Client):
         self._logger.trace(__name__, f'Send SQL command: {client.delete_string}')
         self._context.cursor.execute(client.delete_string)
@@ -152,12 +140,12 @@ class ClientRepositoryService(ClientRepositoryABC):
         if server is None:
             self._logger.warn(__name__, f'Cannot find server by id {server_id}')
             raise Exception('Value not found')
-
+        
         client = self.find_client_by_discord_id_and_server_id(id, server.server_id)
         if client is None:
             self._logger.warn(__name__, f'Cannot find client by ids {id}@{server.server_id}')
             raise Exception('Value not found')
-
+        
         return client
 
     def append_sent_message_count(self, client_id: int, server_id: int, value: int):

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

@@ -25,8 +25,6 @@ class ServerRepositoryService(ServerRepositoryABC):
         for result in results:
             servers.append(Server(
                 result[1],
-                result[2],
-                result[3],
                 id=result[0]
             ))
 
@@ -57,8 +55,6 @@ class ServerRepositoryService(ServerRepositoryABC):
         result = self._context.select(Server.get_select_by_id_string(server_id))[0]
         return Server(
             result[1],
-            result[2],
-            result[3],
             id=result[0]
         )
 
@@ -67,8 +63,6 @@ class ServerRepositoryService(ServerRepositoryABC):
         result = self._context.select(Server.get_select_by_discord_id_string(discord_id))[0]
         return Server(
             result[1],
-            result[2],
-            result[3],
             id=result[0]
         )
 
@@ -77,24 +71,24 @@ class ServerRepositoryService(ServerRepositoryABC):
         result = self._context.select(Server.get_select_by_discord_id_string(discord_id))
         if result is None or len(result) == 0:
             return None
-
+        
         result = result[0]
-
+        
         return Server(
             result[1],
             result[2],
             result[3],
             id=result[0]
         )
-
+    
     def add_server(self, server: Server):
         self._logger.trace(__name__, f'Send SQL command: {server.insert_string}')
         self._context.cursor.execute(server.insert_string)
-
+    
     def update_server(self, server: Server):
         self._logger.trace(__name__, f'Send SQL command: {server.udpate_string}')
         self._context.cursor.execute(server.udpate_string)
-
+    
     def delete_server(self, server: Server):
         self._logger.trace(__name__, f'Send SQL command: {server.delete_string}')
         self._context.cursor.execute(server.delete_string)