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

16
kdb-bot/src/modules/auto_role/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.auto_role'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.auto_role"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
# 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")

27
kdb-bot/src/modules/auto_role/auto_role_module.py
View File

@@ -7,23 +7,36 @@ from cpl_discord.service.discord_collection_abc import DiscordCollectionABC
from bot_core.abc.module_abc import ModuleABC
from bot_core.configuration.feature_flags_enum import FeatureFlagsEnum
from modules.auto_role.command.auto_role_group import AutoRoleGroup
from modules.auto_role.events.auto_role_on_raw_reaction_add import AutoRoleOnRawReactionAddEvent
from modules.auto_role.events.auto_role_on_raw_reaction_remove import AutoRoleOnRawReactionRemoveEvent
from modules.auto_role.events.auto_role_on_raw_reaction_add import (
AutoRoleOnRawReactionAddEvent,
)
from modules.auto_role.events.auto_role_on_raw_reaction_remove import (
AutoRoleOnRawReactionRemoveEvent,
)
from modules.auto_role.helper.auto_role_reaction_handler import AutoRoleReactionHandler
class AutoRoleModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.auto_role_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(AutoRoleReactionHandler)
# commands
self._dc.add_command(AutoRoleGroup)
# events
self._dc.add_event(DiscordEventTypesEnum.on_raw_reaction_add.value, AutoRoleOnRawReactionAddEvent)
self._dc.add_event(DiscordEventTypesEnum.on_raw_reaction_remove.value, AutoRoleOnRawReactionRemoveEvent)
self._dc.add_event(
DiscordEventTypesEnum.on_raw_reaction_add.value,
AutoRoleOnRawReactionAddEvent,
)
self._dc.add_event(
DiscordEventTypesEnum.on_raw_reaction_remove.value,
AutoRoleOnRawReactionRemoveEvent,
)

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.auto_role.command'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.auto_role.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")

413
kdb-bot/src/modules/auto_role/command/auto_role_group.py
View File

@@ -23,18 +23,17 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class AutoRoleGroup(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
db_context: DatabaseContextABC,
permission_service: PermissionServiceABC,
self,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
db_context: DatabaseContextABC,
permission_service: PermissionServiceABC,
):
DiscordCommandABC.__init__(self)
@@ -48,118 +47,191 @@ class AutoRoleGroup(DiscordCommandABC):
self._db_context = db_context
self._permissions = permission_service
self._logger.trace(__name__, f'Loaded command service: {type(self).__name__}')
self._logger.trace(__name__, f"Loaded command service: {type(self).__name__}")
async def _auto_role_auto_complete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
async def _auto_role_auto_complete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
server = self._servers.get_server_by_discord_id(interaction.guild.id)
auto_roles = self._auto_roles.get_auto_roles_by_server_id(server.server_id).select(lambda x: x.auto_role_id)
return [app_commands.Choice(name=auto_role, value=auto_role) for auto_role in self._client_utils.get_auto_complete_list(auto_roles, current)]
auto_roles = self._auto_roles.get_auto_roles_by_server_id(
server.server_id
).select(lambda x: x.auto_role_id)
return [
app_commands.Choice(name=auto_role, value=auto_role)
for auto_role in self._client_utils.get_auto_complete_list(
auto_roles, current
)
]
@commands.hybrid_group(name="auto-role")
@commands.guild_only()
async def auto_role(self, ctx: Context):
pass
@auto_role.command(alias='auto-roles')
@auto_role.command(alias="auto-roles")
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def list(self, ctx: Context, wait: int = None):
self._logger.debug(__name__, f'Received command auto-role list {ctx}')
self._logger.debug(__name__, f"Received command auto-role list {ctx}")
if ctx.guild is None:
return
embed = discord.Embed(
title=self._t.transform('modules.auto_role.list.title'),
description=self._t.transform('modules.auto_role.list.description'),
color=int('ef9d0d', 16)
title=self._t.transform("modules.auto_role.list.title"),
description=self._t.transform("modules.auto_role.list.description"),
color=int("ef9d0d", 16),
)
server = self._servers.get_server_by_discord_id(ctx.guild.id)
auto_roles = self._auto_roles.get_auto_roles_by_server_id(server.server_id)
if auto_roles.count() < 1:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.error.nothing_found'))
self._logger.trace(__name__, f'Finished command auto-role list')
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.auto_role.error.nothing_found")
)
self._logger.trace(__name__, f"Finished command auto-role list")
return
auto_role_id = ''
message_id = ''
auto_role_id = ""
message_id = ""
for auto_role in auto_roles:
auto_role_id += f'\n{auto_role.auto_role_id}'
message_id += f'\n{auto_role.discord_message_id}'
auto_role_id += f"\n{auto_role.auto_role_id}"
message_id += f"\n{auto_role.discord_message_id}"
embed.add_field(name=self._t.transform('modules.auto_role.list.auto_role_id'), value=auto_role_id, inline=True)
embed.add_field(name=self._t.transform('modules.auto_role.list.message_id'), value=message_id, inline=True)
embed.add_field(
name=self._t.transform("modules.auto_role.list.auto_role_id"),
value=auto_role_id,
inline=True,
)
embed.add_field(
name=self._t.transform("modules.auto_role.list.message_id"),
value=message_id,
inline=True,
)
await self._message_service.send_ctx_msg(ctx, embed, wait_before_delete=wait)
self._logger.trace(__name__, f'Finished command auto-role list')
self._logger.trace(__name__, f"Finished command auto-role list")
@auto_role.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def add(self, ctx: Context, channel: discord.TextChannel, message_id: str):
self._logger.debug(__name__, f'Received command auto-role add {ctx} {message_id}')
self._logger.debug(
__name__, f"Received command auto-role add {ctx} {message_id}"
)
message = List(discord.Message, [message async for message in channel.history(limit=50)]).where(lambda m: m.id == int(message_id)).single_or_default()
message = (
List(
discord.Message,
[message async for message in channel.history(limit=50)],
)
.where(lambda m: m.id == int(message_id))
.single_or_default()
)
if message is None:
self._logger.debug(__name__, f'Message with id {message_id} not found in {channel.name}')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.add.error.not_found').format(message_id, channel.mention))
self._logger.trace(__name__, f'Finished command auto-role add')
self._logger.debug(
__name__, f"Message with id {message_id} not found in {channel.name}"
)
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.auto_role.add.error.not_found").format(
message_id, channel.mention
),
)
self._logger.trace(__name__, f"Finished command auto-role add")
return
if self._auto_roles.find_auto_role_by_message_id(int(message_id)) is not None:
self._logger.debug(__name__, f'auto-role for message {message_id} already exists')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.add.error.already_exists').format(message_id))
self._logger.trace(__name__, f'Finished command auto-role add')
self._logger.debug(
__name__, f"auto-role for message {message_id} already exists"
)
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.auto_role.add.error.already_exists").format(
message_id
),
)
self._logger.trace(__name__, f"Finished command auto-role add")
return
server_id = self._servers.get_server_by_discord_id(ctx.guild.id).server_id
self._auto_roles.add_auto_role(AutoRole(server_id, int(channel.id), int(message_id)))
self._auto_roles.add_auto_role(
AutoRole(server_id, int(channel.id), int(message_id))
)
self._db_context.save_changes()
self._logger.info(__name__, f'Saved auto-role for message {message_id} at server {server_id}')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.add.success').format(message_id))
self._logger.trace(__name__, f'Finished command auto-role add')
self._logger.info(
__name__, f"Saved auto-role for message {message_id} at server {server_id}"
)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.auto_role.add.success").format(message_id)
)
self._logger.trace(__name__, f"Finished command auto-role add")
@add.autocomplete('message_id')
async def add_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
channel = discord.utils.get(interaction.guild.text_channels, id=interaction.channel_id)
@add.autocomplete("message_id")
async def add_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
channel = discord.utils.get(
interaction.guild.text_channels, id=interaction.channel_id
)
try:
channel_from_data = interaction.data['options'][0]['options'][0]['value']
found_channel = discord.utils.get(interaction.guild.text_channels, id=int(channel_from_data))
channel_from_data = interaction.data["options"][0]["options"][0]["value"]
found_channel = discord.utils.get(
interaction.guild.text_channels, id=int(channel_from_data)
)
if found_channel is not None:
channel = found_channel
finally:
pass
messages = [message async for message in channel.history(limit=10)]
return [app_commands.Choice(name=f'{message.author}@{message.created_at}', value=str(message.id)) for message in messages if current in str(message.id)]
return [
app_commands.Choice(
name=f"{message.author}@{message.created_at}", value=str(message.id)
)
for message in messages
if current in str(message.id)
]
@auto_role.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def remove(self, ctx: Context, auto_role: int):
self._logger.debug(__name__, f'Received command auto-role remove {ctx} {auto_role}')
self._logger.debug(
__name__, f"Received command auto-role remove {ctx} {auto_role}"
)
auto_role_from_db = self._auto_roles.find_auto_role_by_id(auto_role)
if auto_role_from_db is None:
self._logger.debug(__name__, f'auto-role {auto_role} not found')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.remove.error.not_found').format(auto_role))
self._logger.trace(__name__, f'Finished command auto-role remove')
self._logger.debug(__name__, f"auto-role {auto_role} not found")
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.auto_role.remove.error.not_found").format(
auto_role
),
)
self._logger.trace(__name__, f"Finished command auto-role remove")
return
for rule in self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role_from_db.auto_role_id):
for rule in self._auto_roles.get_auto_role_rules_by_auto_role_id(
auto_role_from_db.auto_role_id
):
self._auto_roles.delete_auto_role_rule(rule)
self._logger.info(__name__, f'Removed auto-role rule {rule.role_id}')
self._logger.info(__name__, f"Removed auto-role rule {rule.role_id}")
self._auto_roles.delete_auto_role(auto_role_from_db)
self._db_context.save_changes()
self._logger.info(__name__, f'Removed auto-role {auto_role}')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.remove.success').format(auto_role))
self._logger.trace(__name__, f'Finished command auto-role remove')
self._logger.info(__name__, f"Removed auto-role {auto_role}")
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.auto_role.remove.success").format(auto_role)
)
self._logger.trace(__name__, f"Finished command auto-role remove")
@remove.autocomplete('auto_role')
async def remove_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
@remove.autocomplete("auto_role")
async def remove_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
return await self._auto_role_auto_complete(interaction, current)
@auto_role.group()
@@ -167,40 +239,56 @@ class AutoRoleGroup(DiscordCommandABC):
async def rule(self, ctx: Context):
pass
@rule.command(alias='rules')
@rule.command(alias="rules")
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def list(self, ctx: Context, auto_role: int, wait: int = None):
self._logger.debug(__name__, f'Received command auto-role rule list {ctx}')
self._logger.debug(__name__, f"Received command auto-role rule list {ctx}")
embed = discord.Embed(
title=self._t.transform('modules.auto_role.list.title'),
description=self._t.transform('modules.auto_role.list.description'),
color=int('ef9d0d', 16)
title=self._t.transform("modules.auto_role.list.title"),
description=self._t.transform("modules.auto_role.list.description"),
color=int("ef9d0d", 16),
)
rules = self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role)
if rules.count() < 1:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.rule.error.id_not_found'))
self._logger.trace(__name__, f'Finished command auto-role rule list')
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.auto_role.rule.error.id_not_found")
)
self._logger.trace(__name__, f"Finished command auto-role rule list")
return
auto_role_rule_id = ''
emoji = ''
role = ''
auto_role_rule_id = ""
emoji = ""
role = ""
for rule in rules:
auto_role_rule_id += f'\n{rule.role_id}'
emoji += f'\n{rule.emoji_name}'
role += f'\n{ctx.guild.get_role(rule.role_id)}'
auto_role_rule_id += f"\n{rule.role_id}"
emoji += f"\n{rule.emoji_name}"
role += f"\n{ctx.guild.get_role(rule.role_id)}"
embed.add_field(name=self._t.transform('modules.auto_role.rule.list.auto_role_rule_id'), value=auto_role_rule_id, inline=True)
embed.add_field(name=self._t.transform('modules.auto_role.rule.list.emoji'), value=emoji, inline=True)
embed.add_field(name=self._t.transform('modules.auto_role.rule.list.role'), value=role, inline=True)
embed.add_field(
name=self._t.transform("modules.auto_role.rule.list.auto_role_rule_id"),
value=auto_role_rule_id,
inline=True,
)
embed.add_field(
name=self._t.transform("modules.auto_role.rule.list.emoji"),
value=emoji,
inline=True,
)
embed.add_field(
name=self._t.transform("modules.auto_role.rule.list.role"),
value=role,
inline=True,
)
await self._message_service.send_ctx_msg(ctx, embed, wait_before_delete=wait)
self._logger.trace(__name__, f'Finished command auto-role rule list')
self._logger.trace(__name__, f"Finished command auto-role rule list")
@list.autocomplete('auto_role')
async def list_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
@list.autocomplete("auto_role")
async def list_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
return await self._auto_role_auto_complete(interaction, current)
@rule.command()
@@ -208,96 +296,183 @@ class AutoRoleGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def add(self, ctx: Context, auto_role: int, emoji_name: str, role_id: str):
self._logger.debug(__name__, f'Received command auto-role add {ctx} {auto_role}')
self._logger.debug(
__name__, f"Received command auto-role add {ctx} {auto_role}"
)
emoji = discord.utils.get(self._bot.emojis, name=emoji_name)
if emoji is None:
self._logger.debug(__name__, f'auto-role rule add emoji {emoji_name} not found')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.rule.add.error.emoji_not_found').format(emoji_name, auto_role))
self._logger.trace(__name__, f'Finished command auto-role add')
self._logger.debug(
__name__, f"auto-role rule add emoji {emoji_name} not found"
)
await self._message_service.send_ctx_msg(
ctx,
self._t.transform(
"modules.auto_role.rule.add.error.emoji_not_found"
).format(emoji_name, auto_role),
)
self._logger.trace(__name__, f"Finished command auto-role add")
return
role = ctx.guild.get_role(int(role_id))
if role is None:
self._logger.debug(__name__, f'auto-role rule add role {role_id} not found')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.rule.add.error.role_not_found').format(role_id, auto_role))
self._logger.trace(__name__, f'Finished command auto-role add')
self._logger.debug(__name__, f"auto-role rule add role {role_id} not found")
await self._message_service.send_ctx_msg(
ctx,
self._t.transform(
"modules.auto_role.rule.add.error.role_not_found"
).format(role_id, auto_role),
)
self._logger.trace(__name__, f"Finished command auto-role add")
return
auto_role_from_db = self._auto_roles.get_auto_role_by_id(auto_role)
if auto_role_from_db is None:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.remove.error.not_found').format(auto_role))
self._logger.trace(__name__, f'Finished command auto-role rule add')
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.auto_role.remove.error.not_found").format(
auto_role
),
)
self._logger.trace(__name__, f"Finished command auto-role rule add")
return
if self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role).where(lambda r: r.emoji_name == emoji.name and int(role_id) == role.id).first_or_default() is not None:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.add.error.already_exists').format(auto_role))
self._logger.trace(__name__, f'Finished command auto-role rule add')
if (
self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role)
.where(lambda r: r.emoji_name == emoji.name and int(role_id) == role.id)
.first_or_default()
is not None
):
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.auto_role.add.error.already_exists").format(
auto_role
),
)
self._logger.trace(__name__, f"Finished command auto-role rule add")
return
self._auto_roles.add_auto_role_rule(AutoRoleRule(auto_role, emoji_name, int(role_id)))
self._auto_roles.add_auto_role_rule(
AutoRoleRule(auto_role, emoji_name, int(role_id))
)
self._db_context.save_changes()
rule = self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role).where(lambda r: r.emoji_name == emoji.name and int(role_id) == role.id).single()
rule = (
self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role)
.where(lambda r: r.emoji_name == emoji.name and int(role_id) == role.id)
.single()
)
try:
guild: Guild = self._bot.guilds.where(lambda g: g == ctx.guild).single()
channel = guild.get_channel(auto_role_from_db.discord_channel_id)
message = await channel.fetch_message(auto_role_from_db.discord_message_id)
emoji = List(discord.Emoji, guild.emojis).where(lambda x: x.name == rule.emoji_name).single()
emoji = (
List(discord.Emoji, guild.emojis)
.where(lambda x: x.name == rule.emoji_name)
.single()
)
if emoji is None:
self._logger.debug(__name__, f'Emoji {rule.emoji_name} not found')
self._logger.debug(__name__, f"Emoji {rule.emoji_name} not found")
return
await message.add_reaction(emoji)
self._logger.debug(__name__, f'Added reaction {rule.emoji_name} to message: {auto_role_from_db.discord_message_id}')
self._logger.debug(
__name__,
f"Added reaction {rule.emoji_name} to message: {auto_role_from_db.discord_message_id}",
)
except Exception as e:
self._logger.error(__name__, f'Cannot add reaction {rule.emoji_name} to message: {auto_role_from_db.discord_message_id}', e)
self._logger.error(
__name__,
f"Cannot add reaction {rule.emoji_name} to message: {auto_role_from_db.discord_message_id}",
e,
)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.rule.add.success').format(emoji, role.mention, auto_role))
self._logger.trace(__name__, f'Finished command auto-role rule add')
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.auto_role.rule.add.success").format(
emoji, role.mention, auto_role
),
)
self._logger.trace(__name__, f"Finished command auto-role rule add")
@add.autocomplete('auto_role')
async def add_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
@add.autocomplete("auto_role")
async def add_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
return await self._auto_role_auto_complete(interaction, current)
@add.autocomplete('emoji_name')
async def add_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
@add.autocomplete("emoji_name")
async def add_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
emojis = List(discord.Emoji, interaction.guild.emojis)
return [app_commands.Choice(name=emoji.name, value=emoji.name) for emoji in self._client_utils.get_auto_complete_list(emojis, current, lambda e: e.name)]
return [
app_commands.Choice(name=emoji.name, value=emoji.name)
for emoji in self._client_utils.get_auto_complete_list(
emojis, current, lambda e: e.name
)
]
@add.autocomplete('role_id')
async def rule_add_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
@add.autocomplete("role_id")
async def rule_add_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
roles = List(discord.Role, interaction.guild.roles)
return [app_commands.Choice(name=role.name, value=str(role.id)) for role in self._client_utils.get_auto_complete_list(roles, current, lambda r: r.name)]
return [
app_commands.Choice(name=role.name, value=str(role.id))
for role in self._client_utils.get_auto_complete_list(
roles, current, lambda r: r.name
)
]
@rule.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def remove(self, ctx: Context, auto_role_rule: int):
self._logger.debug(__name__, f'Received command auto-role remove {ctx} {auto_role_rule}')
self._logger.debug(
__name__, f"Received command auto-role remove {ctx} {auto_role_rule}"
)
auto_role_from_db = self._auto_roles.get_auto_role_rule_by_id(auto_role_rule)
if auto_role_from_db is None:
self._logger.debug(__name__, f'auto-role rule {auto_role_rule} not found')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.remove.error.not_found').format(auto_role_rule))
self._logger.trace(__name__, f'Finished command auto-role rule remove')
self._logger.debug(__name__, f"auto-role rule {auto_role_rule} not found")
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.auto_role.remove.error.not_found").format(
auto_role_rule
),
)
self._logger.trace(__name__, f"Finished command auto-role rule remove")
return
self._auto_roles.delete_auto_role_rule(auto_role_from_db)
self._db_context.save_changes()
self._logger.info(__name__, f'Removed auto-role rule {auto_role_rule}')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.auto_role.rule.remove.success').format(auto_role_rule))
self._logger.trace(__name__, f'Finished command auto-role remove')
self._logger.info(__name__, f"Removed auto-role rule {auto_role_rule}")
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.auto_role.rule.remove.success").format(
auto_role_rule
),
)
self._logger.trace(__name__, f"Finished command auto-role remove")
@remove.autocomplete('auto_role_rule')
async def remove_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
@remove.autocomplete("auto_role_rule")
async def remove_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
server = self._servers.get_server_by_discord_id(interaction.guild.id)
auto_roles = self._auto_roles.get_auto_roles_by_server_id(server.server_id).select(lambda x: x.auto_role_id)
rules = auto_roles.select_many(lambda ar: self._auto_roles.get_auto_role_rules_by_auto_role_id(ar))
auto_roles = self._auto_roles.get_auto_roles_by_server_id(
server.server_id
).select(lambda x: x.auto_role_id)
rules = auto_roles.select_many(
lambda ar: self._auto_roles.get_auto_role_rules_by_auto_role_id(ar)
)
return [
app_commands.Choice(
name=f'{rule.auto_role_rule_id} {rule.emoji_name} {interaction.guild.get_role(int(rule.role_id))}',
value=rule.auto_role_rule_id
name=f"{rule.auto_role_rule_id} {rule.emoji_name} {interaction.guild.get_role(int(rule.role_id))}",
value=rule.auto_role_rule_id,
)
for rule in self._client_utils.get_auto_complete_list(
rules, current, lambda r: r.auto_role_rule_id
)
for rule in self._client_utils.get_auto_complete_list(rules, current, lambda r: r.auto_role_rule_id)
]

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.auto_role.events'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.auto_role.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")

