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

Formatted stuff #405

Browse Source
This commit is contained in:
Sven Heidemann
2023-10-15 11:30:29 +02:00
parent 3a7daf8b42
commit be6361f619
226 changed files with 1083 additions and 3252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
bot/src/modules/achievements/achievement_attribute_resolver.py
View File

@@ -46,22 +46,9 @@ class AchievementAttributeResolver:
self._achievements = achievements
def get_played_on_game_server(self, user: User) -> List[str]:
joins = self._user_joined_game_server.get_user_joined_game_servers_by_user_id(
user.id
)
joins = self._user_joined_game_server.get_user_joined_game_servers_by_user_id(user.id)
return joins.select(lambda x: x.game_server.name)
def get_last_ontime_hours(self, user: User) -> int:
ujvs = (
self._user_joined_voice_channels.get_user_joined_voice_channels_by_user_id(
user.id
)
)
return int(
str(
ujvs.max(
lambda join: (join.leaved_on - join.joined_on).total_seconds()
/ 3600
)
)
)
ujvs = self._user_joined_voice_channels.get_user_joined_voice_channels_by_user_id(user.id)
return int(str(ujvs.max(lambda join: (join.leaved_on - join.joined_on).total_seconds() / 3600)))

60
bot/src/modules/achievements/achievement_service.py
View File

@@ -45,12 +45,8 @@ class AchievementService:
self._attributes.extend(
[
AchievementAttribute("xp", lambda user: user.xp, "number"),
AchievementAttribute(
"message_count", lambda user: user.message_count, "number"
),
AchievementAttribute(
"reaction_count", lambda user: user.reaction_count, "number"
),
AchievementAttribute("message_count", lambda user: user.message_count, "number"),
AchievementAttribute("reaction_count", lambda user: user.reaction_count, "number"),
AchievementAttribute("ontime", lambda user: user.ontime, "number"),
AchievementAttribute("level", lambda user: user.level, "Level"),
# special cases
@@ -70,14 +66,10 @@ class AchievementService:
self._operators = {
"==": lambda value, expected_value: value == expected_value,
"!=": lambda value, expected_value: value != expected_value,
"<=": lambda value, expected_value: self._num(value)
<= self._num(expected_value),
">=": lambda value, expected_value: self._num(value)
>= self._num(expected_value),
"<": lambda value, expected_value: self._num(value)
< self._num(expected_value),
">": lambda value, expected_value: self._num(value)
> self._num(expected_value),
"<=": lambda value, expected_value: self._num(value) <= self._num(expected_value),
">=": lambda value, expected_value: self._num(value) >= self._num(expected_value),
"<": lambda value, expected_value: self._num(value) < self._num(expected_value),
">": lambda value, expected_value: self._num(value) > self._num(expected_value),
"contains": lambda value, expected_value: expected_value in value,
}
@@ -100,57 +92,37 @@ class AchievementService:
def _match(self, value: any, operator: str, expected_value: str) -> bool:
return self._operators[operator](str(value), expected_value)
def has_user_achievement_already(
self, user: User, achievement: Achievement
) -> bool:
def has_user_achievement_already(self, user: User, achievement: Achievement) -> bool:
user_achievements = self._achievements.get_achievements_by_user_id(user.id)
return user_achievements.where(lambda x: x.name == achievement.name).count() > 0
def has_user_achievement(self, user: User, achievement: Achievement) -> bool:
attribute: AchievementAttribute = self._attributes.where(
lambda x: x.name == achievement.attribute
).single()
return self._match(
attribute.resolve(user), achievement.operator, achievement.value
)
attribute: AchievementAttribute = self._attributes.where(lambda x: x.name == achievement.attribute).single()
return self._match(attribute.resolve(user), achievement.operator, achievement.value)
async def validate_achievements_for_user(self, user: User):
achievements = self._achievements.get_achievements_by_server_id(user.server.id)
for achievement in achievements:
if self.has_user_achievement_already(
user, achievement
) or not self.has_user_achievement(user, achievement):
if self.has_user_achievement_already(user, achievement) or not self.has_user_achievement(user, achievement):
continue
self._achievements.add_user_got_achievement(
UserGotAchievement(user, achievement, user.server)
)
self._achievements.add_user_got_achievement(UserGotAchievement(user, achievement, user.server))
self._db.save_changes()
self._give_user_xp(user)
await self._send_achievement_notification(
user.server.discord_id, user.discord_id, achievement.name
)
await self._send_achievement_notification(user.server.discord_id, user.discord_id, achievement.name)
def _give_user_xp(self, user: User):
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{user.server.discord_id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{user.server.discord_id}")
user.xp += settings.xp_per_achievement
self._users.update_user(user)
self._db.save_changes()
async def _send_achievement_notification(
self, guild_id: int, member_id: int, achievement_name: str
):
async def _send_achievement_notification(self, guild_id: int, member_id: int, achievement_name: str):
member = self._bot.get_guild(guild_id).get_member(member_id)
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{guild_id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{guild_id}")
await self._message_service.send_channel_message(
self._bot.get_channel(settings.notification_chat_id),
self._t.transform("modules.achievements.got_new_achievement").format(
member.mention, achievement_name
),
self._t.transform("modules.achievements.got_new_achievement").format(member.mention, achievement_name),
is_persistent=True,
)

16
bot/src/modules/achievements/achievements_module.py
View File

@@ -29,25 +29,17 @@ class AchievementsModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.achievements_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(AchievementAttributeResolver)
services.add_transient(AchievementService)
services.add_transient(AchievementGroup)
services.add_transient(
DiscordEventTypesEnum.on_message.value, AchievementOnMessageEvent
)
services.add_transient(
DiscordEventTypesEnum.on_reaction_add.value, AchievementOnReactionAddEvent
)
services.add_transient(DiscordEventTypesEnum.on_message.value, AchievementOnMessageEvent)
services.add_transient(DiscordEventTypesEnum.on_reaction_add.value, AchievementOnReactionAddEvent)
services.add_transient(
DiscordEventTypesEnum.on_reaction_remove.value,
AchievementOnReactionRemoveEvent,

4
bot/src/modules/achievements/commands/achievements_group.py
View File

@@ -54,9 +54,7 @@ class AchievementGroup(DiscordCommandABC):
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.achievements_module
):

8
bot/src/modules/achievements/events/achievement_on_message_event.py
View File

@@ -43,18 +43,14 @@ class AchievementOnMessageEvent(OnMessageABC):
if message.author.bot:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{message.guild.id}"
)
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{message.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.achievements_module
):
return
server = self._servers.get_server_by_discord_id(message.guild.id)
user = self._users.get_user_by_discord_id_and_server_id(
message.author.id, server.id
)
user = self._users.get_user_by_discord_id_and_server_id(message.author.id, server.id)
user.message_count += 1
self._users.update_user(user)

4
bot/src/modules/achievements/events/achievement_on_reaction_add_event.py
View File

@@ -50,9 +50,7 @@ class AchievementOnReactionAddEvent(OnReactionAddABC):
if user.bot:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{user.guild.id}"
)
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{user.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.achievements_module
):

4
bot/src/modules/achievements/events/achievement_on_reaction_remove_event.py
View File

@@ -50,9 +50,7 @@ class AchievementOnReactionRemoveEvent(OnReactionRemoveABC):
if user.bot:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{user.guild.id}"
)
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{user.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.achievements_module
):

4
bot/src/modules/achievements/events/achievement_on_voice_state_update_event.py
View File

@@ -46,9 +46,7 @@ class AchievementOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
if member.bot:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{member.guild.id}"
)
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{member.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.achievements_module
):

8
bot/src/modules/auto_role/auto_role_module.py
View File

@@ -20,14 +20,10 @@ 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
services.add_transient(AutoRoleGroup)

208
bot/src/modules/auto_role/command/auto_role_group.py
View File

