Publish project to Git

README.md

@@ -0,0 +1,34 @@
+<h1 align="center">
+  AQA Computer Science NEA Project
+  <br>
+</h1>
+
+<p align="center">
+  <a href="https://www.python.org/downloads/">
+    <img src=https://img.shields.io/badge/made%20with-python%203.8-blue" alt="Made with Python 3.8">
+  </a>
+  <a href="https://github.com/Rapptz/discord.py/">
+      <img src="https://img.shields.io/badge/discord-py-blue" alt="discord.py">
+  </a>
+  <!---<a href="https://github.com/vzhou842/profanity-check">
+    <img src="https://img.shields.io/badge/profanity--check-1.0.3-blue" alt="profanity-check-">
+  </a>--->
+</p>
+
+# Overview
+
+This repository contains all of the code used in my AQA Computer Science NEA Project. The project's objective is to create a Discord bot in [Python](https://www.python.org) using the [discord.py](https://github.com/Rapptz/discord.py) API wrapper.
+
+**Features include:**
+
+- [x] Moderation (kick/ban/unban, chat cleaner, warnings, announcements)
+- [x] Integrations (Steam data integration, Riot Games data integration)
+- [x] Full database storage (messages, guild info e.g. prefix, bad manners)
+- [x] Member join and leave notifications
+- [x] Simple commands (coinflip, dice roll, latency)
+- [x] All commands stored using Cogs
+- [x] Music playback from YouTube
+- [ ] Simple GUI to interact with stored data
+- [ ] Alerts (Twitch, Youtube, Mixer)
+- [ ] Custom commands (using data from database)
+- [ ] Admin automation (self-role assignment, cross-server announcements, mod-mail reports)

bot.py

@@ -0,0 +1,43 @@
+import discord
+import os
+from discord.ext import commands
+
+PREFIX = "!"
+VERSION = "1.0"
+
+bot = commands.Bot(command_prefix = PREFIX, case_insensitive=True, self_bot = False, description = f"Help Dialog Box")
+
+#Load commands for Cog files
+@bot.command(brief="Load specified cog", description="Loads the specified cog from the folder of cogs.")
+@commands.is_owner()#@commands.has_role("Owner")
+async def load(ctx, extension): #Load command
+    bot.load_extension(f"cogs.{extension}")
+
+@bot.command(brief="Unload specified cog", description="Unloads the specified cog from the folder of cogs.")
+@commands.is_owner()
+async def unload(ctx, extension):#Unload command
+    bot.unload_extension(f"cogs.{extension}")
+
+@bot.command(brief="Reload specified cog", description="Unloads and loads the specified cog from the folder of cogs.")
+@commands.is_owner()
+async def reload(ctx, extension):#Reload command
+    bot.unload_extension(f"cogs.{extension}")
+    bot.load_extension(f"cogs.{extension}")
+
+#Read all Cog files in.
+for filename in os.listdir("./cogs"):
+    if filename.endswith(".py"):
+        bot.load_extension(f"cogs.{filename[:-3]}")
+
+#Commands
+@bot.command(brief="Shows info about the bot", description="Shows info about the bot.")
+async def info(ctx):
+    embed = discord.Embed(title=f"{bot.user.name}", description=f"Made by **Troy#7760**")
+    embed.add_field(name="Version:", value=(f"{VERSION}"))
+    embed.add_field(name="Help:", value=(f"Use `{PREFIX} + help` to get started"))
+    embed.colour = (0xfb5246)
+    #embed.colour = random.randint(0, 0xffffff)#Gives the embed box a random colour everytime.
+    embed.set_footer(text="troylusty.com", icon_url="https://pbs.twimg.com/profile_images/1218306285382307841/ur9_dCej_400x400.jpg")
+    await ctx.send(content=None, embed=embed)
+
+bot.run("")#Secret token which is unique used to run code on the bot.

cogs/audio.py

