[WIP] Added basic commands & functionality of Gismo@0.4.10

src/bot_core/__init__.py

@@ -1 +1,26 @@
+# -*- coding: utf-8 -*-
+
+"""
+bot-core Keksdose bot - core
+~~~~~~~~~~~~~~~~~~~
+
+Discord bot  for the Keksdose discord Server - core package
+
+:copyright: (c) 2022 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = 'bot_core'
+__author__ = 'Sven Heidemann'
+__license__ = 'MIT'
+__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
+__version__ = '1.0.0.dev1'
+
+from collections import namedtuple
+
+
 # imports: 
+
+VersionInfo = namedtuple('VersionInfo', 'major minor micro')
+version_info = VersionInfo(major='1', minor='0', micro='0.dev1')

src/bot_core/abc/client_utils_service_abc.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+
+
+class ClientUtilsServiceABC(ABC):
+
+    @abstractmethod
+    def __init__(self): pass
+
+    @abstractmethod
+    def received_command(self, guild_id: int): pass
+
+    @abstractmethod
+    def moved_user(self, guild_id: int): pass
+
+    @abstractmethod
+    def get_client(self, dc_ic: int, guild_id: int): pass

src/bot_core/abc/message_service_abc.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+from typing import Union
+
+import discord
+from cpl_query.extension import List
+from discord.ext.commands import Context
+
+
+class MessageServiceABC(ABC):
+
+    @abstractmethod
+    def __init__(self): pass
+    
+    @abstractmethod
+    async def delete_messages(self, messages: List[discord.Message], guild_id: int): pass
+    
+    @abstractmethod
+    async def delete_message(self, message: discord.Message): pass
+    
+    @abstractmethod
+    async def send_channel_message(self, channel: discord.TextChannel, message: Union[str, discord.Embed]): pass
+    
+    @abstractmethod
+    async def send_dm_message(self, message: Union[str, discord.Embed], receiver: Union[discord.User, discord.Member]): pass
+    
+    @abstractmethod
+    async def send_ctx_msg(self, ctx: Context, message: Union[str, discord.Embed], file: discord.File = None, is_persistent: bool = False, wait_before_delete: int = None): pass

src/bot_core/configuration/bot_settings.py

@@ -0,0 +1,32 @@
+import traceback
+
+from cpl_core.configuration import ConfigurationModelABC
+from cpl_core.console import Console
+from cpl_query.extension import List
+
+from bot_core.configuration.server_settings import ServerSettings
+
+
+class BotSettings(ConfigurationModelABC):
+
+    def __init__(self):
+        ConfigurationModelABC.__init__(self)
+
+        self._servers: List[ServerSettings] = List()
+    
+    @property
+    def servers(self) -> List[ServerSettings]:
+        return self._servers
+
+    def from_dict(self, settings: dict):
+        try:
+            servers = List(ServerSettings)
+            for s in settings:
+                st = ServerSettings()
+                settings[s]['Id'] = s
+                st.from_dict(settings[s])
+                servers.append(st)
+            self._servers = servers
+        except Exception as e:
+            Console.error(f'[ ERROR ] [ {__name__} ]: Reading error in {type(self).__name__} settings')
+            Console.error(f'[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}')

src/bot_core/configuration/server_settings.py

@@ -0,0 +1,29 @@
+import traceback
+
+from cpl_core.configuration.configuration_model_abc import ConfigurationModelABC
+from cpl_core.console import Console
+
+
+class ServerSettings(ConfigurationModelABC):
+
+    def __init__(self):
+        ConfigurationModelABC.__init__(self)
+
+        self._id: int = 0
+        self._message_delete_timer: int = 0
+
+    @property
+    def id(self) -> int:
+        return self._id
+
+    @property
+    def message_delete_timer(self) -> int:
+        return self._message_delete_timer
+
+    def from_dict(self, settings: dict):
+        try:
+            self._id = int(settings['Id'])
+            self._message_delete_timer = int(settings['MessageDeleteTimer'])
+        except Exception as e:
+            Console.error(f'[ ERROR ] [ {__name__} ]: Reading error in settings')
+            Console.error(f'[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}')

src/bot_core/service/client_utils_service.py

@@ -0,0 +1,42 @@
+from cpl_core.database.context import DatabaseContextABC
+
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_core.abc.client_utils_service_abc import ClientUtilsServiceABC
+from bot_data.abc.client_repository_abc import ClientRepositoryABC
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+
+
+class ClientUtilsService(ClientUtilsServiceABC):
+
+    def __init__(
+            self,
+            bot: DiscordBotServiceABC,
+            servers: ServerRepositoryABC,
+            clients: ClientRepositoryABC,
+            db: DatabaseContextABC
+    ):
+        ClientUtilsServiceABC.__init__(self)
+        self._bot = bot
+        self._servers = servers
+        self._clients = clients
+        self._db = db
+
+    def received_command(self, guild_id: int):
+        server = self._servers.get_server_by_discord_id(guild_id)
+        client = self._clients.find_client_by_discord_id_and_server_id(self._bot.user.id, server.server_id)
+        client.received_command_count += 1
+        self._clients.update_client(client)
+        self._db.save_changes()
+
+    def moved_user(self, guild_id: int):
+        server = self._servers.get_server_by_discord_id(guild_id)
+        client = self._clients.find_client_by_discord_id_and_server_id(self._bot.user.id, server.server_id)
+        client.moved_users_count += 1
+        self._clients.update_client(client)
+        self._db.save_changes()
+
+    def get_client(self, dc_ic: int, guild_id: int):
+        server = self._servers.get_server_by_discord_id(guild_id)
+        client = self._clients.find_client_by_discord_id_and_server_id(self._bot.user.id, server.server_id)
+        return client

src/bot_core/service/message_service.py

@@ -0,0 +1,105 @@
+import asyncio
+from typing import Union
+
+import discord
+from cpl_core.configuration.configuration_abc import ConfigurationABC
+from cpl_core.database.context.database_context_abc import DatabaseContextABC
+from cpl_core.logging import LoggerABC
+from cpl_discord.service import DiscordBotServiceABC
+from cpl_query.extension import List
+from discord.ext.commands import Context
+
+from bot_core.abc.message_service_abc import MessageServiceABC
+from bot_core.configuration.server_settings import ServerSettings
+from bot_data.abc.client_repository_abc import ClientRepositoryABC
+
+
+class MessageService(MessageServiceABC):
+
+    def __init__(self, config: ConfigurationABC, logger: LoggerABC, bot: DiscordBotServiceABC, clients: ClientRepositoryABC, db: DatabaseContextABC):
+        self._config = config
+        self._logger = logger
+        self._bot = bot
+        self._clients = clients
+        self._db = db
+    
+    async def delete_messages(self, messages: List[discord.Message], guild_id: int):
+        self._logger.debug(__name__, f'Try to delete {messages.count()} messages')
+        server_st: ServerSettings = self._config.get_configuration(f'ServerSettings_{guild_id}')
+        await asyncio.sleep(server_st.message_delete_timer)
+        for message in messages:
+            await self.delete_message(message, mass_delete=True)
+        self._logger.debug(__name__, 'Deleting messages finished')
+        
+    async def delete_message(self, message: discord.Message, mass_delete=False):
+        server_st: ServerSettings = self._config.get_configuration(f'ServerSettings_{message.guild.id}')
+        if not mass_delete:
+            await asyncio.sleep(server_st.message_delete_timer)
+        self._logger.debug(__name__, f'Try to delete message:\n\t{message}\n\t{message.content}')
+        guild_id = message.guild.id
+        try:
+            await message.delete()
+        except Exception as e:
+            self._logger.error(__name__, f'Deleting message failed', e)
+        else:
+            self._clients.append_deleted_message_count(self._bot.user.id, guild_id, 1)
+            self._db.save_changes()
+            self._logger.info(__name__, f'Deleted message {message}')
+    
+    async def send_channel_message(self, channel: discord.TextChannel, message: Union[str, discord.Embed]):
+        self._logger.debug(__name__, f'Try to send message\n\t{message}\n\tto: {channel}')
+        msg = None
+        try:
+            if isinstance(message, discord.Embed):
+                msg = await channel.send(embed=message)
+            else:
+                msg = await channel.send(message)
+        except Exception as e:
+            self._logger.error(__name__, f'Send message to channel {channel.id} failed', e)
+        else:
+            self._logger.info(__name__, f'Sent message to channel {channel.id}')
+            self._clients.append_sent_message_count(self._bot.user.id, channel.guild.id, 1)
+            self._db.save_changes()
+            await self.delete_message(msg)
+    
+    async def send_dm_message(self, message: Union[str, discord.Embed], receiver: Union[discord.User, discord.Member]):
+        self._logger.debug(__name__, f'Try to send message\n\t{message}\n\tto: {receiver}')
+        try:
+            if isinstance(message, discord.Embed):
+                msg = await receiver.send(embed=message)
+            else:
+                msg = await receiver.send(message)
+        except Exception as e:
+            self._logger.error(__name__, f'Send message to user {receiver.id} failed', e)
+        else:
+            self._clients.append_sent_message_count(self._bot.user.id, receiver.guild.id, 1)
+            self._db.save_changes()
+            self._logger.info(__name__, f'Sent message to user {receiver.id}')
+    
+    async def send_ctx_msg(self, ctx: Context, message: Union[str, discord.Embed], file: discord.File = None, is_persistent: bool = False, wait_before_delete: int = None):
+        if ctx is None:
+            self._logger.warn(__name__, 'Message context is empty')
+            self._logger.debug(__name__, f'Message: {message}')
+            return
+        
+        self._logger.debug(__name__, f'Try to send message\t\t{message}\n\tto: {ctx.channel}')
+        msg = None
+        try:
+            if isinstance(message, discord.Embed):
+                msg = await ctx.send(embed=message, file=file)
+            else:
+                msg = await ctx.send(message, file=file)
+        except Exception as e:
+            self._logger.error(__name__, f'Send message to channel {ctx.channel.id} failed', e)
+        else:
+            self._logger.info(__name__, f'Sent message to channel {ctx.channel.id}')
+            self._clients.append_sent_message_count(self._bot.user.id, ctx.guild.id, 1)
+            self._db.save_changes()
+            if wait_before_delete is not None:
+                await asyncio.sleep(wait_before_delete)
+
+            if is_persistent:
+                await self.delete_message(ctx.message)
+                return
+
+            await self.delete_messages(List(discord.Message, [msg, ctx.message]), ctx.guild.id)