async def base64(self, message, parameters):
"""Encodes or decodes text to or from base64.\n
Parameters:
conversionType: Whether to encode or decode text.\n
text: The text to encode or decode.\n
"""
# Check for not enough parameters
if len(parameters) < self._base64.getMinParameters():
embed = getErrorMessage(self._base64, Code.NOT_ENOUGH_PARAMETERS)
# There were enough parameters
else:
# Conversion type is first parameter; Text is all parameters after
conversionType = parameters[0]
text = " ".join(parameters[1:])
# Conversion is Encode
if conversionType in self._base64.getAcceptedParameter(
"conversion", "encode").getAlternatives():
converted = base64.b64encode(text.encode()).decode()
encoded = True
embed = discord.Embed(
title="`{}` {} Base64".format(
text if len(text) < 180 else
"[text is greater than 200 characters]",
"encoded to" if encoded else "decoded from"),
description=converted,
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color)
# Conversion is Decode
elif conversionType in self._base64.getAcceptedParameter(
"conversion", "decode").getAlternatives():
converted = base64.b64decode(text.encode()).decode()
encoded = False
embed = discord.Embed(
title="`{}` {} Base64".format(
text if len(text) < 180 else
"[text is greater than 200 characters]",
"encoded to" if encoded else "decoded from"),
description=converted,
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color)
# Conversion is Invalid
else:
embed = getErrorMessage(self._base64, Code.INVALID_PARAMETER)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def morse(self, message, parameters):
"""Turns text into/from morse code
"""
# Check for not enough parameters
if len(parameters) < self._morse.getMinParameters():
embed = getErrorMessage(self._morse, Code.NOT_ENOUGH_PARAMETERS)
# There were the proper amount of parameters
else:
conversion = parameters[0]
text = " ".join(parameters[1:])
# Check if the conversion is valid
valid = True
if conversion in self._morse.getAcceptedParameter(
"conversion", "encode").getAlternatives():
conversion = "encode"
elif conversion in self._morse.getAcceptedParameter(
"conversion", "decode").getAlternatives():
conversion = "decode"
# Conversion is invalid
else:
embed = getErrorMessage(self._morse, Code.INVALID_PARAMETER)
valid = False
if valid:
response = await loop.run_in_executor(
None, requests.get,
Code.MORSE_API_CALL.format(conversion, text))
response = response.json()
# Check if the API call was a success
if response["success"]:
value = response["value"]
else:
value = response["error"]
embed = discord.Embed(
title="{}".format("Text to Morse" if conversion ==
"encode" else "Morse To Text")
if response["success"] else "Failed to convert",
description="`{}`".format(value),
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def brainfuck(self, message, parameters):
"""Runs brainfuck code and returns the result.\n
Parameters:
code: The brainfuck code to run.\n
parameters: The parameters to insert into the brainfuck code.\n
"""
# Check for not enough parameters
if len(parameters) < self._brainfuck.getMinParameters():
embed = getErrorMessage(self._brainfuck,
Code.NOT_ENOUGH_PARAMETERS)
# Check for too many parameters
elif len(parameters) > self._brainfuck.getMaxParameters():
embed = getErrorMessage(self._brainfuck, Code.TOO_MANY_PARAMETERS)
# There were a proper amount of parameters
else:
code = parameters[0]
if len(parameters) == 2:
parameters = parameters[1]
else:
parameters = []
# Remove all invalid symbols
validSymbols = "<>+-.,[]"
newCode = ""
for char in code:
if char in validSymbols:
newCode += char
code = newCode
try:
async with async_timeout.timeout(5):
description = await loop.run_in_executor(
None, self.__brainfuck, code, parameters)
except:
description = "Timed out"
# Create and return embed for result
embed = discord.Embed(title="Result",
description=description,
colour=self.getEmbedColor() if message.guild
== None else message.author.top_role.color)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def kill(self, message, parameters):
"""Kills the bot and logs out.
"""
processId = OmegaPsi.PROCESS_ID
# Check if parameters exceeds maximum parameters
if len(parameters) > self._kill.getMaxParameters():
embed = getErrorMessage(self._kill,
BotModerator.TOO_MANY_PARAMETERS)
# Parameters do not exceed maximum parameters
else:
processId = OmegaPsi.PROCESS_ID if len(
parameters) == 0 else parameters[0]
embed = discord.Embed(
title="Bot Killed",
description="Omega Psi was killed (Process {})".format(
OmegaPsi.PROCESS_ID),
colour=self.getEmbedColor()
if message.guild == None else message.author.top_role.color)
# Only kill if processId is OmegaPsi.PROCESS_ID
if str(processId) == str(OmegaPsi.PROCESS_ID):
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
await self.client.logout()
async def removeModerator(self, message, parameters):
"""Removes a bot moderator from the bot.\n
Parameters:
parameters: The Discord Users to remove as a bot moderator.\n
"""
# Check if message has no mentions
if len(message.mentions) < self._removeModerator.getMinParameters():
embed = getErrorMessage(self._removeModerator,
BotModerator.NOT_ENOUGH_PARAMETERS)
# There was at least one mention
else:
# Iterate through each member
result = ""
for member in message.mentions:
result += "{} {} a bot moderator.".format(
member.mention, "was successfully removed as"
if await OmegaPsi.removeModerator(member) else ("is not"))
embed = discord.Embed(name="Removed Moderators",
description=result,
colour=self.getEmbedColor() if message.guild
== None else message.author.top_role.color)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def timchen(self, message, parameters):
"""Returns a random picture of Timchen with the caption.
"""
# Check for too many parameters
if len(parameters) > self._timchen.getMaxParameters():
embed = getErrorMessage(self._timchen, Image.TOO_MANY_PARAMETERS)
# There were the proper amount of parameters
else:
# Get a random image
timchenData = await timchen.get_random()
embed = discord.Embed(
title="Timchen!",
description=capitalizeSentences(timchenData.description),
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color).set_image(url=timchenData.url)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def cat(self, message, parameters):
"""Returns a random cat from the internet.
"""
# Check for too many parameters
if len(parameters) > self._cat.getMaxParameters():
embed = getErrorMessage(self._cat, Image.TOO_MANY_PARAMETERS)
# There were the proper amount of parameters
else:
result = await loop.run_in_executor(
None,
partial(requests.get,
Image.CAT_API,
headers={"x-api-key": os.environ["CAT_API_KEY"]}))
result = result.json()
embed = discord.Embed(
title="Cat from the internet",
description=" ",
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color).set_image(url=result[0]["url"])
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def dog(self, message, parameters):
"""Returns a random dog from the internet
"""
# Check for too many parameters
if len(parameters) > self._dog.getMaxParameters():
embed = getErrorMessage(self._dog, Image.TOO_MANY_PARAMETERS)
# There were the proper amount of parameters
else:
result = await loop.run_in_executor(None, requests.get,
Image.DOG_API)
result = result.json()
embed = discord.Embed(
title="Dog from the internet",
description=" ",
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color).set_image(url=result["message"])
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def qrCode(self, message, parameters):
"""Turns data into a QR code.
"""
# Check for not enough parameters
if len(parameters) < self._qrCode.getMinParameters():
embed = getErrorMessage(self._qrCode, Code.NOT_ENOUGH_PARAMETERS)
# There were the proper amount of parameters
else:
data = " ".join(parameters)
# The size should be a function of the data's length
# Use this --> size = 10(length // 20) + 200
size = 10 * (len(data) // 20) + 200
embed = discord.Embed(
title=" ",
description=" ",
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color).set_image(
url=Code.QR_API_CALL.format(size, data.replace(" ", "+")))
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def deactivate(self, message, parameters):
"""Deactivates a command globally in the bot.\n
Parameters:
command: The command to globally deactivate.\n
reason: The reason the command is being globally deactivated.\n
"""
# Check for minimum amount of parameters
if len(parameters) < self._deactivate.getMinParameters():
embed = getErrorMessage(self._deactivate,
BotModerator.NOT_ENOUGH_PARAMETERS)
# Parameters had the minimum amount of parameters
else:
# Command to be deactivated is first parameter; Reason is every parameter after
command = parameters[0]
reason = "No Reason"
if len(parameters) > 1:
reason = " ".join(parameters[1:])
# Open bot file
bot = await OmegaPsi.openOmegaPsi()
# Check if command is valid
commandObject = None
for category in self._categories:
commandObject = self._categories[category].getCommand(command)
if commandObject != None:
break
if commandObject == None:
result = "`{}` is not a valid command.".format(command)
else:
bot["inactive_commands"][commandObject.getAlternatives()
[0]] = reason
result = "`{}` was globally deactivated.\nReason: {}".format(
commandObject.getAlternatives()[0], reason)
# Close bot file
await OmegaPsi.closeOmegaPsi(bot)
embed = discord.Embed(name="Deactivated",
description=result,
colour=self.getEmbedColor() if message.guild
== None else message.author.top_role.color)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def nasaImage(self, message, parameters):
"""Returns an image from NASA.
"""
keywords = " ".join(parameters)
# Get data involving NASA images
if keywords == "random":
imageData = await loop.run_in_executor(None, requests.get,
Image.NASA_RANDOM)
else:
imageData = await loop.run_in_executor(
None, requests.get,
Image.NASA_SEARCH.format(keywords.replace(" ", "+")))
imageData = imageData.json()
# Check if there are no images
if len(imageData["collection"]["items"]) == 0:
embed = getErrorMessage(self._nasaImage, Image.NO_IMAGE)
# There are images
else:
# Choose random item from collection
item = choose(imageData["collection"]["items"])
# Get href from item
imageLink = item["links"][0]["href"]
# Make sure description is less than 2000 characters
if len(item["data"][0]
["description"]) < Image.DESCRIPTION_THRESHOLD:
description = item["data"][0]["description"]
else:
description = item["data"][0][
"description"][:Image.DESCRIPTION_THRESHOLD] + "[...]"
embed = discord.Embed(
title=item["data"][0]["title"],
description=description,
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color).set_image(url=imageLink)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def avatar(self, message, parameters):
"""Returns a random cute avatar that can be used as a placeholder.
Parameters:
parameters (list): The parameters that detect for too many parameters.
"""
# Check for too many parameters
if len(parameters) > self._avatar.getMaxParameters():
embed = getErrorMessage(self._avatar, Image.TOO_MANY_PARAMETERS)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
# There were the proper amount of parameters
else:
# Get list of face features
faceValues = await loop.run_in_executor(None, requests.get,
Image.AVATAR_LIST)
faceValues = faceValues.json()["face"]
# Choose random eyes, nose, mouth, and color
eyes = choose(faceValues["eyes"])
nose = choose(faceValues["nose"])
mouth = choose(faceValues["mouth"])
color = hex(randint(0, 16777215))[2:].rjust(6, "0")
# Load image
image = await loop.run_in_executor(
None, loadImageFromUrl,
Image.AVATAR_API.format(eyes, nose, mouth, color))
# Save image temporarily
avatarFile = "{}_{}_{}_{}.png".format(eyes, nose, mouth, color)
pygame.image.save(image, avatarFile)
# Send file then delete image
await sendMessage(self.client, message, filename=avatarFile)
os.remove(avatarFile)
async def booty(self, message, parameters):
"""Sends a random picture of some booty.
"""
# Check for too many parameters
if len(parameters) > self._booty.getMaxParameters():
return getErrorMessage(self._booty, NSFW.TOO_MANY_PARAMETERS)
# There were the proper amount of parameters
else:
# Load image from URL, temporarily save it, send image
while True:
# Generate random number for an image; Add 0's to beginning until pad is reached (5)
bootyNumber = str(random.randint(1, 5400))
bootyNumber = bootyNumber.rjust(5, "0")
# Try loading the image
try:
loadImageFromUrl(NSFW.BOOTY_URL.format(bootyNumber))
break
# Image load failed; Retry using new number.
except:
pass
embed = discord.Embed(
title="Booty Number {}".format(bootyNumber),
description=" ",
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color).set_image(
url=NSFW.BOOTY_URL.format(bootyNumber))
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def rank(self, message, parameters):
"""Returns an image displaying the rank of the member in this server.\n
discordMember - The member to get the rank of.\n
"""
# Check for too many parameters
if len(parameters) > self._rank.getMaxParameters():
result = getErrorMessage(self._rank, Rank.TOO_MANY_PARAMETERS)
# There were the proper amount of parameters
else:
result = await createRankImage(message.author)
# Check for an error
if type(result) == discord.Embed:
await sendMessage(
self.client,
message,
embed = result.set_footer(
text = "Requested by {}#{}".format(
message.author.name,
message.author.discriminator
),
icon_url = message.author.avatar_url
)
)
else:
# Send rank image and remove
await sendMessage(
self.client,
message,
filename = result
)
os.remove(result)
async def debug(self, message, parameters):
"""Debugs the bot.
"""
# Check if parameters exceeds maximum parameters
if len(parameters) > self._debug.getMaxParameters():
embed = getErrorMessage(self._debug,
BotModerator.TOO_MANY_PARAMETERS)
# Parameters do not exceed maximum parameters
else:
embed = discord.Embed(
title="Omega Psi Debugging",
description="Process ID: {}".format(OmegaPsi.PROCESS_ID),
colour=self.getEmbedColor()
if message.guild == None else message.author.top_role.color)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def gif(self, message, parameters):
"""Returns a gif from giphy.
"""
keywords = " ".join(parameters)
# Get data involving gifs from Giphy
if keywords == "random":
gifData = await loop.run_in_executor(
None, requests.get, os.environ["GIPHY_RANDOM_API_URL"])
gifData = gifData.json()
result = gifData["data"]["embed_url"]
else:
gifsData = await loop.run_in_executor(
None, requests.get, os.environ["GIPHY_SEARCH_API_URL"].format(
keywords.replace(" ", "+")))
gifsData = gifsData.json()
# Return random embed url
if len(gifsData) > 0:
gifData = choose(gifsData["data"])
result = gifData["embed_url"]
else:
result = getErrorMessage(self._gif, Image.NO_GIFS_FOUND)
if type(result) == discord.Embed:
await sendMessage(
self.client,
message,
embed=result.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
else:
await sendMessage(self.client, message, message=result)
async def getServers(self, message, parameters):
"""Returns a list of servers the bot is in.\n
"""
# Check if parameters exceeds maximum parameters
if len(parameters) > self._servers.getMaxParameters():
embed = getErrorMessage(self._servers,
BotModerator.TOO_MANY_PARAMETERS)
# Parameters do not exceed maximum parameters
else:
# Getting results through embed
if len(parameters) == 0:
# Add results to fields
fields = []
fieldText = ""
for server in self.client.guilds:
text = "`{}` | Owner: {}\n".format(server.name,
server.owner.mention)
if len(fieldText) + len(
text) >= OmegaPsi.MESSAGE_THRESHOLD:
fields.append(fieldText)
fieldText = ""
fieldText += text
# Add trailing field text
if len(fieldText) > 0:
fields.append(fieldText)
# Create embed object
embed = discord.Embed(
title="Servers",
description="A list of servers that Omega Psi is in.",
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color)
# Add fields to embed object
count = 0
for field in fields:
count += 1
embed.add_field(
name="Servers {}".format("({} / {})".format(
count, len(fields)) if len(fields) > 1 else ""),
value=field,
inline=False)
# Getting results through markdown file
else:
# Setup markdown text
markdown = "# Omega Psi Server Information\n"
# Iterate through servers bot is in
for guild in self.client.guilds:
# Load file
server = await Server.openServer(guild)
# Add server information (owner, name)
try:
markdown += "## {} - {}\n".format(
guild.name,
guild.owner.name + "#" + guild.owner.discriminator)
except:
markdown += "## {} - No Owner\n".format(guild.name)
# Iterate through members in server dictionary
for member in server["members"]:
member = server["members"][member]
discordMember = guild.get_member(int(member["id"]))
markdown += (
" * {} ({})\n" + " * Moderator? {}\n" +
" * Experience: {}\n" + " * Level: {}\n" +
" * Experience until next level: {}\n").format(
discordMember.name + "#" +
discordMember.discriminator,
discordMember.nick, "Yes"
if discordMember.guild_permissions.manage_guild
else "No", member["experience"],
member["level"],
Server.getExpFromLevel(member["level"] + 1) -
member["experience"])
# Save markdown temporarily
mdFile = open(BotModerator.BOT_MARKDOWN, "w")
mdFile.write(markdown)
mdFile.close()
mdFile = open(BotModerator.BOT_MARKDOWN, "r")
# Send file to DMs; Then delete
await message.author.send(file=discord.File(mdFile))
os.remove(BotModerator.BOT_MARKDOWN)
embed = discord.Embed(
title="File sent.",
description=
"The server information has been sent to your DM's",
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def imgur(self, message, parameters):
"""
"""
attachments = message.attachments
canScroll = False
# Check for no attachments and no parameters
if len(attachments) == 0 and len(parameters) == 0:
embed = getErrorMessage(self._imgur, Image.NOT_ENOUGH_PARAMETERS)
# There was at least one of either
else:
# Check if the first parameter is in the accepted for getting the album to the images
# and getting a scroll embed to show the images
try:
if parameters[0] in self._imgur.getAcceptedParameter(
"image", "me").getAlternatives():
me = True
else:
me = False
except:
me = False
# Get user's imgur album ID
album = await User.getImgurAlbum(message.author)
albumHash = album["hash"]
albumId = album["id"]
# See if user does not have an album attached to them
fields = []
fieldValue = ""
if not albumId:
response = await loop.run_in_executor(
None,
partial(
requests.post,
Image.IMGUR_ALBUM_API,
data={
"title":
"{}#{}".format(message.author.name,
message.author.discriminator),
"description":
"An anonymous imgur album made for the above Discord User"
},
headers={
"Authorization":
"Client-ID {}".format(os.environ["IMGUR_API_KEY"])
}))
response = response.json()
# See if album creation failed
if response["status"] != 200:
error = response["data"]["error"] + "\n"
# Add the error to the result field
if len(fieldValue) + len(
error) > OmegaPsi.MESSAGE_THRESHOLD:
fields.append(fieldValue)
fieldValue = ""
fieldValue += error
# Album creation did not fail
else:
success = "Anonymous Album Created at [this link]({}).\n".format(
Image.IMGUR_ALBUM_URL.format(response["data"]["id"]))
# Add the success message to the result field
if len(fieldValue) + len(
success) > OmegaPsi.MESSAGE_THRESHOLD:
fields.append(fieldValue)
fieldValue = ""
fieldValue += success
# Set the user's imgur album
albumHash = response["data"]["deletehash"]
albumId = response["data"]["id"]
await User.setImgurAlbum(message.author, {
"hash": albumHash,
"id": albumId
})
# Not getting their album and images; Adding one
if not me:
# Get url for each attachment
for attachment in range(len(attachments)):
attachments[attachment] = attachments[attachment].url
attachments += parameters
# Iterate through attachments
for attachment in attachments:
# Upload image
response = await loop.run_in_executor(
None,
partial(requests.post,
Image.IMGUR_IMAGE_API,
data={
"image": attachment,
"album": albumHash
},
headers={
"Authorization":
"Client-ID {}".format(
os.environ["IMGUR_API_KEY"])
}))
print(response.content)
response = response.json()
# See if image upload failed
if response["status"] != 200:
error = response["data"]["error"] + "\n"
# Add the error to the result field
if len(fieldValue) + len(
error) > OmegaPsi.MESSAGE_THRESHOLD:
fields.append(fieldValue)
fieldValue = ""
fieldValue += error
# Image upload did not fail
else:
success = "Anonymous Image Uploaded and Added to your album. [Here]({}) is the direct link to the image.\n".format(
Image.IMGUR_IMAGE_URL.format(
response["data"]["id"]))
# Add the success message to the result field
if len(fieldValue) + len(
success) > OmegaPsi.MESSAGE_THRESHOLD:
fields.append(fieldValue)
fieldValue = ""
fieldValue += success
# Add the trailing result field
if len(fieldValue) > 0:
fields.append(fieldValue)
# Create embed
embed = discord.Embed(
title="Results {}".format("({} / {})".format(
1, len(fields)) if len(fields) > 1 else ""),
description=fields[0],
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color)
# Add all the fields to the embed
count = 1
for field in fields[1:]:
count += 1
embed.add_field(
name="Results {}".format("({} / {})".format(
count, len(fields)) if len(fields) > 1 else ""),
value=field,
inline=False)
# Getting the author's images
else:
# Get the list of images
album = await loop.run_in_executor(
None,
partial(
requests.get,
Image.IMGUR_ALBUM_GET_API.format(albumId),
headers={"Authorization":
"Client-ID f473d8889fc2daf"}))
album = album.json()
# Create the first embed
embed = discord.Embed(
title="Image {}".format(
"({} / {})".format(1, len(album["data"]["images"]))
if len(album["data"]["images"]) > 1 else ""),
description=album["data"]["description"],
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color,
url=album["data"]["link"]).set_image(
url=None if len(album["data"]["images"]) ==
0 else album["data"]["images"][0]["link"]).set_author(
name=album["data"]["title"],
icon_url=message.author.avatar_url
if album["data"]["cover"] == None else
Image.IMGUR_IMAGE_URL.format(
album["data"]["cover"]))
# Create the scrolling embed
self._scrollEmbeds[str(message.author.id)] = {
"message": None,
"images": album["data"]["images"],
"value": 0,
"min": 0,
"max": len(album["data"]["images"]) - 1
}
canScroll = len(album["data"]["images"]) > 0
msg = await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
if canScroll:
for reaction in reactions:
await msg.add_reaction(reaction)
self._scrollEmbeds[str(message.author.id)]["message"] = msg
async def activate(self, message, parameters):
"""Activates commands globally in the bot.
Parameters:
parameters: The parameters to process.
"""
# Check if there are not enough parameters
if len(parameters) < self._activate.getMinParameters():
embed = getErrorMessage(self._activate,
BotModerator.NOT_ENOUGH_PARAMETERS)
# Parameters had the minimum amount of parameters
else:
# Commands held in each parameter
commands = parameters
# Open bot file
bot = await OmegaPsi.openOmegaPsi()
# Iterate through commands
if len(commands) > 0:
result = ""
acCommands = []
for command in commands:
# Iterate through categories
added = False
for category in self._categories:
# Check if command was part of category
commandObject = self._categories[category].getCommand(
command)
if commandObject != None:
acCommands.append(commandObject)
added = True
if not added:
result += "`{}` is not a valid command.\n".format(
command)
# Activate commands
for command in acCommands:
if command.getAlternatives(
)[0] in bot["inactive_commands"]:
bot["inactive_commands"].pop(
command.getAlternatives()[0])
result += "`{}` was activated globally.\n".format(
command.getAlternatives()[0])
else:
result += "`{}` is already globally active.\n".format(
command.getAlternatives()[0])
else:
result = ""
for command in bot["inactive_commands"]:
result += "`{}` was activated globally.\n".format(command)
bot["inactive_commands"] = {}
# Close bot file
await OmegaPsi.closeOmegaPsi(bot)
embed = discord.Embed(name="Activated",
description=result,
colour=self.getEmbedColor() if message.guild
== None else message.author.top_role.color)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def convert(self, message, parameters):
"""Converts a number from the start base to the end base.\n
Parameters:
startBase: The base to convert from.\n
endBase: The base to convert to.\n
number: The number to convert.\n
"""
# Check for not enough parameters
if len(parameters) < self._convert.getMinParameters():
embed = getErrorMessage(self._convert, Code.NOT_ENOUGH_PARAMETERS)
# Check for too many parameters
elif len(parameters) > self._convert.getMaxParameters():
embed = getErrorMessage(self._convert, Code.TOO_MANY_PARAMETERS)
# There were the proper amount of parameters
else:
startBase = "10"
endBase = parameters[0]
number = parameters[1]
if len(parameters) == 3:
startBase = parameters[0]
endBase = parameters[1]
number = parameters[2]
# Only run if start base and end base are valid
if startBase.isdigit() and endBase.isdigit():
startBase = int(startBase)
endBase = int(endBase)
if startBase >= 2 and startBase <= 64 and endBase >= 2 and endBase <= 64:
# Try converting number from startBase to base-10
# Test to see if number is not zero
start = number
title = "Base-{} to Base-{}".format(startBase, endBase)
description = "`{} --> {}`".format(start, number)
# Check if number is not zero; Convert it
if number not in ["0", 0]:
number = convert(number, startBase, endBase)
# Check if number is None; Invalid number for a base
if number == None:
embed = getErrorMessage(self._convert,
Code.BASE_MISMATCH)
# Number is not None; Valid base
else:
# Return number
description = "`{} --> {}`".format(start, number)
embed = discord.Embed(
title=title,
description=description,
colour=self.getEmbedColor() if message.guild
== None else message.author.top_role.color)
# Number is zero; Just send that
else:
embed = discord.Embed(
title=title,
description=description,
colour=self.getEmbedColor() if message.guild
== None else message.author.top_role.color)
# Bases were not within range
else:
embed = getErrorMessage(self._convert,
Code.BASE_OUT_OF_RANGE)
# Bases were not numbers
else:
embed = getErrorMessage(self._convert, Code.INVALID_BASE)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def urban(self, message, parameters):
"""Returns the top 5 urban dictionary entries for the specified term.\n
- term - The term to search on urban dictionary.\n
- discordChannel - The Discord Channel the definition is being sent in.\n
"""
# Check for not enough parameters
if len(parameters) < self._urban.getMinParameters():
embed = getErrorMessage(self._urban, NSFW.NOT_ENOUGH_PARAMETERS)
# There were the proper amount of parameters
else:
term = " ".join(parameters)
# Use requests to get the data in JSON
try:
urlCall = NSFW.URBAN_API_CALL.format(term.replace(" ", "+"))
urbanData = await loop.run_in_executor(None, requests.get,
urlCall)
urbanData = urbanData.json()
# Get first 5 values (or values if there are less than 5)
if len(urbanData["list"]) < 5:
definitions = urbanData["list"]
else:
definitions = urbanData["list"][:5]
# Create discord embed
embed = discord.Embed(
title="{} Results Of `{}`".format(
"Top 5" if len(definitions) > 5 else "", term),
description=" ",
colour=self.getEmbedColor() if message.guild == None else
message.author.top_role.color).set_thumbnail(
url=NSFW.URBAN_ICON)
# Add definitions
defCount = 0
for definition in definitions:
defCount += 1
# Get definition; Split up into multiple fields if necessary
definitionFields = splitText(definition["definition"],
OmegaPsi.MESSAGE_THRESHOLD)
count = 0
for field in definitionFields:
count += 1
embed.add_field(name="Definition {} {}".format(
defCount,
"({} / {})".format(count, len(definitionFields))
if len(definitionFields) > 1 else ""),
value=field,
inline=False)
except:
embed = getErrorMessage(self._urban, NSFW.NO_TERM)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def setStatus(self, message, parameters):
"""Sets the presence of the bot given the activity type and text.\n
Parameters:
activityType: The type of activity to set for the presence.\n
text: The text to set.\n
"""
# Check if parameters is less than minimum parameters
if len(parameters) < self._status.getMinParameters():
embed = getErrorMessage(self._status,
BotModerator.NOT_ENOUGH_PARAMETERS)
# Parameters has minumum parameters
else:
# Activity type is first parameter; Text is every parameter after
activityType = parameters[0]
text = " ".join(parameters[1:])
# Get the specific activity type
activityText = activityType
if activityType in self._status.getAcceptedParameter(
"activity", "playing").getAlternatives():
activityType = discord.ActivityType.playing
activityText = "Playing"
elif activityType in self._status.getAcceptedParameter(
"activity", "streaming").getAlternatives():
activityType = discord.ActivityType.streaming
activityText = "Streaming"
elif activityType in self._status.getAcceptedParameter(
"activity", "listening").getAlternatives():
activityType = discord.ActivityType.listening
activityText = "Listening"
elif activityType in self._status.getAcceptedParameter(
"activity", "watching").getAlternatives():
activityType = discord.ActivityType.watching
activityText = "Watching"
# Update the bot's activity setting
await OmegaPsi.setActivityType(activityType)
await OmegaPsi.setActivityName(text)
# Change the presence of the bot
await self.client.change_presence(
status=discord.Status.online,
activity=discord.Activity(
name=text,
type=activityType,
url="https://www.twitch.tv/FellowHashbrown"))
embed = discord.Embed(
title="Presence Set",
description="Activity: {}\nText: {}\n".format(
activityText, text),
colour=self.getEmbedColor()
if message.guild == None else message.author.top_role.color)
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))
async def levelUp(self, message, parameters):
"""Returns the amount of different interactions a Discord Member needs to level up.
Parameters:
discordMember (discord.Member): The Discord Member to get the interactions of.
interactionType (str): The type of interaction to get.
"""
# Check for too many parameters
if len(parameters) > self._levelUp.getMaxParameters():
embed = getErrorMessage(self._levelUp, Rank.TOO_MANY_PARAMETERS)
# There were the proper amount of parameters
else:
interactionType = None if len(parameters) == 0 else parameters[0]
# Get member info from server
member = await Server.getMember(message.guild, message.author)
# Get member's current and next experience
currentExp = member["experience"]
nextExp = Server.getExpFromLevel(member["level"] + 1)
# Get each interaction type before checking the interaction type
profanity = math.ceil(
(nextExp - currentExp) / (Server.PROFANE_XP + Server.NORMAL_XP)
)
reactions = math.ceil(
(nextExp - currentExp) / Server.REACTION_XP
)
normal = math.ceil(
(nextExp - currentExp) / Server.NORMAL_XP
)
# Check if interaction type is None; Get all stats
if interactionType == None:
embed = discord.Embed(
title = "In order to level up, you need either",
description = "{} Profane Messages\nor\n{} Reactions\nor\n{} Regular Messages".format(
profanity, reactions, normal
),
colour = self.getEmbedColor() if message.guild == None else message.author.top_role.color
)
# Check if interaction type is valid
elif interactionType in self._levelUp.getAcceptedParameter("interaction", "profanity").getAlternatives():
embed = discord.Embed(
title = "In order to level up, you need",
description = "{} Profane Messages".format(profanity),
colour = self.getEmbedColor() if message.guild == None else message.author.top_role.color
)
elif interactionType in self._levelUp.getAcceptedParameter("interaction", "reactions").getAlternatives():
embed = discord.Embed(
title = "In order to level up, you need",
description = "{} Reactions".format(reactions),
colour = self.getEmbedColor() if message.guild == None else message.author.top_role.color
)
elif interactionType in self._levelUp.getAcceptedParameter("interaction", "normal").getAlternatives():
embed = discord.Embed(
title = "In order to level up, you need",
description = "{} Regular Messages".format(normal),
colour = self.getEmbedColor() if message.guild == None else message.author.top_role.color
)
# Interaction type is invalid; error
else:
embed = getErrorMessage(self._levelUp, Rank.INVALID_INTERACTION)
await sendMessage(
self.client,
message,
embed = embed.set_footer(
text = "Requested by {}#{}".format(
message.author.name,
message.author.discriminator
),
icon_url = message.author.avatar_url
)
)
async def todo(self, message, parameters):
"""Runs the todo command.
Parameters:
action (str): What action to perform for the todo command.
item (str): The item to add/remove to/from the TODO list.
"""
# Check for no parameters; list the TODO list
if len(parameters) == 0:
todoList = await OmegaPsi.getToDoList()
todoText = ""
for item in range(len(todoList)):
todoText += "`{}.) {}`\n".format(item + 1, todoList[item])
embed = discord.Embed(
title="TODO List",
description=todoText if len(todoText) > 0 else "Nothing Yet",
colour=self.getEmbedColor()
if message.guild == None else message.author.top_role.color)
# Check for 2 or more parameters
else:
# Check if author is a bot moderator
if await OmegaPsi.isAuthorModerator(message.author):
action = parameters[0]
# There is nothing to add
if len(parameters) == 1:
embed = getErrorMessage(self._todo,
BotModerator.NOT_ENOUGH_PARAMETERS)
# Check if action is valid
elif action in self._todo.getAcceptedParameter(
"action", "add").getAlternatives():
# Check if index is given
if parameters[1].isdigit():
index = int(parameters[1])
item = " ".join(parameters[2:])
else:
index = 0
item = " ".join(parameters[1:])
success = await OmegaPsi.addToDo(item, index)
embed = discord.Embed(
title="Added TODO Item"
if success["success"] else "Failed to add TODO Item",
description=success["reason"],
colour=self.getEmbedColor() if message.guild == None
else message.author.top_role.color)
elif action in self._todo.getAcceptedParameter(
"action", "remove").getAlternatives():
success = await OmegaPsi.removeToDo(" ".join(
parameters[1:]))
embed = discord.Embed(
title="Removed TODO Item" if success["success"] else
"Failed to remove TODO Item",
description=success["reason"],
colour=self.getEmbedColor() if message.guild == None
else message.author.top_role.color)
# Action is invalid
else:
embed = getErrorMessage(self._todo,
BotModerator.INVALID_PARAMETER)
# Author is not bot moderator
else:
embed = OmegaPsi.getNoAccessError()
await sendMessage(
self.client,
message,
embed=embed.set_footer(text="Requested by {}#{}".format(
message.author.name, message.author.discriminator),
icon_url=message.author.avatar_url))