async def on_member_unban(self, guild, member):
user = member
emb = Embed(title="Member Unbanned", colour=Colour.red())
emb.add_field(name="Member:", value=member.name, inline=True)
emb.set_thumbnail(url=user.avatar_url)
logchannel = self.bot.logs_channel
await logchannel.send("", embed=emb)
async def command_error(self, ctx, error):
if isinstance(error, CogBadArgument):
embed = Embed()
embed.colour = Colour.red()
embed.description = str(error)
embed.title = random.choice(self.FAIL_TITLES)
await ctx.send(embed=embed)
async def send_reminder(self, reminder: dict, late: relativedelta = None) -> None:
"""Send the reminder."""
channel = self.bot.get_channel(reminder["channel_id"])
user = self.bot.get_user(reminder["author"])
embed = Embed()
embed.colour = Colour.blurple()
embed.set_author(
icon_url=Icons.remind_blurple,
name="It has arrived!"
)
embed.description = f"Here's your reminder: `{reminder['content']}`."
if reminder.get("jump_url"): # keep backward compatibility
embed.description += f"\n[Jump back to when you created the reminder]({reminder['jump_url']})"
if late:
embed.colour = Colour.red()
embed.set_author(
icon_url=Icons.remind_red,
name=f"Sorry it arrived {humanize_delta(late, max_units=2)} late!"
)
await channel.send(
content=user.mention,
embed=embed
)
await self._delete_reminder(reminder["id"])
async def set(self, ctx, set_type=None):
if set_type.casefold() == "join":
for channel in ctx.guild.channels:
if channel.name == ctx.channel.name:
self.join = channel
embed = Embed(
title="Channel Set",
description=
"This channel will now be the welcomer channel for joining members.",
colour=Colour.green())
await ctx.send(embed=embed)
elif set_type.casefold() == "leave":
for channel in ctx.guild.channels:
if channel.name == ctx.channel.name:
self.leave = channel
embed = Embed(
title="Channel Set",
description=
"This channel will now be the welcomer channel for leaving members.",
colour=Colour.green())
await ctx.send(embed=embed)
else:
embed = Embed(
title="Usage:",
description="`!set [join, leave]`\n**Example:** `!set join`",
colour=Colour.red())
await ctx.send(embed=embed)
async def send_reminder(self, reminder, late: relativedelta = None):
"""
Send the reminder.
:param reminder: The data about the reminder.
:param late: How late the reminder is (if at all)
"""
channel = self.bot.get_channel(int(reminder["channel_id"]))
user = self.bot.get_user(int(reminder["user_id"]))
embed = Embed()
embed.colour = Colour.blurple()
embed.set_author(icon_url=Icons.remind_blurple, name="It has arrived!")
embed.description = f"Here's your reminder: `{reminder['content']}`"
if late:
embed.colour = Colour.red()
embed.set_author(
icon_url=Icons.remind_red,
name=
f"Sorry it arrived {humanize_delta(late, max_units=2)} late!")
await channel.send(content=user.mention, embed=embed)
await self._delete_reminder(reminder["id"])
async def _send_confirmation(ctx: Context, response: dict,
on_success: str):
"""
Send an embed confirming whether or not a change was made successfully.
:return: A Boolean value indicating whether it failed (True) or passed (False)
"""
embed = Embed()
if not response.get("success"):
embed.colour = Colour.red()
embed.title = random.choice(NEGATIVE_REPLIES)
embed.description = response.get("error_message",
"An unexpected error occurred.")
log.warn(
f"Unable to create/edit/delete a reminder. Response: {response}"
)
failed = True
else:
embed.colour = Colour.green()
embed.title = random.choice(POSITIVE_REPLIES)
embed.description = on_success
failed = False
await ctx.send(embed=embed)
return failed
def __init__(self, title="", description=""):
super().__init__()
self.timestamp = datetime.utcnow()
self.colour = Colour.red()
self.url = "https://github.com/bundestagsBot/bundestagsBot"
self.title = title
self.description = description
def _get_colour(self) -> Colour:
try:
last_title = self.__incidentdata.fields[-1].name
status = last_title.split(" ")[0].lower()
if status == "identified":
return Colour.red()
elif status in [
"update",
"monitoring",
"investigating",
"scheduled", # decided to put this in orange as is in future, not now
"in", # scheduled - full is "in progress"
"verifying",
]:
return Colour.orange()
elif status in ["resolved", "completed"]:
return Colour.green()
else:
return Colour(1812720)
except Exception: # hopefully never happens but will keep this for a while
_log.warning(
f"Error with getting correct colour for {self.__service}. The update will still "
"be sent.",
exc_info=True,
)
return Colour(1812720)
async def _tickemaster_count(ctx, *, event_id):
# get count
logger.info("fetching event ticket count")
url = f'{API_BASE_URL}/tmstockchecker?access_code={API_ACCESS_CODE}&event_id={event_id}'
count_response = await http_get(url)
if not count_response or "sections" not in count_response:
await ctx.send("Error fetching info from Ticketmaster")
return
# get info
logger.info("fetching event info")
url = f'{API_BASE_URL}/tmstockchecker/info?access_code={API_ACCESS_CODE}&event_id={event_id}'
info_response = await http_get(url)
event_name = info_response["event_name"] if info_response["event_name"] else event_id
event_link = info_response["event_link"] if info_response["event_link"] \
else f"https://www1.ticketmaster.com/events/{event_id}"
event_city = info_response["event_city"]
event_venue = info_response["event_venue"]
event_datetime = info_response["event_date"]
# create the embed
bot_msg = BotResponse("Ticketmaster Inventory Count", event_id, Colour.red())
bot_msg.set_name(event_name)
bot_msg.set_url(event_link)
bot_msg.set_city(event_city)
bot_msg.set_venue(event_venue)
bot_msg.set_datetime(event_datetime)
for section in count_response["sections"]:
bot_msg.add_section(section["section"], section["count"])
bot_msg.build_display()
await ctx.send(embed=bot_msg)
async def team_command(self, ctx: Context):
"""
Get a list of every member of the team
"""
response = await self.bot.http_session.get(
TEAM_URL.format(team_id=CLICKUP_TEAM), headers=HEADERS)
result = await response.json()
if "err" in result:
log.error("ClickUp responded to the team request with an error!\n"
f"error code: '{result['ECODE']}'\n"
f"error: {result['err']}")
embed = Embed(colour=Colour.red(),
description=f"`{result['ECODE']}`: {result['err']}")
else:
log.debug(
f"{ctx.author} requested a list of team members. Preparing the list..."
)
embed = Embed(colour=Colour.blurple())
for member in result["team"]["members"]:
embed.add_field(name=member["user"]["username"],
value=member["user"]["id"])
embed.set_author(
name="ClickUp Members",
icon_url="https://clickup.com/landing/favicons/favicon-32x32.png",
url=f"https://app.clickup.com/{CLICKUP_TEAM}/{CLICKUP_SPACE}/")
log.debug("List fully prepared, returning list to channel.")
await ctx.send(embed=embed)
class WebhookHandler(logging.Handler):
_colours = {
logging.DEBUG: Colour.light_grey(),
logging.INFO: Colour.gold(),
logging.WARNING: Colour.orange(),
logging.ERROR: Colour.red(),
logging.CRITICAL: Colour.dark_red()
}
def __init__(self, webhook_url, level=logging.NOTSET):
super().__init__(level)
self._webhook_logger = EmbedWebhookLogger(webhook_url)
def emit(self, record: logging.LogRecord):
self.format(record)
message = f'{record.message}\n{record.exc_text or ""}'
message = message[:1987] + '...' if len(message) > 1987 else message
self._webhook_logger.log(
Embed(colour=self._colours.get(record.levelno),
title=record.name,
description=f'```py\n{message}\n```',
timestamp=datetime.datetime.fromtimestamp(
record.created)).add_field(
name=ZWSP,
value=f'{record.filename}:{record.lineno}'))
async def on_command_error(self, ctx, error):
logging_info(f"on_command_error triggered")
if isinstance(error, commands.BadArgument):
logging_info("BadArgument handler ran\n----------")
return await ctx.send("B-Baka!! You've given a bad argument!!")
elif isinstance(error, commands.CommandNotFound):
logging_info("CommandNotFound handler ran\n----------")
return await ctx.send("S-Sorry Senpai, I couldn't find that command qwq", delete_after=20)
elif isinstance(error, commands.BotMissingPermissions):
logging_info(f"BotMissingPermissions handler ran - {error.missing_perms[0]}\n----------")
return await ctx.send(f"Bot missing the following permissions: {error.missing_perms[0]}")
elif isinstance(error, commands.NotOwner):
logging_info("NotOwner handler ran\n----------")
return await ctx.send('Only my owner can do that with me~ >w<')
elif isinstance(error, commands.CommandOnCooldown):
logging_info("CommandOnCooldown handler ran\n----------")
date = str(timedelta(seconds=ceil(error.retry_after))).split(':')
return await ctx.send(f"S-Senpai, I'm cooling down! O//w//O\nplease wait {date[0]} hours, {date[1]} minutes and {date[2]} seconds uwu")
elif isinstance(error, commands.MissingRequiredArgument):
logging_info("MissingRequiredArgument handler ran\n----------")
# \n``Missing: {error.param.name}``")
return await ctx.send(f"You didn't give a required argument, B-Baka!")
elif isinstance(error, commands.MissingPermissions):
logging_info("MissingPermissions handler ran\n----------")
return await ctx.send("Sorry Senpai, you don't have the permissions for this command qwq")
elif isinstance(error, commands.NSFWChannelRequired):
logging_info("NSFWChannelRequired hander ran\n----------")
return await ctx.reply("P-Pervert! <a:LoliTriggered:754632379397570620>\n``This command can only be ran in an nsfw channel``")
logging_error(error)
await ctx.send(embed=Embed(
title="Uh oh. Something bad happened <a:ppMeltdown:754632378386874459>",
description=f"An unhandled error occured.\nIf this keeps occuring open an [issue report](https://github.com/thijnmens/ScuffedBot/issues) or go pester one of the retards that 'code' this mess.\n\n```{error}```",
colour=Colour.red()
))
return await self.bot.get_channel(860609168741498920).send(embed=Embed(
title=f"{ctx.command} in {ctx.guild.name}",
description=f"{ctx.guild.id}\n**Message Content**```{ctx.message.content}```\n**Error**```{error}```",
colour=Colour.red()
))
async def lol_error(self, ctx: commands.Context, ex):
if isinstance(ex, commands.errors.CommandInvokeError):
message = f'Argumento <__nickname__> é necessário para dar continuidade\nExemplo: {ctx.message.content} <__nickname__>'
embed = Embed(color=Colour.red())
embed.title = 'Argumento faltando'
embed.description = message
logger.error('Error lol: %s', ex, exc_info=False)
await handler.send_message(ctx, logger, embed=embed)
async def register(self, ctx, public_key: str):
if not self.bot.voters_manager.check_voter(user_id=int(ctx.author.id)):
if match(r'^XCA[A-Za-z0-9]{95}$|^XCB[A-Za-z0-9]{107}', public_key) is not None:
if self.bot.voters_manager.register_voter(user_id=int(ctx.author.id), public_key=public_key):
details = f"You have successfully registered yourself into the database."
await sys_message(ctx=ctx, details=details, c=Colour.green())
else:
details = f"Something went wrong on the backend. Please try again later. We apologize for " \
f"inconvenience"
await sys_message(ctx=ctx, details=details, c=Colour.red())
else:
details = f"You have provided wrong XCASH public key. Please check again. "
await sys_message(ctx=ctx, details=details, c=Colour.red())
else:
details = f"You have already registered yourself into the system. Please use command. "
await sys_message(ctx=ctx, details=details, c=Colour.red())
async def oshimashi(self, ctx: SlashContext, member: str = ''):
await ctx.defer()
if not (role := hkd.get_wug_role(ctx.guild, member)):
await ctx.send(embed=hkd.create_embed(
description=
"Couldn't find that role. Use **/help roles** to show additional help on how to get roles.",
colour=Colour.red()))
return
async def eventsin(self, ctx: SlashContext, month: str, member: str = ''):
await ctx.defer()
if (search_month := hkd.parse_month(month)) == 'None':
await ctx.send(embed=hkd.create_embed(
description=
"Couldn't find any events. Please follow this format for searching for events: **/eventsin** April Mayushii.",
colour=Colour.red()))
return
async def info_error(self, ctx, error):
embed = Embed(colour=Colour.red())
embed.set_footer(text="Usage: !bj type amount")
embed.add_field(name='Error',
value=error.args[0].replace(
"Command raised an exception: Exception: ", ""))
await ctx.send(embed=embed)
raise error
def failure_embed(message: str) -> Embed:
"""
Constructs failure embed with fixed title:Failure and color:red
:param message: embed description
:return: Embed object
"""
return _simple_embed(message, "Failure", Colour.red())
async def server_error_response(destination, error, title):
"""
Server Response Error Handler
"""
horizon_err = Embed(title=f':exclamation: {title} :exclamation:',
colour=Colour.red())
horizon_err.add_field(name=f'Error Details', value=f'{error}')
await destination.send(embed=horizon_err)
async def height_error(self, ctx, error):
if isinstance(error, commands.BadArgument):
await customMessages.system_message(
ctx=ctx,
c=Colour.red(),
title="Wrong Block Height form provided",
error_details="Block height needs to be provided as INTEGER",
destination=ctx.channel)
def error_ar(ctx, used=None, description=None, aliases=None, type=None):
embed = Embed(
description=
"> **الأستعمال:** `{}{}`\n> **الوصف:** `{}` \n> **الأختصارات:** `{}`\n> "
"**النوع:** `{}`".format(db.get_prefix(ctx=ctx), used, description,
aliases, type),
color=Colour.red())
return embed
async def send_denial(ctx: Context, reason: str) -> None:
"""Send an embed denying the user with the given reason."""
embed = Embed()
embed.colour = Colour.red()
embed.title = random.choice(NEGATIVE_REPLIES)
embed.description = reason
await ctx.send(embed=embed)
async def rich_embed(self, ctx: Context):
embed = Embed()
embed.colour = Colour.red()
embed.set_author(name="Test User Bot", )
embed.description = "Sending a rich embed!"
await self.bot.get_channel(DEV_TEST).send(embed=embed)
async def blocks_error(self, ctx, error):
if isinstance(error, commands.CheckFailure):
await customMessages.system_message(ctx=ctx, c=Colour.red(), title="Missing required permission",
error_details="In order to be able to access this area of "
" commands, you MUST be a Discord Server Owner and "
"command executed on channel of the community where"
" bot has access to.",
destination=ctx.channel)
def test_role_info_command(cog, ctx):
dummy_role = MagicMock(spec=Role)
dummy_role.name = "Dummy"
dummy_role.colour = Colour.blurple()
dummy_role.id = 112233445566778899
dummy_role.position = 10
dummy_role.permissions = Permissions(0)
dummy_role.members = [ctx.author]
admin_role = MagicMock(spec=Role)
admin_role.name = "Admin"
admin_role.colour = Colour.red()
admin_role.id = 998877665544332211
admin_role.position = 3
admin_role.permissions = Permissions(0)
admin_role.members = [ctx.author]
ctx.guild.roles = [dummy_role, admin_role]
cog.role_info.can_run = AsyncMock()
cog.role_info.can_run.return_value = True
coroutine = cog.role_info.callback(cog, ctx, dummy_role, admin_role)
assert asyncio.run(coroutine) is None
assert ctx.send.call_count == 2
(_, dummy_kwargs), (_, admin_kwargs) = ctx.send.call_args_list
dummy_embed = dummy_kwargs["embed"]
admin_embed = admin_kwargs["embed"]
assert dummy_embed.title == "Dummy info"
assert dummy_embed.colour == Colour.blurple()
assert dummy_embed.fields[0].value == str(dummy_role.id)
assert dummy_embed.fields[1].value == f"#{dummy_role.colour.value:0>6x}"
assert dummy_embed.fields[2].value == "0.63 0.48 218"
assert dummy_embed.fields[3].value == "1"
assert dummy_embed.fields[4].value == "10"
assert dummy_embed.fields[5].value == "0"
assert admin_embed.title == "Admin info"
assert admin_embed.colour == Colour.red()
async def send_notminer_msg(message):
embed = Embed(
title="ERROR",
description="You don't have a mining rig yet!\n**TIP:** `!crypto market buy rig`",
colour=Colour.red()
)
await message.channel.trigger_typing()
await asyncio.sleep(2)
await message.send(embed=embed)
async def send_notregistered_msg(message):
embed = Embed(
title="ERROR",
description=
"You are not registered to the database!\n**TIP:** `!register`",
colour=Colour.red())
await message.channel.trigger_typing()
await asyncio.sleep(2)
await message.send(embed=embed)
async def SendError(ctx,
error,
color=Colour.red(),
tip="!help to see the list of commands."):
embed = Embed(title='An Error has occurred',
description=f'**Error:** `{error}`',
colour=color)
embed.set_footer(text=f'Tip: {tip}')
await ctx.send(embed=embed)
async def send_error_message(self, error: HelpQueryNotFound) -> None:
"""Send the error message to the channel."""
embed = Embed(colour=Colour.red(), title=str(error))
if getattr(error, "possible_matches", None):
matches = "\n".join(f"`{match}`" for match in error.possible_matches)
embed.description = f"**Did you mean:**\n{matches}"
await self.context.send(embed=embed)
async def clean_gallery(self) -> None:
"""Remove messages except images from #gallery channel."""
logger.info("CLEAN GALLERY loop running!")
gallery_channel: TextChannel = await self.bot.fetch_channel(
self.bot.conf["GALLERY_CHANNEL_ID"])
reporting_channel: TextChannel = await self.bot.fetch_channel(
self.bot.conf["BOT_STATS_ID"])
while not self.bot.is_closed():
# wait for correct time before purging.
sleep_for: int = self.time_until_midnight()
minutes, seconds = divmod(sleep_for, 60)
hours, minutes = divmod(minutes, 60)
logger.info(f"Purging in {hours} hours {minutes} minutes.")
await reporting_channel.send(
f"```Purging in {hours} hours {minutes} minutes.```")
await asyncio.sleep(sleep_for)
logger.info("Purging Messages...")
def filter_msgs(m: Message) -> bool:
# Do not delete message which has an attachment, eg: image.
if m.attachments:
return False
return True
current_time: datetime = datetime.utcnow()
week_before: datetime = current_time - ONE_WEEK
deleted_messages: list = await gallery_channel.purge(
limit=None, check=filter_msgs, after=week_before)
logger.info(f"{len(deleted_messages)} have been deleted.")
if deleted_messages:
embed: Embed = Embed(colour=Colour.red())
embed.title = f"{len(deleted_messages)} Messages have been deleted."
embed.description = ""
for message in deleted_messages:
embed.description += f"\n**From: {message.author}**\n{message.content}\n"
try:
await reporting_channel.send(embed=embed)
except Exception as e:
if isinstance(e, HTTPException):
logger.warning(
"Embed Body too long for reporting message, sending file instead."
)
deleted_messages_file = Path("deleted_messages.txt")
deleted_messages_file.write_text(embed.description)
file_object = File(fp=str(deleted_messages_file),
filename="Deleted messages")
await reporting_channel.send(file=file_object)
else:
await reporting_channel.send("0 Messages have been deleted.")