@@ -58,14 +58,10 @@ class AutoRoleGroup(DiscordCommandABC):
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.id).select(
lambda x: x.id
)
auto_roles = self._auto_roles.get_auto_roles_by_server_id(server.id).select(lambda x: x.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, lambda x: x.name
)
for auto_role in self._client_utils.get_auto_complete_list(auto_roles, current, lambda x: x.name)
]
@commands.hybrid_group(name="auto-role")
@@ -82,12 +78,8 @@ class AutoRoleGroup(DiscordCommandABC):
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.auto_role_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.auto_role_module):
return
embed = discord.Embed(
@@ -98,9 +90,7 @@ class AutoRoleGroup(DiscordCommandABC):
server = self._servers.get_server_by_discord_id(ctx.guild.id)
auto_roles = self._auto_roles.get_auto_roles_by_server_id(server.id)
if auto_roles.count() < 1:
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.auto_role.error.nothing_found")
)
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
@@ -128,18 +118,12 @@ class AutoRoleGroup(DiscordCommandABC):
@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}")
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.auto_role_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.auto_role_module):
return
message = (
@@ -151,56 +135,38 @@ class AutoRoleGroup(DiscordCommandABC):
.single_or_default()
)
if message is None:
self._logger.debug(
__name__, f"Message with id {message_id} not found in {channel.name}"
)
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._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"
)
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._t.transform("modules.auto_role.add.error.already_exists").format(message_id),
)
self._logger.trace(__name__, f"Finished command auto-role add")
return
server = self._servers.get_server_by_discord_id(ctx.guild.id)
self._auto_roles.add_auto_role(
AutoRole(server, int(channel.id), int(message_id))
)
self._auto_roles.add_auto_role(AutoRole(server, 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}"
)
self._logger.info(__name__, f"Saved auto-role for message {message_id} at server {server}")
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
)
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)
)
found_channel = discord.utils.get(interaction.guild.text_channels, id=int(channel_from_data))
if found_channel is not None:
channel = found_channel
finally:
@@ -208,9 +174,7 @@ class AutoRoleGroup(DiscordCommandABC):
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)
)
app_commands.Choice(name=f"{message.author}@{message.created_at}", value=str(message.id))
for message in messages
if current in str(message.id)
]
@@ -220,18 +184,12 @@ class AutoRoleGroup(DiscordCommandABC):
@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}")
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.auto_role_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.auto_role_module):
return
auto_role_from_db = self._auto_roles.find_auto_role_by_id(auto_role)
@@ -239,16 +197,12 @@ class AutoRoleGroup(DiscordCommandABC):
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._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.id
):
for rule in self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role_from_db.id):
self._auto_roles.delete_auto_role_rule(rule)
self._logger.info(__name__, f"Removed auto-role rule {rule.role_id}")
@@ -271,18 +225,12 @@ class AutoRoleGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def react(self, ctx: Context, auto_role: int):
self._logger.debug(
__name__, f"Received command auto-role react {ctx} {auto_role}"
)
self._logger.debug(__name__, f"Received command auto-role react {ctx} {auto_role}")
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.auto_role_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.auto_role_module):
return
auto_role_from_db = self._auto_roles.find_auto_role_by_id(auto_role)
@@ -290,16 +238,12 @@ class AutoRoleGroup(DiscordCommandABC):
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._t.transform("modules.auto_role.remove.error.not_found").format(auto_role),
)
self._logger.trace(__name__, f"Finished command auto-role react")
return
for rule in self._auto_roles.get_auto_role_rules_by_auto_role_id(
auto_role_from_db.id
):
for rule in self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role_from_db.id):
await self._client_utils.react_to_message_by_auto_role_rule(
auto_role_from_db.discord_channel_id,
auto_role_from_db.discord_message_id,
@@ -333,12 +277,8 @@ class AutoRoleGroup(DiscordCommandABC):
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.auto_role_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.auto_role_module):
return
embed = discord.Embed(
@@ -391,30 +331,20 @@ 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}")
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.auto_role_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.auto_role_module):
return
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"
)
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._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
@@ -424,9 +354,7 @@ class AutoRoleGroup(DiscordCommandABC):
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._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
@@ -435,9 +363,7 @@ class AutoRoleGroup(DiscordCommandABC):
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._t.transform("modules.auto_role.remove.error.not_found").format(auto_role),
)
self._logger.trace(__name__, f"Finished command auto-role rule add")
return
@@ -450,16 +376,12 @@ class AutoRoleGroup(DiscordCommandABC):
):
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.auto_role.add.error.already_exists").format(
auto_role
),
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_from_db, emoji_name, int(role_id))
)
self._auto_roles.add_auto_role_rule(AutoRoleRule(auto_role_from_db, emoji_name, int(role_id)))
self._db_context.save_changes()
rule = (
self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role)
@@ -479,28 +401,20 @@ class AutoRoleGroup(DiscordCommandABC):
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.auto_role.rule.add.success").format(
emoji, role.mention, auto_role
),
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]]:
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]]:
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
)
for emoji in self._client_utils.get_auto_complete_list(emojis, current, lambda e: e.name)
]
@add.autocomplete("role_id")
@@ -510,9 +424,7 @@ class AutoRoleGroup(DiscordCommandABC):
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
)
for role in self._client_utils.get_auto_complete_list(roles, current, lambda r: r.name)
]
@rule.command()
@@ -520,18 +432,12 @@ class AutoRoleGroup(DiscordCommandABC):
@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}")
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.auto_role_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.auto_role_module):
return
auto_role_from_db = self._auto_roles.get_auto_role_rule_by_id(auto_role_rule)
@@ -539,9 +445,7 @@ class AutoRoleGroup(DiscordCommandABC):
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._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
@@ -551,9 +455,7 @@ class AutoRoleGroup(DiscordCommandABC):
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._t.transform("modules.auto_role.rule.remove.success").format(auto_role_rule),
)
self._logger.trace(__name__, f"Finished command auto-role remove")
@@ -562,18 +464,12 @@ class AutoRoleGroup(DiscordCommandABC):
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.id).select(
lambda x: x.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.id).select(lambda x: x.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.id} {rule.emoji_name} {interaction.guild.get_role(int(rule.role_id))}",
value=rule.id,
)
for rule in self._client_utils.get_auto_complete_list(
rules, current, lambda r: r.id
)
for rule in self._client_utils.get_auto_complete_list(rules, current, lambda r: r.id)
]

8
bot/src/modules/auto_role/events/auto_role_on_raw_reaction_add.py
View File

@@ -35,12 +35,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")
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{payload.guild_id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.auto_role_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{payload.guild_id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.auto_role_module):
return
await self._reaction_handler.handle(payload, "add")

8
bot/src/modules/auto_role/events/auto_role_on_raw_reaction_remove.py
View File

@@ -35,12 +35,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")
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{payload.guild_id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.auto_role_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{payload.guild_id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.auto_role_module):
return
await self._reaction_handler.handle(payload, "remove")

12
bot/src/modules/auto_role/helper/auto_role_reaction_handler.py
View File

@@ -22,9 +22,7 @@ class AutoRoleReactionHandler:
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:
@@ -36,9 +34,7 @@ class AutoRoleReactionHandler:
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:
@@ -53,9 +49,7 @@ class AutoRoleReactionHandler:
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.id)
rules: List[AutoRoleRule] = self._auto_roles.get_auto_role_rules_by_auto_role_id(auto_role.id)
if rules.count() == 0:
self._logger.debug(__name__, f"auto-role rules not found - skipping")
return

36
bot/src/modules/base/base_module.py
View File

@@ -53,14 +53,10 @@ 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(BaseReactionHandler)
services.add_singleton(EventService)
services.add_transient(UserWarningsService)
@@ -86,27 +82,13 @@ class BaseModule(ModuleABC):
services.add_transient(UnregisterGroup)
services.add_transient(GameServerGroup)
# events
services.add_transient(
DiscordEventTypesEnum.on_command.value, BaseOnCommandEvent
)
services.add_transient(
DiscordEventTypesEnum.on_command_error.value, BaseOnCommandErrorEvent
)
services.add_transient(
DiscordEventTypesEnum.on_member_join.value, BaseOnMemberJoinEvent
)
services.add_transient(
DiscordEventTypesEnum.on_member_remove.value, BaseOnMemberRemoveEvent
)
services.add_transient(
DiscordEventTypesEnum.on_message.value, BaseOnMessageEvent
)
services.add_transient(
DiscordEventTypesEnum.on_message_delete.value, BaseOnMessageDeleteEvent
)
services.add_transient(
DiscordEventTypesEnum.on_raw_reaction_add.value, BaseOnRawReactionAddEvent
)
services.add_transient(DiscordEventTypesEnum.on_command.value, BaseOnCommandEvent)
services.add_transient(DiscordEventTypesEnum.on_command_error.value, BaseOnCommandErrorEvent)
services.add_transient(DiscordEventTypesEnum.on_member_join.value, BaseOnMemberJoinEvent)
services.add_transient(DiscordEventTypesEnum.on_member_remove.value, BaseOnMemberRemoveEvent)
services.add_transient(DiscordEventTypesEnum.on_message.value, BaseOnMessageEvent)
services.add_transient(DiscordEventTypesEnum.on_message_delete.value, BaseOnMessageDeleteEvent)
services.add_transient(DiscordEventTypesEnum.on_raw_reaction_add.value, BaseOnRawReactionAddEvent)
services.add_transient(
DiscordEventTypesEnum.on_raw_reaction_remove.value,
BaseOnRawReactionRemoveEvent,

8
bot/src/modules/base/birthday_watcher.py
View File

@@ -46,9 +46,7 @@ class BirthdayWatcher(TaskABC):
if user.birthday.day != today.day or user.birthday.month != today.month:
continue
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{user.server.discord_id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{user.server.discord_id}")
user.xp += settings.xp_for_birthday
self._users.update_user(user)
@@ -58,9 +56,7 @@ class BirthdayWatcher(TaskABC):
member = guild.get_member(user.discord_id)
await self._message_service.send_channel_message(
self._bot.get_channel(settings.notification_chat_id),
self._t.transform("modules.base.user.birthday.has_birthday").format(
member.mention
),
self._t.transform("modules.base.user.birthday.has_birthday").format(member.mention),
is_persistent=True,
)
except Exception as e:

12
bot/src/modules/base/command/afk_command.py
View File

@@ -39,9 +39,7 @@ class AFKCommand(DiscordCommandABC):
@CommandChecks.check_is_ready()
async def afk(self, ctx: Context):
self._logger.debug(__name__, f"Received command afk {ctx}")
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if ctx.author.voice is None or ctx.author.voice.channel is None:
await self._message_service.send_ctx_msg(
@@ -52,9 +50,7 @@ class AFKCommand(DiscordCommandABC):
return
self._bot.loop.create_task(
self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.afk_command_move_message")
)
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:
@@ -66,8 +62,6 @@ class AFKCommand(DiscordCommandABC):
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")
)
await self._message_service.send_ctx_msg(ctx, self._t.transform("common.no_permission_message"))
self._logger.trace(__name__, f"Finished afk command")

84
bot/src/modules/base/command/game_server_group.py
View File

@@ -76,15 +76,9 @@ class GameServerGroup(DiscordCommandABC):
if ctx.guild is None:
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
settings.feature_flags, FeatureFlagsEnum.game_server
):
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.feature_not_activated")
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(settings.feature_flags, FeatureFlagsEnum.game_server):
await self._message_service.send_ctx_msg(ctx, self._t.transform("common.feature_not_activated"))
return
server = self._servers.get_server_by_discord_id(ctx.guild.id)
@@ -127,22 +121,14 @@ class GameServerGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_admin()
async def add(self, ctx: Context, name: str, api_key_id: int):
self._logger.debug(
__name__, f"Received command game-server add {ctx}: {name} {api_key_id}"
)
self._logger.debug(__name__, f"Received command game-server add {ctx}: {name} {api_key_id}")
if ctx.guild is None:
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
settings.feature_flags, FeatureFlagsEnum.game_server
):
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.feature_not_activated")
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(settings.feature_flags, FeatureFlagsEnum.game_server):
await self._message_service.send_ctx_msg(ctx, self._t.transform("common.feature_not_activated"))
return
server = self._servers.get_server_by_discord_id(ctx.guild.id)
@@ -166,9 +152,7 @@ class GameServerGroup(DiscordCommandABC):
return [
app_commands.Choice(name=f"{key.identifier}: {key.key}", value=key.id)
for key in self._client_utils.get_auto_complete_list(
keys, current, lambda x: x.key
)
for key in self._client_utils.get_auto_complete_list(keys, current, lambda x: x.key)
]
@game_server.command()
@@ -181,38 +165,26 @@ class GameServerGroup(DiscordCommandABC):
if ctx.guild is None:
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
settings.feature_flags, FeatureFlagsEnum.game_server
):
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.feature_not_activated")
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(settings.feature_flags, FeatureFlagsEnum.game_server):
await self._message_service.send_ctx_msg(ctx, self._t.transform("common.feature_not_activated"))
return
game_server = self._game_servers.get_game_server_by_id(id)
self._game_servers.delete_game_server(game_server)
self._db.save_changes()
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.game_server.remove.success")
)
await self._message_service.send_ctx_msg(ctx, self._t.transform("modules.base.game_server.remove.success"))
self._logger.trace(__name__, f"Finished command game-server remove")
@remove.autocomplete("id")
async def id_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
async def id_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
server = self._servers.get_server_by_discord_id(interaction.guild.id)
game_servers = self._game_servers.get_game_servers_by_server_id(server.id)
return [
app_commands.Choice(name=gs.name, value=gs.id)
for gs in self._client_utils.get_auto_complete_list(
game_servers, current, lambda x: x.name
)
for gs in self._client_utils.get_auto_complete_list(game_servers, current, lambda x: x.name)
]
@game_server.command(name="list-members")
@@ -225,30 +197,20 @@ class GameServerGroup(DiscordCommandABC):
if ctx.guild is None:
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
settings.feature_flags, FeatureFlagsEnum.game_server
):
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.feature_not_activated")
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(settings.feature_flags, FeatureFlagsEnum.game_server):
await self._message_service.send_ctx_msg(ctx, self._t.transform("common.feature_not_activated"))
return
game_server = self._game_servers.get_game_server_by_id(id)
game_idents = self._user_game_idents.get_user_game_idents_by_game_server_id(
game_server.id
)
game_idents = self._user_game_idents.get_user_game_idents_by_game_server_id(game_server.id)
users = ""
for game_ident in game_idents:
users += f"\n{game_ident.user.name}"
embed = discord.Embed(
title=self._t.transform("modules.base.game_server.list_members.title"),
description=self._t.transform(
"modules.base.game_server.list_members.description"
),
description=self._t.transform("modules.base.game_server.list_members.description"),
color=int("ef9d0d", 16),
)
embed.add_field(
@@ -261,15 +223,11 @@ class GameServerGroup(DiscordCommandABC):
self._logger.trace(__name__, f"Finished command game-server remove")
@list_members.autocomplete("id")
async def id_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
async def id_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
server = self._servers.get_server_by_discord_id(interaction.guild.id)
game_servers = self._game_servers.get_game_servers_by_server_id(server.id)
return [
app_commands.Choice(name=gs.name, value=gs.id)
for gs in self._client_utils.get_auto_complete_list(
game_servers, current, lambda x: x.name
)
for gs in self._client_utils.get_auto_complete_list(game_servers, current, lambda x: x.name)
]

4
bot/src/modules/base/command/help_command.py
View File

@@ -50,8 +50,6 @@ class HelpCommand(DiscordCommandABC):
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]]:
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]

