async def on_member_unban(self, guild, user):
fid = f"{guild.id}-{user.id}"
if fid in self.bot.data["unbans"]:
self.bot.data["unbans"].remove(fid)
return
elif not Features.is_logged(guild.id, "MOD_ACTIONS"):
return
Infraction.update(active=False).where((Infraction.user_id == user.id) &
(Infraction.type == "Ban") &
(Infraction.guild_id == guild.id)).execute()
limit = datetime.datetime.utcfromtimestamp(time.time() - 60)
log = await self.find_log(guild, AuditLogAction.unban, lambda e: e.target == user and e.created_at > limit)
if log is None:
# this fails way to often for my liking, alternative is adding a delay but this seems to do the trick for now
log = await self.find_log(guild, AuditLogAction.unban, lambda e: e.target == user and e.created_at > limit)
if log is not None:
i = InfractionUtils.add_infraction(guild.id, user.id, log.user.id, "Unban", "Manual unban")
GearbotLogging.log_key(guild.id, 'unban_log', user=Utils.clean_user(user), user_id=user.id,
moderator=log.user, moderator_id=log.user.id, reason='Manual unban', inf=i.id)
else:
i = InfractionUtils.add_infraction(guild.id, user.id, 0, "Unban", "Manual ban")
GearbotLogging.log_key(guild.id, 'manual_unban_log', user=Utils.clean_user(user), user_id=user.id, inf=i.id)
async def yes():
await infraction.delete()
await MessageUtils.send_to(ctx, "YES", "inf_delete_deleted", id=infraction.id)
GearbotLogging.log_key(ctx.guild.id, 'inf_delete_log', id=infraction.id, target=Utils.clean_user(target),
target_id=target.id, mod=Utils.clean_user(mod), mod_id=mod.id if mod is not None else 0, reason=reason,
user=Utils.clean_user(ctx.author), user_id=ctx.author.id)
InfractionUtils.clear_cache(ctx.guild.id)
async def execute(self, bot, member, data, raid_id, raider_ids, shield):
role = member.guild.get_role(
Configuration.get_var(member.guild.id, "ROLES", "MUTE_ROLE"))
if role is None:
GearbotLogging.log_key(member.guild.id, 'raid_mute_failed_no_role')
else:
duration = data["duration"]
reason = f"Raider muted by raid shield {shield['name']} in raid {raid_id}"
try:
await member.add_roles(role, reason=reason)
except NotFound:
pass
except Forbidden:
log(member.guild.id,
'raid_mute_forbidden',
shield,
user_name=Utils.escape_markdown(member),
user_id=member.id)
except Exception as ex:
log(member.guild.id,
'raid_mute_unknown_error',
shield,
user_name=Utils.escape_markdown(member),
user_id=member.id)
await TheRealGearBot.handle_exception('RAID MUTE FAILURE', bot,
ex)
finally:
until = time.time() + duration
i = await InfractionUtils.add_infraction(member.guild.id,
member.id,
member.guild.me.id,
"Mute",
reason,
end=until)
async def on_voice_state_update(self, member, before, after):
if Features.is_logged(member.guild.id, "VOICE_CHANGES_DETAILED"):
simple = ["deaf", "mute", "self_mute", "self_deaf", "afk"]
for s in simple:
old = getattr(before, s)
new = getattr(after, s)
if old != new:
key = f"voice_change_{s}_{str(new).lower()}"
GearbotLogging.log_key(member.guild.id,
key,
user=Utils.clean_user(member),
user_id=member.id)
if Features.is_logged(member.guild.id, "VOICE_CHANGES"):
if before.channel != after.channel:
parts = dict(user=Utils.clean_user(member), user_id=member.id)
if before.channel is None:
key = "connected_to_voice"
parts.update(channel_name=after.channel.name,
channel_id=after.channel.id)
elif after.channel is None:
key = "disconnected_voice"
parts.update(channel_name=before.channel.name,
channel_id=before.channel.id)
else:
key = "moved_voice"
parts.update(old_channel_name=before.channel.name,
old_channel_id=before.channel.id,
new_channel_name=after.channel.name,
new_channel_id=after.channel.id)
GearbotLogging.log_key(member.guild.id, key, **parts)
async def on_member_remove(self, member: discord.Member):
if member.id == self.bot.user.id: return
timestamp = datetime.datetime.now()
exits = self.bot.data["forced_exits"]
fid = f"{member.guild.id}-{member.id}"
if fid in exits:
exits.remove(fid)
return
if member.guild.me.guild_permissions.view_audit_log and Features.is_logged(member.guild.id, "MOD_ACTIONS"):
try:
async for entry in member.guild.audit_logs(action=AuditLogAction.kick, limit=25):
if member.joined_at is None or member.joined_at > entry.created_at or entry.created_at < datetime.datetime.utcfromtimestamp(
time.time() - 30):
break
if entry.target == member:
if entry.reason is None:
reason = Translator.translate("no_reason", member.guild.id)
else:
reason = entry.reason
i = await InfractionUtils.add_infraction(member.guild.id, entry.target.id, entry.user.id, "Kick", reason,
active=False)
GearbotLogging.log_key(member.guild.id, 'kick_log', user=Utils.clean_user(member), user_id=member.id, moderator=Utils.clean_user(entry.user), moderator_id=entry.user.id, reason=reason, inf=i.id, timestamp=timestamp)
return
except discord.Forbidden:
permissions = member.guild.me.guild_permissions
perm_info = ", ".join(f"{name}: {value}" for name, value in permissions)
await GearbotLogging.bot_log(
f"{Emoji.get_chat_emoji('WARNING')} Tried to fetch audit log for {member.guild.name} ({member.guild.id}) but got denied even though it said i have access, guild permissions: ```{perm_info}```")
if Features.is_logged(member.guild.id, "TRAVEL_LOGS"):
GearbotLogging.log_key(member.guild.id, 'leave_logging', user=Utils.clean_user(member), user_id=member.id, timestamp=timestamp)
async def warn(self, ctx: commands.Context, member: discord.Member, *, reason: Reason):
"""warn_help"""
if ctx.author != member and (ctx.author.top_role > member.top_role or ctx.guild.owner == ctx.author):
if member.id == self.bot.user.id:
async def yes():
channel = self.bot.get_channel(Configuration.get_master_var("inbox", 0))
if channel is not None:
await channel.send(f"[`{ctx.message.created_at.strftime('%c')}`] {ctx.message.author} (`{ctx.message.author.id}`) submitted feedback: {reason}")
await MessageUtils.send_to(ctx, 'YES', 'feedback_submitted')
message = MessageUtils.assemble(ctx, "THINK", "warn_to_feedback")
await Confirmation.confirm(ctx, message, on_yes=yes)
else:
if member.bot:
await MessageUtils.send_to(ctx, "THINK", "cant_warn_bot")
return
i = InfractionUtils.add_infraction(ctx.guild.id, member.id, ctx.author.id, "Warn", reason)
name = Utils.clean_user(member)
await MessageUtils.send_to(ctx, 'YES', 'warning_added', user=name, inf=i.id)
aname = Utils.clean_user(ctx.author)
GearbotLogging.log_key(ctx.guild.id, 'warning_added_modlog', user=name, moderator=aname, reason=reason,
user_id=member.id, moderator_id=ctx.author.id, inf=i.id)
if Configuration.get_var(ctx.guild.id, "INFRACTIONS", "DM_ON_WARN"):
try:
dm_channel = await member.create_dm()
await dm_channel.send(
f"{Emoji.get_chat_emoji('WARNING')} {Translator.translate('warning_dm', ctx.guild.id, server=ctx.guild.name)}```{reason}```")
except discord.Forbidden:
GearbotLogging.log_key(ctx.guild.id, 'warning_could_not_dm', user=name,
userid=member.id)
else:
await ctx.send(f"{Emoji.get_chat_emoji('NO')} {Translator.translate('warning_not_allowed', ctx.guild.id, user=member)}")
async def kick_punishment(self, v: Violation):
reason = self.assemble_reason(v)
i = await InfractionUtils.add_infraction(v.guild.id,
v.member.id,
self.bot.user.id,
'Kick',
reason,
active=False)
self.bot.data["forced_exits"].add(f"{v.guild.id}-{v.member.id}")
try:
await v.guild.kick(v.member, reason=reason)
except Forbidden:
GearbotLogging.log_key(v.guild.id,
'kick_punishment_failure',
user=Utils.clean_user(v.member),
user_id=v.member.id,
moderator=Utils.clean_user(v.guild.me),
moderator_id=v.guild.me.id,
reason=reason,
inf=i.id)
else:
GearbotLogging.log_key(v.guild.id,
'kick_log',
user=Utils.clean_user(v.member),
user_id=v.member.id,
moderator=Utils.clean_user(v.guild.me),
moderator_id=v.guild.me.id,
reason=reason,
inf=i.id)
async def execute(self, bot, member, data, raid_id, raider_ids, shield):
bot.data["forced_exits"].add(f"{member.guild.id}-{member.id}")
reason = f"Raider kicked by raid shield {shield['name']} in raid {raid_id}"
try:
await member.kick(reason=reason)
except NotFound:
pass
except Forbidden:
log(member.guild.id,
'raid_kick_forbidden',
shield,
user_name=Utils.escape_markdown(member),
user_id=member.id)
except Exception as ex:
log(member.guild.id,
'raid_kick_unknown_error',
shield,
user_name=Utils.escape_markdown(member),
user_id=member.id)
await TheRealGearBot.handle_exception('RAID KICK FAILURE', bot, ex)
finally:
i = await InfractionUtils.add_infraction(member.guild.id,
member.id,
bot.user.id,
'Kick',
reason,
active=False)
GearbotLogging.log_key(member.guild.id,
'kick_log',
user=Utils.clean_user(member),
user_id=member.id,
moderator=Utils.clean_user(member.guild.me),
moderator_id=bot.user.id,
reason=reason,
inf=i.id)
async def _warn(self,
ctx,
target,
*,
reason,
message=True,
dm_action=True):
i = await InfractionUtils.add_infraction(ctx.guild.id, target.id,
ctx.author.id, "Warn", reason)
name = Utils.clean_user(target)
if message:
await MessageUtils.send_to(ctx,
'YES',
'warning_added',
user=name,
inf=i.id)
aname = Utils.clean_user(ctx.author)
GearbotLogging.log_key(ctx.guild.id,
'warning_added_modlog',
user=name,
moderator=aname,
reason=reason,
user_id=target.id,
moderator_id=ctx.author.id,
inf=i.id)
if Configuration.get_var(ctx.guild.id, "INFRACTIONS",
"DM_ON_WARN") and dm_action:
await Utils.send_infraction(self.bot, target, ctx.guild, 'WARNING',
'warn', reason)
async def raid_detected(self, bot, guild, raid_id, raider_ids, shield):
GearbotLogging.log_key(guild.id,
"raid_shield_triggered",
raid_id=raid_id,
name=self.shield_name)
await self.handle_actions(self.start_actions, bot, guild, raid_id,
raider_ids, shield)
async def shield_terminated(self, bot, guild, raid_id, raider_ids, shield):
GearbotLogging.log_key(guild.id,
"raid_shield_terminated",
raid_id=raid_id,
name=self.shield_name)
await self.handle_actions(self.termination_actions, bot, guild,
raid_id, raider_ids, shield)
async def on_guild_role_create(self, role):
if not Features.is_logged(role.guild.id, "ROLE_CHANGES"): return
entry = await self.find_log(role.guild, AuditLogAction.role_create, lambda e: e.target.id == role.id)
if entry is None:
GearbotLogging.log_key(role.guild.id, 'role_created', role=role.name)
else:
GearbotLogging.log_key(role.guild.id, 'role_created_by', role=role.name, person=Utils.clean_user(entry.user), person_id=entry.user.id)
async def on_guild_channel_delete(self, channel):
if not Features.is_logged(channel.guild.id, "CHANNEL_CHANGES"): return
e = await self.find_log(channel.guild, AuditLogAction.channel_delete, lambda e: e.target.id == channel.id)
if e is not None:
GearbotLogging.log_key(channel.guild.id, "channel_deleted_by", channel=channel.name, channel_id=channel.id, person=Utils.clean_user(e.user), person_id=e.user.id)
else:
GearbotLogging.log_key(channel.guild.id, "channel_deleted", channel=channel.name, channel_id=channel.id)
async def on_member_update(self, before:discord.Member, after):
guild = before.guild
# nickname changes
if Features.is_logged(guild.id, "NAME_CHANGES"):
if (before.nick != after.nick and
after.nick != before.nick) and f'{before.guild.id}-{before.id}' not in self.bot.data['nickname_changes']:
name = Utils.clean_user(after)
before_clean = "" if before.nick is None else Utils.clean_name(before.nick)
after_clean = "" if after.nick is None else Utils.clean_name(after.nick)
entry = await self.find_log(guild, AuditLogAction.member_update, lambda e: e.target.id == before.id and hasattr(e.changes.before, "nick") and hasattr(e.changes.after, "nick") and before.nick == e.changes.before.nick and after.nick == e.changes.after.nick and e.created_at > datetime.datetime.utcfromtimestamp(time.time() - 2))
if before.nick is None:
type = "added"
elif after.nick is None:
type = "removed"
else:
type = "changed"
mod_name = ""
mod_id = ""
if entry is None:
actor = "unknown"
elif entry.target.id == entry.user.id:
actor = "own"
else:
mod_name = Utils.clean_user(entry.user)
mod_id = entry.user.id
actor = "mod"
GearbotLogging.log_key(guild.id, f'{actor}_nickname_{type}', user=name, user_id=before.id, before=before_clean, after=after_clean, moderator=mod_name, moderator_id=mod_id)
# role changes
if Features.is_logged(guild.id, "ROLE_CHANGES"):
removed = []
added = []
for role in before.roles:
if role not in after.roles:
removed.append(role)
for role in after.roles:
if role not in before.roles:
added.append(role)
if (len(removed) + len(added)) > 0:
entry = await self.find_log(guild, AuditLogAction.member_role_update,
lambda e: e.target.id == before.id and hasattr(e.changes.before, "roles") and hasattr(
e.changes.after, "roles") and all(
r in e.changes.before.roles for r in removed) and all(
r in e.changes.after.roles for r in
added) and e.created_at > datetime.datetime.utcfromtimestamp(
time.time() - 1))
if entry is not None:
removed = entry.changes.before.roles
added = entry.changes.after.roles
for role in removed:
GearbotLogging.log_key(guild.id, 'role_removed_by', role=role.name, user=Utils.clean_user(entry.target), user_id=entry.target.id, moderator=Utils.clean_user(entry.user), moderator_id=entry.user.id)
for role in added:
GearbotLogging.log_key(guild.id, 'role_added_by', role=role.name, user=Utils.clean_user(entry.target), user_id=entry.target.id, moderator=Utils.clean_user(entry.user), moderator_id=entry.user.id)
else:
for role in removed:
GearbotLogging.log_key(guild.id, 'role_removed', role=role.name, user=Utils.clean_user(before), user_id=before.id)
for role in added:
GearbotLogging.log_key(guild.id, 'role_added', role=role.name, user=Utils.clean_user(before), user_id=before.id)
async def _warn(ctx, target, *, reason, message=True):
i = InfractionUtils.add_infraction(ctx.guild.id, target.id,
ctx.author.id, "Warn", reason)
name = Utils.clean_user(target)
if message:
await MessageUtils.send_to(ctx,
'YES',
'warning_added',
user=name,
inf=i.id)
aname = Utils.clean_user(ctx.author)
GearbotLogging.log_key(ctx.guild.id,
'warning_added_modlog',
user=name,
moderator=aname,
reason=reason,
user_id=target.id,
moderator_id=ctx.author.id,
inf=i.id)
if Configuration.get_var(ctx.guild.id, "INFRACTIONS", "DM_ON_WARN"):
try:
dm_channel = await target.create_dm()
await dm_channel.send(
f"{Emoji.get_chat_emoji('WARNING')} {Translator.translate('warning_dm', ctx.guild.id, server=ctx.guild.name)}```{reason}```"
)
except discord.Forbidden:
GearbotLogging.log_key(ctx.guild.id,
'warning_could_not_dm',
user=name,
userid=target.id)
async def on_member_ban(self, guild, user):
if user.id == self.bot.user.id or not Features.is_logged(
guild.id, "MOD_ACTIONS"):
return
timestamp = datetime.datetime.now()
if guild.me.guild_permissions.view_audit_log:
return
if await self.bot.redis_pool.get(f"forced_exits:{guild.id}-{user.id}"
) is not None:
return
await self.bot.redis_pool.psetex(f"forced_exits:{guild.id}-{user.id}",
8000, "1")
await Infraction.filter(user_id=user.id,
type="Unban",
guild_id=guild.id).update(active=False)
i = await InfractionUtils.add_infraction(guild.id, user.id, 0, "Ban",
"Manual ban")
GearbotLogging.log_key(guild.id,
'manual_ban_log',
user=Utils.clean_user(user),
user_id=user.id,
inf=i.id,
timestamp=timestamp)
async def violate(self, v: Violation):
# deterining current punishment
punish_info = v.bucket["PUNISHMENT"]
t = punish_info["TYPE"]
self.bot.dispatch('spam_violation', v)
key = f"{v.guild.id}-{v.member.id}-{v.bucket['TYPE']}"
a = self.get_extra_actions(key)
a.count += v.count
# Punish and Clean
GearbotLogging.log_key(v.guild.id, 'spam_violate', user=Utils.clean_user(v.member), user_id=v.member.id,
check=v.check.upper(), friendly=v.friendly, channel=v.channel.mention, punishment_type=t)
await self.punishments[t](v)
if v.bucket.get("CLEAN", True):
to_clean = AntiSpam._process_bucket_entries(v.offending_messages)
by_channel = {}
for (chan, msg) in to_clean:
by_channel.setdefault(chan, []).append(msg)
for (chan, msgs) in by_channel.items():
guild_chan = v.guild.get_channel(int(chan))
msgs = [Object(id=x) for x in msgs]
if guild_chan is not None:
# Ensure we only delete 100 at a time. Probably not necessary but you never know with people
for group in Utils.chunks(msgs, 100):
try:
await guild_chan.delete_messages(group)
except NotFound:
pass
await asyncio.sleep(v.bucket["SIZE"]["PERIOD"])
a = self.get_extra_actions(key)
a.count -= v.count
async def on_guild_role_update(self, before: discord.Role, after):
if not Features.is_logged(before.guild.id, "ROLE_CHANGES"): return
timestamp = datetime.datetime.now()
await self.handle_simple_changes(
before, after, "role_update_simple", AuditLogAction.role_update,
["name", "color", "hoist", "mentionable"], timestamp)
if before.permissions != after.permissions:
for perm, value in before.permissions:
av = getattr(after.permissions, perm)
if av != value:
entry = await self.find_log(
before.guild, AuditLogAction.role_update,
lambda e: e.target.id == after.id and hasattr(
e.before, "permissions"
) and e.before.permissions == before.permissions and e.
after.permissions == after.permissions)
key = f"role_update_perm_{'added' if av else 'revoked'}"
parts = dict(role=await Utils.clean(after.name),
role_id=after.id,
perm=perm)
if entry is not None:
key += "_by"
parts.update(person=Utils.clean_user(entry.user),
person_id=entry.user.id)
GearbotLogging.log_key(after.guild.id,
key,
**parts,
timestamp=timestamp)
async def warn_punishment(self, v: Violation):
reason = v.bucket["PUNISHMENT"].get("REASON", self.assemble_reason(v))
i = await InfractionUtils.add_infraction(v.guild.id, v.member.id,
self.bot.user.id, 'Warn',
reason)
GearbotLogging.log_key(v.guild.id,
'warning_added_modlog',
user=Utils.clean_user(v.member),
moderator=Utils.clean_user(v.guild.me),
reason=reason,
user_id=v.member.id,
moderator_id=v.guild.me.id,
inf=i.id)
try:
dm_channel = await v.member.create_dm()
await dm_channel.send(
MessageUtils.assemble(dm_channel,
'WARNING',
'warning_dm',
server=v.member.guild.name) +
f"```{reason}```")
except Forbidden:
GearbotLogging.log_key(v.member.guild.id,
'warning_could_not_dm',
user=Utils.escape_markdown(v.member.name),
userid=v.member.id)
async def warn_punishment(self, v: Violation):
reason = v.bucket["PUNISHMENT"].get("REASON", self.assemble_reason(v))
i = await InfractionUtils.add_infraction(v.guild.id, v.member.id, self.bot.user.id, 'Warn', reason)
GearbotLogging.log_key(v.guild.id, 'warning_added_modlog', user=Utils.clean_user(v.member),
moderator=Utils.clean_user(v.guild.me), reason=reason,
user_id=v.member.id, moderator_id=v.guild.me.id, inf=i.id)
await Utils.send_infraction(self.bot, v.member, v.guild, 'WARNING', 'warning', "Spam")
async def on_member_join(self, member: discord.Member):
if Features.is_logged(member.guild.id, "TRAVEL_LOGS"):
dif = (datetime.datetime.utcfromtimestamp(time.time()) -
member.created_at)
new_user_threshold = Configuration.get_var(member.guild.id,
"GENERAL",
"NEW_USER_THRESHOLD")
minutes, seconds = divmod(dif.days * 86400 + dif.seconds, 60)
hours, minutes = divmod(minutes, 60)
age = (Translator.translate(
'days', member.guild.id,
amount=dif.days)) if dif.days > 0 else Translator.translate(
'hours', member.guild.id, hours=hours, minutes=minutes)
if new_user_threshold > dif.total_seconds():
GearbotLogging.log_key(member.guild.id,
'join_logging_new',
user=Utils.clean_user(member),
user_id=member.id,
age=age)
else:
GearbotLogging.log_key(member.guild.id,
'join_logging',
user=Utils.clean_user(member),
user_id=member.id,
age=age)
async def censor_message(self, message, bad, key=""):
if message.channel.permissions_for(message.guild.me).manage_messages:
try:
self.bot.data["message_deletes"].add(message.id)
await message.delete()
except discord.NotFound as ex:
pass
else:
clean_message = await Utils.clean(message.content,
message.guild,
markdown=False)
GearbotLogging.log_key(message.guild.id,
f'censored_message{key}',
user=message.author,
user_id=message.author.id,
message=clean_message,
sequence=bad,
channel=message.channel.mention)
self.bot.dispatch("user_censored", message)
else:
clean_message = await Utils.clean(message.content,
message.guild,
markdown=False)
GearbotLogging.log_key(message.guild.id,
f'censor_message_failed{key}',
user=message.author,
user_id=message.author.id,
message=clean_message,
sequence=bad,
link=message.jump_url)
self.bot.dispatch("user_censored", message)
async def handle_simple_changes(self, before, after, base_key, action,
attributes):
for attr in attributes:
if hasattr(before, attr):
ba = getattr(before, attr)
if isinstance(ba, str) and ba.strip() == "":
ba = None
aa = getattr(after, attr)
if isinstance(aa, str) and aa.strip() == "":
aa = None
key = base_key
if ba != aa:
entry = await self.find_log(
before.guild, action,
lambda e: e.target.id == before.id and hasattr(
e.changes.before, attr) and getattr(
e.changes.before, attr) == ba and getattr(
e.changes.after, attr) == aa)
parts = dict(before=self.prep_attr(ba),
after=self.prep_attr(aa),
thing=after,
thing_id=after.id,
attr=attr)
if entry is not None:
parts.update(person=entry.user,
person_id=entry.user.id)
key += "_by"
GearbotLogging.log_key(before.guild.id, key, **parts)
async def send_infraction(bot, user, guild, emoji, type, reason, **kwargs):
if await get_member(bot, guild, user.id) is None:
return
try:
override = Configuration.get_var(guild.id, "INFRACTIONS", type.upper())
kwargs.update(reason=reason, server=guild.name, guild_id=guild.id)
if override is not None:
message = f"{Emoji.get_chat_emoji(emoji)} {format(override, kwargs, Configuration.get_var(guild.id, 'GENERAL', 'LANG'))}```{reason}```"
else:
message = f"{Emoji.get_chat_emoji(emoji)} {Translator.translate(f'{type.lower()}_dm', guild.id, **kwargs)}```{reason}```"
parts = message.split("```")
out = ""
wrap = False
while len(parts) > 0:
temp = parts.pop(0)
added = 6 if wrap else 0
chars = "```" if wrap else ""
if (len(out) + len(temp) + added) > 2000:
await user.send(out)
temp = ""
out = f"{out}{chars}{temp}{chars}"
wrap = not wrap
if len(out) > 0:
await user.send(out)
except (discord.HTTPException, AttributeError):
GearbotLogging.log_key(guild.id,
f'{type}_could_not_dm',
user=clean_user(user),
userid=user.id)
async def on_user_update(self, before:discord.User, after):
# Username and discriminator changes
if before.name != after.name or before.discriminator != after.discriminator:
for guild in self.bot.guilds:
if guild.get_member(before.id) is not None:
after_clean_name = Utils.escape_markdown(Utils.replace_lookalikes(after.name))
GearbotLogging.log_key(guild.id, 'username_changed', after_clean=after_clean_name, before=before, user_id=after.id, after=after)
async def kick_punishment(self, v: Violation, member):
reason = self.assemble_reason(v)
i = await InfractionUtils.add_infraction(v.guild.id,
member.id,
self.bot.user.id,
'Kick',
reason,
active=False)
await self.bot.redis_pool.psetex(
f"forced_exits:{v.guild.id}-{member.id}", 8000, "1")
try:
if Configuration.get_var(v.guild.id, "INFRACTIONS", "DM_ON_KICK"):
asyncio.create_task(
Utils.send_infraction(self.bot, member, v.guild, 'BOOT',
'kick', "Spam"))
await v.guild.kick(member, reason=reason)
except Forbidden:
GearbotLogging.log_key(v.guild.id,
'kick_punishment_failure',
user=Utils.clean_user(member),
user_id=member.id,
moderator=Utils.clean_user(v.guild.me),
moderator_id=v.guild.me.id,
reason=reason,
inf=i.id)
else:
GearbotLogging.log_key(v.guild.id,
'kick_log',
user=Utils.clean_user(member),
user_id=member.id,
moderator=Utils.clean_user(v.guild.me),
moderator_id=v.guild.me.id,
reason=reason,
inf=i.id)
async def note(self, ctx, member: DiscordUser, *, reason: Reason):
i = await InfractionUtils.add_infraction(ctx.guild.id, member.id, ctx.author.id, "Note", reason)
name = Utils.clean_user(member)
await MessageUtils.send_to(ctx, 'YES', 'note_added', user=name, inf=i.id)
aname = Utils.clean_user(ctx.author)
GearbotLogging.log_key(ctx.guild.id, 'note_added_modlog', user=name, moderator=aname, reason=reason,
user_id=member.id, moderator_id=ctx.author.id, inf=i.id)
async def temp_ban_punishment(self, v: Violation, member):
reason = self.assemble_reason(v)
duration = v.bucket["PUNISHMENT"]["DURATION"]
until = time.time() + duration
await self.bot.redis_pool.psetex(
f"forced_exits:{v.guild.id}-{member.id}", 8000, 1)
await v.guild.ban(member, reason=reason, delete_message_days=0)
i = await InfractionUtils.add_infraction(v.guild.id,
member.id,
self.bot.user.id,
'Tempban',
reason,
end=until)
if Configuration.get_var(v.guild.id, "INFRACTIONS", "DM_ON_TEMPBAN"):
dur = Utils.to_pretty_time(duration, None)
asyncio.create_task(
Utils.send_infraction(self.bot,
member,
v.guild,
'BAN',
'tempban',
"Spam",
duration=dur))
GearbotLogging.log_key(
v.guild.id,
'tempban_log',
user=Utils.clean_user(member),
user_id=member.id,
moderator=Utils.clean_user(v.guild.me),
moderator_id=v.guild.me.id,
reason=reason,
until=datetime.datetime.utcfromtimestamp(until).replace(
tzinfo=datetime.timezone.utc),
inf=i.id)
async def execute(self, bot, member, data, raid_id, raider_ids, shield):
await bot.redis_pool.psetex(
f"forced_exits:{member.guild.id}-{member.id}", 8000, 1)
reason = f"Raider banned by raid shield {shield['name']} in raid {raid_id}"
try:
await member.ban(
reason=reason,
delete_message_days=1 if data["clean_messages"] else 0)
except Forbidden:
log(member.guild.id,
'raid_ban_forbidden',
shield,
user_name=Utils.escape_markdown(member),
user_id=member.id)
except Exception as ex:
log(member.guild.id,
'raid_ban_unknown_error',
shield,
user_name=Utils.escape_markdown(member),
user_id=member.id)
await TheRealGearBot.handle_exception('RAID BAN FAILURE', bot, ex)
finally:
i = await InfractionUtils.add_infraction(member.guild.id,
member.id, bot.user.id,
"Ban", reason)
GearbotLogging.log_key(member.guild.id,
'ban_log',
user=Utils.clean_user(member),
user_id=member.id,
moderator=Utils.clean_user(bot.user),
moderator_id=bot.user.id,
reason=reason,
inf=i.id)
async def on_member_ban(self, guild, user):
if user.id == self.bot.user.id or not Features.is_logged(guild.id, "MOD_ACTIONS"): return
fid = f"{guild.id}-{user.id}"
if fid in self.bot.data["forced_exits"]:
return
self.bot.data["forced_exits"].add(fid)
Infraction.update(active=False).where((Infraction.user_id == user.id) &
(Infraction.type == "Unban") &
(Infraction.guild_id == guild.id)).execute()
limit = datetime.datetime.utcfromtimestamp(time.time() - 60)
log = await self.find_log(guild, AuditLogAction.ban, lambda e: e.target == user and e.created_at > limit)
if log is None:
await asyncio.sleep(1) #is the api having a fit or so?
#this fails way to often for my liking, alternative is adding a delay but this seems to do the trick for now
log = await self.find_log(guild, AuditLogAction.ban, lambda e: e.target == user and e.created_at > limit)
if log is not None:
if log.reason is None:
reason = Translator.translate("no_reason", guild.id)
else:
reason = log.reason
i = InfractionUtils.add_infraction(guild.id, log.target.id, log.user.id, "Ban", reason)
GearbotLogging.log_key(guild.id, 'ban_log', user=Utils.clean_user(user), user_id=user.id, moderator=Utils.clean_user(log.user), moderator_id=log.user.id, reason=reason, inf=i.id)
else:
i = InfractionUtils.add_infraction(guild.id, user.id, 0, "Ban", "Manual ban")
GearbotLogging.log_key(guild.id, 'manual_ban_log', user=Utils.clean_user(user), user_id=user.id, inf=i.id)
