sh-edraft.de/sh_discord_bot
5
1
Fork 1
Code Issues 26 Pull Requests Actions Packages Projects 3 Releases 27 Wiki Activity

Formatted files with black

Browse Source
This commit is contained in:
Sven Heidemann
2023-01-13 23:35:42 +01:00
parent 37ec0cf0c7
commit e2b2fb5abb
252 changed files with 6085 additions and 3791 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
kdb-bot/src/modules/base/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.base'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.base"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports
VersionInfo = namedtuple('VersionInfo', 'major minor micro')
version_info = VersionInfo(major='0', minor='3', micro='0')
VersionInfo = namedtuple("VersionInfo", "major minor micro")
version_info = VersionInfo(major="0", minor="3", micro="0")

14
kdb-bot/src/modules/base/abc/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.base.abc'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.base.abc"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
VersionInfo = namedtuple('VersionInfo', 'major minor micro')
version_info = VersionInfo(major='0', minor='3', micro='0')
VersionInfo = namedtuple("VersionInfo", "major minor micro")
version_info = VersionInfo(major="0", minor="3", micro="0")

4
kdb-bot/src/modules/base/abc/base_helper_abc.py
View File

@@ -4,9 +4,9 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class BaseHelperABC(ABC):
def __init__(self):
ABC.__init__(self)
@abstractmethod
def get_config(self, g_id: int) -> BaseServerSettings: pass
def get_config(self, g_id: int) -> BaseServerSettings:
pass

52
kdb-bot/src/modules/base/base_module.py
View File

@@ -23,21 +23,28 @@ from modules.base.events.base_on_message_delete_event import BaseOnMessageDelete
from modules.base.events.base_on_message_event import BaseOnMessageEvent
from modules.base.events.base_on_raw_reaction_add import BaseOnRawReactionAddEvent
from modules.base.events.base_on_raw_reaction_remove import BaseOnRawReactionRemoveEvent
from modules.base.events.base_on_voice_state_update_event import BaseOnVoiceStateUpdateEvent
from modules.base.events.base_on_voice_state_update_event_help_channel import BaseOnVoiceStateUpdateEventHelpChannel
from modules.base.events.base_on_voice_state_update_event import (
BaseOnVoiceStateUpdateEvent,
)
from modules.base.events.base_on_voice_state_update_event_help_channel import (
BaseOnVoiceStateUpdateEventHelpChannel,
)
from modules.base.helper.base_reaction_handler import BaseReactionHandler
from modules.base.service.base_helper_service import BaseHelperService
class BaseModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.base_module)
def configure_configuration(self, config: ConfigurationABC, env: ApplicationEnvironmentABC):
def configure_configuration(
self, config: ConfigurationABC, env: ApplicationEnvironmentABC
):
pass
def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
def configure_services(
self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
):
services.add_transient(BaseHelperABC, BaseHelperService)
services.add_transient(BaseReactionHandler)
# commands
@@ -52,12 +59,31 @@ class BaseModule(ModuleABC):
self._dc.add_command(UserGroup)
# events
self._dc.add_event(DiscordEventTypesEnum.on_command.value, BaseOnCommandEvent)
self._dc.add_event(DiscordEventTypesEnum.on_command_error.value, BaseOnCommandErrorEvent)
self._dc.add_event(DiscordEventTypesEnum.on_member_join.value, BaseOnMemberJoinEvent)
self._dc.add_event(DiscordEventTypesEnum.on_member_remove.value, BaseOnMemberRemoveEvent)
self._dc.add_event(
DiscordEventTypesEnum.on_command_error.value, BaseOnCommandErrorEvent
)
self._dc.add_event(
DiscordEventTypesEnum.on_member_join.value, BaseOnMemberJoinEvent
)
self._dc.add_event(
DiscordEventTypesEnum.on_member_remove.value, BaseOnMemberRemoveEvent
)
self._dc.add_event(DiscordEventTypesEnum.on_message.value, BaseOnMessageEvent)
self._dc.add_event(DiscordEventTypesEnum.on_message_delete.value, BaseOnMessageDeleteEvent)
self._dc.add_event(DiscordEventTypesEnum.on_raw_reaction_add.value, BaseOnRawReactionAddEvent)
self._dc.add_event(DiscordEventTypesEnum.on_raw_reaction_remove.value, BaseOnRawReactionRemoveEvent)
self._dc.add_event(DiscordEventTypesEnum.on_voice_state_update.value, BaseOnVoiceStateUpdateEvent)
self._dc.add_event(DiscordEventTypesEnum.on_voice_state_update.value, BaseOnVoiceStateUpdateEventHelpChannel)
self._dc.add_event(
DiscordEventTypesEnum.on_message_delete.value, BaseOnMessageDeleteEvent
)
self._dc.add_event(
DiscordEventTypesEnum.on_raw_reaction_add.value, BaseOnRawReactionAddEvent
)
self._dc.add_event(
DiscordEventTypesEnum.on_raw_reaction_remove.value,
BaseOnRawReactionRemoveEvent,
)
self._dc.add_event(
DiscordEventTypesEnum.on_voice_state_update.value,
BaseOnVoiceStateUpdateEvent,
)
self._dc.add_event(
DiscordEventTypesEnum.on_voice_state_update.value,
BaseOnVoiceStateUpdateEventHelpChannel,
)

14
kdb-bot/src/modules/base/command/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.base.command'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.base.command"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports
VersionInfo = namedtuple('VersionInfo', 'major minor micro')
version_info = VersionInfo(major='0', minor='3', micro='0')
VersionInfo = namedtuple("VersionInfo", "major minor micro")
version_info = VersionInfo(major="0", minor="3", micro="0")

48
kdb-bot/src/modules/base/command/afk_command.py
View File

@@ -14,15 +14,14 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class AFKCommand(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
config: ConfigurationABC,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe
self,
logger: CommandLogger,
config: ConfigurationABC,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
):
DiscordCommandABC.__init__(self)
@@ -33,27 +32,42 @@ class AFKCommand(DiscordCommandABC):
self._client_utils = client_utils
self._t = translate
self._logger.trace(__name__, f'Loaded command service: {type(self).__name__}')
self._logger.trace(__name__, f"Loaded command service: {type(self).__name__}")
@commands.hybrid_command()
@commands.guild_only()
@CommandChecks.check_is_ready()
async def afk(self, ctx: Context):
self._logger.debug(__name__, f'Received command afk {ctx}')
settings: BaseServerSettings = self._config.get_configuration(f'BaseServerSettings_{ctx.guild.id}')
self._logger.debug(__name__, f"Received command afk {ctx}")
settings: BaseServerSettings = self._config.get_configuration(
f"BaseServerSettings_{ctx.guild.id}"
)
if ctx.author.voice is None or ctx.author.voice.channel is None:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.base.afk_command_channel_missing_message'))
self._logger.trace(__name__, f'Finished afk command')
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.base.afk_command_channel_missing_message"),
)
self._logger.trace(__name__, f"Finished afk command")
return
self._bot.loop.create_task(self._message_service.send_ctx_msg(ctx, self._t.transform('modules.base.afk_command_move_message')))
self._bot.loop.create_task(
self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.afk_command_move_message")
)
)
channel: VoiceChannel = ctx.guild.get_channel(settings.afk_command_channel_id)
try:
await ctx.author.move_to(channel)
self._client_utils.moved_user(ctx.guild.id)
except Exception as e:
self._logger.error(__name__, f'Cannot move user {ctx.author.id} to channel {ctx.channel.id}', e)
await self._message_service.send_ctx_msg(ctx, self._t.transform('common.no_permission_message'))
self._logger.error(
__name__,
f"Cannot move user {ctx.author.id} to channel {ctx.channel.id}",
e,
)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.no_permission_message")
)
self._logger.trace(__name__, f'Finished afk command')
self._logger.trace(__name__, f"Finished afk command")

40
kdb-bot/src/modules/base/command/help_command.py
View File

@@ -16,14 +16,13 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class HelpCommand(DiscordCommandABC):
def __init__(
self,
config: ConfigurationABC,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC
self,
config: ConfigurationABC,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
):
DiscordCommandABC.__init__(self)
@@ -33,19 +32,28 @@ class HelpCommand(DiscordCommandABC):
self._bot = bot
self._client_utils = client_utils
self._logger.trace(__name__, f'Loaded command service: {type(self).__name__}')
self._logger.trace(__name__, f"Loaded command service: {type(self).__name__}")
@commands.hybrid_command()
@commands.guild_only()
@CommandChecks.check_is_ready()
async def help(self, ctx: Context, persistent_flag: str = None):
self._logger.debug(__name__, f'Received command help {ctx}:{persistent_flag}')
settings: BaseServerSettings = self._config.get_configuration(f'BaseServerSettings_{ctx.guild.id}')
is_persistent = persistent_flag == '--stay'
await self._message_service.send_ctx_msg(ctx, settings.help_command_reference_url, is_persistent=is_persistent, is_public=True)
self._logger.trace(__name__, f'Finished help command')
self._logger.debug(__name__, f"Received command help {ctx}:{persistent_flag}")
settings: BaseServerSettings = self._config.get_configuration(
f"BaseServerSettings_{ctx.guild.id}"
)
is_persistent = persistent_flag == "--stay"
await self._message_service.send_ctx_msg(
ctx,
settings.help_command_reference_url,
is_persistent=is_persistent,
is_public=True,
)
self._logger.trace(__name__, f"Finished help command")
@help.autocomplete('persistent_flag')
async def help_autocomplete(self, interaction: discord.Interaction, current: str) -> List[app_commands.Choice[str]]:
flags = ['--stay']
@help.autocomplete("persistent_flag")
async def help_autocomplete(
self, interaction: discord.Interaction, current: str
) -> List[app_commands.Choice[str]]:
flags = ["--stay"]
return [app_commands.Choice(name=key, value=key) for key in flags]