@@ -0,0 +1,109 @@
+import discord
+import os
+import youtube_dl
+from discord.ext import commands
+from discord.utils import get
+
+players = {}
+
+class Audio(commands.Cog):
+
+    def __init__(self, bot):
+        self.bot = bot
+
+    @commands.command(aliases=["j"], brief="Bot joins the channel", description="Bot joins the channel the message authour is currently in.")
+    async def join(self, ctx):
+        global voice
+        channel = ctx.message.author.voice.channel
+        voice = get(self.bot.voice_clients, guild=ctx.guild)
+        if voice and voice.is_connected():
+            await voice.move_to(channel)
+        else:
+            voice = await channel.connect()
+        await ctx.send(f"joined {channel}")
+
+    @commands.command(aliases=["l"], brief="Bot leaves the channel", description="Bot leaves the channel.")
+    async def leave(self, ctx):
+        channel = ctx.message.author.voice.channel
+        voice = get(self.bot.voice_clients, guild=ctx.guild)
+        if voice and voice.is_connected():
+            await voice.disconnect()
+            await ctx.send(f"left {channel}")
+        else:
+            await ctx.send(f"not in any voice channel")
+
+    @commands.command(aliases=["p", "pla"], brief="Play audio from YouTube video.", description="Play audio from specified YouTube video.")
+    async def play(self, ctx, url : str):
+        song_there = os.path.isfile("song.mp3")
+        try:
+            if song_there:
+                os.remove("song.mp3")
+                print("removed old song file")
+        except PermissionError:
+            print("tried to delete old song file")
+            await ctx.send(f"error music playing")
+            return
+        await ctx.send(f"getting ready")
+        voice = get(self.bot.voice_clients, guild=ctx.guild)
+        ydl_opts = {
+            'format': 'bestaudio/best',
+            'quiet': True,
+            'postprocessors': [{
+                'key': 'FFmpegExtractAudio',
+                'preferredcodec': 'mp3',
+                'preferredquality': '192',
+            }],
+        }
+        with youtube_dl.YoutubeDL(ydl_opts) as ydl:
+            print(f"downloading audio")
+            ydl.download([url])
+        for file in os.listdir("./"):
+            if file.endswith(".mp3"):
+                name = file
+                print(f"renamed audio file {file}")
+                os.rename(file, "song.mp3")
+        voice.play(discord.FFmpegPCMAudio("song.mp3"), after=lambda e: print(f"{name} has finished playing"))#If song is done do function `e`.
+        voice.source = discord.PCMVolumeTransformer(voice.source)
+        voice.source.volume = 0.33
+        nnname = name.rsplit("-", 2)
+        await ctx.send(f"playing {nnname[0]}")
+        print("playing")
+        """
+        https://youtu.be/Bp9SZYqIWIM
+        """
+
+    @commands.command(aliases=["pau"], brief="Pause song", description="Pause currently playing song.")
+    async def pause(self, ctx):
+        voice = get(self.bot.voice_clients, guild=ctx.guild)
+        if voice and voice.is_playing():
+            print(f"music paused")
+            voice.pause()
+            await ctx.send(f"music paused")
+        else:
+            print("music not playing")
+            await ctx.send("music not playing failed to pause")
+
+    @commands.command(aliases=["r"], brief="Resume song", description="Resume paused song.")
+    async def resume(self, ctx):
+        voice = get(self.bot.voice_clients, guild=ctx.guild)
+        if voice and voice.is_paused():
+            print(f"music resumed")
+            voice.resume()
+            await ctx.send(f"music resumed")
+        else:
+            print("music not paused")
+            await ctx.send("music not paused")
+
+    @commands.command(aliases=["s"], brief="Stop playing all songs", description="Stop playing all songs and clear queues.")
+    async def stop(self, ctx):
+        voice = get(self.bot.voice_clients, guild=ctx.guild)
+        if voice and voice.is_playing():
+            print(f"music stopped")
+            voice.stop()
+            await ctx.send(f"music stopped")
+        else:
+            print("music not playing failed to stop")
+            await ctx.send("music not playing failed to stop")
+
+def setup(bot):
+    bot.add_cog(Audio(bot))

cogs/default.py

@@ -0,0 +1,28 @@
+import random
+from discord.ext import commands
+
+class Default(commands.Cog):
+
+    def __init__(self, bot):
+        self.bot = bot
+
+    @commands.command(aliases=["flip"], brief="Flips a coin", description="Generates a random number between 0 and 1. If 0 is generated Heads is returned and if 1 is generated Tails is returned.")
+    async def coin(self, ctx):
+        zeroOrOne = random.randint(0,1)
+        if zeroOrOne == 0:
+            result = "Heads"
+        else:
+            result = "Tails"
+        await ctx.send(f"It's {result}")
+
+    @commands.command(aliases=["roll"], brief="Rolls a dice", description="Generates a random number between 1 and 6 then returns the value.")
+    async def dice(self, ctx):
+        roll = random.randint(1, 6)#Generate a random number between 1 and 6.
+        await ctx.send(f"I've rolled a {roll} :game_die:")#Used an f-string to easily format the string since it makes it easier to add more variables and other values.
+
+    @commands.command(aliases=["ping"], brief="Displays the bot's latency", description="Uses bot.latency to display the latency of the bot.")
+    async def latency(self, ctx):
+        await ctx.send(f"{round(self.bot.latency * 1000)}ms :alarm_clock:")
+
+def setup(bot):
+    bot.add_cog(Default(bot))

cogs/integrations.py

