async def on_command_error(bot, ctx: commands.Context, error):
if isinstance(error, commands.BotMissingPermissions):
GearbotLogging.error(f"Encountered a permission error while executing {ctx.command}: {error}")
await ctx.send(error)
elif isinstance(error, commands.CheckFailure):
if ctx.command.qualified_name is not "latest" and ctx.guild is not None and Configuration.get_var(ctx.guild.id, "GENERAL", "PERM_DENIED_MESSAGE"):
await MessageUtils.send_to(ctx, 'LOCK', 'permission_denied')
elif isinstance(error, commands.CommandOnCooldown):
await ctx.send(error)
elif isinstance(error, commands.MissingRequiredArgument):
param = list(ctx.command.params.values())[min(len(ctx.args) + len(ctx.kwargs), len(ctx.command.params))]
bot.help_command.context = ctx
await ctx.send(
f"{Emoji.get_chat_emoji('NO')} {Translator.translate('missing_arg', ctx, arg=param._name, error=Utils.replace_lookalikes(str(error)))}\n{Emoji.get_chat_emoji('WRENCH')} {Translator.translate('command_usage', ctx, usage=bot.help_command.get_command_signature(ctx.command))}")
elif isinstance(error, PostParseError):
bot.help_command.context = ctx
await ctx.send(f"{Emoji.get_chat_emoji('NO')} {Translator.translate('bad_argument', ctx, type=error.type, error=Utils.replace_lookalikes(str(error.error)))}\n{Emoji.get_chat_emoji('WRENCH')} {Translator.translate('command_usage', ctx, usage=bot.help_command.get_command_signature(ctx.command))}")
elif isinstance(error, commands.BadArgument):
param = list(ctx.command.params.values())[min(len(ctx.args) + len(ctx.kwargs), len(ctx.command.params))]
bot.help_command.context = ctx
await ctx.send(f"{Emoji.get_chat_emoji('NO')} {Translator.translate('bad_argument', ctx, type=param._name, error=Utils.replace_lookalikes(str(error)))}\n{Emoji.get_chat_emoji('WRENCH')} {Translator.translate('command_usage', ctx, usage=bot.help_command.get_command_signature(ctx.command))}")
elif isinstance(error, commands.CommandNotFound):
return
elif isinstance(error, PeeweeException):
await handle_database_error(bot)
else:
await handle_exception("Command execution failed", bot, error.original if hasattr(error, "original") else error, ctx=ctx)
# notify caller
e = Emoji.get_chat_emoji('BUG')
if ctx.channel.permissions_for(ctx.me).send_messages:
await ctx.send(f"{e} Something went wrong while executing that command {e}")
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 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 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 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)
def getConfigVar(id, key):
if not id in SERVER_CONFIGS.keys():
GearbotLogging.info(
f"Config entry requested before config was loaded for guild {id}, loading config for it"
)
loadConfig(id)
return SERVER_CONFIGS[id][key]
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 db_cleaner(self):
if Configuration.get_master_var("purge_db", True):
# purge all messages older then 6 weeks
snowflake = time_snowflake(datetime.datetime.utcfromtimestamp(time() - 60*60*24*7*6).replace(tzinfo=datetime.timezone.utc))
purged_attachments = await LoggedAttachment.filter(id__lt=snowflake).delete()
purged = await LoggedMessage.filter(messageid__lt=snowflake).delete()
GearbotLogging.info(f"Purged {purged} old messages and {purged_attachments} attachments")
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 update_site(self, ctx):
GearbotLogging.info("Site update initiated")
await DocUtils.update_docs(ctx)
message = await ctx.send(
f"{Emoji.get_chat_emoji('REFRESH')} Purging cloudflare cache")
cloudflare_info = Configuration.get_master_var("CLOUDFLARE", {})
if 'ZONE' in cloudflare_info:
headers = {
"X-Auth-Email": cloudflare_info["EMAIL"],
"X-Auth-Key": cloudflare_info["KEY"],
"Content-Type": "application/json"
}
async with self.bot.aiosession.post(
f"https://api.cloudflare.com/client/v4/zones/{cloudflare_info['ZONE']}/purge_cache",
json=dict(purge_everything=True),
headers=headers) as reply:
content = await reply.json()
GearbotLogging.info(f"Cloudflare purge response: {content}")
if content["success"]:
await message.edit(
content=
f"{Emoji.get_chat_emoji('YES')} Cloudflare cache has been purged"
)
else:
await message.edit(
content=
f"{Emoji.get_chat_emoji('NO')} Cloudflare cache purge failed"
)
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 hotreload(self, ctx: commands.Context):
message = await GearbotLogging.bot_log(
f"{Emoji.get_chat_emoji('REFRESH')} Hot reload in progress...")
ctx_message = await ctx.send(
f"{Emoji.get_chat_emoji('REFRESH')} Hot reload in progress...")
GearbotLogging.info("Initiating hot reload")
GearbotLogging.LOG_PUMP.running = False
importlib.reload(Reloader)
for c in Reloader.components:
importlib.reload(c)
GearbotLogging.info("Reloading all cogs...")
temp = []
for cog in self.bot.cogs:
temp.append(cog)
for cog in temp:
self.bot.unload_extension(f"Cogs.{cog}")
GearbotLogging.info(f'{cog} has been unloaded.')
self.bot.load_extension(f"Cogs.{cog}")
GearbotLogging.info(f'{cog} has been loaded.')
to_unload = Configuration.get_master_var("DISABLED_COMMANDS", [])
for c in to_unload:
self.bot.remove_command(c)
await TheRealGearBot.initialize(self.bot)
GearbotLogging.info("Hot reload complete.")
m = f"{Emoji.get_chat_emoji('YES')} Hot reload complete"
await message.edit(content=m)
await ctx_message.edit(content=m)
await Translator.upload()
self.bot.hot_reloading = False
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 on_ready(bot):
if not bot.STARTUP_COMPLETE:
await initialize(bot, True)
#shutdown handler for clean exit on linux
try:
for signame in ('SIGINT', 'SIGTERM'):
asyncio.get_event_loop().add_signal_handler(getattr(signal, signame),
lambda: asyncio.ensure_future(Utils.cleanExit(bot, signame)))
except Exception:
pass #doesn't work on windows
bot.start_time = datetime.utcnow()
GearbotLogging.info("Loading cogs...")
for extension in Configuration.get_master_var("COGS"):
try:
bot.load_extension("Cogs." + extension)
except Exception as e:
await handle_exception(f"Failed to load cog {extension}", bot, e)
GearbotLogging.info("Cogs loaded")
to_unload = Configuration.get_master_var("DISABLED_COMMANDS", [])
for c in to_unload:
bot.remove_command(c)
bot.STARTUP_COMPLETE = True
info = await bot.application_info()
bot.loop.create_task(keepDBalive(bot)) # ping DB every hour so it doesn't run off
gears = [Emoji.get_chat_emoji(e) for e in ["WOOD", "STONE", "IRON", "GOLD", "DIAMOND"]]
a = " ".join(gears)
b = " ".join(reversed(gears))
await GearbotLogging.bot_log(message=f"{a} All gears turning at full speed, {info.name} ready to go! {b}")
await bot.change_presence(activity=Activity(type=3, name='the gears turn'))
else:
await bot.change_presence(activity=Activity(type=3, name='the gears turn'))
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 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 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 get_info(self, ctx, project_name, log):
while project_name in self.fetching:
# already fetching, wait for data to arrive
await asyncio.sleep(1)
if not project_name in self.cf_cache.keys():
self.fetching.append(project_name)
if log:
message = await ctx.send(
f"<a:gearLoading:468054357724889089> {Translator.translate('fetching_info', ctx)} <a:gearLoading:468054357724889089>"
)
info = await self.fetch_info(project_name)
if info is False:
if log:
await ctx.send(Translator.translate(
'cf_fetch_failed', ctx))
else:
GearbotLogging.info(
f"Retrieved project data for {project_name}, adding to cache."
)
self.cf_cache[project_name] = {
"info": info,
"time": datetime.datetime.utcnow()
}
self.fetching.remove(project_name)
if log:
await message.delete()
return info
else:
return self.cf_cache[project_name]["info"]
async def taco_eater(self):
"""A person can eat a taco every 5 mins, we run every 15s"""
GearbotLogging.info("Time to start munching on some ЁЯМо")
while self.running:
self.bot.eaten += len(self.bot.users) / 20
# update stats in redis
await self.bot.redis_pool.hmset_dict(
"botstats", {
"start_time":
str(self.bot.start_time),
"user_mesages":
str(self.bot.user_messages),
"bot_messages":
str(self.bot.bot_messages),
"own_messages":
str(self.bot.self_messages),
"total_members":
str(sum(len(guild.members) for guild in self.bot.guilds)),
"unique_members":
str(len(self.bot.users)),
"taco_count":
str(round(self.bot.eaten)),
"random_number":
random.randint(0, 5000),
"commands_executed":
str(self.bot.commandCount),
"custom_commands_executed":
str(self.bot.custom_command_count),
"guilds":
len(self.bot.guilds)
})
await asyncio.sleep(15)
GearbotLogging.info("Cog terminated, guess no more ЁЯМо for people")
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_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 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_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 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)
def translate(key, location, **kwargs):
lid = None
if location is not None:
if hasattr(location, "guild"):
location = location.guild
if location is not None and hasattr(location, "id"):
lid = location.id
else:
lid = location
if lid is None:
lang_key = "en_US"
else:
lang_key = Configuration.get_var(lid, "GENERAL", "LANG")
translated = key
if key not in LANGS[lang_key]:
if key not in untranlatable:
BOT.loop.create_task(tranlator_log('WARNING', f'Untranslatable string detected: {key}\n'))
untranlatable.add(key)
return key if key not in LANGS["en_US"] else format(LANGS['en_US'][key], kwargs, 'en_US')
try:
translated = format(LANGS[lang_key][key], kwargs, lang_key)
except (KeyError, ValueError, ParseError, VisitationError) as ex:
BOT.loop.create_task(tranlator_log('NO', f'Corrupt translation detected!\n**Lang code:** {lang_key}\n**Translation key:** {key}\n```\n{LANGS[lang_key][key]}```'))
GearbotLogging.exception("Corrupt translation", ex)
if key in LANGS["en_US"].keys():
try:
translated = format(LANGS['en_US'][key], kwargs, 'en_US')
except (KeyError, ValueError, ParseError, VisitationError) as ex:
BOT.loop.create_task(tranlator_log('NO', f'Corrupt English source string detected!\n**Translation key:** {key}\n```\n{LANGS["en_US"][key]}```'))
GearbotLogging.exception('Corrupt translation', ex)
return translated
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 translation_task(bot):
while not bot.is_closed():
try:
await Translator.update()
except Exception as ex:
GearbotLogging.error(
"Something went wrong during translation updates")
GearbotLogging.error(traceback.format_exc())
embed = Embed(colour=Colour(0xff0000),
timestamp=datetime.utcfromtimestamp(time.time()))
embed.set_author(
name="Something went wrong during translation updates")
embed.add_field(name="Exception", value=str(ex))
v = ""
for line in traceback.format_exc().splitlines():
if len(v) + len(line) >= 1024:
embed.add_field(name="Stacktrace", value=v)
v = ""
v = f"{v}\n{line}"
if len(v) > 0:
embed.add_field(name="Stacktrace", value=v)
await GearbotLogging.bot_log(embed=embed)
try:
await asyncio.sleep(6 * 60 * 60)
except asyncio.CancelledError:
pass # bot shutting down
async def taco_eater(self):
"""A person can eat a taco every 5 mins, we run every 5s"""
GearbotLogging.info("Time to start munching on some 🌮")
while self.running:
self.bot.eaten += len(self.bot.users) / 60
await asyncio.sleep(5)
GearbotLogging.info("Cog terminated, guess no more 🌮 for people")
async def node_init(generation, resource_version):
from database import DatabaseConnector
from database.DatabaseConnector import Node
await DatabaseConnector.init()
hostname = os.uname()[1]
GearbotLogging.info(
f"GearBot clusternode {hostname} (generation {generation}). Trying to figure out where i fit in"
)
existing = await Node.filter(hostname=hostname,
generation=generation).get_or_none()
if existing is None:
count = 0
while count < 100:
try:
await Node.create(hostname=hostname,
generation=generation,
resource_version=resource_version,
shard=count)
return count
except Exception as ex:
GearbotLogging.exception("did something go wrong?", ex)
count += 1
else:
return existing.shard
