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

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)