19
kdb-bot/src/modules/auto_role/events/auto_role_on_raw_reaction_add.py
View File

@@ -10,14 +10,13 @@ from modules.auto_role.helper.auto_role_reaction_handler import AutoRoleReaction
class AutoRoleOnRawReactionAddEvent(OnRawReactionAddABC):
def __init__(
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
reaction_handler: AutoRoleReactionHandler
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
reaction_handler: AutoRoleReactionHandler,
):
OnRawReactionAddABC.__init__(self)
@@ -29,8 +28,8 @@ class AutoRoleOnRawReactionAddEvent(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/auto_role/events/auto_role_on_raw_reaction_remove.py
View File

@@ -10,14 +10,13 @@ from modules.auto_role.helper.auto_role_reaction_handler import AutoRoleReaction
class AutoRoleOnRawReactionRemoveEvent(OnRawReactionRemoveABC):
def __init__(
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
reaction_handler: AutoRoleReactionHandler
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
reaction_handler: AutoRoleReactionHandler,
):
OnRawReactionRemoveABC.__init__(self)
@@ -29,8 +28,8 @@ class AutoRoleOnRawReactionRemoveEvent(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")

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.auto_role.helper'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.auto_role.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")

47
kdb-bot/src/modules/auto_role/helper/auto_role_reaction_handler.py
View File

@@ -11,60 +11,67 @@ from bot_data.model.auto_role_rule import AutoRoleRule
class AutoRoleReactionHandler:
def __init__(
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
servers: ServerRepositoryABC,
auto_roles: AutoRoleRepositoryABC,
):
self._logger = logger
self._bot = bot
self._servers = servers
self._auto_roles = auto_roles
self._message_ids = self._auto_roles.get_auto_roles().select(lambda x: x.discord_message_id)
self._message_ids = self._auto_roles.get_auto_roles().select(
lambda x: x.discord_message_id
)
self._roles = self._auto_roles.get_auto_roles()
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}")
if payload.message_id not in self._message_ids:
self._logger.debug(__name__, f'Message not in auto-roles - skipping')
self._logger.debug(__name__, f"Message not in auto-roles - skipping")
return
guild = self._bot.get_guild(payload.guild_id)
user = guild.get_member(payload.user_id)
if user 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
if user.bot:
self._logger.debug(__name__, f'User is bot - skipping')
self._logger.debug(__name__, f"User is bot - skipping")
return
emoji = payload.emoji.name
auto_role: AutoRole = self._roles.where(lambda x: x.discord_message_id == payload.message_id).single_or_default()
auto_role: AutoRole = self._roles.where(
lambda x: x.discord_message_id == payload.message_id
).single_or_default()
if auto_role is None:
self._logger.debug(__name__, f'auto-role for message not found - skipping')
self._logger.debug(__name__, f"auto-role for message not found - skipping")
return
rules: List[AutoRoleRule] = self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role.auto_role_id)
rules: List[
AutoRoleRule
] = self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role.auto_role_id)
if rules.count() == 0:
self._logger.debug(__name__, f'auto-role rules not found - skipping')
self._logger.debug(__name__, f"auto-role rules not found - skipping")
return
for rule in rules:
if emoji != rule.emoji_name:
continue
if r_type == 'add':
if r_type == "add":
role = guild.get_role(rule.role_id)
self._logger.debug(__name__, f'Assign role {role.name} to {user.name}')
self._logger.debug(__name__, f"Assign role {role.name} to {user.name}")
await user.add_roles(role)
elif r_type == 'remove':
elif r_type == "remove":
role = guild.get_role(rule.role_id)
self._logger.debug(__name__, f'Remove role {role.name} to {user.name}')
self._logger.debug(__name__, f"Remove role {role.name} to {user.name}")
await user.remove_roles(role)
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/__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")

16
kdb-bot/src/modules/boot_log/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.boot_log'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.boot_log"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
# 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")

9
kdb-bot/src/modules/boot_log/boot_log_extension.py
View File

@@ -10,14 +10,15 @@ from bot_core.configuration.feature_flags_settings import FeatureFlagsSettings
class BootLogExtension(ApplicationExtensionABC):
def __init__(self):
pass
async def run(self, config: ConfigurationABC, services: ServiceProviderABC):
feature_flags: FeatureFlagsSettings = config.get_configuration(FeatureFlagsSettings)
feature_flags: FeatureFlagsSettings = config.get_configuration(
FeatureFlagsSettings
)
if not feature_flags.get_flag(FeatureFlagsEnum.boot_log_module):
return
logger: LoggerABC = services.get_service(LoggerABC)
logger.debug(__name__, 'BootLog extension started')
config.add_configuration('Bot_StartTime', str(datetime.now()))
logger.debug(__name__, "BootLog extension started")
config.add_configuration("Bot_StartTime", str(datetime.now()))

9
kdb-bot/src/modules/boot_log/boot_log_module.py
View File

@@ -10,14 +10,17 @@ from modules.boot_log.boot_log_on_ready_event import BootLogOnReadyEvent
class BootLogModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.boot_log_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
):
# commands
# events
self._dc.add_event(DiscordEventTypesEnum.on_ready.value, BootLogOnReadyEvent)

73
kdb-bot/src/modules/boot_log/boot_log_on_ready_event.py
View File

@@ -9,18 +9,19 @@ from discord import guild
from bot_core.abc.message_service_abc import MessageServiceABC
from bot_core.configuration.server_settings import ServerSettings
from modules.boot_log.configuration.boot_log_server_settings import BootLogServerSettings
from modules.boot_log.configuration.boot_log_server_settings import (
BootLogServerSettings,
)
class BootLogOnReadyEvent(OnReadyABC):
def __init__(
self,
config: ConfigurationABC,
logger: LoggerABC,
bot: DiscordBotServiceABC,
message_service: MessageServiceABC,
translate: TranslatePipe
self,
config: ConfigurationABC,
logger: LoggerABC,
bot: DiscordBotServiceABC,
message_service: MessageServiceABC,
translate: TranslatePipe,
):
OnReadyABC.__init__(self)
self._config = config
@@ -30,49 +31,61 @@ class BootLogOnReadyEvent(OnReadyABC):
self._message_service = message_service
self._t = translate
self._logger.info(__name__, f'Module {type(self)} loaded')
self._logger.info(__name__, f"Module {type(self)} loaded")
async def on_ready(self):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.debug(__name__, f"Module {type(self)} started")
try:
start_time = self._config.get_configuration('Bot_StartTime')
init_time = round((datetime.now() - datetime.strptime(start_time, '%Y-%m-%d %H:%M:%S.%f')).total_seconds(), 2)
self._config.add_configuration('InitTime', str(init_time))
self._logger.debug(__name__, f'Bot Init time: {init_time}s')
start_time = self._config.get_configuration("Bot_StartTime")
init_time = round(
(
datetime.now()
- datetime.strptime(start_time, "%Y-%m-%d %H:%M:%S.%f")
).total_seconds(),
2,
)
self._config.add_configuration("InitTime", str(init_time))
self._logger.debug(__name__, f"Bot Init time: {init_time}s")
# print warning if initialisation took too long
if init_time >= 30:
self._logger.warn(
__name__, 'It takes too long to start the bot!')
self._logger.warn(__name__, "It takes too long to start the bot!")
# print error if initialisation took way too long
elif init_time >= 90:
self._logger.error(
__name__, 'It takes far too long to start the bot!!!')
__name__, "It takes far too long to start the bot!!!"
)
except Exception as e:
self._logger.error(__name__, 'Init time calculation failed', e)
self._logger.error(__name__, "Init time calculation failed", e)
return
for g in self._bot.guilds:
g: guild = g
self._logger.debug(__name__, f'Server detected: {g.id}')
self._logger.debug(__name__, f"Server detected: {g.id}")
server_settings: ServerSettings = self._config.get_configuration(f'ServerSettings_{g.id}')
server_settings: ServerSettings = self._config.get_configuration(
f"ServerSettings_{g.id}"
)
if server_settings is None:
self._logger.error(__name__, f'BootLog settings for server {g.id} not found!')
self._logger.error(
__name__, f"BootLog settings for server {g.id} not found!"
)
return
module_settings: BootLogServerSettings = self._config.get_configuration(f'BootLogServerSettings_{g.id}')
module_settings: BootLogServerSettings = self._config.get_configuration(
f"BootLogServerSettings_{g.id}"
)
if module_settings is None:
self._logger.error(__name__, f'Config {type(self).__name__}_{g.id} not found!')
self._logger.error(
__name__, f"Config {type(self).__name__}_{g.id} not found!"
)
return
await self._message_service.send_channel_message(
self._bot.get_channel(
module_settings.login_message_channel_id
),
self._t.transform('modules.boot_log.login_message').format(init_time)
self._bot.get_channel(module_settings.login_message_channel_id),
self._t.transform("modules.boot_log.login_message").format(init_time),
)
self._config.add_configuration('IS_READY', 'true')
self._logger.info(__name__, 'Bot is ready')
self._logger.trace(__name__, f'Module {type(self)} stopped')
self._config.add_configuration("IS_READY", "true")
self._logger.info(__name__, "Bot is ready")
self._logger.trace(__name__, f"Module {type(self)} stopped")

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.boot_log.configuration'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.boot_log.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")