5
bot/src/modules/base/command/info_command.py
View File

@@ -55,10 +55,7 @@ class InfoCommand(DiscordCommandABC):
)
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,
(datetime.now() - datetime.strptime(start_time, "%Y-%m-%d %H:%M:%S.%f")).total_seconds() / 3600,
2,
)
embed.add_field(

4
bot/src/modules/base/command/mass_move_command.py
View File

@@ -58,9 +58,7 @@ class MassMoveCommand(DiscordCommandABC):
await self._message_service.send_ctx_msg(
ctx,
self._t.transform("modules.base.mass_move.moved").format(
channel_from.mention, channel_to.mention
),
self._t.transform("modules.base.mass_move.moved").format(channel_from.mention, channel_to.mention),
)
self._logger.trace(__name__, f"Finished mass-move command")

8
bot/src/modules/base/command/ping_command.py
View File

@@ -58,12 +58,8 @@ class PingCommand(DiscordCommandABC):
color=int("ef9d0d", 16),
)
for server in self._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")
)
await self._message_service.send_ctx_msg(ctx, self._t.transform("modules.base.pong"))
self._logger.trace(__name__, f"Finished ping command")

8
bot/src/modules/base/command/presence_command.py
View File

@@ -34,9 +34,7 @@ class PresenceCommand(DiscordCommandABC):
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:
@@ -46,8 +44,6 @@ class PresenceCommand(DiscordCommandABC):
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")

12
bot/src/modules/base/command/purge_command.py
View File

@@ -41,20 +41,14 @@ class PurgeCommand(DiscordCommandABC):
@CommandChecks.check_is_member_moderator()
async def purge(self, ctx: Context):
self._logger.debug(__name__, f"Received command purge {ctx}")
server_settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
server_settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{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")
)
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")

12
bot/src/modules/base/command/register_group.py
View File

@@ -59,17 +59,13 @@ class RegisterGroup(DiscordCommandABC):
@commands.guild_only()
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def minecraft(
self, ctx: Context, member: discord.Member, game_server: int, name: str
):
async def minecraft(self, ctx: Context, member: discord.Member, game_server: int, name: str):
self._logger.debug(__name__, f"Received command register minecraft {ctx}")
minecraft_id = None
try:
self._logger.debug(__name__, f"Try to get minecraft id for {name}")
response = requests.get(
url=f"https://api.mojang.com/users/profiles/minecraft/{name}"
)
response = requests.get(url=f"https://api.mojang.com/users/profiles/minecraft/{name}")
if len(response.content) == 0:
await self._message_service.send_interaction_msg(
ctx.interaction,
@@ -110,7 +106,5 @@ class RegisterGroup(DiscordCommandABC):
return [
app_commands.Choice(name=gs.name, value=gs.id)
for gs in self._client_utils.get_auto_complete_list(
game_servers, current, lambda x: x.name
)
for gs in self._client_utils.get_auto_complete_list(game_servers, current, lambda x: x.name)
]

4
bot/src/modules/base/command/submit_group.py
View File

@@ -11,9 +11,7 @@ from modules.base.forms.complaint_form import ComplaintForm
class SubmitGroup(DiscordCommandABC):
def __init__(
self, services: ServiceProviderABC, logger: LoggerABC, bot: DiscordBotServiceABC
):
def __init__(self, services: ServiceProviderABC, logger: LoggerABC, bot: DiscordBotServiceABC):
DiscordCommandABC.__init__(self)
self._services = services

8
bot/src/modules/base/command/unregister_group.py
View File

@@ -62,9 +62,7 @@ class UnregisterGroup(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.id)
ident = user.game_idents.where(
lambda x: x.game_server.id == game_server
).single()
ident = user.game_idents.where(lambda x: x.game_server.id == game_server).single()
self._user_game_idents.delete_user_game_ident(ident)
self._users.update_user(user)
self._db.save_changes()
@@ -84,7 +82,5 @@ class UnregisterGroup(DiscordCommandABC):
return [
app_commands.Choice(name=gs.name, value=gs.id)
for gs in self._client_utils.get_auto_complete_list(
game_servers, current, lambda x: x.name
)
for gs in self._client_utils.get_auto_complete_list(game_servers, current, lambda x: x.name)
]

156
bot/src/modules/base/command/user_group.py
View File

@@ -111,9 +111,7 @@ class UserGroup(DiscordCommandABC):
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()
@@ -131,9 +129,7 @@ class UserGroup(DiscordCommandABC):
)
date = datetime.date(year, month, day)
server = self._servers.get_server_by_discord_id(ctx.guild.id)
user = self._users.get_user_by_discord_id_and_server_id(
ctx.author.id, server.id
)
user = self._users.get_user_by_discord_id_and_server_id(ctx.author.id, server.id)
user.birthday = date
self._users.update_user(user)
self._db.save_changes()
@@ -141,15 +137,11 @@ class UserGroup(DiscordCommandABC):
ctx.interaction, self._t.transform("modules.base.user.birthday.success")
)
# notify team to prevent multiple entries every day
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
channel = ctx.guild.get_channel(settings.team_channel_id)
await self._message_service.send_channel_message(
channel,
self._t.transform("modules.base.user.birthday.success_team").format(
ctx.author.mention, date
),
self._t.transform("modules.base.user.birthday.success_team").format(ctx.author.mention, date),
is_persistent=True,
)
self._logger.trace(__name__, f"Finished user-info command")
@@ -188,18 +180,12 @@ 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):
@@ -209,16 +195,10 @@ class UserGroup(DiscordCommandABC):
user = self._users.find_user_by_discord_id_and_server_id(member.id, server.id)
joins = self._user_joined_servers.get_user_joined_servers_by_user_id(user.id)
embed = discord.Embed(
title=member.name, description=member.name, color=int("ef9d0d", 16)
)
embed = discord.Embed(title=member.name, description=member.name, color=int("ef9d0d", 16))
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.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),
@@ -229,9 +209,7 @@ class UserGroup(DiscordCommandABC):
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.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)),
@@ -281,9 +259,7 @@ class UserGroup(DiscordCommandABC):
)
# send to interaction because of sensitive data
await self._message_service.send_interaction_msg(
ctx.interaction, embed, wait_before_delete=wait
)
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()
@@ -294,9 +270,7 @@ class UserGroup(DiscordCommandABC):
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):
@@ -320,26 +294,18 @@ class UserGroup(DiscordCommandABC):
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
) -> TList[app_commands.Choice[str]]:
return [
app_commands.Choice(name=value, value=key) for key, value in self._atr_TList
]
async def get_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
return [app_commands.Choice(name=value, value=key) for key, value in self._atr_TList]
@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
):
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):
@@ -352,9 +318,7 @@ class UserGroup(DiscordCommandABC):
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"),
@@ -374,15 +338,11 @@ class UserGroup(DiscordCommandABC):
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
) -> TList[app_commands.Choice[str]]:
async def set_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
atr_TList = [("xp", self._atr_dict["xp"])]
return [app_commands.Choice(name=value, value=key) for key, value in atr_TList]
@@ -390,18 +350,12 @@ class UserGroup(DiscordCommandABC):
@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
) -> TList[app_commands.Choice[str]]:
async def set_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
atr_TList = [("xp", self._atr_dict["xp"])]
return [app_commands.Choice(name=value, value=key) for key, value in atr_TList]
@@ -409,18 +363,12 @@ class UserGroup(DiscordCommandABC):
@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
) -> TList[app_commands.Choice[str]]:
async def set_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
atr_TList = [("xp", self._atr_dict["xp"])]
return [app_commands.Choice(name=value, value=key) for key, value in atr_TList]
@@ -429,9 +377,7 @@ 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
@@ -446,9 +392,7 @@ class UserGroup(DiscordCommandABC):
await self._level.check_level(member)
elif atr == "ontime":
self._user_joined_voice_channel.delete_user_joined_voice_channel_by_user_id(
user.id
)
self._user_joined_voice_channel.delete_user_joined_voice_channel_by_user_id(user.id)
self._db.save_changes()
else:
@@ -460,18 +404,14 @@ class UserGroup(DiscordCommandABC):
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
) -> TList[app_commands.Choice[str]]:
return [
app_commands.Choice(name=value, value=key) for key, value in self._atr_TList
]
return [app_commands.Choice(name=value, value=key) for key, value in self._atr_TList]
@user.group()
@commands.guild_only()
@@ -483,9 +423,7 @@ class UserGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def show(self, ctx: Context, member: discord.Member, wait: int = None):
self._logger.debug(
__name__, f"Received command user warning show {ctx}:{member}"
)
self._logger.debug(__name__, f"Received command user warning show {ctx}:{member}")
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.id)
@@ -515,9 +453,7 @@ class UserGroup(DiscordCommandABC):
value=warnings_description_string,
inline=True,
)
await self._message_service.send_interaction_msg(
ctx.interaction, embed, wait_before_delete=wait
)
await self._message_service.send_interaction_msg(ctx.interaction, embed, wait_before_delete=wait)
self._logger.trace(__name__, f"Finished user warning show command")
@warning.command()
@@ -525,21 +461,13 @@ class UserGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def add(self, ctx: Context, member: discord.Member, description: str):
self._logger.debug(
__name__, f"Received command user warning add {ctx}:{member},{description}"
)
self._logger.debug(__name__, f"Received command user warning add {ctx}:{member},{description}")
try:
await self._user_warnings_service.add_warnings_async(
member, description, ctx.author.id
)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.warnings.add.success")
)
await self._user_warnings_service.add_warnings_async(member, description, ctx.author.id)
await self._message_service.send_ctx_msg(ctx, self._t.transform("modules.base.warnings.add.success"))
except Exception as e:
self._logger.error(__name__, f"Adding user warning failed", e)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.warnings.add.failed")
)
await self._message_service.send_ctx_msg(ctx, self._t.transform("modules.base.warnings.add.failed"))
self._logger.trace(__name__, f"Finished user warning add command")
@warning.command()
@@ -547,17 +475,11 @@ class UserGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def remove(self, ctx: Context, warning_id: int):
self._logger.debug(
__name__, f"Received command user warning remove {ctx}:{warning_id}"
)
self._logger.debug(__name__, f"Received command user warning remove {ctx}:{warning_id}")
try:
await self._user_warnings_service.remove_warnings_async(warning_id)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.warnings.remove.success")
)
await self._message_service.send_ctx_msg(ctx, self._t.transform("modules.base.warnings.remove.success"))
except Exception as e:
self._logger.error(__name__, f"Removing user warning failed", e)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.base.warnings.remove.failed")
)
await self._message_service.send_ctx_msg(ctx, self._t.transform("modules.base.warnings.remove.failed"))
self._logger.trace(__name__, f"Finished user warning remove command")

