more reporting and more ways to earn XP

bot/commands/games.py

@@ -33,19 +33,19 @@ class Games(commands.Cog):
 
 		if not user:
 			user = ctx.author
-		level = await get_level(self.bot.pg, user)
+		level = await get_level(self.bot.pg, user.id)
 
 		if level == 0:
 			if ctx.author == user:
-				ctx.send(f"You are not playing, join the game with {COMMAND_PREFIX}`levelup`")
+				await ctx.send(f"You are not playing, join the game with `{COMMAND_PREFIX}levelup`")
 			else:
-				ctx.send(f"{user} is not playing.")
+				await ctx.send(f"`{user}` is not playing.")
 		else:
-			xp_spent, total_xp = get_xp(user)
+			xp_spent, total_xp = await get_xp(self.bot.pg, user.id)
 			if ctx.author == user:
-				ctx.send(f"You rank at level {level}. ({xp_spent}/{total_xp})")
+				await ctx.send(f"You rank at level {level}. ({xp_spent}/{total_xp})")
 			else:
-				ctx.send(f"{user} ranks at level {level}. ({xp_spent}/{total_xp})")
+				await ctx.send(f"`{user}` ranks at level {level}. ({xp_spent}/{total_xp})")
 
 	@commands.command(
 		description="Check the experience points for a player.",
@@ -64,17 +64,17 @@ class Games(commands.Cog):
 
 		if not user:
 			xp_spent, total_xp = await get_xp(self.bot.pg, ctx.author.id)
-			ctx.send(f"You have spent {xp_spent} experience points of your {total_xp} total.")
+			await ctx.send(f"You have spent {xp_spent} experience points of your {total_xp} total.")
 		else:
-			xp_spent, total_xp = await get_xp(self.bot.pg, user)
-			ctx.send(f"{user} has spent {xp_spent} of {total_xp} experience points.")
+			xp_spent, total_xp = await get_xp(self.bot.pg, user.id)
+			await ctx.send(f"`{user}` has spent {xp_spent} of {total_xp} experience points.")
 
 	@commands.command(
 		description="Attempt to gain a level.",
 		brief="Level up",
 		help="Try to rank up a level in the game by spending XP."
 	)
-	async def levelup(self, ctx: commands.Context, user: Optional[discord.User]):
+	async def levelup(self, ctx: commands.Context):
 		# Ignore user if on the ignore list.
 		if await is_ignored(self.bot.pg, ctx.author.id):
 			return
@@ -86,13 +86,13 @@ class Games(commands.Cog):
 
 		xp_spent, total_xp = await get_xp(self.bot.pg, ctx.author.id)
 		xp_available = total_xp - xp_spent
-		level = await get_level(self.bot.pg, user)
+		level = await get_level(self.bot.pg, ctx.author.id)
 		threshold = (level + 1) * 50 + xp_spent
 		if xp_available < threshold:
-			ctx.send(f"Not yet, you require {threshold - xp_available} more XP to level up.")
+			await ctx.send(f"Not yet, you require {threshold - xp_available} more XP to level up.")
 		else:
-			level_up(self.bot.pg, ctx.author.id, threshold)
-			ctx.send(f"You have climbed the ranks for {threshold} XP, leaving you {xp_available - threshold} remaining.")
+			await level_up(self.bot.pg, ctx.author.id, threshold)
+			await ctx.send(f"You have climbed the ranks for {threshold} XP, leaving you {xp_available - threshold} remaining.")
 
 
 	@commands.command(
@@ -107,7 +107,7 @@ class Games(commands.Cog):
 
 		# Warn if games are off.
 		if not await get_games(self.bot.pg, ctx.channel.id):
-			ctx.author.send(f"Games are disabled in {ctx.channel}, ask an admin to enable them.")
+			await ctx.author.send(f"Games are disabled in {ctx.channel}, ask an admin to enable them.")
 			return
 		if not amount:
 			amount = 2

bot/events/general.py

@@ -1,10 +1,10 @@
 import logging, discord, asyncpg, random, sys
 
 from discord.ext import commands
-from query.guild import update_guild, get_report_deleted, get_output_channel
+from query.guild import update_guild, get_report_deleted, get_output_channel, get_report_edited
 from query.channel import insert_channel, get_interact
 from query.channel_user import upsert_total_messages
-from query.user import create_user
+from query.user import create_user, created_invite, created_integration, member_updated, user_updated, member_banned, member_unbanned, presence_updated, message_edited, message_deleted, reacted, event_created, event_joined, thread_created, thread_joined
 from common.logging import report
 
 def setup(bot: commands.Bot):
@@ -87,19 +87,36 @@ class General(commands.Cog):
 		await report(self.bot, f"Guild removed `{guild}`.")
 
 	@commands.Cog.listener()
-	async def on_message_delete(self, message: discord.Message):
-		if await get_report_deleted(self.bot.pg, message.guild.id):
-			report(self.bot, message.guild_id, f"Message from {message.author}, in {message.channel} deleted: {message}")
-		self.last_msg = message
+	async def on_invite_create(self, invite: discord.Invite):
+		await created_invite(self.bot.pg, invite.inviter.id)
 
 	@commands.Cog.listener()
-	async def on_raw_member_remove(self, payload):
-		report(self.bot, f"{payload.user} has left {payload.guild_id}")
+	async def on_integration_create(self, integration: discord.Integration):
+		await created_integration(self.bot.pg, integration.user.id)
+
+	@commands.Cog.listener()
+	async def on_member_update(self, before):
+		await member_updated(self.bot.pg, before.id)
+
+	@commands.Cog.listener()
+	async def on_user_update(self, before):
+		await user_updated(self.bot.pg, before.id)
+
+	@commands.Cog.listener()
+	async def on_member_ban(self, guild: discord.Guild, user: discord.User):
+		await member_banned(self.bot.pg, user.id)
+
+	@commands.Cog.listener()
+	async def on_member_unban(self, guild: discord.Guild, user: discord.User):
+		await member_unbanned(self.bot.pg, user.id)
+
+	@commands.Cog.listener()
+	async def on_presence_update(self, before):
+		await presence_updated(self.bot.pg, before.id)
 
 	@commands.Cog.listener()
 	async def on_message(self, message: discord.Message):
 		## ActiveRPG
-		
 		# Create user, if not exists
 		await create_user(self.bot.pg, message.author.id)	
 		
@@ -158,6 +175,49 @@ class General(commands.Cog):
 				]
 				await message.reply(random.choice(messages))
 
+	@commands.Cog.listener()
+	async def on_message_edit(self, before: discord.Message, after: discord.Message):
+		await message_edited(self.bot.pg, before.author.id)
+		if before.guild:
+			if await get_report_edited(self.bot.pg, before.guild.id) and get_output_channel(self.bot.pg, before.guild.id):
+				report(self.bot, before.guild.id, f"Message from {before.author}, in {before.channel} edited from {before.content} to {after.content}")
+
+	@commands.Cog.listener()
+	async def on_message_delete(self, message: discord.Message):
+		await message_deleted(self.bot.pg, message.author.id)
+		if await get_report_deleted(self.bot.pg, message.guild.id):
+			report(self.bot, message.guild_id,
+				   f"Message from {message.author}, in {message.channel} deleted: {message}")
+
+		# !snipe
+		self.last_msg = message
+
+	@commands.Cog.listener()
+	async def on_raw_member_remove(self, payload):
+		report(self.bot, f"{payload.user} has left {payload.guild_id}")
+
+	@commands.Cog.listener()
+	async def on_reaction_add(self, reaction, user):
+		reacted(self.bot.pg, user.id)
+
+	@commands.Cog.listener()
+	async def on_scheduled_event_create(self, event: discord.ScheduledEvent):
+		event_created(self.bot.pg, event.creator.id)
+
+	@commands.Cog.listener()
+	async def on_scheduled_event_user_add(self, event: discord.ScheduledEvent, user):
+		event_joined(self.bot.pg, user.id)
+
+	@commands.Cog.listener()
+	async def on_thread_create(self, thread: discord.Thread):
+		thread_created(self.bot.pg, thread.owner.id)
+
+	@commands.Cog.listener()
+	async def on_thread_member_join(self, member: discord.User):
+		thread_joined(self.bot.pg, member.id)
+
+
+
 	# Undelete last deleted message
 	@commands.command(name="snipe")
 	async def snipe(self, ctx: commands.Context):

bot/query/guild.py

@@ -8,3 +8,6 @@ async def get_output_channel(pg, guild_id):
 
 async def get_report_deleted(pg, guild_id):
 	return await pg.fetchval("SELECT report_deleted FROM guild WHERE guild_id = $1", guild_id)
+
+async def get_report_edited(pg, guild_id):
+	return await pg.fetchval("SELECT report_edited FROM guild WHERE guild_id = $1", guild_id)

bot/query/initialise_database.py

@@ -5,7 +5,8 @@ async def init_db(pg):
                 id SERIAL PRIMARY KEY, \
                 guild_id BIGINT UNIQUE NOT NULL, \
                 output_channel BIGINT REFERENCES channel (channel_id), \
-                report_deleted BOOL DEFAULT FALSE\
+                report_deleted BOOL DEFAULT FALSE, \
+                report_edited BOOL DEFAULT FALSE\
             )\
         ",
         "CREATE TABLE IF NOT EXISTS \
@@ -36,7 +37,22 @@ async def init_db(pg):
                 user_id BIGINT UNIQUE NOT NULL, \
                 ignore BOOL DEFAULT FALSE, \
                 level INT DEFAULT 0, \