15
kdb-bot/src/modules/boot_log/configuration/boot_log_server_settings.py
View File

@@ -5,7 +5,6 @@ from cpl_core.console import Console
class BootLogServerSettings(ConfigurationModelABC):
def __init__(self):
ConfigurationModelABC.__init__(self)
@@ -15,15 +14,19 @@ class BootLogServerSettings(ConfigurationModelABC):
@property
def id(self) -> int:
return self._id
@property
def login_message_channel_id(self) -> int:
return self._login_message_channel_id
def from_dict(self, settings: dict):
try:
self._id = int(settings['Id'])
self._login_message_channel_id = int(settings['LoginMessageChannelId'])
self._id = int(settings["Id"])
self._login_message_channel_id = int(settings["LoginMessageChannelId"])
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()}"
)

15
kdb-bot/src/modules/boot_log/configuration/boot_log_settings.py
View File

@@ -4,11 +4,12 @@ from cpl_core.configuration.configuration_model_abc import ConfigurationModelABC
from cpl_core.console import Console
from cpl_query.extension import List
from modules.boot_log.configuration.boot_log_server_settings import BootLogServerSettings
from modules.boot_log.configuration.boot_log_server_settings import (
BootLogServerSettings,
)
class BootLogSettings(ConfigurationModelABC):
def __init__(self):
ConfigurationModelABC.__init__(self)
@@ -23,10 +24,14 @@ class BootLogSettings(ConfigurationModelABC):
servers = List(BootLogServerSettings)
for s in settings:
st = BootLogServerSettings()
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()}"
)

16
kdb-bot/src/modules/database/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.database'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.database"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
# 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")

9
kdb-bot/src/modules/database/database_extension.py
View File

@@ -13,16 +13,17 @@ from bot_data.service.seeder_service import SeederService
class DatabaseExtension(ApplicationExtensionABC):
def __init__(self):
pass
async def run(self, config: ConfigurationABC, services: ServiceProviderABC):
feature_flags: FeatureFlagsSettings = config.get_configuration(FeatureFlagsSettings)
feature_flags: FeatureFlagsSettings = config.get_configuration(
FeatureFlagsSettings
)
if not feature_flags.get_flag(FeatureFlagsEnum.data_module):
return
logger: LoggerABC = services.get_service(DatabaseLogger)
logger.debug(__name__, 'Database extension started')
config.add_configuration('Database_StartTime', str(datetime.now()))
logger.debug(__name__, "Database extension started")
config.add_configuration("Database_StartTime", str(datetime.now()))
migrations: MigrationService = services.get_service(MigrationService)
migrations.migrate()

9
kdb-bot/src/modules/database/database_module.py
View File

@@ -10,14 +10,17 @@ from modules.database.database_on_ready_event import DatabaseOnReadyEvent
class DatabaseModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.database_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
):
# commands
# events
self._dc.add_event(DiscordEventTypesEnum.on_ready.value, DatabaseOnReadyEvent)

225
kdb-bot/src/modules/database/database_on_ready_event.py
View File

@@ -12,7 +12,9 @@ from bot_core.pipes.date_time_offset_pipe import DateTimeOffsetPipe
from bot_data.abc.client_repository_abc import ClientRepositoryABC
from bot_data.abc.known_user_repository_abc import KnownUserRepositoryABC
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.client import Client
from bot_data.model.known_user import KnownUser
@@ -26,7 +28,6 @@ from modules.base.configuration.base_server_settings import BaseServerSettings
class DatabaseOnReadyEvent(OnReadyABC):
def __init__(
self,
config: ConfigurationABC,
@@ -40,7 +41,7 @@ class DatabaseOnReadyEvent(OnReadyABC):
known_users: KnownUserRepositoryABC,
user_joins: UserJoinedServerRepositoryABC,
user_joins_vc: UserJoinedVoiceChannelRepositoryABC,
dtp: DateTimeOffsetPipe
dtp: DateTimeOffsetPipe,
):
self._config = config
@@ -57,55 +58,67 @@ class DatabaseOnReadyEvent(OnReadyABC):
self._dtp = dtp
OnReadyABC.__init__(self)
self._logger.info(__name__, f'Module {type(self)} loaded')
self._logger.info(__name__, f"Module {type(self)} loaded")
def _validate_init_time(self):
try:
start_time = self._config.get_configuration('Database_StartTime')
init_time = round((datetime.now() - datetime.strptime(start_time, '%Y-%m-%d %H:%M:%S.%f')).total_seconds(), 2)
self._config.add_configuration('Database_InitTime', str(init_time))
self._logger.debug(__name__, f'Database Init time: {init_time}s')
start_time = self._config.get_configuration("Database_StartTime")
init_time = round(
(
datetime.now()
- datetime.strptime(start_time, "%Y-%m-%d %H:%M:%S.%f")
).total_seconds(),
2,
)
self._config.add_configuration("Database_InitTime", str(init_time))
self._logger.debug(__name__, f"Database Init time: {init_time}s")
# print warning if initialisation took too long
if init_time >= 30:
self._logger.warn(
__name__, 'It takes too long to prepare the database!')
__name__, "It takes too long to prepare the database!"
)
# print error if initialisation took way too long
elif init_time >= 90:
self._logger.error(
__name__, 'It takes far too long to prepare the database!!!')
__name__, "It takes far too long to prepare the database!!!"
)
except Exception as e: #
self._logger.error(__name__, 'Database init time calculation failed', e)
self._logger.error(__name__, "Database init time calculation failed", e)
return
def _check_known_users(self):
self._logger.debug(__name__, f'Start checking KnownUsers table, {len(self._bot.users)}')
self._logger.debug(
__name__, f"Start checking KnownUsers table, {len(self._bot.users)}"
)
for u in self._bot.users:
u: discord.User = u
try:
if u.bot:
self._logger.trace(__name__, f'User {u.id} is ignored, because its a bot')
self._logger.trace(
__name__, f"User {u.id} is ignored, because its a bot"
)
continue
user = self._known_users.find_user_by_discord_id(u.id)
if user is not None:
continue
self._logger.warn(__name__, f'Unknown user: {u.id}')
self._logger.debug(__name__, f'Add user: {u.id}')
self._logger.warn(__name__, f"Unknown user: {u.id}")
self._logger.debug(__name__, f"Add user: {u.id}")
self._known_users.add_user(KnownUser(u.id))
self._db_context.save_changes()
user = self._known_users.find_user_by_discord_id(u.id)
if user is None:
self._logger.fatal(__name__, f'Cannot add user: {u.id}')
self._logger.fatal(__name__, f"Cannot add user: {u.id}")
self._logger.debug(__name__, f'Added user: {u.id}')
self._logger.debug(__name__, f"Added user: {u.id}")
except Exception as e:
self._logger.error(__name__, f'Cannot get user', e)
self._logger.error(__name__, f"Cannot get user", e)
def _check_servers(self):
self._logger.debug(__name__, f'Start checking Servers table')
self._logger.debug(__name__, f"Start checking Servers table")
for g in self._bot.guilds:
g: discord.Guild = g
try:
@@ -113,123 +126,157 @@ class DatabaseOnReadyEvent(OnReadyABC):
if server is not None:
continue
self._logger.warn(__name__, f'Server not found in database: {g.id}')
self._logger.debug(__name__, f'Add server: {g.id}')
self._logger.warn(__name__, f"Server not found in database: {g.id}")
self._logger.debug(__name__, f"Add server: {g.id}")
self._servers.add_server(Server(g.id))
self._db_context.save_changes()
server = self._servers.find_server_by_discord_id(g.id)
if server is None:
self._logger.fatal(__name__, f'Cannot add server: {g.id}')
self._logger.fatal(__name__, f"Cannot add server: {g.id}")
self._logger.debug(__name__, f'Added server: {g.id}')
self._logger.debug(__name__, f"Added server: {g.id}")
except Exception as e:
self._logger.error(__name__, f'Cannot get server', e)
self._logger.error(__name__, f"Cannot get server", e)
results = self._servers.get_servers()
if results is None or len(results) == 0:
self._logger.error(__name__, f'Table Servers is empty!')
self._logger.error(__name__, f"Table Servers is empty!")
def _check_clients(self):
self._logger.debug(__name__, f'Start checking Clients table')
self._logger.debug(__name__, f"Start checking Clients table")
for g in self._bot.guilds:
g: discord.Guild = g
try:
server: Server = self._servers.find_server_by_discord_id(g.id)
if server is None:
self._logger.fatal(__name__, f'Server not found in database: {g.id}')
self._logger.fatal(
__name__, f"Server not found in database: {g.id}"
)
client = self._clients.find_client_by_server_id(server.server_id)
if client is not None:
continue
self._logger.warn(__name__, f'Client for server {g.id} not found in database: {self._bot.user.id}')
self._logger.debug(__name__, f'Add client: {self._bot.user.id}')
self._clients.add_client(Client(self._bot.user.id, 0, 0, 0, 0, 0, server))
self._logger.warn(
__name__,
f"Client for server {g.id} not found in database: {self._bot.user.id}",
)
self._logger.debug(__name__, f"Add client: {self._bot.user.id}")
self._clients.add_client(
Client(self._bot.user.id, 0, 0, 0, 0, 0, server)
)
self._db_context.save_changes()
client = self._clients.find_client_by_server_id(server.server_id)
if client is None:
self._logger.fatal(__name__, f'Cannot add client {self._bot.user.id} for server {g.id}')
self._logger.fatal(
__name__,
f"Cannot add client {self._bot.user.id} for server {g.id}",
)
self._logger.debug(__name__, f'Added client: {g.id}')
self._logger.debug(__name__, f"Added client: {g.id}")
except Exception as e:
self._logger.error(__name__, f'Cannot get client', e)
self._logger.error(__name__, f"Cannot get client", e)
results = self._servers.get_servers()
if results is None or len(results) == 0:
self._logger.error(__name__, f'Table Servers is empty!')
self._logger.error(__name__, f"Table Servers is empty!")
def _check_users(self):
self._logger.debug(__name__, f'Start checking Users table')
self._logger.debug(__name__, f"Start checking Users table")
for g in self._bot.guilds:
g: discord.Guild = g
try:
server = self._servers.find_server_by_discord_id(g.id)
if server is None:
self._logger.fatal(__name__, f'Server not found in database: {g.id}')
self._logger.fatal(
__name__, f"Server not found in database: {g.id}"
)
for u in g.members:
u: Union[discord.Member, discord.User] = u
if u.bot:
self._logger.trace(__name__, f'User {u.id} is ignored, because its a bot')
self._logger.trace(
__name__, f"User {u.id} is ignored, because its a bot"
)
continue
user = self._users.find_user_by_discord_id_and_server_id(u.id, server.server_id)
user = self._users.find_user_by_discord_id_and_server_id(
u.id, server.server_id
)
if user is not None:
continue
self._logger.warn(__name__, f'User not found in database: {u.id}')
self._logger.debug(__name__, f'Add user: {u.id}')
self._logger.warn(__name__, f"User not found in database: {u.id}")
self._logger.debug(__name__, f"Add user: {u.id}")
self._users.add_user(User(u.id, 0, server))
self._db_context.save_changes()
self._logger.debug(__name__, f'Added User: {u.id}')
self._logger.debug(__name__, f"Added User: {u.id}")
except Exception as e:
self._logger.error(__name__, f'Cannot get User', e)
self._logger.error(__name__, f"Cannot get User", e)
results = self._users.get_users()
if results is None or len(results) == 0:
self._logger.error(__name__, f'Table Users is empty!')
self._logger.error(__name__, f"Table Users is empty!")
def _check_user_joins(self):
self._logger.debug(__name__, f'Start checking UserJoinedServers table')
self._logger.debug(__name__, f"Start checking UserJoinedServers table")
for guild in self._bot.guilds:
guild: discord.Guild = guild
server = self._servers.find_server_by_discord_id(guild.id)
if server is None:
self._logger.fatal(__name__, f'Server not found in database: {guild.id}')
self._logger.fatal(
__name__, f"Server not found in database: {guild.id}"
)
try:
for u in guild.members:
u: discord.User = u
if u.bot:
self._logger.trace(__name__, f'User {u.id} is ignored, because its a bot')
self._logger.trace(
__name__, f"User {u.id} is ignored, because its a bot"
)
continue
user = self._users.find_user_by_discord_id_and_server_id(u.id, server.server_id)
user = self._users.find_user_by_discord_id_and_server_id(
u.id, server.server_id
)
if user is None:
self._logger.fatal(__name__, f'User not found in database: {u.id}')
self._logger.fatal(
__name__, f"User not found in database: {u.id}"
)
join = self._user_joins.find_active_user_joined_server_by_user_id(user.user_id)
join = self._user_joins.find_active_user_joined_server_by_user_id(
user.user_id
)
if join is not None:
continue
m: discord.Member = u
self._logger.warn(__name__, f'Active UserJoinedServer not found in database: {guild.id}:{u.id}@{m.joined_at}')
self._logger.debug(__name__, f'Add UserJoinedServer: {guild.id}:{u.id}@{m.joined_at}')
self._user_joins.add_user_joined_server(UserJoinedServer(user, self._dtp.transform(m.joined_at), None))
self._logger.warn(
__name__,
f"Active UserJoinedServer not found in database: {guild.id}:{u.id}@{m.joined_at}",
)
self._logger.debug(
__name__,
f"Add UserJoinedServer: {guild.id}:{u.id}@{m.joined_at}",
)
self._user_joins.add_user_joined_server(
UserJoinedServer(user, self._dtp.transform(m.joined_at), None)
)
self._db_context.save_changes()
self._logger.debug(__name__, f'Added UserJoinedServer: {u.id}')
self._logger.debug(__name__, f"Added UserJoinedServer: {u.id}")
except Exception as e:
self._logger.error(__name__, f'Cannot get UserJoinedServer', e)
self._logger.error(__name__, f"Cannot get UserJoinedServer", e)
results = self._users.get_users()
if results is None or len(results) == 0:
self._logger.error(__name__, f'Table Users is empty!')
self._logger.error(__name__, f"Table Users is empty!")
joins = self._user_joins.get_user_joined_servers()
for join in joins:
@@ -242,42 +289,64 @@ class DatabaseOnReadyEvent(OnReadyABC):
dc_user = guild.get_member(join.user.discord_id)
if dc_user is None:
self._logger.warn(__name__, f'User {join.user.discord_id} already left the server.')
self._logger.warn(
__name__,
f"User {join.user.discord_id} already left the server.",
)
join.leaved_on = datetime.now()
self._user_joins.update_user_joined_server(join)
self._db_context.save_changes()
def _check_user_joins_vc(self):
self._logger.debug(__name__, f'Start checking UserJoinedVoiceChannel table')
self._logger.debug(__name__, f"Start checking UserJoinedVoiceChannel table")
for guild in self._bot.guilds:
guild: discord.Guild = guild
server = self._servers.find_server_by_discord_id(guild.id)
if server is None:
self._logger.fatal(__name__, f'Server not found in database: {guild.id}')
self._logger.fatal(
__name__, f"Server not found in database: {guild.id}"
)
try:
for member in guild.members:
if member.bot:
self._logger.trace(__name__, f'User {member.id} is ignored, because its a bot')
self._logger.trace(
__name__, f"User {member.id} is ignored, because its a bot"
)
continue
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.fatal(__name__, f'User not found in database: {member.id}')
self._logger.fatal(
__name__, f"User not found in database: {member.id}"
)
joins = self._user_joins_vc.find_active_user_joined_voice_channels_by_user_id(user.user_id)
joins = self._user_joins_vc.find_active_user_joined_voice_channels_by_user_id(
user.user_id
)
if joins is None or len(joins) == 0:
continue
for join in joins:
self._logger.warn(__name__, f'Active UserJoinedVoiceChannel found in database: {guild.id}:{member.id}@{join.joined_on}')
self._logger.warn(
__name__,
f"Active UserJoinedVoiceChannel found in database: {guild.id}:{member.id}@{join.joined_on}",
)
join.leaved_on = datetime.now()
settings: BaseServerSettings = self._config.get_configuration(f'BaseServerSettings_{guild.id}')
settings: BaseServerSettings = self._config.get_configuration(
f"BaseServerSettings_{guild.id}"
)
if ((join.leaved_on - join.joined_on).total_seconds() / 60 / 60) > settings.max_voice_state_hours:
join.leaved_on = join.joined_on + timedelta(hours=settings.max_voice_state_hours)
if (
(join.leaved_on - join.joined_on).total_seconds() / 60 / 60
) > settings.max_voice_state_hours:
join.leaved_on = join.joined_on + timedelta(
hours=settings.max_voice_state_hours
)
self._user_joins_vc.update_user_joined_voice_channel(join)
# todo: maybe add XP
@@ -285,26 +354,34 @@ class DatabaseOnReadyEvent(OnReadyABC):
for member in guild.members:
if member.bot:
self._logger.trace(__name__, f'User {member.id} is ignored, because its a bot')
self._logger.trace(
__name__, f"User {member.id} is ignored, because its a bot"
)
continue
if member.voice is None:
continue
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.fatal(__name__, f'User not found in database: {member.id}')
self._logger.fatal(
__name__, f"User not found in database: {member.id}"
)
join = UserJoinedVoiceChannel(user, member.voice.channel.id, datetime.now())
join = UserJoinedVoiceChannel(
user, member.voice.channel.id, datetime.now()
)
self._user_joins_vc.add_user_joined_voice_channel(join)
self._db_context.save_changes()
self._logger.warn(__name__, f'VS {member.voice}')
self._logger.warn(__name__, f"VS {member.voice}")
except Exception as e:
self._logger.error(__name__, f'Cannot get UserJoinedVoiceChannel', e)
self._logger.error(__name__, f"Cannot get UserJoinedVoiceChannel", e)
async def on_ready(self):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.debug(__name__, f"Module {type(self)} started")
await self._seeder.seed()
@@ -316,4 +393,4 @@ class DatabaseOnReadyEvent(OnReadyABC):
self._check_user_joins_vc()
self._validate_init_time()
self._logger.trace(__name__, f'Module {type(self)} stopped')
self._logger.trace(__name__, f"Module {type(self)} stopped")