83
kdb-bot/src/modules/base/command/info_command.py
View File

@@ -16,15 +16,14 @@ from bot_core.logging.command_logger import CommandLogger
class InfoCommand(DiscordCommandABC):
def __init__(
self,
config: ConfigurationABC,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe
self,
config: ConfigurationABC,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
):
DiscordCommandABC.__init__(self)
@@ -35,34 +34,68 @@ class InfoCommand(DiscordCommandABC):
self._client_utils = client_utils
self._t = translate
self._logger.trace(__name__, f'Loaded command service: {type(self).__name__}')
self._logger.trace(__name__, f"Loaded command service: {type(self).__name__}")
@commands.hybrid_command()
@commands.guild_only()
@CommandChecks.check_is_ready()
async def info(self, ctx: Context, *, wait: int = None):
self._logger.debug(__name__, f'Received command info {ctx},{wait}')
self._logger.debug(__name__, f"Received command info {ctx},{wait}")
client = self._client_utils.get_client(self._bot.user.id, ctx.guild.id)
embed = discord.Embed(
title=self._t.transform('modules.base.info.title'),
description=self._t.transform('modules.base.info.description'),
color=int('ef9d0d', 16)
title=self._t.transform("modules.base.info.title"),
description=self._t.transform("modules.base.info.description"),
color=int("ef9d0d", 16),
)
embed.add_field(name=self._t.transform('modules.base.info.fields.version'), value=bot.__version__)
start_time = self._config.get_configuration('Bot_StartTime')
ontime = round((datetime.now() - datetime.strptime(start_time, '%Y-%m-%d %H:%M:%S.%f')).total_seconds() / 3600, 2)
embed.add_field(name=self._t.transform('modules.base.info.fields.ontime'), value=f'{ontime}h')
embed.add_field(name=self._t.transform('modules.base.info.fields.sent_message_count'), value=client.sent_message_count, inline=False)
embed.add_field(name=self._t.transform('modules.base.info.fields.received_message_count'), value=client.received_message_count)
embed.add_field(name=self._t.transform('modules.base.info.fields.deleted_message_count'), value=client.deleted_message_count, inline=False)
embed.add_field(name=self._t.transform('modules.base.info.fields.received_command_count'), value=client.received_command_count)
embed.add_field(name=self._t.transform('modules.base.info.fields.moved_users_count'), value=client.moved_users_count)
embed.add_field(
name=self._t.transform("modules.base.info.fields.version"),
value=bot.__version__,
)
start_time = self._config.get_configuration("Bot_StartTime")
ontime = round(
(
datetime.now() - datetime.strptime(start_time, "%Y-%m-%d %H:%M:%S.%f")
).total_seconds()
/ 3600,
2,
)
embed.add_field(
name=self._t.transform("modules.base.info.fields.ontime"),
value=f"{ontime}h",
)
embed.add_field(
name=self._t.transform("modules.base.info.fields.sent_message_count"),
value=client.sent_message_count,
inline=False,
)
embed.add_field(
name=self._t.transform("modules.base.info.fields.received_message_count"),
value=client.received_message_count,
)
embed.add_field(
name=self._t.transform("modules.base.info.fields.deleted_message_count"),
value=client.deleted_message_count,
inline=False,
)
embed.add_field(
name=self._t.transform("modules.base.info.fields.received_command_count"),
value=client.received_command_count,
)
embed.add_field(
name=self._t.transform("modules.base.info.fields.moved_users_count"),
value=client.moved_users_count,
)
from bot.module_list import ModuleList
modules = ModuleList.get_modules()
modules = modules.select(lambda x: x.__name__.replace('Module', ''))
embed.add_field(name=self._t.transform('modules.base.info.fields.modules'), value='\n'.join(modules), inline=False)
modules = modules.select(lambda x: x.__name__.replace("Module", ""))
embed.add_field(
name=self._t.transform("modules.base.info.fields.modules"),
value="\n".join(modules),
inline=False,
)
await self._message_service.send_ctx_msg(ctx, embed, wait_before_delete=wait)
self._logger.trace(__name__, f'Finished info command')
self._logger.trace(__name__, f"Finished info command")

38
kdb-bot/src/modules/base/command/mass_move_command.py
View File

@@ -14,14 +14,13 @@ from bot_core.service.client_utils_service import ClientUtilsService
class MassMoveCommand(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
translate: TranslatePipe,
client_utils: ClientUtilsService
self,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
translate: TranslatePipe,
client_utils: ClientUtilsService,
):
DiscordCommandABC.__init__(self)
self._logger = logger
@@ -30,15 +29,21 @@ class MassMoveCommand(DiscordCommandABC):
self._t = translate
self._client_utils = client_utils
@commands.hybrid_command(name='mass-move')
@commands.hybrid_command(name="mass-move")
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def mass_move(self, ctx: Context, channel_to: discord.VoiceChannel,
channel_from: discord.VoiceChannel = None):
self._logger.debug(__name__, f'Received command mass-move {ctx}')
async def mass_move(
self,
ctx: Context,
channel_to: discord.VoiceChannel,
channel_from: discord.VoiceChannel = None,
):
self._logger.debug(__name__, f"Received command mass-move {ctx}")
if channel_from is None and ctx.author.voice is None:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.base.mass_move.channel_from_error'))
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.mass_move.channel_from_error")
)
return
if channel_from is None:
@@ -49,6 +54,11 @@ class MassMoveCommand(DiscordCommandABC):
await asyncio.gather(*moves)
self._client_utils.moved_users(ctx.guild.id, move_count)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.base.mass_move.moved').format(channel_from.mention, channel_to.mention))
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.base.mass_move.moved").format(
channel_from.mention, channel_to.mention
),
)
self._logger.trace(__name__, f'Finished mass-move command')
self._logger.trace(__name__, f"Finished mass-move command")

44
kdb-bot/src/modules/base/command/ping_command.py
View File

@@ -16,17 +16,16 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class PingCommand(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
permissions: PermissionServiceABC,
base_helper: BaseHelperABC,
servers: ServerRepositoryABC,
self,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
permissions: PermissionServiceABC,
base_helper: BaseHelperABC,
servers: ServerRepositoryABC,
):
DiscordCommandABC.__init__(self)
@@ -39,11 +38,12 @@ class PingCommand(DiscordCommandABC):
self._base_helper = base_helper
self._servers = servers
self._logger.trace(__name__, f'Loaded command service: {type(self).__name__}')
self._logger.trace(__name__, f"Loaded command service: {type(self).__name__}")
@staticmethod
def _get_ping(url: str) -> float:
from icmplib import ping
ping_result = ping(url, count=4, interval=0.2, privileged=False)
return ping_result.avg_rtt
@@ -51,18 +51,24 @@ class PingCommand(DiscordCommandABC):
@commands.guild_only()
@CommandChecks.check_is_ready()
async def ping(self, ctx: Context):
self._logger.debug(__name__, f'Received command ping {ctx}')
self._logger.debug(__name__, f"Received command ping {ctx}")
if self._permissions.is_member_technician(ctx.author):
embed = discord.Embed(
title=self._t.transform('modules.base.info.title'),
description=self._t.transform('modules.base.info.description'),
color=int('ef9d0d', 16)
title=self._t.transform("modules.base.info.title"),
description=self._t.transform("modules.base.info.description"),
color=int("ef9d0d", 16),
)
server = self._servers.get_server_by_discord_id(ctx.guild.id)
settings: BaseServerSettings = self._base_helper.get_config(server.discord_server_id)
settings: BaseServerSettings = self._base_helper.get_config(
server.discord_server_id
)
for server in settings.ping_urls:
embed.add_field(name=server, value=f'{self._get_ping(server)} ms', inline=False)
embed.add_field(
name=server, value=f"{self._get_ping(server)} ms", inline=False
)
await self._message_service.send_ctx_msg(ctx, embed)
else:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.base.pong'))
self._logger.trace(__name__, f'Finished ping command')
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.pong")
)
self._logger.trace(__name__, f"Finished ping command")

31
kdb-bot/src/modules/base/command/presence_command.py
View File

@@ -11,13 +11,12 @@ from bot_core.logging.command_logger import CommandLogger
class PresenceCommand(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
translate: TranslatePipe,
self,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
translate: TranslatePipe,
):
DiscordCommandABC.__init__(self)
@@ -30,19 +29,25 @@ class PresenceCommand(DiscordCommandABC):
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def presence(self, ctx: Context, text: str = ''):
self._logger.debug(__name__, f'Received command presence {ctx}')
async def presence(self, ctx: Context, text: str = ""):
self._logger.debug(__name__, f"Received command presence {ctx}")
if text == '':
if text == "":
await self._bot.change_presence(activity=None)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.base.presence.removed'))
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.presence.removed")
)
return
if len(text) > 128:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.base.presence.max_char_count_exceeded'))
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.presence.max_char_count_exceeded")
)
return
await self._bot.change_presence(activity=discord.Game(name=text))
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.base.presence.changed'))
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.presence.changed")
)
self._logger.trace(__name__, f'Finished presence command')
self._logger.trace(__name__, f"Finished presence command")

35
kdb-bot/src/modules/base/command/purge_command.py
View File

