async def on_guild_channel_create(self, channel: discord.abc.GuildChannel):
guild: discord.Guild = channel.guild
roleid = Configuration.get_var(guild.id, "MUTE_ROLE")
if roleid is not 0:
role = guild.get_role(roleid)
if role is not None and channel.permissions_for(
guild.me).manage_channels:
if isinstance(channel, discord.TextChannel):
try:
await channel.set_permissions(
role,
reason=Translator.translate(
'mute_setup', guild.id),
send_messages=False,
add_reactions=False)
except discord.Forbidden:
pass
else:
try:
await channel.set_permissions(
role,
reason=Translator.translate(
'mute_setup', guild.id),
speak=False,
connect=False)
except discord.Forbidden:
pass
async def on_member_join(self, member: discord.Member):
now = datetime.datetime.fromtimestamp(time.time())
if Infraction.get_or_none(Infraction.type == "Mute",
Infraction.active == True,
Infraction.end >= now,
Infraction.guild_id == member.guild.id,
Infraction.user_id == member.id):
roleid = Configuration.get_var(member.guild.id, "MUTE_ROLE")
if roleid is not 0:
role = member.guild.get_role(roleid)
if role is not None:
if member.guild.me.guild_permissions.manage_roles:
await member.add_roles(role,
reason=Translator.translate(
'mute_reapply_reason',
member.guild.id))
GearbotLogging.log_to(
member.guild.id, "MOD_ACTIONS",
f"{Emoji.get_chat_emoji('MUTE')} {Translator.translate('mute_reapply_log', member.guild.id, user=Utils.clean_user(member), user_id=member.id)}"
)
else:
GearbotLogging.log_to(
member.guild.id, "MOD_ACTIONS",
Translator.translate('mute_reapply_failed_log',
member.build.id))
async def _kick(self, ctx, user, reason, confirm):
self.bot.data["forced_exits"].add(f"{ctx.guild.id}-{user.id}")
await ctx.guild.kick(
user,
reason=Utils.trim_message(
f"Moderator: {ctx.author.name}#{ctx.author.discriminator} ({ctx.author.id}) Reason: {reason}",
500))
translated = Translator.translate('kick_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)
GearbotLogging.log_to(ctx.guild.id, "MOD_ACTIONS",
f":boot: {translated}")
InfractionUtils.add_infraction(ctx.guild.id,
user.id,
ctx.author.id,
Translator.translate(
'kick', ctx.guild.id),
reason,
active=False)
if confirm:
await GearbotLogging.send_to(ctx,
"YES",
"kick_confirmation",
ctx.guild.id,
user=Utils.clean_user(user),
user_id=user.id,
reason=reason)
async def forceban(self,
ctx: commands.Context,
user_id: int,
*,
reason=""):
"""purge_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)
await ctx.guild.ban(
user,
reason=
f"Moderator: {ctx.author.name} ({ctx.author.id}) Reason: {reason}",
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), reason=reason)}"
)
await GearbotLogging.logToModLog(
ctx.guild,
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)}"
)
InfractionUtils.add_infraction(
ctx.guild.id, user.id, ctx.author.id,
Translator.translate('forced_ban', ctx.guild.id), reason)
else:
await ctx.send(
f"{Emoji.get_chat_emoji('WARNING')} {Translator.translate('forceban_to_ban', ctx.guild.id)}"
)
await ctx.invoke(self.ban, member, reason=reason)
def can_act(action,
ctx,
user,
require_on_server=True,
action_bot=True,
check_bot_ability=True):
is_member = isinstance(user, Member)
if not require_on_server and not is_member:
return True, None
if (not is_member) and require_on_server:
return False, Translator.translate("user_not_on_server", ctx.guild.id)
if check_bot_ability and user.top_role >= ctx.guild.me.top_role:
return False, Translator.translate(f'{action}_unable',
ctx.guild.id,
user=Utils.clean_user(user))
if (
(ctx.author != user and ctx.author.top_role > user.top_role) or
(ctx.guild.owner == ctx.author)
) and user != ctx.guild.owner and user != ctx.bot.user and ctx.author != user:
return True, None
if user.bot and not action_bot:
return False, Translator.translate(f"cant_{action}_bot",
ctx.guild.id,
user=user)
return False, Translator.translate(f'{action}_not_allowed',
ctx.guild.id,
user=user)
async def role(self, ctx: commands.Context, *, role: str = None):
"""role_help"""
if role is None:
await Pages.create_new("role", ctx)
else:
try:
role = await commands.RoleConverter().convert(ctx, role)
except BadArgument as ex:
await ctx.send(Translator.translate("role_not_found", ctx))
else:
roles = Configuration.get_var(ctx.guild.id, "SELF_ROLES")
if role.id in roles:
try:
if role in ctx.author.roles:
await ctx.author.remove_roles(role)
await ctx.send(
Translator.translate("role_left",
ctx,
role_name=role.name))
else:
await ctx.author.add_roles(role)
await ctx.send(
Translator.translate("role_joined",
ctx,
role_name=role.name))
except discord.Forbidden:
await ctx.send(
f"{Emoji.get_chat_emoji('NO')} {Translator.translate('mute_role_to_high', ctx, role=role.name)}"
)
else:
await ctx.send(
Translator.translate("role_not_allowed", ctx))
async def role(self, ctx: commands.Context, *, role: str = None):
"""role_help"""
if role is None:
await Pages.create_new("role", ctx)
else:
try:
role = await commands.RoleConverter().convert(ctx, role)
except Exception as ex:
await ctx.send(Translator.translate("role_not_found", ctx))
else:
roles = Configuration.getConfigVar(ctx.guild.id, "SELF_ROLES")
if role.id in roles:
if role in ctx.author.roles:
await ctx.author.remove_roles(role)
await ctx.send(
Translator.translate("role_left",
ctx,
role_name=role.name))
else:
await ctx.author.add_roles(role)
await ctx.send(
Translator.translate("role_joined",
ctx,
role_name=role.name))
else:
await ctx.send(
Translator.translate("role_not_allowed", ctx))
def gen_emoji_page(self, guild: discord.Guild, page):
se = sorted(guild.emojis, key=lambda e: e.name)
embed = Embed(color=0x2db1f3)
embed.set_author(name=Translator.translate('emoji_server',
guild,
server=guild.name,
page=page + 1,
pages=len(guild.emojis) +
1),
url=guild.icon_url)
if page == 0:
for chunk in Utils.chunks(se, 18):
embed.add_field(name="\u200b",
value=" ".join(str(e) for e in chunk))
animated = set()
static = set()
for e in guild.emojis:
(animated if e.animated else static).add(str(e))
max_emoji = guild.emoji_limit
embed.add_field(name=Translator.translate('static_emoji', guild),
value=f"{len(static)} / {max_emoji}")
embed.add_field(name=Translator.translate('animated_emoji', guild),
value=f"{len(animated)} / {max_emoji}")
else:
self.add_emoji_info(guild, embed, se[page - 1])
return embed
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 ban(self,
ctx: commands.Context,
user: discord.Member,
*,
reason=""):
"""ban_help"""
if reason == "":
reason = Translator.translate("no_reason", ctx.guild.id)
if (ctx.author != user and user != ctx.bot.user and ctx.author.top_role
> user.top_role) or ctx.guild.owner == ctx.author:
if ctx.me.top_role > user.top_role:
self.bot.data["forced_exits"].append(user.id)
await ctx.guild.ban(
user,
reason=
f"Moderator: {ctx.author.name} ({ctx.author.id}) Reason: {reason}",
delete_message_days=0)
await ctx.send(
f"{Emoji.get_chat_emoji('YES')} {Translator.translate('ban_confirmation', ctx.guild.id, user=Utils.clean_user(user), user_id=user.id, reason=reason)}"
)
await GearbotLogging.logToModLog(
ctx.guild,
f":door: {Translator.translate('ban_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)}"
)
InfractionUtils.add_infraction(ctx.guild.id, user.id,
ctx.author.id, "Ban", reason)
else:
await ctx.send(
Translator.translate('ban_unable',
ctx.guild.id,
user=Utils.clean_user(user)))
else:
await ctx.send(
f"{Emoji.get_chat_emoji('NO')} {Translator.translate('ban_not_allowed', ctx.guild.id, user=user)}"
)
def to_pretty_time(seconds, guild_id):
seconds = max(round(seconds, 2), 0)
partcount = 0
parts = {
'weeks': 60 * 60 * 24 * 7,
'days': 60 * 60 * 24,
'hours_solo': 60 * 60,
'minutes': 60,
'seconds': 1
}
duration = ""
if seconds < 1:
return Translator.translate("seconds", guild_id, amount=seconds)
for k, v in parts.items():
if seconds / v >= 1:
amount = math.floor(seconds / v)
seconds -= amount * v
if partcount == 1:
duration += ", "
duration += " " + Translator.translate(k, guild_id, amount=amount)
if seconds == 0:
break
return duration.strip()
async def about(self, ctx):
"""about_help"""
uptime = datetime.utcnow() - self.bot.start_time
hours, remainder = divmod(int(uptime.total_seconds()), 3600)
days, hours = divmod(hours, 24)
minutes, seconds = divmod(remainder, 60)
tacos = "{:,}".format(round(self.bot.eaten))
user_messages = "{:,}".format(self.bot.user_messages)
bot_messages = "{:,}".format(self.bot.bot_messages)
self_messages = "{:,}".format(self.bot.self_messages)
total = "{:,}".format(sum(len(guild.members) for guild in self.bot.guilds))
unique = "{:,}".format(len(self.bot.users))
embed = discord.Embed(colour=discord.Colour(0x00cea2),
timestamp=datetime.utcfromtimestamp(time.time()),
description=
MessageUtils.assemble(ctx, 'DIAMOND', 'about_spinning_gears', duration=Translator.translate('dhms', ctx, days=days, hours=hours, minutes=minutes, seconds=seconds)) + "\n"+
MessageUtils.assemble(ctx, 'GOLD', 'about_messages', user_messages=user_messages, bot_messages=bot_messages, self_messages=self_messages) + "\n"+
MessageUtils.assemble(ctx, 'IRON', 'about_grinders', errors=self.bot.errors) + "\n" +
MessageUtils.assemble(ctx, 'STONE', 'about_commands', commandCount=self.bot.commandCount, custom_command_count=self.bot.custom_command_count) + "\n" +
MessageUtils.assemble(ctx, 'WOOD', 'about_guilds', guilds=len(self.bot.guilds)) + "\n" +
MessageUtils.assemble(ctx, 'INNOCENT', 'about_users', total=total, unique=unique) + "\n" +
MessageUtils.assemble(ctx, 'TACO', 'about_tacos', tacos=tacos) + "\n" +
MessageUtils.assemble(ctx, 'ALTER', 'commit_hash', hash=self.bot.version) +
MessageUtils.assemble(ctx, 'TODO', 'about_stats'))
click_here = Translator.translate('click_here', ctx)
embed.add_field(name=Translator.translate('support_server', ctx), value=f"[{click_here}](https://discord.gg/vddW3D9)")
embed.add_field(name=Translator.translate('website', ctx), value=f"[{click_here}](https://gearbot.rocks)")
embed.add_field(name=f"Github", value=f"[{click_here}](https://github.com/gearbot/GearBot)")
embed.set_footer(text=self.bot.user.name, icon_url=self.bot.user.avatar_url)
await ctx.send(embed=embed)
async def kick(self, ctx, user: discord.Member, *, reason=""):
"""kick_help"""
if reason == "":
reason = Translator.translate("no_reason", ctx.guild.id)
self.bot.data["forced_exits"].append(user.id)
if (ctx.author != user and user != ctx.bot.user and ctx.author.top_role
> user.top_role) or ctx.guild.owner == ctx.author:
if ctx.me.top_role > user.top_role:
await ctx.guild.kick(
user,
reason=
f"Moderator: {ctx.author.name}#{ctx.author.discriminator} ({ctx.author.id}) Reason: {reason}"
)
await ctx.send(
f"{Emoji.get_chat_emoji('YES')} {Translator.translate('kick_confirmation', ctx.guild.id, user=Utils.clean_user(user), user_id=user.id, reason=reason)}"
)
await GearbotLogging.logToModLog(
ctx.guild,
f":boot: {Translator.translate('kick_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)}"
)
InfractionUtils.add_infraction(
ctx.guild.id, user.id, ctx.author.id,
Translator.translate('kick', ctx.guild.id), reason)
else:
await ctx.send(
Translator.translate('kick_unable',
ctx.guild.id,
user=Utils.clean_user(user)))
else:
await ctx.send(
f"{Emoji.get_chat_emoji('NO')} {Translator.translate('kick_not_allowed', ctx.guild.id, user=user)}"
)
async def apexstats(self, ctx, platform: ApexPlatform, *, username):
"""about_apexstats"""
headers = {"TRN-Api-Key": Configuration.get_master_var("APEX_KEY")}
url = "https://public-api.tracker.gg/apex/v1/standard/profile/" + platform + "/" + (
username)
async with self.bot.aiosession.get(url, headers=headers) as resp:
if resp.status == 404:
await MessageUtils.send_to(ctx, "NO",
"apexstats_user_not_found")
return
elif not resp.status == 200:
await MessageUtils.send_to(ctx, "NO", "apexstats_api_error")
return
else:
responsejson = await resp.json()
embed = disnake.Embed(
colour=disnake.Colour(0x00cea2),
timestamp=datetime.datetime.utcfromtimestamp(
time.time()).replace(tzinfo=datetime.timezone.utc))
embed.add_field(
name=Translator.translate('apexstats_username', ctx),
value=await Utils.clean(
responsejson["data"]["metadata"]["platformUserHandle"]
))
for stat_type in responsejson["data"]["stats"]:
type_key_name = stat_type["metadata"]["key"]
type_key_value = stat_type["displayValue"]
embed.add_field(name=Translator.translate(
f'apexstats_key_{type_key_name}', ctx),
value=type_key_value)
await ctx.send(embed=embed)
def __init__(self, filters, pages, guild_id, userid, current_page=0):
super().__init__(timeout=None)
self.id = ""
if pages > 0:
start = f"einf_search:{userid}:{current_page}"
self.add_item(
Button(label=Translator.translate('first_page', guild_id),
custom_id=f'{start}:first_page',
disabled=current_page == 0,
style=ButtonStyle.blurple))
self.add_item(
Button(label=Translator.translate('prev_page', guild_id),
custom_id=f'{start}:prev_page',
disabled=current_page == 0,
style=ButtonStyle.blurple))
self.add_item(
Button(emoji=Emoji.get_emoji('AE'),
style=ButtonStyle.grey,
custom_id=f'{start}:blank',
label=None))
self.add_item(
Button(label=Translator.translate('next_page', guild_id),
custom_id=f'{start}:next_page',
disabled=current_page >= pages - 1,
style=ButtonStyle.blurple))
self.add_item(
Button(label=Translator.translate('last_page', guild_id),
custom_id=f'{start}:last_page',
disabled=current_page >= pages - 1,
style=ButtonStyle.blurple))
self.stop()
async def quote(self, ctx: commands.Context, *, message: Message):
"""quote_help"""
await ctx.trigger_typing()
member = message.guild.get_member(ctx.author.id)
if member is None:
await GearbotLogging.send_to(ctx, 'NO',
'quote_not_visible_to_user')
else:
permissions = message.channel.permissions_for(member)
if permissions.read_message_history and permissions.read_message_history:
if message.channel.is_nsfw() and not ctx.channel.is_nsfw():
await GearbotLogging.send_to(ctx, 'NO',
'quote_nsfw_refused')
else:
attachment = None
attachments = LoggedAttachment.select().where(
LoggedAttachment.messageid == message.id)
if len(attachments) == 1:
attachment = attachments[0]
embed = discord.Embed(colour=discord.Color(0xd5fff),
timestamp=message.created_at)
if message.content is None or message.content == "":
if attachment is not None:
if attachment.isImage:
embed.set_image(url=attachment.url)
else:
embed.add_field(name=Translator.translate(
"attachment_link", ctx),
value=attachment.url)
else:
description = message.content
embed = discord.Embed(colour=discord.Color(0xd5fff),
description=description,
timestamp=message.created_at)
embed.add_field(
name="​",
value=f"[Jump to message]({message.jump_url})")
if attachment is not None:
if attachment.isImage:
embed.set_image(url=attachment.url)
else:
embed.add_field(name=Translator.translate(
"attachment_link", ctx),
value=attachment.url)
user = message.author
embed.set_author(name=user.name, icon_url=user.avatar_url)
embed.set_footer(text=Translator.translate(
"quote_footer",
ctx,
channel=message.channel.name,
user=Utils.clean_user(ctx.author),
message_id=message.id))
await ctx.send(embed=embed)
if ctx.channel.permissions_for(ctx.me).manage_messages:
await ctx.message.delete()
else:
await GearbotLogging.send_to(ctx, 'NO',
'quote_not_visible_to_user')
async def list_list(ctx, item_type, list_name="roles", wrapper="<@&{item}>"):
items = Configuration.get_var(ctx.guild.id, f"{item_type}_{list_name}".upper())
if len(items) == 0:
desc = Translator.translate(f"no_{item_type}_{list_name}", ctx)
else:
desc = "\n".join(wrapper.format(item=item) for item in items)
embed = discord.Embed(title=Translator.translate(f"current_{item_type}_{list_name}", ctx), description=desc)
await ctx.send(embed=embed)
def time_difference(begin, end, location):
diff = begin - end
minutes, seconds = divmod(diff.days * 86400 + diff.seconds, 60)
hours, minutes = divmod(minutes, 60)
return (Translator.translate(
'days', location,
amount=diff.days)) if diff.days > 0 else Translator.translate(
'hours', location, hours=hours, minutes=minutes)
def handler(guild, old, new, parts):
GearbotLogging.log_key(
guild.id,
f"config_dash_security_change",
type=Translator.translate(f"config_dash_security_{t.lower()}",
guild.id),
old=Translator.translate(f"perm_lvl_{old}", guild.id),
new=Translator.translate(f"perm_lvl_{new}", guild.id),
**parts)
async def quote(self, ctx:commands.Context, message_id:int):
"""quote_help"""
embed = None
async with ctx.typing():
message = LoggedMessage.get_or_none(messageid=message_id)
if message is None:
for guild in self.bot.guilds:
for channel in guild.text_channels:
try:
dmessage: discord.Message = await channel.get_message(message_id)
for a in dmessage.attachments:
LoggedAttachment.get_or_create(id=a.id, url=a.url,
isImage=(a.width is not None or a.width is 0),
messageid=message.id)
message = LoggedMessage.create(messageid=message_id, content=dmessage.content, author=dmessage.author.id, timestamp = dmessage.created_at.timestamp(), channel=channel.id, server=dmessage.guild.id)
except Exception as ex:
#wrong channel
pass
if message is not None:
break
if message is not None:
channel = self.bot.get_channel(message.channel)
attachment = None
attachments = LoggedAttachment.select().where(LoggedAttachment.messageid == message_id)
if len(attachments) == 1:
attachment = attachments[0]
embed = discord.Embed(colour=discord.Color(0xd5fff), timestamp=datetime.utcfromtimestamp(message.timestamp))
if message.content is None or message.content == "":
if attachment is not None:
if attachment.isImage:
embed.set_image(url=attachment.url)
else:
embed.add_field(name=Translator.translate("attachement_link", ctx), value=attachment.url)
else:
description = message.content
embed = discord.Embed(colour=discord.Color(0xd5fff), description=description, timestamp=datetime.utcfromtimestamp(message.timestamp))
embed.add_field(name="", value=f"https://discordapp.com/channels/{channel.guild.id}/{channel.id}/{message_id}")
if attachment is not None:
if attachment.isImage:
embed.set_image(url=attachment.url)
else:
embed.add_field(name=Translator.translate("attachement_link", ctx), value=attachment.url)
try:
user = await commands.MemberConverter().convert(ctx, message.author)
except:
user = await ctx.bot.get_user_info(message.author)
embed.set_author(name=user.name, icon_url=user.avatar_url)
embed.set_footer(text=Translator.translate("quote_footer", ctx, channel=self.bot.get_channel(message.channel).name, user=Utils.clean(ctx.author.display_name), message_id=message_id))
if embed is None:
await ctx.send(Translator.translate("quote_not_found", ctx))
else:
if channel.is_nsfw() and not ctx.channel.is_nsfw():
await ctx.send(f"{Emoji.get_chat_emoji('NO')} {Translator.translate('quote_nsfw_refused', ctx)}")
return
await ctx.send(embed=embed)
if ctx.channel.permissions_for(ctx.me).manage_messages:
await ctx.message.delete()
async def mute_role(self, ctx: commands.Context, role: discord.Role):
"""configure_mute_help"""
if role == ctx.guild.default_role:
return await ctx.send(
f"{Emoji.get_chat_emoji('NO')} {Translator.translate(f'default_role_forbidden', ctx)}"
)
guild: discord.Guild = ctx.guild
perms = guild.me.guild_permissions
if not perms.manage_roles:
await ctx.send(
f"{Emoji.get_chat_emoji('NO')} {Translator.translate('mute_missing_perm', ctx)}"
)
return
if not guild.me.top_role > role:
await ctx.send(
f"{Emoji.get_chat_emoji('NO')} {Translator.translate('mute_missing_perm', ctx, role=role.mention)}"
)
return
Configuration.setConfigVar(ctx.guild.id, "MUTE_ROLE", int(role.id))
await ctx.send(
f"{Emoji.get_chat_emoji('YES')} {Translator.translate('mute_role_confirmation', ctx, role=role.mention)}"
)
failed = []
for channel in guild.text_channels:
try:
await channel.set_permissions(role,
reason=Translator.translate(
'mute_setup', ctx),
send_messages=False,
add_reactions=False)
except discord.Forbidden as ex:
failed.append(channel.mention)
for channel in guild.voice_channels:
try:
await channel.set_permissions(role,
reason=Translator.translate(
'mute_setup', ctx),
speak=False,
connect=False)
except discord.Forbidden as ex:
failed.append(
Translator.translate('voice_channel',
ctx,
channel=channel.name))
if len(failed) > 0:
message = f"{Emoji.get_chat_emoji('WARNING')} {Translator.translate('mute_setup_failures', ctx, role=role.mention)}\n"
for fail in failed:
if len(message) + len(fail) > 2048:
await ctx.send(message)
message = ""
message = message + fail
if len(message) > 0:
await ctx.send(message)
else:
await ctx.send(
f"{Emoji.get_chat_emoji('YES')} {Translator.translate('mute_setup_complete', ctx)}"
)
def server_info_embed(guild, request_guild=None):
guild_features = ", ".join(guild.features)
if guild_features == "":
guild_features = None
guild_made = guild.created_at.strftime("%d-%m-%Y")
embed = discord.Embed(color=guild.roles[-1].color, timestamp=datetime.utcfromtimestamp(time.time()))
embed.set_thumbnail(url=guild.icon_url_as())
embed.add_field(name=Translator.translate('server_name', request_guild), value=guild.name, inline=True)
embed.add_field(name=Translator.translate('id', request_guild), value=guild.id, inline=True)
embed.add_field(name=Translator.translate('owner', request_guild), value=guild.owner, inline=True)
embed.add_field(name=Translator.translate('members', request_guild), value=guild.member_count, inline=True)
embed.add_field(
name=Translator.translate('channels', request_guild),
value=f"{Emoji.get_chat_emoji('CATEGORY')} {Translator.translate('categories', request_guild)}: {str(len(guild.categories))}\n"
f"{Emoji.get_chat_emoji('CHANNEL')} {Translator.translate('text_channels', request_guild)}: {str(len(guild.text_channels))}\n"
f"{Emoji.get_chat_emoji('VOICE')} {Translator.translate('voice_channels', request_guild)}: {str(len(guild.voice_channels))}\n"
f"{Translator.translate('total_channel', request_guild)}: {str(len(guild.text_channels) + len(guild.voice_channels))}",
inline=True
)
embed.add_field(
name=Translator.translate('created_at', request_guild),
value=f"{guild_made} ({(datetime.fromtimestamp(time.time()) - guild.created_at).days} days ago)",
inline=True
)
embed.add_field(
name=Translator.translate('vip_features', request_guild),
value=guild_features,
inline=True
)
if guild.icon_url_as() != "":
embed.add_field(
name=Translator.translate('server_icon', request_guild),
value=f"[{Translator.translate('server_icon', request_guild)}]({guild.icon_url_as()})",
inline=True
)
roles = ", ".join(role.name for role in guild.roles)
embed.add_field(
name=Translator.translate('all_roles', request_guild),
value=roles if len(roles) < 1024 else f"{len(guild.roles)} roles",
inline=False
)
if guild.emojis:
emoji = "".join(str(e) for e in guild.emojis)
embed.add_field(
name=Translator.translate('emoji', request_guild),
value=emoji if len(emoji) < 1024 else f"{len(guild.emojis)} emoji"
)
if guild.splash_url != "":
embed.set_image(url=guild.splash_url)
if guild.banner_url_as() != "":
embed.set_image(url=guild.banner_url_as())
return embed
async def list_channels(ctx, type):
channel_list = Configuration.get_var(ctx.guild.id, f'IGNORED_CHANNELS_{type.upper()}')
if len(channel_list) > 0:
channels = "\n".join(ctx.guild.get_channel(c).mention for c in channel_list)
else:
channels = Translator.translate('no_ignored_channels', ctx)
embed = discord.Embed(color=ctx.guild.roles[-1].color, description=channels)
embed.set_author(name=Translator.translate(f'ignored_channels_list_{type}', ctx, guild=ctx.guild.name), icon_url=ctx.guild.icon_url)
await ctx.send(embed=embed)
async def update_cf(self, ctx, message, page_num, action, data):
pages = await self.gen_cf_pages(ctx, data["project_name"], False)
if pages is None:
return Translator.translate('cf_not_found', ctx), None, False
embed = disnake.Embed(title=Translator.translate('cf_info_title', ctx, project_name=data['project_name']))
page, page_num = Pages.basic_pages(pages, page_num, action)
for k, v in page.items():
embed.add_field(name=k, value=v)
return None, embed, page_num
def __init__(self, filters, pages, guild_id, current_page=0, ephemeral=False, userid=""):
super().__init__(timeout=None)
self.id=""
if pages > 0:
self.add_item(CallbackButton(Translator.translate('first_page', guild_id), self.on_first_page, 'inf_search:first_page', disabled=current_page == 0))
self.add_item(CallbackButton(Translator.translate('prev_page', guild_id), self.on_prev_page, 'inf_search:prev_page', disabled=current_page == 0))
self.add_item(CallbackButton(emoji=Emoji.get_emoji('AE'), style=ButtonStyle.grey, cid='inf_search:blank', callback=self.hi, label=None))
self.add_item(CallbackButton(Translator.translate('next_page', guild_id), self.on_next_page, 'inf_search:next_page', disabled=current_page >= pages-1))
self.add_item(CallbackButton(Translator.translate('last_page', guild_id), self.on_last_page, 'inf_search:last_page', disabled=current_page >= pages-1))
async def coinflip(self, ctx, *, thing:str = ""):
"""coinflip_help"""
if thing == "":
thing = Translator.translate("coinflip_default", ctx)
outcome = random.randint(1, 2)
if outcome == 1 or ("mute" in thing and "vos" in thing):
await ctx.send(Translator.translate("coinflip_yes", ctx, thing=thing))
else:
await ctx.send(Translator.translate("coinflip_no", ctx, thing=thing))
async def update_pages(guild_id, query, fields, amount, pages, start,
longest_id, longest_type, longest_timestamp, header):
key = get_key(guild_id, query, fields, amount)
count = len(pages)
if start >= count:
start = 0
elif start < 0:
start = count - 1
order = [start]
lower = start - 1
upper = start + 1
GearbotLogging.debug(f"Determining page order for {key}")
while len(order) < len(pages):
if upper == len(pages):
upper = 0
order.append(upper)
upper += 1
if len(order) == len(pages):
break
if lower == -1:
lower = len(pages) - 1
order.append(lower)
lower -= 1
GearbotLogging.debug(f"Updating pages for {key}, ordering: {order}")
for number in order:
longest_name = max(len(Translator.translate('moderator', guild_id)),
len(Translator.translate('user', guild_id)))
page = pages[number]
found = set(ID_MATCHER.findall(page))
for uid in found:
name = await Utils.username(int(uid.strip()), clean=False)
longest_name = max(longest_name, len(name))
for uid in found:
name = Utils.pad(
await Utils.username(int(uid.strip()), clean=False),
longest_name)
page = page.replace(f"<@{uid}>", name).replace(f"<@!{uid}>", name)
page = f"{header}```md\n{get_header(longest_id, longest_name, longest_type, longest_timestamp, guild_id)}\n{page}```"
GearbotLogging.debug(
f"Finished assembling page {number} for key {key}")
try:
await bot.redis_pool.lset(key, number, page)
except ReplyError:
return # key expired while we where working on it
pages[number] = page
GearbotLogging.debug(f"Pushed page {number} for key {key} to redis")
bot.dispatch("page_assembled", {
"key": key,
"page_num": number,
"page": page
})
GearbotLogging.debug(
f"All pages assembled for key {key}, setting expiry to 60 minutes")
bot.dispatch("all_pages_assembled", {"key": key, "pages": pages})
await bot.redis_pool.expire(key, 60 * 60)
async def init_cf(self, ctx, project_name):
info = await self.get_info(ctx, project_name, True)
pages = await self.gen_cf_pages(ctx, project_name, True)
if pages is None:
return Translator.translate('cf_not_found', ctx), None, False, []
embed = disnake.Embed(title=Translator.translate('cf_info_title', ctx, project_name=project_name))
embed.set_thumbnail(url=info["thumbnail"])
for k, v in pages[0].items():
embed.add_field(name=k, value=v)
return None, embed, len(pages) > 1, []
async def fetch_infraction_pages(guild_id, query, amount, fields, requested):
key = get_key(guild_id, query, fields, amount)
if query == "":
infs = await Infraction.filter(guild_id=guild_id
).order_by("-id").limit(50)
else:
subfilters = []
if "[user]" in fields and isinstance(query, int):
subfilters.append(Q(user_id=query))
if "[mod]" in fields and isinstance(query, int):
subfilters.append(Q(mod_id=query))
if "[reason]" in fields:
subfilters.append(Q(reason__icontains=str(query)))
infs = await Infraction.filter(
Q(Q(*subfilters, join_type="OR"),
guild_id=guild_id,
join_type="AND")).order_by("-id").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)}> | {datetime.fromtimestamp(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)
async def info(self, ctx, infraction: ServerInfraction):
"""inf_info_help"""
embed = discord.Embed(color=0x00cea2,
description=f"**{Translator.translate('reason', ctx)}**\n{infraction.reason}",
timestamp=datetime.fromtimestamp(infraction.start))
user = await Utils.get_user(infraction.user_id)
mod = await Utils.get_user(infraction.mod_id)
key = f"inf_{infraction.type.lower().replace(' ', '_')}"
if infraction.end is None:
duration = Translator.translate("unknown_duration", ctx)
else:
time = (datetime.fromtimestamp(infraction.end) - datetime.fromtimestamp(infraction.start)).total_seconds()
duration = Utils.to_pretty_time(time, ctx.guild.id)
embed.set_author(
name=Translator.translate(key, ctx, mod=Utils.username_from_user(mod), user=Utils.username_from_user(user),
duration=duration),
icon_url=mod.avatar_url)
embed.set_thumbnail(url=user.avatar_url)
embed.add_field(name=Translator.translate('moderator', ctx), value=Utils.clean_user(mod))
embed.add_field(name=Translator.translate('user', ctx), value=Utils.clean_user(user))
embed.add_field(name=Translator.translate('mod_id', ctx), value=infraction.mod_id)
embed.add_field(name=Translator.translate('user_id', ctx), value=infraction.user_id)
embed.add_field(name=Translator.translate('inf_added', ctx), value=datetime.fromtimestamp(infraction.start))
if infraction.end is not None:
embed.add_field(name=Translator.translate('inf_end', ctx), value=datetime.fromtimestamp(infraction.end))
embed.add_field(name=Translator.translate('inf_active', ctx),
value=MessageUtils.assemble(ctx, 'YES' if infraction.active else 'NO',
str(infraction.active).lower()))
images = self.IMAGE_MATCHER.findall(infraction.reason)
if len(images) > 0:
embed.set_image(url=images[0])
await ctx.send(embed=embed)