16
bot/src/modules/base/events/base_on_command_error_event.py
View File

@@ -167,9 +167,7 @@ class BaseOnCommandErrorEvent(OnCommandErrorABC):
)
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(
@@ -261,19 +259,13 @@ class BaseOnCommandErrorEvent(OnCommandErrorABC):
self._t.transform("common.errors.command_error"),
without_tracking=True,
)
message = self._t.transform(
"modules.base.technician_command_error_message"
).format(
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
),
datetime.datetime.now().strftime(self._time_format_settings.date_time_format),
uid,
)
for t in self._tech_settings.technician_ids:
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)

20
bot/src/modules/base/events/base_on_command_event.py
View File

@@ -49,9 +49,7 @@ 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
@@ -63,9 +61,7 @@ class BaseOnCommandEvent(OnCommandABC):
user: Optional[User] = None
try:
user = self._users.get_user_by_discord_id_and_server_id(
dc_user_id, server.id
)
user = self._users.get_user_by_discord_id_and_server_id(dc_user_id, server.id)
except Exception as e:
self._logger.error(__name__, f"Cannot get user {dc_user_id}", e)
return
@@ -74,23 +70,17 @@ class BaseOnCommandEvent(OnCommandABC):
self._logger.error(__name__, f"User not found {dc_user_id}")
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{message.guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{message.guild.id}")
old_xp = user.xp
user.xp += settings.xp_per_message
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.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)

28
bot/src/modules/base/events/base_on_member_join_event.py
View File

