Badge database normalization (#250)

* Database badge PK and FK normalization

The following DB changes in the seed data and also the migration

badge_info
- removal of “id”
- badge_filename is new PK

badge_affiliation
badge_type
badge_universe
- badge_id replaced with badge_filename, data updated to reflect

trade_offered
trade_accepted
- badge_id replaced with badge_filename, data updated to reflect

badges
profile_badges
- badge_name renamed to badge_filename to reflect content

Next steps:
1. update agimus code to remove use of badge_id and badge_name as relational data and reflect the new DB structure

* Badge PK/FK normalization

common.py:
- profile_badges.badge_name is now profile_badges.badge_filename (same data)

handlers/xp.py
- FoD.png is handed out at welcome, but badges.badge_name is now badges.badge_filename (same data)

utils/badge_utils.py
- badges.badge_name is now badges.badge_filename (same data)

commands/profile.py
- db_get_user_badge_names returns the filename under the key ‘badge_filename’ now
- profile badge inclusion needed updating too
- setting profile badge updated

commands/badges.py
- updated all the joins and return values to reflect the updated database structure here as well. INSERTS need to use the right name as well, since badges.badge_name is now badges.badge_filename

cogs/trade.py
- updated all the joins and return values to reflect the updated database structure (badges.badge_name => badges.badge_filename, trade_requested.badge_id => trade_requested.badge_filename, trade_offered.badge_id => trade_offered.badge_filename). Fortunately the queries contain most of the actionable bits, not much python to update, thankfully.

* Committing and updating to v1.3.25

* Updating DB query in badges statistics

Needed to update the query for badge_name to badge_filename

Co-authored-by: Dan Ross <[email protected]>

Author: danmatakizawa

charts/agimus/Chart.yaml

@@ -2,5 +2,5 @@ apiVersion: v2
 name: agimus
 description: A helm chart for a discord bot that also runs a mysql db
 type: application
-version: v1.4.0
-appVersion: v1.4.0
+version: v1.4.1
+appVersion: v1.4.1

cogs/trade.py

@@ -30,8 +30,8 @@ async def autocomplete_badges(ctx:discord.AutocompleteContext):
   return results
 
 async def _autocomplete_requestor_badges(ctx, requestor_id, requestee_id):
-  requestor_badges = [b['badge_name'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(requestor_id)]
-  requestee_badges = [b['badge_name'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(requestee_id)]
+  requestor_badges = [b['badge_filename'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(requestor_id)] # @TODO improve query to pull badge_name
+  requestee_badges = [b['badge_filename'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(requestee_id)] # @TODO improve query to pull badge_name
   badge_names = [b for b in requestor_badges if b not in requestee_badges]
   if len(badge_names) == 0:
     badge_names = ["This user already has all badges that you possess! Use '/trade cancel' to cancel this trade."]
@@ -41,8 +41,8 @@ async def _autocomplete_requestor_badges(ctx, requestor_id, requestee_id):
   return [result for result in badge_names if ctx.value.lower() in result.lower()]
 
 async def _autocomplete_requestee_badges(ctx, requestee_id, requestor_id):
-  requestor_badges = [b['badge_name'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(requestor_id)]
-  requestee_badges = [b['badge_name'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(requestee_id)]
+  requestor_badges = [b['badge_filename'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(requestor_id)] # @TODO improve query to pull badge_name
+  requestee_badges = [b['badge_filename'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(requestee_id)] # @TODO improve query to pull badge name
   badge_names = [b for b in requestee_badges if b not in requestor_badges]
   if len(badge_names) == 0:
       badge_names = ["You already have all badges that this user possesses! Use '/trade cancel' to cancel this trade."]
@@ -403,10 +403,10 @@ async def _cancel_invalid_related_trades(self, active_trade):
 
   async def _requestor_already_has_badges(self, interaction, active_trade, requestor, requestee):
     requestor_badges = db_get_user_badge_names(active_trade["requestor_id"])
-    requestor_badges = [b["badge_name"].replace('_', ' ').replace('.png', '') for b in requestor_badges]
+    requestor_badges = [b["badge_filename"].replace('_', ' ').replace('.png', '') for b in requestor_badges]
 
     trade_requested_badges = db_get_trade_requested_badges(active_trade)
-    trade_requested_badges = [b["badge_name"].replace('_', ' ').replace('.png', '') for b in trade_requested_badges]
+    trade_requested_badges = [b["badge_filename"].replace('_', ' ').replace('.png', '') for b in trade_requested_badges]
 
     badges_in_trade_requestor_has = [t for t in requestor_badges if t in trade_requested_badges]
 
@@ -448,10 +448,10 @@ async def _requestor_already_has_badges(self, interaction, active_trade, request
 
   async def _requestee_already_has_badges(self, interaction, active_trade, requestor, requestee):
     requestee_badges = db_get_user_badge_names(active_trade["requestee_id"])
-    requestee_badges = [b["badge_name"].replace('_', ' ').replace('.png', '') for b in requestee_badges]
+    requestee_badges = [b["badge_filename"].replace('_', ' ').replace('.png', '') for b in requestee_badges]
 
     trade_offered_badges = db_get_trade_offered_badges(active_trade)
-    trade_offered_badges = [b["badge_name"].replace('_', ' ').replace('.png', '') for b in trade_offered_badges]
+    trade_offered_badges = [b["badge_filename"].replace('_', ' ').replace('.png', '') for b in trade_offered_badges]
 
     badges_in_trade_requestee_has = [t for t in requestee_badges if t in trade_offered_badges]
 
@@ -492,10 +492,10 @@ async def _requestee_already_has_badges(self, interaction, active_trade, request
 
   async def _requestor_still_has_badges(self, interaction, active_trade, requestor, requestee):
     requestor_badges = db_get_user_badge_names(active_trade["requestor_id"])
-    requestor_badges = [b["badge_name"].replace('_', ' ').replace('.png', '') for b in requestor_badges]
+    requestor_badges = [b["badge_filename"].replace('_', ' ').replace('.png', '') for b in requestor_badges]
 
     trade_offered_badges = db_get_trade_offered_badges(active_trade)
-    trade_offered_badges = [b["badge_name"].replace('_', ' ').replace('.png', '') for b in trade_offered_badges]
+    trade_offered_badges = [b["badge_filename"].replace('_', ' ').replace('.png', '') for b in trade_offered_badges]
 
     badges_in_trade_requestor_has = [t for t in requestor_badges if t in trade_offered_badges]
 
@@ -536,10 +536,10 @@ async def _requestor_still_has_badges(self, interaction, active_trade, requestor
 
   async def _requestee_still_has_badges(self, interaction, active_trade, requestor, requestee):
     requestee_badges = db_get_user_badge_names(active_trade["requestee_id"])
-    requestee_badges = [b["badge_name"].replace('_', ' ').replace('.png', '') for b in requestee_badges]
+    requestee_badges = [b["badge_filename"].replace('_', ' ').replace('.png', '') for b in requestee_badges]
 
     trade_requested_badges = db_get_trade_requested_badges(active_trade)
-    trade_requested_badges = [b["badge_name"].replace('_', ' ').replace('.png', '') for b in trade_requested_badges]
+    trade_requested_badges = [b["badge_filename"].replace('_', ' ').replace('.png', '') for b in trade_requested_badges]
 
     badges_in_trade_requestee_has = [t for t in requestee_badges if t in trade_requested_badges]
 
@@ -900,7 +900,7 @@ async def _generate_offered_embed_and_image(self, active_trade):
     requestor = await self.bot.current_guild.fetch_member(active_trade["requestor_id"])
 
     offered_badges = db_get_trade_offered_badges(active_trade)
-    offered_badge_filenames = [f"{b['badge_name'].replace(' ', '_')}.png" for b in offered_badges]
+    offered_badge_filenames = [f"{b['badge_filename']}" for b in offered_badges]
     offered_image_id = f"{active_trade['id']}-offered"
     offered_image = await generate_badge_trade_showcase(
       offered_badge_filenames,
@@ -922,7 +922,7 @@ async def _generate_requested_embed_and_image(self, active_trade):
     requestor = await self.bot.current_guild.fetch_member(active_trade["requestor_id"])
 
     requested_badges = db_get_trade_requested_badges(active_trade)
-    requested_badge_filenames = [f"{b['badge_name'].replace(' ', '_')}.png" for b in requested_badges]
+    requested_badge_filenames = [f"{b['badge_filename']}" for b in requested_badges]
     requested_image_id = f"{active_trade['id']}-requested"
     requested_image = await generate_badge_trade_showcase(
       requested_badge_filenames,
@@ -1032,11 +1032,11 @@ async def _add_offered_badge_to_trade(self, ctx, active_trade, badge):
     # Don't need to check for active because already done so in propose()
     requestee = await self.bot.current_guild.fetch_member(active_trade["requestee_id"])
     requestee_badges = db_get_user_badge_names(active_trade["requestee_id"])
-    requestee_badge_names = [b["badge_name"].replace(".png", "").replace("_", " ") for b in requestee_badges]
+    requestee_badge_names = [b["badge_filename"].replace(".png", "").replace("_", " ") for b in requestee_badges]
 
     requestor = await self.bot.current_guild.fetch_member(active_trade["requestor_id"])
     requestor_badges = db_get_user_badge_names(active_trade["requestor_id"])
-    requestor_badge_names = [b["badge_name"].replace(".png", "").replace("_", " ") for b in requestor_badges]
+    requestor_badge_names = [b["badge_filename"].replace(".png", "").replace("_", " ") for b in requestor_badges]
 
     logger.info(f"{Fore.CYAN}{requestor.display_name} is looking to offer `{badge}` to {requestee.display_name}.")
 
@@ -1107,11 +1107,11 @@ async def _add_requested_badge_to_trade(self, ctx, active_trade, badge):
     # Don't need to check for active because already done so in propose()
     requestee = await self.bot.current_guild.fetch_member(active_trade["requestee_id"])
     requestee_badges = db_get_user_badge_names(active_trade["requestee_id"])
-    requestee_badge_names = [b["badge_name"].replace(".png", "").replace("_", " ") for b in requestee_badges]
+    requestee_badge_names = [b["badge_filename"].replace(".png", "").replace("_", " ") for b in requestee_badges]
 
     requestor = await self.bot.current_guild.fetch_member(active_trade["requestor_id"])
     requestor_badges = db_get_user_badge_names(active_trade["requestor_id"])
-    requestor_badge_names = [b["badge_name"].replace(".png", "").replace("_", " ") for b in requestor_badges]
+    requestor_badge_names = [b["badge_filename"].replace(".png", "").replace("_", " ") for b in requestor_badges]
 
     logger.info(f"{Fore.CYAN}{requestor.display_name} is looking to request `{badge}` from {requestee.display_name}.")
 
@@ -1234,10 +1234,10 @@ def db_get_trade_requested_badges(active_trade):
   db = getDB()
   query = db.cursor(dictionary=True)
   sql = '''
-    SELECT b_i.badge_name
+    SELECT b_i.badge_name, b_i.badge_filename
     FROM badge_info as b_i
       JOIN trade_requested AS t_r
-      ON t_r.trade_id = %s AND t_r.badge_id = b_i.id
+      ON t_r.trade_id = %s AND t_r.badge_filename = b_i.badge_filename
   '''
   vals = (active_trade_id,)
   query.execute(sql, vals)
@@ -1253,10 +1253,10 @@ def db_get_trade_offered_badges(active_trade):
   db = getDB()
   query = db.cursor(dictionary=True)
   sql = '''
-    SELECT b_i.badge_name
+    SELECT b_i.badge_name, b_i.badge_filename
     FROM badge_info as b_i
       JOIN trade_offered AS t_o
-      ON t_o.trade_id = %s AND t_o.badge_id = b_i.id
+      ON t_o.trade_id = %s AND t_o.badge_filename = b_i.badge_filename
   '''
   vals = (active_trade_id,)
   query.execute(sql, vals)
@@ -1272,8 +1272,8 @@ def db_add_badge_to_trade_offer(active_trade, badge_name):
   db = getDB()
   query = db.cursor(dictionary=True)
   sql = '''
-    INSERT INTO trade_offered (trade_id, badge_id)
-      VALUES (%s, (SELECT id FROM badge_info WHERE badge_name = %s))
+    INSERT INTO trade_offered (trade_id, badge_filename)
+      VALUES (%s, (SELECT badge_filename FROM badge_info WHERE badge_name = %s))
   '''
   vals = (active_trade_id, badge_name)
   query.execute(sql, vals)
@@ -1288,7 +1288,7 @@ def db_remove_badge_from_trade_offer(active_trade, badge_name):
   query = db.cursor(dictionary=True)
   sql = '''
     DELETE FROM trade_offered
-      WHERE trade_id = %s AND badge_id = (SELECT id FROM badge_info WHERE badge_name = %s)
+      WHERE trade_id = %s AND badge_filename = (SELECT badge_filename FROM badge_info WHERE badge_name = %s)
   '''
   vals = (active_trade_id, badge_name)
   query.execute(sql, vals)
@@ -1302,8 +1302,8 @@ def db_add_badge_to_trade_request(active_trade, badge_name):
   db = getDB()
   query = db.cursor(dictionary=True)
   sql = '''
-    INSERT INTO trade_requested (trade_id, badge_id)
-      VALUES (%s, (SELECT id FROM badge_info WHERE badge_name = %s))
+    INSERT INTO trade_requested (trade_id, badge_filename)
+      VALUES (%s, (SELECT badge_filename FROM badge_info WHERE badge_name = %s))
   '''
   vals = (active_trade_id, badge_name)
   query.execute(sql, vals)
@@ -1318,7 +1318,7 @@ def db_remove_badge_from_trade_request(active_trade, badge_name):
   query = db.cursor(dictionary=True)
   sql = '''
     DELETE FROM trade_requested
-      WHERE trade_id = %s AND badge_id = (SELECT id FROM badge_info WHERE badge_name = %s)
+      WHERE trade_id = %s AND badge_filename = (SELECT badge_filename FROM badge_info WHERE badge_name = %s)
   '''
   vals = (active_trade_id, badge_name)
   query.execute(sql, vals)
@@ -1404,21 +1404,21 @@ def db_perform_badge_transfer(active_trade):
 
   # Transfer Requested Badges to Requestor
   sql = '''
-    INSERT INTO badges (user_discord_id, badge_name)
+    INSERT INTO badges (user_discord_id, badge_filename)
       SELECT t.requestor_id, b_i.badge_filename
         FROM trades as t
         JOIN badge_info as b_i
         JOIN trade_requested as t_r
-          ON t.id = %s AND t_r.trade_id = t.id AND t_r.badge_id = b_i.id
+          ON t.id = %s AND t_r.trade_id = t.id AND t_r.badge_filename = b_i.badge_filename
   '''
   vals = (trade_id,)
   query.execute(sql, vals)
 
   # Delete Requested Badges from Requestee
   sql = '''
     DELETE b FROM badges b
-      JOIN badge_info b_i ON b.badge_name = b_i.badge_filename
-      JOIN trade_requested t_r ON t_r.badge_id = b_i.id
+      JOIN badge_info b_i ON b.badge_filename = b_i.badge_filename
+      JOIN trade_requested t_r ON t_r.badge_filename = b_i.badge_filename
       JOIN trades t ON t_r.trade_id = t.id
         WHERE (t.id = %s AND t.requestee_id = %s AND b.user_discord_id = %s)
   '''
@@ -1427,21 +1427,21 @@ def db_perform_badge_transfer(active_trade):
 
   # Transfer Offered Badges to Requestee
   sql = '''
-    INSERT INTO badges (user_discord_id, badge_name)
+    INSERT INTO badges (user_discord_id, badge_filename)
       SELECT t.requestee_id, b_i.badge_filename
         FROM trades as t
         JOIN badge_info as b_i
         JOIN trade_offered as t_o
-          ON t.id = %s AND t_o.trade_id = t.id AND t_o.badge_id = b_i.id
+          ON t.id = %s AND t_o.trade_id = t.id AND t_o.badge_filename = b_i.badge_filename
   '''
   vals = (trade_id,)
   query.execute(sql, vals)
 
   # Delete Offered Badges from Requestor
   sql = '''
     DELETE b FROM badges b
-      JOIN badge_info b_i ON b.badge_name = b_i.badge_filename
-      JOIN trade_offered t_o ON t_o.badge_id = b_i.id
+      JOIN badge_info b_i ON b.badge_filename = b_i.badge_filename
+      JOIN trade_offered t_o ON t_o.badge_filename = b_i.badge_filename
       JOIN trades t ON t_o.trade_id = t.id
         WHERE (t.id = %s AND t.requestor_id = %s AND b.user_discord_id = %s)
   '''
@@ -1490,11 +1490,11 @@ def db_get_related_badge_trades(active_trade):
     LEFT JOIN trade_requested `tr` ON t.id = tr.trade_id
 
     INNER JOIN (
-        SELECT trade_id, requestor_id, requestee_id, badge_id
+        SELECT trade_id, requestor_id, requestee_id, badge_filename
         FROM trade_requested
         INNER JOIN trades ON trade_requested.trade_id = trades.id AND trades.id = %s
         UNION ALL
-        SELECT trade_id, requestor_id, requestee_id, badge_id
+        SELECT trade_id, requestor_id, requestee_id, badge_filename
         FROM trade_offered
         INNER JOIN trades ON trade_offered.trade_id = trades.id AND trades.id = %s
     ) as activeTrade ON 1
@@ -1509,7 +1509,7 @@ def db_get_related_badge_trades(active_trade):
     AND (t.requestor_id IN (activeTrade.requestor_id, activeTrade.requestee_id) OR t.requestee_id IN (activeTrade.requestor_id, activeTrade.requestee_id))
 
     -- involves one or more of the badges involved in the active trade
-    AND (to.badge_id = activeTrade.badge_id OR tr.badge_id = activeTrade.badge_id)
+    AND (to.badge_filename = activeTrade.badge_filename OR tr.badge_filename = activeTrade.badge_filename)
     GROUP BY t.id
   '''
   vals = (active_trade_id, active_trade_id)

commands/badges.py

@@ -326,7 +326,7 @@ async def badge_statistics(ctx:discord.ApplicationContext):
   embed.add_field(name="Total badges collected\non the USS Hood", value=f"{results['total_badges'][0]['count']}", inline=True)
   embed.add_field(name=f"{get_emoji('combadge')}", value="⠀", inline=True)
   embed.add_field(name="Badges collected today", value=f"{results['badges_today'][0]['count']}", inline=True)
-  embed.add_field(name="Top 3 most-collected badges", value=str("\n".join(f"{t['badge_name'].replace('_', ' ').replace('.png', '')} ({t['count']})" for t in top_three)), inline=True)
+  embed.add_field(name="Top 3 most-collected badges", value=str("\n".join(f"{t['badge_filename'].replace('_', ' ').replace('.png', '')} ({t['count']})" for t in top_three)), inline=True)
   embed.add_field(name=f"{get_emoji('combadge')}", value="⠀", inline=True)
   embed.add_field(name="Top 3 badge collectors", value=str("\n".join(f"{t['name']} ({t['count']})" for t in top_collectors)), inline=True)
   await ctx.respond(embed=embed, ephemeral=False)
@@ -472,7 +472,7 @@ def db_get_all_affiliation_badges(affiliation):
   sql = '''
     SELECT badge_name FROM badge_info b_i
       JOIN badge_affiliation AS b_a
-        ON b_i.id = b_a.badge_id
+        ON b_i.badge_filename = b_a.badge_filename
       WHERE b_a.affiliation_name = %s
   '''
   vals = (affiliation,)
@@ -493,9 +493,9 @@ def db_get_badges_user_has_from_affiliation(user_id, affiliation):
   sql = '''
     SELECT b_i.badge_name FROM badges b
       JOIN badge_info AS b_i
-        ON b.badge_name = b_i.badge_filename
+        ON b.badge_filename = b_i.badge_filename
       JOIN badge_affiliation AS b_a
-        ON b_i.id = b_a.badge_id
+        ON b_i.badge_filename = b_a.badge_filename
       WHERE b.user_discord_id = %s
         AND b_a.affiliation_name = %s
   '''
@@ -552,7 +552,7 @@ def db_get_badges_user_has_from_franchise(user_id, franchise):
   sql = '''
     SELECT b_i.badge_name FROM badges b
       JOIN badge_info AS b_i
-        ON b.badge_name = b_i.badge_filename
+        ON b.badge_filename = b_i.badge_filename
       WHERE b.user_discord_id = %s
         AND b_i.franchise = %s
   '''
@@ -617,7 +617,7 @@ def db_get_badges_user_has_from_time_period(user_id, time_period):
   sql = '''
     SELECT b_i.badge_name FROM badges b
       JOIN badge_info AS b_i
-        ON b.badge_name = b_i.badge_filename
+        ON b.badge_filename = b_i.badge_filename
       WHERE b.user_discord_id = %s
         AND b_i.time_period = %s
   '''
@@ -655,7 +655,7 @@ def db_get_all_type_badges(type):
   sql = '''
     SELECT badge_name FROM badge_info b_i
       JOIN badge_type AS b_t
-        ON b_i.id = b_t.badge_id
+        ON b_i.badge_filename = b_t.badge_filename
       WHERE b_t.type_name = %s
   '''
   vals = (type,)
@@ -676,9 +676,9 @@ def db_get_badges_user_has_from_type(user_id, type):
   sql = '''
     SELECT b_i.badge_name FROM badges b
       JOIN badge_info AS b_i
-        ON b.badge_name = b_i.badge_filename
+        ON b.badge_filename = b_i.badge_filename
       JOIN badge_type AS b_t
-        ON b_i.id = b_t.badge_id
+        ON b_i.badge_filename = b_t.badge_filename
       WHERE b.user_discord_id = %s
         AND b_t.type_name = %s
   '''
@@ -709,7 +709,7 @@ def give_user_badge(user_discord_id:int):
     badge_choice = random.choice(badges)
   db = getDB()
   query = db.cursor()
-  sql = "INSERT INTO badges (user_discord_id, badge_name) VALUES (%s, %s)"
+  sql = "INSERT INTO badges (user_discord_id, badge_filename) VALUES (%s, %s)"
   vals = (user_discord_id, badge_choice)
   query.execute(sql, vals)
   db.commit()
@@ -720,7 +720,7 @@ def give_user_badge(user_discord_id:int):
 def give_user_specific_badge(user_discord_id:int, badge_choice:str):
   db = getDB()
   query = db.cursor()
-  sql = "INSERT INTO badges (user_discord_id, badge_name) VALUES (%s, %s)"
+  sql = "INSERT INTO badges (user_discord_id, badge_filename) VALUES (%s, %s)"
   vals = (user_discord_id, badge_choice)
   query.execute(sql, vals)
   db.commit()
@@ -734,7 +734,7 @@ def give_user_specific_badge(user_discord_id:int, badge_choice:str):
 def get_user_badges(user_discord_id:int):
   db = getDB()
   query = db.cursor()
-  sql = "SELECT badge_name FROM badges WHERE user_discord_id = %s ORDER BY badge_name ASC"
+  sql = "SELECT badge_filename FROM badges WHERE user_discord_id = %s ORDER BY badge_filename ASC"
   vals = (user_discord_id,)
   query.execute(sql, vals)
   badges = [badge[0] for badge in query.fetchall()]
@@ -745,7 +745,7 @@ def get_user_badges(user_discord_id:int):
 
 def run_badge_stats_queries():
   queries = {
-    "most_collected" : "SELECT badge_name, COUNT(id) as count FROM badges GROUP BY badge_name ORDER BY count DESC LIMIT 3;",
+    "most_collected" : "SELECT badge_filename, COUNT(id) as count FROM badges GROUP BY badge_filename ORDER BY count DESC LIMIT 3;",
     "total_badges" : "SELECT COUNT(id) as count FROM badges;",
     "badges_today" : "SELECT COUNT(id) as count FROM badges WHERE time_created > NOW() - INTERVAL 1 DAY;",
     "top_collectors" : "SELECT name, COUNT(badges.id) as count FROM users JOIN badges ON users.discord_id = badges.user_discord_id GROUP BY discord_id ORDER BY COUNT(badges.id) DESC LIMIT 3;"

commands/profile.py

@@ -47,7 +47,7 @@ async def set_tagline(ctx:discord.ApplicationContext, tagline:str):
 
 
 def user_badges_autocomplete(ctx:discord.AutocompleteContext):
-  user_badges = [b['badge_name'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(ctx.interaction.user.id)]
+  user_badges = [b['badge_filename'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(ctx.interaction.user.id)]
   if len(user_badges) == 0:
     user_badges = ["You don't have any badges yet!"]
   user_badges.sort()
@@ -79,7 +79,7 @@ async def set_profile_badge(ctx:discord.ApplicationContext, badge:str):
     return
 
   # Check to make sure they own the badge
-  user_badges = [b['badge_name'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(ctx.author.id)]
+  user_badges = [b['badge_filename'].replace('_', ' ').replace('.png', '') for b in db_get_user_badge_names(ctx.author.id)]
   if badge not in user_badges:
     await ctx.respond(embed=discord.Embed(
       title="Unable To Set Featured Profile Badge",
@@ -311,26 +311,26 @@ async def profile(ctx:discord.ApplicationContext, public:str):
     base_bg.paste(sticker_bg, (406+random.randint(-10,5), 886+random.randint(-3,3)), sticker_bg)
 
   # put badge on
-  if len(user["badges"]) > 0 and user['badges'][0]['badge_name']:
-    badge_name = user['badges'][0]['badge_name']
+  if len(user["badges"]) > 0 and user['badges'][0]['badge_filename']:
+    badge_filename = user['badges'][0]['badge_filename']
     user_badges = db_get_user_badge_names(user['discord_id'])
-    if badge_name not in [b['badge_name'] for b in user_badges]:
+    if badge_filename not in [b['badge_filename'] for b in user_badges]:
       # Catch if the user had a badge present that they no longer have, if so clear it from the table
       db_remove_user_profile_badge(user['discord_id'])
       if user["receive_notifications"]:
         try:
           await ctx.author.send(
             embed=discord.Embed(
               title="Profile Badge No Longer Present",
-              description=f"Just a heads up, you had a badge on your profile previously, \"{badge_name.replace('_', ' ').replace('.png', '')}\", which is no longer in your inventory.\n\nYou can set a new featured badge with `/set_profile_badge`!",
+              description=f"Just a heads up, you had a badge on your profile previously, \"{badge_filename.replace('_', ' ').replace('.png', '')}\", which is no longer in your inventory.\n\nYou can set a new featured badge with `/set_profile_badge`!",
               color=discord.Color.red()
             )
           )
         except discord.Forbidden as e:
           logger.info(f"Unable to send notification to {ctx.author.display_name} regarding their cleared profile badge, they have their DMs closed.")
     else:
       # Otherwise go ahead and stamp the badge on their profile PADD
-      badge_image = Image.open(f"./images/badges/{badge_name}").convert("RGBA").resize((170, 170))
+      badge_image = Image.open(f"./images/badges/{badge_filename}").convert("RGBA").resize((170, 170))
       base_bg.paste(badge_image, (540, 550), badge_image)
 
 
@@ -366,8 +366,8 @@ async def profile(ctx:discord.ApplicationContext, public:str):
 def db_remove_user_profile_badge(user_id):
   db = getDB()
   query = db.cursor()
-  sql = "REPLACE INTO profile_badges (badge_name, user_discord_id) VALUES (%(badge_name)s, %(user_discord_id)s)"
-  vals = {"badge_name" : "", "user_discord_id" : user_id}
+  sql = "REPLACE INTO profile_badges (badge_filename, user_discord_id) VALUES (%(badge_filename)s, %(user_discord_id)s)"
+  vals = {"badge_filename" : "", "user_discord_id" : user_id}
   logger.info(f"CLEARING PROFILE BADGE {sql}")
   query.execute(sql, vals)
   db.commit()
@@ -377,19 +377,20 @@ def db_remove_user_profile_badge(user_id):
 def db_add_user_profile_badge(user_id, badge):
   db = getDB()
   query = db.cursor()
-  sql = "REPLACE INTO profile_badges (badge_name, user_discord_id) VALUES (%(badge_name)s, %(user_discord_id)s)"
-  vals = {"badge_name" : badge, "user_discord_id" : user_id}
+  sql = "REPLACE INTO profile_badges (badge_filename, user_discord_id) VALUES (%(badge_filename)s, %(user_discord_id)s)"
+  vals = {"badge_filename" : badge, "user_discord_id" : user_id}
   logger.info(f"UPDATING PROFILE BADGE {sql} {vals}")
   query.execute(sql, vals)
   db.commit()
   query.close()
   db.close()
 
-def db_get_badge_filename_for_badge(badge):
+# Given a badge name, retrieves the badge_filename
+def db_get_badge_filename_for_badge(badge_name):
   db = getDB()
   query = db.cursor(dictionary=True)
   sql = "SELECT badge_filename FROM badge_info WHERE badge_name = %s"
-  vals = (badge,)
+  vals = (badge_name,)
   query.execute(sql, vals)
   row = query.fetchone()
   db.commit()

common.py

@@ -192,7 +192,7 @@ def get_user(discord_id:int):
   query.execute(sql, vals)
   user_stickers = query.fetchall()
   # get user featured badges
-  sql = "SELECT badge_name FROM profile_badges WHERE user_discord_id = %s AND badge_name IS NOT NULL"
+  sql = "SELECT badge_filename FROM profile_badges WHERE user_discord_id = %s AND badge_filename IS NOT NULL"
   vals = (discord_id,)
   query.execute(sql, vals)
   user_badges = query.fetchall()

data/seed-db.sql

@@ -72,7 +72,7 @@ CREATE TABLE IF NOT EXISTS profile_taglines (
 CREATE TABLE IF NOT EXISTS profile_badges (
   id int(11) NOT NULL AUTO_INCREMENT,
   user_discord_id VARCHAR(64) NOT NULL,
-  badge_name VARCHAR(255) DEFAULT NULL,
+  badge_filename VARCHAR(128) DEFAULT NULL,
   last_modified TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP() ON UPDATE CURRENT_TIMESTAMP,
   PRIMARY KEY (id),
   UNIQUE KEY (user_discord_id)
@@ -92,64 +92,63 @@ CREATE TABLE IF NOT EXISTS trades (
 CREATE TABLE IF NOT EXISTS badges (
   id int(11) NOT NULL AUTO_INCREMENT,
   user_discord_id varchar(64) NOT NULL,
-  badge_name varchar(128) NOT NULL,
+  badge_filename varchar(128) NOT NULL,
   time_created timestamp NOT NULL DEFAULT current_timestamp(),
   PRIMARY KEY (id)
 );
-CREATE TABLE IF NOT EXISTS badge_info (
-  id int(11) NOT NULL AUTO_INCREMENT,
-  badge_name varchar(128) NOT NULL,
-  badge_filename varchar(128) NOT NULL,
-  badge_url varchar(256) NOT NULL,
-  quadrant varchar(128) DEFAULT NULL,
-  time_period varchar(128) DEFAULT NULL,
-  franchise varchar(128) DEFAULT NULL,
-  reference varchar(128) DEFAULT NULL,
-  PRIMARY KEY (id)
+CREATE TABLE IF NOT EXISTS `badge_info` (
+    `badge_filename` varchar(128) NOT NULL,
+    `badge_name` varchar(128) NOT NULL,
+    `badge_url` varchar(256) NOT NULL,
+    `quadrant` varchar(128) DEFAULT NULL,
+    `time_period` varchar(128) DEFAULT NULL,
+    `franchise` varchar(128) DEFAULT NULL,
+    `reference` varchar(128) DEFAULT NULL,
+    PRIMARY KEY (`badge_filename`)
 );
 CREATE TABLE IF NOT EXISTS badge_affiliation (
-  id int(11) NOT NULL AUTO_INCREMENT,
-  badge_id int (11) NOT NULL,
-  affiliation_name varchar(128) NOT NULL,
-  PRIMARY KEY (id),
-  FOREIGN KEY (badge_id)
-    REFERENCES badge_info(id)
+    `id` int NOT NULL AUTO_INCREMENT,
+    `badge_filename` varchar(128) NOT NULL,
+    `affiliation_name` varchar(128) NOT NULL,
+    PRIMARY KEY (`id`),
+    KEY `badge_filename` (`badge_filename`),
+    CONSTRAINT `badge_affiliation_fk_badge_filename` FOREIGN KEY (`badge_filename`) REFERENCES `badge_info` (`badge_filename`)
 );
 CREATE TABLE IF NOT EXISTS badge_type (
-  id int(11) NOT NULL AUTO_INCREMENT,
-  badge_id int (11) NOT NULL,
-  type_name varchar(128) NOT NULL,
-  PRIMARY KEY (id),
-  FOREIGN KEY (badge_id)
-    REFERENCES badge_info(id)
+    `id` int NOT NULL AUTO_INCREMENT,
+    `badge_filename` varchar(128) NOT NULL,
+    `type_name` varchar(128) NOT NULL,
+    PRIMARY KEY (`id`),
+    KEY `badge_filename` (`badge_filename`),
+    CONSTRAINT `badge_type_fk_badge_filename` FOREIGN KEY (`badge_filename`) REFERENCES `badge_info` (`badge_filename`)
 );
 CREATE TABLE IF NOT EXISTS badge_universe (
-  id int(11) NOT NULL AUTO_INCREMENT,
-  badge_id int (11) NOT NULL,
-  universe_name varchar(128) NOT NULL,
-  PRIMARY KEY (id),
-  FOREIGN KEY (badge_id)
-    REFERENCES badge_info(id)
+    `id` int NOT NULL AUTO_INCREMENT,
+    `badge_filename` varchar(128) NOT NULL,
+    `universe_name` varchar(128) NOT NULL,
+    PRIMARY KEY (`id`),
+    KEY `badge_filename` (`badge_filename`),
+    CONSTRAINT `badge_universe_fk_badge_filename` FOREIGN KEY (`badge_filename`) REFERENCES `badge_info` (`badge_filename`)
 );
 CREATE TABLE IF NOT EXISTS trade_offered (
   id int(11) NOT NULL AUTO_INCREMENT,
-  badge_id int(11) NOT NULL,
+  badge_filename VARCHAR(128) NOT NULL,
   trade_id int(11) NOT NULL,
   time_created timestamp NOT NULL DEFAULT current_timestamp(),
   PRIMARY KEY (id),
-  FOREIGN KEY (badge_id)
-    REFERENCES badge_info(id),
+  FOREIGN KEY (badge_filename)
+    REFERENCES badge_info(badge_filename),
   FOREIGN KEY (trade_id)
     REFERENCES trades(id)
 );
 CREATE TABLE IF NOT EXISTS trade_requested (
   id int(11) NOT NULL AUTO_INCREMENT,
-  badge_id int(11) NOT NULL,
+  badge_filename VARCHAR(128) NOT NULL,
   trade_id int(11) NOT NULL,
   time_created timestamp NOT NULL DEFAULT current_timestamp(),
   PRIMARY KEY (id),
-  FOREIGN KEY (badge_id)
-    REFERENCES badge_info(id),
+  FOREIGN KEY (badge_filename)
+    REFERENCES badge_info(badge_filename),
   FOREIGN KEY (trade_id)
     REFERENCES trades(id)
 );

handlers/xp.py

@@ -257,11 +257,11 @@ async def level_up_user(user:discord.User, level:int):
   await send_level_up_message(user, level, badge)
 
 def give_welcome_badge(user_id):
-  user_badge_names = [b['badge_name'] for b in db_get_user_badge_names(user_id)]
+  user_badge_names = [b['badge_filename'] for b in db_get_user_badge_names(user_id)]
   if "Friends_Of_DeSoto.png" not in user_badge_names:
     db = getDB()
     query = db.cursor()
-    sql = "INSERT INTO badges (user_discord_id, badge_name) VALUES (%s, 'Friends_Of_DeSoto.png');"
+    sql = "INSERT INTO badges (user_discord_id, badge_filename) VALUES (%s, 'Friends_Of_DeSoto.png');"
     vals = (user_id,)
     query.execute(sql, vals)
     db.commit()

migrations/v1.4.1.sql

@@ -0,0 +1,180 @@
+-- ------------------------------------------------------------
+-- BEGIN SECTION A: NEW BADGE METADATA
+-- ------------------------------------------------------------
+
+-- Create a new badge_info table, now with blackjack and hookers
+-- More specifically, removing id, making badge_filename the PK and moving badge_filename to the top of the table.
+CREATE TABLE `badge_info_new` LIKE `badge_info`;
+INSERT INTO `badge_info_new` SELECT * FROM badge_info;
+ALTER TABLE badge_info_new DROP COLUMN `id`;
+ALTER TABLE badge_info_new ADD PRIMARY KEY (`badge_filename`);
+ALTER TABLE badge_info_new CHANGE COLUMN badge_name badge_name VARCHAR(128) NOT NULL AFTER badge_filename;
+
+-- Create new badge_affiliation and populate from old one
+CREATE TABLE `badge_affiliation_new`
+(
+    `id`               int          NOT NULL AUTO_INCREMENT,
+    `badge_filename`   varchar(128) NOT NULL,
+    `affiliation_name` varchar(128) NOT NULL,
+    PRIMARY KEY (`id`),
+    KEY `badge_filename` (`badge_filename`),
+    CONSTRAINT `badge_affiliation_fk_badge_filename` FOREIGN KEY (`badge_filename`) REFERENCES `badge_info_new` (`badge_filename`)
+);
+
+INSERT INTO badge_affiliation_new (badge_filename, affiliation_name)
+SELECT
+    badge_info.badge_filename,
+    badge_affiliation.affiliation_name
+    FROM badge_info
+    INNER JOIN badge_affiliation ON badge_info.id = badge_affiliation.badge_id;
+
+-- Create new badge_type and populate from old one
+CREATE TABLE `badge_type_new`
+(
+    `id`             int          NOT NULL AUTO_INCREMENT,
+    `badge_filename` varchar(128) NOT NULL,
+    `type_name`      varchar(128) NOT NULL,
+    PRIMARY KEY (`id`),
+    KEY `badge_filename` (`badge_filename`),
+    CONSTRAINT `badge_type_fk_badge_filename` FOREIGN KEY (`badge_filename`) REFERENCES `badge_info_new` (`badge_filename`)
+);
+
+INSERT INTO badge_type_new (badge_filename, type_name)
+SELECT
+    badge_info.badge_filename,
+    badge_type.type_name
+    FROM badge_info
+    INNER JOIN badge_type ON badge_info.id = badge_type.badge_id;
+
+-- Create new badge universe and populate from old one
+CREATE TABLE `badge_universe_new`
+(
+    `id`             int          NOT NULL AUTO_INCREMENT,
+    `badge_filename` varchar(128) NOT NULL,
+    `universe_name`  varchar(128) NOT NULL,
+    PRIMARY KEY (`id`),
+    KEY `badge_filename` (`badge_filename`),
+    CONSTRAINT `badge_universe_fk_badge_filename` FOREIGN KEY (`badge_filename`) REFERENCES `badge_info_new` (`badge_filename`)
+);
+
+INSERT INTO badge_universe_new (badge_filename, universe_name)
+SELECT
+    badge_info.badge_filename,
+    badge_universe.universe_name
+FROM badge_info
+INNER JOIN badge_universe ON badge_info.id = badge_universe.badge_id;
+
+
+-- ------------------------------------------------------------
+-- END SECTION A: NEW BADGE METADATA
+-- ------------------------------------------------------------
+
+-- ------------------------------------------------------------
+-- BEGIN SECTION B: UPDATE BADGE REFERENCES
+-- ------------------------------------------------------------
+
+-- trade_offered
+CREATE TABLE IF NOT EXISTS trade_offered_new
+(
+    id             int(11)      NOT NULL AUTO_INCREMENT,
+    badge_filename VARCHAR(128) NOT NULL,
+    trade_id       int(11)      NOT NULL,
+    time_created   timestamp    NOT NULL DEFAULT current_timestamp(),
+    PRIMARY KEY (id),
+    FOREIGN KEY (badge_filename)
+        REFERENCES badge_info_new (badge_filename),
+    FOREIGN KEY (trade_id)
+        REFERENCES trades (id)
+);
+INSERT INTO trade_offered_new (id, badge_filename, trade_id, time_created)
+SELECT
+    trade_offered.id,
+    badge_info.badge_filename,
+    trade_offered.trade_id,
+    trade_offered.time_created
+    FROM trade_offered
+    INNER JOIN badge_info ON trade_offered.badge_id = badge_info.id;
+
+-- trade_requested
+CREATE TABLE IF NOT EXISTS trade_requested_new
+(
+    id             int(11)      NOT NULL AUTO_INCREMENT,
+    badge_filename VARCHAR(128) NOT NULL,
+    trade_id       int(11)      NOT NULL,
+    time_created   timestamp    NOT NULL DEFAULT current_timestamp(),
+    PRIMARY KEY (id),
+    FOREIGN KEY (badge_filename)
+        REFERENCES badge_info_new (badge_filename),
+    FOREIGN KEY (trade_id)
+        REFERENCES trades (id)
+);
+INSERT INTO trade_requested_new (id, badge_filename, trade_id, time_created)
+SELECT
+    trade_requested.id,
+    badge_info.badge_filename,
+    trade_requested.trade_id,
+    trade_requested.time_created
+    FROM trade_requested
+    INNER JOIN badge_info ON trade_requested.badge_id = badge_info.id;
+
+-- badges
+CREATE TABLE `badges_new`
+(
+    `id`              int          NOT NULL AUTO_INCREMENT,
+    `user_discord_id` varchar(64)  NOT NULL,
+    `badge_filename`  varchar(128) NOT NULL,
+    `time_created`    timestamp    NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (`id`)
+);
+INSERT INTO badges_new (id, user_discord_id, badge_filename, time_created) SELECT id, user_discord_id, badge_name as badge_filename, time_created FROM badges;
+
+-- profile_badges;
+CREATE TABLE `profile_badges_new`
+(
+    `id`              int         NOT NULL AUTO_INCREMENT,
+    `user_discord_id` varchar(64) NOT NULL,
+    `badge_filename`  varchar(128)         DEFAULT NULL,
+    `last_modified`   timestamp   NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    PRIMARY KEY (`id`),
+    UNIQUE KEY `user_discord_id` (`user_discord_id`)
+);
+INSERT INTO profile_badges_new (id, user_discord_id, badge_filename, last_modified) SELECT id, user_discord_id, badge_name, last_modified FROM profile_badges;
+
+-- @TODO profile_badges should use badge_filename, not badge_name
+
+
+-- @TODO swap table names
+
+-- ------------------------------------------------------------
+-- END SECTION B: UPDATE BADGE REFERENCES
+-- ------------------------------------------------------------
+
+-- ------------------------------------------------------------
+-- START SECTION C: CLEANUP
+-- ------------------------------------------------------------
+
+-- Swap tables so previous ones are now "_old"
+RENAME TABLE badge_info to badge_info_old, badge_info_new to badge_info;
+RENAME TABLE badge_affiliation to badge_affiliation_old, badge_affiliation_new to badge_affiliation;
+RENAME TABLE badge_type to badge_type_old, badge_type_new to badge_type;
+RENAME TABLE badge_universe to badge_universe_old, badge_universe_new to badge_universe;
+
+RENAME TABLE badges to badges_old, badges_new to badges;
+RENAME TABLE profile_badges to profile_badges_old, profile_badges_new to profile_badges;
+RENAME TABLE trade_offered to trade_offered_old, trade_offered_new to trade_offered;
+RENAME TABLE trade_requested to trade_requested_old, trade_requested_new to trade_requested;
+
+
+-- When you're happy, then uncomment and execute the following lines to remove the old tables.
+DROP TABLE profile_badges_old;
+DROP TABLE trade_offered_old;
+DROP TABLE trade_requested_old;
+DROP TABLE badges_old;
+DROP TABLE badge_affiliation_old;
+DROP TABLE badge_type_old;
+DROP TABLE badge_universe_old;
+DROP TABLE badge_info_old;
+
+-- ------------------------------------------------------------
+-- END SECTION C: CLEANUP
+-- ------------------------------------------------------------

utils/badge_utils.py

@@ -300,7 +300,7 @@ def db_get_badge_count_for_user(user_id):
 def db_get_user_badge_names(user_id):
   db = getDB()
   query = db.cursor(dictionary=True)
-  sql = "SELECT badge_name FROM badges WHERE user_discord_id = %s"
+  sql = "SELECT badge_filename FROM badges WHERE user_discord_id = %s"
   vals = (user_id,)
   query.execute(sql, vals)
   badge_names = query.fetchall()