async def silence(self,
ctx: Context,
duration: HushDurationConverter = 10) -> None:
"""
Silence the current channel for `duration` minutes or `forever`.
Duration is capped at 15 minutes, passing forever makes the silence indefinite.
Indefinitely silenced channels get added to a notifier which posts notices every 15 minutes from the start.
"""
await self._get_instance_vars_event.wait()
log.debug(f"{ctx.author} is silencing channel #{ctx.channel}.")
if not await self._silence(
ctx.channel, persistent=(duration is None), duration=duration):
await ctx.send(
f"{Emojis.cross_mark} current channel is already silenced.")
return
if duration is None:
await ctx.send(
f"{Emojis.check_mark} silenced current channel indefinitely.")
return
await ctx.send(
f"{Emojis.check_mark} silenced current channel for {duration} minute(s)."
)
self.scheduler.schedule_later(duration * 60, ctx.channel.id,
ctx.invoke(self.unsilence))
async def lock(self,
ctx: Context = None,
duration: t.Optional[Duration] = None,
*,
reason: t.Optional[str]) -> None:
"""
Disallow everyones permission to talk in this channel
for given `duration` or indefinitely.
"""
logger.debug(f"Channel #{ctx.channel} was silenced by {ctx.author}.")
if not await self._lock(ctx.channel):
await ctx.send(":x: This channel is already locked.")
return
reason = "No reason specified" if not reason else reason
if not duration:
await ctx.send(f"🔒 Channel locked indefinitely: {reason}.")
return
await ctx.send(
f"🔒 Channel locked for {stringify_reldelta(relativedelta(seconds=duration))}: {reason}."
)
self.timer.delay(duration, ctx.channel.id, ctx.invoke(self.unlock))
async def _schedule_unsilence(self, ctx: Context,
duration: Optional[int]) -> None:
"""Schedule `ctx.channel` to be unsilenced if `duration` is not None."""
if duration is None:
await self.unsilence_timestamps.set(ctx.channel.id, -1)
else:
self.scheduler.schedule_later(duration * 60, ctx.channel.id,
ctx.invoke(self.unsilence))
unsilence_time = datetime.now(tz=timezone.utc) + timedelta(
minutes=duration)
await self.unsilence_timestamps.set(ctx.channel.id,
unsilence_time.timestamp())
async def start_(self,ctx: commands.Context,arg):
if ctx.author.id in self.active_users: ctx.invoke(self.stop_)
try:
gid = int(arg)
except:
embed = utility.Embed(None,"That isn't a valid server ID!")
await ctx.send(embed=embed)
return
try:
guild = self.bot.get_guild(gid) or await self.bot.fetch_guild(gid)
member = guild.get_member(ctx.author.id) or await guild.fetch_member(ctx.author.id)
except discord.Forbidden:
embed = utility.Embed(None,"I couldn't find that server, are you sure I'm in it?")
await ctx.send(embed=embed)
return
except:
raise
embed = utility.Embed("Monitoring your messages","Will go until you run `..stop` or 10 minutes of silence, use `..continue` to refresh timer")
await ctx.send(embed=embed)
event = asyncio.Event()
self.active_users[ctx.author.id] = { "id":gid, "timer": asyncio.create_task(self.timer(event)), "event": event }
if len(self.active_users) == 1:
self.bot.add_listener(self.monitor, "on_message")
asyncio.create_task(self.wait_to_stop(ctx, event))
async def lock(self,
ctx: Context,
duration: t.Optional[Duration] = None,
*,
reason: t.Optional[str]) -> None:
"""
Disallow everyones permission to talk in this channel
for given `duration` or indefinitely.
"""
if duration is None:
duration = float("inf")
max_duration = await Permissions.get_permission_from_member(
self.bot.db_engine, self.bot, "lock", ctx.guild, ctx.author)
if duration > max_duration:
raise MissingPermissions(["sufficient_locktime"])
logger.debug(f"Channel #{ctx.channel} was silenced by {ctx.author}.")
status = await self._lock(ctx.channel)
if status == 0:
await ctx.send(":x: This channel is already locked.")
return
elif status == -1:
await ctx.send(
":x: This channel was already locked manually using channel permissions."
)
return
reason = "No reason specified" if not reason else reason
if duration == float("inf"):
await ctx.send(f"🔒 Channel locked indefinitely: {reason}.")
return
await ctx.send(
f"🔒 Channel locked for {stringify_duration(duration)}: {reason}.")
self.timer.delay(duration, ctx.channel.id, ctx.invoke(self.unlock))
async def lock(self,
ctx: Context,
duration: t.Optional[Duration] = None,
*,
reason: t.Optional[str]) -> None:
"""
Disallow everyones permission to talk in this channel
for given `duration` or indefinitely.
"""
if duration == float("inf"):
duration = None
max_duration = await self.permissions_db.get_locktime(
ctx.guild, ctx.author)
if any([
not duration and max_duration != -1, duration
and max_duration != -1 and duration > max_duration
]):
raise MissingPermissions(["sufficient_locktime"])
logger.debug(f"Channel #{ctx.channel} was silenced by {ctx.author}.")
if not await self._lock(ctx.channel):
await ctx.send(":x: This channel is already locked.")
return
reason = "No reason specified" if not reason else reason
if not duration:
await ctx.send(f"🔒 Channel locked indefinitely: {reason}.")
return
await ctx.send(
f"🔒 Channel locked for {stringify_duration(duration)}: {reason}."
)
self.timer.delay(duration, ctx.channel.id, ctx.invoke(self.unlock))
