247 lines
8.8 KiB
Python
247 lines
8.8 KiB
Python
import traceback
|
|
from typing import Optional, Union
|
|
import discord
|
|
from discord.ext import bridge, commands
|
|
from util.lovehate_db import DB
|
|
from disc_havoc import Havoc
|
|
|
|
|
|
class LoveHate(commands.Cog):
|
|
"""LoveHate Cog for Havoc"""
|
|
|
|
def __init__(self, bot: Havoc) -> None:
|
|
self.bot: Havoc = bot
|
|
self.db = DB(self.bot)
|
|
|
|
def join_with_and(self, items: list) -> str:
|
|
"""
|
|
Join list with and added before last item
|
|
|
|
Args:
|
|
items (list)
|
|
Returns:
|
|
str
|
|
"""
|
|
if len(items) > 1:
|
|
return ", ".join(items[:-1]) + " and " + items[-1]
|
|
return items[0] if items else ""
|
|
|
|
@bridge.bridge_command()
|
|
async def loves(self, ctx, user: Optional[str] = None) -> None:
|
|
"""
|
|
If keyword isn't provided, returns the things YOU love; specify a user to find what THEY love.
|
|
"""
|
|
try:
|
|
if not user:
|
|
display_name = ctx.author.display_name
|
|
loves: Union[list[tuple], bool] = await self.db.get_lovehates(
|
|
user=display_name, loves=True
|
|
)
|
|
if not loves:
|
|
return await ctx.respond("You don't seem to love anything...")
|
|
|
|
out_loves: list = []
|
|
if not isinstance(loves, list):
|
|
return
|
|
for love in loves:
|
|
(love,) = love
|
|
out_loves.append(love)
|
|
|
|
out_loves_str: str = self.join_with_and(out_loves)
|
|
return await ctx.respond(f"{ctx.author.mention} loves {out_loves_str}")
|
|
|
|
loves = await self.db.get_lovehates(user=user.strip(), loves=True)
|
|
if not loves:
|
|
return await ctx.respond(f"{user} doesn't seem to love anything...")
|
|
|
|
out_loves_str = self.join_with_and(out_loves)
|
|
return await ctx.respond(f"{user} loves {out_loves_str}")
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
return await ctx.respond(f"Error: {str(e)}")
|
|
|
|
@bridge.bridge_command()
|
|
async def wholoves(self, ctx, *, thing: Optional[str] = None) -> None:
|
|
"""
|
|
Check who loves <thing>
|
|
"""
|
|
try:
|
|
if not thing:
|
|
_thing: str = ctx.author.display_name
|
|
else:
|
|
_thing = thing
|
|
if discord.utils.raw_mentions(_thing):
|
|
# There are mentions
|
|
thing_id: int = discord.utils.raw_mentions(_thing)[0] # First mention
|
|
guild: Optional[discord.Guild] = self.bot.get_guild(ctx.guild.id)
|
|
if not guild:
|
|
return
|
|
thing_member: Optional[discord.Member] = guild.get_member(thing_id)
|
|
if not thing_member:
|
|
return
|
|
|
|
_thing = thing_member.display_name
|
|
|
|
if not _thing:
|
|
return
|
|
|
|
who_loves: Union[list, bool] = await self.db.get_wholovehates(
|
|
thing=_thing, loves=True
|
|
)
|
|
if not isinstance(who_loves, list):
|
|
return await ctx.respond(f"I couldn't find anyone who loves {thing}...")
|
|
|
|
out_wholoves: list = []
|
|
for lover in who_loves:
|
|
(lover,) = lover
|
|
out_wholoves.append(str(lover))
|
|
|
|
optional_s: str = "s" if len(out_wholoves) == 1 else ""
|
|
|
|
out_wholoves_str: str = self.join_with_and(out_wholoves)
|
|
|
|
return await ctx.respond(f"{out_wholoves_str} love{optional_s} {thing}")
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
return await ctx.respond(f"Error: {str(e)}")
|
|
|
|
@bridge.bridge_command()
|
|
async def whohates(self, ctx, *, thing: Optional[str] = None) -> None:
|
|
"""
|
|
Check who hates <thing>
|
|
"""
|
|
try:
|
|
if not thing:
|
|
_thing: str = ctx.author.display_name
|
|
else:
|
|
_thing = thing
|
|
if discord.utils.raw_mentions(_thing):
|
|
# There are mentions
|
|
guild: Optional[discord.Guild] = self.bot.get_guild(ctx.guild.id)
|
|
if not guild:
|
|
return
|
|
thing_id: int = discord.utils.raw_mentions(_thing)[0] # First mention
|
|
thing_member: Optional[discord.Member] = guild.get_member(thing_id)
|
|
if not thing_member:
|
|
return
|
|
_thing = thing_member.display_name
|
|
|
|
who_hates: Union[list[tuple], bool] = await self.db.get_wholovehates(
|
|
thing=_thing, hates=True
|
|
)
|
|
if not who_hates:
|
|
return await ctx.respond(f"I couldn't find anyone who hates {thing}...")
|
|
|
|
out_whohates: list = []
|
|
if not isinstance(who_hates, list):
|
|
return
|
|
for hater in who_hates:
|
|
(hater,) = hater
|
|
out_whohates.append(str(hater))
|
|
|
|
optional_s: str = "s" if len(out_whohates) == 1 else ""
|
|
|
|
out_whohates_str: str = self.join_with_and(out_whohates)
|
|
|
|
return await ctx.respond(f"{out_whohates_str} hate{optional_s} {thing}")
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
return await ctx.respond(f"Error: {str(e)}")
|
|
|
|
@bridge.bridge_command()
|
|
async def dontcare(self, ctx, thing: str) -> None:
|
|
"""
|
|
Make me forget your opinion on <thing>
|
|
"""
|
|
try:
|
|
stop_caring: str = await self.db.update(ctx.author.display_name, thing, 0)
|
|
return await ctx.respond(stop_caring)
|
|
except Exception as e:
|
|
await ctx.respond(f"Error: {str(e)}")
|
|
traceback.print_exc()
|
|
|
|
@bridge.bridge_command()
|
|
async def hates(self, ctx, user: Optional[str] = None) -> None:
|
|
"""
|
|
If keyword isn't provided, returns the things YOU hate; specify a user to find what THEY hate.
|
|
"""
|
|
try:
|
|
if not user:
|
|
display_name = ctx.author.display_name
|
|
hates: Union[list[tuple], bool] = await self.db.get_lovehates(
|
|
user=display_name, hates=True
|
|
)
|
|
if not hates:
|
|
return await ctx.respond("You don't seem to hate anything...")
|
|
else:
|
|
hates = await self.db.get_lovehates(user=user.strip(), hates=True)
|
|
if not hates:
|
|
return await ctx.respond(f"{user} doesn't seem to hate anything...")
|
|
|
|
out_hates: list = []
|
|
if not isinstance(hates, list):
|
|
return
|
|
for hated_thing in hates:
|
|
(hated_thing,) = hated_thing
|
|
out_hates.append(str(hated_thing))
|
|
|
|
out_hates_str: str = self.join_with_and(out_hates)
|
|
return await ctx.respond(f"{user} hates {out_hates_str}")
|
|
except Exception as e:
|
|
await ctx.respond(f"Error: {str(e)}")
|
|
traceback.print_exc()
|
|
|
|
@bridge.bridge_command(aliases=["sarcastichate"])
|
|
async def love(self, ctx, *, thing: str) -> None:
|
|
"""
|
|
Love <thing>
|
|
"""
|
|
try:
|
|
if discord.utils.raw_mentions(thing):
|
|
# There are mentions
|
|
thing_id: int = discord.utils.raw_mentions(thing)[0] # First mention
|
|
guild: Optional[discord.Guild] = self.bot.get_guild(ctx.guild)
|
|
if not guild:
|
|
return
|
|
thing_member: Optional[discord.Member] = guild.get_member(thing_id)
|
|
if not thing_member:
|
|
return
|
|
thing = thing_member.display_name
|
|
|
|
love: str = await self.db.update(ctx.author.display_name, thing, 1)
|
|
return await ctx.respond(love)
|
|
except Exception as e:
|
|
await ctx.respond(f"Error: {str(e)}")
|
|
traceback.print_exc()
|
|
|
|
@bridge.bridge_command(aliases=["sarcasticlove"])
|
|
async def hate(self, ctx, *, thing: str) -> None:
|
|
"""
|
|
Hate <thing>
|
|
"""
|
|
try:
|
|
if discord.utils.raw_mentions(thing):
|
|
# There are mentions
|
|
thing_id: int = discord.utils.raw_mentions(thing)[0] # First mention
|
|
guild: Optional[discord.Guild] = self.bot.get_guild(ctx.guild.id)
|
|
if not guild:
|
|
return
|
|
thing_member: Optional[discord.Member] = guild.get_member(thing_id)
|
|
if not thing_member:
|
|
return
|
|
thing = thing_member.display_name
|
|
hate: str = await self.db.update(ctx.author.display_name, thing, -1)
|
|
return await ctx.respond(hate)
|
|
except Exception as e:
|
|
await ctx.respond(f"Error: {str(e)}")
|
|
traceback.print_exc()
|
|
|
|
def cog_unload(self) -> None:
|
|
# not needed currently
|
|
pass
|
|
|
|
|
|
def setup(bot) -> None:
|
|
"""Run on Cog Load"""
|
|
bot.add_cog(LoveHate(bot))
|