@@ -0,0 +1,313 @@
+import discord
+import json
+import time
+import urllib.request
+from discord.ext import commands
+
+logins = {
+    "steam": {
+        "api-key": "",
+    },
+    "riot": {
+        "api-key": "",
+    }
+}
+
+
+def most_frequent(List):
+    counter = 0
+    num = List[0]
+    for i in List:
+        curr_frequency = List.count(i)
+        if (curr_frequency > counter):
+            counter = curr_frequency
+            num = i
+    return num
+
+
+class Integrations(commands.Cog):
+
+    def __init__(self, bot):
+        self.bot = bot
+
+    @commands.command(brief="Steam user's ban info", description="Uses the Steam API to return a specified users detailed ban status.")
+    async def steambans(self, ctx, *, steamID64=""):
+        steamWebApiKey = logins["steam"]["api-key"]
+        try:
+            with urllib.request.urlopen(
+                    f"http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key={steamWebApiKey}&steamids={steamID64}") as url:
+                playerSummaries = json.loads(url.read().decode())
+            try:
+                personaname = playerSummaries['response']['players'][0]['personaname']
+            except:
+                personaname = "*data not found*"
+            try:
+                realname = playerSummaries['response']['players'][0]['realname']
+            except:
+                realname = "*data not found*"
+            try:
+                avatarfull = playerSummaries['response']['players'][0]['avatarfull']
+            except:
+                avatarfull = "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/b5/b5bd56c1aa4644a474a2e4972be27ef9e82e517e_full.jpg"
+            try:
+                profileurl = playerSummaries['response']['players'][0]['profileurl']
+            except:
+                profileurl = f"https://steamcommunity.com/profiles/{steamID64}"
+        except:
+            personaname, realname, avatarfull, profileurl = "*data not loaded*", "*data not loaded*", "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/b5/b5bd56c1aa4644a474a2e4972be27ef9e82e517e_full.jpg", f"https://steamcommunity.com/profiles/{steamID64}"
+        try:
+            with urllib.request.urlopen(
+                    f"http://api.steampowered.com/ISteamUser/GetPlayerBans/v1/?key={steamWebApiKey}&steamids={steamID64}") as url:
+                getPlayerBans = json.loads(url.read().decode())
+            try:
+                communityBanned = getPlayerBans['players'][0]['CommunityBanned']
+            except:
+                communityBanned = "*data not found*"
+            try:
+                vacBanned = getPlayerBans['players'][0]['VACBanned']
+            except:
+                vacBanned = "*data not found*"
+            try:
+                numberOfVACBans = getPlayerBans['players'][0]['NumberOfVACBans']
+            except:
+                numberOfVACBans = "*data not found*"
+            try:
+                daysSinceLastBan = getPlayerBans['players'][0]['DaysSinceLastBan']
+            except:
+                daysSinceLastBan = "*data not found*"
+            try:
+                numberOfGameBans = getPlayerBans['players'][0]['NumberOfGameBans']
+            except:
+                numberOfGameBans = "*data not found*"
+            try:
+                economyBan = getPlayerBans['players'][0]['EconomyBan']
+            except:
+                economyBan = "*data not found*"
+        except:
+            communityBanned, vacBanned, numberOfVACBans, daysSinceLastBan, numberOfGameBans, economyBan = "*data not loaded*", "*data not loaded*", "*data not loaded*", "*data not loaded*", "*data not loaded*", "*data not loaded*"
+        embed = discord.Embed(title="Steam Bans Check", description="")
+        embed.set_image(url=f"{avatarfull}")
+        embed.add_field(name="Username", value=f"{personaname}")
+        embed.add_field(name="Real name", value=f"{realname}")
+        embed.add_field(name="Profile url", value=f"{profileurl}")
+        embed.add_field(name="VAC", value=f"{vacBanned}")
+        embed.add_field(name="Number of VAC bans", value=f"{numberOfVACBans}")
+        embed.add_field(name="Days since last ban", value=f"{daysSinceLastBan}")
+        embed.add_field(name="Number of game bans", value=f"{numberOfGameBans}")
+        embed.add_field(name="Community banned", value=f"{communityBanned}")
+        embed.add_field(name="Economy ban", value=f"{economyBan}")
+        embed.colour = (0x5dcff6)
+        embed.set_footer(text="Steam",
+                         icon_url="https://upload.wikimedia.org/wikipedia/commons/thumb/8/83/Steam_icon_logo.svg/2000px-Steam_icon_logo.svg.png")
+        await ctx.send(content=None, embed=embed)
+
+    @commands.command(aliases=["csgo", "cs"], brief="CS:GO stats info", description="Uses the Steam API to return and calculate a specified users Counter-Strike: Global Offensive statistics.")
+    async def csgostats(self, ctx, *, steamID64=""):
+        steamWebApiKey = logins["steam"]["api-key"]
+        try:
+            with urllib.request.urlopen(f"http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key={steamWebApiKey}&steamids={steamID64}") as url:
+                playerSummaries = json.loads(url.read().decode())
+            try:
+                personaname = playerSummaries['response']['players'][0]['personaname']
+            except:
+                personaname = "*data not found*"
+            try:
+                realname = playerSummaries['response']['players'][0]['realname']
+            except:
+                realname = "*data not found*"
+            try:
+                avatarfull = playerSummaries['response']['players'][0]['avatarfull']
+            except:
+                avatarfull = "*data not found*"
+            try:
+                profileurl = playerSummaries['response']['players'][0]['profileurl']
+            except:
+                profileurl = "*data not found*"
+        except:
+            personaname, realname, avatarfull, profileurl = "*data not loaded*", "*data not loaded*", "https://steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/b5/b5bd56c1aa4644a474a2e4972be27ef9e82e517e_full.jpg", f"https://steamcommunity.com/profiles/{steamID64}"
+        try:
+            with urllib.request.urlopen(f"http://api.steampowered.com/ISteamUserStats/GetUserStatsForGame/v0002/?appid=730&key={steamWebApiKey}&steamid={steamID64}") as url:
+                getUserStatsForGame = json.loads(url.read().decode())
+            playerstats = getUserStatsForGame["playerstats"]
+            stats = playerstats["stats"]
+            for i in range(len(stats)):
+                if stats[i]['name'] == "total_kills":
+                    totalKills = stats[i]['value']
+                if stats[i]['name'] == "total_deaths":
+                    totalDeaths = stats[i]['value']
+                if stats[i]['name'] == "total_time_played":
+                    totalTimePlayed = stats[i]['value']
+                if stats[i]['name'] == "total_wins":
+                    totalWins = stats[i]['value']
+                if stats[i]['name'] == "total_kills_headshot":
+                    totalKillsHeadshot = stats[i]['value']
+                if stats[i]['name'] == "total_shots_fired":
+                    totalShotsFired = stats[i]['value']
+                if stats[i]['name'] == "total_shots_hit":
+                    totalShotsHit = stats[i]['value']
+                if stats[i]['name'] == "total_mvps":
+                    totalMvps = stats[i]['value']
+            killToDeath = round((totalKills / totalDeaths), 2)
+            accuracy = round((totalShotsHit / totalShotsFired * 100), 2)
+            headshotPercentage = round((totalKillsHeadshot / totalKills * 100), 2)
+            totalTimePlayed = round(totalTimePlayed / 3600)
+        except:
+            killToDeath, totalKills, totalTimePlayed, accuracy, headshotPercentage, totalMvps = "*data not loaded*", "*data not loaded*", "*data not loaded*", "*data not loaded*", "*data not loaded*", "*data not loaded*"
+        try:
+            data = {}
+            for i in range(len(stats)):
+                if stats[i]['name'].startswith("total_kills_"):
+                    data[f"{stats[i]['name']}"] = int(f"{stats[i]['value']}")
+            try:
+                data.pop("total_kills_knife")
+            except:
+                error = True
+            try:
+                data.pop("total_kills_hegrenade")
+            except:
+                error = True
+            try:
+                data.pop("total_kills_headshot")
+            except:
+                error = True
+            try:
+                data.pop("total_kills_enemy_weapon")
+            except:
+                error = True
+            try:
+                data.pop("total_kills_enemy_blinded")
+            except:
+                error = True
+            try:
+                data.pop("total_kills_knife_fight")
+            except:
+                error = True
+            try:
+                data.pop("total_kills_against_zoomed_sniper")
+            except:
+                error = True
+            try:
+                data.pop("total_kills_molotov")
+            except:
+                error = True
+            try:
+                data.pop("total_kills_taser")
+            except:
+                error = True
+            data = {k: v for k, v in sorted(data.items(), key=lambda item: item[1], reverse=True)} # Sort weapons into most used
+            dict_items = data.items()
+            values = list(dict_items)[:5] # Cut to the top 5 most used
+            for i in range(0, len(values)): # Save stats to easily referenceable variables
+                if i == 0:
+                    ak47 = values[i][1]
+                elif i == 1:
+                    awp = values[i][1]
+                elif i == 2:
+                    m4a1 = values[i][1]
+                elif i == 3:
+                    deagle = values[i][1]
+                elif i == 4:
+                    hkp2000 = values[i][1]
+        except:
+            error = True
+        if error == True:
+            print(f"error is true")
+        try:
+            with urllib.request.urlopen(
+                    f"http://api.steampowered.com/ISteamUser/GetPlayerBans/v1/?key={steamWebApiKey}&steamids={steamID64}") as url:
+                getPlayerBans = json.loads(url.read().decode())
+            try:
+                vacBanned = getPlayerBans['players'][0]['VACBanned']
+            except:
+                vacBanned = "*data not found*"
+        except:
+            vacBanned = "*data not loaded*"
+        embed = discord.Embed(title="CS:GO Stats", description="")
+        embed.set_image(url=f"{avatarfull}")
+        embed.add_field(name="Username", value=f"{personaname}")
+        embed.add_field(name="Real name", value=f"{realname}")
+        embed.add_field(name="Profile url", value=f"{profileurl}")
+        embed.add_field(name="VAC", value=f"{vacBanned}")
+        embed.add_field(name="K/D", value=f"{killToDeath}")
+        embed.add_field(name="Total Kills", value=f"{totalKills}")
+        embed.add_field(name="Time Played", value=f"{totalTimePlayed} hours")
+        #embed.add_field(name="Win Percentage", value=f"")
+        embed.add_field(name="Accuracy", value=f"{accuracy}%")
+        embed.add_field(name="Headshot Percentage", value=f"{headshotPercentage}%")
+        embed.add_field(name="MVPs", value=f"{totalMvps}")
+        embed.add_field(name="Total Weapon Kills", value=f"AK-47: {ak47}, M4A1: {m4a1}, AWP: {awp}, DEAGLE: {deagle}, HKP2000: {hkp2000}")
+        embed.colour = (0xf99d1c)
+        embed.set_footer(text="Counter-Strike: Global Offensive", icon_url="http://i.imgur.com/JP5mOFP.png")
+        await ctx.send(content=None, embed=embed)
+
+    @commands.command(brief="UNFINISHED - League of Legends Stats", description="League of Legends Stats")
+    async def lol(self, ctx, name, region="DEFAULT"):
+        print(region.casefold())
+        start = time.time()
+        riotGamesApiKey = logins["riot"]["api-key"]
+        regions = ["BR1", "EUN1", "EUW1", "JP1", "KR", "LA1", "LA2", "NA1", "OC1", "TR1", "RU"]
+        if region == "DEFAULT":
+            for i in range(0, len(regions)):
+                try:
+                    with urllib.request.urlopen(
+                            f"https://{regions[i].casefold()}.api.riotgames.com/lol/summoner/v4/summoners/by-name/{name.casefold()}?api_key={riotGamesApiKey}") as url:
+                        data = json.loads(url.read().decode())
+                        print(f"FOUND {regions[i]}")
+                        correctRegion = regions[i].casefold()
+                        if data == None:
+                            break  # Stop searching through the regions if one has been found
+                except:
+                    print(f"NOT FOUND {regions[i]}")
+        else:
+            try:
+                print(f"{region, name, riotGamesApiKey}")
+                print(
+                    f"https://{region.casefold()}.api.riotgames.com/lol/summoner/v4/summoners/by-name/{name.casefold()}?api_key={riotGamesApiKey}")
+                with urllib.request.urlopen(
+                        f"https://{region.casefold()}.api.riotgames.com/lol/summoner/v4/summoners/by-name/{name.casefold()}?api_key={riotGamesApiKey}") as url:
+                    data = json.loads(url.read().decode())
+                    correctRegion = region.casefold()
+            except:
+                print(f"error")
+        name = data["name"]
+        accountId = data["accountId"]
+        summonerLevel = data["summonerLevel"]
+        profileIconId = data["profileIconId"]
+        try:
+            with urllib.request.urlopen(
+                    f"https://{correctRegion.casefold()}.api.riotgames.com/lol/match/v4/matchlists/by-account/{accountId}?api_key={riotGamesApiKey}") as url:
+                data2 = json.loads(url.read().decode())
+        except:
+            print("error2")
+        lane = []
+        for i in range(0, len(data2)):
+            lane.append(data2["matches"][i]["lane"])
+        role = []
+        for i in range(0, len(data2)):
+            role.append(data2["matches"][i]["role"])
+        champion = []
+        for i in range(0, len(data2)):
+            champion.append(data2["matches"][i]["champion"])
+        totalGames = data2["totalGames"]
+        embed = discord.Embed(title="League of Legends Stats", description="")
+        embed.add_field(name="Name", value=f"{name}")
+        embed.add_field(name="Region", value=f"{correctRegion}")
+        # embed.add_field(name="Account ID", value=f"{accountId}")
+        embed.add_field(name="Summoner Level", value=f"{summonerLevel}")
+        embed.add_field(name="Favourite Lane", value=f"{most_frequent(lane)}")
+        embed.add_field(name="Favourite Role", value=f"{most_frequent(role)}")
+        embed.add_field(name="Favourite Champion", value=f"{most_frequent(champion)}")
+        embed.add_field(name="Total Games", value=f"{totalGames}")
+        embed.colour = (0xc28f2c)
+        embed.set_footer(text="League of Legends",
+                         icon_url="https://pbs.twimg.com/profile_images/1229450306343145472/eOInxRFz_400x400.png")
+        end = time.time()
+        embed.add_field(name="Time Taken", value=f"{round(end - start)} second(s)")
+        await ctx.send(content=None, embed=embed)
+
+    @commands.command(brief="UNRELEASED - Valorant Stats", description="Valorant Stats")
+    async def valorant(self, ctx, name="DEFAULT", region="DEFAULT"):
+        await ctx.send(f"GAME NOT RELEASED YET")
+
+def setup(bot):
+    bot.add_cog(Integrations(bot))

