async def cog_check(self, ctx):
return await ctx.bot.is_owner(
ctx.author) or ctx.author.id in Configuration.get_master_var(
"BOT_ADMINS", [])
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')
parser = ArgumentParser()
parser.add_argument("--token", help="Specify your Discord token")
parser.add_argument("--total_shards", help="Total shard count")
parser.add_argument("--num_shards",
help="Amount of shards to start in this cluster")
parser.add_argument("--offset", help="Shard offset")
clargs = parser.parse_args()
GearbotLogging.init_logger(int(clargs.offset) if clargs.offset else 0)
if 'gearbotlogin' in os.environ:
token = os.environ['gearbotlogin']
elif clargs.token:
token = clargs.token
elif Configuration.get_master_var("LOGIN_TOKEN", "0") != "0":
token = Configuration.get_master_var("LOGIN_TOKEN")
else:
token = input("Please enter your Discord token: ")
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
intents = Intents(
guilds=True,
members=True,
bans=True,
emojis=True,
integrations=False,
webhooks=False,
invites=False,
async def initialize(bot):
await gearbot.login(token)
try:
await GearbotLogging.initialize(
bot, Configuration.get_master_var("BOT_LOG_CHANNEL"))
# database
GearbotLogging.info(
f"Cluster {bot.cluster} connecting to the database.")
await DatabaseConnector.init()
GearbotLogging.info(
f"Cluster {bot.cluster} database connection established.")
await Emoji.initialize(bot)
Utils.initialize(bot)
InfractionUtils.initialize(bot)
bot.data = {"unbans": set(), "nickname_changes": set()}
c = await Utils.get_commit()
bot.version = c
GearbotLogging.info(
f"GearBot cluster {bot.cluster} spinning up version {c}")
await GearbotLogging.bot_log(
f"{Emoji.get_chat_emoji('ALTER')} GearBot cluster {bot.cluster} spinning up version {c}"
)
socket = Configuration.get_master_var("REDIS_SOCKET", "")
if socket == "":
bot.redis_pool = await aioredis.create_redis_pool(
(Configuration.get_master_var('REDIS_HOST', "localhost"),
Configuration.get_master_var('REDIS_PORT', 6379)),
encoding="utf-8",
db=0)
else:
bot.redis_pool = await aioredis.create_redis_pool(socket,
encoding="utf-8",
db=0,
maxsize=3)
GearbotLogging.info(
"Cluster {bot.cluster} redis connection established")
await GearbotLogging.bot_log(
f"{Emoji.get_chat_emoji('YES')} Cluster {bot.cluster} redis connection established, let's go full speed!"
)
bot.aiosession = aiohttp.ClientSession()
await Translator.initialize(bot)
bot.being_cleaned.clear()
await Configuration.initialize(bot)
bot.start_time = datetime.datetime.utcnow().replace(
tzinfo=datetime.timezone.utc)
for extension in Configuration.get_master_var("COGS"):
try:
GearbotLogging.info(f"Loading {extension} cog...")
bot.load_extension("Cogs." + extension)
except ExtensionAlreadyLoaded:
pass
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.add_view(InfSearch([], 1, 0))
bot.STARTUP_COMPLETE = True
info = await bot.application_info()
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} {info.name} initialization complete, going online! {b}"
)
except Exception as e:
await handle_exception("Startup failure", bot, e)
raise e
def get_translator_log_channel():
crowdin = Configuration.get_master_var("TRANSLATIONS", dict(SOURCE="SITE", CHANNEL=0, KEY= "", LOGIN="", WEBROOT=""))
channel = BOT.get_channel(crowdin["CHANNEL"]) if crowdin is not None else None
return channel.send if channel is not None else GearbotLogging.bot_log
async def initialize(bot, startup=False):
#lock event handling while we get ready
bot.locked = True
try:
#database
GearbotLogging.info(
f"Cluster {bot.cluster} connecting to the database.")
await DatabaseConnector.init()
GearbotLogging.info(
f"Cluster {bot.cluster} database connection established.")
await Emoji.initialize(bot)
Utils.initialize(bot)
InfractionUtils.initialize(bot)
bot.data = {
"forced_exits": set(),
"unbans": set(),
"message_deletes": set(),
"nickname_changes": set()
}
await GearbotLogging.initialize(
bot, Configuration.get_master_var("BOT_LOG_CHANNEL"))
if startup:
c = await Utils.get_commit()
bot.version = c
GearbotLogging.info(
f"GearBot cluster {bot.cluster} spinning up version {c}")
await GearbotLogging.bot_log(
f"{Emoji.get_chat_emoji('ALTER')} GearBot cluster {bot.cluster} spinning up version {c}"
)
if bot.redis_pool is None:
try:
socket = Configuration.get_master_var("REDIS_SOCKET", "")
if socket == "":
bot.redis_pool = await aioredis.create_redis_pool(
(Configuration.get_master_var('REDIS_HOST',
"localhost"),
Configuration.get_master_var('REDIS_PORT', 6379)),
encoding="utf-8",
db=0)
else:
bot.redis_pool = await aioredis.create_redis_pool(
socket, encoding="utf-8", db=0)
except OSError:
GearbotLogging.error(
"==============Failed to connect to redis==============")
await GearbotLogging.bot_log(
f"{Emoji.get_chat_emoji('NO')} Failed to connect to redis, caching unavailable"
)
else:
GearbotLogging.info(
"Cluster {bot.cluster} redis connection established")
await GearbotLogging.bot_log(
f"{Emoji.get_chat_emoji('YES')} Cluster {bot.cluster} redis connection established, let's go full speed!"
)
if bot.aiosession is None:
bot.aiosession = aiohttp.ClientSession()
await Translator.initialize(bot)
bot.being_cleaned.clear()
await Configuration.initialize(bot)
DashConfig.initialize(bot)
except Exception as ex:
#make sure we always unlock, even when something went wrong!
bot.locked = False
raise ex
bot.locked = False
from peewee import *
from Util import Configuration
connection = MySQLDatabase(Configuration.get_master_var("DATABASE_NAME"),
user=Configuration.get_master_var("DATABASE_USER"),
password=Configuration.get_master_var("DATABASE_PASS"),
host=Configuration.get_master_var("DATABASE_HOST"),
port=Configuration.get_master_var("DATABASE_PORT"), use_unicode=True, charset="utf8mb4")
class LoggedMessage(Model):
messageid = BigIntegerField(primary_key=True)
content = CharField(max_length=2048, collation="utf8mb4_general_ci", null=True)
author = BigIntegerField()
channel = BigIntegerField()
server = BigIntegerField()
class Meta:
database = connection
class LoggedAttachment(Model):
id = BigIntegerField(primary_key=True)
url = CharField()
isImage = BooleanField()
messageid = BigIntegerField()
class Meta:
database = connection
async def init():
GearbotLogging.info("Connecting to the database...")
await Tortoise.init(db_url=Configuration.get_master_var('DATABASE'),
modules={"models": ["database.DatabaseConnector"]})
await Tortoise.generate_schemas()
async def on_interaction(self, interaction):
guild = self.bot.get_guild(interaction.guild_id)
if interaction.type == InteractionType.component:
cid = interaction.data.custom_id
if cid.startswith('self_role'):
parts = cid.split(':')
if parts[1] == 'role':
rid = parts[2]
if rid.isnumeric():
rid = int(rid)
roles = Configuration.get_var(interaction.guild_id,
"ROLES", "SELF_ROLES")
if rid in roles:
role = guild.get_role(rid)
if role is None:
roles.remove(rid)
Configuration.set_var(interaction.guild_id,
"ROLES", "SELF_ROLES",
roles)
v = SelfRoleView(guild=guild, page=0)
interaction.response.edit_message(
content=Translator.translate(
"assignable_roles",
interaction.guild_id,
server_name=guild.name,
page_num=1,
page_count=v.pages),
view=v)
interaction.followup.send_message(
MessageUtils.assemble(
interaction.guild_id, 'WARNING',
'self_role_missing'),
ephemeral=True)
else:
try:
if role in interaction.user.roles:
await interaction.user.remove_roles(
role)
await interaction.response.send_message(
Translator.translate(
"role_left",
interaction.guild_id,
role_name=role.name,
user=interaction.user),
ephemeral=True)
else:
await interaction.user.add_roles(role)
await interaction.response.send_message(
Translator.translate(
"role_joined",
interaction.guild_id,
role_name=role.name,
user=interaction.user),
ephemeral=True)
except disnake.Forbidden:
await interaction.response.send_message(
f"{Emoji.get_chat_emoji('NO')} {Translator.translate('role_too_high_add', interaction.guild_id, role=role.name)}",
ephemeral=True)
elif parts[1] == "page":
v = SelfRoleView(guild=interaction.guild,
page=int(parts[2]))
await interaction.response.edit_message(
content=Translator.translate(
"assignable_roles",
interaction.guild_id,
server_name=interaction.guild.name,
page_num=int(parts[2]) + 1,
page_count=v.pages),
view=v)
elif cid.startswith('help:'):
parts = cid.split(':')
if parts[1] == 'page':
q = parts[3] if parts[3] != 'None' else None
content, view = await Help.message_parts(
self.bot, q, guild, interaction.user, int(parts[2]))
await interaction.response.edit_message(content=content,
view=view)
elif parts[1] == 'selector':
q = interaction.values[0]
q = q if q != 'None' else None
content, view = await Help.message_parts(
self.bot, q, guild, interaction.user, 0)
await interaction.response.edit_message(content=content,
view=view)
elif cid.startswith('pager:'):
parts = cid.split(':')
t = parts[2]
if t == 'eval':
if interaction.user.id not in Configuration.get_master_var(
'BOT_ADMINS'):
return
output = await self.bot.redis_pool.get(f'eval:{parts[3]}')
if output is None:
await interaction.response.send_message(
"Eval output no longer available", ephemeral=True)
else:
pages = Pages.paginate(output,
prefix='```py\n',
suffix='```')
content, view, page_num = SimplePager.get_parts(
pages, int(parts[1]), interaction.guild_id,
f'eval:{parts[3]}')
await interaction.response.edit_message(
content=
f'Eval output {page_num + 1}/{len(pages)}{content}',
view=view)
elif t == 'commands':
cog = self.bot.get_command("CustCommands")
if cog is not None:
pages = cog.get_command_pages(interaction.guild_id)
content, view, page_num = SimplePager.get_parts(
pages, int(parts[1]), guild.id, 'commands')
page = cog.gen_command_page(pages, page_num,
interaction.guild)
await interaction.response.edit_message(embed=page,
view=view)
elif t == 'emoji':
cog = self.bot.get_cog('Emoji')
if cog is not None:
amount = len(guild.emojis) + 1
content, view, page_num = SimplePager.get_parts(
range(amount), int(parts[1]), interaction.guild.id,
'emoji')
await interaction.response.edit_message(
embed=cog.gen_emoji_page(guild, page_num),
view=view)
elif t == 'role_list':
cog = self.bot.get_cog('Moderation')
if cog is not None:
pages = cog.gen_roles_pages(interaction.guild,
parts[3])
content, view, page_num = SimplePager.get_parts(
pages, int(parts[1]), guild.id,
f'role_list:{parts[3]}')
await interaction.response.edit_message(
content=
f"**{Translator.translate('roles', interaction.guild_id, server_name=guild.name, page_num=page_num + 1, pages=len(pages))}**```\n{pages[page_num]}```",
view=view)
elif t == 'censor_list':
cog = self.bot.get_cog('Moderation')
if cog is not None:
censor_list = Configuration.get_var(
interaction.guild.id, "CENSORING",
"TOKEN_CENSORLIST")
pages = Pages.paginate("\n".join(censor_list))
page, view, page_num = SimplePager.get_parts(
pages, int(parts[1]), interaction.guild.id,
'censor_list')
await interaction.response.edit_message(
content=
f"**{Translator.translate(f'censor_list', guild, server=guild.name, page_num=page_num + 1, pages=len(pages))}**```\n{page}```",
view=view)
elif t == 'word_censor_list':
cog = self.bot.get_cog('Moderation')
if cog is not None:
censor_list = Configuration.get_var(
guild.id, "CENSORING", "WORD_CENSORLIST")
pages = Pages.paginate("\n".join(censor_list))
page, view, page_num = SimplePager.get_parts(
pages, int(parts[1]), guild.id, 'word_censor_list')
await interaction.response.edit_message(
content=
f"**{Translator.translate(f'word_censor_list', guild, server=guild.name, page_num=page_num + 1, pages=len(pages))}**```\n{page}```",
view=view)
elif t == 'full_censor_list':
cog = self.bot.get_cog('Moderation')
if cog is not None:
censor_list = Configuration.get_var(
guild.id, "CENSORING", "FULL_MESSAGE_LIST")
pages = Pages.paginate("\n".join(censor_list))
page, view, page_num = SimplePager.get_parts(
pages, int(parts[1]), guild.id, 'full_censor_list')
await interaction.response.edit_message(
content=
f"**{Translator.translate(f'full_censor_list', guild, server=guild.name, page_num=page_num + 1, pages=len(pages))}**```\n{page}```",
view=view)
elif t == 'flag_list':
cog = self.bot.get_cog('Moderation')
if cog is not None:
censor_list = Configuration.get_var(
guild.id, "FLAGGING", "TOKEN_LIST")
pages = Pages.paginate("\n".join(censor_list))
page, view, page_num = SimplePager.get_parts(
pages, int(parts[1]), guild.id, 'flag_list')
await interaction.response.edit_message(
content=
f"**{Translator.translate(f'flagged_list', guild, server=guild.name, page_num=page_num + 1, pages=len(pages))}**```\n{page}```",
view=view)
elif t == 'word_flag_list':
cog = self.bot.get_cog('Moderation')
if cog is not None:
censor_list = Configuration.get_var(
guild.id, "FLAGGING", "WORD_LIST")
pages = Pages.paginate("\n".join(censor_list))
page, view, page_num = SimplePager.get_parts(
pages, int(parts[1]), guild.id, 'word_flag_list')
await interaction.response.edit_message(
content=
f"**{Translator.translate(f'flagged_word_list', guild, server=guild.name, page_num=page_num + 1, pages=len(pages))}**```\n{page}```",
view=view)
elif t == 'mass_failures':
output = await self.bot.redis_pool.get(
f'mass_failures:{parts[3]}')
if output is None:
await interaction.response.send_message(
MessageUtils.assemble(interaction.guild_id, 'NO',
'view_expired'),
ephemeral=True)
else:
pages = Pages.paginate(output,
prefix='```\n',
suffix='```')
content, view, page_num = SimplePager.get_parts(
pages, int(parts[1]), interaction.guild_id,
f'mass_failures:{parts[3]}:{parts[4]}')
await interaction.response.edit_message(
content=
f"**{Translator.translate(f'mass_failures_{parts[4]}', interaction.guild_id, page_num=page_num+1, pages=len(pages))}**{content}",
view=view)
elif cid.startswith('einf_search:'):
parts = cid.split(':')
uid = int(parts[1])
old_page = int(parts[2])
t = parts[3]
if t == 'first_page':
page, current, pages, query, fields = await get_ephemeral_cached_page(
interaction, uid, 0)
await interaction.response.edit_message(
content=await InfractionUtils.assemble_message(
interaction.guild_id, page, query, current, pages),
view=EphemeralInfSearch(filters=fields,
pages=pages,
current_page=current,
guild_id=interaction.guild_id,
userid=uid))
elif t == 'prev_page':
page, current, pages, query, fields = await get_ephemeral_cached_page(
interaction, uid, old_page - 1)
await interaction.response.edit_message(
content=await InfractionUtils.assemble_message(
interaction.guild_id, page, query, current, pages),
view=EphemeralInfSearch(filters=fields,
pages=pages,
current_page=current,
guild_id=interaction.guild_id,
userid=uid))
elif t == 'blank':
await interaction.response.send_message(
Emoji.get_chat_emoji('AE'), ephemeral=True)
elif t == 'next_page':
page, current, pages, query, fields = await get_ephemeral_cached_page(
interaction, uid, old_page + 1)
await interaction.response.edit_message(
content=await InfractionUtils.assemble_message(
interaction.guild_id, page, query, current, pages),
view=EphemeralInfSearch(filters=fields,
pages=pages,
current_page=current,
guild_id=interaction.guild_id,
userid=uid))
elif t == 'last_page':
page, current, pages, query, fields = await get_ephemeral_cached_page(
interaction, uid, 1000)
await interaction.response.edit_message(
content=await InfractionUtils.assemble_message(
interaction.guild_id, page, query, current, pages),
view=EphemeralInfSearch(filters=fields,
pages=pages,
current_page=current,
guild_id=interaction.guild_id,
userid=uid))
elif interaction.type == InteractionType.application_command:
if interaction.data.name == "Extract user IDs":
self.bot.metrics.uid_usage.labels(
type="channel", cluster=self.bot.cluster).inc()
await interaction.response.defer(ephemeral=True)
parts = await Utils.get_user_ids(
interaction.data.resolved.messages[
interaction.data.target_id].content)
if len(parts) > 0:
for chunk in Pages.paginate("\n".join(parts), 200):
await interaction.followup.send(chunk)
else:
await interaction.followup.send(
MessageUtils.assemble(interaction.guild, "NO",
"no_uids_found"))
elif interaction.data["name"] == "Send user IDs to DM":
self.bot.metrics.uid_usage.labels(
type="DM", cluster=self.bot.cluster).inc()
await interaction.response.defer(ephemeral=True)
parts = await Utils.get_user_ids(
interaction.data["resolved"]["messages"][
interaction.data["target_id"]]["content"])
if len(parts) > 0:
try:
for chunk in Pages.paginate("\n".join(parts), 200):
await interaction.user.send(chunk)
except Forbidden:
await interaction.followup.send("Unable to send DM")
else:
await interaction.followup.send("IDs sent in DM")
else:
try:
await interaction.user.send(
MessageUtils.assemble(interaction.guild, "NO",
"no_uids_found"))
except Forbidden:
await interaction.followup.send("Unable to send DM")
else:
await interaction.followup.send("IDs sent in DM")
elif interaction.data.name == "Userinfo":
if await Permissioncheckers.check_permission(
self.bot.get_command("userinfo"), interaction.guild,
interaction.user, self.bot):
t = "allowed"
target = interaction.data["target_id"]
member = None
user_dict = interaction.data["resolved"]["users"][target]
user = User(data=user_dict, state=interaction._state)
if "members" in interaction.data[
"resolved"] and target in interaction.data[
"resolved"]["members"]:
member_dict = interaction.data["resolved"]["members"][
target]
member_dict["user"] = user_dict
member = Member(data=member_dict,
guild=interaction.guild,
state=interaction._state)
embed = await Utils.generate_userinfo_embed(
user, member, interaction.guild, interaction.user)
await interaction.response.send_message(embed=embed,
ephemeral=True)
else:
t = "denied"
await interaction.response.send_message(
MessageUtils.assemble(interaction.guild, 'LOCK',
'permission_denied'),
ephemeral=True)
self.bot.metrics.userinfo_usage.labels(
type=t, cluster=self.bot.cluster).inc()
elif interaction.data.name == "Search Infractions":
if await Permissioncheckers.check_permission(
self.bot.get_command("inf search"), interaction.guild,
interaction.user, self.bot):
uid = int(interaction.data["target_id"])
t = "allowed"
await interaction.response.send_message(
MessageUtils.assemble(interaction.guild, 'SEARCH',
'inf_search_compiling'),
ephemeral=True)
pages = await InfractionUtils.fetch_infraction_pages(
interaction.guild.id, uid, 100,
["[user]", "[mod]", "[reason]"], 0)
page = await self.bot.wait_for(
'page_assembled',
check=lambda l: l['key'] == get_key(
interaction.guild.id, uid, [
"[user]", "[mod]", "[reason]"
], 100) and l['page_num'] == 0)
await interaction.edit_original_message(
content=await InfractionUtils.assemble_message(
interaction.guild.id, page['page'], uid, 0, pages),
view=EphemeralInfSearch(
filters=["[user]", "[mod]", "[reason]"],
pages=pages,
guild_id=interaction.guild.id,
userid=uid))
else:
t = "denied"
await interaction.response.send_message(
MessageUtils.assemble(interaction.guild, 'LOCK',
'permission_denied'),
ephemeral=True)
self.bot.metrics.inf_search_usage.labels(
type=t, cluster=self.bot.cluster).inc()
"===========================================DATA DUMP COMPLETE==========================================="
)
Logging.error("\n".join(lines))
# nice embed for info on discord
embed.set_author(name=exception_type)
embed.add_field(name="Exception",
value=f"{str(exception)} (`{type(exception)}`)",
inline=False)
parts = Utils.paginate(tb, max_chars=1024)
num = 1
for part in parts:
embed.add_field(name=f"Traceback {num}/{len(parts)}", value=part)
num += 1
# try logging to botlog, wrapped in an try catch as there is no higher lvl catching to prevent taking down the bot (and if we ended here it might have even been due to trying to log to botlog
try:
await Logging.bot_log(embed=embed)
except Exception as ex:
Logging.error(
f"Failed to log to botlog, either Discord broke or something is seriously wrong!\n{ex}"
)
Logging.error(traceback.format_exc())
token = Configuration.get_master_var("TOKEN")
Logging.info("Ready to go, spinning up the engine")
bot.run(token)
Logging.info("Outboard shutdown complete")
def initialize(bot):
for name, eid in Configuration.get_master_var("EMOJI", {}).items():
emojis[name] = utils.get(bot.emojis, id=eid)
async def send_error_log(bot, message):
channel = bot.get_channel(Configuration.get_master_var("BOT_LOG_CHANNEL"))
await channel.send(message)
def upload_file():
data = {'files[/bot/commands.json]': open('lang/en_US.json', 'r')}
crowdin_data = Configuration.get_master_var("TRANSLATIONS", dict(SOURCE="SITE", CHANNEL=0, KEY= "", LOGIN="", WEBROOT=""))
reply = requests.post(f"https://api.crowdin.com/api/project/gearbot/update-file?login={crowdin_data['LOGIN']}&account-key={crowdin_data['KEY']}&json", files=data)
GearbotLogging.info(reply)
async def on_raw_message_edit(self, event: RawMessageUpdateEvent):
cid = int(event.data["channel_id"])
if cid == Configuration.get_master_var("BOT_LOG_CHANNEL"):
return
c = self.bot.get_channel(cid)
if c is None or isinstance(
c, DMChannel) or c.guild is None or (not Features.is_logged(
c.guild.id,
"MESSAGE_LOGS")) or cid in Configuration.get_var(
c.guild.id, "MESSAGE_LOGS", "IGNORED_CHANNELS_OTHER"):
return
message = await MessageUtils.get_message_data(self.bot,
event.message_id)
if message is not None and "content" in event.data:
channel: discord.TextChannel = self.bot.get_channel(
int(event.data["channel_id"]))
if channel.guild is None:
return
user: discord.User = self.bot.get_user(message.author)
hasUser = user is not None
if message.content == event.data["content"]:
# either pinned or embed data arrived, if embed data arrives it's gona be a recent one so we'll have the cached message to compare to
old = message.pinned
new = event.data["pinned"]
if old == new:
return
else:
parts = dict(channel=Utils.escape_markdown(c.name),
channel_id=c.id)
if new:
# try to find who pinned it
key = "message_pinned"
m = await c.history(limit=5
).get(type=MessageType.pins_add)
if m is not None:
key += "_by"
parts.update(user=Utils.escape_markdown(m.author),
user_id=m.author.id)
else:
# impossible to determine who unpinned it :meowsad:
key = "message_unpinned"
GearbotLogging.log_key(c.guild.id, key, **parts)
GearbotLogging.log_raw(
c.guild.id, key,
f'```\n{Utils.trim_message(event.data["content"], 1990)}\n```'
)
GearbotLogging.log_raw(
c.guild.id, key,
f"{Translator.translate('jump_link', c.guild.id)}: {MessageUtils.construct_jumplink(c.guild.id, c.id, event.message_id)}"
)
await MessageUtils.update_message(self.bot,
event.message_id,
message.content, new)
return
mc = message.content
if mc is None or mc == "":
mc = f"<{Translator.translate('no_content', channel.guild.id)}>"
after = event.data["content"]
if after is None or after == "":
after = f"<{Translator.translate('no_content', channel.guild.id)}>"
if hasUser and user.id not in Configuration.get_var(
channel.guild.id, "MESSAGE_LOGS",
"IGNORED_USERS") and user.id != channel.guild.me.id:
GearbotLogging.log_key(channel.guild.id,
'edit_logging',
user=Utils.clean_user(user),
user_id=user.id,
channel=channel.mention)
if Configuration.get_var(channel.guild.id, "MESSAGE_LOGS",
"EMBED"):
embed = discord.Embed()
embed.set_author(
name=user if hasUser else message.author,
icon_url=user.avatar_url if hasUser else EmptyEmbed)
embed.set_footer(
text=Translator.translate('sent_in',
channel.guild.id,
channel=f"#{channel.name}"))
embed.add_field(name=Translator.translate(
'before', channel.guild.id),
value=Utils.trim_message(mc, 1024),
inline=False)
embed.add_field(name=Translator.translate(
'after', channel.guild.id),
value=Utils.trim_message(after, 1024),
inline=False)
GearbotLogging.log_raw(channel.guild.id,
"edit_logging",
embed=embed)
else:
clean_old = await Utils.clean(mc, channel.guild)
clean_new = await Utils.clean(after, channel.guild)
GearbotLogging.log_raw(channel.guild.id, "edit_logging",
f"**Old:** {clean_old}")
GearbotLogging.log_raw(channel.guild.id, "edit_logging",
f"**New:** {clean_new}")
await MessageUtils.update_message(self.bot, event.message_id,
after, event.data["pinned"])
def prefix_callable(bot, message):
return TheRealGearBot.prefix_callable(bot, message)
gearbot = GearBot(command_prefix=prefix_callable, case_insensitive=True, max_messages = 100) #100 is the min for some reason
if __name__ == '__main__':
parser = ArgumentParser()
parser.add_argument("--token", help="Specify your Discord token")
GearbotLogging.init_logger()
clargs = parser.parse_args()
if 'gearbotlogin' in os.environ:
token = os.environ['gearbotlogin']
elif clargs.token:
token = clargs.token
elif not Configuration.get_master_var("LOGIN_TOKEN", "0") is "0":
token = Configuration.get_master_var("LOGIN_TOKEN")
else:
token = input("Please enter your Discord token: ")
gearbot.remove_command("help")
GearbotLogging.info("Ready to go, spinning up the gears")
gearbot.run(token)
GearbotLogging.info("GearBot shutting down, cleaning up")
gearbot.database_connection.close()
GearbotLogging.info("Cleanup complete")
def upload_file():
data = {'files[master/lang/en_US.json]': open('lang/en_US.json', 'r')}
project_key = Configuration.get_master_var("CROWDIN_KEY")
requests.post(f"https://api.crowdin.com/api/project/gearbot/update-file?key={project_key}&json", files=data)
async def initialize(bot):
emoji_guild = await bot.fetch_guild(Configuration.get_master_var("EMOJI_GUILD"))
for name, eid in Configuration.get_master_var("EMOJI", {}).items():
emojis[name] = utils.get(bot.emojis, id=eid)
from peewee import *
from Util import Configuration
from Util.Enums import ReminderStatus
from database.DBFields import TinyIntField
connection = MySQLDatabase(
Configuration.get_master_var("DATABASE_NAME"),
user=Configuration.get_master_var("DATABASE_USER"),
password=Configuration.get_master_var("DATABASE_PASS"),
host=Configuration.get_master_var("DATABASE_HOST"),
port=Configuration.get_master_var("DATABASE_PORT"),
use_unicode=True,
charset="utf8mb4")
class EnumField(IntegerField):
"""This class enables an Enum field for Peewee"""
def __init__(self, choices, *args, **kwargs):
super().__init__(*args, **kwargs)
self.choices = choices
def db_value(self, value):
return value.value
def python_value(self, value):
return self.choices(value)
class LoggedMessage(Model):
messageid = BigIntegerField(primary_key=True)
def upload_file():
data = {'files[master/lang/en_US.json]': open('lang/en_US.json', 'r')}
crowdin_data = Configuration.get_master_var("CROWDIN")
requests.post(
f"https://api.crowdin.com/api/project/gearbot/update-file?login={crowdin_data['login']}&account-key={crowdin_data['key']}&json",
files=data)
