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.")