16
kdb-bot/src/modules/level/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.level'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.level"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
# 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/level/command/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.level.command'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.level.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")

449
kdb-bot/src/modules/level/command/level_group.py
View File

@@ -24,21 +24,20 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class LevelGroup(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
permission_service: PermissionServiceABC,
translate: TranslatePipe,
db: DatabaseContextABC,
levels: LevelRepositoryABC,
servers: ServerRepositoryABC,
users: UserRepositoryABC,
level_service: LevelService,
level_seeder: LevelSeeder,
self,
logger: CommandLogger,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
permission_service: PermissionServiceABC,
translate: TranslatePipe,
db: DatabaseContextABC,
levels: LevelRepositoryABC,
servers: ServerRepositoryABC,
users: UserRepositoryABC,
level_service: LevelService,
level_seeder: LevelSeeder,
):
DiscordCommandABC.__init__(self)
@@ -57,72 +56,79 @@ class LevelGroup(DiscordCommandABC):
self._level_seeder = level_seeder
self._colors = [
('blue', discord.Colour.blue().to_rgb()),
('dark_blue', discord.Colour.dark_blue().to_rgb()),
('dark_gold', discord.Colour.dark_gold().to_rgb()),
('dark_gray', discord.Colour.dark_gray().to_rgb()),
('dark_green', discord.Colour.dark_green().to_rgb()),
('dark_grey', discord.Colour.dark_grey().to_rgb()),
('dark_magenta', discord.Colour.dark_magenta().to_rgb()),
('dark_orange', discord.Colour.dark_orange().to_rgb()),
('dark_purple', discord.Colour.dark_purple().to_rgb()),
('dark_red', discord.Colour.dark_red().to_rgb()),
('dark_teal', discord.Colour.dark_teal().to_rgb()),
('default', discord.Colour.default().to_rgb()),
('gold', discord.Colour.gold().to_rgb()),
('green', discord.Colour.green().to_rgb()),
('greyple', discord.Colour.greyple().to_rgb()),
('light_grey', discord.Colour.light_grey().to_rgb()),
('magenta', discord.Colour.magenta().to_rgb()),
('orange', discord.Colour.orange().to_rgb()),
('purple', discord.Colour.purple().to_rgb()),
('red', discord.Colour.red().to_rgb()),
('teal', discord.Colour.teal().to_rgb()),
('yellow', discord.Colour.yellow().to_rgb())
("blue", discord.Colour.blue().to_rgb()),
("dark_blue", discord.Colour.dark_blue().to_rgb()),
("dark_gold", discord.Colour.dark_gold().to_rgb()),
("dark_gray", discord.Colour.dark_gray().to_rgb()),
("dark_green", discord.Colour.dark_green().to_rgb()),
("dark_grey", discord.Colour.dark_grey().to_rgb()),
("dark_magenta", discord.Colour.dark_magenta().to_rgb()),
("dark_orange", discord.Colour.dark_orange().to_rgb()),
("dark_purple", discord.Colour.dark_purple().to_rgb()),
("dark_red", discord.Colour.dark_red().to_rgb()),
("dark_teal", discord.Colour.dark_teal().to_rgb()),
("default", discord.Colour.default().to_rgb()),
("gold", discord.Colour.gold().to_rgb()),
("green", discord.Colour.green().to_rgb()),
("greyple", discord.Colour.greyple().to_rgb()),
("light_grey", discord.Colour.light_grey().to_rgb()),
("magenta", discord.Colour.magenta().to_rgb()),
("orange", discord.Colour.orange().to_rgb()),
("purple", discord.Colour.purple().to_rgb()),
("red", discord.Colour.red().to_rgb()),
("teal", discord.Colour.teal().to_rgb()),
("yellow", discord.Colour.yellow().to_rgb()),
]
self._logger.trace(__name__, f'Loaded command service: {type(self).__name__}')
self._logger.trace(__name__, f"Loaded command service: {type(self).__name__}")
async def _seed_levels(self, ctx: Context):
# send message to ctx.channel because send_ctx_msg resolves ctx
try:
start = await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.seeding_started'),
is_persistent=True
self._t.transform("modules.level.seeding_started"),
is_persistent=True,
)
await self._level_seeder.seed()
end = await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.seeding_finished'),
is_persistent=True
self._t.transform("modules.level.seeding_finished"),
is_persistent=True,
)
await self._message_service.delete_message(start)
await self._message_service.delete_message(end)
except Exception as e:
self._logger.error(__name__, f'Level seeding failed', e)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.seeding_failed'))
self._logger.error(__name__, f"Level seeding failed", e)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.level.seeding_failed")
)
async def _level_auto_complete(self, interaction: discord.Interaction, current: str) -> TList[
app_commands.Choice[str]]:
async def _level_auto_complete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
server = self._servers.get_server_by_discord_id(interaction.guild.id)
levels = self._levels.get_levels_by_server_id(server.server_id).select(lambda l: l.name)
return [app_commands.Choice(name=level, value=level) for level in
self._client_utils.get_auto_complete_list(levels, current)]
levels = self._levels.get_levels_by_server_id(server.server_id).select(
lambda l: l.name
)
return [
app_commands.Choice(name=level, value=level)
for level in self._client_utils.get_auto_complete_list(levels, current)
]
@commands.hybrid_group()
@commands.guild_only()
async def level(self, ctx: Context):
pass
@level.command(alias='levels')
@level.command(alias="levels")
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def list(self, ctx: Context, wait: int = None):
self._logger.debug(__name__, f'Received command level list {ctx}')
self._logger.debug(__name__, f"Received command level list {ctx}")
if ctx.guild is None:
return
@@ -130,46 +136,60 @@ class LevelGroup(DiscordCommandABC):
server = self._servers.get_server_by_discord_id(ctx.guild.id)
levels = self._levels.get_levels_by_server_id(server.server_id)
if levels.count() < 1:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.error.nothing_found'))
self._logger.trace(__name__, f'Finished command level list')
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.level.error.nothing_found")
)
self._logger.trace(__name__, f"Finished command level list")
return
level_name = ''
xp = ''
permissions = ''
level_name = ""
xp = ""
permissions = ""
for level in levels:
level_name += f'\n{level.name}'
xp += f'\n{level.min_xp}'
permissions += f'\n{level.permissions}'
level_name += f"\n{level.name}"
xp += f"\n{level.min_xp}"
permissions += f"\n{level.permissions}"
embed = discord.Embed(
title=self._t.transform('modules.level.list.title'),
description=self._t.transform('modules.level.list.description'),
color=int('ef9d0d', 16)
title=self._t.transform("modules.level.list.title"),
description=self._t.transform("modules.level.list.description"),
color=int("ef9d0d", 16),
)
embed.add_field(
name=self._t.transform("modules.level.list.name"),
value=level_name,
inline=True,
)
embed.add_field(
name=self._t.transform("modules.level.list.min_xp"), value=xp, inline=True
)
embed.add_field(
name=self._t.transform("modules.level.list.permission_int"),
value=permissions,
inline=True,
)
embed.add_field(name=self._t.transform('modules.level.list.name'), value=level_name, inline=True)
embed.add_field(name=self._t.transform('modules.level.list.min_xp'), value=xp, inline=True)
embed.add_field(name=self._t.transform('modules.level.list.permission_int'), value=permissions, inline=True)
await self._message_service.send_ctx_msg(ctx, embed, wait_before_delete=wait)
self._logger.trace(__name__, f'Finished command level list')
self._logger.trace(__name__, f"Finished command level list")
@level.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_admin()
async def create(self, ctx: Context, name: str, color: str, min_xp: int, permissions: int):
self._logger.debug(__name__, f'Received command level create {ctx}')
async def create(
self, ctx: Context, name: str, color: str, min_xp: int, permissions: int
):
self._logger.debug(__name__, f"Received command level create {ctx}")
try:
color = hex(discord.Colour.from_str(color).value)
except Exception as e:
self._logger.error(__name__, f'Error parsing color {color}', e)
self._logger.error(__name__, f"Error parsing color {color}", e)
return
try:
permissions = discord.Permissions(permissions).value
except Exception as e:
self._logger.error(__name__, f'Error parsing permissions {permissions}', e)
self._logger.error(__name__, f"Error parsing permissions {permissions}", e)
return
if ctx.guild is None:
@@ -180,47 +200,67 @@ class LevelGroup(DiscordCommandABC):
levels = self._levels.get_levels_by_server_id(server.server_id)
if levels.where(lambda l: l.name == level.name).first_or_default() is not None:
self._logger.debug(__name__, f'Level with name {level.name} already exists')
self._logger.debug(__name__, f"Level with name {level.name} already exists")
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.error.level_with_name_already_exists').format(level.name)
self._t.transform(
"modules.level.error.level_with_name_already_exists"
).format(level.name),
)
elif (
levels.where(lambda l: l.min_xp == level.min_xp).first_or_default()
is not None
):
self._logger.debug(
__name__,
f"Level with min_xp {level.min_xp} already exists {level.name}",
)
found_level = levels.where(
lambda l: l.min_xp == level.min_xp
).first_or_default()
await self._message_service.send_ctx_msg(
ctx,
self._t.transform(
"modules.level.error.level_with_xp_already_exists"
).format(found_level.name, found_level.min_xp),
)
elif levels.where(lambda l: l.min_xp == level.min_xp).first_or_default() is not None:
self._logger.debug(__name__, f'Level with min_xp {level.min_xp} already exists {level.name}')
found_level = levels.where(lambda l: l.min_xp == level.min_xp).first_or_default()
await self._message_service.send_ctx_msg(ctx, self._t.transform(
'modules.level.error.level_with_xp_already_exists').format(found_level.name, found_level.min_xp))
else:
try:
self._levels.add_level(level)
self._db.save_changes()
self._logger.info(
__name__, f'Saved level {name} with color {color}, min_xp {min_xp} and permissions {permissions}'
__name__,
f"Saved level {name} with color {color}, min_xp {min_xp} and permissions {permissions}",
)
except Exception as e:
self._logger.error(
__name__,
f'Could not save level {name} with color {color}, min_xp {min_xp} and permissions {permissions}',
e
f"Could not save level {name} with color {color}, min_xp {min_xp} and permissions {permissions}",
e,
)
else:
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.create.created').format(name, permissions)
self._t.transform("modules.level.create.created").format(
name, permissions
),
)
await self._seed_levels(ctx)
self._logger.trace(__name__, f'Finished command level create')
self._logger.trace(__name__, f"Finished command level create")
@create.autocomplete('color')
async def create_color_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[
app_commands.Choice[str]]:
@create.autocomplete("color")
async def create_color_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
# value in rg format see:
# https://discordpy.readthedocs.io/en/latest/api.html#discord.Colour.to_rgb
return [
app_commands.Choice(
name=self._t.transform(f'common.colors.{color}'), value=f'rgb({code[0]}, {code[1]}, {code[2]})'
) for color, code in self._colors
name=self._t.transform(f"common.colors.{color}"),
value=f"rgb({code[0]}, {code[1]}, {code[2]})",
)
for color, code in self._colors
]
@level.command()
@@ -228,18 +268,25 @@ class LevelGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_admin()
async def edit(
self, ctx: Context, level: str, name: str = None, color: str = None, min_xp: int = None,
permissions: int = None
self,
ctx: Context,
level: str,
name: str = None,
color: str = None,
min_xp: int = None,
permissions: int = None,
):
self._logger.debug(__name__, f'Received command level edit {ctx}')
self._logger.debug(__name__, f"Received command level edit {ctx}")
server = self._servers.get_server_by_discord_id(ctx.guild.id)
level_from_db = self._levels.get_levels_by_server_id(server.server_id).where(
lambda l: l.name == level).single_or_default()
level_from_db = (
self._levels.get_levels_by_server_id(server.server_id)
.where(lambda l: l.name == level)
.single_or_default()
)
if level_from_db is None:
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.edit.not_found').format(level)
ctx, self._t.transform("modules.level.edit.not_found").format(level)
)
return
@@ -255,9 +302,9 @@ class LevelGroup(DiscordCommandABC):
except Exception as e:
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.edit.color_invalid').format(color)
self._t.transform("modules.level.edit.color_invalid").format(color),
)
self._logger.error(__name__, f'Error parsing color {color}', e)
self._logger.error(__name__, f"Error parsing color {color}", e)
return
if min_xp is not None:
@@ -267,9 +314,15 @@ class LevelGroup(DiscordCommandABC):
try:
level_from_db.permissions = discord.Permissions(permissions).value
except Exception as e:
await self._message_service.send_ctx_msg(ctx, self._t.transform(
'modules.level.edit.permission_invalid').format(permissions))
self._logger.error(__name__, f'Error parsing permissions {permissions}', e)
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.level.edit.permission_invalid").format(
permissions
),
)
self._logger.error(
__name__, f"Error parsing permissions {permissions}", e
)
return
try:
@@ -278,39 +331,44 @@ class LevelGroup(DiscordCommandABC):
await role.edit(
name=level_from_db.name,
permissions=discord.Permissions(level_from_db.permissions),
colour=discord.Colour(int(level_from_db.color, 16))
colour=discord.Colour(int(level_from_db.color, 16)),
)
self._logger.info(
__name__,
f'Saved level {level_from_db.name} with color {level_from_db.color}, min_xp {level_from_db.min_xp} and permissions {level_from_db.permissions}'
f"Saved level {level_from_db.name} with color {level_from_db.color}, min_xp {level_from_db.min_xp} and permissions {level_from_db.permissions}",
)
except Exception as e:
self._logger.error(
__name__,
f'Could not save level {level} with color {color}, min_xp {min_xp} and permissions {permissions}',
e
f"Could not save level {level} with color {color}, min_xp {min_xp} and permissions {permissions}",
e,
)
else:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.edit.edited').format(level))
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.level.edit.edited").format(level)
)
await self._seed_levels(ctx)
self._logger.trace(__name__, f'Finished command level edit')
self._logger.trace(__name__, f"Finished command level edit")
@edit.autocomplete('level')
async def edit_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[
app_commands.Choice[str]]:
@edit.autocomplete("level")
async def edit_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
return await self._level_auto_complete(interaction, current)
@edit.autocomplete('color')
async def edit_color_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[
app_commands.Choice[str]]:
@edit.autocomplete("color")
async def edit_color_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
# value in rg format see:
# https://discordpy.readthedocs.io/en/latest/api.html#discord.Colour.to_rgb
return [
app_commands.Choice(
name=self._t.transform(f'common.colors.{color}'),
value=f'rgb({code[0]}, {code[1]}, {code[2]})'
) for color, code in self._colors
name=self._t.transform(f"common.colors.{color}"),
value=f"rgb({code[0]}, {code[1]}, {code[2]})",
)
for color, code in self._colors
]
@level.command()
@@ -318,42 +376,47 @@ class LevelGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_admin()
async def remove(self, ctx: Context, level: str):
self._logger.debug(__name__, f'Received command level remove {ctx}')
self._logger.debug(__name__, f"Received command level remove {ctx}")
server = self._servers.get_server_by_discord_id(ctx.guild.id)
level_from_db = self._levels.get_levels_by_server_id(server.server_id).where(
lambda l: l.name == level).first_or_default()
level_from_db = (
self._levels.get_levels_by_server_id(server.server_id)
.where(lambda l: l.name == level)
.first_or_default()
)
if level_from_db is None:
self._logger.debug(__name__, f'level {level} not found')
self._logger.debug(__name__, f"level {level} not found")
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.remove.error.not_found').format(level)
self._t.transform("modules.level.remove.error.not_found").format(level),
)
self._logger.trace(__name__, f'Finished command level remove')
self._logger.trace(__name__, f"Finished command level remove")
return
try:
self._levels.delete_level(level_from_db)
self._db.save_changes()
guild: Guild = self._bot.guilds.where(lambda g: g == ctx.guild).single()
role: Role = guild.roles.where(lambda r: r.name == level).single_or_default()
role: Role = guild.roles.where(
lambda r: r.name == level
).single_or_default()
if role is not None:
await role.delete()
self._logger.info(__name__, f'Removed level {level}')
self._logger.info(__name__, f"Removed level {level}")
except Exception as e:
self._logger.error(__name__, f'Could not remove level {level}', e)
self._logger.error(__name__, f"Could not remove level {level}", e)
else:
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.remove.success').format(level)
ctx, self._t.transform("modules.level.remove.success").format(level)
)
await self._seed_levels(ctx)
self._logger.trace(__name__, f'Finished command level remove')
self._logger.trace(__name__, f"Finished command level remove")
@remove.autocomplete('level')
async def remove_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[
app_commands.Choice[str]]:
@remove.autocomplete("level")
async def remove_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
return await self._level_auto_complete(interaction, current)
@level.command()
@@ -361,21 +424,28 @@ class LevelGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def down(self, ctx: Context, member: discord.Member):
self._logger.debug(__name__, f'Received command level down {ctx} {member}')
self._logger.debug(__name__, f"Received command level down {ctx} {member}")
if member.bot:
return
server = self._servers.get_server_by_discord_id(ctx.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
)
level = self._level_service.get_level(user)
levels = self._levels.get_levels_by_server_id(server.server_id).order_by(lambda l: l.min_xp)
levels = self._levels.get_levels_by_server_id(server.server_id).order_by(
lambda l: l.min_xp
)
if level == levels.first():
await self._message_service.send_ctx_msg(
ctx, self._t.transform('modules.level.down.already_first').format(member.mention)
ctx,
self._t.transform("modules.level.down.already_first").format(
member.mention
),
)
self._logger.trace(__name__, f'Finished command level down')
self._logger.trace(__name__, f"Finished command level down")
return
try:
@@ -383,37 +453,51 @@ class LevelGroup(DiscordCommandABC):
user.xp = new_level.min_xp
self._users.update_user(user)
self._db.save_changes()
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.down.success').format(
member.mention, new_level.name))
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.level.down.success").format(
member.mention, new_level.name
),
)
await self._level_service.set_level(user)
except Exception as e:
self._logger.error(__name__, f'Cannot level down {member.name} with level {level.name}', e)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.down.failed').format(
member.mention))
self._logger.error(
__name__, f"Cannot level down {member.name} with level {level.name}", e
)
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.level.down.failed").format(member.mention),
)
self._logger.trace(__name__, f'Finished command level down')
self._logger.trace(__name__, f"Finished command level down")
@level.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def up(self, ctx: Context, member: discord.Member):
self._logger.debug(__name__, f'Received command level up {ctx} {member}')
self._logger.debug(__name__, f"Received command level up {ctx} {member}")
if member.bot:
return
server = self._servers.get_server_by_discord_id(ctx.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
)
level = self._level_service.get_level(user)
levels = self._levels.get_levels_by_server_id(server.server_id).order_by(lambda l: l.min_xp)
levels = self._levels.get_levels_by_server_id(server.server_id).order_by(
lambda l: l.min_xp
)
if level.name == levels.last().name:
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.up.already_last').format(member.mention)
self._t.transform("modules.level.up.already_last").format(
member.mention
),
)
self._logger.trace(__name__, f'Finished command level up')
self._logger.trace(__name__, f"Finished command level up")
return
try:
@@ -421,62 +505,87 @@ class LevelGroup(DiscordCommandABC):
user.xp = new_level.min_xp
self._users.update_user(user)
self._db.save_changes()
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.up.success').format(
member.mention, new_level.name))
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.level.up.success").format(
member.mention, new_level.name
),
)
await self._level_service.set_level(user)
except Exception as e:
self._logger.error(__name__, f'Cannot level up {member.name} with level {level.name}', e)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.up.failed').format(
member.mention))
self._logger.error(
__name__, f"Cannot level up {member.name} with level {level.name}", e
)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.level.up.failed").format(member.mention)
)
self._logger.trace(__name__, f'Finished command level up')
self._logger.trace(__name__, f"Finished command level up")
@level.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def set(self, ctx: Context, member: discord.Member, level: str):
self._logger.debug(__name__, f'Received command level up {ctx} {member}')
self._logger.debug(__name__, f"Received command level up {ctx} {member}")
if member.bot:
return
server = self._servers.get_server_by_discord_id(ctx.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
)
current_level = self._level_service.get_level(user)
new_level = self._levels.get_levels_by_server_id(server.server_id).where(
lambda l: l.name == level).single_or_default()
new_level = (
self._levels.get_levels_by_server_id(server.server_id)
.where(lambda l: l.name == level)
.single_or_default()
)
if new_level is None:
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.set.not_found').format(level)
ctx, self._t.transform("modules.level.set.not_found").format(level)
)
self._logger.trace(__name__, f'Finished command level set')
self._logger.trace(__name__, f"Finished command level set")
return
if current_level.name == level:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.set.already_level').format(
member.mention, level))
self._logger.trace(__name__, f'Finished command level set')
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.level.set.already_level").format(
member.mention, level
),
)
self._logger.trace(__name__, f"Finished command level set")
return
try:
user.xp = new_level.min_xp
self._users.update_user(user)
self._db.save_changes()
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.set.success').format(
member.mention, new_level.name))
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.level.set.success").format(
member.mention, new_level.name
),
)
await self._level_service.set_level(user)
except Exception as e:
self._logger.error(__name__, f'Cannot set level {level} for {member.name}', e)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.set.failed').format(
member.mention))
self._logger.error(
__name__, f"Cannot set level {level} for {member.name}", e
)
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.level.set.failed").format(member.mention),
)
self._logger.trace(__name__, f'Finished command level set')
self._logger.trace(__name__, f"Finished command level set")
@set.autocomplete('level')
async def set_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
@set.autocomplete("level")
async def set_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
return await self._level_auto_complete(interaction, current)
@level.command()
@@ -484,6 +593,6 @@ class LevelGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def reload(self, ctx: Context):
self._logger.debug(__name__, f'Received command level reload {ctx}')
self._logger.debug(__name__, f"Received command level reload {ctx}")
await self._seed_levels(ctx)
self._logger.trace(__name__, f'Finished command level reload')
self._logger.trace(__name__, f"Finished command level reload")

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.level.configuration'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.level.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")