@@ -66,9 +66,7 @@ class BaseOnMemberJoinEvent(OnMemberJoinABC):
except Exception as 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]
):
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}")
await self._messenger.send_dm_message(
self._t.transform("modules.base.welcome_message").format(member.guild.name),
@@ -77,40 +75,28 @@ class BaseOnMemberJoinEvent(OnMemberJoinABC):
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.id
)
user = self._users.find_user_by_discord_id_and_server_id(member.id, 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._users.add_user(User(member.id, 0, 0, 0, server))
self._db.save_changes()
user = self._users.get_user_by_discord_id_and_server_id(
member.id, 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.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)
async def _notify_team(self, member: discord.Member):
self._logger.debug(__name__, f"Notify team that a member left")
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{member.guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{member.guild.id}")
channel = member.guild.get_channel(settings.team_channel_id)
await self._messenger.send_channel_message(
channel,
self._t.transform("modules.base.welcome_message_for_team").format(
member.mention
),
self._t.transform("modules.base.welcome_message_for_team").format(member.mention),
is_persistent=True,
)
self._logger.trace(__name__, f"Notified team that a member left")

16
bot/src/modules/base/events/base_on_member_remove_event.py
View File

@@ -41,16 +41,12 @@ class BaseOnMemberRemoveEvent(OnMemberRemoveABC):
async def _remove_user(self, member: Union[discord.User, discord.Member]):
self._logger.debug(__name__, f"Remove user {member}")
await self._message_service.send_dm_message(
self._t.transform("modules.base.goodbye_message"), member
)
await self._message_service.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.id
)
user = self._users.find_user_by_discord_id_and_server_id(member.id, server.id)
if user is None:
self._logger.error(__name__, f"Cannot find user {member}")
return
@@ -64,15 +60,11 @@ class BaseOnMemberRemoveEvent(OnMemberRemoveABC):
async def _notify_team(self, member: discord.Member):
self._logger.debug(__name__, f"Notify team that a member left")
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{member.guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{member.guild.id}")
channel = member.guild.get_channel(settings.team_channel_id)
await self._message_service.send_channel_message(
channel,
self._t.transform("modules.base.member_left_message").format(
member.mention
),
self._t.transform("modules.base.member_left_message").format(member.mention),
is_persistent=True,
)
self._logger.trace(__name__, f"Notified team that a member left")

16
bot/src/modules/base/events/base_on_message_delete_event.py
View File

@@ -40,9 +40,7 @@ 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
@@ -54,9 +52,7 @@ class BaseOnMessageDeleteEvent(OnMessageDeleteABC):
user: Optional[User] = None
try:
user = self._users.find_user_by_discord_id_and_server_id(
dc_user_id, server.id
)
user = self._users.find_user_by_discord_id_and_server_id(dc_user_id, server.id)
except Exception as e:
self._logger.error(__name__, f"Cannot get user {dc_user_id}", e)
return
@@ -65,9 +61,7 @@ class BaseOnMessageDeleteEvent(OnMessageDeleteABC):
self._logger.error(__name__, f"User not found {dc_user_id}")
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{message.guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{message.guild.id}")
old_xp = user.xp
user.xp -= settings.xp_per_message
self._users.update_user(user)
@@ -83,9 +77,7 @@ class BaseOnMessageDeleteEvent(OnMessageDeleteABC):
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:

20
bot/src/modules/base/events/base_on_message_event.py
View File

@@ -45,9 +45,7 @@ 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
@@ -59,9 +57,7 @@ class BaseOnMessageEvent(OnMessageABC):
user: Optional[User] = None
try:
user = self._users.find_user_by_discord_id_and_server_id(
dc_user_id, server.id
)
user = self._users.find_user_by_discord_id_and_server_id(dc_user_id, server.id)
except Exception as e:
self._logger.error(__name__, f"Cannot get user {dc_user_id}", e)
return
@@ -70,9 +66,7 @@ class BaseOnMessageEvent(OnMessageABC):
self._logger.error(__name__, f"User not found {dc_user_id}")
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{server.discord_id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{server.discord_id}")
if self._client_utils.is_message_xp_count_by_hour_higher_that_max_message_count_per_hour(
message.created_at, user, settings
):
@@ -83,9 +77,7 @@ 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):
@@ -93,9 +85,7 @@ class BaseOnMessageEvent(OnMessageABC):
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:

7
bot/src/modules/base/events/base_on_scheduled_event_update_event.py
View File

@@ -21,9 +21,7 @@ class BaseOnScheduledEventUpdateEvent(OnScheduledEventUpdateABC):
self._bot = bot
self._events = events
async def on_scheduled_event_update(
self, before: discord.ScheduledEvent, after: discord.ScheduledEvent
):
async def on_scheduled_event_update(self, before: discord.ScheduledEvent, after: discord.ScheduledEvent):
self._logger.debug(__name__, f"Module {type(self)} started")
# save started event
@@ -35,8 +33,7 @@ class BaseOnScheduledEventUpdateEvent(OnScheduledEventUpdateABC):
self._events.give_xp_for_event_participation(member, active_event)
# delete stopped event
if before.status != after.status and (
after.status.value == EventStatus.cancelled.value
or after.status.value == EventStatus.completed.value
after.status.value == EventStatus.cancelled.value or after.status.value == EventStatus.completed.value
):
event = self._events.get_active_event(after)
if event is None:

54
bot/src/modules/base/events/base_on_voice_state_update_event.py
View File

@@ -45,14 +45,10 @@ class BaseOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
self._logger.info(__name__, f"Module {type(self)} loaded")
def _update_voice_state(
self, joined: bool, dc_user_id: int, channel_id: int, server: Server
):
def _update_voice_state(self, joined: bool, dc_user_id: int, 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.id
)
user = self._users.get_user_by_discord_id_and_server_id(dc_user_id, server.id)
except Exception as e:
self._logger.error(__name__, f"Cannot get user {dc_user_id}", e)
return
@@ -68,13 +64,9 @@ class BaseOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
self._db.save_changes()
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{server.discord_id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{server.discord_id}")
join = self._user_joins_vc.get_active_user_joined_voice_channel_by_user_id(
user.id
)
join = self._user_joins_vc.get_active_user_joined_voice_channel_by_user_id(user.id)
join.leaved_on = datetime.now()
old_xp = user.xp
@@ -103,9 +95,7 @@ class BaseOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
__name__,
f"Detected on_voice_state_update {member.id} from {before} to {after}",
)
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{member.guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{member.guild.id}")
server = self._servers.get_server_by_discord_id(member.guild.id)
try:
@@ -133,36 +123,18 @@ class BaseOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
# 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)

12
bot/src/modules/base/events/base_on_voice_state_update_event_help_channel.py
View File

@@ -33,15 +33,11 @@ class BaseOnVoiceStateUpdateEventHelpChannel(OnVoiceStateUpdateABC):
async def _notify_team(self, member: discord.Member):
self._logger.debug(__name__, f"Notify team that a member needs help")
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{member.guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{member.guild.id}")
channel = member.guild.get_channel(settings.team_channel_id)
await self._message_service.send_channel_message(
channel,
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),
is_persistent=True,
)
self._logger.trace(__name__, f"Notified team that a member need help")
@@ -55,9 +51,7 @@ class BaseOnVoiceStateUpdateEventHelpChannel(OnVoiceStateUpdateABC):
):
self._logger.debug(__name__, f"Module {type(self)} started")
server = self._servers.get_server_by_discord_id(member.guild.id)
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{server.discord_id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{server.discord_id}")
if after.channel is None or after.channel.id != settings.help_voice_channel_id:
return

12
bot/src/modules/base/forms/bug_report_form.py
View File

@@ -10,9 +10,7 @@ from bot_data.model.technician_config import TechnicianConfig
class BugReportForm(ui.Modal):
description = ui.TextInput(
label="Report a bug", required=True, style=TextStyle.long
)
description = ui.TextInput(label="Report a bug", required=True, style=TextStyle.long)
def __init__(
self,
@@ -40,14 +38,10 @@ class BugReportForm(ui.Modal):
for t in self._technician_config.technician_ids:
member = self._bot.get_user(t)
await self._message_service.send_dm_message(
self._t.transform("modules.base.bug.message").format(
interaction.user.mention, self.description.value
),
self._t.transform("modules.base.bug.message").format(interaction.user.mention, self.description.value),
member,
without_tracking=True,
)
await self._message_service.send_interaction_msg(
interaction, self._t.transform("modules.base.bug.response")
)
await self._message_service.send_interaction_msg(interaction, self._t.transform("modules.base.bug.response"))
self._logger.trace(__name__, f"Finished bug report form")

8
bot/src/modules/base/forms/complaint_form.py
View File

@@ -10,9 +10,7 @@ from bot_data.model.server_config import ServerConfig
class ComplaintForm(ui.Modal):
description = ui.TextInput(
label="Complain about something", required=True, style=TextStyle.long
)
description = ui.TextInput(label="Complain about something", required=True, style=TextStyle.long)
def __init__(
self,
@@ -34,9 +32,7 @@ class ComplaintForm(ui.Modal):
async def on_submit(self, interaction: discord.Interaction):
self._logger.debug(__name__, f"Started complaint command form")
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{interaction.guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{interaction.guild.id}")
channel = interaction.guild.get_channel(settings.team_channel_id)
await self._message_service.send_channel_message(
channel,

16
bot/src/modules/base/helper/base_reaction_handler.py
View File

@@ -38,9 +38,7 @@ class BaseReactionHandler:
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:
@@ -62,12 +60,8 @@ class BaseReactionHandler:
self._logger.debug(__name__, f"Skipping reaction handling")
return
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)
@@ -76,9 +70,7 @@ class BaseReactionHandler:
server = self._servers.get_server_by_discord_id(guild.id)
user = self._users.get_user_by_discord_id_and_server_id(member.id, server.id)
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{guild.id}")
if r_type == "add":
if self._client_utils.is_message_xp_count_by_hour_higher_that_max_message_count_per_hour(

20
bot/src/modules/base/helper/voice_channel_transformer.py
View File

@@ -8,9 +8,7 @@ from bot_core.abc.client_utils_abc import ClientUtilsABC
class VoiceChannelTransformer(Transformer):
async def transform(
self, interaction: Interaction, value: str, /
) -> discord.VoiceChannel:
async def transform(self, interaction: Interaction, value: str, /) -> discord.VoiceChannel:
voice_channel = (
List(discord.VoiceChannel, interaction.guild.voice_channels)
.where(lambda x: str(x.id) == value)
@@ -18,24 +16,16 @@ class VoiceChannelTransformer(Transformer):
)
return voice_channel
async def autocomplete(
self, interaction: Interaction, current: str, /
) -> list[Choice[str]]:
async def autocomplete(self, interaction: Interaction, current: str, /) -> list[Choice[str]]:
@ServiceProviderABC.inject
def get_client_utils(client_utils: ClientUtilsABC) -> ClientUtilsABC:
return client_utils
voice_channels = List(discord.Role, interaction.guild.voice_channels).where(
lambda x: len(x.members) > 0
)
voice_channels = List(discord.Role, interaction.guild.voice_channels).where(lambda x: len(x.members) > 0)
return [
app_commands.Choice(
name=f"{vc.name}"
if vc.category is None
else f"{vc.name}: {vc.category.name}",
name=f"{vc.name}" if vc.category is None else f"{vc.name}: {vc.category.name}",
value=vc.name,
)
for vc in get_client_utils().get_auto_complete_list(
voice_channels, current, lambda x: x.name
)
for vc in get_client_utils().get_auto_complete_list(voice_channels, current, lambda x: x.name)
]

12
bot/src/modules/base/service/event_service.py
View File

@@ -36,9 +36,7 @@ class EventService:
self._active_events.add(event)
def get_active_event(self, event: discord.ScheduledEvent) -> Optional[ActiveEvent]:
return self._active_events.where(
lambda x: x.event.id == event.id
).single_or_default()
return self._active_events.where(lambda x: x.event.id == event.id).single_or_default()
def get_active_event_by_channel_id(self, channel_id: int) -> Optional[ActiveEvent]:
return self._active_events.where(
@@ -51,18 +49,14 @@ class EventService:
self._active_events.remove(event)
def give_xp_for_event_participation(
self, member: discord.Member, active_event: ActiveEvent
):
def give_xp_for_event_participation(self, member: discord.Member, active_event: ActiveEvent):
server = self._servers.get_server_by_discord_id(member.guild.id)
user = self._users.get_user_by_discord_id_and_server_id(member.id, server.id)
if active_event.participants.any(lambda x: x.id == user.id):
self._logger.debug(__name__, f"Module {type(self)} stopped")
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{server.discord_id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{server.discord_id}")
user.xp += settings.xp_per_event_participation
self._users.update_user(user)
self._db.save_changes()

92
bot/src/modules/base/service/user_warnings_service.py
View File

@@ -46,92 +46,60 @@ class UserWarningsService:
self._t = t
self._permissions = permissions
async def notify_team(
self, member: discord.Member, description: str, removed=False
):
async def notify_team(self, member: discord.Member, description: str, removed=False):
try:
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{member.guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{member.guild.id}")
channel = member.guild.get_channel(settings.team_channel_id)
if removed:
translation = self._t.transform(
"modules.base.warnings.team_removed"
).format(description, member.mention)
translation = self._t.transform("modules.base.warnings.team_removed").format(
description, member.mention
)
else:
translation = self._t.transform(
"modules.base.warnings.team_warned"
).format(member.mention, description)
translation = self._t.transform("modules.base.warnings.team_warned").format(member.mention, description)
self._bot.loop.create_task(
self._message_service.send_channel_message(
channel, translation, is_persistent=True
)
self._message_service.send_channel_message(channel, translation, is_persistent=True)
)
except Exception as e:
self._logger.error(
__name__, f"Team notification for user warning failed!", e
)
self._logger.error(__name__, f"Team notification for user warning failed!", e)
async def notify_user(self, member: discord.Member, message: str):
try:
# run as task to keep the interaction alive
self._bot.loop.create_task(
self._message_service.send_dm_message(message, member)
)
self._bot.loop.create_task(self._message_service.send_dm_message(message, member))
except Exception as e:
self._logger.error(
__name__, f"User notification for user warning failed!", e
)
self._logger.error(__name__, f"User notification for user warning failed!", e)
async def check_for_warnings(self, member: discord.Member, user: User):
existing_warnings = self._warnings.get_user_warnings_by_user_id(user.id)
if existing_warnings.count() == 1:
await self.notify_user(
member, self._t.transform("modules.base.warnings.first")
)
await self.notify_user(member, self._t.transform("modules.base.warnings.first"))
elif existing_warnings.count() == 2:
server = self._servers.get_server_by_discord_id(member.guild.id)
user = self._users.get_user_by_discord_id_and_server_id(
member.id, server.id
)
user = self._users.get_user_by_discord_id_and_server_id(member.id, server.id)
level = self._level_service.get_level(user)
levels = self._levels.get_levels_by_server_id(server.id).order_by(
lambda l: l.min_xp
)
levels = self._levels.get_levels_by_server_id(server.id).order_by(lambda l: l.min_xp)
new_level = levels.where(
lambda l: l.min_xp < level.min_xp
).last_or_default()
new_level = levels.where(lambda l: l.min_xp < level.min_xp).last_or_default()
if new_level is not None:
user.xp = new_level.min_xp
self._users.update_user(user)
self._db.save_changes()
await self.notify_user(
member, self._t.transform("modules.base.warnings.second")
)
await self.notify_user(member, self._t.transform("modules.base.warnings.second"))
elif existing_warnings.count() == 3:
server = self._servers.get_server_by_discord_id(member.guild.id)
user = self._users.get_user_by_discord_id_and_server_id(
member.id, server.id
)
user = self._users.get_user_by_discord_id_and_server_id(member.id, server.id)
levels = self._levels.get_levels_by_server_id(server.id)
new_level = (
levels.where(lambda l: l.min_xp > 0)
.order_by(lambda l: l.min_xp)
.last_or_default()
)
new_level = levels.where(lambda l: l.min_xp > 0).order_by(lambda l: l.min_xp).last_or_default()
if new_level is not None:
user.xp = new_level.min_xp
self._users.update_user(user)
self._db.save_changes()
await self.notify_user(
member, self._t.transform("modules.base.warnings.third")
)
await self.notify_user(member, self._t.transform("modules.base.warnings.third"))
elif existing_warnings.count() >= 4:
user.xp = 0
@@ -149,39 +117,29 @@ class UserWarningsService:
await self.notify_user(
member,
self._t.transform("modules.base.warnings.warned").format(
warning.description
),
self._t.transform("modules.base.warnings.warned").format(warning.description),
)
await self.notify_team(member, warning.description)
await self.check_for_warnings(member, user)
def _add_warnings(
self, member: discord.Member, description: str, author_id: int = None
):
def _add_warnings(self, member: discord.Member, description: str, author_id: int = None):
server = self._servers.get_server_by_discord_id(member.guild.id)
user = self._users.get_user_by_discord_id_and_server_id(member.id, server.id)
author = None
if author_id is not None:
author = self._users.get_user_by_discord_id_and_server_id(
author_id, server.id
)
author = self._users.get_user_by_discord_id_and_server_id(author_id, server.id)
warning = UserWarnings(description, user, author)
self._warnings.add_user_warnings(warning)
self._db.save_changes()
return warning
def add_warnings(
self, member: discord.Member, description: str, author_id: int = None
):
def add_warnings(self, member: discord.Member, description: str, author_id: int = None):
warning = self._add_warnings(member, description, author_id)
self._bot.loop.create_task(self._notify_after_add(member, warning))
async def add_warnings_async(
self, member: discord.Member, description: str, author_id: int = None
):
async def add_warnings_async(self, member: discord.Member, description: str, author_id: int = None):
warning = self._add_warnings(member, description, author_id)
await self._notify_after_add(member, warning)
@@ -190,9 +148,7 @@ class UserWarningsService:
member = guild.get_member(warning.user.discord_id)
await self.notify_user(
member,
self._t.transform("modules.base.warnings.removed").format(
warning.description
),
self._t.transform("modules.base.warnings.removed").format(warning.description),
)
await self.notify_team(member, warning.description, removed=True)

4
bot/src/modules/boot_log/boot_log_extension.py
View File

@@ -14,9 +14,7 @@ class BootLogExtension(ApplicationExtensionABC):
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)

12
bot/src/modules/boot_log/boot_log_module.py
View File

@@ -13,16 +13,10 @@ 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
services.add_transient(
DiscordEventTypesEnum.on_ready.value, BootLogOnReadyEvent
)
services.add_transient(DiscordEventTypesEnum.on_ready.value, BootLogOnReadyEvent)

17
bot/src/modules/boot_log/boot_log_on_ready_event.py
View File

@@ -45,10 +45,7 @@ class BootLogOnReadyEvent(OnReadyABC):
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(),
(datetime.now() - datetime.strptime(start_time, "%Y-%m-%d %H:%M:%S.%f")).total_seconds(),
2,
)
self._config.add_configuration("InitTime", str(init_time))
@@ -59,9 +56,7 @@ class BootLogOnReadyEvent(OnReadyABC):
# 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!!!"
)
self._logger.error(__name__, "It takes far too long to start the bot!!!")
except Exception as e:
self._logger.error(__name__, "Init time calculation failed", e)
return
@@ -70,9 +65,7 @@ class BootLogOnReadyEvent(OnReadyABC):
g: guild = g
self._logger.debug(__name__, f"Server detected: {g.id}")
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{g.id}"
)
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{g.id}")
if server_config is None:
self._logger.error(__name__, f"Config ServerConfig_{g.id} not found!")
return
@@ -85,9 +78,7 @@ class BootLogOnReadyEvent(OnReadyABC):
self._bot.loop.create_task(
self._message_service.send_channel_message(
self._bot.get_channel(server_config.login_message_channel_id),
self._t.transform("modules.boot_log.login_message").format(
init_time
),
self._t.transform("modules.boot_log.login_message").format(init_time),
)
)

4
bot/src/modules/config/config_extension.py
View File

@@ -13,9 +13,7 @@ class ConfigExtension(ApplicationExtensionABC):
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.config_module):
return
logger: LoggerABC = services.get_service(LoggerABC)

8
bot/src/modules/config/config_module.py
View File

@@ -13,12 +13,8 @@ class ConfigModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.config_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(DiscordEventTypesEnum.on_ready.value, ConfigOnReadyEvent)

4
bot/src/modules/config/events/config_on_ready_event.py
View File

@@ -26,6 +26,4 @@ class ConfigOnReadyEvent(OnReadyABC):
async def on_ready(self):
for guild in self._bot.guilds:
await self._config_service.reload_server_config(
self._servers.get_server_by_discord_id(guild.id)
)
await self._config_service.reload_server_config(self._servers.get_server_by_discord_id(guild.id))

4
bot/src/modules/database/database_extension.py
View File

@@ -17,9 +17,7 @@ class DatabaseExtension(ApplicationExtensionABC):
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)

12
bot/src/modules/database/database_module.py
View File

@@ -13,16 +13,10 @@ 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
services.add_transient(
DiscordEventTypesEnum.on_ready.value, DatabaseOnReadyEvent
)
services.add_transient(DiscordEventTypesEnum.on_ready.value, DatabaseOnReadyEvent)

13
bot/src/modules/database/database_on_ready_event.py
View File

@@ -29,25 +29,18 @@ class DatabaseOnReadyEvent(OnReadyABC):
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(),
(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!"
)
self._logger.warn(__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!!!"
)
self._logger.error(__name__, "It takes far too long to prepare the database!!!")
except Exception as e: #
self._logger.error(__name__, "Database init time calculation failed", e)
return

185
bot/src/modules/level/command/level_group.py
View File

@@ -108,17 +108,13 @@ class LevelGroup(DiscordCommandABC):
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")
)
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]]:
server = self._servers.get_server_by_discord_id(interaction.guild.id)
levels = self._levels.get_levels_by_server_id(server.id).select(
lambda l: l.name
)
levels = self._levels.get_levels_by_server_id(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)
@@ -138,20 +134,14 @@ class LevelGroup(DiscordCommandABC):
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
server = self._servers.get_server_by_discord_id(ctx.guild.id)
levels = self._levels.get_levels_by_server_id(server.id)
if levels.count() < 1:
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.level.error.nothing_found")
)
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
@@ -173,9 +163,7 @@ class LevelGroup(DiscordCommandABC):
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.min_xp"), value=xp, inline=True)
embed.add_field(
name=self._t.transform("modules.level.list.permission_int"),
value=permissions,
@@ -188,19 +176,13 @@ class LevelGroup(DiscordCommandABC):
@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
):
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}")
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
try:
@@ -226,26 +208,19 @@ class LevelGroup(DiscordCommandABC):
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
):
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()
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),
self._t.transform("modules.level.error.level_with_xp_already_exists").format(
found_level.name, found_level.min_xp
),
)
else:
try:
@@ -264,9 +239,7 @@ class LevelGroup(DiscordCommandABC):
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)
@@ -303,19 +276,13 @@ class LevelGroup(DiscordCommandABC):
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
server = self._servers.get_server_by_discord_id(ctx.guild.id)
level_from_db = (
self._levels.get_levels_by_server_id(server.id)
.where(lambda l: l.name == level)
.single_or_default()
self._levels.get_levels_by_server_id(server.id).where(lambda l: l.name == level).single_or_default()
)
if level_from_db is None:
await self._message_service.send_ctx_msg(
@@ -349,13 +316,9 @@ class LevelGroup(DiscordCommandABC):
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
self._t.transform("modules.level.edit.permission_invalid").format(permissions),
)
self._logger.error(__name__, f"Error parsing permissions {permissions}", e)
return
try:
@@ -377,9 +340,7 @@ class LevelGroup(DiscordCommandABC):
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")
@@ -413,19 +374,13 @@ class LevelGroup(DiscordCommandABC):
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
server = self._servers.get_server_by_discord_id(ctx.guild.id)
level_from_db = (
self._levels.get_levels_by_server_id(server.id)
.where(lambda l: l.name == level)
.first_or_default()
self._levels.get_levels_by_server_id(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")
@@ -440,9 +395,7 @@ class LevelGroup(DiscordCommandABC):
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}")
@@ -471,12 +424,8 @@ class LevelGroup(DiscordCommandABC):
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
if member.bot:
@@ -485,16 +434,12 @@ 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.id)
level = self._level_service.get_level(user)
levels = self._levels.get_levels_by_server_id(server.id).order_by(
lambda l: l.min_xp
)
levels = self._levels.get_levels_by_server_id(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
),
self._t.transform("modules.level.down.already_first").format(member.mention),
)
self._logger.trace(__name__, f"Finished command level down")
return
@@ -506,15 +451,11 @@ class LevelGroup(DiscordCommandABC):
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
),
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
)
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),
@@ -531,12 +472,8 @@ class LevelGroup(DiscordCommandABC):
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
if member.bot:
@@ -545,16 +482,12 @@ 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.id)
level = self._level_service.get_level(user)
levels = self._levels.get_levels_by_server_id(server.id).order_by(
lambda l: l.min_xp
)
levels = self._levels.get_levels_by_server_id(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")
return
@@ -566,15 +499,11 @@ class LevelGroup(DiscordCommandABC):
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
),
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
)
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)
)
@@ -590,12 +519,8 @@ class LevelGroup(DiscordCommandABC):
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
if member.bot:
@@ -604,11 +529,7 @@ 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.id)
current_level = self._level_service.get_level(user)
new_level = (
self._levels.get_levels_by_server_id(server.id)
.where(lambda l: l.name == level)
.single_or_default()
)
new_level = self._levels.get_levels_by_server_id(server.id).where(lambda l: l.name == level).single_or_default()
if new_level is None:
await self._message_service.send_ctx_msg(
@@ -620,9 +541,7 @@ class LevelGroup(DiscordCommandABC):
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._t.transform("modules.level.set.already_level").format(member.mention, level),
)
self._logger.trace(__name__, f"Finished command level set")
return
@@ -633,15 +552,11 @@ class LevelGroup(DiscordCommandABC):
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
),
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
)
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),
@@ -650,9 +565,7 @@ class LevelGroup(DiscordCommandABC):
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]]:
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()
@@ -664,12 +577,8 @@ class LevelGroup(DiscordCommandABC):
if ctx.guild is None:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
await self._seed_levels(ctx)

