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

Merge pull request 'Levelsystem per Befehl neuladen #164' (#175) from #164 into 0.3.1

Browse Source 
Reviewed-on: sh-edraft.de/kd_discord_bot#175
Reviewed-by: Ebola-Chan <nick.jungmann@gmail.com>
Closes #164
This commit is contained in:
Sven Heidemann 2023-01-13 22:15:11 +01:00
commit 624625d4b5
3 changed files with 188 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
kdb-bot/src/bot_core/abc/message_service_abc.py
View File

@ -1,5 +1,5 @@
from abc import ABC, abstractmethod
from typing import Union
from typing import Union, Optional
import discord
from cpl_query.extension import List
@ -19,13 +19,24 @@ class MessageServiceABC(ABC):
async def delete_message(self, message: discord.Message, without_tracking=False): pass
@abstractmethod
async def send_channel_message(self, channel: discord.TextChannel, message: Union[str, discord.Embed], without_tracking=True): pass
async def send_channel_message(
self, channel: discord.TextChannel, message: Union[str, discord.Embed], without_tracking=True
): pass
@abstractmethod
async def send_dm_message(self, message: Union[str, discord.Embed], receiver: Union[discord.User, discord.Member], without_tracking=False): pass
async def send_dm_message(
self, message: Union[str, discord.Embed], receiver: Union[discord.User, discord.Member],
without_tracking=False
): pass
@abstractmethod
async def send_ctx_msg(self, ctx: Context, message: Union[str, discord.Embed], file: discord.File = None, is_persistent: bool = False, is_public: bool = False, wait_before_delete: int = None, without_tracking=True): pass
async def send_ctx_msg(
self, ctx: Context, message: Union[str, discord.Embed], file: discord.File = None,
is_persistent: bool = False, is_public: bool = False, wait_before_delete: int = None, without_tracking=True
) -> Optional[discord.Message]: pass
@abstractmethod
async def send_interaction_msg(self, interaction: Interaction, message: Union[str, discord.Embed], is_persistent: bool = False, is_public: bool = False, wait_before_delete: int = None, without_tracking=True, **kwargs): pass
async def send_interaction_msg(
self, interaction: Interaction, message: Union[str, discord.Embed], is_persistent: bool = False,
is_public: bool = False, wait_before_delete: int = None, without_tracking=True, **kwargs
): pass

52
kdb-bot/src/bot_core/service/message_service.py
View File

@ -1,5 +1,5 @@
import asyncio
from typing import Union
from typing import Union, Optional
import discord
from cpl_core.configuration.configuration_abc import ConfigurationABC
@ -18,13 +18,14 @@ from bot_data.abc.client_repository_abc import ClientRepositoryABC
class MessageService(MessageServiceABC):
def __init__(self, config: ConfigurationABC, logger: MessageLogger, bot: DiscordBotServiceABC, clients: ClientRepositoryABC, db: DatabaseContextABC):
def __init__(self, config: ConfigurationABC, logger: MessageLogger, bot: DiscordBotServiceABC,
clients: ClientRepositoryABC, db: DatabaseContextABC):
self._config = config
self._logger = logger
self._bot = bot
self._clients = clients
self._db = db
async def delete_messages(self, messages: List[discord.Message], guild_id: int, without_tracking=False):
self._logger.debug(__name__, f'Try to delete {messages.count()} messages')
server_st: ServerSettings = self._config.get_configuration(f'ServerSettings_{guild_id}')
@ -32,13 +33,18 @@ class MessageService(MessageServiceABC):
for message in messages:
await self.delete_message(message, mass_delete=True, without_tracking=without_tracking)
self._logger.debug(__name__, 'Deleting messages finished')
async def delete_message(self, message: discord.Message, mass_delete=False, without_tracking=False):
server_st: ServerSettings = self._config.get_configuration(f'ServerSettings_{message.guild.id}')
guild_id = \
message.guild.id if message.guild is not None else \
message.channel.guild.id if message.channel is not None and message.channel.guild is not None else \
message.reference.guild_id if message.reference is not None and message.reference.guild_id is not None \
else None
server_st: ServerSettings = self._config.get_configuration(f'ServerSettings_{guild_id}')
if not mass_delete:
await asyncio.sleep(server_st.message_delete_timer)
self._logger.debug(__name__, f'Try to delete message: {LogMessageHelper.get_log_string(message)}')
guild_id = message.guild.id
try:
await message.delete()
await asyncio.sleep(server_st.message_delete_timer)
@ -49,8 +55,11 @@ class MessageService(MessageServiceABC):
self._clients.append_deleted_message_count(self._bot.user.id, guild_id, 1)
self._db.save_changes()
self._logger.info(__name__, f'Deleted message {message}')
async def send_channel_message(self, channel: discord.TextChannel, message: Union[str, discord.Embed], is_persistent: bool = False, wait_before_delete: int = None, without_tracking=False):
async def send_channel_message(
self, channel: discord.TextChannel, message: Union[str, discord.Embed], is_persistent: bool = False,
wait_before_delete: int = None, without_tracking=False
):
self._logger.debug(__name__, f'Try to send message\n\t{message}\n\tto: {channel}')
msg = None
try:
@ -73,8 +82,11 @@ class MessageService(MessageServiceABC):
return
await self.delete_message(msg, without_tracking)
async def send_dm_message(self, message: Union[str, discord.Embed], receiver: Union[discord.User, discord.Member], without_tracking=False):
async def send_dm_message(
self, message: Union[str, discord.Embed], receiver: Union[discord.User, discord.Member],
without_tracking=False
):
self._logger.debug(__name__, f'Try to send message\n\t{message}\n\tto: {receiver}')
try:
if isinstance(message, discord.Embed):
@ -88,13 +100,16 @@ class MessageService(MessageServiceABC):
self._clients.append_sent_message_count(self._bot.user.id, receiver.guild.id, 1)
self._db.save_changes()
self._logger.info(__name__, f'Sent message to user {receiver.id}')
async def send_ctx_msg(self, ctx: Context, message: Union[str, discord.Embed], file: discord.File = None, is_persistent: bool = False, is_public: bool = False, wait_before_delete: int = None, without_tracking=False):
async def send_ctx_msg(
self, ctx: Context, message: Union[str, discord.Embed], file: discord.File = None,
is_persistent: bool = False, is_public: bool = False, wait_before_delete: int = None, without_tracking=False
) -> Optional[discord.Message]:
if ctx is None:
self._logger.warn(__name__, 'Message context is empty')
self._logger.debug(__name__, f'Message: {message}')
return
return None
self._logger.debug(__name__, f'Try to send message\t\t{message}\n\tto: {ctx.channel}')
msg = None
try:
@ -114,12 +129,17 @@ class MessageService(MessageServiceABC):
await asyncio.sleep(wait_before_delete)
if is_persistent:
return
return msg
if ctx.guild is not None:
await self.delete_message(msg, without_tracking)
async def send_interaction_msg(self, interaction: Interaction, message: Union[str, discord.Embed], is_persistent: bool = False, is_public: bool = False, wait_before_delete: int = None, without_tracking=False, **kwargs):
return msg
async def send_interaction_msg(
self, interaction: Interaction, message: Union[str, discord.Embed], is_persistent: bool = False,
is_public: bool = False, wait_before_delete: int = None, without_tracking=False, **kwargs
):
if interaction is None:
self._logger.warn(__name__, 'Message context is empty')
self._logger.debug(__name__, f'Message: {message}')

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

@ -83,20 +83,34 @@ class LevelGroup(DiscordCommandABC):
self._logger.trace(__name__, f'Loaded command service: {type(self).__name__}')
async def _seed_levels(self, channel: discord.TextChannel):
async def _seed_levels(self, ctx: Context):
# send message to ctx.channel because send_ctx_msg resolves ctx
try:
await self._message_service.send_channel_message(channel, self._t.transform('modules.level.seeding_started'))
start = await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.seeding_started'),
is_persistent=True
)
await self._level_seeder.seed()
await self._message_service.send_channel_message(channel, self._t.transform('modules.level.seeding_finished'))
end = await self._message_service.send_ctx_msg(
ctx,
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_channel_message(channel, self._t.transform('modules.level.seeding_failed'))
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)]
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()
@ -167,41 +181,66 @@ class LevelGroup(DiscordCommandABC):
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')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.error.level_with_name_already_exists').format(level.name))
await self._message_service.send_ctx_msg(
ctx,
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))
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}')
self._logger.info(
__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)
self._logger.error(
__name__,
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))
await self._seed_levels(ctx.channel)
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.create.created').format(name, permissions)
)
await self._seed_levels(ctx)
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]]:
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]
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
]
@level.command()
@commands.guild_only()
@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):
async def edit(
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}')
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))
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.edit.not_found').format(level)
)
return
guild: Guild = self._bot.guilds.where(lambda g: g == ctx.guild).single()
@ -214,7 +253,10 @@ class LevelGroup(DiscordCommandABC):
try:
level_from_db.color = hex(discord.Colour.from_str(color).value)
except Exception as e:
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.edit.color_invalid').format(color))
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.edit.color_invalid').format(color)
)
self._logger.error(__name__, f'Error parsing color {color}', e)
return
@ -225,33 +267,51 @@ 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))
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:
self._levels.update_level(level_from_db)
self._db.save_changes()
await role.edit(name=level_from_db.name, permissions=discord.Permissions(level_from_db.permissions), 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}')
await role.edit(
name=level_from_db.name,
permissions=discord.Permissions(level_from_db.permissions),
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}'
)
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)
self._logger.error(
__name__,
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._seed_levels(ctx.channel)
await self._seed_levels(ctx)
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]]:
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]]:
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]
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
]
@level.command()
@commands.guild_only()
@ -261,10 +321,14 @@ class LevelGroup(DiscordCommandABC):
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')
await self._message_service.send_ctx_msg(ctx, self._t.transform('modules.level.remove.error.not_found').format(level))
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.remove.error.not_found').format(level)
)
self._logger.trace(__name__, f'Finished command level remove')
return
@ -279,13 +343,17 @@ class LevelGroup(DiscordCommandABC):
except Exception as 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))
await self._seed_levels(ctx.channel)
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.remove.success').format(level)
)
await self._seed_levels(ctx)
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]]:
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()
@ -304,7 +372,9 @@ class LevelGroup(DiscordCommandABC):
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))
await self._message_service.send_ctx_msg(
ctx, self._t.transform('modules.level.down.already_first').format(member.mention)
)
self._logger.trace(__name__, f'Finished command level down')
return
@ -313,11 +383,13 @@ 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))
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')
@ -337,7 +409,10 @@ class LevelGroup(DiscordCommandABC):
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))
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.up.already_last').format(member.mention)
)
self._logger.trace(__name__, f'Finished command level up')
return
@ -346,11 +421,13 @@ 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))
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')
@ -367,15 +444,20 @@ class LevelGroup(DiscordCommandABC):
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)
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))
await self._message_service.send_ctx_msg(
ctx,
self._t.transform('modules.level.set.not_found').format(level)
)
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))
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
@ -383,14 +465,25 @@ 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.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))
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')
@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()
@commands.guild_only()
@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}')
await self._seed_levels(ctx)
self._logger.trace(__name__, f'Finished command level reload')