31
kdb-bot/src/modules/level/configuration/default_level_settings.py
View File

@@ -8,12 +8,11 @@ from bot_data.model.level import Level
class DefaultLevelSettings(ConfigurationModelABC):
def __init__(self):
ConfigurationModelABC.__init__(self)
self._levels = List(Level)
self._level_header = ''
self._level_header = ""
@property
def levels(self) -> List[Level]:
@@ -25,15 +24,21 @@ class DefaultLevelSettings(ConfigurationModelABC):
def from_dict(self, settings: dict):
try:
self._level_header = settings['LevelHeader']
for level in settings['Levels']:
self._levels.append(Level(
level['Name'],
level['Color'],
int(level['MinXp']),
int(level['Permissions']),
None
))
self._level_header = settings["LevelHeader"]
for level in settings["Levels"]:
self._levels.append(
Level(
level["Name"],
level["Color"],
int(level["MinXp"]),
int(level["Permissions"]),
None,
)
)
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()}"
)

15
kdb-bot/src/modules/level/configuration/level_server_settings.py
View File

@@ -5,7 +5,6 @@ from cpl_core.console import Console
class LevelServerSettings(ConfigurationModelABC):
def __init__(self):
ConfigurationModelABC.__init__(self)
@@ -22,8 +21,14 @@ class LevelServerSettings(ConfigurationModelABC):
def from_dict(self, settings: dict):
try:
self._id = int(settings['Id'])
self._changed_level_notification_channel = int(settings['ChangedLevelNotificationChannelId'])
self._id = int(settings["Id"])
self._changed_level_notification_channel = int(
settings["ChangedLevelNotificationChannelId"]
)
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()}"
)

11
kdb-bot/src/modules/level/configuration/level_settings.py
View File

@@ -8,7 +8,6 @@ from modules.level.configuration.level_server_settings import LevelServerSetting
class LevelSettings(ConfigurationModelABC):
def __init__(self):
ConfigurationModelABC.__init__(self)
@@ -23,10 +22,14 @@ class LevelSettings(ConfigurationModelABC):
servers = List(LevelServerSettings)
for s in settings:
st = LevelServerSettings()
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/level/events/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.level.events'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.level.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")

9
kdb-bot/src/modules/level/events/level_on_member_join_event.py
View File

@@ -7,17 +7,12 @@ from modules.level.service.level_service import LevelService
class LevelOnMemberJoinEvent(OnMemberJoinABC):
def __init__(
self,
logger: MessageLogger,
level: LevelService
):
def __init__(self, logger: MessageLogger, level: LevelService):
OnMemberJoinABC.__init__(self)
self._logger = logger
self._level = level
@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")
await self._level.check_level(member)

9
kdb-bot/src/modules/level/events/level_on_message_event.py
View File

@@ -7,17 +7,12 @@ from modules.level.service.level_service import LevelService
class LevelOnMessageEvent(OnMessageABC):
def __init__(
self,
logger: MessageLogger,
level: LevelService
):
def __init__(self, logger: MessageLogger, level: LevelService):
OnMessageABC.__init__(self)
self._logger = logger
self._level = level
@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")
await self._level.check_level(message.author)

18
kdb-bot/src/modules/level/events/level_on_voice_state_update_event.py
View File

@@ -7,19 +7,19 @@ from modules.level.service.level_service import LevelService
class LevelOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
def __init__(
self,
logger: LoggerABC,
level: LevelService
):
def __init__(self, logger: LoggerABC, level: LevelService):
OnVoiceStateUpdateABC.__init__(self)
self._logger = logger
self._level = level
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")
await self._level.check_level(member)

24
kdb-bot/src/modules/level/level_module.py
View File