@@ -15,15 +15,14 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class PurgeCommand(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
config: ConfigurationABC,
message_service: MessageServiceABC,
permissions: PermissionServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe
self,
logger: CommandLogger,
config: ConfigurationABC,
message_service: MessageServiceABC,
permissions: PermissionServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
):
DiscordCommandABC.__init__(self)
@@ -34,22 +33,28 @@ class PurgeCommand(DiscordCommandABC):
self._client_utils = client_utils
self._t = translate
self._logger.trace(__name__, f'Loaded command service: {type(self).__name__}')
self._logger.trace(__name__, f"Loaded command service: {type(self).__name__}")
@commands.hybrid_command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def purge(self, ctx: Context):
self._logger.debug(__name__, f'Received command purge {ctx}')
server_settings: ServerSettings = self._config.get_configuration(f'ServerSettings_{ctx.guild.id}')
self._logger.debug(__name__, f"Received command purge {ctx}")
server_settings: ServerSettings = self._config.get_configuration(
f"ServerSettings_{ctx.guild.id}"
)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.moderator.purge_message'))
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.moderator.purge_message")
)
await asyncio.sleep(server_settings.message_delete_timer)
try:
await ctx.channel.purge()
except Exception as e:
self._logger.error(__name__, f'Cannot purge channel {ctx.channel.id}', e)
await self._message_service.send_ctx_msg(ctx, self._t.transform('common.bot_has_no_permission_message'))
self._logger.error(__name__, f"Cannot purge channel {ctx.channel.id}", e)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.bot_has_no_permission_message")
)
self._logger.trace(__name__, f'Finished purge command')
self._logger.trace(__name__, f"Finished purge command")

296
kdb-bot/src/modules/base/command/user_group.py
View File

@@ -17,30 +17,31 @@ from bot_core.logging.command_logger import CommandLogger
from bot_core.pipes.date_time_offset_pipe import DateTimeOffsetPipe
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_joined_voice_channel_repository_abc import (
UserJoinedVoiceChannelRepositoryABC,
)
from bot_data.abc.user_repository_abc import UserRepositoryABC
from modules.level.service.level_service import LevelService
from modules.permission.abc.permission_service_abc import PermissionServiceABC
class UserGroup(DiscordCommandABC):
def __init__(
self,
config: ConfigurationABC,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
permissions: PermissionServiceABC,
servers: ServerRepositoryABC,
db: DatabaseContextABC,
users: UserRepositoryABC,
user_joined_servers: UserJoinedServerRepositoryABC,
user_joined_voice_channel: UserJoinedVoiceChannelRepositoryABC,
translate: TranslatePipe,
date: DateTimeOffsetPipe,
level: LevelService
self,
config: ConfigurationABC,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
permissions: PermissionServiceABC,
servers: ServerRepositoryABC,
db: DatabaseContextABC,
users: UserRepositoryABC,
user_joined_servers: UserJoinedServerRepositoryABC,
user_joined_voice_channel: UserJoinedVoiceChannelRepositoryABC,
translate: TranslatePipe,
date: DateTimeOffsetPipe,
level: LevelService,
):
DiscordCommandABC.__init__(self)
@@ -59,23 +60,32 @@ class UserGroup(DiscordCommandABC):
self._date = date
self._level = level
self._logger.trace(__name__, f'Loaded command service: {type(self).__name__}')
self._logger.trace(__name__, f"Loaded command service: {type(self).__name__}")
self._atr_dict = {
"xp": self._t.transform('modules.base.user.atr.xp'),
'ontime': self._t.transform('modules.base.user.atr.ontime')
"xp": self._t.transform("modules.base.user.atr.xp"),
"ontime": self._t.transform("modules.base.user.atr.ontime"),
}
self._atr_list = [(key, self._atr_dict[key]) for key in self._atr_dict]
async def _handle_atr_calc(self, ctx: Context, atr: str, value: int, member: discord.Member, is_remove=False):
async def _handle_atr_calc(
self,
ctx: Context,
atr: str,
value: int,
member: discord.Member,
is_remove=False,
):
if member is None or not isinstance(member, discord.Member):
member = ctx.author
server = self._servers.find_server_by_discord_id(ctx.guild.id)
user = self._users.find_user_by_discord_id_and_server_id(member.id, server.server_id)
user = self._users.find_user_by_discord_id_and_server_id(
member.id, server.server_id
)
if atr == 'xp':
if atr == "xp":
if is_remove:
user.xp -= value
else:
@@ -87,14 +97,16 @@ class UserGroup(DiscordCommandABC):
else:
await self._message_service.send_interaction_msg(
ctx.interaction,
self._t.transform('modules.base.user.error.atr_not_found').format(atr)
self._t.transform("modules.base.user.error.atr_not_found").format(atr),
)
return
type = 'add' if not is_remove else 'remove'
type = "add" if not is_remove else "remove"
await self._message_service.send_interaction_msg(
ctx.interaction,
self._t.transform(f'modules.base.user.{type}.{atr.lower()}').format(atr, value, member.mention)
self._t.transform(f"modules.base.user.{type}.{atr.lower()}").format(
atr, value, member.mention
),
)
@commands.hybrid_group()
@@ -105,130 +117,180 @@ class UserGroup(DiscordCommandABC):
@user.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
async def info(self, ctx: Context, member: Optional[discord.Member] = None, *, wait: int = None):
self._logger.debug(__name__, f'Received command user-info {ctx}:{member},{wait}')
async def info(
self, ctx: Context, member: Optional[discord.Member] = None, *, wait: int = None
):
self._logger.debug(
__name__, f"Received command user-info {ctx}:{member},{wait}"
)
is_mod = self._permissions.is_member_moderator(ctx.author)
if member is not None and not is_mod:
await self._message_service.send_ctx_msg(ctx, self._t.transform('common.no_permission_message'))
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.no_permission_message")
)
return
if member is None or not isinstance(member, discord.Member):
member = ctx.author
server = self._servers.find_server_by_discord_id(ctx.guild.id)
user = self._users.find_user_by_discord_id_and_server_id(member.id, server.server_id)
joins = self._user_joined_servers.get_user_joined_servers_by_user_id(user.user_id)
embed = discord.Embed(
title=member.name,
description=member.name,
color=int('ef9d0d', 16)
user = self._users.find_user_by_discord_id_and_server_id(
member.id, server.server_id
)
joins = self._user_joined_servers.get_user_joined_servers_by_user_id(
user.user_id
)
embed.add_field(name=self._t.transform('modules.base.user.atr.id'), value=member.id)
embed.add_field(name=self._t.transform('modules.base.user.atr.name'), value=member.name)
embed.add_field(name=self._t.transform('modules.base.user.atr.discord_join'),
value=self._date.transform(member.created_at), inline=False)
embed.add_field(name=self._t.transform('modules.base.user.atr.last_join'),
value=self._date.transform(member.joined_at), inline=False)
embed.add_field(name=self._t.transform('modules.base.user.atr.xp'), value=str(user.xp))
embed.add_field(name=self._t.transform('modules.base.user.atr.ontime'),
value=str(self._client_utils.get_ontime_for_user(user)))
embed = discord.Embed(
title=member.name, description=member.name, color=int("ef9d0d", 16)
)
roles = ''
embed.add_field(
name=self._t.transform("modules.base.user.atr.id"), value=member.id
)
embed.add_field(
name=self._t.transform("modules.base.user.atr.name"), value=member.name
)
embed.add_field(
name=self._t.transform("modules.base.user.atr.discord_join"),
value=self._date.transform(member.created_at),
inline=False,
)
embed.add_field(
name=self._t.transform("modules.base.user.atr.last_join"),
value=self._date.transform(member.joined_at),
inline=False,
)
embed.add_field(
name=self._t.transform("modules.base.user.atr.xp"), value=str(user.xp)
)
embed.add_field(
name=self._t.transform("modules.base.user.atr.ontime"),
value=str(self._client_utils.get_ontime_for_user(user)),
)
roles = ""
for role in member.roles:
roles += f'{role.name}\n'
embed.add_field(name=self._t.transform('modules.base.user.atr.roles'), value=roles, inline=False)
roles += f"{role.name}\n"
embed.add_field(
name=self._t.transform("modules.base.user.atr.roles"),
value=roles,
inline=False,
)
if is_mod or member == ctx.author:
joins_string = ''
joins_string = ""
for join in joins:
joins_string += f'{self._date.transform(join.joined_on)}\n'
embed.add_field(name=self._t.transform('modules.base.user.atr.joins'), value=joins_string)
joins_string += f"{self._date.transform(join.joined_on)}\n"
embed.add_field(
name=self._t.transform("modules.base.user.atr.joins"),
value=joins_string,
)
if is_mod or member == ctx.author:
lefts_string = ''
lefts_string = ""
for join in joins:
if join.leaved_on is None:
if lefts_string == '':
lefts_string = '/'
if lefts_string == "":
lefts_string = "/"
continue
lefts_string += f'{self._date.transform(join.leaved_on)}\n'
lefts_string += f"{self._date.transform(join.leaved_on)}\n"
embed.add_field(name=self._t.transform('modules.base.user.atr.lefts'), value=lefts_string)
embed.add_field(
name=self._t.transform("modules.base.user.atr.lefts"),
value=lefts_string,
)
if is_mod or member == ctx.author:
embed.add_field(
name=self._t.transform('modules.base.user.atr.warnings'),
value=self._t.transform('common.not_implemented_yet'),
inline=False
name=self._t.transform("modules.base.user.atr.warnings"),
value=self._t.transform("common.not_implemented_yet"),
inline=False,
)
# send to interaction because of sensitive data
await self._message_service.send_interaction_msg(ctx.interaction, embed, wait_before_delete=wait)
self._logger.trace(__name__, f'Finished user-info command')
await self._message_service.send_interaction_msg(
ctx.interaction, embed, wait_before_delete=wait
)
self._logger.trace(__name__, f"Finished user-info command")
@user.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
async def get(self, ctx: Context, atr: str, member: discord.Member = None):
self._logger.debug(__name__, f'Received command user-get {atr} {ctx}:{member}')
self._logger.debug(__name__, f"Received command user-get {atr} {ctx}:{member}")
is_mod = self._permissions.is_member_moderator(ctx.author)
if member is not None and not is_mod:
await self._message_service.send_ctx_msg(ctx, self._t.transform('common.no_permission_message'))
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.no_permission_message")
)
return
if member is None or not isinstance(member, discord.Member):
member = ctx.author
server = self._servers.find_server_by_discord_id(ctx.guild.id)
user = self._users.find_user_by_discord_id_and_server_id(member.id, server.server_id)
user = self._users.find_user_by_discord_id_and_server_id(
member.id, server.server_id
)
if atr == 'xp':
if atr == "xp":
value = str(user.xp)
elif atr == 'ontime':
elif atr == "ontime":
value = str(self._client_utils.get_ontime_for_user(user))
else:
await self._message_service.send_interaction_msg(
ctx.interaction,
self._t.transform('modules.base.user.error.atr_not_found').format(atr)
self._t.transform("modules.base.user.error.atr_not_found").format(atr),
)
return
await self._message_service.send_interaction_msg(
ctx.interaction,
self._t.transform(f'modules.base.user.get.{atr.lower()}').format(member.mention, value)
self._t.transform(f"modules.base.user.get.{atr.lower()}").format(
member.mention, value
),
)
@get.autocomplete('atr')
async def get_autocomplete(self, interaction: discord.Interaction, current: str) -> List[app_commands.Choice[str]]:
return [app_commands.Choice(name=value, value=key) for key, value in self._atr_list]
@get.autocomplete("atr")
async def get_autocomplete(
self, interaction: discord.Interaction, current: str
) -> List[app_commands.Choice[str]]:
return [
app_commands.Choice(name=value, value=key) for key, value in self._atr_list
]
@user.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def set(self, ctx: Context, atr: str, value: int, member: discord.Member = None):
self._logger.debug(__name__, f'Received command user-set {atr} {ctx}:{member}')
async def set(
self, ctx: Context, atr: str, value: int, member: discord.Member = None
):
self._logger.debug(__name__, f"Received command user-set {atr} {ctx}:{member}")
if member is None or not isinstance(member, discord.Member):
member = ctx.author
server = self._servers.find_server_by_discord_id(ctx.guild.id)
user = self._users.find_user_by_discord_id_and_server_id(member.id, server.server_id)
user = self._users.find_user_by_discord_id_and_server_id(
member.id, server.server_id
)
if atr == 'xp':
if atr == "xp":
try:
user.xp = value
except TypeError as te:
self._logger.error(__name__, f'String value couldn\'t be converted to int', te)
self._logger.error(
__name__, f"String value couldn't be converted to int", te
)
await self._message_service.send_interaction_msg(
ctx.interaction,
self._t.transform('modules.base.user.set.error.type_error')
self._t.transform("modules.base.user.set.error.type_error"),
)
return
else:
@@ -239,44 +301,60 @@ class UserGroup(DiscordCommandABC):
else:
await self._message_service.send_interaction_msg(
ctx.interaction,
self._t.transform('modules.base.user.error.atr_not_found').format(atr)
self._t.transform("modules.base.user.error.atr_not_found").format(atr),
)
return
await self._message_service.send_interaction_msg(
ctx.interaction,
self._t.transform(f'modules.base.user.set.{atr.lower()}').format(member.mention, value)
self._t.transform(f"modules.base.user.set.{atr.lower()}").format(
member.mention, value
),
)
@set.autocomplete('atr')
async def set_autocomplete(self, interaction: discord.Interaction, current: str) -> List[app_commands.Choice[str]]:
atr_list = [('xp', self._atr_dict['xp'])]
@set.autocomplete("atr")
async def set_autocomplete(
self, interaction: discord.Interaction, current: str
) -> List[app_commands.Choice[str]]:
atr_list = [("xp", self._atr_dict["xp"])]
return [app_commands.Choice(name=value, value=key) for key, value in atr_list]
@user.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def add(self, ctx: Context, atr: str, value: int, member: discord.Member = None):
self._logger.debug(__name__, f'Received command user-add {atr}-={value} {ctx}:{member}')
async def add(
self, ctx: Context, atr: str, value: int, member: discord.Member = None
):
self._logger.debug(
__name__, f"Received command user-add {atr}-={value} {ctx}:{member}"
)
await self._handle_atr_calc(ctx, atr, value, member)
@add.autocomplete('atr')
async def set_autocomplete(self, interaction: discord.Interaction, current: str) -> List[app_commands.Choice[str]]:
atr_list = [('xp', self._atr_dict['xp'])]
@add.autocomplete("atr")
async def set_autocomplete(
self, interaction: discord.Interaction, current: str
) -> List[app_commands.Choice[str]]:
atr_list = [("xp", self._atr_dict["xp"])]
return [app_commands.Choice(name=value, value=key) for key, value in atr_list]
@user.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def remove(self, ctx: Context, atr: str, value: int, member: discord.Member = None):
self._logger.debug(__name__, f'Received command user-remove {atr}-={value} {ctx}:{member}')
async def remove(
self, ctx: Context, atr: str, value: int, member: discord.Member = None
):
self._logger.debug(
__name__, f"Received command user-remove {atr}-={value} {ctx}:{member}"
)
await self._handle_atr_calc(ctx, atr, value, member, is_remove=True)
@remove.autocomplete('atr')
async def set_autocomplete(self, interaction: discord.Interaction, current: str) -> List[app_commands.Choice[str]]:
atr_list = [('xp', self._atr_dict['xp'])]
@remove.autocomplete("atr")
async def set_autocomplete(
self, interaction: discord.Interaction, current: str
) -> List[app_commands.Choice[str]]:
atr_list = [("xp", self._atr_dict["xp"])]
return [app_commands.Choice(name=value, value=key) for key, value in atr_list]
@user.command()
@@ -284,38 +362,48 @@ class UserGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def reset(self, ctx: Context, atr: str, member: discord.Member = None):
self._logger.debug(__name__, f'Received command user-reset {atr} {ctx}:{member}')
self._logger.debug(
__name__, f"Received command user-reset {atr} {ctx}:{member}"
)
if member is None or not isinstance(member, discord.Member):
member = ctx.author
server = self._servers.find_server_by_discord_id(ctx.guild.id)
user = self._users.find_user_by_discord_id_and_server_id(member.id, server.server_id)
user = self._users.find_user_by_discord_id_and_server_id(
member.id, server.server_id
)
if atr == 'xp':
if atr == "xp":
user.xp = 0
self._users.update_user(user)
self._db.save_changes()
await self._level.check_level(member)
elif atr == 'ontime':
self._user_joined_voice_channel.delete_user_joined_voice_channel_by_user_id(user.user_id)
elif atr == "ontime":
self._user_joined_voice_channel.delete_user_joined_voice_channel_by_user_id(
user.user_id
)
self._db.save_changes()
else:
await self._message_service.send_interaction_msg(
ctx.interaction,
self._t.transform('modules.base.user.error.atr_not_found').format(atr)
self._t.transform("modules.base.user.error.atr_not_found").format(atr),
)
return
await self._message_service.send_interaction_msg(
ctx.interaction,
self._t.transform(f'modules.base.user.reset.{atr.lower()}').format(atr, member.mention)
self._t.transform(f"modules.base.user.reset.{atr.lower()}").format(
atr, member.mention
),
)
@reset.autocomplete('atr')
async def reset_autocomplete(self, interaction: discord.Interaction, current: str) -> List[
app_commands.Choice[str]
]:
return [app_commands.Choice(name=value, value=key) for key, value in self._atr_list]
@reset.autocomplete("atr")
async def reset_autocomplete(
self, interaction: discord.Interaction, current: str
) -> List[app_commands.Choice[str]]:
return [
app_commands.Choice(name=value, value=key) for key, value in self._atr_list
]