12
bot/src/modules/level/events/level_on_member_join_event.py
View File

@@ -11,9 +11,7 @@ from modules.level.service.level_service import LevelService
class LevelOnMemberJoinEvent(OnMemberJoinABC):
def __init__(
self, config: ConfigurationABC, logger: MessageLogger, level: LevelService
):
def __init__(self, config: ConfigurationABC, logger: MessageLogger, level: LevelService):
OnMemberJoinABC.__init__(self)
self._config = config
self._logger = logger
@@ -22,12 +20,8 @@ class LevelOnMemberJoinEvent(OnMemberJoinABC):
@EventChecks.check_is_ready()
async def on_member_join(self, member: discord.Member):
self._logger.debug(__name__, f"Module {type(self)} started")
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{member.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{member.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
await self._level.check_level(member)

12
bot/src/modules/level/events/level_on_message_event.py
View File

@@ -11,9 +11,7 @@ from modules.level.service.level_service import LevelService
class LevelOnMessageEvent(OnMessageABC):
def __init__(
self, config: ConfigurationABC, logger: MessageLogger, level: LevelService
):
def __init__(self, config: ConfigurationABC, logger: MessageLogger, level: LevelService):
OnMessageABC.__init__(self)
self._config = config
self._logger = logger
@@ -28,12 +26,8 @@ class LevelOnMessageEvent(OnMessageABC):
if message.author.bot:
return
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{message.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{message.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
try:

8
bot/src/modules/level/events/level_on_raw_reaction_add_event.py
View File

@@ -29,12 +29,8 @@ class LevelOnRawReactionAddEvent(OnRawReactionAddABC):
@EventChecks.check_is_ready()
async def on_raw_reaction_add(self, payload: RawReactionActionEvent):
self._logger.debug(__name__, f"Module {type(self)} started")
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{payload.guild_id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{payload.guild_id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
try:

8
bot/src/modules/level/events/level_on_raw_reaction_remove_event.py
View File

@@ -29,12 +29,8 @@ class LevelOnRawReactionRemoveEvent(OnRawReactionRemoveABC):
@EventChecks.check_is_ready()
async def on_raw_reaction_remove(self, payload: RawReactionActionEvent):
self._logger.debug(__name__, f"Module {type(self)} started")
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{payload.guild_id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{payload.guild_id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
try:

12
bot/src/modules/level/events/level_on_voice_state_update_event.py
View File

@@ -11,9 +11,7 @@ from modules.level.service.level_service import LevelService
class LevelOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
def __init__(
self, config: ConfigurationABC, logger: LoggerABC, level: LevelService
):
def __init__(self, config: ConfigurationABC, logger: LoggerABC, level: LevelService):
OnVoiceStateUpdateABC.__init__(self)
self._config = config
self._logger = logger
@@ -29,12 +27,8 @@ class LevelOnVoiceStateUpdateEvent(OnVoiceStateUpdateABC):
after: discord.VoiceState,
):
self._logger.debug(__name__, f"Module {type(self)} started")
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{member.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{member.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
return
await self._level.check_level(member)

20
bot/src/modules/level/level_module.py
View File

@@ -29,17 +29,13 @@ 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)
env.set_working_directory(cwd)
def configure_services(
self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
):
def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
services.add_transient(DataSeederABC, LevelSeeder)
services.add_transient(LevelService)
@@ -47,19 +43,13 @@ class LevelModule(ModuleABC):
services.add_transient(LevelGroup)
# events
services.add_transient(
DiscordEventTypesEnum.on_message.value, LevelOnMessageEvent
)
services.add_transient(DiscordEventTypesEnum.on_message.value, LevelOnMessageEvent)
services.add_transient(
DiscordEventTypesEnum.on_voice_state_update.value,
LevelOnVoiceStateUpdateEvent,
)
services.add_transient(
DiscordEventTypesEnum.on_member_join.value, LevelOnMemberJoinEvent
)
services.add_transient(
DiscordEventTypesEnum.on_raw_reaction_add.value, LevelOnRawReactionAddEvent
)
services.add_transient(DiscordEventTypesEnum.on_member_join.value, LevelOnMemberJoinEvent)
services.add_transient(DiscordEventTypesEnum.on_raw_reaction_add.value, LevelOnRawReactionAddEvent)
services.add_transient(
DiscordEventTypesEnum.on_raw_reaction_remove.value,
LevelOnRawReactionRemoveEvent,

41
bot/src/modules/level/level_seeder.py
View File

@@ -46,10 +46,7 @@ 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
):
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)),
@@ -60,11 +57,7 @@ class LevelSeeder(DataSeederABC):
self._logger.debug(__name__, f"Created role {level.name}")
levels = self._levels.find_levels_by_server_id(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._db.save_changes()
@@ -78,21 +71,12 @@ class LevelSeeder(DataSeederABC):
async def seed(self):
# create levels
for guild in self._bot.guilds:
server_config: ServerConfig = self._config.get_configuration(
f"ServerConfig_{guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
server_config.feature_flags, FeatureFlagsEnum.level_module
):
server_config: ServerConfig = self._config.get_configuration(f"ServerConfig_{guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(server_config.feature_flags, FeatureFlagsEnum.level_module):
continue
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)
@@ -118,20 +102,13 @@ class LevelSeeder(DataSeederABC):
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
levels.index_of(levels.where(lambda l: l.name == role.name).single()) + 1
)
if new_position <= 0:
new_position = 1
@@ -142,9 +119,7 @@ class LevelSeeder(DataSeederABC):
)
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)

44
bot/src/modules/level/service/level_service.py
View File

@@ -43,9 +43,7 @@ class LevelService:
if user.xp < 0:
return levels_by_server.order_by(lambda l: l.min_xp).first()
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,12 +51,8 @@ class LevelService:
return levels.last()
async def set_level(self, user: User):
level_names = self._levels.get_levels_by_server_id(user.server.id).select(
lambda l: l.name
)
guild: Guild = self._bot.guilds.where(
lambda g: g.id == user.server.discord_id
).single()
level_names = self._levels.get_levels_by_server_id(user.server.id).select(lambda l: l.name)
guild: Guild = self._bot.guilds.where(lambda g: g.id == user.server.discord_id).single()
member: Member = guild.members.where(lambda m: m.id == user.discord_id).single()
level = self.get_level(user)
@@ -69,39 +63,25 @@ class LevelService:
notification_needed = False
for role in member.roles.where(lambda r: r.name in level_names.to_list()):
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)
notification_needed = True
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}")
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)
if notification_needed:
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{guild.id}")
await self._message_service.send_channel_message(
self._bot.get_channel(settings.notification_chat_id),
self._t.transform("modules.level.new_level_message").format(
member.mention, level.name
),
self._t.transform("modules.level.new_level_message").format(member.mention, level.name),
is_persistent=True,
)
@@ -112,9 +92,7 @@ class LevelService:
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.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)