@@ -11,23 +11,28 @@ from bot_core.configuration.feature_flags_enum import FeatureFlagsEnum
from modules.level.command.level_group import LevelGroup
from modules.level.events.level_on_member_join_event import LevelOnMemberJoinEvent
from modules.level.events.level_on_message_event import LevelOnMessageEvent
from modules.level.events.level_on_voice_state_update_event import LevelOnVoiceStateUpdateEvent
from modules.level.events.level_on_voice_state_update_event import (
LevelOnVoiceStateUpdateEvent,
)
from modules.level.level_seeder import LevelSeeder
from modules.level.service.level_service import LevelService
class LevelModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.level_module)
def configure_configuration(self, config: ConfigurationABC, env: ApplicationEnvironmentABC):
def configure_configuration(
self, config: ConfigurationABC, env: ApplicationEnvironmentABC
):
cwd = env.working_directory
env.set_working_directory(os.path.dirname(os.path.realpath(__file__)))
config.add_json_file(f'default-level.json', optional=False)
config.add_json_file(f"default-level.json", optional=False)
env.set_working_directory(cwd)
def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
def configure_services(
self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
):
services.add_transient(LevelSeeder)
services.add_transient(LevelService)
@@ -36,5 +41,10 @@ class LevelModule(ModuleABC):
# events
self._dc.add_event(DiscordEventTypesEnum.on_message.value, LevelOnMessageEvent)
self._dc.add_event(DiscordEventTypesEnum.on_voice_state_update.value, LevelOnVoiceStateUpdateEvent)
self._dc.add_event(DiscordEventTypesEnum.on_member_join.value, LevelOnMemberJoinEvent)
self._dc.add_event(
DiscordEventTypesEnum.on_voice_state_update.value,
LevelOnVoiceStateUpdateEvent,
)
self._dc.add_event(
DiscordEventTypesEnum.on_member_join.value, LevelOnMemberJoinEvent
)

77
kdb-bot/src/modules/level/level_seeder.py
View File

@@ -14,15 +14,14 @@ from modules.level.service.level_service import LevelService
class LevelSeeder(DataSeederABC):
def __init__(
self,
logger: DatabaseLogger,
levels: DefaultLevelSettings,
level_repo: LevelRepositoryService,
servers: ServerRepositoryABC,
level: LevelService,
bot: DiscordBotServiceABC
self,
logger: DatabaseLogger,
levels: DefaultLevelSettings,
level_repo: LevelRepositoryService,
servers: ServerRepositoryABC,
level: LevelService,
bot: DiscordBotServiceABC,
):
DataSeederABC.__init__(self)
@@ -38,26 +37,44 @@ class LevelSeeder(DataSeederABC):
async def _create_level(self, level: Level, guild: Guild, server: Server):
level.server = server
try:
if guild.roles.where(lambda r: r.name == level.name).first_or_default() is None:
await guild.create_role(name=level.name, colour=Colour(int(level.color, 16)), hoist=False, mentionable=True, permissions=Permissions(level.permissions))
self._logger.debug(__name__, f'Created role {level.name}')
if (
guild.roles.where(lambda r: r.name == level.name).first_or_default()
is None
):
await guild.create_role(
name=level.name,
colour=Colour(int(level.color, 16)),
hoist=False,
mentionable=True,
permissions=Permissions(level.permissions),
)
self._logger.debug(__name__, f"Created role {level.name}")
levels = self._levels.find_levels_by_server_id(server.server_id)
if levels is None or levels.where(lambda l: l.name == level.name).first_or_default() is None:
if (
levels is None
or levels.where(lambda l: l.name == level.name).first_or_default()
is None
):
self._levels.add_level(level)
self._logger.debug(__name__, f'Saved level {level.name}')
self._logger.debug(__name__, f"Saved level {level.name}")
except discord.errors.Forbidden as e:
self._logger.error(__name__, f'Creating level failed', e)
self._logger.error(__name__, f"Creating level failed", e)
level.permissions = 0
self._levels.update_level(level)
except Exception as e:
self._logger.error(__name__, f'Creating level failed', e)
self._logger.error(__name__, f"Creating level failed", e)
async def seed(self):
# create levels
for guild in self._bot.guilds:
created_default = False
if guild.roles.where(lambda r: r.name == self._level_header).first_or_default() is None:
if (
guild.roles.where(
lambda r: r.name == self._level_header
).first_or_default()
is None
):
await guild.create_role(name=self._level_header)
server = self._servers.find_server_by_discord_id(guild.id)
@@ -70,34 +87,48 @@ class LevelSeeder(DataSeederABC):
for level in levels:
await self._create_level(level, guild, server)
self._logger.debug(__name__, f'Seeded levels')
self._logger.debug(__name__, f"Seeded levels")
else:
# create default levels
for level in self._default_levels:
created_default = True
await self._create_level(level, guild, server)
self._logger.debug(__name__, f'Seeded default levels')
self._logger.debug(__name__, f"Seeded default levels")
if created_default:
continue
levels = levels.order_by_descending(lambda l: l.min_xp)
position_above_levels = guild.roles.where(lambda r: r.name == self._level_header).single().position
position_above_levels = (
guild.roles.where(lambda r: r.name == self._level_header)
.single()
.position
)
for role in guild.roles.order_by_descending(lambda r: r.position):
if levels.where(lambda l: l.name == role.name).count() == 0:
continue
new_position = position_above_levels - (levels.index_of(levels.where(lambda l: l.name == role.name).single()) + 1)
new_position = position_above_levels - (
levels.index_of(
levels.where(lambda l: l.name == role.name).single()
)
+ 1
)
if new_position <= 0:
new_position = 1
try:
self._logger.debug(__name__, f'Moved {role.name} from {role.position} to {new_position}')
self._logger.debug(
__name__,
f"Moved {role.name} from {role.position} to {new_position}",
)
await role.edit(position=new_position)
except Exception as e:
self._logger.error(__name__, f'Cannot change position of {role.name}', e)
self._logger.error(
__name__, f"Cannot change position of {role.name}", e
)
for m in guild.members:
await self._level.check_level(m)
self._logger.debug(__name__, f'Checked role order')
self._logger.debug(__name__, f"Checked role order")

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.level.service'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.level.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")

75
kdb-bot/src/modules/level/service/level_service.py
View File

@@ -18,18 +18,17 @@ from modules.level.configuration.level_server_settings import LevelServerSetting
class LevelService:
def __init__(
self,
config: ConfigurationABC,
logger: LoggerABC,
db: DatabaseContextABC,
levels: LevelRepositoryService,
users: UserRepositoryService,
servers: ServerRepositoryService,
bot: DiscordBotServiceABC,
message_service: MessageService,
t: TranslatePipe
self,
config: ConfigurationABC,
logger: LoggerABC,
db: DatabaseContextABC,
levels: LevelRepositoryService,
users: UserRepositoryService,
servers: ServerRepositoryService,
bot: DiscordBotServiceABC,
message_service: MessageService,
t: TranslatePipe,
):
self._config = config
self._logger = logger
@@ -43,9 +42,9 @@ class LevelService:
def get_level(self, user: User) -> Level:
levels_by_server = self._levels.get_levels_by_server_id(user.server.server_id)
levels = levels_by_server \
.order_by(lambda l: l.min_xp) \
.where(lambda l: user.xp >= l.min_xp)
levels = levels_by_server.order_by(lambda l: l.min_xp).where(
lambda l: user.xp >= l.min_xp
)
if levels.count() == 0:
return levels_by_server.order_by(lambda l: l.min_xp).last()
@@ -53,8 +52,12 @@ class LevelService:
return levels.last()
async def set_level(self, user: User):
level_names = self._levels.get_levels_by_server_id(user.server.server_id).select(lambda l: l.name)
guild: Guild = self._bot.guilds.where(lambda g: g.id == user.server.discord_server_id).single()
level_names = self._levels.get_levels_by_server_id(
user.server.server_id
).select(lambda l: l.name)
guild: Guild = self._bot.guilds.where(
lambda g: g.id == user.server.discord_server_id
).single()
member: Member = guild.members.where(lambda m: m.id == user.discord_id).single()
level = self.get_level(user)
@@ -67,24 +70,38 @@ class LevelService:
continue
try:
self._logger.debug(__name__, f'Try to remove role {role.name} from {member.name}')
self._logger.debug(
__name__, f"Try to remove role {role.name} from {member.name}"
)
await member.remove_roles(role)
self._logger.info(__name__, f'Removed role {role.name} from {member.name}')
self._logger.info(
__name__, f"Removed role {role.name} from {member.name}"
)
except Exception as e:
self._logger.error(__name__, f'Removing role {role.name} from {member.name} failed!', e)
self._logger.error(
__name__, f"Removing role {role.name} from {member.name} failed!", e
)
try:
self._logger.debug(__name__, f'Try to add role {level_role.name} to {member.name}')
self._logger.debug(
__name__, f"Try to add role {level_role.name} to {member.name}"
)
await member.add_roles(level_role)
self._logger.info(__name__, f'Add role {level_role.name} to {member.name}')
self._logger.info(__name__, f"Add role {level_role.name} to {member.name}")
except Exception as e:
self._logger.error(__name__, f'Adding role {level_role.name} to {member.name} failed!', e)
self._logger.error(
__name__, f"Adding role {level_role.name} to {member.name} failed!", e
)
level_settings: LevelServerSettings = self._config.get_configuration(f'LevelServerSettings_{guild.id}')
level_settings: LevelServerSettings = self._config.get_configuration(
f"LevelServerSettings_{guild.id}"
)
await self._message_service.send_channel_message(
self._bot.get_channel(level_settings.changed_level_notification_channel),
self._t.transform('modules.level.new_level_message').format(member.mention, level.name),
is_persistent=True
self._t.transform("modules.level.new_level_message").format(
member.mention, level.name
),
is_persistent=True,
)
async def check_level(self, member: discord.Member):
@@ -92,9 +109,13 @@ class LevelService:
return
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.warn(__name__, f'User not found {member.guild.name}@{member.name}')
self._logger.warn(
__name__, f"User not found {member.guild.name}@{member.name}"
)
return
await self.set_level(user)

16
kdb-bot/src/modules/permission/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.permission'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.permission"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
# 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/permission/abc/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.permission.abc'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.permission.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")

42
kdb-bot/src/modules/permission/abc/permission_service_abc.py
View File

@@ -4,42 +4,54 @@ import discord
class PermissionServiceABC(ABC):
@abstractmethod
def __init__(self):
pass
@abstractmethod
def __init__(self): pass
def on_ready(self):
pass
@abstractmethod
def on_ready(self): pass
def on_member_update(self, before: discord.Member, after: discord.Member):
pass
@abstractmethod
def on_member_update(self, before: discord.Member, after: discord.Member): pass
def get_admin_role_ids(self, g_id: int) -> list[int]:
pass
@abstractmethod
def get_admin_role_ids(self, g_id: int) -> list[int]: pass
def get_admin_roles(self, g_id: int) -> list[discord.Role]:
pass
@abstractmethod
def get_admin_roles(self, g_id: int) -> list[discord.Role]: pass
def get_admins(self, g_id: int) -> list[discord.Member]:
pass
@abstractmethod
def get_admins(self, g_id: int) -> list[discord.Member]: pass
def get_moderator_role_ids(self, g_id: int) -> list[int]:
pass
@abstractmethod
def get_moderator_role_ids(self, g_id: int) -> list[int]: pass
def get_moderator_roles(self, g_id: int) -> list[discord.Role]:
pass
@abstractmethod
def get_moderator_roles(self, g_id: int) -> list[discord.Role]: pass
def get_moderators(self, g_id: int) -> list[discord.Member]:
pass
@abstractmethod
def get_moderators(self, g_id: int) -> list[discord.Member]: pass
def get_technicians(self) -> list[discord.Member]:
pass
@abstractmethod
def get_technicians(self) -> list[discord.Member]: pass
def is_member_admin(self, member: discord.Member) -> bool:
pass
@abstractmethod
def is_member_admin(self, member: discord.Member) -> bool: pass
def is_member_moderator(self, member: discord.Member) -> bool:
pass
@abstractmethod
def is_member_moderator(self, member: discord.Member) -> bool: pass
@abstractmethod
def is_member_technician(self, member: discord.Member) -> bool: pass
def is_member_technician(self, member: discord.Member) -> bool:
pass

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.permission.configuration'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.permission.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")

17
kdb-bot/src/modules/permission/configuration/permission_server_settings.py
View File

@@ -5,7 +5,6 @@ from cpl_core.console import Console
class PermissionServerSettings(ConfigurationModelABC):
def __init__(self):
ConfigurationModelABC.__init__(self)
@@ -27,12 +26,16 @@ class PermissionServerSettings(ConfigurationModelABC):
def from_dict(self, settings: dict):
try:
self._id = int(settings['Id'])
for index in settings['AdminRoleIds']:
self._id = int(settings["Id"])
for index in settings["AdminRoleIds"]:
self._admin_roles.append(int(index))
for index in settings['ModeratorRoleIds']:
for index in settings["ModeratorRoleIds"]:
self._moderator_roles.append(int(index))
except Exception as e:
Console.error(f'[ ERROR ] [ {__name__} ]: Reading error in {self.__name__} settings')
Console.error(f'[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}')
Console.error(
f"[ ERROR ] [ {__name__} ]: Reading error in {self.__name__} settings"
)
Console.error(
f"[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}"
)

15
kdb-bot/src/modules/permission/configuration/permission_settings.py
View File

@@ -4,11 +4,12 @@ from cpl_core.configuration.configuration_model_abc import ConfigurationModelABC
from cpl_core.console import Console
from cpl_query.extension import List
from modules.permission.configuration.permission_server_settings import PermissionServerSettings
from modules.permission.configuration.permission_server_settings import (
PermissionServerSettings,
)
class PermissionSettings(ConfigurationModelABC):
def __init__(self):
ConfigurationModelABC.__init__(self)
@@ -23,10 +24,14 @@ class PermissionSettings(ConfigurationModelABC):
servers = List(PermissionServerSettings)
for s in settings:
st = PermissionServerSettings()
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/permission/events/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.permission.events'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.permission.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")

3
kdb-bot/src/modules/permission/events/permission_on_member_update_event.py
View File

@@ -6,14 +6,13 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class PermissionOnMemberUpdateEvent(OnMemberUpdateABC):
def __init__(self, logger: LoggerABC, permission_service: PermissionServiceABC):
OnMemberUpdateABC.__init__(self)
self._logger = logger
self._permission_service = permission_service
async def on_member_update(self, before: discord.Member, after: discord.Member):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.debug(__name__, f"Module {type(self)} started")
if before.roles != after.roles:
self._permission_service.on_member_update(before, after)

3
kdb-bot/src/modules/permission/events/permission_on_ready_event.py
View File

