Implement in XpHandler

handlers/xp_handler.py

@@ -7,6 +7,7 @@ import discord
 from config.parser import JsonCache
 from lib import formatter
 from services.GuildConfig import GuildConfig
+from services.level_reward import LevelReward
 from services.Xp import Xp
 
 strings = JsonCache.read_json("strings")
@@ -48,6 +49,8 @@ class XPHandler:
                 else:
                     await message.reply(content=level_message)
 
+            await self.assign_level_role(message.guild, message.author, level_config.level)
+
             logs.info(f"[XpHandler] {message.author.name} leveled up to lv {level_config.level} "
                       f"in guild {message.guild.name} ({message.guild.id}).")
 
@@ -59,10 +62,6 @@ class XPHandler:
         level_config.ctime = current_time + level_config.new_cooldown
         level_config.push()
 
-        # Legacy code for Rave Cave level roles
-        # turn into a global system soon
-        await self.legacy_assign_level_role(message.author, level_config.level)
-
     @staticmethod
     async def get_level_channel(message, guild_config):
         if guild_config.level_channel_id:
@@ -120,50 +119,19 @@ class XPHandler:
         return start_string + random_message.format(level)
 
     @staticmethod
-    async def legacy_assign_level_role(user, level):
+    async def assign_level_role(guild, user, level: int) -> None:
+        _rew = LevelReward(guild.id)
+        role_id = _rew.role(level)
+        reason = "Racu Role Rewards"
 
-        guild = user.guild
+        if role_id:
 
-        if (
-                guild.id != 719227135151046699 or
-                not (level % 5 == 0 and 5 <= level <= 100)
-        ):
-            return
+            role = guild.get_role(role_id)
+            if role:
+                await user.add_roles(role, reason=reason)
 
-        level_roles = {
-            "level_5": 1118491431036792922,
-            "level_10": 1118491486259003403,
-            "level_15": 1118491512536301570,
-            "level_20": 1118491532111126578,
-            "level_25": 1118491554005393458,
-            "level_30": 1118491572770713710,
-            "level_35": 1118491596820840492,
-            "level_40": 1118491622045405287,
-            "level_45": 1118491650721853500,
-            "level_50": 1118491681004732466,
-            "level_55": 1191681166848303135,
-            "level_60": 1191681220145319956,
-            "level_65": 1191681253322264587,
-            "level_70": 1191681274180554792,
-            "level_75": 1191681293277216859,
-            "level_80": 1191681312269017180,
-            "level_85": 1191681337560662086,
-            "level_90": 1191681359995998209,
-            "level_95": 1191681384113262683,
-            "level_100": 1191681405445492778,
-            # Add more level roles as needed
-        }
-
-        current_level_role = None
-        new_level_role_id = level_roles.get(f"level_{level}")
-
-        for role in user.roles:
-            if role.id in level_roles.values() and role.id != new_level_role_id:
-                current_level_role = role
-                break
-
-        new_level_role = guild.get_role(new_level_role_id)
-        await user.add_roles(new_level_role)
-
-        if current_level_role:
-            await user.remove_roles(current_level_role)
+            previous = _rew.replace_previous_reward(level)
+            if previous[1]:
+                role = guild.get_role(previous[0])
+                if role:
+                    await user.remove_roles(role, reason=reason)

main.py

@@ -1,11 +1,12 @@
 import os
+import traceback
 
 import discord
 from dotenv import load_dotenv
 
 from handlers import LoggingHandler, ErrorHandler
 from handlers.ReactionHandler import ReactionHandler
-from handlers.XPHandler import XPHandler
+from handlers.xp_handler import XPHandler
 from lib.embeds.greet import Greet
 from services.Client import RacuBot
 from services.GuildConfig import GuildConfig
@@ -50,8 +51,8 @@ async def on_message(message):
         await reaction_handler.handle_message(message)
 
     except Exception as error:
-        logs.error(f"[EventHandler] on_message (check debug log): {error}", exc_info=False)
-        logs.debug(f"[EventHandler] on_message (w/ stacktrace): {error}", exc_info=True)
+        logs.error(f"[EventHandler] on_message (check debug log): {error}", exc_info=True)
+        traceback.print_tb(error.__traceback__)
 
 
 @client.event

modules/config/__init__.py

@@ -48,6 +48,19 @@ class Config(commands.Cog):
 
         await set_prefix.set_cmd(ctx, prefix)
 
+    @bridge.bridge_command(
+        name="xpreward",
+        aliases=["xprew", "xpr"],
+        guild_only="True"
+    )
+    @commands.guild_only()
+    @commands.has_permissions(manage_roles=True)
+    async def xpreward_command(self, ctx, level: int, roles: discord.Role):
+        """
+        Reward members for reaching a level. Guide: https://gitlab.com/wlinator/Racu/wikis/Role-Rewards
+        """
+        pass
+
     config = SlashCommandGroup("config", "server config commands.", guild_only=True,
                                default_member_permissions=discord.Permissions(manage_channels=True))
     birthday_config = config.create_subgroup(name="birthdays")

services/level_reward.py

@@ -1,44 +1,58 @@
 from datetime import datetime, timedelta
 from db import database
+import logging
 
 import pytz
 
 from config.parser import JsonCache
 
 resources = JsonCache.read_json("resources")
+_logs = logging.getLogger('Racu.Core')
 
 
 class LevelReward:
     def __init__(self, guild_id):
         self.guild_id = guild_id
-        self.rewards = sorted(self.get_rewards())
+        self.rewards = self.get_rewards()
 
     def get_rewards(self) -> dict:
         query = """
                 SELECT level, role_id, persistent
                 FROM level_rewards
                 WHERE guild_id = %s
+                ORDER BY level DESC
                 """
         data = database.select_query(query, (self.guild_id,))
 
         rewards = {}
         for row in data:
-            rewards[int(row[0])] = [int(row[1]), row[2]]
+            rewards[int(row[0])] = [int(row[1]), bool(row[2])]
 
+        _logs.info(rewards)
         return rewards
 
-    def level_role(self, level: int):
+    def role(self, level: int):
         if self.rewards:
+
             if level in self.rewards:
-                return self.rewards[level][0]
+                role_id = self.rewards.get(level)[0]
+                _logs.info(role_id)
+                return role_id
 
         return None
 
-    def replace_previous(self, level) -> bool:
-        index = self.rewards.index(level)
+    def replace_previous_reward(self, level):
+        replace = False
+        previous_reward = None
+        levels = sorted(self.rewards.keys())
 
-        if index != 0:
-            previous_key = self.rewards[index - 1]
-            return not bool(self.rewards[previous_key][1])
+        if level in levels:
+            values_below = [x for x in levels if x < level]
 
-        return False
+            if values_below:
+                replace = not bool(self.rewards.get(max(values_below))[1])
+
+            if replace:
+                previous_reward = self.rewards.get(max(values_below))[0]
+
+        return previous_reward, replace