14
kdb-bot/src/modules/base/configuration/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.base.configuration'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.base.configuration"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
VersionInfo = namedtuple('VersionInfo', 'major minor micro')
version_info = VersionInfo(major='0', minor='3', micro='0')
VersionInfo = namedtuple("VersionInfo", "major minor micro")
version_info = VersionInfo(major="0", minor="3", micro="0")

33
kdb-bot/src/modules/base/configuration/base_server_settings.py
View File

@@ -6,7 +6,6 @@ from cpl_query.extension import List
class BaseServerSettings(ConfigurationModelABC):
def __init__(self):
ConfigurationModelABC.__init__(self)
@@ -18,7 +17,7 @@ class BaseServerSettings(ConfigurationModelABC):
self._xp_per_ontime_hour: int = 0
self._afk_channel_ids: List[int] = List(int)
self._afk_command_channel_id: int = 0
self._help_command_reference_url: str = ''
self._help_command_reference_url: str = ""
self._help_voice_channel_id: int = 0
self._ping_urls = List(str)
@@ -68,19 +67,23 @@ class BaseServerSettings(ConfigurationModelABC):
def from_dict(self, settings: dict):
try:
self._id = int(settings['Id'])
self._max_voice_state_hours = int(settings['MaxVoiceStateHours'])
self._xp_per_message = int(settings['XpPerMessage'])
self._xp_per_reaction = int(settings['XpPerReaction'])
self._max_message_xp_per_hour = int(settings['MaxMessageXpPerHour'])
self._xp_per_ontime_hour = int(settings['XpPerOntimeHour'])
for index in settings['AFKChannelIds']:
self._id = int(settings["Id"])
self._max_voice_state_hours = int(settings["MaxVoiceStateHours"])
self._xp_per_message = int(settings["XpPerMessage"])
self._xp_per_reaction = int(settings["XpPerReaction"])
self._max_message_xp_per_hour = int(settings["MaxMessageXpPerHour"])
self._xp_per_ontime_hour = int(settings["XpPerOntimeHour"])
for index in settings["AFKChannelIds"]:
self._afk_channel_ids.append(int(index))
self._afk_command_channel_id = settings['AFKCommandChannelId']
self._help_command_reference_url = settings['HelpCommandReferenceUrl']
self._help_voice_channel_id = settings['HelpVoiceChannelId']
for url in settings['PingURLs']:
self._afk_command_channel_id = settings["AFKCommandChannelId"]
self._help_command_reference_url = settings["HelpCommandReferenceUrl"]
self._help_voice_channel_id = settings["HelpVoiceChannelId"]
for url in settings["PingURLs"]:
self._ping_urls.append(url)
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()}')
Console.error(
f"[ ERROR ] [ {__name__} ]: Reading error in {type(self).__name__} settings"
)
Console.error(
f"[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}"
)

