def test_without_role_check_without_unwanted_role(context): context.guild = True role = MagicMock() role.id = 42 context.author.roles = (role,) assert checks.without_role_check(context, role.id + 10)
def bot_check(ctx: Context) -> bool: """Block any command within the verification channel that is not !accept.""" if ctx.channel.id == constants.Channels.verification and without_role_check( ctx, *constants.MODERATION_ROLES): return ctx.command.name == "accept" else: return True
async def new_reminder(self, ctx: Context, expiration: Duration, *, content: str) -> t.Optional[discord.Message]: """ Set yourself a simple reminder. Expiration is parsed per: http://strftime.org/ """ embed = discord.Embed() # If the user is not staff, we need to verify whether or not to make a reminder at all. if without_role_check(ctx, *STAFF_ROLES): # If they don't have permission to set a reminder in this channel if ctx.channel.id not in WHITELISTED_CHANNELS: embed.colour = discord.Colour.red() embed.title = random.choice(NEGATIVE_REPLIES) embed.description = "Sorry, you can't do that here!" return await ctx.send(embed=embed) # Get their current active reminders active_reminders = await self.bot.api_client.get( 'bot/reminders', params={ 'author__id': str(ctx.author.id) } ) # Let's limit this, so we don't get 10 000 # reminders from kip or something like that :P if len(active_reminders) > MAXIMUM_REMINDERS: embed.colour = discord.Colour.red() embed.title = random.choice(NEGATIVE_REPLIES) embed.description = "You have too many active reminders!" return await ctx.send(embed=embed) # Now we can attempt to actually set the reminder. reminder = await self.bot.api_client.post( 'bot/reminders', json={ 'author': ctx.author.id, 'channel_id': ctx.message.channel.id, 'jump_url': ctx.message.jump_url, 'content': content, 'expiration': expiration.isoformat() } ) now = datetime.utcnow() - timedelta(seconds=1) humanized_delta = humanize_delta(relativedelta(expiration, now)) # Confirm to the user that it worked. await self._send_confirmation( ctx, on_success=f"Your reminder will arrive in {humanized_delta}!", reminder_id=reminder["id"], delivery_dt=expiration, ) self.schedule_task(reminder["id"], reminder)
async def _check_mentions(ctx: Context, mentions: t.Iterable[Mentionable]) -> t.Tuple[bool, str]: """ Returns whether or not the list of mentions is allowed. Conditions: - Role reminders are Mods+ - Reminders for other users are Helpers+ If mentions aren't allowed, also return the type of mention(s) disallowed. """ if without_role_check(ctx, *STAFF_ROLES): return False, "members/roles" elif without_role_check(ctx, *MODERATION_ROLES): return all(isinstance(mention, discord.Member) for mention in mentions), "roles" else: return True, ""
async def new_reminder(self, ctx: Context, expiration: ExpirationDate, *, content: str): """ Set yourself a simple reminder. """ embed = Embed() # If the user is not staff, we need to verify whether or not to make a reminder at all. if without_role_check(ctx, *STAFF_ROLES): # If they don't have permission to set a reminder in this channel if ctx.channel.id not in WHITELISTED_CHANNELS: embed.colour = Colour.red() embed.title = random.choice(NEGATIVE_REPLIES) embed.description = "Sorry, you can't do that here!" return await ctx.send(embed=embed) # Get their current active reminders active_reminders = await self.bot.api_client.get( 'bot/reminders', params={'user__id': str(ctx.author.id)}) # Let's limit this, so we don't get 10 000 # reminders from kip or something like that :P if len(active_reminders) > MAXIMUM_REMINDERS: embed.colour = Colour.red() embed.title = random.choice(NEGATIVE_REPLIES) embed.description = "You have too many active reminders!" return await ctx.send(embed=embed) # Now we can attempt to actually set the reminder. reminder = await self.bot.api_client.post('bot/reminders', json={ 'author': ctx.author.id, 'channel_id': ctx.message.channel.id, 'content': content, 'expiration': expiration.isoformat() }) # Confirm to the user that it worked. await self._send_confirmation( ctx, on_success="Your reminder has been created successfully!") loop = asyncio.get_event_loop() self.schedule_task(loop, reminder["id"], reminder)
async def predicate(ctx: Context) -> bool: return without_role_check(ctx, *role_ids)
def test_without_role_check_returns_true_without_unwanted_role(self): """`without_role_check` returns `True` if `Context.author` does not have unwanted role.""" role_id = 42 self.ctx.author.roles.append(MockRole(id=role_id)) self.assertTrue(checks.without_role_check(self.ctx, role_id + 10))
def test_without_role_check_returns_false_with_unwanted_role(self): """`without_role_check` returns `False` if `Context.author` has unwanted role.""" role_id = 42 self.ctx.author.roles.append(MockRole(id=role_id)) self.assertFalse(checks.without_role_check(self.ctx, role_id))
def test_without_role_check_without_guild(self): """`without_role_check` should return `False` when `Context.guild` is None.""" self.ctx.guild = None self.assertFalse(checks.without_role_check(self.ctx))
def test_without_role_check_without_guild(context): context.guild = None assert not checks.without_role_check(context)
async def new_reminder(self, ctx: Context, mentions: Greedy[Mentionable], expiration: Duration, *, content: str) -> None: """ Set yourself a simple reminder. Expiration is parsed per: http://strftime.org/ """ # If the user is not staff, we need to verify whether or not to make a reminder at all. if without_role_check(ctx, *STAFF_ROLES): # If they don't have permission to set a reminder in this channel if ctx.channel.id not in WHITELISTED_CHANNELS: await send_denial(ctx, "Sorry, you can't do that here!") return # Get their current active reminders active_reminders = await self.bot.api_client.get( 'bot/reminders', params={'author__id': str(ctx.author.id)}) # Let's limit this, so we don't get 10 000 # reminders from kip or something like that :P if len(active_reminders) > MAXIMUM_REMINDERS: await send_denial(ctx, "You have too many active reminders!") return # Remove duplicate mentions mentions = set(mentions) mentions.discard(ctx.author) # Filter mentions to see if the user can mention members/roles if not await self.validate_mentions(ctx, mentions): return mention_ids = [mention.id for mention in mentions] # Now we can attempt to actually set the reminder. reminder = await self.bot.api_client.post('bot/reminders', json={ 'author': ctx.author.id, 'channel_id': ctx.message.channel.id, 'jump_url': ctx.message.jump_url, 'content': content, 'expiration': expiration.isoformat(), 'mentions': mention_ids, }) now = datetime.utcnow() - timedelta(seconds=1) humanized_delta = humanize_delta(relativedelta(expiration, now)) mention_string = (f"Your reminder will arrive in {humanized_delta} " f"and will mention {len(mentions)} other(s)!") # Confirm to the user that it worked. await self._send_confirmation( ctx, on_success=mention_string, reminder_id=reminder["id"], delivery_dt=expiration, ) self.schedule_reminder(reminder)
async def new_reminder(self, ctx: Context, duration: str, *, content: str): """ Set yourself a simple reminder. """ embed = Embed() # If the user is not staff, we need to verify whether or not to make a reminder at all. if without_role_check(ctx, *STAFF_ROLES): # If they don't have permission to set a reminder in this channel if ctx.channel.id not in WHITELISTED_CHANNELS: embed.colour = Colour.red() embed.title = random.choice(NEGATIVE_REPLIES) embed.description = "Sorry, you can't do that here!" return await ctx.send(embed=embed) # Get their current active reminders response = await self.bot.http_session.get( url=URLs.site_reminders_user_api.format(user_id=ctx.author.id), headers=self.headers) active_reminders = await response.json() # Let's limit this, so we don't get 10 000 # reminders from kip or something like that :P if len(active_reminders) > MAXIMUM_REMINDERS: embed.colour = Colour.red() embed.title = random.choice(NEGATIVE_REPLIES) embed.description = "You have too many active reminders!" return await ctx.send(embed=embed) # Now we can attempt to actually set the reminder. try: response = await self.bot.http_session.post( url=URLs.site_reminders_api, headers=self.headers, json={ "user_id": str(ctx.author.id), "duration": duration, "content": content, "channel_id": str(ctx.channel.id) }) response_data = await response.json() # AFAIK only happens if the user enters, like, a quintillion weeks except ClientResponseError: embed.colour = Colour.red() embed.title = random.choice(NEGATIVE_REPLIES) embed.description = ( "An error occurred while adding your reminder to the database. " "Did you enter a reasonable duration?") log.warn( f"User {ctx.author} attempted to create a reminder for {duration}, but failed." ) return await ctx.send(embed=embed) # Confirm to the user whether or not it worked. failed = await self._send_confirmation( ctx, response_data, on_success="Your reminder has been created successfully!") # If it worked, schedule the reminder. if not failed: loop = asyncio.get_event_loop() reminder = response_data["reminder"] self.schedule_task(loop, reminder["id"], reminder)