async def textmute(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if not pld.msg.author.permissions_in(pld.msg.channel).manage_messages:
response = denied('Access Denied. Manage Messages needed.')
else:
if not pld.msg.mentions:
response = error('No user targeted.')
else:
author = pld.msg.author
target = pld.msg.mentions[0]
if author.id == target.id:
response = error('Can\'t mute yourself.')
elif cmd.bot.user.id == target.id:
response = error('I can\'t mute myself.')
else:
above_hier = hierarchy_permit(author, target)
if not above_hier:
response = denied('Can\'t mute someone equal or above you.')
else:
timed = pld.args[-1].startswith('--time=')
try:
now = arrow.utcnow().timestamp
endstamp = now + convert_to_seconds(pld.args[-1].split('=')[-1]) if timed else None
except (LookupError, ValueError):
err_response = error('Please use the format HH:MM:SS.')
await pld.msg.channel.send(embed=err_response)
return
mute_list = pld.settings.get('muted_users')
if mute_list is None:
mute_list = []
if target.id in mute_list:
response = error(f'{target.display_name} is already text muted.')
else:
mute_list.append(target.id)
await cmd.db.set_guild_settings(pld.msg.guild.id, 'muted_users', mute_list)
response = ok(f'{target.display_name} has been text muted.')
rarg = pld.args[1:-1] if timed else pld.args[1:] if pld.args[1:] else None
reason = ' '.join(rarg) if rarg else None
await make_incident(cmd.db, pld.msg.guild, pld.msg.author, target, reason)
log_embed = generate_log_embed(pld.msg, target, reason)
await log_event(cmd.bot, pld.settings, log_embed, 'log_mutes')
guild_icon = str(pld.msg.guild.icon_url) if pld.msg.guild.icon_url else discord.Embed.Empty
to_target_title = '🔇 You have been text muted.'
to_target = discord.Embed(color=0x696969)
to_target.add_field(name=to_target_title, value=f'Reason: {reason}')
to_target.set_footer(text=f'On: {pld.msg.guild.name}', icon_url=guild_icon)
try:
await target.send(embed=to_target)
except discord.Forbidden:
pass
if endstamp:
doc_data = {'server_id': pld.msg.guild.id, 'user_id': target.id, 'time': endstamp}
await cmd.db[cmd.db.db_nam].TextmuteClockworkDocs.insert_one(doc_data)
await pld.msg.channel.send(embed=response)
async def voicekick(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).kick_members:
target = get_broad_target(pld)
if target:
if cmd.bot.user.id != target.id:
if pld.msg.author.id != target.id:
above_hier = hierarchy_permit(pld.msg.author, target)
is_admin = pld.msg.author.permissions_in(
pld.msg.channel).administrator
if above_hier or is_admin:
above_me = hierarchy_permit(pld.msg.guild.me, target)
if above_me:
if target.voice:
tvc = target.voice.channel
tempvc = discord.utils.find(
lambda x: x.name == 'Kick Hall',
pld.msg.guild.channels)
if not tempvc:
tempvc = await pld.msg.guild.create_voice_channel(
'Kick Hall')
await target.move_to(tempvc)
await tempvc.delete()
remove_title = f'👢 {target.name} has been removed from {tvc.name}.'
response = discord.Embed(color=0xc1694f,
title=remove_title)
else:
response = error(
f'{target.name} is not in a voice channel.'
)
else:
response = denied(
'Target is above my highest role.')
else:
response = denied(
'Can\'t kick someone equal or above you.')
else:
response = error('You can\'t kick yourself.')
else:
response = error('I can\'t kick myself.')
else:
response = error('No user targeted.')
else:
response = denied('Access Denied. Kick permissions needed.')
await pld.msg.channel.send(embed=response)
async def prefix(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
current_prefix = cmd.db.get_prefix(pld.settings)
if pld.args:
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
new_prefix = ''.join(pld.args)
if new_prefix != current_prefix:
prefix_text = new_prefix
if new_prefix == cmd.bot.cfg.pref.prefix:
new_prefix = None
prefix_text = cmd.bot.cfg.pref.prefix
await cmd.db.set_guild_settings(pld.msg.guild.id, 'prefix', new_prefix)
response = ok(f'**{prefix_text}** has been set as the new prefix.')
else:
response = error('The current prefix and the new one are the same.')
else:
response = denied('Access Denied. Manage Server needed.')
else:
response = info(f'**{current_prefix}** is the current prefix.')
await pld.msg.channel.send(embed=response)
async def byemessage(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
if pld.args:
goodbye_text = ' '.join(pld.args)
await cmd.db.set_guild_settings(pld.msg.guild.id, 'bye_message',
goodbye_text)
response = ok('New Goodbye Message set.')
else:
current_goodbye = pld.settings.get('bye_message')
if not current_goodbye:
current_goodbye = '{user_name} has left {server_name}.'
bye_embed = pld.settings.get('bye_embed') or {}
if bye_embed.get('active'):
response = await make_bye_embed(bye_embed, current_goodbye,
pld.msg.guild)
else:
response = info('Current Goodbye Message')
response.description = current_goodbye
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def removeinactivewarning(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author == pld.msg.guild.owner:
if pld.msg.mentions:
if len(pld.args) == 2:
target = pld.msg.mentions[0]
warn_id = pld.args[1].lower()
lookup = {
'guild': pld.msg.guild.id,
'target.id': target.id,
'warning.id': warn_id,
'warning.active': False
}
warn_data = await cmd.db[cmd.db.db_nam
].Warnings.find_one(lookup)
if warn_data:
warn_iden = warn_data.get('warning').get('id')
await cmd.db[cmd.db.db_nam].Warnings.delete_one(lookup)
response = ok(f'Warning {warn_iden} deleted.')
else:
response = not_found('Inactive warning not found.')
else:
response = error('Both user tag and warning ID are needed.')
else:
response = error('No user targeted.')
else:
response = denied('Access Denied. Server Owner needed.')
await pld.msg.channel.send(embed=response)
async def greetdmmessage(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
if pld.args:
greeting_text = ' '.join(pld.args)
await cmd.db.set_guild_settings(pld.msg.guild.id, 'greet_dm_message', greeting_text)
response = ok('New DM Greeting Message set.')
else:
current_greeting = pld.settings.get('greet_dm_message')
if not current_greeting:
current_greeting = 'Hello {user_mention}, welcome to {server_name}.'
greet_embed = pld.settings.get('greet_dm_embed') or {}
if greet_embed.get('active'):
response = await make_greet_embed(greet_embed, current_greeting, pld.msg.guild)
else:
response = info('Current DM Greeting Message')
response.description = current_greeting
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def logsettings(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
settings = []
for log_key in log_keys:
if log_key == 'log_modules':
enabled = pld.settings.get('logged_modules')
else:
enabled = pld.settings.get(log_key)
channel_id = pld.settings.get(f'{log_key}_channel')
channel = await cmd.bot.get_channel(channel_id)
chn = channel.name if channel else 'Not Set'
state = 'Enabled' if enabled else 'Disabled'
log_line = [log_key[4:].title(), chn, state]
settings.append(log_line)
headers = ['Type', 'Channel', 'State']
output = boop(settings, column_names=headers)
response = discord.Embed(color=0xC1694F)
enabled_count = len([opt for opt in settings if opt[2] == 'Enabled'])
details = f'```py\n{enabled_count} out of {len(log_keys)} logs enabled.\n```'
response.add_field(name='📋 Log settings',
value=details,
inline=False)
response.add_field(name='📄 Details',
value=f'```\n{output}\n```',
inline=False)
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def massban(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).ban_members:
if pld.msg.mentions:
results = get_members(cmd, pld.msg, pld.msg.mentions)
if isinstance(results, list):
init_response = discord.Embed(color=0x696969, title='🔨 Removing members...')
init_message = await pld.msg.channel.send(embed=init_response)
buffer = list(re.finditer(r'<@!?\d+>', pld.msg.content))[-1].span()[1]
reason = pld.msg.content[buffer:].strip() or 'No reason stated.'
await ban_members(cmd, pld, results, reason)
user = '******' if len(pld.msg.mentions) > 1 else 'user has'
response = discord.Embed(color=0x696969, title=f'🔨 {len(results)} {user} been banned.')
await init_message.edit(embed=response)
return
else:
response = discord.Embed(color=0xBE1931, title=results)
else:
response = error('No user targeted.')
else:
response = denied('Access Denied. Kick permissions needed.')
await pld.msg.channel.send(embed=response)
async def editincident(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_messages:
icore = get_incident_core(cmd.db)
if len(pld.args) >= 2:
lookup = pld.args[0]
reason = ' '.join(pld.args[1:])
incident = await icore.get_by_token(pld.msg.guild.id, lookup)
if incident:
if not len(reason) > 1000:
incident.edit(pld.msg.author, reason)
await icore.save(incident)
response = ok(f'Incident {incident.id} updated.')
else:
response = error(
'Reasons have a limit of 1000 characters.')
else:
response = error('No incident with that ID was found.')
else:
response = error('Invalid number of arguments.')
else:
response = denied('Access Denied. Manage Messages needed.')
await pld.msg.channel.send(embed=response)
async def removereaction(_cmd, pld):
"""
:param _cmd: The command object referenced in the command.
:type _cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_messages:
if len(pld.args) == 2:
mid, emote = pld.args
if mid.isdigit():
message = await message_search(mid, pld.msg)
if message:
if pld.msg.guild.me.permissions_in(message.channel).manage_messages:
removed = await remove_emote(message, emote)
if removed:
response = ok('Reaction removed.')
else:
response = not_found('Emote not found on that message.')
else:
response = error('I can\'t remove reactions in that channel.')
else:
response = not_found('Message not found.')
else:
response = error('Invalid message ID.')
else:
response = error('Invalid number of arguments.')
else:
response = denied('Access Denied. Manage Messages needed.')
await pld.msg.channel.send(embed=response)
async def addselfrole(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.guild_permissions.manage_roles:
if pld.args:
lookup = ' '.join(pld.args)
target_role = discord.utils.find(lambda x: x.name.lower() == lookup.lower(), pld.msg.guild.roles)
if target_role:
role_below = bool(target_role.position < pld.msg.guild.me.top_role.position)
if role_below:
selfroles = pld.settings.get('self_roles', [])
if target_role.id in selfroles:
response = error('This role is already self assignable.')
else:
selfroles.append(target_role.id)
await cmd.db.set_guild_settings(pld.msg.guild.id, 'self_roles', selfroles)
response = ok(f'{target_role.name} added.')
else:
response = error('This role is above my highest role.')
else:
response = not_found(f'I can\'t find {lookup} on this server.')
else:
response = error('Nothing inputted.')
else:
response = denied('Access Denied. Manage Roles needed.')
await pld.msg.channel.send(embed=response)
async def logmodule(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.guild_permissions.manage_guild:
if pld.args:
module_name = pld.args[0].lower()
if module_name in cmd.bot.modules.categories:
logged_modules = pld.settings.get('logged_modules') or []
if module_name in logged_modules:
result = 'disabled'
logged_modules.remove(module_name)
else:
result = 'enabled'
logged_modules.append(module_name)
await cmd.db.set_guild_settings(pld.msg.guild.id,
'logged_modules',
logged_modules)
response = ok(f'{module_name.upper()} logging {result}.')
else:
response = not_found('Module not found.')
else:
response = error('No module given.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def autoroletimeout(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
if pld.args:
try:
timeout = abs(int(pld.args[0]))
except ValueError:
timeout = None
if timeout is not None:
await cmd.db.set_guild_settings(pld.msg.guild.id,
'auto_role_timeout', timeout)
response = ok(f'Timeout set to {timeout} seconds.')
else:
response = error('This role is above my highest role.')
else:
timeout = pld.settings.get('auto_role_timeout', 0)
response = discord.Embed(
color=0x696969,
title=f'🕙 The current timeout is {timeout} seconds.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def boundinvites(_cmd, pld):
"""
:param _cmd: The command object referenced in the command.
:type _cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.guild_permissions.create_instant_invite:
bound_invites = pld.settings.get('bound_invites')
if bound_invites:
output_lines = []
output_role_data = []
for key in bound_invites:
role_id = bound_invites.get(key)
target_role = pld.msg.guild.get_role(role_id)
if target_role:
role_name = target_role.name
else:
role_name = '{Role Missing}'
output_role_data.append([key, role_name])
output_role_data = sorted(output_role_data, key=lambda x: x[1])
for key, role_name in output_role_data:
out_line = f'`{key}`: {role_name}'
output_lines.append(out_line)
response = discord.Embed(color=0xF9F9F9, title='⛓ List of Bound Invites')
response.description = '\n'.join(output_lines)
else:
response = not_found('No invites have been bound.')
else:
response = denied('Access Denied. Create Instant Invites needed.')
await pld.msg.channel.send(embed=response)
async def shadowpollinvisible(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.args:
poll_id = pld.args[0].lower()
poll_file = await cmd.db[cmd.db.db_nam].ShadowPolls.find_one({'id': poll_id})
if poll_file:
author = poll_file['origin']['author']
if author == pld.msg.author.id:
visible = poll_file['settings']['visible']
if visible:
poll_file['settings'].update({'visible': False})
await cmd.db[cmd.db.db_nam].ShadowPolls.update_one({'id': poll_id}, {'$set': poll_file})
response = discord.Embed(color=0x161616, title=f'🕶 Poll {poll_file["id"]} is now invisible.')
else:
response = error(f'Poll {poll_file["id"]} is already invisible.')
else:
response = denied('You didn\'t make this poll.')
else:
response = not_found('Poll not found.')
else:
response = error('Missing poll ID.')
await pld.msg.channel.send(embed=response)
async def shadowpollexpires(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.args:
if len(pld.args) == 2:
poll_id = pld.args[0].lower()
time_input = pld.args[1]
try:
exp_in = convert_to_seconds(time_input)
poll_file = await cmd.db[cmd.db.db_nam].ShadowPolls.find_one({'id': poll_id})
if poll_file:
if poll_file['origin']['author'] == pld.msg.author.id:
end_stamp = arrow.utcnow().float_timestamp + exp_in
end_human = arrow.get(end_stamp).humanize()
end_datet = arrow.get(end_stamp).datetime
poll_file['settings'].update({'expires': end_stamp})
poll_coll = cmd.db[cmd.db.db_nam].ShadowPolls
await poll_coll.update_one({'id': poll_id}, {'$set': poll_file})
title = f'⏰ Poll set to expire {end_human}.'
response = discord.Embed(color=0xff3333, title=title, timestamp=end_datet)
else:
response = denied('You didn\'t make this poll.')
else:
response = not_found('Poll not found.')
except (LookupError, ValueError):
response = error('Please use the format HH:MM:SS.')
else:
response = error('Missing arguments.')
else:
response = error('Missing poll ID and expiration time.')
await pld.msg.channel.send(embed=response)
async def wfnewschannel(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_channels:
if pld.msg.channel_mentions:
target_channel = pld.msg.channel_mentions[0]
else:
if pld.args:
if pld.args[0].lower() == 'disable':
await cmd.db.set_guild_settings(pld.msg.guild.id,
'warframe_news_channel',
None)
response = ok('Warframe News Channel disabled.')
await pld.msg.channel.send(embed=response)
return
else:
target_channel = pld.msg.channel
await cmd.db.set_guild_settings(pld.msg.guild.id,
'warframe_news_channel',
target_channel.id)
response = ok(f'Warframe News Channel set to #{target_channel.name}')
else:
response = denied('Access Denied. Manage Channels needed.')
await pld.msg.channel.send(embed=response)
async def blockwords(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
if pld.args:
blocked_words = pld.settings.get('blocked_words', [])
added_words = []
for word in pld.args:
if word.lower() not in blocked_words:
blocked_words.append(word.lower())
added_words.append(word.lower())
await cmd.db.set_guild_settings(pld.msg.guild.id, 'blocked_words',
blocked_words)
if added_words:
response = ok(
f'I have added {len(added_words)} words to the blacklist.')
else:
response = info('No new words were added.')
else:
response = error('Nothing inputted.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def starboardemote(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
starboard_doc = pld.settings.get('starboard') or {}
if pld.args:
new_emote = pld.args[0][0]
if category(new_emote) == 'So':
starboard_doc.update({'emote': new_emote})
await cmd.db.set_guild_settings(pld.msg.guild.id, 'starboard', starboard_doc)
response = ok(f'Starboard emote set to {new_emote}')
else:
response = error('Emote must be native to Discord.')
else:
emote = starboard_doc.get('emote')
if emote:
response = discord.Embed(color=0xFFAC33, title=f'🌟 The current emote is {emote}')
else:
response = error('An emote has not been set.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def unban(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).ban_members:
if pld.args:
lookup = ' '.join(pld.args)
target = None
banlist = await pld.msg.guild.bans()
for entry in banlist:
if entry.user.name.lower() == lookup.lower():
target = entry.user
break
if target:
await pld.msg.guild.unban(
target,
reason=
f'By {pld.msg.author.name}#{pld.msg.author.discriminator}.'
)
log_embed = generate_log_embed(pld.msg, target)
await log_event(cmd.bot, pld.settings, log_embed, 'log_bans')
response = ok(f'{target.name} has been unbanned.')
else:
response = discord.Embed(
title=f'🔍 {lookup} not found in the ban list.')
else:
response = error('Nothing inputted.')
else:
response = denied('Access Denied. Ban permissions needed.')
await pld.msg.channel.send(embed=response)
async def unbindinvite(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.guild_permissions.create_instant_invite:
if pld.args:
invite_id = pld.args[0]
forced = pld.args[-1] == ':f'
invites = await pld.msg.guild.invites()
target_inv = discord.utils.find(lambda inv: inv.id.lower() == invite_id.lower(), invites)
if target_inv or forced:
if forced:
inv_id = invite_id
else:
inv_id = target_inv.id
bindings = pld.settings.get('bound_invites')
if bindings is None:
bindings = {}
if inv_id in bindings:
bindings.pop(inv_id)
await cmd.db.set_guild_settings(pld.msg.guild.id, 'bound_invites', bindings)
response = ok(f'Invite {inv_id} has been unbound.')
else:
response = error(f'Invite {inv_id} not bound.')
else:
response = error('No invite with that ID was found.')
else:
response = error('Not enough arguments. Invite and role name needed.')
else:
response = denied('Access Denied. Create Instant Invites needed.')
await pld.msg.channel.send(embed=response)
async def unhardblockwords(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
if pld.args:
blocked_words = pld.settings.get('hardblocked_words')
if blocked_words is None:
blocked_words = []
removed_words = []
if pld.args[-1].lower() == '--all':
removed_words = blocked_words
blocked_words = []
else:
for word in pld.args:
if word.lower() in blocked_words:
blocked_words.remove(word.lower())
removed_words.append(word.lower())
await cmd.db.set_guild_settings(pld.msg.guild.id,
'hardblocked_words', blocked_words)
if removed_words:
response = ok(
f'I have removed {len(removed_words)} words from the heavy blacklist.'
)
else:
response = info('No words were removed.')
else:
response = error('Nothing inputted.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def addreactor(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
if len(pld.args) >= 2:
trigger = ' '.join(pld.args[:-1]).lower().strip()
if len(trigger) <= 200:
if '.' not in trigger:
reaction = pld.args[-1].strip('<> ')
auto_reactions = pld.settings.get('reactor_triggers', {})
res_text = 'updated' if trigger in auto_reactions else 'added'
auto_reactions.update({trigger: reaction})
await cmd.db.set_guild_settings(pld.msg.guild.id,
'reactor_triggers',
auto_reactions)
response = ok(f'{trigger} has been {res_text}')
else:
response = error('The trigger can\'t have a dot in it.')
else:
response = error('The trigger has a limit of 200 characters.')
else:
response = error('Invalid number of arguments.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def greetdmembed(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
greet_embed = pld.settings.get('greet_dm_embed') or {}
embed_data = {
'active': greet_embed.get('active'),
'color': greet_embed.get('color'),
'thumbnail': greet_embed.get('thumbnail'),
'image': greet_embed.get('image')
}
if pld.args:
queries = ' '.join(pld.args).split()
qrys = [(f, d, v)
for f, d, v in [qry.partition(':') for qry in queries]]
fields = ['color', 'thumbnail', 'image']
results = []
for qry in qrys:
if qry[1]:
field, value = qry[0].lower(), qry[2]
if field in fields:
if value.lower() == 'remove':
embed_data.update({field: None})
res = 'Removed'
elif check_field(field, value):
if field == 'color':
value = int(value, 16)
embed_data.update({field: value})
res = 'Set'
else:
res = 'Invalid Value'
else:
res = 'Invalid Field'
res_line = f'{field.title()}: {res}'
results.append(res_line)
else:
response = error(
'Separate fields and values with a colon.')
await pld.msg.channel.send(embed=response)
return
await cmd.db.set_guild_settings(pld.msg.guild.id, 'greet_dm_embed',
embed_data)
response = ok('DM Greeting Embed updated.')
response.description = '\n'.join(results)
else:
if greet_embed.get('active'):
state, ender = False, 'disabled'
else:
state, ender = True, 'enabled'
embed_data.update({'active': state})
await cmd.db.set_guild_settings(pld.msg.guild.id, 'greet_dm_embed',
embed_data)
response = ok(f'DM Greeting Embed {ender}.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def collectiontrigger(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
jar_doc = pld.settings.get('collection_jar') or {}
if pld.args:
if len(pld.args) == 1:
trigger = pld.args[0].lower()
jar_doc.update({'trigger': trigger})
await cmd.db.set_guild_settings(pld.msg.guild.id,
'collection_jar', jar_doc)
response = ok(f'Collection Jar trigger set to `{trigger}`.')
else:
response = error('Trigger can\'t be more than one word.')
else:
trigger = jar_doc.get('trigger')
if trigger:
response = discord.Embed(
color=0xbdddf4,
title=f'💬 The current trigger is `{trigger}`.')
else:
response = error('A trigger has not been set.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def starboardlimit(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
starboard_doc = pld.settings.get('starboard') or {}
if pld.args:
try:
new_limit = abs(int(pld.args[0]))
except ValueError:
new_limit = None
if new_limit is not None:
starboard_doc.update({'limit': int(new_limit)})
await cmd.db.set_guild_settings(pld.msg.guild.id, 'starboard', starboard_doc)
response = ok(f'Starboard limit set to {new_limit}.')
else:
response = error('Limit must be a number.')
else:
limit = starboard_doc.get('limit')
if limit:
response = discord.Embed(color=0xFFAC33, title=f'🌟 The current limit is {limit}')
else:
response = error('A limit has not been set.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def unblocknames(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
if pld.args:
blocked_names = pld.settings.get('blocked_names') or []
removed_names = []
if pld.args[-1].lower() == '--all':
removed_names = blocked_names
blocked_names = []
else:
for name in pld.args:
if name.lower() in blocked_names:
blocked_names.remove(name.lower())
removed_names.append(name.lower())
await cmd.db.set_guild_settings(pld.msg.guild.id, 'blocked_names', blocked_names)
if removed_names:
ender = 's' if len(removed_names) > 1 else ''
response = ok(f'I have removed {len(removed_names)} name{ender} from the blacklist.')
else:
response = info('No name were removed.')
else:
response = error('Nothing inputted.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def filterignore(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).manage_guild:
if pld.args:
if len(pld.args) >= 3:
filter_name = pld.args[1].lower()
target_type = get_target_type(pld.args[0].lower())
if target_type:
if filter_name in filter_names:
targets, valid = get_targets(pld.msg, pld.args, target_type)
if valid:
overrides = pld.settings.get('filter_overrides') or {}
override_data = overrides.get(filter_name)
if not override_data:
override_data = {'users': [], 'channels': [], 'roles': []}
override = override_data.get(target_type) or []
error_response = None
for target in targets:
if target.id not in override:
override.append(target.id)
else:
error_response = error(f'{target.name} already has an override for that filter.')
break
if not error_response:
override_data.update({target_type: override})
overrides.update({filter_name: override_data})
await cmd.db.set_guild_settings(pld.msg.guild.id, 'filter_overrides', overrides)
if len(targets) > 1:
starter = f'{len(targets)} {target_type}'
response = ok(f'{starter} are no longer affected by `blocked{filter_name}`.')
else:
pnd = '#' if target_type == 'channels' else ''
starter = f'{pnd}{targets[0].name}'
response = ok(f'{starter} is no longer affected by `blocked{filter_name}`.')
else:
await pld.msg.channel.send(embed=error_response)
return
else:
if targets:
response = not_found(f'{targets} not found.')
else:
ender = 'specified' if target_type == 'roles' else 'targeted'
response = not_found(f'No {target_type} {ender}.')
else:
response = error('Invalid filter.')
else:
response = error('Invalid target type.')
else:
response = error('Not enough arguments.')
else:
response = error('Nothing inputted.')
else:
response = denied('Access Denied. Manage Server needed.')
await pld.msg.channel.send(embed=response)
async def kick(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author.permissions_in(pld.msg.channel).kick_members:
target = get_broad_target(pld)
if target:
if cmd.bot.user.id != target.id:
if pld.msg.author.id != target.id:
above_hier = hierarchy_permit(pld.msg.author, target)
is_admin = pld.msg.author.permissions_in(pld.msg.channel).administrator
if above_hier or is_admin:
above_me = hierarchy_permit(pld.msg.guild.me, target)
if above_me:
reason = ' '.join(pld.args[1:]) if pld.args[1:] else None
response = discord.Embed(color=0xc1694f, title='👢 The user has been removed.')
response_title = f'{target.name}#{target.discriminator}'
response.set_author(name=response_title, icon_url=user_avatar(target))
to_target = discord.Embed(color=0xc1694f)
to_target.add_field(name='👢 You have been kicked.', value=f'Reason: {reason}')
guild_icon = str(pld.msg.guild.icon_url) if pld.msg.guild.icon_url else discord.Embed.Empty
to_target.set_footer(text=f'From: {pld.msg.guild.name}.', icon_url=guild_icon)
try:
await target.send(embed=to_target)
except discord.Forbidden:
pass
author = f'{pld.msg.author.name}#{pld.msg.author.discriminator}'
await target.kick(reason=f'By {author}: {reason}')
log_embed = generate_log_embed(pld.msg, target, reason)
await log_event(cmd.bot, pld.settings, log_embed, 'log_kicks')
else:
response = denied('Target is above my highest role.')
else:
response = denied('Can\'t kick someone equal or above you.')
else:
response = error('You can\'t kick yourself.')
else:
response = error('I can\'t kick myself.')
else:
response = error('No user targeted.')
else:
response = denied('Access Denied. Kick permissions needed.')
await pld.msg.channel.send(embed=response)
async def viewinactivewarning(cmd, pld):
"""
:param cmd: The command object referenced in the command.
:type cmd: sigma.core.mechanics.command.SigmaCommand
:param pld: The payload with execution data and details.
:type pld: sigma.core.mechanics.payload.CommandPayload
"""
if pld.msg.author == pld.msg.guild.owner:
if pld.msg.mentions:
if len(pld.args) == 2:
target = pld.msg.mentions[0]
warn_id = pld.args[1].lower()
lookup = {
'guild': pld.msg.guild.id,
'target.id': target.id,
'warning.id': warn_id,
'warning.active': False
}
warn_data = await cmd.db[cmd.db.db_nam
].Warnings.find_one(lookup)
if warn_data:
author = await cmd.bot.get_user(
warn_data.get('moderator').get('id'))
if author:
author_descrp = f'{author.mention}\n{author.name}#{author.discriminator}'
else:
wmod = warn_data.get('moderator')
author_descrp = f'<@{wmod.get("id")}>\n{wmod.get("name")}#{wmod.get("discriminator")}'
target_avatar = user_avatar(target)
target_descrp = f'{target.mention}\n{target.name}#{target.discriminator}'
response = discord.Embed(color=0xFFCC4D,
timestamp=arrow.utcnow().datetime)
response.set_author(
name=f'Warning {warn_id} information | Inactive',
icon_url=target_avatar)
response.add_field(name='âš Warned User',
value=target_descrp)
response.add_field(name='🛡 Moderator',
value=author_descrp)
response.add_field(
name='📄 Reason',
value=warn_data.get('warning').get('reason'),
inline=False)
response.set_footer(
text=
f'[{warn_data.get("warning").get("id")}] user_id: {target.id}'
)
else:
response = not_found(
f'{target.name} has no {warn_id} warning.')
else:
response = error('Both user tag and warning ID are needed.')
else:
response = error('No user targeted.')
else:
response = denied('Access Denied. Server Owner needed.')
await pld.msg.channel.send(embed=response)