8
bot/src/modules/permission/permission_module.py
View File

@@ -13,14 +13,10 @@ 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_transient(PermissionServiceABC, PermissionService)
# commands
# events

20
bot/src/modules/permission/service/permission_service.py
View File

@@ -28,22 +28,18 @@ class PermissionService(PermissionServiceABC):
self._server_configs = server_configs
self._technician_configs = technician_configs
def _has_member_role(
self, member: discord.Member, team_member_type: TeamMemberTypeEnum
) -> bool:
def _has_member_role(self, member: discord.Member, team_member_type: TeamMemberTypeEnum) -> bool:
if member is None or member.guild is None:
return False
self._logger.debug(
__name__, f"Checking is member {member.name} {team_member_type.value}"
)
self._logger.debug(__name__, f"Checking is member {member.name} {team_member_type.value}")
try:
server = self._servers.get_server_by_discord_id(member.guild.id)
config = self._server_configs.get_server_config_by_server(server.id)
roles = config.team_role_ids.where(
lambda x: x.team_member_type == team_member_type
).select(lambda x: member.guild.get_role(x.role_id))
roles = config.team_role_ids.where(lambda x: x.team_member_type == team_member_type).select(
lambda x: member.guild.get_role(x.role_id)
)
for role in roles:
if role not in member.roles:
continue
@@ -58,9 +54,9 @@ class PermissionService(PermissionServiceABC):
return self._has_member_role(member, TeamMemberTypeEnum.admin)
def is_member_moderator(self, member: discord.Member) -> bool:
return self._has_member_role(
member, TeamMemberTypeEnum.moderator
) or self._has_member_role(member, TeamMemberTypeEnum.admin)
return self._has_member_role(member, TeamMemberTypeEnum.moderator) or self._has_member_role(
member, TeamMemberTypeEnum.admin
)
def is_member_technician(self, member: discord.Member) -> bool:
if member is None or member.guild is None:

4
bot/src/modules/short_role_name/events/short_role_name_on_member_update_event.py
View File

@@ -9,8 +9,6 @@ class ShortRoleNameOnMemberUpdateEvent(OnMemberUpdateABC):
OnMemberUpdateABC.__init__(self)
self._service = service
async def on_member_update(
self, before: discord.member.Member, after: discord.member.Member
):
async def on_member_update(self, before: discord.member.Member, after: discord.member.Member):
if before.roles != after.roles or before.name != after.name:
await self._service.check_short_role_names(after)

16
bot/src/modules/short_role_name/service/short_role_name_service.py
View File

@@ -32,12 +32,8 @@ class ShortRoleNameService:
async def check_short_role_names(self, member: discord.Member):
self._logger.debug(__name__, f"Started short role name check for {member.id}")
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{member.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
settings.feature_flags, FeatureFlagsEnum.short_role_name
):
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{member.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(settings.feature_flags, FeatureFlagsEnum.short_role_name):
self._logger.debug(__name__, f"Feature not active")
return
@@ -49,16 +45,12 @@ class ShortRoleNameService:
new_nick = member.nick if member.nick is not None else member.name
member_roles = List(discord.Role, member.roles)
highest_role: Optional[discord.Role] = (
member_roles.last_or_default()
if settings.short_role_name_only_set_highest_role
else None
member_roles.last_or_default() if settings.short_role_name_only_set_highest_role else None
)
member_role_ids = member_roles.select(lambda x: x.id)
server = self._server.get_server_by_discord_id(member.guild.id)
for short_role_name in self._short_role_names.get_short_role_names_by_server_id(
server.id
):
for short_role_name in self._short_role_names.get_short_role_names_by_server_id(server.id):
short_role_name: ShortRoleName = short_role_name
new_nick = new_nick.replace(f" [{short_role_name.short_name}]", "")

16
bot/src/modules/short_role_name/short_role_name_check_command.py
View File

@@ -47,22 +47,14 @@ class ShortRoleNameCheckCommand(DiscordCommandABC):
if ctx.guild is None:
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
settings.feature_flags, FeatureFlagsEnum.short_role_name
):
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.feature_not_activated")
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(settings.feature_flags, FeatureFlagsEnum.short_role_name):
await self._message_service.send_ctx_msg(ctx, self._t.transform("common.feature_not_activated"))
return
for member in ctx.guild.members:
await self._service.check_short_role_names(member)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.short_role_name.checked_message")
)
await self._message_service.send_ctx_msg(ctx, self._t.transform("modules.short_role_name.checked_message"))
self._logger.trace(__name__, f"Finished purge command")

8
bot/src/modules/short_role_name/short_role_name_module.py
View File

@@ -21,14 +21,10 @@ class ShortRoleNameModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.short_role_name_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(DataSeederABC, ShortRoleNameSeeder)
services.add_transient(ShortRoleNameService)

8
bot/src/modules/special_offers/special_offers_module.py
View File