cogs/listeners.py

@@ -0,0 +1,118 @@
+import datetime
+import discord
+import os
+import sqlite3
+from discord.ext import commands
+from profanity_check import predict
+
+DBFILENAME = "bot.db"
+
+def createDB():
+    if os.path.isfile(DBFILENAME):
+        db = sqlite3.connect(DBFILENAME)
+    else:
+        db = sqlite3.connect(DBFILENAME)
+        print(f"File didn't exist. Created file: {DBFILENAME}")
+        cursor = db.cursor()
+        cursor.execute("CREATE TABLE if not exists guilds (id INTEGER, prefix TEXT, PRIMARY KEY (id))")
+        cursor.execute("CREATE TABLE if not exists messages (date TEXT, time TEXT, message TEXT, details TEXT, user INTEGER, guild INTEGER, link TEXT, bool INTEGER, PRIMARY KEY (date, time), FOREIGN KEY (user) REFERENCES users (user), FOREIGN KEY (guild) REFERENCES guilds (id))")
+        cursor.execute("CREATE TABLE if not exists users (user INTEGER, username TEXT, total INTEGER, profanity INTEGER, PRIMARY KEY (user))")
+        db.commit()
+    db.close()
+
+class Listeners(commands.Cog):
+
+    def __init__(self, bot):
+        self.bot = bot
+
+    @commands.Cog.listener()
+    async def on_ready(self):
+        try:
+            createDB()#Run createDB. This will check for the database and tables. If they don't exist they will be created.
+            print(f"Bot is ready (createDB successful)")
+            print(f"Name: {self.bot.user.name}\nID: {self.bot.user.id}")  # Prints the bots username (e.g. Bot#1111) and prints out the user id of the bot (e.g. 58492482649273613).
+            await self.bot.change_presence(status=discord.Status.dnd, activity=discord.Activity(type=discord.ActivityType.watching, name=f"in {len(self.bot.guilds)} guild(s) with {len(set(self.bot.get_all_members()))} members"))
+        except:
+            print(f"Bot is ready (createDB failed)")
+            print (f"Name: {self.bot.user.name}\nID: {self.bot.user.id}")#Prints the bots username (e.g. Bot#1111) and prints out the user id of the bot (e.g. 58492482649273613).
+            await self.bot.change_presence(status=discord.Status.dnd, activity=discord.Activity(type=discord.ActivityType.watching, name=f"in {len(self.bot.guilds)} guild(s) with {len(set(self.bot.get_all_members()))} members"))
+
+    @commands.Cog.listener()
+    async def on_member_join(self, member):
+        channel = member.guild.system_channel
+        if channel is not None:
+            await channel.send(f"Hey {member.mention} :wave:")
+
+    @commands.Cog.listener()
+    async def on_member_remove(self, guild):
+        channel = member.guild.system_channel
+        if channel is not None:
+            await channel.send(f"Bye {member.mention} :cry:")
+
+    @commands.Cog.listener()
+    async def on_message(self, message):
+        if message.author == self.bot.user:
+            return
+        else:
+            messageLink = f"https://discordapp.com/channels/{message.guild.id}/{message.channel.id}/{message.id}"
+            if message.content != "":  # Checks if the message contains content. (Stops server messages being registered)
+                db = sqlite3.connect(DBFILENAME)  # Add guild to guilds table
+                cursor = db.cursor()
+                cursor.execute("SELECT id FROM guilds WHERE id=?", (message.guild.id,))
+                guildResult = cursor.fetchone()
+                if guildResult:
+                    # Does exist
+                    db.close()
+                else:
+                    # Doesn't exist
+                    cursor.execute("INSERT INTO guilds(id, prefix) VALUES(?,?)", (message.guild.id, "!"))
+                    db.commit()
+                    db.close()
+                db = sqlite3.connect(DBFILENAME)#Open the database
+                cursor = db.cursor()
+                cursor.execute("SELECT user FROM users WHERE user=?", (message.author.id,))#Select `user` to see if the value exists
+                userResult = cursor.fetchone()
+                if userResult:
+                    #User does exist
+                    cursor.execute("SELECT total FROM users WHERE user=?", (message.author.id,))#Select the total from the user
+                    totalResult = cursor.fetchone()
+                    totalResult = int(totalResult[0])
+                    totalResult += 1#Add 1 to the total (messages) count
+                    if predict([f"{message.content}"]) == [1]:#If message contains profanity [1] will be returned
+                        cursor.execute("SELECT profanity FROM users WHERE user=?", (message.author.id,))#Select the total profanity from the user
+                        totalProfanity = cursor.fetchone()
+                        totalProfanity = int(totalProfanity[0])
+                        totalProfanity += 1#Add 1 to the total profanity count
+                        cursor.execute("UPDATE users SET profanity=? WHERE user=?", (totalProfanity, message.author.id))
+                        cursor.execute("UPDATE users SET total=? WHERE user=?", (totalResult, message.author.id))#Add the new total value into the table
+                        cursor.execute("UPDATE users SET username=? WHERE user=?", (message.author.name, message.author.id))
+                        dateTime = datetime.datetime.now()
+                        time = str(dateTime.strftime("%X")) + ":" + str((dateTime.strftime("%f")))
+                        cursor.execute("INSERT INTO messages(date, time, message, details, user, guild, link, bool) VALUES(?,?,?,?,?,?,?,?)", (str(dateTime.strftime("%x")), (time), str(message.content), str(message), int(message.author.id), int(message.guild.id), str(messageLink), int(1)))
+                    else:
+                        cursor.execute("UPDATE users SET total=? WHERE user=?", (totalResult, message.author.id))#Add the new total value into the table
+                        cursor.execute("UPDATE users SET username=? WHERE user=?", (message.author.name, message.author.id))
+                        dateTime = datetime.datetime.now()
+                        time = str(dateTime.strftime("%X")) + ":" + str((dateTime.strftime("%f")))
+                        cursor.execute("INSERT INTO messages(date, time, message, details, user, guild, link, bool) VALUES(?,?,?,?,?,?,?,?)", (str(dateTime.strftime("%x")), (time), str(message.content), str(message), int(message.author.id), int(message.guild.id), str(messageLink), int(0)))
+                    db.commit()
+                else:
+                    #User doesn't exist
+                    if predict([f"{message.content}"]) == [1]:#If message contains profanity [1] will be returned
+                        cursor.execute("INSERT INTO users(user, username, total, profanity) VALUES(?,?,?,?)", (message.author.id, message.author.name, 1, 1))#Adds the user into the table and adds a value of 1 as the total
+                        dateTime = datetime.datetime.now()
+                        time = str(dateTime.strftime("%X")) + ":" + str((dateTime.strftime("%f")))
+                        cursor.execute("INSERT INTO messages(date, time, message, details, user, guild, link, bool) VALUES(?,?,?,?,?,?,?,?)", (str(dateTime.strftime("%x")), (time), str(message.content), str(message), int(message.author.id), int(message.guild.id), str(messageLink), int(0)))
+                    else:
+                        cursor.execute("INSERT INTO users(user, username, total, profanity) VALUES(?,?,?,?)", (message.author.id, message.author.name, 1, 0))#Adds the user into the table and adds a value of 1 as the total
+                        dateTime = datetime.datetime.now()
+                        time = str(dateTime.strftime("%X")) + ":" + str((dateTime.strftime("%f")))
+                        cursor.execute("INSERT INTO messages(date, time, message, details, user, guild, link, bool) VALUES(?,?,?,?,?,?,?,?)", (str(dateTime.strftime("%x")), (time), str(message.content), str(message), int(message.author.id), int(message.guild.id), str(messageLink), int(0)))
+                    db.commit()
+                    db.close()
+                #await self.bot.process_commands(message)
+            else:
+                return
+
+def setup(bot):
+    bot.add_cog(Listeners(bot))