@@ -5,12 +5,11 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class PermissionOnReadyEvent(OnReadyABC):
def __init__(self, logger: LoggerABC, permission_service: PermissionServiceABC):
OnReadyABC.__init__(self)
self._logger = logger
self._permission_service = permission_service
async def on_ready(self):
self._logger.debug(__name__, f'Module {type(self)} started')
self._logger.debug(__name__, f"Module {type(self)} started")
self._permission_service.on_ready()

17
kdb-bot/src/modules/permission/permission_module.py
View File

@@ -7,22 +7,29 @@ from cpl_discord.service.discord_collection_abc import DiscordCollectionABC
from bot_core.abc.module_abc import ModuleABC
from bot_core.configuration.feature_flags_enum import FeatureFlagsEnum
from modules.permission.abc.permission_service_abc import PermissionServiceABC
from modules.permission.events.permission_on_member_update_event import PermissionOnMemberUpdateEvent
from modules.permission.events.permission_on_member_update_event import (
PermissionOnMemberUpdateEvent,
)
from modules.permission.events.permission_on_ready_event import PermissionOnReadyEvent
from modules.permission.service.permission_service import PermissionService
class PermissionModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.permission_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_singleton(PermissionServiceABC, PermissionService)
# commands
# events
self._dc.add_event(DiscordEventTypesEnum.on_ready.value, PermissionOnReadyEvent)
self._dc.add_event(DiscordEventTypesEnum.on_member_update.value, PermissionOnMemberUpdateEvent)
self._dc.add_event(
DiscordEventTypesEnum.on_member_update.value, PermissionOnMemberUpdateEvent
)

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.permission.service'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.permission.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")

49
kdb-bot/src/modules/permission/service/permission_service.py
View File

@@ -5,17 +5,18 @@ from cpl_discord.service import DiscordBotServiceABC
from bot_core.configuration.bot_settings import BotSettings
from modules.permission.abc.permission_service_abc import PermissionServiceABC
from modules.permission.configuration.permission_server_settings import PermissionServerSettings
from modules.permission.configuration.permission_server_settings import (
PermissionServerSettings,
)
class PermissionService(PermissionServiceABC):
def __init__(
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
config: ConfigurationABC,
bot_settings: BotSettings
self,
logger: LoggerABC,
bot: DiscordBotServiceABC,
config: ConfigurationABC,
bot_settings: BotSettings,
):
PermissionServiceABC.__init__(self)
self._logger = logger
@@ -36,7 +37,7 @@ class PermissionService(PermissionServiceABC):
def on_ready(self):
for guild in self._bot.guilds:
guild: discord.Guild = guild
self._logger.debug(__name__, f'Validate permission settings')
self._logger.debug(__name__, f"Validate permission settings")
for technician_id in self._technician_ids:
technician = guild.get_member(technician_id)
@@ -44,9 +45,11 @@ class PermissionService(PermissionServiceABC):
continue
self._technicians.append(technician)
settings: PermissionServerSettings = self._config.get_configuration(f'PermissionServerSettings_{guild.id}')
settings: PermissionServerSettings = self._config.get_configuration(
f"PermissionServerSettings_{guild.id}"
)
if settings is None:
self._logger.error(__name__, 'Permission settings not found')
self._logger.error(__name__, "Permission settings not found")
return
self._admin_role_ids[guild.id] = settings.admin_roles
@@ -63,19 +66,19 @@ class PermissionService(PermissionServiceABC):
if role.id in self._admin_role_ids[guild.id]:
admin_roles.append(role)
self._logger.trace(__name__, f'Added admin role {role}')
self._logger.trace(__name__, f"Added admin role {role}")
for member in role.members:
admins.append(member)
self._logger.trace(__name__, f'Added admin {member}')
self._logger.trace(__name__, f"Added admin {member}")
if role.id in self._moderator_role_ids[guild.id]:
mod_roles.append(role)
self._logger.trace(__name__, f'Added moderator role {role}')
self._logger.trace(__name__, f"Added moderator role {role}")
for member in role.members:
mods.append(member)
self._logger.trace(__name__, f'Added moderator {member}')
self._logger.trace(__name__, f"Added moderator {member}")
self._admin_roles[guild.id] = admin_roles
self._admins[guild.id] = admins
@@ -88,20 +91,20 @@ class PermissionService(PermissionServiceABC):
for admin_role in self._admin_roles[g_id]:
if admin_role in before.roles and admin_role not in after.roles:
self._admins[g_id].remove(after)
self._logger.trace(__name__, f'Removed {after.id} from admins')
self._logger.trace(__name__, f"Removed {after.id} from admins")
elif admin_role in after.roles and admin_role not in before.roles:
self._admins[g_id].append(after)
self._logger.trace(__name__, f'Added {after.id} to admins')
self._logger.trace(__name__, f"Added {after.id} to admins")
for moderator_role in self._moderator_roles[g_id]:
if moderator_role in before.roles and moderator_role not in after.roles:
self._moderators[g_id].remove(after)
self._logger.trace(__name__, f'Removed {after.id} from moderators')
self._logger.trace(__name__, f"Removed {after.id} from moderators")
elif moderator_role in after.roles and moderator_role not in before.roles:
self._moderators[g_id].append(after)
self._logger.trace(__name__, f'Added {after.id} to moderators')
self._logger.trace(__name__, f"Added {after.id} to moderators")
def get_admin_role_ids(self, g_id: int) -> list[int]:
return self._admin_role_ids[g_id]
@@ -125,10 +128,16 @@ class PermissionService(PermissionServiceABC):
return self._technicians
def is_member_admin(self, member: discord.Member) -> bool:
return member.guild.id in self._admins and member in self._admins[member.guild.id]
return (
member.guild.id in self._admins and member in self._admins[member.guild.id]
)
def is_member_moderator(self, member: discord.Member) -> bool:
return member.guild.id in self._moderators and member in self._moderators[member.guild.id] or self.is_member_admin(member)
return (
member.guild.id in self._moderators
and member in self._moderators[member.guild.id]
or self.is_member_admin(member)
)
def is_member_technician(self, member: discord.Member) -> bool:
return member in self._technicians

16
kdb-bot/src/modules/stats/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.stats'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.stats"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
# 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/stats/command/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.stats.command'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.stats.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")

168
kdb-bot/src/modules/stats/command/stats_group.py
View File

@@ -20,18 +20,17 @@ from modules.stats.ui.add_statistic_form import AddStatisticForm
class StatsGroup(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
message_service: MessageServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
permission_service: PermissionServiceABC,
statistic: StatisticService,
servers: ServerRepositoryABC,
stats: StatisticRepositoryABC,
db: DatabaseContextABC,
self,
logger: CommandLogger,
message_service: MessageServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
permission_service: PermissionServiceABC,
statistic: StatisticService,
servers: ServerRepositoryABC,
stats: StatisticRepositoryABC,
db: DatabaseContextABC,
):
DiscordCommandABC.__init__(self)
@@ -55,41 +54,51 @@ class StatsGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def list(self, ctx: Context, wait: int = None):
self._logger.debug(__name__, f'Received command stats list {ctx}')
self._logger.debug(__name__, f"Received command stats list {ctx}")
if ctx.guild is None:
return
embed = discord.Embed(
title=self._t.transform('modules.auto_role.list.title'),
description=self._t.transform('modules.auto_role.list.description'),
color=int('ef9d0d', 16)
title=self._t.transform("modules.auto_role.list.title"),
description=self._t.transform("modules.auto_role.list.description"),
color=int("ef9d0d", 16),
)
server = self._servers.get_server_by_discord_id(ctx.guild.id)
stats = self._stats.get_statistics_by_server_id(server.server_id)
if stats.count() == 0:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.stats.list.nothing_found'))
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.stats.list.nothing_found")
)
return
statistics = ''
descriptions = ''
statistics = ""
descriptions = ""
for statistic in stats:
statistics += f'\n{statistic.name}'
descriptions += f'\n{statistic.description}'
statistics += f"\n{statistic.name}"
descriptions += f"\n{statistic.description}"
embed.add_field(name=self._t.transform('modules.stats.list.statistic'), value=statistics, inline=True)
embed.add_field(name=self._t.transform('modules.stats.list.description'), value=descriptions, inline=True)
embed.add_field(
name=self._t.transform("modules.stats.list.statistic"),
value=statistics,
inline=True,
)
embed.add_field(
name=self._t.transform("modules.stats.list.description"),
value=descriptions,
inline=True,
)
await self._message_service.send_ctx_msg(ctx, embed, wait_before_delete=wait)
self._logger.trace(__name__, f'Finished command stats list')
self._logger.trace(__name__, f"Finished command stats list")
@stats.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def view(self, ctx: Context, name: str, wait: int = None):
self._logger.debug(__name__, f'Received command stats view {ctx}:{name}')
self._logger.debug(__name__, f"Received command stats view {ctx}:{name}")
if ctx.guild is None:
return
@@ -103,43 +112,62 @@ class StatsGroup(DiscordCommandABC):
embed = discord.Embed(
title=statistic.name,
description=statistic.description,
color=int('ef9d0d', 16)
color=int("ef9d0d", 16),
)
for i in range(result.header.count()):
header = result.header[i]
value = ''
value = ""
for row in result.values:
value += f'\n{row[i]}'
value += f"\n{row[i]}"
embed.add_field(name=header, value=value, inline=True)
await self._message_service.send_ctx_msg(ctx, embed, wait_before_delete=wait)
await self._message_service.send_ctx_msg(
ctx, embed, wait_before_delete=wait
)
except Exception as e:
self._logger.error(__name__, f'Cannot view statistic {name}', e)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.stats.view.failed'))
self._logger.error(__name__, f"Cannot view statistic {name}", e)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.stats.view.failed")
)
self._logger.trace(__name__, f'Finished stats view command')
self._logger.trace(__name__, f"Finished stats view command")
@view.autocomplete('name')
async def view_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
@view.autocomplete("name")
async def view_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
server = self._servers.get_server_by_discord_id(interaction.guild.id)
stats = self._stats.get_statistics_by_server_id(server.server_id)
return [app_commands.Choice(name=f'{statistic.name}: {statistic.description}', value=statistic.name) for statistic in stats]
return [
app_commands.Choice(
name=f"{statistic.name}: {statistic.description}", value=statistic.name
)
for statistic in stats
]
@stats.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_technician()
async def add(self, ctx: Context, name: str):
self._logger.debug(__name__, f'Received command stats add {ctx}: {name}')
self._logger.debug(__name__, f"Received command stats add {ctx}: {name}")
if ctx.guild is None:
return
server = self._servers.get_server_by_discord_id(ctx.guild.id)
form = AddStatisticForm(server, self._stats, self._db, name, self._message_service, self._logger, self._t)
self._logger.trace(__name__, f'Finished stats add command')
self._logger.trace(__name__, f'Started stats command form')
form = AddStatisticForm(
server,
self._stats,
self._db,
name,
self._message_service,
self._logger,
self._t,
)
self._logger.trace(__name__, f"Finished stats add command")
self._logger.trace(__name__, f"Started stats command form")
await ctx.interaction.response.send_modal(form)
@stats.command()
@@ -147,46 +175,76 @@ class StatsGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_technician()
async def edit(self, ctx: Context, name: str):
self._logger.debug(__name__, f'Received command stats edit {ctx}: {name}')
self._logger.debug(__name__, f"Received command stats edit {ctx}: {name}")
try:
server = self._servers.get_server_by_discord_id(ctx.guild.id)
stats = self._stats.get_statistics_by_server_id(server.server_id)
statistic = stats.where(lambda s: s.name == name).single()
form = AddStatisticForm(server, self._stats, self._db, name, self._message_service, self._logger, self._t, code=statistic.code, description=statistic.description)
self._logger.trace(__name__, f'Finished stats edit command')
self._logger.trace(__name__, f'Started stats command form')
form = AddStatisticForm(
server,
self._stats,
self._db,
name,
self._message_service,
self._logger,
self._t,
code=statistic.code,
description=statistic.description,
)
self._logger.trace(__name__, f"Finished stats edit command")
self._logger.trace(__name__, f"Started stats command form")
await ctx.interaction.response.send_modal(form)
except Exception as e:
self._logger.error(__name__, f'Cannot edit statistic {name}', e)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.stats.edit.failed'))
self._logger.error(__name__, f"Cannot edit statistic {name}", e)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.stats.edit.failed")
)
@edit.autocomplete('name')
async def edit_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
@edit.autocomplete("name")
async def edit_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
server = self._servers.get_server_by_discord_id(interaction.guild.id)
stats = self._stats.get_statistics_by_server_id(server.server_id)
return [app_commands.Choice(name=f'{statistic.name}: {statistic.description}', value=statistic.name) for statistic in stats]
return [
app_commands.Choice(
name=f"{statistic.name}: {statistic.description}", value=statistic.name
)
for statistic in stats
]
@stats.command()
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_technician()
async def remove(self, ctx: Context, name: str):
self._logger.debug(__name__, f'Received command stats remove {ctx}: {name}')
self._logger.debug(__name__, f"Received command stats remove {ctx}: {name}")
try:
server = self._servers.get_server_by_discord_id(ctx.guild.id)
statistic = self._stats.get_statistic_by_name(name, server.server_id)
self._stats.delete_statistic(statistic)
self._db.save_changes()
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.stats.remove.success'))
self._logger.trace(__name__, f'Finished stats remove command')
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.stats.remove.success")
)
self._logger.trace(__name__, f"Finished stats remove command")
except Exception as e:
self._logger.error(__name__, f'Cannot remove statistic {name}', e)
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.stats.remove.failed'))
self._logger.error(__name__, f"Cannot remove statistic {name}", e)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.stats.remove.failed")
)
@remove.autocomplete('name')
async def edit_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
@remove.autocomplete("name")
async def edit_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
server = self._servers.get_server_by_discord_id(interaction.guild.id)
stats = self._stats.get_statistics_by_server_id(server.server_id)
return [app_commands.Choice(name=f'{statistic.name}: {statistic.description}', value=statistic.name) for statistic in stats]
return [
app_commands.Choice(
name=f"{statistic.name}: {statistic.description}", value=statistic.name
)
for statistic in stats
]

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.stats.model'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.stats.model"
__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")

1
kdb-bot/src/modules/stats/model/statistic_result.py
View File

@@ -2,7 +2,6 @@ from cpl_query.extension import List
class StatisticResult:
def __init__(self):
self._header = List(str)
self._values = List(List)

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.stats.service'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.stats.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")

93
kdb-bot/src/modules/stats/service/statistic_service.py
View File

