def reward_xp(self, event, user_id):
points = self.config.reward_points
uid = self.get_id(user_id)
if int(uid) in event.guild.members:
name = str(event.guild.members[int(uid)])
else:
name = uid
if uid is None:
event.msg.reply("🚫 invalid snowflake/mention").after(5).delete()
event.msg.delete()
return
user = self.get_user(uid)
if points < 0:
event.msg.reply("🚫 removing xp is not allowed!")
log_to_bot_log(self.bot, f"âš {event.author} tried to remove xp from {name}")
return
xp = user["xp"] + points
self.users.update_one({
"user_id": str(uid)
}, {
"$set": {
"xp": xp
}
})
event.msg.reply(f":ok_hand: <@{uid}> received some xp for helping out!")
log_to_bot_log(self.bot, f":pencil: {event.msg.author} gave {points} to {name} (``{uid}``), new xp total: {xp}")
def github(self, event):
event.msg.reply(
f"My source code can be found at <{self.config.source_code_location}>"
)
log_to_bot_log(
self.bot,
":bug: " + str(event.msg.author) + " used the Github command.")
def give_xp(self, event, user_id, points):
uid = self.get_id(user_id)
if uid is None:
event.msg.reply(":no_entry_sign: invalid snowflake/mention").after(
5).delete()
return
user = self.get_user(uid)
if user["xp"] + points < 0:
xp = 0
self.users.update_one({"user_id": str(uid)}, {"$set": {"xp": xp}})
log_to_bot_log(
self.bot,
":pencil: {mod} updated point total for {user} to {points}".
format(mod=str(event.msg.author),
user=str(uid),
points=str(xp)))
event.msg.reply("User cannot have below 0 points, so set to 0."
).after(5).delete()
event.msg.delete()
return
xp = user["xp"] + points
self.users.update_one({"user_id": str(uid)}, {"$set": {"xp": xp}})
event.msg.reply(":ok_hand: {user} point total updated to {points}".format(user=str(uid), points=xp)) \
.after(5).delete()
event.msg.delete()
log_to_bot_log(
self.bot,
":pencil: {mod} updated point total for {user} to {points}".format(
mod=str(event.msg.author), user=str(uid), points=str(xp)))
def remove_squasher_roles(self):
t = time.time()
purchases = self.purchases.find({
"expired": False,
"time": {
"$lt": t - 604800.0
},
"type": "bug_squasher"
})
for purchase in purchases:
print("[SQ] expired squasher role detected.")
# purchase has expired.
guild = self.bot.client.api.guilds_get(self.config.dtesters_guild_id)
if not guild: # if not in guild, wait until we are.
print("[SQ] guild couldn't be found.")
return
member = guild.get_member(str(purchase["user_id"]))
# they left, so that means they don't have bug squasher
if not member:
self.set_purchase_expired(purchase["_id"])
continue
role = self.config.roles["squasher"]
if role in member.roles:
member.remove_role(role)
log_to_bot_log(self.bot,
"Removed the bug squasher role from {} as their purchase expired".format(str(member)))
self.set_purchase_expired(purchase["_id"])
def questions_made_easy(self, event, args):
#Checks to see if the topic in the list and then replies with the message in annouceBot.py
args.question_title = args.question_title.lower()
event.msg.delete()
if args.question_title in self.config.frequently_asked_questions.keys():
event.msg.reply(self.config.frequently_asked_questions[args.question_title])
log_to_bot_log(self.bot, ":notebook: "+str(event.msg.author)+" used the tag command for `"+args.question_title+"`.")
def on_message_create(self, event):
# If the bot does the thing in the right channel, check what mentors are available.
if self.config.join_phrase in event.content and event.channel_id == self.config.channels[
'new_bh']:
the_chosen_one = self.get_mentor()
else:
return
# If there's at least one mentor in the list, ping them.
if the_chosen_one is None:
self.bot.client.api.channels_messages_create(
self.config.channels['mentor'],
self.config.messages['no_bh_mentors'].format(
event.content[10:28]))
log_to_bot_log(
self.bot, self.config.messages['no_bh_mentors'].format(
event.content[10:28]))
return
react_message = self.bot.client.api.channels_messages_create(
self.config.channels['mentor'],
self.config.messages['new_bh_join'].format(event.content[10:28],
the_chosen_one.id))
self.bot.client.api.channels_messages_reactions_create(
self.config.channels['mentor'], react_message.id,
self.build_emoji('mentor'))
def start_command(self, event):
"""Start the event"""
if self.status != "Scheduled":
event.msg.reply("Event has already started")
return
if event.guild is None:
return
# give bug hunters access to submission channel
participants_role = event.guild.roles[int(self.config.participants_role)]
event_channel = event.guild.channels[int(self.config.event_channel)]
# determine current overrides and if one exists just flip the read channel bit around
perms = event_channel.overwrites
view_channel = 1024
if participants_role.id in perms.keys():
# update existing override
allow = perms[participants_role.id].allow.add(view_channel)
deny = perms[participants_role.id].deny.sub(view_channel)
event_channel.create_overwrite(participants_role, allow=allow, deny=deny)
else:
# no override present, make a new one
event_channel.create_overwrite(participants_role, allow=view_channel, deny=0)
self.status = "Started"
event.channel.send_message(
"<:approve:302137375092375553> Submissions channel unlocked and commands unlocked, here we go")
log_to_bot_log(self.bot, ":unlock: {name} (`{id}`) started the event.".format(name=str(event.msg.author),
id=event.msg.author.id))
self.save_event_stats()
def revoke(self, event, report):
"""Revoke a submission"""
if event.msg.channel.id != self.config.event_channel:
return
trello_info = TrelloUtils.getCardInfo(event, report)
if trello_info is None:
# invalid card
event.msg.reply("I can't even fetch info for that, you sure you reported that one?")
return
if not trello_info["id"] in self.reported_cards.keys():
# not reported yet
event.msg.reply("I don't have a report for that card, how do you expect me to edit a non existing thing?")
return
report_info = self.reported_cards[trello_info["id"]]
if report_info["author_id"] != str(event.author.id):
# someone else reported
event.msg.reply(
"I think there's been a case of mistaken identity here, this report was made by {} and it looks like you are {}".format(
self.participants[str(report_info["author_id"])], str(event.author)))
return
# delete message and entry
event.msg.channel.get_message(report_info["message_id"]).delete()
del self.reported_cards[trello_info["id"]]
event.msg.reply(":warning: Your submission has been nuked <@{}>!".format(event.author.id))
log_to_bot_log(self.bot,
f":outbox_tray: {event.author} (``{event.author.id}``) has revoked <https://trello.com/c/{trello_info['shortLink']}>")
self.save_event_stats()
def cancel_help_request(self, event):
session = self.helpme.find_one(
{'$and': [{
'helpee_id': event.author.id
}, {
'active': True
}]})
if session:
last_event = session['history'][-1][1]
if last_event == 'waiting':
try:
self.bot.client.api.channels_messages_delete(
self.config.channels['mentor'],
session['status_message_id'])
except APIException:
pass
elif last_event == 'assigned':
self.send_dm(session['mentor_id'],
f'{event.author} cancelled their HelpMe request')
session['history'].append(
(time.time(), 'cancelled', event.author.id))
self.helpme.update_one(
{'_id': session['_id']},
{'$set': {
'history': session['history'],
'active': False
}})
event.msg.reply(f'I have cancelled your open HelpMe request')
log_to_bot_log(
self.bot,
f'{event.author} cancelled their HelpMe request ({str(session["_id"])})'
)
else:
event.msg.reply("You don't have an open HelpMe request")
def clear_user(self, event, user, reason):
"""Someone's been so bad we need to remove all their submissions :("""
if not str(user.id) in self.participants:
# that definitely was the wrong user
event.msg.reply("This user has not participated in the event")
return
else:
# seperate list to remove as we can't alter the list we are iterating over
to_remove = []
for rid, report in self.reported_cards.items():
if str(user) == str(report["author_id"]):
try:
channel = event.guild.channels[self.config.event_channel]
channel.get_message(report["message_id"]).delete()
except APIException:
pass # mod already removed it?
to_remove.append(rid)
for r in to_remove:
del self.reported_cards[r]
event.channel.send_message(
"<{}> cleared reports from {}.".format(self.config.emojis["yes"], self.participants[str(user)]))
log_to_bot_log(self.bot,
":wastebasket: {mod} cleared all submissions for {user} with reason {reason}".format(
mod=str(event.msg.author), user=self.participants[str(user)], reason=reason))
del self.participants[str(user)]
self.save_event_stats()
def give_xp(self, event, user_id, points):
uid = self.get_id(user_id)
if int(uid) in event.guild.members:
name = str(event.guild.members[int(uid)])
else:
name = uid
if uid is None:
event.msg.reply(":no_entry_sign: invalid snowflake/mention").after(5).delete()
return
user = self.get_user(uid)
if user["xp"] + points < 0:
points = -user["xp"]
xp = user["xp"] + points
self.users.update_one({
"user_id": str(uid)
}, {
"$set": {
"xp": xp
}
})
event.msg.reply(f":ok_hand: {name} point total updated to {xp}").after(5).delete()
event.msg.delete()
log_to_bot_log(self.bot,f":pencil: {event.msg.author} gave {points} to {name} (``{user_id}``), new xp total: {xp}")
def give_lifetime_xp(self, event, user_id, points):
uid = self.get_id(user_id)
if int(uid) in event.guild.members:
name = str(event.guild.members[int(uid)])
else:
name = uid
if uid is None:
event.msg.reply(":no_entry_sign: invalid snowflake/mention").after(5).delete()
return
user = self.get_user(uid)
if user.get("badge-progress") is None:
event.msg.reply(":no_entry_sign: that user doesn't have lifetime XP. Wumpus forgot about them"
" (they need to perform a bot action or gain XP)").after(5).delete()
return
self.users.update_one({
"user_id": str(uid)
}, {
"$set": {
"badge-progress": user.get("badge-progress", user["xp"]) + points
}
})
badge_progress = user["badge-progress"]
event.msg.reply(f":ok_hand: {name} lifetime XP total updated to {badge_progress}.").after(5).delete()
event.msg.delete()
log_to_bot_log(self.bot,
f":pencil: {event.msg.author} gave {points} lifetime XP to {name} (``{user_id}``), new xp total: {xp}")
def edit(self, event, details):
if event.msg.channel.id != self.config.event_channel:
return
parts = details.split("|")
if len(parts) < 3:
event.msg.reply(
"<@{}> It seems you're missing parts, the syntax for this command is `+edit <trello link> | <section (destination or info)> | <new info>`".format(
event.author.id))
return
if len(parts) > 3:
parts[2] = "|".join(parts[2:])
link = parts[0]
section = parts[1].strip(" ").lower()
info = parts[2]
trello_info = TrelloUtils.getCardInfo(event, link)
if trello_info is None:
event.msg.reply("I can't even fetch info for that, you sure you reported that one?")
return
if not trello_info["id"] in self.reported_cards.keys():
event.msg.reply("I don't have a report for that card, how do you expect me to edit a non existing thing?")
return
report_info = self.reported_cards[trello_info["id"]]
if report_info["author_id"] != str(event.author.id):
event.msg.reply(
"I think there's been a case of mistaken identity here, this report was made by {} and it looks like you are {}".format(
self.participants[str(report_info["author_id"])], str(event.author)))
return
dmessage = event.guild.channels[self.config.event_channel].get_message(report_info["message_id"])
content = dmessage.content
new_message = ""
lines = content.splitlines()
if section == "destination":
new_message = "\n".join(lines[:2])
while not lines[2].startswith("**Submitted by**:"):
lines.pop(2)
new_message += "\n**Destination**: {}\n{}".format(sanitize.S(info, escape_codeblocks=True),
"\n".join(lines[2:]))
elif section == "info":
count = 0
while not lines[count].startswith("**Detailed info**"):
count += 1
new_message = "\n".join(lines[:count])
new_message += "\n**Detailed info**: {}\n{}".format(sanitize.S(info, escape_codeblocks=True),
"\n".join(lines[-1:]))
else:
event.msg.reply("Unknown section")
return
if len(new_message) > 2000:
event.msg.reply(
"<@{}> Sorry, but would make the report too long for me to process, would mind removing {} characters? Then everything should be fine again.".format(
event.author.id, len(new_message) - 2000))
return
print(new_message)
dmessage.edit(new_message)
event.channel.send_message("<@{}>, your report has been updated!".format(event.author.id))
log_to_bot_log(self.bot,
":pencil: {} has updated the {} of their submission for <https://trello.com/c/{}>".format(
str(event.author), section.lower(), trello_info["shortLink"]))
def end_event(self, event):
"""End the event, hide channel and prep for approval/denial"""
participants_role = event.guild.roles[int(self.config.participants_role)]
event_channel = event.guild.channels[int(self.config.event_channel)]
perms = event_channel.overwrites
view_channel = 1024
if participants_role.id in perms.keys():
event_channel.create_overwrite(participants_role, allow=0, deny=1024)
else:
event_channel.create_overwrite(participants_role, allow=0, deny=1024)
event.msg.delete()
event.channel.send_message("<{}> Event ended, preparing submissions...".format(self.config.emojis["yes"]))
log_to_bot_log(self.bot,
":lock: {user} ended event, prepping the submissions".format(user=str(event.msg.author)))
self.status = "Ended"
self.save_event_stats()
# loop through all submissions and add reactions to it
for reporter, report in self.reported_cards.items():
message = event_channel.get_message(report["message_id"])
self.bot.client.api.channels_messages_reactions_create(event_channel.id, message.id,
self.config.emojis["yes"])
self.bot.client.api.channels_messages_reactions_create(event_channel.id, message.id,
self.config.emojis["no"])
event.msg.reply("<@{}> all {} submissions have been prepped for approval/denial!".format(event.author.id, len(
self.reported_cards)))
def update_subscriptions(self, event, report_id, scopes = None):
report = self.reports.find_one({'report_id': report_id})
if report is not None:
user_id = str(event.author.id)
user_scopes = Scope(report['subs'].get(user_id, 0))
old_scopes = user_scopes
# User wants all notifications (or wants to reverse that)
if scopes is None:
if user_scopes == Scope.ALL:
# Could be confusing but acts as a toggle for convenience
user_scopes = Scope.NONE
response = f"You'll no longer receive notifications for #{report_id}"
else:
user_scopes = Scope.ALL
response = f"You'll receive all notifications for #{report_id}"
# User wants to clear notifications
elif scopes.lower() in ['clear', 'none']:
if user_scopes:
user_scopes = Scope.NONE
response = f"You'll no longer receive notifications for #{report_id}"
else:
response = f"You haven't registered for notifications for #{report_id}"
# User wants specific notifications
else:
req_scopes = Scope.NONE
# Try to parse the scopes they wanted
try:
for s in scopes.split(','):
req_scopes |= Scope[s.upper()]
except KeyError:
response = "I didn't recognise one or more of those scopes. Try `+notify <id>` to receive all notifications for a report"
else:
if req_scopes != Scope.NONE:
if req_scopes in user_scopes:
response = f"You already have notifications for these scopes. You can use `+notify <id> clear` to remove them"
else:
user_scopes |= req_scopes
response = f"You'll receive `{self._get_scope_str(user_scopes)}` notifications for #{report_id}"
# If they've made valid changes to their scopes
if old_scopes != user_scopes:
# Removed
if user_scopes == Scope.NONE:
self.reports.update_one({'report_id': report_id}, {'$unset': {f'subs.{user_id}': ''}})
log_to_bot_log(self.bot, f':pager: {event.author} removed notifications for #{report_id}')
# Added/Changed
else:
scope_str = self._get_scope_str(user_scopes)
self.reports.update_one({'report_id': report_id}, {'$set': {f'subs.{user_id}': user_scopes.value}})
log_to_bot_log(self.bot,
f':pager: {event.author} registered for `{scope_str}` notifications for #{report_id}')
event.msg.reply(f'{event.author.mention} {response}').after(5).delete()
else:
event.msg.reply(f"{event.author.mention} I can't find that report ID").after(5).delete()
if not event.msg.channel.is_dm:
try:
event.msg.delete()
except APIException:
# Bug Bot caught it
pass
def reload_plugins(self, event):
# do NOT reload this plugin, command execution gets interrupted otherwise!
todo = [plugin for name, plugin in self.bot.plugins.items() if name != "reload"]
for p in todo:
c = p.__class__
self.bot.rmv_plugin(c)
self.bot.add_plugin(c)
event.msg.reply("🔁 All plugins (and configs) have been reloaded")
log_to_bot_log(self.bot, f"🔁 {event.msg.author} reloaded all plugins (and configs)")
def grant_role(self, event):
if 441739649753546764 in event.member.roles:
event.member.remove_role(441739649753546764)
log_to_bot_log(self.bot, f":thumbsdown: {str(event.author)} removed the A11y role from themselves.")
event.msg.reply(f"<@{event.author.id}> I have removed the A11y (Accessibility Role) from you. Use the same command again to add the role to yourself.").after(5).delete()
event.msg.delete()
else:
event.member.add_role(441739649753546764)
log_to_bot_log(self.bot, f":thumbsup: {event.author} added the A11y role to themselves.")
event.msg.reply(f"<@{event.author.id}> I have added the A11y (Accessibility Role) to you. Use the same command again to remove the role from yourself.").after(5).delete()
event.msg.delete()
def answer_frequent_questions(self, event):
if event.author.id in self.bot_IDs.values():
return
for role in event.member.roles:
if role in self.advanced_roles.values():
return
self.FAQ_dictionary = self.get_questions_as_a_dict()
for key in self.FAQ_dictionary.keys():
if key.lower() in event.content.lower():
time.sleep(3)
event.reply(self.FAQ_dictionary[key].replace("\\n", "\n"))
log_to_bot_log(self.bot, f":clock1: {event.author} activated the auto response.")
def add_xp(self, user_id, amount):
uid = str(user_id)
user = self.users.find_one({'user_id': uid})
if user is None:
user = {'user_id': uid, 'xp': 0}
self.users.insert_one(user)
total = user['xp'] + amount
self.users.update_one({'user_id': uid}, {'$set': {'xp': total}})
log_to_bot_log(
self.bot,
f':pencil: Updated point total for {uid} to {total} for completing a HelpMe request'
)
def set_dm_guide_percentage(self, event, percent):
percent = percent / 100
self.experiments["dm-guide-on-join"] = percent
file = open("experiments.json", "w")
file.write(json.dumps(self.experiments))
file.close()
event.msg.reply(
":ok_hand: set dm guide percentage experimentation thing to `{percent}`"
.format(percent=percent * 100))
log_to_bot_log(
self.bot,
":wrench: DM Guide percentage updated to `{percent}` by {user}".
format(percent=percent * 100, user=str(event.msg.author)))
def make_unmentionable_after_ping(self, event):
if event.author.id in self.config.bot_IDs.values():
return
for Mentioned_Role in self.config.role_IDs.values():
# errors if it's an int, so making it a string
Mentioned_Role = str(Mentioned_Role)
if Mentioned_Role in event.content:
# in order to make it unmentionable it has to be an int. So now changing that var back to an int.
Mentioned_Role = int(Mentioned_Role)
Role_To_Make_Mentionable = event.guild.roles.get(Mentioned_Role)
Role_To_Make_Mentionable.update(mentionable=False)
log_to_bot_log(self.bot, f":exclamation: A role ping was detected and the role was successfully set to be unmentionable.")
return
return
def emergency_lockdown(self, event, args):
event.msg.delete()
for name, channelID in self.config.channels_to_lockdown.items():
# lock the channel if listed or when locking everything
if name in args.channel_names or args.channel_names == "all":
log_to_bot_log(self.bot, ":lock: The "+name+" channel has been locked by "+str(event.msg.author)+" for the reason: "+args.reason+".")
# grab the first (bug hunter or test role) for the queue, grab everyone (or whatever test role is there) for public channels
rolename = "bug_hunter" if name == "bug" else "everyone"
role = event.guild.roles[self.config.role_IDs_to_lockdown[rolename]]
channel = event.guild.channels[channelID]
channel.send_message(args.reason)
# deny reactions and sending perms
channel.create_overwrite(role, allow=0, deny=2112)
event.msg.reply("Lockdown command has successfully completed!")
def sync_queue(self, event):
queue = event.guild.channels[self.config.channels['bug-approval-queue']]
reports = []
for message in queue.messages:
if message.author.id == self.config.bug_bot_user_id:
search = re.findall(r'(?<=Report\sID:\s\*{2})[0-9]+', message.content)
if search:
report_id = int(search[-1])
if not self.reports.find_one({'report_id': report_id}):
reports.append({'report_id': report_id, 'subs': {}, 'queue_msg': message.id})
if len(reports) > 0:
self.reports.insert_many(reports)
log_to_bot_log(self.bot,
f':envelope_with_arrow: {event.author} triggered a notify sync. {len(reports)} unseen reports added to the database')
event.msg.delete()
def remove_report(self, event, report):
trello_info = TrelloUtils.getCardInfo(event, report)
if trello_info is None:
event.msg.reply("I can't even fetch info for that, you sure someone reported that one?")
return
if not trello_info["id"] in self.reported_cards.keys():
event.msg.reply(
"I don't have a report for that card, how do you expect me to edit a non existing thing?")
return
report_info = self.reported_cards[trello_info["id"]]
event.guild.channels[self.config.event_channel].get_message(report_info["message_id"]).delete()
del self.reported_cards[trello_info["id"]]
event.msg.reply(":warning: Submission has been nuked <@{}>!".format(event.author.id))
log_to_bot_log(self.bot, ":wastebasket: {} has removed <https://trello.com/c/{}>".format(str(event.author),
trello_info[
'shortLink']))
def export(self, event, file_name):
log_to_bot_log(self.bot, ":notepad_spiral: {user} is performing an XP export".format(
user=str(event.author)
))
msg = event.msg.reply(":gem: computing... (this might take a while)")
with open(file_name, "w+") as file:
user_dict = self.users.find()
newly_formed_user_dict = {}
for user in iter(user_dict):
newly_formed_user_dict[user["user_id"]] = {
"x": user["xp"],
"p": user.get("badge-progress", user["xp"])
}
data = json.dumps(newly_formed_user_dict)
file.write(data)
msg.edit(":ok_hand: complete! saved to `{file_name}`".format(
file_name=file_name
))
def change_verification_level(self, event, level, reason=None):
vl = VerificationLevel.get(level.lower())
if vl is not None:
if event.guild.verification_level != vl:
try:
self.bot.client.api.guilds_modify(event.guild.id, reason, verification_level=vl.value)
except APIException:
event.msg.reply("Failed to change the server verification level")
else:
if reason is None:
reason = ""
else:
reason = " with reason `{}`".format(reason)
log_to_bot_log(self.bot, ":vertical_traffic_light: {} changed the server verification level to {}{}".format(event.msg.author, level, reason))
event.msg.reply("Server verification level changed successfully")
else:
event.msg.reply("The server verification level is already set to {}".format(level))
else:
event.msg.reply("That level name doesn't seem to be valid")
def lift_lockdown(self, event, channels):
event.msg.delete()
for name, channelID in self.config.channels_to_lockdown.items():
# unlock the channel if listed or when unlocking everything
if name in channels or channels == "all":
log_to_bot_log(self.bot, ":unlock: The "+name+" channel has been unlocked by "+str(event.msg.author)+".")
# grab the first (bug hunter or test role) for the queue, grab everyone (or whatever test role is there) for public channels
rolename = "bug_hunter" if name == "bug" else "everyone"
role = event.guild.roles[self.config.role_IDs_to_lockdown[rolename]]
channel = event.guild.channels[channelID]
channel.create_overwrite(role, allow=2048 if name == "bug" else 0, deny=64)
# clean up lockdown message, scan last 5 messages just in case
limit = 5
count = 0
for message in channel.messages_iter(chunk_size=limit):
if message.author.id == self.bot.client.api.users_me_get().id:
message.delete()
count = count + 1
if count >= limit:
break
event.msg.reply("Unlock command has successfully completed!")
def guide_send(self, event):
randnum = random.random()
time.sleep(30)
if randnum <= self.experiments["dm-guide-on-join"]:
try:
channel = event.member.user.open_dm()
Pages.create_new(self.bot,
"guide",
channel,
page=1,
guide="guide",
is_join_dm=True)
log_to_bot_log(
self.bot,
":green_book: Guide was successfully sent to {user}.".
format(user=str(event.member)))
except:
log_to_bot_log(
self.bot,
":no_entry_sign: {user} has DMs disabled, so the guide wasn't sent to them."
.format(user=str(event.member)))
def make_employee(self, event, new_employee):
if any(role == 197042389569765376 for role in event.member.roles):
if new_employee.startswith("<@"):
id = new_employee[2:-1]
elif new_employee.startswith("<@!"):
id = new_employee[3:-1]
else:
id = new_employee
try:
id = int(id)
except Exception:
event.msg.reply("Unable to parse that as mention or ID")
else:
if id in event.guild.members.keys():
self.bot.client.api.guilds_members_roles_add(event.guild.id, id, 197042389569765376)
event.msg.reply("Role added")
else:
event.msg.reply("Unable to find that person")
else:
event.msg.reply(":lock: You do not have permission to use this command!")
log_to_bot_log(self.bot, f":warning: {str(event.msg.author)} tried to use a command they do not have permission to use.")
def make_role_temporarily_pingable(self, event, args):
args.desired_role_to_ping = args.desired_role_to_ping.lower()
if args.desired_role_to_ping not in self.config.role_IDs.keys():
event.msg.reply(f"Sorry but I can't find a role called `{args.desired_role_to_ping}`. Please check the name and try again.")
return
#Variables
Role_as_an_int = self.config.role_IDs[args.desired_role_to_ping]
Is_Role_Mentionable = event.guild.roles.get(Role_as_an_int).mentionable
Role_To_Make_Mentionable = event.guild.roles.get(Role_as_an_int)
if Is_Role_Mentionable:
Role_To_Make_Mentionable.update(mentionable=False)
event.msg.reply(f"The `{args.desired_role_to_ping}` role has been successfully set to unmentionable!")
log_to_bot_log(self.bot, f":exclamation: `{args.desired_role_to_ping}` was successfully set to unpingable.")
return
else:
Role_To_Make_Mentionable.update(mentionable=True)
event.msg.reply(f"The `{args.desired_role_to_ping}` role has been successfully set to mentionable! _PLEASE_ do not forget to use this command again after you've made your announcement to make it unmentionable!")
log_to_bot_log(self.bot, f":exclamation: `{args.desired_role_to_ping}` is now pingable!")
return