cogs/management.py

@@ -0,0 +1,87 @@
+import discord
+import sqlite3
+from discord.ext import commands
+
+DBFILENAME = "bot.db"
+
+class Management(commands.Cog):
+
+    def __init__(self, bot):
+        self.bot = bot
+
+    #Commands
+    @commands.command(aliases=["purge", "clear"], brief="Cleans messages from channel", description="Clears either 1 or a user set amount of messages from the channel the command was called within.")
+    @commands.has_permissions(manage_messages=True)
+    async def clean(self, ctx, *, amount=1):
+        await ctx.channel.purge(limit=int(amount) + 1)
+
+    @commands.command(brief="Kicks user", description="Removes a specified user from the server. They can re-join if they have an invite link.")
+    @commands.has_permissions(kick_members=True)#@commands.has_any_role("Owner", "Moderator")
+    async def kick(self, ctx, member : discord.Member, *, reason=None):
+        await member.kick(reason=reason)
+
+    @commands.command(brief="Ban user", description="Removes a specified user from the server. They will be unable to re-join until they have been unbanned.")
+    @commands.has_permissions(ban_members=True)
+    async def ban(self, ctx, member : discord.Member, *, reason=None):
+        await member.ban(reason=reason)
+
+    @commands.command(brief="Unban user", description="Removes a specified user from the servers list of banned users. Allowing them to re-join the server with an invite link.")
+    @commands.has_permissions(ban_members=True)
+    async def unban(self, ctx, *, member):
+        banned_users = await ctx.guild.bans()
+        member_name, member_discriminator = member.split("#")
+        for ban_entry in banned_users:
+            user = ban_entry.user
+            if (user.name, user.discriminator) == (member_name, member_discriminator):
+                await ctx.guild.unban(user)
+
+    @commands.command(aliases=["a"], brief="Echo messsage", description="The bot will echo the text following the command also deleting the message used to call the commmand.")
+    @commands.has_permissions(manage_messages = True)
+    async def announcement(self, ctx, *, message=""):
+        await ctx.message.channel.purge(limit=1)
+        await ctx.send(f"{message}")
+
+    @commands.command(brief="Warn user", description="Sends a warning message with reasoning to the specified user.")
+    @commands.has_permissions(manage_messages = True)
+    async def warn(self, ctx, member : discord.Member, *, reason=None):
+        await ctx.message.channel.purge(limit=1)
+        #await member.send(f"**WARNING** from {ctx.message.author.mention}:\n{reason}")
+        embed = discord.Embed(title=f"**WARNING** from", description=f"{ctx.message.author.mention}")
+        embed.add_field(name="Reason:", value=(f"{reason}"))
+        embed.colour = (0xff0000)
+        await member.send(content=None, embed=embed)
+
+    @commands.command(brief="User messages", description="Check specified users profanity rating.")
+    @commands.has_permissions(manage_messages=True)
+    async def messages(self, ctx, member: discord.Member):
+        db = sqlite3.connect(DBFILENAME)#Open the database
+        cursor = db.cursor()
+        cursor.execute("SELECT total FROM users WHERE user=?", (member.id,))#Select mentioned user to see if the value exists
+        totalResult = cursor.fetchone()
+        totalResult = int(totalResult[0])
+        cursor.execute("SELECT profanity FROM users WHERE user=?", (member.id,))#Select mentioned user to see if the value exists
+        profanityResult = cursor.fetchone()
+        profanityResult = int(profanityResult[0])
+        profanityPercent = round((profanityResult / totalResult * 100), 2)
+        cursor.execute("SELECT message FROM messages WHERE bool=? AND user=?", (1, member.id))
+        messageResult = cursor.fetchall()
+        db.close()
+        if not messageResult: #if messageResult is empty
+            allMessages = "No messages to show"
+        else:
+            messageResult = messageResult[-5:]#Only select the last 5 messages which contained profanity
+            allMessages = ""
+            for i in range(0, len(messageResult)):
+                allMessages += str(messageResult[i])
+            allMessages = allMessages.replace("(", "")
+            allMessages = allMessages.replace(")", "")
+            allMessages = allMessages.replace(",", " ")
+        embed = discord.Embed(title="Messages", description="")
+        embed.add_field(name="Total", value=f"{totalResult}")
+        embed.add_field(name="Profanity", value=f"{profanityResult}")
+        embed.add_field(name="Profanity %", value=f"{profanityPercent}")
+        embed.add_field(name="Recent rude messages", value=f"{allMessages}")
+        await ctx.send(content=None, embed=embed)
+
+def setup(bot):
+    bot.add_cog(Management(bot))