@@ -13,14 +13,10 @@ class SteamSpecialOffersModule(ModuleABC):
def __init__(self, dc: DiscordCollectionABC):
ModuleABC.__init__(self, dc, FeatureFlagsEnum.steam_special_offers_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(TaskABC, SteamOfferWatcher)
# commands
# events

40
bot/src/modules/special_offers/steam_offer_watcher.py
View File

@@ -53,9 +53,7 @@ class SteamOfferWatcher(TaskABC):
@staticmethod
def _get_max_count() -> int:
count = 0
result = requests.get(
f"https://store.steampowered.com/search/results?specials=1"
)
result = requests.get(f"https://store.steampowered.com/search/results?specials=1")
soup = bs4.BeautifulSoup(result.text, "lxml")
element = soup.find_all("div", {"class": "search_results_count"})
if len(element) < 1:
@@ -77,13 +75,9 @@ class SteamOfferWatcher(TaskABC):
for element in elements:
name_element = element.find("span", {"class": "title"})
original_price_element = element.find(
"div", {"class": "discount_original_price"}
)
original_price_element = element.find("div", {"class": "discount_original_price"})
discount_element = element.find("div", {"class": "discount_pct"})
discount_price_element = element.find(
"div", {"class": "discount_final_price"}
)
discount_price_element = element.find("div", {"class": "discount_final_price"})
if (
name_element is None
@@ -99,25 +93,15 @@ class SteamOfferWatcher(TaskABC):
name = name_element.contents[0].replace("'", "`").replace('"', "`")
original_price = float(
original_price_element.contents[0]
.replace(" ", "")
.replace("€", "")
.replace(",", ".")
original_price_element.contents[0].replace(" ", "").replace("€", "").replace(",", ".")
)
discount = int(discount_element.contents[0].replace("%", ""))
discount_price = float(
discount_price_element.contents[0]
.replace(" ", "")
.replace("€", "")
.replace(",", ".")
discount_price_element.contents[0].replace(" ", "").replace("€", "").replace(",", ".")
)
games.add(SteamSpecialOffer(name, original_price, discount_price, discount))
self._urls[name] = element.attrs["href"]
self._image_urls[name] = (
element.find("div", {"class": "search_capsule"})
.find("img")
.attrs["src"]
)
self._image_urls[name] = element.find("div", {"class": "search_capsule"}).find("img").attrs["src"]
return games
@@ -134,9 +118,7 @@ class SteamOfferWatcher(TaskABC):
return new_offers
async def _send_embed_for_offer(
self, offer: SteamSpecialOffer, channel_id: int
) -> discord.Embed:
async def _send_embed_for_offer(self, offer: SteamSpecialOffer, channel_id: int) -> discord.Embed:
embed = discord.Embed(
title=offer.name,
url=self._urls[offer.name],
@@ -211,9 +193,7 @@ class SteamOfferWatcher(TaskABC):
if self._is_new:
return
for guild in self._bot.guilds:
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{guild.id}"
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{guild.id}")
if (
not FeatureFlagsSettings.get_flag_from_dict(
settings.feature_flags, FeatureFlagsEnum.steam_special_offers
@@ -224,9 +204,7 @@ class SteamOfferWatcher(TaskABC):
for offer in offers_for_notifications:
self._bot.loop.create_task(
self._send_embed_for_offer(
offer, settings.game_offer_notification_chat_id
)
self._send_embed_for_offer(offer, settings.game_offer_notification_chat_id)
)
except Exception as e:
self._logger.error(__name__, f"Steam offer watcher failed", e)

4
bot/src/modules/technician/api_key_seeder.py
View File

@@ -36,9 +36,7 @@ class ApiKeySeeder(DataSeederABC):
return
try:
frontend_key = ApiKey(
"frontend", "87f529fd-a32e-40b3-a1d1-7a1583cf3ff5", None
)
frontend_key = ApiKey("frontend", "87f529fd-a32e-40b3-a1d1-7a1583cf3ff5", None)
self._api_keys.add_api_key(frontend_key)
self._db.save_changes()
self._logger.info(__name__, f"Created frontend API-Key")

36
bot/src/modules/technician/command/api_key_group.py
View File

@@ -54,9 +54,7 @@ class ApiKeyGroup(DiscordCommandABC):
def _get_api_key_str(self, api_key: ApiKey) -> str:
return hashlib.sha256(
f"{api_key.identifier}:{api_key.key}+{self._auth_settings.secret_key}".encode(
"utf-8"
)
f"{api_key.identifier}:{api_key.key}+{self._auth_settings.secret_key}".encode("utf-8")
).hexdigest()
@commands.hybrid_group(name="api-key")
@@ -69,9 +67,7 @@ class ApiKeyGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_technician()
async def get(self, ctx: Context, key: str, wait: int = None):
self._logger.debug(
__name__, f"Received command api-key get {ctx}: {key},{wait}"
)
self._logger.debug(__name__, f"Received command api-key get {ctx}: {key},{wait}")
api_key = self._api_keys.get_api_key_by_key(key)
await self._message_service.send_ctx_msg(
@@ -83,16 +79,12 @@ class ApiKeyGroup(DiscordCommandABC):
self._logger.trace(__name__, f"Finished command api-key get")
@get.autocomplete("key")
async def get_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
async def get_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
keys = self._api_keys.get_api_keys()
return [
app_commands.Choice(name=f"{key.identifier}: {key.key}", value=key.key)
for key in self._client_utils.get_auto_complete_list(
keys, current, lambda x: x.key
)
for key in self._client_utils.get_auto_complete_list(keys, current, lambda x: x.key)
]
@api_key.command()
@@ -100,14 +92,10 @@ class ApiKeyGroup(DiscordCommandABC):
@CommandChecks.check_is_ready()
@CommandChecks.check_is_member_moderator()
async def add(self, ctx: Context, identifier: str):
self._logger.debug(
__name__, f"Received command api-key add {ctx}: {identifier}"
)
self._logger.debug(__name__, f"Received command api-key add {ctx}: {identifier}")
server = self._servers.get_server_by_discord_id(ctx.guild.id)
user = self._users.get_user_by_discord_id_and_server_id(
ctx.author.id, server.id
)
user = self._users.get_user_by_discord_id_and_server_id(ctx.author.id, server.id)
api_key = ApiKey(identifier, str(uuid.uuid4()), user)
self._api_keys.add_api_key(api_key)
self._db.save_changes()
@@ -137,21 +125,15 @@ class ApiKeyGroup(DiscordCommandABC):
api_key = keys.single()
self._api_keys.delete_api_key(api_key)
self._db.save_changes()
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.technician.api_key.remove.success")
)
await self._message_service.send_ctx_msg(ctx, self._t.transform("modules.technician.api_key.remove.success"))
self._logger.trace(__name__, f"Finished command api-key remove")
@remove.autocomplete("key")
async def set_autocomplete(
self, interaction: discord.Interaction, current: str
) -> TList[app_commands.Choice[str]]:
async def set_autocomplete(self, interaction: discord.Interaction, current: str) -> TList[app_commands.Choice[str]]:
keys = self._api_keys.get_api_keys()
return [
app_commands.Choice(name=f"{key.identifier}: {key.key}", value=key.key)
for key in self._client_utils.get_auto_complete_list(
keys, current, lambda x: x.key
)
for key in self._client_utils.get_auto_complete_list(keys, current, lambda x: x.key)
]

5
bot/src/modules/technician/command/log_command.py
View File

@@ -98,10 +98,7 @@ class LogCommand(DiscordCommandABC):
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))

4
bot/src/modules/technician/command/restart_command.py
View File

@@ -52,9 +52,7 @@ class RestartCommand(DiscordCommandABC):
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 self._message_service.send_ctx_msg(ctx, self._t.transform("modules.technician.restart_message"))
await asyncio.sleep(self._settings.wait_for_restart)
await self._data_integrity.check_data_integrity(is_for_shutdown=True)
await self._bot.stop_async()

4
bot/src/modules/technician/command/shutdown_command.py
View File

@@ -51,9 +51,7 @@ class ShutdownCommand(DiscordCommandABC):
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._message_service.send_ctx_msg(ctx, self._t.transform("modules.technician.shutdown_message"))
await asyncio.sleep(self._settings.wait_for_shutdown)
await self._data_integrity.check_data_integrity(is_for_shutdown=True)
await self._bot.stop_async()

58
bot/src/modules/technician/command/sync_xp_command.py
View File

@@ -71,28 +71,18 @@ class SyncXpGroup(DiscordCommandABC):
if ctx.guild is None:
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
settings.feature_flags, FeatureFlagsEnum.sync_xp
):
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.feature_not_activated")
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(settings.feature_flags, FeatureFlagsEnum.sync_xp):
await self._message_service.send_ctx_msg(ctx, self._t.transform("common.feature_not_activated"))
return
other_server = self._servers.get_server_by_id(server_id)
users_on_other_server = self._users.get_users_by_server_id(
other_server.id
).where(lambda x: not x.left_server)
discord_ids_on_other_server = users_on_other_server.select(
lambda x: x.discord_id
)
users_on_other_server = self._users.get_users_by_server_id(other_server.id).where(lambda x: not x.left_server)
discord_ids_on_other_server = users_on_other_server.select(lambda x: x.discord_id)
for user in self._users.get_users_by_server_id(
self._servers.get_server_by_discord_id(ctx.guild.id).id
).where(lambda x: not x.left_server):
for user in self._users.get_users_by_server_id(self._servers.get_server_by_discord_id(ctx.guild.id).id).where(
lambda x: not x.left_server
):
try:
if user.discord_id not in discord_ids_on_other_server:
continue
@@ -106,21 +96,15 @@ class SyncXpGroup(DiscordCommandABC):
user.xp = user_on_other_server.xp
self._users.update_user(user)
self._db.save_changes()
await self._level_service.check_level(
ctx.guild.get_member(user.discord_id)
)
await self._level_service.check_level(ctx.guild.get_member(user.discord_id))
except Exception as e:
self._logger.error(__name__, f"Cannot sync user {user.name}", e)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.technician.synced_message")
)
await self._message_service.send_ctx_msg(ctx, self._t.transform("modules.technician.synced_message"))
self._logger.trace(__name__, f"Finished sync xp command")
@all_members.autocomplete("server_id")
async def list_autocomplete(
self, interaction: discord.Interaction, current: str
) -> list[app_commands.Choice]:
async def list_autocomplete(self, interaction: discord.Interaction, current: str) -> list[app_commands.Choice]:
return [
app_commands.Choice(name=server.name, value=server.id)
for server in self._client_utils.get_auto_complete_list(
@@ -138,15 +122,9 @@ class SyncXpGroup(DiscordCommandABC):
if ctx.guild is None:
return
settings: ServerConfig = self._config.get_configuration(
f"ServerConfig_{ctx.guild.id}"
)
if not FeatureFlagsSettings.get_flag_from_dict(
settings.feature_flags, FeatureFlagsEnum.sync_xp
):
await self._message_service.send_ctx_msg(
ctx, self._t.transform("common.feature_not_activated")
)
settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{ctx.guild.id}")
if not FeatureFlagsSettings.get_flag_from_dict(settings.feature_flags, FeatureFlagsEnum.sync_xp):
await self._message_service.send_ctx_msg(ctx, self._t.transform("common.feature_not_activated"))
return
other_server = self._servers.get_server_by_id(server_id)
@@ -169,16 +147,12 @@ class SyncXpGroup(DiscordCommandABC):
except Exception as e:
self._logger.error(__name__, f"Cannot sync user {user.name}", e)
await self._message_service.send_ctx_msg(
ctx, self._t.transform("modules.technician.synced_message")
)
await self._message_service.send_ctx_msg(ctx, self._t.transform("modules.technician.synced_message"))
await self._level_service.check_level(member)
self._logger.trace(__name__, f"Finished sync xp command")
@by_member.autocomplete("server_id")
async def list_autocomplete(
self, interaction: discord.Interaction, current: str
) -> list[app_commands.Choice]:
async def list_autocomplete(self, interaction: discord.Interaction, current: str) -> list[app_commands.Choice]:
return [
app_commands.Choice(name=server.name, value=server.id)
for server in self._client_utils.get_auto_complete_list(

8
bot/src/modules/technician/technician_module.py
View File

@@ -18,14 +18,10 @@ 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(DataSeederABC, ApiKeySeeder)
# commands
services.add_transient(RestartCommand)