def invite_user_to_raid(channel, user):
"""Invites a user to the raid channel."""
global should_refresh_active_raids
# don't invite bots and webhooks
if user.bot:
return
# refresh active raids in future
should_refresh_active_raids = True
# adds an overwrite for the user
perms = discord.PermissionOverwrite(read_messages=True)
await client.edit_channel_permissions(channel, user, perms)
# invite user to role
role = get_raid_role(channel)
if role:
await client.add_roles(user, role)
# sends a message to the raid channel the user was added
await client.send_message(channel,
"{}, you are now a member of this raid group.".format(user.mention),
embed=get_success_embed('{} has joined the raid!'.format(user.display_name)))
python类PermissionOverwrite()的实例源码
def mute(self, ctx, *, user:discord.Member):
"""Mute un utilisateur
Requiert la permission de kick"""
await self.bot.delete_message(ctx.message)
if ctx.message.author.server_permissions.kick_members == True:
overwrite = ctx.message.channel.overwrites_for(user) or discord.PermissionOverwrite()
overwrite.send_messages = False
await self.bot.edit_channel_permissions(ctx.message.channel, user, overwrite)
tmp = await self.bot.send_message(ctx.message.channel, "{} is now muted here !".format(user.mention))
await asyncio.sleep(5)
await self.bot.delete_message(tmp)
else:
tmp = await self.bot.say("```\nVous n'avez pas la permission d'utiliser cette commande\n```")
await asyncio.sleep(5)
await self.bot.delete_message(tmp)
def unmute(self, ctx, *, user:discord.Member):
"""Unute un utilisateur
Requiert la permission de kick"""
await self.bot.delete_message(ctx.message)
if ctx.message.author.server_permissions.kick_members == True:
overwrite = ctx.message.channel.overwrites_for(user) or discord.PermissionOverwrite()
overwrite.send_messages = True
await self.bot.edit_channel_permissions(ctx.message.channel, user, overwrite)
tmp = await self.bot.send_message(ctx.message.channel, "{} is no longer muted here! He/she can speak now!".format(user.mention))
await asyncio.sleep(5)
await self.bot.delete_message(tmp)
else:
tmp = await self.bot.say("```\nVous n'avez pas la permission d'utiliser cette commande\n```")
await asyncio.sleep(5)
await self.bot.delete_message(tmp)
def mute(self, ctx, *, member: discord.Member):
"""Mute someone on voice and text chat.
Usage: mute [person's name]"""
or_check_perms(ctx, ['mute_members', 'manage_roles', 'manage_channels', 'manage_messages'])
status = await ctx.send('Muting... ??')
pg_task = self.loop.create_task(asyncio.wait_for(self.progress(status, 'Muting'), timeout=30, loop=self.loop))
try:
ch_perms = discord.PermissionOverwrite(**{p: False for p in muted_perms})
for channel in ctx.guild.channels:
await channel.set_permissions(member, ch_perms)
await member.__redit(mute=True, deafen=None, reason='Mute command was used on user')
pg_task.cancel()
await status.delete(reason='Deleting progress/status message')
await ctx.send('Successfully muted **%s**!' % str(member))
except (discord.Forbidden, discord.HTTPException):
pg_task.cancel()
await status.delete(reason='Deleting progress/status message')
await ctx.send('**I don\'t have enough permissions to do that!**')
def unmute(self, ctx, *, member: discord.Member):
"""Unmute someone on voice and text chat.
Usage: unmute [person's name]"""
or_check_perms(ctx, ('mute_members', 'manage_roles', 'manage_channels', 'manage_messages'))
status = await ctx.send('Unmuting... ??')
pg_task = self.loop.create_task(asyncio.wait_for(self.progress(status, 'Unmuting'), timeout=30, loop=self.loop))
role_map = {r.name: r for r in member.roles}
try:
if 'Muted' in role_map:
await member.remove_roles(role_map['Muted'], reason='Unmute command was used on user')
ch_perms = discord.PermissionOverwrite(**{p: None for p in muted_perms})
for channel in ctx.guild.channels:
await channel.set_permissions(member, ch_perms)
await member.__redit(mute=False, deafen=None, reason='Unmute command was used on user')
pg_task.cancel()
await status.delete(reason='Deleting progress/status message')
await ctx.send('Successfully unmuted **%s**!' % str(member))
except (discord.Forbidden, discord.HTTPException):
pg_task.cancel()
await status.delete(reason='Deleting progress/status message')
await ctx.send('**I don\'t have enough permissions to do that!**')
def create(self, ctx, *channel_name):
"""Create a new voice channel with Supervisor permission."""
guild = ctx.guild
channel_name = " ".join(channel_name)
for channel in guild.voice_channels:
if channel.name == channel_name:
await self.bot_reply(ctx, 'Channel **{}** already exists, {}'.format(channel_name, ctx.author.mention))
return False
supervisor_role = None
for role in guild.roles:
if role.name == 'Supervisors':
supervisor_role = role
break
if supervisor_role is None:
return False
perms = {
supervisor_role: discord.PermissionOverwrite(manage_roles=True)
}
await guild.create_voice_channel(channel_name, overwrites=perms)
def create(self, ctx, *channel_name):
"""Create a new text channel with Supervisor permission."""
guild = ctx.guild
channel_name = " ".join(channel_name)
for channel in guild.text_channels:
if channel.name == channel_name:
await self.bot_reply(ctx, 'Channel **{}** already exists, {}'.format(channel_name, ctx.author.mention))
return False
supervisor_role = None
for role in guild.roles:
if role.name == 'Supervisors':
supervisor_role = role
break
if supervisor_role is None:
return False
perms = {
guild.default_role: discord.PermissionOverwrite(read_messages=False),
supervisor_role: discord.PermissionOverwrite(read_messages=True, manage_roles=True)
}
await guild.create_text_channel(channel_name, overwrites=perms)
def make_private_room(race_private_info, discord_member):
# Define permissions
deny_read = discord.PermissionOverwrite(read_messages=False)
permit_read = discord.PermissionOverwrite(read_messages=True)
# Make a channel for the room
# noinspection PyUnresolvedReferences
race_channel = await server.client.create_channel(
server.server,
get_raceroom_name(race_private_info.race_info),
discord.ChannelPermissions(target=server.server.default_role, overwrite=deny_read),
discord.ChannelPermissions(target=server.server.me, overwrite=permit_read),
discord.ChannelPermissions(target=discord_member, overwrite=permit_read),
type=discord.ChannelType.text
)
if race_channel is not None:
new_room = PrivateRaceRoom(
race_discord_channel=race_channel,
race_private_info=race_private_info,
admin_as_member=discord_member)
await new_room.initialize()
Necrobot().register_bot_channel(race_channel, new_room)
return race_channel
def get_events_channel(self, guild):
"""Return the events channel if it exists, otherwise create one and return it"""
for channel in guild.channels:
if channel.name == "upcoming-events":
return channel
# Need to make sure the bot can still send messages in the events channel
overwrites = {
guild.default_role: discord.PermissionOverwrite(send_messages=False, add_reactions=True),
guild.me: discord.PermissionOverwrite(send_messages=True, add_reactions=True)
}
return await guild.create_text_channel("upcoming-events", overwrites=overwrites)
def on_member_join(self, member):
if (member.server.id in self.settings) and not ("bots" in member.server.name.lower()):
try:
temp = self.settings[member.server.id]['joined']
except KeyError:
self.settings[member.server.id]['joined'] = 0
try:
self.settings[member.server.id]['joined'] += 1
self.save_settings()
if self.settings[member.server.id]['members'] != 0:
if (self.settings[member.server.id]['joined'] >= self.settings[member.server.id]['members']) and not (self.settings[member.server.id]['protected']):
self.settings[member.server.id]['protected'] = True
self.save_settings()
for channel in member.server.channels:
if (channel.id == self.settings[member.server.id]['channel']) and (self.settings[member.server.id]['channel'] != None):
await self.bot.send_message(channel, "Raid protect has been turned on, more than {} people joined within 8 seconds.".format(self.settings[member.server.id]['members']))
await asyncio.sleep(8)
self.settings[member.server.id]['joined'] = 0
self.save_settings()
except KeyError:
pass
try:
if self.settings[member.server.id]['protected']:
for channel in member.server.channels:
if channel.id != self.settings[member.server.id]['channel']:
perms = discord.PermissionOverwrite()
perms.read_messages = False
perms.send_messages = False
await self.bot.edit_channel_permissions(channel, member, perms)
else:
await self.bot.send_message(channel, "{}, you have been muted in every channel because raidprotect is on, if you are not here to raid just wait patiently and your permissions will be restored.".format(member.mention))
except KeyError:
return
def mute(self, member, minutes:int):
for channel in member.server.channels:
perms = discord.PermissionOverwrite()
perms.send_messages = False
await self.bot.edit_channel_permissions(channel, member, perms)
await asyncio.sleep(minutes * 60)
for channel in member.server.channels:
perms = discord.PermissionOverwrite()
perms.send_messages = None
await self.bot.edit_channel_permissions(channel, member, perms)
def makestarboard(self, ctx):
'''
Make a channel that works with the starboard setup
'''
serverSettings = getServerJson(ctx.message.server.id)
serverSettings['Toggles']['Starboard'] = True
c = PermissionOverwrite(send_messages=False, add_reactions=False)
d = PermissionOverwrite(send_messages=True, add_reactions=True)
v = await self.sparcli.create_channel(ctx.message.server, 'starboard', (ctx.message.server.default_role, c), (ctx.message.server.me, d))
serverSettings['Channels']['Starboard'] = v.id
saveServerJson(ctx.message.server.id, serverSettings)
await self.sparcli.say('Done!')
def setup_channel(self, channel, role):
perms = discord.PermissionOverwrite()
if channel.type == discord.ChannelType.text:
perms.send_messages = False
perms.send_tts_messages = False
elif channel.type == discord.ChannelType.voice:
perms.speak = False
await self.bot.edit_channel_permissions(channel, role, overwrite=perms)
def suspend(message: discord.Message, channel: discord.Channel=Annotate.Self):
""" Suspends a channel by removing send permission for the server's default role.
This function acts like a toggle. """
send = channel.overwrites_for(message.server.default_role).send_messages
print(send, False if send is None else not send)
overwrite = discord.PermissionOverwrite(send_messages=False if send is None else not send)
await client.edit_channel_permissions(channel, message.server.default_role, overwrite)
try:
if overwrite.send_messages:
await client.say(message, "{} is no longer suspended.".format(channel.mention))
else:
await client.say(message, "Suspended {}.".format(channel.mention))
except discord.Forbidden: # ...
await client.send_message(message.author, "You just removed my send permission in {}.".format(channel.mention))
def mute(ctx, user, message):
"""
Command for muting users.
:param ctx:
:param user:
:param message:
:return:
"""
if user is None:
await ctx.send_message(message.channel, "**Error**: User not mentioned."
"\nUsage: `;;mute @user`")
return
overwrite = discord.PermissionOverwrite()
overwrite.send_messages = False
try:
# TODO maybe change this to use Roles instead?
for channel in message.server.channels:
await ctx.edit_channel_permissions(channel, user, overwrite)
await ctx.send_message(message.channel, "**Success**: `Muted {}`".format(user.name))
await ctx.send_message(user, "You are now muted in the server **{}**\n"
"For more details, talk to the Server Admins / Moderators\n\n"
"*I am a bot. Please don't reply to this message.*".format(message.server.name))
return
except Exception as e:
if error_messages.error_message(e, "mute"):
await ctx.send_message(message.channel, "**Error**: `{}`".format(error_messages.error_message(e, "mute")))
return
else:
print(e)
def propagateMute(self, ctx):
if self.bot.Henry(ctx):
for role in ctx.message.server.roles:
if role.id == '338575090847580160':
MUTED_ROLE = role
overwrite = discord.PermissionOverwrite()
setattr(overwrite, 'send_messages', False)
setattr(overwrite, 'manage_messages', False)
setattr(overwrite, 'manage_channels', False)
setattr(overwrite, 'manage_server', False)
setattr(overwrite, 'manage_nicknames', False)
setattr(overwrite, 'manage_roles', False)
for channel in ctx.message.server.channels:
if channel.id not in AVOID:
await self.bot.edit_channel_permissions(channel, MUTED_ROLE, overwrite)
# @commands.command(pass_context=True)
# async def lock(self, ctx):
# """Locks the current channel."""
# for role in ctx.message.server.roles:
# if role.id == '338575090847580160':
# MUTED_ROLE = role
# if role.id == '296466915235332106':
# BOTS_ROLE = role
# if self.minion(ctx):
# everyone = []
# for user in ctx.message.server.members:
# if ctx.message.channel.permissions_for(user).send_messages and BOTS_ROLE not in user.roles: #don't mute bots
# everyone.append(user)
# for user in everyone:
# await self.bot.add_roles(user, MUTED_ROLE)
# await self.bot.say("Locking Channel")
# else:
# await self.bot.say("You ain't no mod, shoo!")
def ch_perms(self, channel, user, value):
"""Helper function"""
overwrite = discord.PermissionOverwrite()
overwrite.send_messages = value
await self.bot.edit_channel_permissions(channel, user, overwrite)
def are_overwrites_empty(self, overwrites):
"""There is currently no cleaner way to check if a
PermissionOverwrite object is empty"""
original = [p for p in iter(overwrites)]
empty = [p for p in iter(discord.PermissionOverwrite())]
return original == empty
def mute(ctx, user, message):
"""
Command for muting users.
:param ctx:
:param user:
:param message:
:return:
"""
if user is None:
await ctx.send_message(message.channel, "**Error**: User not mentioned."
"\nUsage: `?mute @user`")
return
overwrite = discord.PermissionOverwrite()
overwrite.send_messages = False
try:
# TODO maybe change this to use Roles instead?
for channel in message.server.channels:
await ctx.edit_channel_permissions(channel, user, overwrite)
await ctx.send_message(message.channel, "**Success**: `Muted {}`".format(user.name))
await ctx.send_message(user, "You are now muted in the server **{}**\n"
"For more details, talk to the Server Admins / Moderators\n\n"
"*I am a bot. Please don't reply to this message.*".format(message.server.name))
return
except Exception as e:
if error_messages.error_message(e, "mute"):
await ctx.send_message(message.channel, "**Error**: `{}`".format(error_messages.error_message(e, "mute")))
return
else:
print(e)
def mutechannel(self, ctx):
perms = discord.PermissionOverwrite()
perms.send_messages = False
await self.bot.edit_channel_permissions(ctx.message.channel, ctx.message.server.default_role ,perms)
todelete = await self.bot.say("Done :+1:")
await asyncio.sleep(5)
await self.bot.delete_message(todelete)
def unmutechannel(self, ctx):
perms = discord.PermissionOverwrite()
perms.send_messages = True
await self.bot.edit_channel_permissions(ctx.message.channel, ctx.message.server.default_role ,perms)
todelete = await self.bot.say("Done :+1:")
await asyncio.sleep(5)
await self.bot.delete_message(todelete)
def muteperms(self, ctx):
"""Adds Muted permissions to channel used in"""
overwrite = discord.PermissionOverwrite()
overwrite.send_messages = False
overwrite.embed_links = False
overwrite.attach_files = False
overwrite.create_instant_invite = False
overwrite.manage_messages = False
overwrite.send_tts_messages = False
overwrite.mention_everyone = False
overwrite.speak = False
overwrite.use_voice_activation = False
await self.bot.edit_channel_permissions(ctx.message.channel, discord.utils.get(ctx.message.server.roles, name="Muted"), overwrite)
await self.bot.say("Set up Muted permissions for this channel")
def make_muted_perms(server, muted):
"""This adds muted perms to every channel, easier than getting admins to do it manually"""
overwrite = discord.PermissionOverwrite()
overwrite.send_messages = False
overwrite.embed_links = False
overwrite.attach_files = False
overwrite.create_instant_invite = False
overwrite.manage_messages = False
overwrite.send_tts_messages = False
overwrite.mention_everyone = False
overwrite.speak = False
overwrite.use_voice_activation = False
for channel in server.channels:
await bot.edit_channel_permissions(channel, muted, overwrite)
def cmd_slowmode(self, message, author, server, channel_id, time_between, reason=None):
"""
Usage: {command_prefix}slowmode #channel <time between messages> ["reason"]
Puts the channel mentioned into a slowmode where users can only send messages every x seconds.
To turn slow mode off, set the time between messages to "0"
"""
if await self.has_roles(message.channel, author, server, command='slowmode'):
if channel_id in self.server_index[message.server.id][12]:
raise CommandError('ERROR: Channel ID is ignored. Unignore the channel before setting to slow mode')
try:
time_between = int(time_between)
except:
raise CommandError('ERROR: The time limit between messages isn\'t a number, please specify a real number')
try:
if channel_id in self.slow_mode_dict.keys():
if time_between == 0:
await self.delete_role(server, self.slow_mode_dict[channel_id]['channel_muted_role'])
del self.slow_mode_dict[channel_id]
await self.safe_send_message(discord.Object(channel_id), 'This channel is no longer in slow mode!')
else:
self.slow_mode_dict[channel_id]['time_between'] = time_between
await self.safe_send_message(discord.Object(channel_id), 'The delay between allowed messages is now **%s seconds**!' % time_between)
else:
slowed_channel = discord.utils.get(server.channels, id=channel_id)
channel_muted_role = await self.create_role(server,
name=slowed_channel.name + 'SLOWROLE',
permissions=discord.Permissions(permissions=66560))
overwrite = discord.PermissionOverwrite()
overwrite.read_messages = True
overwrite.send_messages = False
await self.edit_channel_permissions(slowed_channel, channel_muted_role, overwrite)
await self.safe_send_message(discord.Object(channel_id), 'This channel is now in slow mode with a delay of **%s seconds**!' % time_between)
self.slow_mode_dict[channel_id] = {'time_between': time_between,
'channel_muted_role': channel_muted_role}
await self.write_to_modlog(message, author, server, reason)
except:
raise CommandError('ERROR: Please make sure the syntax is correct and resubmit the command!')
def mute(self, ctx, mem: str):
"""Mute a Member."""
member = getUser(ctx, mem)
if member:
if not utils.find(lambda r: "mute" in r.name.lower(), ctx.message.guild.roles):
if not utils.find(lambda r: "Muted" == r.name, ctx.message.guild.roles):
perms = utils.find(lambda r: "@everyone" == r.name, ctx.message.guild.roles).permissions
role = await ctx.guild.create_role(name="Muted", permissions=perms)
log.info('Created role: Muted')
for channel in ctx.guild.text_channels:
await channel.set_permissions(role, overwrite=discord.PermissionOverwrite(send_messages=False, add_reactions=False))
for channel in ctx.guild.voice_channels:
await channel.set_permissions(role, overwrite=discord.PermissionOverwrite(speak=False))
log.info('Prepared Mute role for mutes in channels')
role = utils.find(lambda r: "Muted" == r.name, ctx.message.guild.roles)
else:
role = utils.find(lambda r: "mute" in r.name.lower(), ctx.message.guild.roles)
if role not in member.roles:
roles = member.roles
roles.append(role)
asyncio.sleep(0.5)
await member.edit(roles=roles)
log.info(f'Muted {member}')
e = discord.Embed(color=embedColor(self))
e.set_author(name="\N{SPEAKER WITH CANCELLATION STROKE} Muted " + str(member))
await edit(ctx, embed=e)
else:
await edit(ctx, content="\N{HEAVY EXCLAMATION MARK SYMBOL} Already muted", ttl=5)
# Mute a Member
def are_overwrites_empty(self, overwrites):
"""There is currently no cleaner way to check if a
PermissionOverwrite object is empty"""
original = [p for p in iter(overwrites)]
empty = [p for p in iter(discord.PermissionOverwrite())]
return original == empty
def ne_process(self, ev: NecroEvent):
if ev.event_type == 'rtmp_name_change':
for row in await matchdb.get_channeled_matches_raw_data():
if int(row[2]) == ev.user.user_id or int(row[3]) == ev.user.user_id:
channel_id = int(row[13])
channel = server.find_channel(channel_id=channel_id)
if channel is not None:
read_perms = discord.PermissionOverwrite(read_messages=True)
await server.client.edit_channel_permissions(
channel=channel,
target=ev.user.member,
overwrite=read_perms
)
def allow(self, member_or_role):
read_permit = discord.PermissionOverwrite()
read_permit.read_messages = True
await self.client.edit_channel_permissions(self.channel, member_or_role, read_permit)
# Restrict the member from seeing the necrobot
def deny(self, member_or_role):
read_deny = discord.PermissionOverwrite()
read_deny.read_messages = False
await self.client.edit_channel_permissions(self.channel, member_or_role, read_deny)
# True if the user has admin permissions for this race
def mute(ctx, *, member : discord.Member):
if not ctx.message.author.server_permissions.mute_members:
return print(Fore.RED + "Command Failed To Execute |\n Command Ran In:[" + ctx.message.server.id + "]\n User:[" + ctx.message.author.id + "]\n Channel:[" + ctx.message.channel.id + "]\n Reason: " + Fore.YELLOW + "Insufficient Permissions! Both user and member need Mute Members permission!")
overwrite = discord.PermissionOverwrite()
overwrite.send_messages = False
await client.edit_channel_permissions(ctx.message.channel, member, overwrite)
await client.say("**%s** has been muted!"%member.mention)
print(Fore.CYAN + "Command Successfully Executed |\n Command Ran In:[" + ctx.message.server.id + "]\n User:[" + ctx.message.author.id + "]\n Channel:[" + ctx.message.channel.id + "]")
