async def get_infraction_pages(guild_id, query, amount):
if f"{guild_id}_{query}" not in cache.keys():
if query is None:
infs = Infraction.select().where(Infraction.guild_id == guild_id).order_by(Infraction.id.desc()).limit(amount)
else:
infs = Infraction.select().where((Infraction.guild_id == guild_id) & (
(Infraction.user_id == query) | (Infraction.mod_id == query))).order_by(Infraction.id.desc()).limit(amount)
out = ""
longest_user = 0
longest_mod = 9
longest_type = 4
longest_id = len(str(infs[0].id)) if len(infs) > 0 else 2
for inf in infs:
user = await Utils.username(inf.user_id)
longest_user = max(longest_user, len(user))
mod = await Utils.username(inf.mod_id)
longest_mod = max(longest_mod, len(mod))
longest_type = max(longest_type, len(inf.type))
for inf in infs:
user = await Utils.username(inf.user_id)
mod = await Utils.username(inf.mod_id)
out += f"{Utils.pad(str(inf.id), longest_id)} | {Utils.pad(user, longest_user)} | {Utils.pad(mod, longest_mod)} | {inf.start} | {Utils.pad(inf.type, longest_type)} | {inf.reason}\n"
prefix = f"{Utils.pad('id', longest_id)} | {Utils.pad('user', longest_user-1)}| {Utils.pad('moderator', longest_mod-1)}| timestamp | {Utils.pad('type', longest_type)} | reason"
prefix = f"```md\n{prefix}\n{'-' * len(prefix)}\n"
pages = Pages.paginate(out, prefix=prefix, suffix="```")
cache[f"{guild_id}_{query}"] = pages
if len(cache.keys()) > 20:
del cache[list(cache.keys())[0]]
return cache[f"{guild_id}_{query}"]
async def fetch_infraction_pages(guild_id, query, amount, fields, requested):
key = get_key(guild_id, query, fields, amount)
if query == "":
infs = Infraction.select().where(
Infraction.guild_id == guild_id).order_by(
Infraction.id.desc()).limit(50)
else:
infs = Infraction.select().where((Infraction.guild_id == guild_id) & (
("[user]" in fields and isinstance(query, int) and Infraction.
user_id == query) | ("[mod]" in fields and isinstance(query, int)
and Infraction.mod_id == query)
| ("[reason]" in fields and fn.lower(Infraction.reason).contains(
str(query).lower())))).order_by(Infraction.id.desc()).limit(
int(amount))
longest_type = 4
longest_id = len(str(infs[0].id)) if len(infs) > 0 else len(
Translator.translate('id', guild_id))
longest_timestamp = max(len(Translator.translate('timestamp', guild_id)),
19)
types = dict()
for inf in infs:
t = inf.type.lower()
longest_type = max(longest_type, len(Translator.translate(t,
guild_id)))
if t not in types:
types[t] = 1
else:
types[t] += 1
header = ", ".join(
Translator.translate(f"{k}s", guild_id, count=v)
for k, v in types.items())
name = await Utils.username(query) if isinstance(
query, int) else await Utils.clean(bot.get_guild(guild_id).name)
title = f"{Emoji.get_chat_emoji('SEARCH')} {Translator.translate('inf_search_header', guild_id, name=name, page_num=100, pages=100)}\n```md\n\n```"
page_header = get_header(longest_id, 37, longest_type, longest_timestamp,
guild_id)
mcount = 2000 - len(header) - len(page_header) - len(title)
out = "\n".join(
f"{Utils.pad(str(inf.id), longest_id)} | <@{Utils.pad(str(inf.user_id), 37)}> | <@{Utils.pad(str(inf.mod_id), 37)}> | {inf.start} | {Utils.pad(Translator.translate(inf.type.lower(), guild_id), longest_type)} | {Utils.trim_message(inf.reason, 1000)}"
for inf in infs)
pages = Pages.paginate(out, max_chars=mcount)
if bot.redis_pool is not None:
GearbotLogging.debug(f"Pushing placeholders for {key}")
pipe = bot.redis_pool.pipeline()
for page in pages:
pipe.lpush(key, "---NO PAGE YET---")
await pipe.execute()
bot.loop.create_task(
update_pages(guild_id, query, fields, amount, pages, requested,
longest_id, longest_type, longest_timestamp, header))
return len(pages)
def swap_mute_role(guild, old, new, parts):
active_mutes = Infraction.select().where((Infraction.type == "Mute") & (
Infraction.guild_id == guild.id) & Infraction.active)
loop = asyncio.get_running_loop()
old_role = guild.get_role(old)
new_role = guild.get_role(new)
parts.update(old_id=old,
old_name=Utils.escape_markdown(old_role.name)
if old_role is not None else old,
new_id=new,
new_name=Utils.escape_markdown(new_role.name)
if new_role is not None else new,
count=len(active_mutes))
if old != 0:
if old_role is not None:
loop.create_task(role_remover(active_mutes, guild, old_role))
if new != 0:
GearbotLogging.log_key(guild.id, "config_mute_role_changed",
**parts)
else:
GearbotLogging.log_key(
guild.id,
"config_mute_role_disabled",
**parts,
)
if new != 0:
if new_role is not None:
loop.create_task(role_adder(active_mutes, guild, new_role))
if old == 0:
GearbotLogging.log_key(guild.id, "config_mute_role_set", **parts)
async def timed_actions(self):
GearbotLogging.info("Started timed moderation action background task")
while self.running:
# actions to handle and the function handling it
types = {"Mute": self._lift_mute, "Tempban": self._lift_tempban}
now = datetime.datetime.fromtimestamp(time.time())
limit = datetime.datetime.fromtimestamp(time.time() + 30)
for name, action in types.items():
for infraction in Infraction.select().where(
Infraction.type == name, Infraction.active == True,
Infraction.end <= limit):
if infraction.id not in self.handling:
self.handling.add(infraction.id)
self.bot.loop.create_task(
self.run_after(
(infraction.end - now).total_seconds(),
action(infraction)))
await asyncio.sleep(10)
GearbotLogging.info(
"Timed moderation actions background task terminated")
async def forceban(self,
ctx: commands.Context,
user_id: UserID,
*,
reason: Reason = ""):
"""forceban_help"""
if reason == "":
reason = Translator.translate("no_reason", ctx.guild.id)
try:
member = await commands.MemberConverter().convert(
ctx, str(user_id))
except BadArgument:
user = await ctx.bot.get_user_info(user_id)
self.bot.data["forced_exits"].add(f"{ctx.guild.id}-{user.id}")
await ctx.guild.ban(
user,
reason=Utils.trim_message(
f"Moderator: {ctx.author.name}#{ctx.author.discriminator} ({ctx.author.id}) Reason: {reason}",
500),
delete_message_days=0)
await ctx.send(
f"{Emoji.get_chat_emoji('YES')} {Translator.translate('forceban_confirmation', ctx.guild.id, user=Utils.clean_user(user), user_id=user_id, reason=reason)}"
)
GearbotLogging.log_to(
ctx.guild.id, "MOD_ACTIONS",
f":door: {Translator.translate('forceban_log', ctx.guild.id, user=Utils.clean_user(user), user_id=user_id, moderator=Utils.clean_user(ctx.author), moderator_id=ctx.author.id, reason=reason)}"
)
tempbans = list(Infraction.select().where(
(Infraction.user_id == user.id)
& (Infraction.type == "Tempban")
& (Infraction.guild_id == ctx.guild.id)))
if len(tempbans) > 0:
inf = tempbans[0]
timeframe = datetime.datetime.utcfromtimestamp(
inf.end.timestamp()) - datetime.datetime.utcfromtimestamp(
time.time())
hours, remainder = divmod(int(timeframe.total_seconds()), 3600)
minutes, seconds = divmod(remainder, 60)
tt = Translator.translate("hours",
ctx,
hours=hours,
minutes=minutes)
await GearbotLogging.send_to(ctx,
"WARNING",
"forceban_override_tempban",
user=Utils.clean_user(user),
timeframe=tt,
inf_id=inf.id)
Infraction.update(active=False).where(
(Infraction.user_id == user.id)
& ((Infraction.type == "Unban")
| (Infraction.type == "Tempban"))
& (Infraction.guild_id == ctx.guild.id)).execute()
InfractionUtils.add_infraction(ctx.guild.id, user.id,
ctx.author.id, "Forced ban", reason)
else:
await ctx.send(
f"{Emoji.get_chat_emoji('WARNING')} {Translator.translate('forceban_to_ban', ctx.guild.id, user=Utils.clean_user(member))}"
)
await ctx.invoke(self.ban, member, reason=reason)