@@ -10,7 +10,9 @@ from bot_data.abc.known_user_repository_abc import KnownUserRepositoryABC
from bot_data.abc.level_repository_abc import LevelRepositoryABC
from bot_data.abc.server_repository_abc import ServerRepositoryABC
from bot_data.abc.user_joined_server_repository_abc import UserJoinedServerRepositoryABC
from bot_data.abc.user_joined_voice_channel_repository_abc import UserJoinedVoiceChannelRepositoryABC
from bot_data.abc.user_joined_voice_channel_repository_abc import (
UserJoinedVoiceChannelRepositoryABC,
)
from bot_data.abc.user_repository_abc import UserRepositoryABC
from bot_data.model.auto_role import AutoRole
from bot_data.model.client import Client
@@ -24,18 +26,17 @@ from modules.stats.model.statistic_result import StatisticResult
class StatisticService:
def __init__(
self,
auto_roles: AutoRoleRepositoryABC,
clients: ClientRepositoryABC,
known_users: KnownUserRepositoryABC,
levels: LevelRepositoryABC,
servers: ServerRepositoryABC,
user_joined_servers: UserJoinedServerRepositoryABC,
user_joined_voice_channel: UserJoinedVoiceChannelRepositoryABC,
users: UserRepositoryABC,
bot: DiscordBotServiceABC,
self,
auto_roles: AutoRoleRepositoryABC,
clients: ClientRepositoryABC,
known_users: KnownUserRepositoryABC,
levels: LevelRepositoryABC,
servers: ServerRepositoryABC,
user_joined_servers: UserJoinedServerRepositoryABC,
user_joined_voice_channel: UserJoinedVoiceChannelRepositoryABC,
users: UserRepositoryABC,
bot: DiscordBotServiceABC,
):
self._auto_roles = auto_roles
self._clients = clients
@@ -48,47 +49,49 @@ class StatisticService:
self._bot = bot
async def execute(self, code: str, server: Server) -> StatisticResult:
guild = self._bot.guilds.where(lambda g: g.id == server.discord_server_id).single()
guild = self._bot.guilds.where(
lambda g: g.id == server.discord_server_id
).single()
return await self.get_data(
code,
self._auto_roles
.get_auto_roles()
.where(lambda x: x.server.server_id == server.server_id),
self._clients
.get_clients()
.where(lambda x: x.server.server_id == server.server_id),
self._auto_roles.get_auto_roles().where(
lambda x: x.server.server_id == server.server_id
),
self._clients.get_clients().where(
lambda x: x.server.server_id == server.server_id
),
self._known_users.get_users(),
self._levels
.get_levels()
.where(lambda x: x.server.server_id == server.server_id),
self._servers
.get_servers()
.where(lambda x: x.server_id == server.server_id),
self._user_joined_servers
.get_user_joined_servers()
.where(lambda x: x.user.server.server_id == server.server_id),
self._user_joined_voice_channel
.get_user_joined_voice_channels()
.where(lambda x: x.user.server.server_id == server.server_id),
self._users
.get_users()
.where(lambda x: x.server.server_id == server.server_id),
guild
self._levels.get_levels().where(
lambda x: x.server.server_id == server.server_id
),
self._servers.get_servers().where(
lambda x: x.server_id == server.server_id
),
self._user_joined_servers.get_user_joined_servers().where(
lambda x: x.user.server.server_id == server.server_id
),
self._user_joined_voice_channel.get_user_joined_voice_channels().where(
lambda x: x.user.server.server_id == server.server_id
),
self._users.get_users().where(
lambda x: x.server.server_id == server.server_id
),
guild,
)
@staticmethod
async def get_data(
code: str,
auto_roles: List[AutoRole],
clients: List[Client],
known_users: List[KnownUser],
levels: List[Level],
servers: List[Server],
user_joined_servers: List[UserJoinedServer],
user_joined_voice_channel: List[UserJoinedVoiceChannel],
users: List[User],
guild: Guild
code: str,
auto_roles: List[AutoRole],
clients: List[Client],
known_users: List[KnownUser],
levels: List[Level],
servers: List[Server],
user_joined_servers: List[UserJoinedServer],
user_joined_voice_channel: List[UserJoinedVoiceChannel],
users: List[User],
guild: Guild,
) -> StatisticResult:
result = StatisticResult()
exec(code)

9
kdb-bot/src/modules/stats/stats_module.py
View File

@@ -10,14 +10,17 @@ from modules.stats.service.statistic_service import StatisticService
class StatsModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.stats_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(StatisticService)
# commands
self._dc.add_command(StatsGroup)

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

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.stats.ui'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.stats.ui"
__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")

67
kdb-bot/src/modules/stats/ui/add_statistic_form.py
View File

@@ -13,20 +13,20 @@ from bot_data.model.statistic import Statistic
class AddStatisticForm(ui.Modal):
description = ui.TextInput(label='Beschreibung', required=True)
code = ui.TextInput(label='Code', required=True, style=TextStyle.long)
description = ui.TextInput(label="Beschreibung", required=True)
code = ui.TextInput(label="Code", required=True, style=TextStyle.long)
def __init__(
self,
server: Server,
stats: StatisticRepositoryABC,
db: DatabaseContextABC,
name: str,
message_service: MessageServiceABC,
logger: CommandLogger,
t: TranslatePipe,
code: str = None,
description: str = None,
self,
server: Server,
stats: StatisticRepositoryABC,
db: DatabaseContextABC,
name: str,
message_service: MessageServiceABC,
logger: CommandLogger,
t: TranslatePipe,
code: str = None,
description: str = None,
):
ui.Modal.__init__(self, title=name)
@@ -45,32 +45,55 @@ class AddStatisticForm(ui.Modal):
self.description.default = description
async def on_submit(self, interaction: discord.Interaction):
statistic = self._stats.get_statistics_by_server_id(self._server.server_id).where(lambda s: s.name == self._name).single_or_default()
statistic = (
self._stats.get_statistics_by_server_id(self._server.server_id)
.where(lambda s: s.name == self._name)
.single_or_default()
)
if interaction.guild is None:
if statistic is None:
await self._message_service.send_interaction_msg(interaction, self._t.transform('modules.stats.add.failed'))
await self._message_service.send_interaction_msg(
interaction, self._t.transform("modules.stats.add.failed")
)
else:
await self._message_service.send_interaction_msg(interaction, self._t.transform('modules.stats.edit.failed'))
await self._message_service.send_interaction_msg(
interaction, self._t.transform("modules.stats.edit.failed")
)
return
try:
if statistic is None:
self._stats.add_statistic(Statistic(self._name, self.description.value, self.code.value, self._server))
self._stats.add_statistic(
Statistic(
self._name,
self.description.value,
self.code.value,
self._server,
)
)
self._db.save_changes()
await self._message_service.send_interaction_msg(interaction, self._t.transform('modules.stats.add.success'))
await self._message_service.send_interaction_msg(
interaction, self._t.transform("modules.stats.add.success")
)
return
statistic.description = self.description.value
statistic.code = self.code.value
self._stats.update_statistic(statistic)
self._db.save_changes()
await self._message_service.send_interaction_msg(interaction, self._t.transform('modules.stats.edit.success'))
await self._message_service.send_interaction_msg(
interaction, self._t.transform("modules.stats.edit.success")
)
except Exception as e:
self._logger.error(__name__, f'Save statistic {self._name} failed', e)
self._logger.error(__name__, f"Save statistic {self._name} failed", e)
if statistic is None:
await self._message_service.send_interaction_msg(interaction, self._t.transform('modules.stats.add.failed'))
await self._message_service.send_interaction_msg(
interaction, self._t.transform("modules.stats.add.failed")
)
else:
await self._message_service.send_interaction_msg(interaction, self._t.transform('modules.stats.edit.failed'))
await self._message_service.send_interaction_msg(
interaction, self._t.transform("modules.stats.edit.failed")
)
self._logger.trace(__name__, f'Finished stats command form')
self._logger.trace(__name__, f"Finished stats command form")

16
kdb-bot/src/modules/technician/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.technician'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.technician"
__author__ = "Sven Heidemann"
__license__ = "MIT"
__copyright__ = "Copyright (c) 2022 sh-edraft.de"
__version__ = "0.3.0"
from collections import namedtuple
# imports:
# 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/technician/command/__init__.py
View File

@@ -11,16 +11,16 @@ Discord bot for the Keksdose discord Server
"""
__title__ = 'modules.technician.command'
__author__ = 'Sven Heidemann'
__license__ = 'MIT'
__copyright__ = 'Copyright (c) 2022 sh-edraft.de'
__version__ = '0.3.0'
__title__ = "modules.technician.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")

56
kdb-bot/src/modules/technician/command/log_command.py
View File

@@ -22,18 +22,17 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class LogCommand(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
logging_settings: LoggingSettings,
services: ServiceProviderABC,
message_service: MessageServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
permissions: PermissionServiceABC,
time_format: TimeFormatSettings,
env: ApplicationEnvironmentABC
self,
logger: CommandLogger,
logging_settings: LoggingSettings,
services: ServiceProviderABC,
message_service: MessageServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
permissions: PermissionServiceABC,
time_format: TimeFormatSettings,
env: ApplicationEnvironmentABC,
):
DiscordCommandABC.__init__(self)
@@ -49,10 +48,10 @@ class LogCommand(DiscordCommandABC):
self._log_settings: LoggingSettings = logging_settings
self._time_format_settings: TimeFormatSettings = time_format
self._logger.trace(__name__, f'Loaded command service: {type(self).__name__}')
self._logger.trace(__name__, f"Loaded command service: {type(self).__name__}")
def _reduce_path(self, p: str) -> str:
if len(p.split('/')) == 1 or p == '':
if len(p.split("/")) == 1 or p == "":
return p
return self._reduce_path(os.path.dirname(p))
@@ -62,15 +61,15 @@ class LogCommand(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_technician()
async def log(self, ctx: Context):
self._logger.debug(__name__, f'Received command log {ctx}')
self._logger.debug(__name__, f"Received command log {ctx}")
possible_log_paths = List(str)
possible_log_paths.append(self._reduce_path(self._logging_settings.path))
file_extensions = List(str)
if '.' in self._logging_settings.filename:
if "." in self._logging_settings.filename:
split_filename = self._logging_settings.filename.split(".")
file_extensions.append(f'.{split_filename[len(split_filename) - 1]}')
file_extensions.append(f".{split_filename[len(split_filename) - 1]}")
for subclass in CustomFileLoggerABC.__subclasses__():
logger: CustomFileLoggerABC = self._services.get_service(subclass)
@@ -78,9 +77,9 @@ class LogCommand(DiscordCommandABC):
continue
path = self._reduce_path(logger.settings.path)
if '.' in logger.settings.filename:
if "." in logger.settings.filename:
split_filename = logger.settings.filename.split(".")
file_extension = f'.{split_filename[len(split_filename) - 1]}'
file_extension = f".{split_filename[len(split_filename) - 1]}"
if file_extension not in file_extensions:
file_extensions.append(file_extension)
@@ -89,28 +88,35 @@ class LogCommand(DiscordCommandABC):
possible_log_paths.append(path)
files_str = "\n\t".join(possible_log_paths.to_list())
self._logger.debug(__name__, f'Possible log files: \n\t{files_str}')
self._logger.debug(__name__, f"Possible log files: \n\t{files_str}")
files = List(str)
for possible_path in possible_log_paths:
for r, d, f in os.walk(possible_path):
for file in f:
if '.' not in file:
if "." not in file:
continue
split_filename = file.split(".")
if f'.{split_filename[len(split_filename) - 1]}' not in file_extensions:
if (
f".{split_filename[len(split_filename) - 1]}"
not in file_extensions
):
continue
files.append(os.path.join(r, file))
files_str = "\n\t".join(files.to_list())
self._logger.debug(__name__, f'Log files: \n\t{files_str}')
self._logger.debug(__name__, f"Log files: \n\t{files_str}")
zip_file = ZipFile('logs.zip', 'w')
zip_file = ZipFile("logs.zip", "w")
files.for_each(lambda x: zip_file.write(x))
zip_file.close()
await self._message_service.send_interaction_msg(ctx.interaction, self._t.transform('modules.technician.log_message'), file=discord.File(zip_file.filename, 'logs.zip'))
await self._message_service.send_interaction_msg(
ctx.interaction,
self._t.transform("modules.technician.log_message"),
file=discord.File(zip_file.filename, "logs.zip"),
)
os.remove(zip_file.filename)
self._logger.trace(__name__, f'Finished log command')
self._logger.trace(__name__, f"Finished log command")

33
kdb-bot/src/modules/technician/command/restart_command.py
View File

@@ -16,17 +16,16 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class RestartCommand(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
config: ConfigurationABC,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
permissions: PermissionServiceABC,
settings: BotSettings
self,
logger: CommandLogger,
config: ConfigurationABC,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
permissions: PermissionServiceABC,
settings: BotSettings,
):
DiscordCommandABC.__init__(self)
@@ -39,19 +38,21 @@ class RestartCommand(DiscordCommandABC):
self._permissions = permissions
self._settings = settings
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_technician()
async def restart(self, ctx: Context):
self._logger.debug(__name__, f'Received command restart {ctx}')
self._logger.debug(__name__, f"Received command restart {ctx}")
self._config.add_configuration('IS_RESTART', 'true')
await self._client_utils.presence_game('common.presence.restart')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.technician.restart_message'))
self._config.add_configuration("IS_RESTART", "true")
await self._client_utils.presence_game("common.presence.restart")
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.technician.restart_message")
)
await asyncio.sleep(self._settings.wait_for_restart)
await self._bot.stop_async()
self._logger.trace(__name__, f'Finished restart command')
self._logger.trace(__name__, f"Finished restart command")

31
kdb-bot/src/modules/technician/command/shutdown_command.py
View File

@@ -17,17 +17,16 @@ from modules.permission.abc.permission_service_abc import PermissionServiceABC
class ShutdownCommand(DiscordCommandABC):
def __init__(
self,
logger: CommandLogger,
config: ConfigurationABC,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
permissions: PermissionServiceABC,
settings: BotSettings
self,
logger: CommandLogger,
config: ConfigurationABC,
message_service: MessageServiceABC,
bot: DiscordBotServiceABC,
client_utils: ClientUtilsABC,
translate: TranslatePipe,
permissions: PermissionServiceABC,
settings: BotSettings,
):
DiscordCommandABC.__init__(self)
@@ -40,18 +39,20 @@ class ShutdownCommand(DiscordCommandABC):
self._permissions = permissions
self._settings = settings
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_technician()
async def shutdown(self, ctx: Context):
self._logger.debug(__name__, f'Received command shutdown {ctx}')
self._logger.debug(__name__, f"Received command shutdown {ctx}")
await self._client_utils.presence_game('common.presence.shutdown')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.technician.shutdown_message'))
await self._client_utils.presence_game("common.presence.shutdown")
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.technician.shutdown_message")
)
await asyncio.sleep(self._settings.wait_for_shutdown)
await self._bot.stop_async()
self._logger.trace(__name__, f'Finished shutdown command')
self._logger.trace(__name__, f"Finished shutdown command")

9
kdb-bot/src/modules/technician/technician_module.py
View File

@@ -13,14 +13,17 @@ from modules.base.service.base_helper_service import BaseHelperService
class TechnicianModule(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)
# commands
self._dc.add_command(RestartCommand)