gui.py

@@ -0,0 +1,139 @@
+import sqlite3
+from tkinter import *
+
+DBFILENAME = "bot.db"
+
+#USE JOIN STATEMENT
+#NAME AND ALL MESSAGES
+
+def runGUI():
+    window = Tk()
+    #window.title(f"{self.bot.user.name} - {self.bot.user.id}")
+    window.title("Discord")
+    window.geometry("600x200")
+
+    txt = Entry(window, width=10)
+    txt.grid(column=0, row=0)
+
+    txt2 = Entry(window, width=10)
+    txt2.grid(column=3, row=0)
+
+    def clicked():
+        db = sqlite3.connect(DBFILENAME)
+        cursor = db.cursor()
+        try:
+            cursor.execute("SELECT total FROM users WHERE user=?", (txt.get(),))
+            totalResult = cursor.fetchone()
+            totalResult = int(totalResult[0])
+        except:
+            totalResult = "error"
+        try:
+            cursor.execute("SELECT profanity FROM users WHERE user=?", (txt.get(),))
+            profanityResult = cursor.fetchone()
+            profanityResult = int(profanityResult[0])
+            try:
+                percentageProfanity = round((profanityResult / totalResult * 100), 2)
+            except:
+                percentageProfanity = "error"
+        except:
+            profanityResult = "error"
+            percentageProfanity = "error"
+        try:
+            cursor.execute("SELECT message FROM messages WHERE bool=? AND user=?", (1, txt.get(),))
+            profanityMessagesResult = cursor.fetchall()
+            profanityMessagesResult = profanityMessagesResult[-5:]
+            allMessages = ""
+            for i in range(0, len(profanityMessagesResult)):
+                allMessages += str(profanityMessagesResult[i])
+            allMessages = allMessages.replace("(", "")
+            allMessages = allMessages.replace(")", "")
+            allMessages = allMessages.replace(",", " ")
+        except:
+            allMessages = "error"
+        db.close()
+        resT = f"Total: {totalResult}"
+        total.configure(text=resT)
+        resP = f"Profanity: {profanityResult}"
+        profanity.configure(text=resP)
+        resPERC = f"Percentage: {percentageProfanity}%"
+        percentage.configure(text=resPERC)
+        resTPM = f"Recent profanity: {allMessages}"
+        recentprofanity.configure(text=resTPM)
+
+    def clicked2():
+        db = sqlite3.connect(DBFILENAME)
+        cursor = db.cursor()
+        try:
+            cursor.execute("SELECT total FROM users WHERE user=?", (txt2.get(),))
+            totalResult = cursor.fetchone()
+            totalResult = int(totalResult[0])
+        except:
+            totalResult = "error"
+        try:
+            cursor.execute("SELECT profanity FROM users WHERE user=?", (txt2.get(),))
+            profanityResult = cursor.fetchone()
+            profanityResult = int(profanityResult[0])
+            try:
+                percentageProfanity = round((profanityResult / totalResult * 100), 2)
+            except:
+                percentageProfanity = "error"
+        except:
+            profanityResult = "error"
+            percentageProfanity = "error"
+        try:
+            cursor.execute("SELECT message FROM messages WHERE bool=? AND user=?", (1, txt2.get(),))
+            profanityMessagesResult = cursor.fetchall()
+            profanityMessagesResult = profanityMessagesResult[-5:]
+            allMessages = ""
+            for i in range(0, len(profanityMessagesResult)):
+                allMessages += str(profanityMessagesResult[i])
+            allMessages = allMessages.replace("(", "")
+            allMessages = allMessages.replace(")", "")
+            allMessages = allMessages.replace(",", " ")
+        except:
+            allMessages = "error"
+        db.close()
+        resT = f"Total: {totalResult}"
+        total2.configure(text=resT)
+        resP = f"Profanity: {profanityResult}"
+        profanity2.configure(text=resP)
+        resPERC = f"Percentage: {percentageProfanity}%"
+        percentage2.configure(text=resPERC)
+        resTPM = f"Recent profanity: {allMessages}"
+        recentprofanity2.configure(text=resTPM)
+
+    btn = Button(window, text="Search", command=clicked)
+    btn.grid(column=1, row=0)
+
+    btn2 = Button(window, text="Search", command=clicked2)
+    btn2.grid(column=4, row=0)
+
+    total = Label(window, text="Total:")
+    total.grid(column=0, row=1)
+
+    total2 = Label(window, text="Total:")
+    total2.grid(column=3, row=1)
+
+    profanity = Label(window, text=f"Profanity:")
+    profanity.grid(column=0, row=2)
+
+    profanity2 = Label(window, text=f"Profanity:")
+    profanity2.grid(column=3, row=2)
+
+    percentage = Label(window, text=f"Percentage:")
+    percentage.grid(column=0, row=3)
+
+    percentage2 = Label(window, text=f"Percentage:")
+    percentage2.grid(column=3, row=3)
+
+    recentprofanity = Label(window, text=f"Recent profanity:")
+    recentprofanity.grid(column=0, row=4)
+
+    recentprofanity2 = Label(window, text=f"Recent profanity:")
+    recentprofanity2.grid(column=3, row=4)
+
+    window.iconbitmap("discord.ico")
+
+    window.mainloop()
+
+runGUI()

test.py

@@ -0,0 +1,17 @@
+values = [('total_kills_ak47', 3563), ('total_kills_awp', 2321), ('total_kills_m4a1', 1662), ('total_kills_deagle', 1151), ('total_kills_hkp2000', 959)]
+
+for i in range(0, len(values)):
+    if i == 0:
+        ak47 = values[i][1]
+    elif i == 1:
+        awp = values[i][1]
+    elif i == 1:
+        m4a1 = values[i][1]
+    elif i == 1:
+        deagle = values[i][1]
+    elif i == 1:
+        hkp2000 = values[i][1]
+
+print(ak47)
+
+#print(values[i][1])