13
kdb-bot/src/modules/base/configuration/base_settings.py
View File

@@ -8,12 +8,11 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class BaseSettings(ConfigurationModelABC):
def __init__(self):
ConfigurationModelABC.__init__(self)
self._servers: List[BaseServerSettings] = List()
@property
def servers(self) -> List[BaseServerSettings]:
return self._servers
@@ -23,10 +22,14 @@ class BaseSettings(ConfigurationModelABC):
servers = List(BaseServerSettings)
for s in settings:
st = BaseServerSettings()
settings[s]['Id'] = s
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()}')
Console.error(
f"[ ERROR ] [ {__name__} ]: Reading error in {type(self).__name__} settings"
)
Console.error(
f"[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}"
)

14
kdb-bot/src/modules/base/events/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.base.events'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.base.events"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
VersionInfo = namedtuple('VersionInfo', 'major minor micro')
version_info = VersionInfo(major='0', minor='3', micro='0')
VersionInfo = namedtuple("VersionInfo", "major minor micro")
version_info = VersionInfo(major="0", minor="3", micro="0")

223
kdb-bot/src/modules/base/events/base_on_command_error_event.py
View File

@@ -17,15 +17,14 @@ from bot_core.exception.check_error import CheckError
class BaseOnCommandErrorEvent(OnCommandErrorABC):
def __init__(
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
messenger: MessageServiceABC,
bot_settings: BotSettings,
time_format_settings: TimeFormatSettings,
translate: TranslatePipe
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
messenger: MessageServiceABC,
bot_settings: BotSettings,
time_format_settings: TimeFormatSettings,
translate: TranslatePipe,
):
OnCommandErrorABC.__init__(self)
self._logger = logger
@@ -39,112 +38,244 @@ class BaseOnCommandErrorEvent(OnCommandErrorABC):
if isinstance(error, CheckError):
return
error = getattr(error, 'original', error)
error = getattr(error, "original", error)
uid = uuid.uuid4()
self._logger.error(__name__, f'Got error: {type(error).__name__} UID: {uid}')
self._logger.error(__name__, f"Got error: {type(error).__name__} UID: {uid}")
if isinstance(error, commands.MissingRequiredArgument):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.missing_required_argument'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.missing_required_argument"),
without_tracking=True,
)
elif isinstance(error, commands.ArgumentParsingError):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.argument_parsing_error'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.argument_parsing_error"),
without_tracking=True,
)
elif isinstance(error, commands.UnexpectedQuoteError):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.unexpected_quote_error'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.unexpected_quote_error"),
without_tracking=True,
)
elif isinstance(error, commands.InvalidEndOfQuotedStringError):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.invalid_end_of_quoted_string_error'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.invalid_end_of_quoted_string_error"),
without_tracking=True,
)
elif isinstance(error, commands.ExpectedClosingQuoteError):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.expected_closing_quote_error'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.expected_closing_quote_error"),
without_tracking=True,
)
elif isinstance(error, commands.BadArgument):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.bad_argument'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.bad_argument"),
without_tracking=True,
)
elif isinstance(error, commands.BadUnionArgument):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.bad_union_argument'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.bad_union_argument"),
without_tracking=True,
)
elif isinstance(error, commands.PrivateMessageOnly):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.private_message_only'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.private_message_only"),
without_tracking=True,
)
elif isinstance(error, commands.NoPrivateMessage):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.no_private_message'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.no_private_message"),
without_tracking=True,
)
elif isinstance(error, commands.CheckFailure):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.check_failure'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.check_failure"),
without_tracking=True,
)
elif isinstance(error, commands.CheckAnyFailure):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.check_any_failure'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.check_any_failure"),
without_tracking=True,
)
elif isinstance(error, commands.CommandNotFound):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.command_not_found'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.command_not_found"),
without_tracking=True,
)
elif isinstance(error, commands.DisabledCommand):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.disabled_command'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.disabled_command"),
without_tracking=True,
)
elif isinstance(error, commands.CommandInvokeError):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.command_invoke_error'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.command_invoke_error"),
without_tracking=True,
)
elif isinstance(error, commands.TooManyArguments):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.too_many_arguments'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.too_many_arguments"),
without_tracking=True,
)
elif isinstance(error, commands.UserInputError):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.user_input_error'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.user_input_error"),
without_tracking=True,
)
elif isinstance(error, commands.CommandOnCooldown):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.command_on_cooldown'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.command_on_cooldown"),
without_tracking=True,
)
elif isinstance(error, commands.MaxConcurrencyReached):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.max_concurrency_reached'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.max_concurrency_reached"),
without_tracking=True,
)
elif isinstance(error, commands.NotOwner):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.not_owner'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx, self._t.transform("common.errors.not_owner"), without_tracking=True
)
elif isinstance(error, commands.MissingPermissions):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.missing_permissions'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.missing_permissions"),
without_tracking=True,
)
elif isinstance(error, commands.BotMissingPermissions):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.bot_missing_permissions'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.bot_missing_permissions"),
without_tracking=True,
)
elif isinstance(error, commands.MissingRole):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.missing_role'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.missing_role"),
without_tracking=True,
)
elif isinstance(error, commands.BotMissingRole):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.bot_missing_role'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.bot_missing_role"),
without_tracking=True,
)
elif isinstance(error, commands.MissingAnyRole):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.missing_any_role'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.missing_any_role"),
without_tracking=True,
)
elif isinstance(error, commands.BotMissingAnyRole):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.bot_missing_any_role'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.bot_missing_any_role"),
without_tracking=True,
)
elif isinstance(error, commands.NSFWChannelRequired):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.nsfw_channel_required'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.nsfw_channel_required"),
without_tracking=True,
)
elif isinstance(error, commands.ExtensionError):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.extension_error'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.extension_error"),
without_tracking=True,
)
elif isinstance(error, commands.ExtensionAlreadyLoaded):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.extension_already_loaded'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.extension_already_loaded"),
without_tracking=True,
)
elif isinstance(error, commands.ExtensionNotLoaded):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.extension_not_loaded'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.extension_not_loaded"),
without_tracking=True,
)
elif isinstance(error, commands.NoEntryPointError):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.no_entry_point_error'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.no_entry_point_error"),
without_tracking=True,
)
elif isinstance(error, commands.ExtensionFailed):
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.extension_failed'), without_tracking=True)
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.extension_failed"),
without_tracking=True,
)
else:
await self._messenger.send_ctx_msg(ctx, self._t.transform('common.errors.command_error'), without_tracking=True)
message = self._t.transform('modules.base.technician_command_error_message').format(
await self._messenger.send_ctx_msg(
ctx,
self._t.transform("common.errors.command_error"),
without_tracking=True,
)
message = self._t.transform(
"modules.base.technician_command_error_message"
).format(
ctx.command,
ctx.author,
error,
datetime.datetime.now().strftime(self._time_format_settings.date_time_format),
uid
datetime.datetime.now().strftime(
self._time_format_settings.date_time_format
),
uid,
)
for t in self._bot_settings.technicians:
member = self._bot.get_user(t)
await self._messenger.send_dm_message(message, member, without_tracking=True)
await self._messenger.send_dm_message(
message, member, without_tracking=True
)

49
kdb-bot/src/modules/base/events/base_on_command_event.py
View File

@@ -20,20 +20,19 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class BaseOnCommandEvent(OnCommandABC):
def __init__(
self,
logger: CommandLogger,
bot: DiscordBotServiceABC,
messenger: MessageServiceABC,
bot_settings: BotSettings,
time_format_settings: TimeFormatSettings,
translate: TranslatePipe,
bhs: BaseHelperABC,
db: DatabaseContextABC,
users: UserRepositoryABC,
clients: ClientRepositoryABC,
servers: ServerRepositoryABC,
self,
logger: CommandLogger,
bot: DiscordBotServiceABC,
messenger: MessageServiceABC,
bot_settings: BotSettings,
time_format_settings: TimeFormatSettings,
translate: TranslatePipe,
bhs: BaseHelperABC,
db: DatabaseContextABC,
users: UserRepositoryABC,
clients: ClientRepositoryABC,
servers: ServerRepositoryABC,
):
OnCommandABC.__init__(self)
self._logger = logger
@@ -53,25 +52,29 @@ class BaseOnCommandEvent(OnCommandABC):
self._clients.append_received_command_count(self._bot.user.id, g_id, 1)
self._db.save_changes()
except Exception as e:
self._logger.error(__name__, f'Cannot edit client {self._bot.user.id}@{g_id}', e)
self._logger.error(
__name__, f"Cannot edit client {self._bot.user.id}@{g_id}", e
)
def _handle_message_for_xp(self, message: discord.Message):
dc_user_id = message.author.id
try:
server = self._servers.get_server_by_discord_id(message.guild.id)
except Exception as e:
self._logger.error(__name__, f'Cannot get server {message.guild.id}', e)
self._logger.error(__name__, f"Cannot get server {message.guild.id}", e)
return
user: Optional[User] = None
try:
user = self._users.get_user_by_discord_id_and_server_id(dc_user_id, server.server_id)
user = self._users.get_user_by_discord_id_and_server_id(
dc_user_id, server.server_id
)
except Exception as e:
self._logger.error(__name__, f'Cannot get user {dc_user_id}', e)
self._logger.error(__name__, f"Cannot get user {dc_user_id}", e)
return
if user is None:
self._logger.error(__name__, f'User not found {dc_user_id}')
self._logger.error(__name__, f"User not found {dc_user_id}")
return
settings: BaseServerSettings = self._base_helper.get_config(message.guild.id)
@@ -80,11 +83,15 @@ class BaseOnCommandEvent(OnCommandABC):
self._users.update_user(user)
self._db.save_changes()
self._logger.debug(__name__, f'User {user} sent message. xp: from {old_xp} to {user.xp}')
self._logger.debug(
__name__, f"User {user} sent message. xp: from {old_xp} to {user.xp}"
)
async def on_command(self, ctx: Context):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.info(__name__, f'Received command: {ctx.command} from {ctx.channel}')
self._logger.debug(__name__, f"Module {type(self)} started")
self._logger.info(
__name__, f"Received command: {ctx.command} from {ctx.channel}"
)
if ctx is None or ctx.guild is None:
return
self._append_received_command_count(ctx.guild.id)

78
kdb-bot/src/modules/base/events/base_on_member_join_event.py
View File

@@ -23,20 +23,19 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class BaseOnMemberJoinEvent(OnMemberJoinABC):
def __init__(
self,
config: ConfigurationABC,
logger: LoggerABC,
base_helper: BaseHelperABC,
messenger: MessageServiceABC,
permissions: PermissionServiceABC,
db: DatabaseContextABC,
known_users: KnownUserRepositoryABC,
users: UserRepositoryABC,
servers: ServerRepositoryABC,
user_joins: UserJoinedServerRepositoryABC,
translate: TranslatePipe
self,
config: ConfigurationABC,
logger: LoggerABC,
base_helper: BaseHelperABC,
messenger: MessageServiceABC,
permissions: PermissionServiceABC,
db: DatabaseContextABC,
known_users: KnownUserRepositoryABC,
users: UserRepositoryABC,
servers: ServerRepositoryABC,
user_joins: UserJoinedServerRepositoryABC,
translate: TranslatePipe,
):
OnMemberJoinABC.__init__(self)
self._config = config
@@ -52,48 +51,71 @@ class BaseOnMemberJoinEvent(OnMemberJoinABC):
self._t = translate
def _check_for_known_user(self, member: Union[discord.User, discord.Member]):
self._logger.debug(__name__, f'Check if user is already known {member}')
self._logger.debug(__name__, f"Check if user is already known {member}")
try:
user = self._known_users.find_user_by_discord_id(member.id)
if user is not None:
return
self._logger.debug(__name__, f'Add user: {member.id}')
self._logger.debug(__name__, f"Add user: {member.id}")
self._known_users.add_user(KnownUser(member.id))
self._db.save_changes()
except Exception as e:
self._logger.error(__name__, f'Cannot get user {member.id}', e)
self._logger.error(__name__, f"Cannot get user {member.id}", e)
async def _add_if_not_exists_user_async(self, member: Union[discord.User, discord.Member]):
self._logger.debug(__name__, f'Check if user exists {member}')
async def _add_if_not_exists_user_async(
self, member: Union[discord.User, discord.Member]
):
self._logger.debug(__name__, f"Check if user exists {member}")
settings: BaseServerSettings = self._base_helper.get_config(member.guild.id)
await self._messenger.send_dm_message(self._t.transform('modules.base.welcome_message').format(member.guild.name), member)
await self._messenger.send_dm_message(
self._t.transform("modules.base.welcome_message").format(member.guild.name),
member,
)
for admin in self._permission_service.get_admins(member.guild.id):
await self._messenger.send_dm_message(self._t.transform('modules.base.welcome_message_for_team').format(member.mention), admin)
await self._messenger.send_dm_message(
self._t.transform("modules.base.welcome_message_for_team").format(
member.mention
),
admin,
)
for moderator in self._permission_service.get_moderators(member.guild.id):
await self._messenger.send_dm_message(self._t.transform('modules.base.welcome_message_for_team').format(member.mention), moderator)
await self._messenger.send_dm_message(
self._t.transform("modules.base.welcome_message_for_team").format(
member.mention
),
moderator,
)
try:
server = self._servers.get_server_by_discord_id(member.guild.id)
user = self._users.find_user_by_discord_id_and_server_id(member.id, server.server_id)
user = self._users.find_user_by_discord_id_and_server_id(
member.id, server.server_id
)
if user is not None:
self._user_joins.add_user_joined_server(UserJoinedServer(user, datetime.now()))
self._user_joins.add_user_joined_server(
UserJoinedServer(user, datetime.now())
)
self._db.save_changes()
return
self._logger.debug(__name__, f'Add user: {member.id}')
self._logger.debug(__name__, f"Add user: {member.id}")
self._users.add_user(User(member.id, 0, server))
self._db.save_changes()
user = self._users.get_user_by_discord_id_and_server_id(member.id, server.server_id)
self._user_joins.add_user_joined_server(UserJoinedServer(user, datetime.now()))
user = self._users.get_user_by_discord_id_and_server_id(
member.id, server.server_id
)
self._user_joins.add_user_joined_server(
UserJoinedServer(user, datetime.now())
)
self._db.save_changes()
except Exception as e:
self._logger.error(__name__, f'Cannot get user {member.id}', e)
self._logger.error(__name__, f"Cannot get user {member.id}", e)
@EventChecks.check_is_ready()
async def on_member_join(self, member: discord.Member):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.debug(__name__, f"Module {type(self)} started")
self._check_for_known_user(member)
await self._add_if_not_exists_user_async(member)

39
kdb-bot/src/modules/base/events/base_on_member_remove_event.py
View File

@@ -17,17 +17,16 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class BaseOnMemberRemoveEvent(OnMemberRemoveABC):
def __init__(
self,
logger: LoggerABC,
base_helper: BaseHelperABC,
db: DatabaseContextABC,
messenger: MessageServiceABC,
users: UserRepositoryABC,
servers: ServerRepositoryABC,
user_joins: UserJoinedServerRepositoryABC,
translate: TranslatePipe
self,
logger: LoggerABC,
base_helper: BaseHelperABC,
db: DatabaseContextABC,
messenger: MessageServiceABC,
users: UserRepositoryABC,
servers: ServerRepositoryABC,
user_joins: UserJoinedServerRepositoryABC,
translate: TranslatePipe,
):
OnMemberRemoveABC.__init__(self)
@@ -41,26 +40,32 @@ class BaseOnMemberRemoveEvent(OnMemberRemoveABC):
self._t = translate
async def _remove_user(self, member: Union[discord.User, discord.Member]):
self._logger.debug(__name__, f'Remove user {member}')
self._logger.debug(__name__, f"Remove user {member}")
settings: BaseServerSettings = self._base_helper.get_config(member.guild.id)
await self._messenger.send_dm_message(self._t.transform('modules.base.goodbye_message'), member)
await self._messenger.send_dm_message(
self._t.transform("modules.base.goodbye_message"), member
)
try:
server = self._servers.get_server_by_discord_id(member.guild.id)
user = self._users.find_user_by_discord_id_and_server_id(member.id, server.server_id)
user = self._users.find_user_by_discord_id_and_server_id(
member.id, server.server_id
)
if user is None:
self._logger.error(__name__, f'Cannot find user {member}')
self._logger.error(__name__, f"Cannot find user {member}")
return
join = self._user_joins.get_active_user_joined_server_by_user_id(user.user_id)
join = self._user_joins.get_active_user_joined_server_by_user_id(
user.user_id
)
join.leaved_on = datetime.now()
self._user_joins.update_user_joined_server(join)
self._db.save_changes()
except Exception as e:
self._logger.error(__name__, f'Cannot get user {member.id}', e)
self._logger.error(__name__, f"Cannot get user {member.id}", e)
@EventChecks.check_is_ready()
async def on_member_remove(self, member: discord.Member):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.debug(__name__, f"Module {type(self)} started")
await self._remove_user(member)

44
kdb-bot/src/modules/base/events/base_on_message_delete_event.py
View File

@@ -16,16 +16,15 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class BaseOnMessageDeleteEvent(OnMessageDeleteABC):
def __init__(
self,
logger: MessageLogger,
bhs: BaseHelperABC,
db: DatabaseContextABC,
bot: DiscordBotServiceABC,
users: UserRepositoryABC,
clients: ClientRepositoryABC,
servers: ServerRepositoryABC,
self,
logger: MessageLogger,
bhs: BaseHelperABC,
db: DatabaseContextABC,
bot: DiscordBotServiceABC,
users: UserRepositoryABC,
clients: ClientRepositoryABC,
servers: ServerRepositoryABC,
):
OnMessageDeleteABC.__init__(self)
self._logger = logger
@@ -41,25 +40,29 @@ class BaseOnMessageDeleteEvent(OnMessageDeleteABC):
self._clients.append_deleted_message_count(self._bot.user.id, g_id, 1)
self._db.save_changes()
except Exception as e:
self._logger.error(__name__, f'Cannot edit client {self._bot.user.id}@{g_id}', e)
self._logger.error(
__name__, f"Cannot edit client {self._bot.user.id}@{g_id}", e
)
def _handle_message_delete(self, message: discord.Message):
dc_user_id = message.author.id
try:
server = self._servers.get_server_by_discord_id(message.guild.id)
except Exception as e:
self._logger.error(__name__, f'Cannot get server {message.guild.id}', e)
self._logger.error(__name__, f"Cannot get server {message.guild.id}", e)
return
user: Optional[User] = None
try:
user = self._users.find_user_by_discord_id_and_server_id(dc_user_id, server.server_id)
user = self._users.find_user_by_discord_id_and_server_id(
dc_user_id, server.server_id
)
except Exception as e:
self._logger.error(__name__, f'Cannot get user {dc_user_id}', e)
self._logger.error(__name__, f"Cannot get user {dc_user_id}", e)
return
if user is None:
self._logger.error(__name__, f'User not found {dc_user_id}')
self._logger.error(__name__, f"User not found {dc_user_id}")
return
settings: BaseServerSettings = self._base_helper.get_config(message.guild.id)
@@ -68,16 +71,21 @@ class BaseOnMessageDeleteEvent(OnMessageDeleteABC):
self._users.update_user(user)
self._db.save_changes()
self._logger.debug(__name__, f'Removed message from user {user}. xp: from {old_xp} to {user.xp}')
self._logger.debug(
__name__,
f"Removed message from user {user}. xp: from {old_xp} to {user.xp}",
)
async def on_message_delete(self, message: discord.Message):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.debug(__name__, f"Module {type(self)} started")
if message is None or message.guild is None:
return
self._logger.info(__name__, f'Received message: {LogMessageHelper.get_log_string(message)}')
self._logger.info(
__name__, f"Received message: {LogMessageHelper.get_log_string(message)}"
)
self._append_deleted_message_count(message.guild.id)
if not message.author.bot:
self._handle_message_delete(message)
self._logger.debug(__name__, f'Module {type(self)} stopped')
self._logger.debug(__name__, f"Module {type(self)} stopped")

51
kdb-bot/src/modules/base/events/base_on_message_event.py
View File

@@ -18,17 +18,16 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class BaseOnMessageEvent(OnMessageABC):
def __init__(
self,
logger: MessageLogger,
bhs: BaseHelperABC,
client_utils: ClientUtilsService,
db: DatabaseContextABC,
bot: DiscordBotServiceABC,
users: UserRepositoryABC,
clients: ClientRepositoryABC,
servers: ServerRepositoryABC,
self,
logger: MessageLogger,
bhs: BaseHelperABC,
client_utils: ClientUtilsService,
db: DatabaseContextABC,
bot: DiscordBotServiceABC,
users: UserRepositoryABC,
clients: ClientRepositoryABC,
servers: ServerRepositoryABC,
):
OnMessageABC.__init__(self)
self._logger = logger
@@ -46,29 +45,35 @@ class BaseOnMessageEvent(OnMessageABC):
self._clients.append_received_message_count(self._bot.user.id, g_id, 1)
self._db.save_changes()
except Exception as e:
self._logger.error(__name__, f'Cannot edit client {self._bot.user.id}@{g_id}', e)
self._logger.error(
__name__, f"Cannot edit client {self._bot.user.id}@{g_id}", e
)
def _handle_message_for_xp(self, message: discord.Message):
dc_user_id = message.author.id
try:
server = self._servers.get_server_by_discord_id(message.guild.id)
except Exception as e:
self._logger.error(__name__, f'Cannot get server {message.guild.id}', e)
self._logger.error(__name__, f"Cannot get server {message.guild.id}", e)
return
user: Optional[User] = None
try:
user = self._users.find_user_by_discord_id_and_server_id(dc_user_id, server.server_id)
user = self._users.find_user_by_discord_id_and_server_id(
dc_user_id, server.server_id
)
except Exception as e:
self._logger.error(__name__, f'Cannot get user {dc_user_id}', e)
self._logger.error(__name__, f"Cannot get user {dc_user_id}", e)
return
if user is None:
self._logger.error(__name__, f'User not found {dc_user_id}')
self._logger.error(__name__, f"User not found {dc_user_id}")
return
settings: BaseServerSettings = self._base_helper.get_config(message.guild.id)
if self._client_utils.is_message_xp_count_by_hour_higher_that_max_message_count_per_hour(message.created_at, user, settings):
if self._client_utils.is_message_xp_count_by_hour_higher_that_max_message_count_per_hour(
message.created_at, user, settings
):
return
old_xp = user.xp
@@ -76,19 +81,21 @@ class BaseOnMessageEvent(OnMessageABC):
self._users.update_user(user)
self._db.save_changes()
self._logger.debug(__name__, f'User {user} sent message. xp: from {old_xp} to {user.xp}')
self._logger.debug(
__name__, f"User {user} sent message. xp: from {old_xp} to {user.xp}"
)
@EventChecks.check_is_ready()
async def on_message(self, message: discord.Message):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.debug(__name__, f"Module {type(self)} started")
if message is None or message.guild is None:
return
self._logger.info(__name__, f'Received message: {LogMessageHelper.get_log_string(message)}')
self._logger.info(
__name__, f"Received message: {LogMessageHelper.get_log_string(message)}"
)
self._append_received_message_count(message.guild.id)
if not message.author.bot:
self._handle_message_for_xp(message)
self._logger.debug(__name__, f'Module {type(self)} stopped')
self._logger.debug(__name__, f"Module {type(self)} stopped")

19
kdb-bot/src/modules/base/events/base_on_raw_reaction_add.py
View File

@@ -10,14 +10,13 @@ from modules.base.helper.base_reaction_handler import BaseReactionHandler
class BaseOnRawReactionAddEvent(OnRawReactionAddABC):
def __init__(
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
reaction_handler: BaseReactionHandler
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
reaction_handler: BaseReactionHandler,
):
OnRawReactionAddABC.__init__(self)
@@ -29,8 +28,8 @@ class BaseOnRawReactionAddEvent(OnRawReactionAddABC):
@EventChecks.check_is_ready()
async def on_raw_reaction_add(self, payload: RawReactionActionEvent):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.debug(__name__, f"Module {type(self)} started")
await self._reaction_handler.handle(payload, 'add')
await self._reaction_handler.handle(payload, "add")
self._logger.debug(__name__, f'Module {type(self)} stopped')
self._logger.debug(__name__, f"Module {type(self)} stopped")

19
kdb-bot/src/modules/base/events/base_on_raw_reaction_remove.py
View File

@@ -10,14 +10,13 @@ from modules.base.helper.base_reaction_handler import BaseReactionHandler
class BaseOnRawReactionRemoveEvent(OnRawReactionRemoveABC):
def __init__(
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
reaction_handler: BaseReactionHandler,
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
reaction_handler: BaseReactionHandler,
):
OnRawReactionRemoveABC.__init__(self)
@@ -29,8 +28,8 @@ class BaseOnRawReactionRemoveEvent(OnRawReactionRemoveABC):
@EventChecks.check_is_ready()
async def on_raw_reaction_remove(self, payload: RawReactionActionEvent):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.debug(__name__, f"Module {type(self)} started")
await self._reaction_handler.handle(payload, 'remove')
await self._reaction_handler.handle(payload, "remove")
self._logger.debug(__name__, f'Module {type(self)} stopped')
self._logger.debug(__name__, f"Module {type(self)} stopped")

122
kdb-bot/src/modules/base/events/base_on_voice_state_update_event.py
View File

@@ -12,7 +12,9 @@ from bot_core.helper.event_checks import EventChecks
from bot_data.abc.known_user_repository_abc import KnownUserRepositoryABC
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_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.user import User
@@ -22,19 +24,18 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class BaseOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
def __init__(
self,
config: ConfigurationABC,
logger: LoggerABC,
base_helper: BaseHelperABC,
servers: ServerRepositoryABC,
known_users: KnownUserRepositoryABC,
users: UserRepositoryABC,
user_joins: UserJoinedServerRepositoryABC,
user_joins_vc: UserJoinedVoiceChannelRepositoryABC,
client_utils: ClientUtilsABC,
db: DatabaseContextABC,
self,
config: ConfigurationABC,
logger: LoggerABC,
base_helper: BaseHelperABC,
servers: ServerRepositoryABC,
known_users: KnownUserRepositoryABC,
users: UserRepositoryABC,
user_joins: UserJoinedServerRepositoryABC,
user_joins_vc: UserJoinedVoiceChannelRepositoryABC,
client_utils: ClientUtilsABC,
db: DatabaseContextABC,
):
OnVoiceStateUpdateABC.__init__(self)
self._config = config
@@ -48,18 +49,22 @@ class BaseOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
self._client_utils = client_utils
self._db = db
self._logger.info(__name__, f'Module {type(self)} loaded')
self._logger.info(__name__, f"Module {type(self)} loaded")
def _update_voice_state(self, joined: bool, dc_user_id: int, dc_channel_id: int, server: Server):
def _update_voice_state(
self, joined: bool, dc_user_id: int, dc_channel_id: int, server: Server
):
user: Optional[User] = None
try:
user = self._users.get_user_by_discord_id_and_server_id(dc_user_id, server.server_id)
user = self._users.get_user_by_discord_id_and_server_id(
dc_user_id, server.server_id
)
except Exception as e:
self._logger.error(__name__, f'Cannot get user {dc_user_id}', e)
self._logger.error(__name__, f"Cannot get user {dc_user_id}", e)
return
if user is None:
self._logger.error(__name__, f'User not found {dc_user_id}')
self._logger.error(__name__, f"User not found {dc_user_id}")
return
try:
@@ -69,9 +74,13 @@ class BaseOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
self._db.save_changes()
return
settings: BaseServerSettings = self._base_helper.get_config(server.discord_server_id)
settings: BaseServerSettings = self._base_helper.get_config(
server.discord_server_id
)
join = self._user_joins_vc.get_active_user_joined_voice_channel_by_user_id(user.user_id)
join = self._user_joins_vc.get_active_user_joined_voice_channel_by_user_id(
user.user_id
)
join.leaved_on = datetime.now()
# ontime as hours
@@ -83,49 +92,80 @@ class BaseOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
self._users.update_user(user)
self._db.save_changes()
self._logger.debug(__name__,
f'User {user} leaved_on {join.leaved_on}. Ontime: {ontime}h | xp: from {old_xp} to {user.xp}')
self._logger.debug(
__name__,
f"User {user} leaved_on {join.leaved_on}. Ontime: {ontime}h | xp: from {old_xp} to {user.xp}",
)
except Exception as e:
self._logger.error(__name__, f'Ontime validation failed', e)
self._logger.error(__name__, f"Ontime validation failed", e)
@EventChecks.check_is_ready()
async def on_voice_state_update(
self,
member: discord.Member,
before: discord.VoiceState,
after: discord.VoiceState
self,
member: discord.Member,
before: discord.VoiceState,
after: discord.VoiceState,
):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.trace(__name__, f'Detected on_voice_state_update {member.id} from {before} to {after}')
self._logger.debug(__name__, f"Module {type(self)} started")
self._logger.trace(
__name__,
f"Detected on_voice_state_update {member.id} from {before} to {after}",
)
settings: BaseServerSettings = self._base_helper.get_config(member.guild.id)
server = self._servers.get_server_by_discord_id(member.guild.id)
try:
# join
if before.channel is None and after.channel is not None and after.channel.id not in settings.afk_channel_ids:
self._logger.trace(__name__, f'User {member.id} joined {after.channel}')
if (
before.channel is None
and after.channel is not None
and after.channel.id not in settings.afk_channel_ids
):
self._logger.trace(__name__, f"User {member.id} joined {after.channel}")
self._update_voice_state(True, member.id, after.channel.id, server)
# leave
elif before.channel is not None and after.channel is None and before.channel.id not in settings.afk_channel_ids:
self._logger.trace(__name__, f'User {member.id} left {before.channel}')
elif (
before.channel is not None
and after.channel is None
and before.channel.id not in settings.afk_channel_ids
):
self._logger.trace(__name__, f"User {member.id} left {before.channel}")
self._update_voice_state(False, member.id, before.channel.id, server)
# channel to channel
elif before.channel is not None and after.channel is not None:
# joined
if before.channel.id in settings.afk_channel_ids and after.channel.id not in settings.afk_channel_ids:
self._logger.trace(__name__, f'User {member.id} joined {after.channel}')
if (
before.channel.id in settings.afk_channel_ids
and after.channel.id not in settings.afk_channel_ids
):
self._logger.trace(
__name__, f"User {member.id} joined {after.channel}"
)
self._update_voice_state(True, member.id, after.channel.id, server)
# left
elif after.channel.id in settings.afk_channel_ids and before.channel.id not in settings.afk_channel_ids:
self._logger.trace(__name__, f'User {member.id} left {before.channel}')
self._update_voice_state(False, member.id, before.channel.id, server)
elif (
after.channel.id in settings.afk_channel_ids
and before.channel.id not in settings.afk_channel_ids
):
self._logger.trace(
__name__, f"User {member.id} left {before.channel}"
)
self._update_voice_state(
False, member.id, before.channel.id, server
)
else:
self._logger.trace(__name__, f'User {member.id} switched to {after.channel}')
self._update_voice_state(False, member.id, before.channel.id, server)
self._logger.trace(
__name__, f"User {member.id} switched to {after.channel}"
)
self._update_voice_state(
False, member.id, before.channel.id, server
)
self._update_voice_state(True, member.id, after.channel.id, server)
except Exception as e:
self._logger.error(__name__, f'Cannot handle voice state for user {member.id}', e)
self._logger.error(
__name__, f"Cannot handle voice state for user {member.id}", e
)

43
kdb-bot/src/modules/base/events/base_on_voice_state_update_event_help_channel.py
View File

@@ -13,16 +13,15 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class BaseOnVoiceStateUpdateEventHelpChannel(OnVoiceStateUpdateABC):
def __init__(
self,
config: ConfigurationABC,
logger: LoggerABC,
base_helper: BaseHelperABC,
servers: ServerRepositoryABC,
permissions: PermissionServiceABC,
message_service: MessageServiceABC,
t: TranslatePipe,
self,
config: ConfigurationABC,
logger: LoggerABC,
base_helper: BaseHelperABC,
servers: ServerRepositoryABC,
permissions: PermissionServiceABC,
message_service: MessageServiceABC,
t: TranslatePipe,
):
OnVoiceStateUpdateABC.__init__(self)
self._config = config
@@ -33,21 +32,33 @@ class BaseOnVoiceStateUpdateEventHelpChannel(OnVoiceStateUpdateABC):
self._message_service = message_service
self._t = t
self._logger.info(__name__, f'Module {type(self)} loaded')
self._logger.info(__name__, f"Module {type(self)} loaded")
@EventChecks.check_is_ready()
async def on_voice_state_update(self, member: discord.Member, before: discord.VoiceState, after: discord.VoiceState):
self._logger.debug(__name__, f'Module {type(self)} started')
async def on_voice_state_update(
self,
member: discord.Member,
before: discord.VoiceState,
after: discord.VoiceState,
):
self._logger.debug(__name__, f"Module {type(self)} started")
server = self._servers.get_server_by_discord_id(member.guild.id)
settings: BaseServerSettings = self._base_helper.get_config(server.discord_server_id)
settings: BaseServerSettings = self._base_helper.get_config(
server.discord_server_id
)
if after.channel is None or after.channel.id != settings.help_voice_channel_id:
return
mods = [*self._permissions.get_admins(member.guild.id), *self._permissions.get_moderators(member.guild.id)]
mods = [
*self._permissions.get_admins(member.guild.id),
*self._permissions.get_moderators(member.guild.id),
]
for a in mods:
await self._message_service.send_dm_message(
self._t.transform('modules.base.member_joined_help_voice_channel').format(member.mention),
self._t.transform(
"modules.base.member_joined_help_voice_channel"
).format(member.mention),
a,
)
self._logger.debug(__name__, f'Module {type(self)} stopped')
self._logger.debug(__name__, f"Module {type(self)} stopped")

14
kdb-bot/src/modules/base/helper/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.base.helper'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.base.helper"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
VersionInfo = namedtuple('VersionInfo', 'major minor micro')
version_info = VersionInfo(major='0', minor='3', micro='0')
VersionInfo = namedtuple("VersionInfo", "major minor micro")
version_info = VersionInfo(major="0", minor="3", micro="0")

54
kdb-bot/src/modules/base/helper/base_reaction_handler.py
View File

@@ -14,16 +14,15 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class BaseReactionHandler:
def __init__(
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
users: UserRepositoryABC,
base_helper: BaseHelperABC,
client_utils: ClientUtilsABC,
db: DatabaseContextABC,
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
users: UserRepositoryABC,
base_helper: BaseHelperABC,
client_utils: ClientUtilsABC,
db: DatabaseContextABC,
):
self._logger = logger
self._bot = bot
@@ -34,47 +33,58 @@ class BaseReactionHandler:
self._db = db
async def handle(self, payload: RawReactionActionEvent, r_type=None) -> None:
self._logger.trace(__name__, f'Handle reaction {payload} {r_type}')
self._logger.trace(__name__, f"Handle reaction {payload} {r_type}")
guild = self._bot.get_guild(payload.guild_id)
member = guild.get_member(payload.user_id)
if member is None:
self._logger.warn(__name__, f'User {payload.user_id} in {guild.name} not found - skipping')
self._logger.warn(
__name__, f"User {payload.user_id} in {guild.name} not found - skipping"
)
return
try:
log_msg = f'{member.name} reacted'
log_msg = f"{member.name} reacted"
if payload.emoji.name is not None:
log_msg += f' with {payload.emoji.name}'
log_msg += f" with {payload.emoji.name}"
try:
channel = guild.get_channel(payload.channel_id)
message = await channel.fetch_message(payload.message_id)
self._logger.info(__name__, f'{log_msg} to message {LogMessageHelper.get_log_string(message)}')
self._logger.info(
__name__,
f"{log_msg} to message {LogMessageHelper.get_log_string(message)}",
)
except Exception as e:
self._logger.error(__name__, f'Getting message for reaction logging failed', e)
self._logger.info(__name__, f'{log_msg} to message {payload.message_id}')
self._logger.error(
__name__, f"Getting message for reaction logging failed", e
)
self._logger.info(
__name__, f"{log_msg} to message {payload.message_id}"
)
except Exception as e:
self._logger.error(__name__, f'Reaction logging failed', e)
self._logger.error(__name__, f"Reaction logging failed", e)
if member.bot:
return
server = self._servers.get_server_by_discord_id(guild.id)
user = self._users.get_user_by_discord_id_and_server_id(member.id, server.server_id)
user = self._users.get_user_by_discord_id_and_server_id(
member.id, server.server_id
)
settings: BaseServerSettings = self._base_helper.get_config(guild.id)
if r_type == 'add':
if r_type == "add":
if self._client_utils.is_message_xp_count_by_hour_higher_that_max_message_count_per_hour(
datetime.now(), user, settings, is_reaction=True
datetime.now(), user, settings, is_reaction=True
):
return
user.xp += settings.xp_per_reaction
self._users.update_user(user)
self._db.save_changes()
elif r_type == 'remove':
elif r_type == "remove":
user.xp -= settings.xp_per_reaction
self._users.update_user(user)
self._db.save_changes()
else:
self._logger.warn(__name__, f'Invalid reaction type {r_type}')
self._logger.warn(__name__, f"Invalid reaction type {r_type}")

14
kdb-bot/src/modules/base/service/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.base.service'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.base.service"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports
VersionInfo = namedtuple('VersionInfo', 'major minor micro')
version_info = VersionInfo(major='0', minor='3', micro='0')
VersionInfo = namedtuple("VersionInfo", "major minor micro")
version_info = VersionInfo(major="0", minor="3", micro="0")

3
kdb-bot/src/modules/base/service/base_helper_service.py
View File

@@ -5,10 +5,9 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class BaseHelperService(BaseHelperABC):
def __init__(self, config: ConfigurationABC):
BaseHelperABC.__init__(self)
self._config = config
def get_config(self, g_id: int) -> BaseServerSettings:
return self._config.get_configuration(f'BaseServerSettings_{g_id}')
return self._config.get_configuration(f"BaseServerSettings_{g_id}")

14
kdb-bot/src/modules/base/thread/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.base.thread'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.base.thread"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports
VersionInfo = namedtuple('VersionInfo', 'major minor micro')
version_info = VersionInfo(major='0', minor='3', micro='0')
VersionInfo = namedtuple("VersionInfo", "major minor micro")
version_info = VersionInfo(major="0", minor="3", micro="0")