-                xp_spent INT DEFAULT 0\
+                xp_spent INT DEFAULT 0, \
+                invites_created INT DEFAULT 0, \
+                integrations_created INT DEFAULT 0, \
+                member_updated INT DEFAULT 0, \
+                user_updated INT DEFAULT 0, \
+                member_banned INT DEFAULT 0, \
+                member_unbanned INT DEFAULT 0, \
+                presence_updated INT DEFAULT 0, \
+                messages_edited INT DEFAULT 0, \
+                messages_deleted INT DEFAULT 0, \
+                reacted INT DEFAULT 0, \
+                events_created INT DEFAULT 0, \
+                events_joined INT DEFAULT 0, \
+                threads_created INT DEFAULT 0, \
+                threads_joined INT DEFAULT 0, \
+                created TIMESTAMP NOT NULL DEFAULT now()\
             )\
         ",
         "CREATE TABLE IF NOT EXISTS \

bot/query/user.py

@@ -14,15 +14,77 @@ async def get_level(pg, user_id):
 	return await pg.fetchval("SELECT level FROM \"user\" WHERE user_id = $1", user_id)
 
 async def get_xp(pg, user_id):
-	message_array = await pg.fetch("SELECT total_messages FROM channel_user WHERE user_id = $1", user_id)
-	print(message_array)
+	message_array = await pg.fetch("SELECT total_messages FROM channel_user WHERE \"user\" = $1", user_id)
 	total_xp = 0
 	for messages in message_array:
-		print(messages)
-		total_xp += messages
+		total_xp += messages[0]
+
+	extras_array = await pg.fetch("SELECT invites_created, integrations_created, member_updated, user_updated, member_banned, member_unbanned, presence_updated, messages_edited, messages_deleted, reacted, events_created, events_joined, threads_created, threads_joined FROM \"user\" WHERE user_id = $1", user_id)
+	invites_created, integrations_created, member_updated, user_updated, member_banned, member_unbanned, presence_updated, messages_edited, messages_deleted, reacted, events_created, events_joined, threads_created, threads_joined = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+	for extra in extras_array:
+		invites_created += extra[0]
+		integrations_created += extra[1]
+		member_updated += extra[2]
+		user_updated += extra[3]
+		member_banned += extra[4]
+		member_unbanned += extra[5]
+		presence_updated += extra[6]
+		messages_edited += extra[7]
+		messages_deleted += extra[8]
+		reacted += extra[9]
+		events_created += extra[10]
+		events_joined += extra[11]
+		threads_created += extra[12]
+		threads_joined += extra[13]
+
+	total_xp += (invites_created * 100) + ((integrations_created + events_created) * 200) + ((member_updated + user_updated + presence_updated + events_joined + threads_joined) * 10) + member_banned + member_unbanned + messages_edited + messages_deleted + (reacted * 2) + (threads_created * 50)
 
 	xp_spent = await pg.fetchval("SELECT xp_spent FROM \"user\" WHERE user_id = $1", user_id)
 	return xp_spent, total_xp
 
 async def level_up(pg, user_id, xp):
-	await pg.execute("UPDATE \"user\" (level, xp_spent) VALUES(+ 1, $2) WHERE user_id = $1", user_id, xp)
+	await pg.execute("UPDATE \"user\" SET (level, xp_spent) = (+ 1, $2) WHERE user_id = $1", user_id, xp)
+
+async def created_invite(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (invites_created) = (+ 1) WHERE user_id = $1", user_id)
+async def invites_created(pg, user_id):
+	return await pg.fetchval("SELECT invites_created FROM \"user\" WHERE user_id = $1", user_id)
+
+async def created_integration(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (integrations_created) = (+ 1) WHERE user_id = $1", user_id)
+
+async def member_updated(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (member_updated) = (+ 1) WHERE user_id = $1", user_id)
+
+async def user_updated(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (user_updated) = (+ 1) WHERE user_id = $1", user_id)
+
+async def member_banned(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (member_banned) = (+ 1) WHERE user_id = $1", user_id)
+
+async def member_unbanned(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (member_unbanned) = (+ 1) WHERE user_id = $1", user_id)
+
+async def presence_updated(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (presence_updated) = (+ 1) WHERE user_id = $1", user_id)
+
+async def message_edited(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (messages_edited) = (+ 1) WHERE user_id = $1", user_id)
+
+async def message_deleted(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (messages_deleted) = (+ 1) WHERE user_id = $1", user_id)
+
+async def reacted(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (reacted) = (+ 1) WHERE user_id = $1", user_id)
+
+async def event_created(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (events_created) = (+ 1) WHERE user_id = $1", user_id)
+
+async def event_joined(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (events_joined) = (+ 1) WHERE user_id = $1", user_id)
+
+async def thread_created(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (threads_created) = (+ 1) WHERE user_id = $1", user_id)
+
+async def thread_joined(pg, user_id):
+	await pg.execute("UPDATE \"user\" SET (threads_joined) = (+ 1) WHERE user_id = $1", user_id)