diff options
Diffstat (limited to 'bot/cogs')
| -rw-r--r-- | bot/cogs/hacktoberstats.py | 181 | ||||
| -rw-r--r-- | bot/cogs/spookyreact.py | 58 |
2 files changed, 205 insertions, 34 deletions
diff --git a/bot/cogs/hacktoberstats.py b/bot/cogs/hacktoberstats.py index ac81b887..adbc5c82 100644 --- a/bot/cogs/hacktoberstats.py +++ b/bot/cogs/hacktoberstats.py @@ -1,7 +1,10 @@ +import json +import logging import re import typing from collections import Counter from datetime import datetime +from pathlib import Path import aiohttp import discord @@ -11,13 +14,129 @@ from discord.ext import commands class Stats: def __init__(self, bot): self.bot = bot + self.link_json = Path('./bot/resources', 'github_links.json') + self.linked_accounts = self.load_linked_users() - @commands.command( - name="stats", - aliases=["getstats", "userstats"], - brief="Get a user's Hacktoberfest contribution stats", + @commands.group( + name='stats', + aliases=('hacktoberstats', 'getstats', 'userstats'), + invoke_without_command=True ) - async def get_stats(self, ctx, username: str): + async def hacktoberstats_group(self, ctx: commands.Context, github_username: str=None): + """ + If invoked without a subcommand or github_username, get the invoking user's stats if + they've linked their Discord name to GitHub using .stats link + + If invoked with a github_username, get that user's contributions + """ + if not github_username: + author_id, author_mention = Stats._author_mention_from_context(ctx) + + if str(author_id) in self.linked_accounts.keys(): + github_username = self.linked_accounts[author_id]["github_username"] + logging.info(f"Getting stats for {author_id} linked GitHub account '{github_username}'") + else: + msg = ( + f"{author_mention}, you have not linked a GitHub account\n\n" + f"You can link your GitHub account using:\n```{ctx.prefix}stats link github_username```\n" + f"Or query GitHub stats directly using:\n```{ctx.prefix}stats github_username```" + ) + await ctx.send(msg) + return + + await self.get_stats(ctx, github_username) + + @hacktoberstats_group.command(name="link") + async def link_user(self, ctx: commands.Context, github_username: str=None): + """ + Link the invoking user's Github github_username to their Discord ID + + Linked users are stored as a nested dict: + { + Discord_ID: { + "github_username": str + "date_added": datetime + } + } + """ + author_id, author_mention = Stats._author_mention_from_context(ctx) + if github_username: + if str(author_id) in self.linked_accounts.keys(): + old_username = self.linked_accounts[author_id]["github_username"] + logging.info(f"{author_id} has changed their github link from '{old_username}' to '{github_username}'") + await ctx.send(f"{author_mention}, your GitHub username has been updated to: '{github_username}'") + else: + logging.info(f"{author_id} has added a github link to '{github_username}'") + await ctx.send(f"{author_mention}, your GitHub username has been added") + + self.linked_accounts[author_id] = { + "github_username": github_username, + "date_added": datetime.now() + } + + self.save_linked_users() + else: + logging.info(f"{author_id} tried to link a GitHub account but didn't provide a username") + await ctx.send(f"{author_mention}, a GitHub username is required to link your account") + + @hacktoberstats_group.command(name="unlink") + async def unlink_user(self, ctx: commands.Context): + """ + Remove the invoking user's account link from the log + """ + author_id, author_mention = Stats._author_mention_from_context(ctx) + + stored_user = self.linked_accounts.pop(author_id, None) + if stored_user: + await ctx.send(f"{author_mention}, your GitHub profile has been unlinked") + logging.info(f"{author_id} has unlinked their GitHub account") + else: + await ctx.send(f"{author_mention}, you do not currently have a linked GitHub account") + logging.info(f"{author_id} tried to unlink their GitHub account but no account was linked") + + self.save_linked_users() + + def load_linked_users(self) -> typing.Dict: + """ + Load list of linked users from local JSON file + + Linked users are stored as a nested dict: + { + Discord_ID: { + "github_username": str + "date_added": datetime + } + } + """ + if self.link_json.exists(): + logging.info(f"Loading linked GitHub accounts from '{self.link_json}'") + with open(self.link_json, 'r') as fID: + linked_accounts = json.load(fID) + + logging.info(f"Loaded {len(linked_accounts)} linked GitHub accounts from '{self.link_json}'") + return linked_accounts + else: + logging.info(f"Linked account log: '{self.link_json}' does not exist") + return {} + + def save_linked_users(self): + """ + Save list of linked users to local JSON file + + Linked users are stored as a nested dict: + { + Discord_ID: { + "github_username": str + "date_added": datetime + } + } + """ + logging.info(f"Saving linked_accounts to '{self.link_json}'") + with open(self.link_json, 'w') as fID: + json.dump(self.linked_accounts, fID, default=str) + logging.info(f"linked_accounts saved to '{self.link_json}'") + + async def get_stats(self, ctx: commands.Context, github_username: str): """ Query GitHub's API for PRs created by a GitHub user during the month of October that do not have an 'invalid' tag @@ -25,41 +144,40 @@ class Stats: For example: !getstats heavysaturn - If a valid username is provided, an embed is generated and posted to the channel + If a valid github_username is provided, an embed is generated and posted to the channel Otherwise, post a helpful error message - - The first input argument is treated as the username, any additional inputs are discarded """ - prs = await self.get_october_prs(username) + prs = await self.get_october_prs(github_username) if prs: - stats_embed = self.build_embed(username, prs) + stats_embed = self.build_embed(github_username, prs) await ctx.send('Here are some stats!', embed=stats_embed) else: - await ctx.send(f"No October GitHub contributions found for '{username}'") + await ctx.send(f"No October GitHub contributions found for '{github_username}'") - def build_embed(self, username: str, prs: typing.List[dict]) -> discord.Embed: + def build_embed(self, github_username: str, prs: typing.List[dict]) -> discord.Embed: """ - Return a stats embed built from username's PRs + Return a stats embed built from github_username's PRs """ + logging.info(f"Building Hacktoberfest embed for GitHub user: '{github_username}'") pr_stats = self._summarize_prs(prs) n = pr_stats['n_prs'] if n >= 5: - shirtstr = f"**{username} has earned a tshirt!**" + shirtstr = f"**{github_username} has earned a tshirt!**" elif n == 4: - shirtstr = f"**{username} is 1 PR away from a tshirt!**" + shirtstr = f"**{github_username} is 1 PR away from a tshirt!**" else: - shirtstr = f"**{username} is {5 - n} PRs away from a tshirt!**" + shirtstr = f"**{github_username} is {5 - n} PRs away from a tshirt!**" stats_embed = discord.Embed( - title=f"{username}'s Hacktoberfest", + title=f"{github_username}'s Hacktoberfest", color=discord.Color(0x9c4af7), - description=f"{username} has made {n} {Stats._contributionator(n)} in October\n\n{shirtstr}\n\n" + description=f"{github_username} has made {n} {Stats._contributionator(n)} in October\n\n{shirtstr}\n\n" ) - stats_embed.set_thumbnail(url=f"https://www.github.com/{username}.png") + stats_embed.set_thumbnail(url=f"https://www.github.com/{github_username}.png") stats_embed.set_author( name="Hacktoberfest", url="https://hacktoberfest.digitalocean.com", @@ -70,13 +188,14 @@ class Stats: value=self._build_top5str(pr_stats) ) + logging.info(f"Hacktoberfest PR built for GitHub user '{github_username}'") return stats_embed @staticmethod - async def get_october_prs(username: str) -> typing.List[dict]: + async def get_october_prs(github_username: str) -> typing.List[dict]: """ - Query GitHub's API for PRs created during the month of October by username that do - not have an 'invalid' tag + Query GitHub's API for PRs created during the month of October by github_username + that do not have an 'invalid' tag If PRs are found, return a list of dicts with basic PR information @@ -89,10 +208,11 @@ class Stats: Otherwise, return None """ + logging.info(f"Generating Hacktoberfest PR query for GitHub user: '{github_username}'") base_url = "https://api.github.com/search/issues?q=" not_label = "invalid" action_type = "pr" - is_query = f"public+author:{username}" + is_query = f"public+author:{github_username}" date_range = "2018-10-01..2018-10-31" per_page = "300" query_url = ( @@ -111,13 +231,16 @@ class Stats: if "message" in jsonresp.keys(): # One of the parameters is invalid, short circuit for now - # In the future, log: jsonresp["errors"][0]["message"] + api_message = jsonresp["errors"][0]["message"] + logging.error(f"GitHub API request for '{github_username}' failed with message: {api_message}") return else: if jsonresp["total_count"] == 0: # Short circuit if there aren't any PRs + logging.info(f"No Hacktoberfest PRs found for GitHub user: '{github_username}'") return else: + logging.info(f"Found {len(jsonresp['items'])} Hacktoberfest PRs for GitHub user: '{github_username}'") outlist = [] for item in jsonresp["items"]: shortname = Stats._get_shortname(item["repository_url"]) @@ -188,6 +311,16 @@ class Stats: else: return "contributions" + @staticmethod + def _author_mention_from_context(ctx: commands.Context) -> typing.Tuple: + """ + Return stringified Message author ID and mentionable string from commands.Context + """ + author_id = str(ctx.message.author.id) + author_mention = ctx.message.author.mention + + return author_id, author_mention + def setup(bot): bot.add_cog(Stats(bot)) diff --git a/bot/cogs/spookyreact.py b/bot/cogs/spookyreact.py index 2652a60e..9146b797 100644 --- a/bot/cogs/spookyreact.py +++ b/bot/cogs/spookyreact.py @@ -1,11 +1,16 @@ +import logging +import re + +import discord + SPOOKY_TRIGGERS = { - 'spooky': "\U0001F47B", - 'skeleton': "\U0001F480", - 'doot': "\U0001F480", - 'pumpkin': "\U0001F383", - 'halloween': "\U0001F383", - 'jack-o-lantern': "\U0001F383", - 'danger': "\U00002620" + 'spooky': (r"\bspo{2,}ky\b", "\U0001F47B"), + 'skeleton': (r"\bskeleton\b", "\U0001F480"), + 'doot': (r"\bdo{2,}t\b", "\U0001F480"), + 'pumpkin': (r"\bpumpkin\b", "\U0001F383"), + 'halloween': (r"\bhalloween\b", "\U0001F383"), + 'jack-o-lantern': (r"\bjack-o-lantern\b", "\U0001F383"), + 'danger': (r"\bdanger\b", "\U00002620") } @@ -18,13 +23,46 @@ class SpookyReact: def __init__(self, bot): self.bot = bot - async def on_message(self, ctx): + async def on_message(self, ctx: discord.Message): """ A command to send the hacktoberbot github project + + Lines that begin with the bot's command prefix are ignored + + Hacktoberbot's own messages are ignored """ for trigger in SPOOKY_TRIGGERS.keys(): - if trigger in ctx.content.lower(): - await ctx.add_reaction(SPOOKY_TRIGGERS[trigger]) + trigger_test = re.search(SPOOKY_TRIGGERS[trigger][0], ctx.content.lower()) + if trigger_test: + # Check message for bot replies and/or command invocations + # Short circuit if they're found, logging is handled in _short_circuit_check + if await self._short_circuit_check(ctx): + return + else: + await ctx.add_reaction(SPOOKY_TRIGGERS[trigger][1]) + logging.info(f"Added '{trigger}' reaction to message ID: {ctx.id}") + + async def _short_circuit_check(self, ctx: discord.Message) -> bool: + """ + Short-circuit helper check. + + Return True if: + * author is the bot + * prefix is not None + """ + # Check for self reaction + if ctx.author == self.bot.user: + logging.info(f"Ignoring reactions on self message. Message ID: {ctx.id}") + return True + + # Check for command invocation + # Because on_message doesn't give a full Context object, generate one first + tmp_ctx = await self.bot.get_context(ctx) + if tmp_ctx.prefix: + logging.info(f"Ignoring reactions on command invocation. Message ID: {ctx.id}") + return True + + return False def setup(bot): |