async def view(self, CommandArgs):
"""view your server settings"""
guild = CommandArgs.guild
guild_data = CommandArgs.guild_data
response = CommandArgs.response
trello_board = CommandArgs.trello_board
prefix = CommandArgs.prefix
embed = Embed(title="Bloxlink Settings")
text_buffer = []
options_trello_data = {}
donator_profile, _ = await get_features(Object(id=guild.owner_id),
guild=guild)
premium = donator_profile.features.get("premium")
if premium:
text_buffer.append(
"**This is a [Premium Server](https://www.patreon.com/join/bloxlink?)**\n"
)
embed.colour = GOLD_COLOR
if trello_board:
options_trello_data, _ = await get_options(trello_board)
guild_data.update(options_trello_data)
for option_name, option_data in OPTIONS.items():
value = None
if option_data[0]:
value = str(option_data[0](guild, guild_data)) # pylint: disable=not-callable
else:
try:
value = str(
guild_data.get(option_name,
DEFAULTS.get(option_name, "False")))
except KeyError:
value = str(
guild_data.get(option_name,
DEFAULTS.get(option_name, "False")))
if option_data[3] and not premium:
value = str(DEFAULTS.get(option_name, "False"))
value = value.replace("{prefix}", prefix)
text_buffer.append(f"**{option_name}** {ARROW} {value}")
embed.description = "\n".join(text_buffer)
embed.set_footer(text="Powered by Bloxlink",
icon_url=Bloxlink.user.avatar.url)
embed.set_author(name=guild.name,
icon_url=guild.icon.url if guild.icon else "")
await response.send(embed=embed)
async def __main__(self, CommandArgs):
response = CommandArgs.response
author = CommandArgs.author
guild = CommandArgs.guild
guild_data = CommandArgs.guild_data
toggle = not guild_data.get("dynamicRoles",
DEFAULTS.get("dynamicRoles"))
guild_data["dynamicRoles"] = toggle
await self.r.table("guilds").insert(guild_data,
conflict="update").run()
if toggle:
await post_event(
guild, guild_data, "configuration",
f"{author.mention} ({author.id}) has **enabled** `dynamicRoles`.",
BROWN_COLOR)
await response.success("Successfully **enabled** Dynamic Roles!")
else:
await post_event(
guild, guild_data, "configuration",
f"{author.mention} ({author.id}) has **disabled** `dynamicRoles`.",
BROWN_COLOR)
await response.success("Successfully **disabled** Dynamic Roles!")
async def unverified(self, CommandArgs):
"""set the DM message of people who are UNVERIFIED on Bloxlink"""
author = CommandArgs.author
guild = CommandArgs.guild
unverified_DM = await get_guild_value(
guild,
["unverifiedDM", DEFAULTS.get("unverifiedDM")])
response = CommandArgs.response
if unverified_DM:
response.delete(await response.send(
"When people join your server and are **UNVERIFIED** on Bloxlink, they will "
f"receive this DM:"))
response.delete(await response.send(f"```{unverified_DM}```"))
parsed_args_1 = (await CommandArgs.prompt([{
"prompt":
"Would you like to **change** the DM people get when they join and are unverified, or "
"would you like to **disable** this feature?\n\nPlease specify: (change, disable)",
"name":
"option",
"type":
"choice",
"choices": ("change", "disable")
}]))["option"]
if parsed_args_1 == "change":
parsed_args_2 = (await CommandArgs.prompt([{
"prompt":
"What would you like the text of the Unverified Join DM to be? You may use "
f"these templates: ```{UNVERIFIED_TEMPLATES}```",
"name":
"text",
"formatting":
False
}],
last=True))["text"]
await set_guild_value(guild, unverifiedDM=parsed_args_2)
elif parsed_args_1 == "disable":
await set_guild_value(guild, unverifiedDM=None)
await post_event(
guild, "configuration",
f"{author.mention} ({author.id}) has **changed** the `joinDM` option for `unverified` members.",
BROWN_COLOR)
raise Message(f"Successfully **{parsed_args_1}d** your DM message.",
type="success")
async def __main__(self, CommandArgs):
response = CommandArgs.response
author = CommandArgs.author
guild = CommandArgs.guild
toggle = not (await get_guild_value(guild, "dynamicRoles") or DEFAULTS.get("dynamicRoles"))
await set_guild_value(guild, dynamicRoles=toggle)
if toggle:
await post_event(guild, "configuration", f"{author.mention} ({author.id}) has **enabled** `dynamicRoles`.", BROWN_COLOR)
await response.success("Successfully **enabled** Dynamic Roles!")
else:
await post_event(guild, "configuration", f"{author.mention} ({author.id}) has **disabled** `dynamicRoles`.", BROWN_COLOR)
await response.success("Successfully **disabled** Dynamic Roles!")
async def verified(self, CommandArgs):
"""set the DM message of people who are VERIFIED on Bloxlink"""
guild_data = CommandArgs.guild_data
verifiedDM = guild_data.get("verifiedDM", DEFAULTS.get("welcomeMessage"))
author = CommandArgs.author
guild = CommandArgs.guild
response = CommandArgs.response
if verifiedDM:
response.delete(await response.send("When people join your server and are **VERIFIED** on Bloxlink, they will "
f"receive this DM:"))
response.delete(await response.send(f"```{verifiedDM}```"))
parsed_args_1 = (await CommandArgs.prompt([{
"prompt": "Would you like to **change** the DM people get when they join and are verified, or "
"would you like to **disable** this feature?\n\nPlease specify: (change, disable)",
"name": "option",
"type": "choice",
"choices": ("change", "disable")
}]))["option"]
if parsed_args_1 == "change":
parsed_args_2 = (await CommandArgs.prompt([{
"prompt": "What would you like the text of the Verified Join DM to be? You may use "
f"these templates: ```{NICKNAME_TEMPLATES}```",
"name": "text",
"formatting": False
}], last=True))["text"]
guild_data["verifiedDM"] = parsed_args_2
await set_guild_value(guild, "verifiedDM", parsed_args_2)
await self.r.table("guilds").insert(guild_data, conflict="update").run()
elif parsed_args_1 == "disable":
guild_data["verifiedDM"] = None
await set_guild_value(guild, "verifiedDM", None)
await self.r.table("guilds").insert(guild_data, conflict="replace").run()
await post_event(guild, guild_data, "configuration", f"{author.mention} ({author.id}) has **changed** the `joinDM` option for `verified` members.", BROWN_COLOR)
raise Message(f"Successfully **{parsed_args_1}d** your DM message.", type="success")
def __init__(self, verify_button_text=None, intro_message=None):
super().__init__(timeout=None)
if intro_message != DEFAULTS.get("verifyChannelTextModal"):
self.add_item(item=discord.ui.Button(label="The text above was set by the Server Admins. ONLY verify from https://blox.link.",
disabled=True,
custom_id="verify_view:warning_button",
row=0))
verify_button = discord.ui.Button(label=verify_button_text,
emoji="<:chain:970894927196209223>",
style=discord.ButtonStyle.green,
custom_id="verify_view:verify_button",
row=1)
verify_button.callback = self.verify_button_click
self.add_item(item=verify_button)
self.add_item(item=discord.ui.Button(style=discord.ButtonStyle.link, label="Need help?", emoji="❔",
url="https://www.youtube.com/playlist?list=PLz7SOP-guESE1V6ywCCLc1IQWiLURSvBE", row=1))
class VerifyChannelModal(discord.ui.Modal, title="Verification Channel"):
verify_button_text = discord.ui.TextInput(
label="What text do you want for your Verify button?",
default="Verify with Bloxlink",
max_length=80)
bloxlink_post = discord.ui.TextInput(
label="What would you like Bloxlink to write?",
default=DEFAULTS.get("verifyChannelTextModal"),
style=discord.TextStyle.paragraph,
max_length=2000)
def __init__(self, verify_channel, *args, **kwargs):
self.verify_channel = verify_channel
super().__init__(*args, **kwargs)
async def on_submit(self, interaction: discord.Interaction):
guild = interaction.guild
try:
await self.verify_channel.send(
str(self.bloxlink_post).replace("{server-name}", guild.name),
view=VerificationView(self.verify_button_text.value,
self.bloxlink_post.value))
except discord.errors.Forbidden:
await interaction.response.send_message(
"I was unable to post in your verification channel. Please make sure I have the correct permissions."
)
else:
await interaction.response.send_message(
f"Your new verification channel has been created! {self.verify_channel.mention}"
)
for child in self.children:
if child.custom_id == "verify_channel_modal:welcome_message":
guild_welcome_message = await get_guild_value(
guild, "welcomeMessage")
if child.value != guild_welcome_message:
await set_guild_value(guild,
welcomeMessage=child.value)
break
async def restore(self, CommandArgs):
"""restore your Server Data"""
message = CommandArgs.message
author = CommandArgs.message.author
guild = CommandArgs.message.guild
response = CommandArgs.response
prefix = CommandArgs.prefix
if author.id == OWNER:
if message.attachments:
attachment = message.attachments[0]
if not attachment.height:
file_data = await attachment.read()
json_data = file_data.decode("utf8").replace("'", '"')
json_data = json.loads(json_data)
json_data["id"] = str(guild.id)
if json_data.get("roleBinds"):
role_map = {}
for bind_type, bind_data in json_data.get("roleBinds", {}).items():
if bind_type == "groups":
for group_id, group_data in bind_data.items():
for rank, rank_data in group_data.get("binds", {}).items():
for role_id in rank_data.get("roles", []):
if not guild.get_role(int(role_id)):
role_map_find = role_map.get(role_id)
if not role_map_find:
role = await guild.create_role(name=rank*6)
role_map[role_id] = str(role.id)
role_map_find = str(role.id)
json_data["roleBinds"]["groups"][group_id]["binds"][rank]["roles"].remove(role_id)
json_data["roleBinds"]["groups"][group_id]["binds"][rank]["roles"].append(role_map_find)
await self.r.table("guilds").insert(json_data, conflict="replace").run()
return await response.success("Successfully **restored** this server's data.")
else:
raise Error("You must supply a non-image file for data restore.")
user_data = await self.r.db("bloxlink").table("users").get(str(author.id)).run() or {}
user_backups = user_data.get("backups", [])
if not user_backups:
raise Message(f"You don't have any backups created! You may create them with ``{prefix}data backup``.", type="silly")
embed = Embed(title="Bloxlink Data Restore", description="Please select the backup you could like to restore with the reactions.")
for i, backup in enumerate(user_backups):
guild_data = backup["data"]
backup_name = backup["backupName"]
timestamp = datetime.datetime.fromtimestamp(backup["timestamp"])
trello_board = await get_board(guild_data=guild_data, guild=guild)
prefix, _ = await get_prefix(guild=guild, trello_board=trello_board)
backup["prefix"] = prefix
backup["trello_board"] = trello_board,
backup["timestamp"] = timestamp
backup["nickname_template"] = guild_data.get("nicknameTemplate", DEFAULTS.get("nicknameTemplate"))
if trello_board:
trello_options, _ = await get_options(trello_board)
guild_data.update(trello_options)
len_role_binds = count_binds(guild_data)
backup["len_role_binds"] = len_role_binds
embed.add_field(name=f"{INT_REACTIONS[i]} {ARROW} {backup_name}", value="\n".join([
f"**Role Binds** {ARROW} {len_role_binds}",
f"**Prefix** {ARROW} {prefix}",
f"**Nickname Template** {ARROW} {backup['nickname_template']}",
f"**Created on ** {timestamp.strftime('%b. %d, %Y (%A)')}"
]))
message = await response.send(embed=embed)
if message:
response.delete(message)
for i, _ in enumerate(user_backups):
emote_string = INT_REACTIONS[i]
try:
await message.add_reaction(emote_string)
except Forbidden:
raise PermissionError("I'm missing permission to add reactions to your message!")
try:
reaction, _ = await Bloxlink.wait_for("reaction_add", timeout=PROMPT["PROMPT_TIMEOUT"], check=self._reaction_check(author))
except TimeoutError:
raise CancelledPrompt(f"timeout ({PROMPT['PROMPT_TIMEOUT']}s)")
else:
chosen_backup = None
str_reaction = str(reaction)
for i, reaction_string in enumerate(INT_REACTIONS):
if str_reaction == reaction_string:
chosen_backup = user_backups[i]
if chosen_backup:
parsed_args = await CommandArgs.prompt([
{
"prompt": "**Warning!** This will **__restore__ ALL OF YOUR SETTINGS** including:\n"
f"**{chosen_backup['len_role_binds']}** Role Binds\n"
f"**{chosen_backup['prefix']}** prefix\n"
f"**{chosen_backup['nickname_template']}** Nickname Template\n"
"Continue? ``Y/N``",
"name": "confirm",
"type": "choice",
"formatting": False,
"choices": ("yes", "no"),
"embed_title": "Warning!",
"embed_color": ORANGE_COLOR,
"footer": "Say **yes** to continue, or **no** to cancel."
}
])
if parsed_args["confirm"] == "yes":
await self._restore(guild, chosen_backup)
await response.success("Successfully **restored** your backup!")
else:
raise CancelledPrompt("cancelled restore")
async def __main__(self, CommandArgs):
author = CommandArgs.author
response = CommandArgs.response
prefix = CommandArgs.prefix
if not SELF_HOST:
author_data = await self.r.db("bloxlink").table("users").get(str(author.id)).run() or {"id": str(author.id)}
try:
primary_account, accounts = await get_user("username", author=author, everything=False, basic_details=True)
if accounts:
parsed_accounts = await parse_accounts(accounts)
parsed_accounts_str = ", ".join(parsed_accounts.keys())
parsed_args = await CommandArgs.prompt([
{
"prompt": "This command will allow you to switch into an account you verified as in the past.\n"
f"If you would like to link __a new account__, then please use `{prefix}verify add`.\n\n"
"**__WARNING:__** This will remove __all of your roles__ in the server and give you "
"new roles depending on the server configuration.",
"footer": "Say **next** to continue.",
"type": "choice",
"choices": ["next"],
"name": "_",
"formatting": False
},
{
"prompt": "Are you trying to change your account for _this_ server? If so, simply say `next`.\nIf not, please provide "
"the __Server ID__ of the server to switch as. Please see this article to find the Server ID: "
"[click here](https://support.discordapp.com/hc/en-us/articles/206346498-Where-can-I-find-my-User-Server-Message-ID->).",
"name": "guild",
"validation": self.validate_server,
},
{
"prompt": "We'll switch your account for the server **{guild.name}**.\n"
"Please select an account to switch into:```" + parsed_accounts_str + "```",
"name": "account",
"type": "choice",
"choices": parsed_accounts.keys()
},
{
"prompt": "Would you like to make this your __primary__ account? Please say **yes** or **no**.",
"name": "primary",
"type": "choice",
"choices": ("yes", "no")
}
], last=True)
guild = parsed_args["guild"]
username = parsed_args["account"]
roblox_id = (parsed_accounts.get(username)).id
guild_data = await self.r.table("guilds").get(str(guild.id)).run() or {"id": str(guild.id)}
trello_board = await get_board(guild_data=guild_data, guild=guild)
if trello_board:
options_trello, _ = await get_options(trello_board)
guild_data.update(options_trello)
allow_reverify = guild_data.get("allowReVerify", DEFAULTS.get("allowReVerify"))
roblox_accounts = author_data.get("robloxAccounts", {})
if guild and not allow_reverify:
guild_accounts = roblox_accounts.get("guilds", {})
chosen_account = guild_accounts.get(str(guild.id))
if chosen_account and chosen_account != roblox_id:
raise Error("You already selected your account for this server. `allowReVerify` must be "
"enabled for you to change it.")
try:
member = await guild.fetch_member(author.id)
except (Forbidden, NotFound):
await verify_member(author, roblox_id, guild=guild, author_data=author_data, allow_reverify=allow_reverify, primary_account=parsed_args["primary"] == "yes")
raise Message("You're not a member of the provided server, so I was only able to update your account internally.", type="success")
try:
username = await verify_as(
member,
guild,
response = response,
primary = parsed_args["primary"] == "yes",
roblox_id = roblox_id,
trello_board = trello_board,
update_user = False)
except Message as e:
if e.type == "error":
await response.error(e)
else:
await response.send(e)
except Error as e:
await response.error(e)
else:
role_binds, group_ids, _ = await get_binds(guild_data=guild_data, trello_board=trello_board)
if count_binds(guild_data, role_binds=role_binds, group_ids=group_ids) and not find(lambda r: r.name == "Bloxlink Bypass", member.roles):
for role in list(member.roles):
if role != guild.default_role and role.name != "Muted":
try:
await member.remove_roles(role, reason="Switched User")
except Forbidden:
pass
try:
added, removed, nickname, errors, roblox_user = await update_member(
member,
guild = guild,
roles = True,
nickname = True,
response = response,
cache = False)
except BloxlinkBypass:
await response.info("Since you have the `Bloxlink Bypass` role, I was unable to update your roles/nickname; however, your account was still changed.")
return
except Blacklisted as b:
if str(b):
raise Error(f"{author.mention} has an active restriction for: `{b}`.")
else:
raise Error(f"{author.mention} has an active restriction from Bloxlink.")
else:
welcome_message = guild_data.get("welcomeMessage") or DEFAULTS.get("welcomeMessage")
welcome_message = await get_nickname(author, welcome_message, guild_data=guild_data, roblox_user=roblox_user, is_nickname=False)
await post_event(guild, guild_data, "verification", f"{author.mention} ({author.id}) has **switched their user** to `{username}`.", GREEN_COLOR)
await CommandArgs.response.send(welcome_message)
else:
raise Message(f"You only have one account linked! Please use `{prefix}verify add` to add another.", type="silly")
except UserNotVerified:
raise Error(f"You're not linked to Bloxlink. Please use `{prefix}verify add`.")
else:
raise Message(f"{author.mention}, to verify with Bloxlink, please visit our website at " \
f"<{VERIFY_URL}>. It won't take long!\nStuck? See this video: <https://www.youtube.com/watch?v=hq496NmQ9GU>")
async def change(self, CommandArgs):
"""change your Bloxlink settings"""
if not CommandArgs.has_permission:
raise PermissionError("You do not have the required permissions to change server settings.")
prefix = CommandArgs.prefix
response = CommandArgs.response
message = CommandArgs.message
author = CommandArgs.message.author
guild = CommandArgs.message.guild
guild_data = CommandArgs.guild_data
parsed_args = await CommandArgs.prompt([{
"prompt": "What value would you like to change? Note that some settings you can't change "
"from this command due to the extra complexity, but I will tell you the "
f"appropriate command to use.\n\nOptions: ``{options_strings}``\n\nPremium-only options: ``{premium_options_strings}``",
"name": "choice",
"type": "choice",
"formatting": False,
"footer": f"Use ``{prefix}settings help`` to view a description of all choices.",
"choices": options_combined
}])
choice = parsed_args["choice"]
if choice == "trelloID":
raise Message(f"You can link your Trello board from ``{prefix}setup``!", type="success")
elif choice == "Linked Groups":
raise Message(f"You can link your group from ``{prefix}bind``!", type="success")
elif choice == "joinDM":
message.content = f"{prefix}joindm"
return await parse_message(message)
elif choice == "groupShoutChannel":
message.content = f"{prefix}shoutproxy"
return await parse_message(message)
elif choice == "whiteLabel":
message.content = f"{prefix}whitelabel"
return await parse_message(message)
option_find = OPTIONS.get(choice)
if option_find:
if option_find[3]:
profile, _ = await get_features(Object(id=guild.owner_id), guild=guild)
if not profile.features.get("premium"):
raise Error("This option is premium-only! The server owner must have premium for it to be changed.\n"
f"Use ``{prefix}donate`` for more instructions on getting premium.")
option_type = option_find[1]
trello_board = CommandArgs.trello_board
card = success_text = parsed_value = None
desc = option_find[4].format(prefix=CommandArgs.prefix, templates=NICKNAME_TEMPLATES)
if trello_board:
options_trello_data, trello_binds_list = await get_options(trello_board, return_cards=True)
options_trello_find = options_trello_data.get(choice)
if options_trello_find:
card = options_trello_find[1]
if option_type == "boolean":
parsed_value = await CommandArgs.prompt([{
"prompt": f"Would you like to **enable** or **disable** ``{choice}``?\n\n"
f"**Option description:**\n{desc}",
"name": "choice",
"type": "choice",
"footer": "Say **clear** to set as the default value.",
"formatting": False,
"choices": ("enable", "disable", "clear")
}])
parsed_bool_choice = parsed_value["choice"]
if parsed_bool_choice == "clear":
parsed_value = DEFAULTS.get(choice)
else:
parsed_value = parsed_bool_choice == "enable"
await self.r.table("guilds").insert({
"id": str(guild.id),
choice: parsed_value
}, conflict="update").run()
success_text = f"Successfully **{parsed_bool_choice}d** ``{choice}``!"
elif option_type == "string":
parsed_value = (await CommandArgs.prompt([{
"prompt": f"Please specify a new value for ``{choice}``.\n\n"
f"**Option description:**\n{desc}",
"name": "choice",
"type": "string",
"footer": "Say **clear** to set as the default value.",
"formatting": False,
"max": option_find[2]
}]))["choice"]
if parsed_value == "clear":
parsed_value = DEFAULTS.get(choice)
await self.r.table("guilds").insert({
"id": str(guild.id),
choice: parsed_value
}, conflict="update").run()
success_text = f"Successfully saved your new {choice}!"
elif option_type == "role":
parsed_value = (await CommandArgs.prompt([{
"prompt": f"Please specify a role for ``{choice}``.\n\n"
f"**Option description:**\n{desc}",
"name": "role",
"type": "role",
"exceptions": ("clear",),
"footer": "Say **clear** to set as the default value.",
"formatting": False
}]))["role"]
if parsed_value == "clear":
parsed_value = DEFAULTS.get(choice)
else:
parsed_value = str(parsed_value.id)
await self.r.table("guilds").insert({
"id": str(guild.id),
choice: parsed_value
}, conflict="update").run()
success_text = f"Successfully saved your new ``{choice}``!"
elif option_type == "number":
parsed_value = (await CommandArgs.prompt([{
"prompt": f"Please specify a new integer for ``{choice}``.\n\n"
f"**Option description:**\n{desc}",
"name": "choice",
"type": "number",
"footer": "Say **clear** to set as the default value.",
"formatting": False,
"exceptions": ("clear",),
"max": option_find[2]
}]))["choice"]
if parsed_value == "clear":
parsed_value = DEFAULTS.get(choice)
await self.r.table("guilds").insert({
"id": str(guild.id),
choice: parsed_value
}, conflict="update").run()
success_text = f"Successfully saved your new ``{choice}``!"
elif option_type == "choice":
choices = ", ".join(option_find[2])
parsed_value = (await CommandArgs.prompt([{
"prompt": f"Please pick a new value for ``{choice}``: ``{choices}``\n\n"
f"**Option description:**\n{desc}",
"name": "choice",
"type": "choice",
"footer": "Say **clear** to set as the default value.",
"formatting": False,
"exceptions": ["clear"],
"choices": option_find[2]
}]))["choice"]
if parsed_value == "clear":
parsed_value = DEFAULTS.get(choice)
await self.r.table("guilds").insert({
"id": str(guild.id),
choice: parsed_value
}, conflict="update").run()
success_text = f"Successfully saved your new ``{choice}``!"
else:
raise Error("An unknown type was specified.")
else:
raise Error("An unknown option was specified.")
if trello_board:
try:
if card:
if card.name == choice:
await card.edit(desc=str(parsed_value))
else:
await card.edit(name=f"{choice}:{parsed_value}")
else:
trello_settings_list = await trello_board.get_list(lambda L: L.name == "Bloxlink Settings") \
or await trello_board.create_list(name="Bloxlink Settings")
await trello_settings_list.create_card(name=choice, desc=str(parsed_value))
if trello_binds_list:
await trello_binds_list.sync(card_limit=TRELLO["CARD_LIMIT"])
except TrelloUnauthorized:
await response.error("In order for me to edit your Trello settings, please add ``@bloxlink`` to your "
"Trello board.")
except (TrelloNotFound, TrelloBadRequest):
pass
await set_guild_value(guild, choice, parsed_value)
await post_event(guild, guild_data, "configuration", f"{author.mention} ({author.id}) has **changed** the ``{choice}`` option.", BROWN_COLOR)
raise Message(success_text, type="success")
async def __main__(self, CommandArgs):
response = CommandArgs.response
guild_data = CommandArgs.guild_data
prefix = CommandArgs.prefix
guild = CommandArgs.message.guild
try:
category = find(lambda c: c.name == "Verification", guild.categories) or \
await guild.create_category("Verification")
verify_info = find(lambda t: t.name == "verify-instructions", category.channels) or \
await guild.create_text_channel("verify-instructions", category=category)
verify_channel = find(lambda t: t.name == "verify", category.channels) or \
await guild.create_text_channel("verify", category=category)
sample_channel = await guild.create_text_channel("sample-channel")
except Forbidden:
raise PermissionError("I was unable to create the necessary channels. Please ensure I have the "
"``Manage Channels`` permission.")
except HTTPException:
raise Error("You have too many channels or categories! Please delete some before continuing.")
try:
await verify_info.send("This server uses Bloxlink to manage Roblox verification. In "
"order to unlock all the features of this server, you'll need "
"to verify your Roblox account with your Discord account!\n\nTo "
f"do this, run ``{prefix}verify`` in {verify_channel.mention} and follow the instructions.")
await sample_channel.send("This is a sample channel that only Verified users " \
"can read. This channel is not important, you may freely delete it.\n" \
"To create another sample channel, right click this channel and click 'Clone " \
"Text Channel', or just run this command again.")
except (Forbidden, NotFound):
raise PermissionError("I was unable to send messages to the created channels. Please give me the "
"proper permissions.")
try:
await verify_info.set_permissions(guild.me, send_messages=True, read_messages=True)
verified_role_name = guild_data.get("verifiedRoleName", DEFAULTS.get("verifiedRoleName"))
for role in guild.roles:
if role.name != guild.me.name:
await verify_info.set_permissions(role, send_messages=False, read_messages=True)
await verify_channel.set_permissions(role, send_messages=True, read_messages=True)
if role.name == verified_role_name:
for target, overwrite in sample_channel.overwrites.items():
await sample_channel.set_permissions(target, overwrite=None)
await sample_channel.set_permissions(guild.default_role, send_messages=False, read_messages=False)
await sample_channel.set_permissions(role, send_messages=True, read_messages=True)
except Forbidden:
raise PermissionError("Unable to set permissions to the channels. Please ensure I have the "
"``Manage Channels`` and ``Manage Roles`` permission.")
except NotFound:
raise Error("Please do not delete the created channels while I'm setting them up...")
await self.r.table("guilds").insert({
"id": str(guild.id),
"verifyChannel": str(verify_channel.id)
}, conflict="update").run()
await response.success(f"All done! Your new verification channel is {verify_channel.mention} and " \
"is now managed by Bloxlink.")
async def __main__(self, CommandArgs):
response = CommandArgs.response
guild = CommandArgs.guild
is_premium = "premium" in (await has_premium(guild=guild)).features
verify_category = discord.utils.find(
lambda c: c.name == "Verification",
guild.categories) or await guild.create_category(
name="Verification")
verify_channel = discord.utils.find(
lambda c: c.name == "verify",
guild.text_channels) or await guild.create_text_channel(
name="verify", category=verify_category)
await verify_channel.set_permissions(guild.me,
send_messages=True,
read_messages=True)
verify_instructions = discord.utils.find(
lambda c: c.name == "verify-instructions", guild.text_channels)
try:
if is_premium:
verify_instructions = verify_instructions or verify_channel
welcome_message = await get_guild_value(
guild, "welcomeMessage")
modal = VerifyChannelModal(verify_channel)
modal.add_item(item=discord.ui.TextInput(
label="Message after someone verifies",
default=welcome_message or DEFAULTS.get("welcomeMessage"),
style=discord.TextStyle.paragraph,
required=False,
max_length=2000,
custom_id="verify_channel_modal:welcome_message"))
await verify_instructions.set_permissions(guild.me,
send_messages=True,
read_messages=True)
await verify_instructions.set_permissions(guild.default_role,
send_messages=False,
read_messages=True)
await response.send_modal(modal)
await set_guild_value(guild, verifyChannel=None)
else:
await verify_channel.set_permissions(guild.default_role,
send_messages=True,
read_messages=True)
if not verify_instructions:
verify_instructions = await guild.create_text_channel(
name="verify-instructions", category=verify_category)
await verify_instructions.set_permissions(guild.default_role,
send_messages=False,
read_messages=True)
await verify_instructions.set_permissions(guild.me,
send_messages=True,
read_messages=True)
try:
await verify_instructions.move(before=verify_channel)
except ValueError:
pass
try:
await verify_instructions.send(
"This server uses Bloxlink to manage Roblox verification. To gain access to the rest of the server, you must verify with Bloxlink.\n"
f"To do so, simply say `/getrole` in {verify_channel.mention}.\n"
)
except discord.errors.Forbidden:
await response.send(
"I was unable to send the instructions to verify. Please make sure I have the correct permissions."
)
await response.send(
f"All done! Your new verification channel is {verify_channel.mention}.\n\n**Pro-tip:** Bloxlink Premium subscribers can "
"[add a verification button to their channel and can customize the text that Bloxlink posts!](<https://twitter.com/bloxlink/status/1521487474949857282>)\n"
f"Subscribe from our [Dashboard!](<https://blox.link/dashboard/guilds/{guild.id}/premium>)"
)
await set_guild_value(guild,
verifyChannel=str(verify_channel.id))
except discord.errors.Forbidden:
await response.send(
"I encountered a permission error. Please make sure I can create channels and set permissions."
)
