async 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
async def createchannel(message: discord.Message, arguments: str):
global temp_channels
server = message.server
args = arguments.rsplit()
name = args[0]
everyone_perms = discord.PermissionOverwrite(read_messages=False)
member_perms = discord.PermissionOverwrite(read_messages=True,
manage_channels=True)
author_perms = discord.PermissionOverwrite(read_messages=True,
manage_channels=True,
manage_roles=True)
everyone = discord.ChannelPermissions(target=server.default_role,
overwrite=everyone_perms)
access = [
discord.ChannelPermissions(target=message.author,
overwrite=author_perms), everyone
]
for person in message.mentions:
access.append(
discord.ChannelPermissions(target=person,
overwrite=member_perms))
channel = await shinobu.create_channel(server, args[0], *access)
await shinobu.edit_channel(channel,
topic="What is this channel about?")
async 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 None:
return None
# Put the race channel in the races category
race_channel_category = server.find_channel(
channel_name=Config.RACE_CHANNEL_CATEGORY_NAME)
if race_channel_category is not None:
await discordutil.set_channel_category(channel=race_channel,
category=race_channel_category)
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
async def on_message(message):
try:
firehose = discord.utils.find(lambda m: m.name == "firehose",
message.server.channels)
except:
await trainsbot.send_message(message.channel, "Something went wrong")
if message.channel.name != "firehose":
unfdmsg = "{0.channel} **|** {0.author.display_name}: {0.content}"
await trainsbot.send_message(firehose, unfdmsg.format(message))
if message.content.startswith("!invite"):
try:
fmt2 = "landing-{0.author.id}"
everyone_perms = discord.PermissionOverwrite(read_messages=False)
mine_perms = discord.PermissionOverwrite(read_messages=True)
mine = discord.ChannelPermissions(target=message.server.me,
overwrite=mine_perms)
everyone = discord.ChannelPermissions(
target=message.server.default_role, overwrite=everyone_perms)
newchan = await trainsbot.create_channel(message.server,
fmt2.format(message),
everyone, mine)
invite = await trainsbot.create_invite(destination=newchan,
max_uses=1)
await trainsbot.send_message(
message.channel,
"Your invite is awaiting approval, thank you.")
adminchannel = discord.utils.find(lambda m: m.name == "admins",
message.server.channels)
fmt = "User {0.author} has requested an invite. Invite code: {1.code}"
await trainsbot.send_message(adminchannel,
fmt.format(message, invite))
except Exception as e:
print(e)
async def prepare(self):
self.player_role = await self.bot.create_role(self.server,
name="Mystery Player")
self.observer_role = await self.bot.create_role(
self.server, name="Mystery Observer")
self.dead_role = await self.bot.create_role(self.server,
name="Location")
everyone_perm = discord.ChannelPermissions(
target=self.server.default_role,
overwrite=discord.PermissionOverwrite(read_messages=False,
send_messages=False))
player_perm = discord.ChannelPermissions(
target=self.player_role,
overwrite=discord.PermissionOverwrite(read_messages=True,
send_messages=True))
observer_perm = discord.ChannelPermissions(
target=self.observer_role,
overwrite=discord.PermissionOverwrite(read_messages=True,
send_messages=False))
dead_perm = discord.ChannelPermissions(
target=self.dead_role,
overwrite=discord.PermissionOverwrite(read_messages=True,
send_messages=True))
self.channel = await self.bot.create_channel(
self.server, "%slobby" % (self.channel_prefix), everyone_perm,
player_perm, observer_perm, dead_perm)
await self.bot.edit_channel(self.channel, topic="Mystery game lobby.")
self.game_state = self.STATE_LOBBY
for location in self.locations:
await location.start()
async def create_private_channel(ctx, channel_name, *users: discord.User):
'''Create a private channel named name, and then add users.'''
#Initialize server as the server in which this command is being run from
server = ctx.message.server
#Ensure the channel has at least one user
if not users:
await client.say("Usage: create_private_channel <name> <users...>")
#Deny everyone read_messages permissions
#Grant Group read_messages permissions
everyone_perms = discord.PermissionOverwrite(read_messages=False)
group_perms = discord.PermissionOverwrite(read_messages=True)
#overwrite the channel default with deny everyone rule
everyone = discord.ChannelPermissions(target=server.default_role,
overwrite=everyone_perms)
#Make a group that includes the listed users and the bot- add this to the overwrite
group = []
group.append(
discord.ChannelPermissions(target=server.me, overwrite=group_perms))
for user in users:
group.append(
discord.ChannelPermissions(target=user, overwrite=group_perms))
#create the channel as a text channel with "everyone" and "group" overwrite permissions
await client.create_channel(server,
channel_name,
everyone,
*group,
type=discord.ChannelType.text)
await asyncio.sleep(3)
async def private(self, ctx, nom, perso):
if nom in self.pv_chan.values():
print("nom deja existant !")
else:
everyone_perms = discord.PermissionOverwrite(connect=False)
pv_perms = discord.PermissionOverwrite(connect=True)
everyone = discord.ChannelPermissions(
target=self.server.default_role, overwrite=everyone_perms)
pv = discord.ChannelPermissions(target=ctx.message.author,
overwrite=pv_perms)
self.pv_chan[nom] = await self.bot.create_channel(
self.server, nom, everyone, pv, type=discord.ChannelType.voice)
"""for player in perso:
test"""
print(perso)
embed = discord.Embed(title="Channeller priver",
description="Info",
color=0xff0000)
embed.set_thumbnail(url="https://i.imgur.com/F7M1e6s.png")
embed.add_field(
name="Priver",
value="Channel créé ! Déplacement automatique...",
inline=True)
await self.bot.say(embed=embed)
print("Channel " + str(nom) + " créé par: " +
str(ctx.message.author))
await self.bot.move_member(ctx.message.author, self.pv_chan[nom])
async def make_match_room(match: Match, register=False) -> MatchRoom or None:
"""Create a discord.Channel and a corresponding MatchRoom for the given Match.
Parameters
----------
match: Match
The Match to create a room for.
register: bool
If True, will register the Match in the database.
Returns
-------
Optional[MatchRoom]
The created room object.
"""
# Check to see the match is registered
if not match.is_registered:
if register:
await match.commit()
else:
console.warning('Tried to make a MatchRoom for an unregistered Match ({0}).'.format(match.matchroom_name))
return None
# Check to see if we already have the match channel
channel_id = match.channel_id
match_channel = server.find_channel(channel_id=channel_id) if channel_id is not None else None
# If we couldn't find the channel or it didn't exist, make a new one
if match_channel is None:
# Create permissions
deny_read = discord.PermissionOverwrite(read_messages=False)
permit_read = discord.PermissionOverwrite(read_messages=True)
racer_permissions = []
for racer in match.racers:
if racer.member is not None:
racer_permissions.append(discord.ChannelPermissions(target=racer.member, overwrite=permit_read))
# Make a channel for the room
# noinspection PyUnresolvedReferences
match_channel = await server.client.create_channel(
server.server,
get_matchroom_name(match),
discord.ChannelPermissions(target=server.server.default_role, overwrite=deny_read),
discord.ChannelPermissions(target=server.server.me, overwrite=permit_read),
*racer_permissions,
type=discord.ChannelType.text)
if match_channel is None:
console.warning('Failed to make a match channel.')
return None
# Make the actual RaceRoom and initialize it
match.set_channel_id(int(match_channel.id))
new_room = MatchRoom(match_discord_channel=match_channel, match=match)
Necrobot().register_bot_channel(match_channel, new_room)
await new_room.initialize()
return new_room
async def setup(ctx):
author = ctx.message.author
server = ctx.message.server
mod_perms = discord.Permissions(manage_messages=True,
kick_members=True,
manage_nicknames=True,
mute_members=True)
admin_perms = discord.Permissions(ADMINISTRATOR=True)
await client.create_role(author.server,
name="Owner",
permissions=admin_perms)
await client.create_role(author.server,
name="Admin",
permissions=admin_perms)
await client.create_role(author.server,
name="Senior Moderator",
permissions=mod_perms)
await client.create_role(author.server, name="G.O.H")
await client.create_role(author.server,
name="Moderator",
permissions=mod_perms)
await client.create_role(author.server, name="Muted")
await client.create_role(author.server, name="Friend of Owner")
await client.create_role(author.server, name="Verified")
everyone_perms = discord.PermissionOverwrite(send_messages=False,
read_messages=True)
everyone = discord.ChannelPermissions(target=server.default_role,
overwrite=everyone_perms)
user_perms = discord.PermissionOverwrite(read_messages=True)
user = discord.ChannelPermissions(target=server.default_role,
overwrite=user_perms)
private_perms = discord.PermissionOverwrite(read_messages=False)
private = discord.ChannelPermissions(target=server.default_role,
overwrite=private_perms)
await client.create_channel(server, '🎉welcome🎉', everyone)
await client.create_channel(server, '🎯rules🎯', everyone)
await client.create_channel(server, '🎥featured-content🎥', everyone)
await client.create_channel(server, '📢announcements📢', everyone)
await client.create_channel(server, '📢vote_polls📢', everyone)
await client.create_channel(server, 'private_chat', private)
await client.create_channel(server, '🎮general_chat🎮', user)
await client.create_channel(server, '🎮general_media🎮', user)
await client.create_channel(server, '👍bots_zone👍', user)
await client.create_channel(server, '🎥youtube_links🎥', user)
await client.create_channel(server, '🎥giveaway_links🎥', user)
await client.create_channel(server, '🎥other_links🎥', user)
await client.create_channel(server,
'🔥Music Zone🔥',
type=discord.ChannelType.voice)
await client.create_channel(server, '🔥music_command🔥s', user)
await client.create_channel(server,
'🔥Chill Zone🔥',
type=discord.ChannelType.voice)
async def addchannel(server, channel_name, channel_type_str):
if channel_type_str == 'text':
channel_type = discord.ChannelType.text
else:
channel_type = discord.ChannelType.voice
everyone_perms = discord.PermissionOverwrite(read_messages=False)
my_perms = discord.PermissionOverwrite(read_messages=True)
everyone = discord.ChannelPermissions(target=server.default_role, overwrite=everyone_perms)
mine = discord.ChannelPermissions(target=server.me, overwrite=my_perms)
await client.create_channel(server, channel_name, everyone, mine, type=channel_type)
async def claim(self, ctx):
server = ctx.message.server
claimer = ctx.message.author
ticket = ctx.message.content[14:]
if ticket == "":
await self.bot.say("Please input a ticket id")
return
with open("data/claimedticketids.json", "r") as f:
ticket_claims = json.load(f)
a = open("data/tickets.json").read()
tickets = json.loads(a)
if ticket not in ticket_claims:
await self.bot.say("No ticket with that ID was found")
return
if ticket_claims[ticket] != "not_claimed":
await self.bot.say("This ticket is already claimed.")
return
ticket_claims[ticket] = claimer.id
role = discord.utils.get(server.roles, name="Overseer")
user = await self.bot.get_user_info(
tickets[ticket]["ticket_data"][0][u'issuer_id'])
ticket_perms = discord.PermissionOverwrite(read_messages=True)
everyone_perms = discord.PermissionOverwrite(read_messages=False)
techlead = discord.ChannelPermissions(target=role,
overwrite=ticket_perms)
everyone = discord.ChannelPermissions(target=server.default_role,
overwrite=everyone_perms)
ticketuser = discord.ChannelPermissions(target=user,
overwrite=ticket_perms)
claimeruser = discord.ChannelPermissions(target=ctx.message.author,
overwrite=ticket_perms)
await self.bot.create_channel(server, "Ticket Nr. {}".format(ticket),
ticketuser, everyone, techlead,
claimeruser)
with open("data/claimedticketids.json", "w") as f:
json.dump(ticket_claims, f)
channel = discord.utils.get(ctx.message.server.channels,
name="tickets")
await self.bot.send_message(
channel, claimer.name + " has claimed the ticket nr. " + ticket)
await self.bot.say("You have claimed the ticket nr. " + ticket)
async def ticket(ctx,*, content):
everyone_perms = discord.PermissionOverwrite(read_messages=False)
my_perms = discord.PermissionOverwrite(read_messages=True)
everyone = discord.ChannelPermissions(target=ctx.message.server.default_role, overwrite=everyone_perms)
mine = discord.ChannelPermissions(ctx.message.author, overwrite=my_perms)
test = await bot.create_channel(ctx.message.server, 'ticket', everyone, mine)
await bot.delete_message(ctx.message)
await asyncio.sleep(2)
msg = 'Hello pls wait for staff to come'
for servers in bot.servers:
for channel in servers.channels:
if channel.name == 'ticket':
await bot.send_message(channel, msg)
async def c_initmod(self, message, args, cxt):
'''`j!initmod modchannel logchannel` - Initialize Moderator extension in this server'''
await self.is_admin(message.author.id)
if len(args) < 3:
await cxt.say(self.c_initmod.__doc__)
return
server = message.server
server_id = message.server.id
if server_id in self.moddb:
await cxt.say("Moderator is already running on in this server")
return
try:
mod_channel_name = args[1]
log_channel_name = args[2]
except:
await cxt.say("???")
return
# everyone can read, only jose can write
everyone_perms = discord.PermissionOverwrite(read_messages=True,
write_messages=False)
my_perms = discord.PermissionOverwrite(read_messages=True,
write_messages=True)
everyone = discord.ChannelPermissions(target=server.default_role,
overwrite=everyone_perms)
jose = discord.ChannelPermissions(target=server.me, overwrite=my_perms)
try:
mod_channel = await self.client.create_channel(server, \
mod_channel_name, everyone, jose)
log_channel = await self.client.create_channel(server, \
log_channel_name, everyone, jose)
except discord.Forbidden:
await cxt.say("hey I can't create channels give me permissions")
return
self.moddb[server_id] = {
'mod_channel': mod_channel.id,
'log_channel': log_channel.id,
'logs': {
'0': 'Genesis log'
},
}
return
async def handle_log_channel(self, server):
# Check if the channel already exists
if not [
ch for ch in server.channels
if ch.name == self.handler.get_var(server.id, "logchannel")
]:
if not self.handler.get_var(server.id, "logchannel"):
return None
# Creates permission overwrites: normal users cannot see the channel, only users with the role "Nano Admin" and the bot
them = discord.PermissionOverwrite(read_messages=False,
send_messages=False,
read_message_history=False)
us = discord.PermissionOverwrite(read_messages=True,
send_messages=True,
read_message_history=True,
attach_files=True,
embed_links=True,
manage_messages=True)
admins = discord.utils.find(lambda m: m.name == "Nano Admin",
server.roles)
if admins:
admin_perms = discord.ChannelPermissions(target=admins,
overwrite=us)
else:
admin_perms = None
them_perms = discord.ChannelPermissions(target=server.default_role,
overwrite=them)
nano_perms = discord.ChannelPermissions(target=server.me,
overwrite=us)
log_channel_name = self.handler.get_var(server.id, "logchannel")
if admins:
return await self.client.create_channel(
server, log_channel_name, admin_perms, them_perms,
nano_perms)
else:
return await self.client.create_channel(
server, log_channel_name, them_perms, nano_perms)
else:
return discord.utils.find(
lambda m: m.name == self.handler.get_var(
server.id, "logchannel"), server.channels)
async def AutoTempVoice(
self, before,
user): #Is called when Someone joins the voice channel - Listener
"""Automaticly checks the voice channel for users and makes a channel for them"""
# I cannot have any returns here so channels will be created
if before.voice_channel is not None:
# Did they come from a channel?
if before.voice_channel.id in self.check_empty:
#Was the channel they where in a tempary channel?
if len(before.voice_channel.voice_members) == 0:
# How many people are in the channel?
# if zero => empty. Therefore, remove the channel
await self.bot.delete_channel(
self.bot.get_channel(before.voice_channel.id))
self.check_empty.remove(before.voice_channel.id)
if user.voice_channel is None: # Are they in a channel right now?
return
if self.settings[user.voice_channel.server.id]['type'] != True:
return
try:
if self.settings[user.voice_channel.server.
id]['channel'] != user.voice_channel.id:
return
position = user.voice_channel.position
perms = discord.PermissionOverwrite(
mute_members=True, deafen_members=True,
manage_channels=True) #Sets permisions
perms = discord.ChannelPermissions(
target=user, overwrite=perms
) #Sets the channel permissions for the person who sent the message
channel = await self.bot.create_channel(
user.voice_channel.server,
user.name,
perms,
type=discord.ChannelType.voice) #creates a channel
self.check_empty.append(channel.id) #Multidimentional list
dataIO.save_json("data/Tasty/TempVoice/VoiceChannel.json",
self.check_empty) #saves the new file
await self.channel_to_category(
user.voice_channel.id,
channel.id) #puts channel into the right category
await self.bot.move_member(user, channel)
await self.bot.move_channel(channel, position + 1)
except discord.Forbidden:
await self.bot.send_message(
user.server.owner,
"I need the proper permissions! I was unable to create a new channel. (Move members, Manage channels)"
)
async def setupwelcome(ctx):
if ctx.message.author.bot:
return
else:
server = ctx.message.server
everyone_perms = discord.PermissionOverwrite(send_messages=False, read_messages=True)
everyone = discord.ChannelPermissions(target=server.default_role, overwrite=everyone_perms)
await client.create_channel(server, '🎉-welcome-🎊',everyone)
async def _make_hidden_channel(self, ctx, channel_name: str):
"""
隠れチャンネルを作成します。
使用例「!mkhidden new_channel_name」
"""
server = ctx.message.server
everyone_perm = discord.ChannelPermissions(target=server.default_role,
overwrite=HIDDEN_OVERWRITE)
await self.bot.create_channel(server, channel_name, everyone_perm)
async def voice(self, ctx, *, name: str = ''): #actual command
"""Creates a voice channel use opptional argument <name> to spesify the name of the channel, Use `" "` around the name of the channel"""
#Checks the mode (type = True (therefore mode = [1])
if self.settings[ctx.message.server.id]['type'] != False:
return
if name == '': #Tests if no name was passed
name = ctx.message.author.name #Sets it to the name of whoever sent the message
server_role = self.settings[ctx.message.server.id]['role']
if server_role is not None:
for role in set(ctx.message.author.roles):
if role.id == server_role:
break # If role is found
else: #If we didn't break out of the loop then the user does not have the right role
await self.bot.say(
"Sorry but you are not permited to use that command! A role is needed."
)
return # If role is found breaks loop - else statement isn't executed.
#If all the requirements are met
try:
perms = discord.PermissionOverwrite(
mute_members=True, deafen_members=True,
manage_channels=True) #Sets permisions
perms = discord.ChannelPermissions(
target=ctx.message.author, overwrite=perms
) #Sets the channel permissions for the person who sent the message
channel = await self.bot.create_channel(
ctx.message.server,
name,
perms,
type=discord.ChannelType.voice) #creates a channel
await self.move_channel_to_category(
channel.id, self.settings[channel.server.id]['category'])
self.check_empty.append(channel.id) #Multidimentional list
dataIO.save_json("data/Tasty/TempVoice/VoiceChannel.json",
self.check_empty) #saves the new file
return
except discord.Forbidden:
await self.bot.send_message(
ctx.message.channel,
"I don't have the right perrmissions for that! (I need to be able to manage channels)"
)
except Exception as e: # if something else happens such as it's not connected or a file has been messed with and so doesn't show an error in discord channel
print("=================")
print(e)
print("=================")
await self.bot.send_message(ctx.message.channel,
"An error occured - check logs")
async def summon(message, parsed_args):
"""Create a mirrored channel pair."""
private_channel_tuple = namedtuple("private_channel_pair",
["user_channel", "admin_channel"])
server = message.server
everyone_role = server.default_role
server_id = server.id
admin_role = servers[server_id]["admin_role"]
author = message.author
channel_name = f"{author.name}-Talking to admins"
channel_name_admin = channel_name + "-Admin only side"
denied_perms = discord.PermissionOverwrite(read_messages=False)
allowed_perms = discord.PermissionOverwrite(read_messages=True)
everyone = discord.ChannelPermissions(target=everyone_role,
overwrite=denied_perms)
admin = discord.ChannelPermissions(target=admin_role,
overwrite=allowed_perms)
admin_no = discord.ChannelPermissions(target=admin_role,
overwrite=denied_perms)
user = discord.ChannelPermissions(target=author, overwrite=allowed_perms)
bot_perms = discord.ChannelPermissions(target=bot.user,
overwrite=denied_perms)
new_user_channel = await bot.create_channel(server, channel_name, everyone,
admin_no, user, bot_perms)
new_admin_channel = await bot.create_channel(server, channel_name_admin,
everyone, admin, bot_perms)
new_channels = private_channel_tuple(new_user_channel, new_admin_channel)
servers[server_id]["created_channels"].append(new_channels)
await bot.delete_message(message)
user_message = f"{author.mention} you can talk to the admins here."
admin_message = (f"{author.mention} has opened a private channel with the "
"admins")
await bot.send_message(new_user_channel, user_message)
await bot.send_message(new_admin_channel, admin_message)
return True
async def setw(ctx):
if ctx.message.author.bot:
return
if ctx.message.author.server_permissions.administrator == False:
await client.say('**You do not have permission to use this command**')
return
else:
server = ctx.message.server
everyone_perms = discord.PermissionOverwrite(send_messages=False,
read_messages=True)
everyone = discord.ChannelPermissions(target=server.default_role,
overwrite=everyone_perms)
await client.create_channel(server, 'server-welcome', everyone)
async def on_ready():
print('Logged in as')
print(client.user.name)
print(client.user.id)
print('------')
discord_handles = get_privileges_handles_from_api()
for server in client.servers:
role = discord.utils.get(server.roles, name=our_role_name)
if not role:
print('Creating role {0} in {1}'.format(our_role_name, server))
role = await client.create_role(server, name=our_role_name)
else:
print('Role {0} found at {1}'.format(our_role_name, server))
channel = discord.utils.get(client.get_all_channels(),
server__name=server.name,
name=our_channel_name)
if not channel:
print('Creating channel {0} in {1}'.format(our_channel_name,
server))
everyone_perms = discord.PermissionOverwrite(send_messages=False)
owner_perms = discord.PermissionOverwrite(send_messages=True)
everyone = discord.ChannelPermissions(target=server.default_role,
overwrite=everyone_perms)
owners = discord.ChannelPermissions(target=role,
overwrite=owner_perms)
await client.create_channel(server, our_channel_name, everyone,
owners)
else:
print('Channel {0} found at {1}'.format(channel, server))
for member in server.members:
if member.name in discord_handles and role not in member.roles:
print('Adding role to {0} member'.format(member.name))
await client.add_roles(member, role)
elif member.name in discord_handles and role in member.roles:
print('{0} already has our role'.format(member.name))
else:
print('{0} does not own our token'.format(member.name))
async def create_user(self,
ctx,
name,
user: discord.Member,
after: discord.Channel = None):
"""User specific channel.
Everyone can read but only one person can write.
"""
server = ctx.message.server
channel = await self.bot.create_channel(
server,
name,
discord.ChannelPermissions(target=server.default_role,
overwrite=discord.PermissionOverwrite(
read_messages=True,
send_messages=False)),
discord.ChannelPermissions(
target=user,
overwrite=discord.PermissionOverwrite(send_messages=True)),
type=discord.ChannelType.text)
await self.bot.say("Channel created.")
async def start(self):
self.role = await self.game.bot.create_role(self.game.server,
name="Location")
self.dead_role = await self.game.bot.create_role(self.game.server,
name="Location")
everyone_perm = discord.ChannelPermissions(
target=self.game.server.default_role,
overwrite=discord.PermissionOverwrite(read_messages=False,
send_messages=False,
read_message_history=False))
role_perm = discord.ChannelPermissions(
target=self.role,
overwrite=discord.PermissionOverwrite(read_messages=True,
send_messages=True,
read_message_history=False))
observer_perm = discord.ChannelPermissions(
target=self.game.observer_role,
overwrite=discord.PermissionOverwrite(read_messages=True,
send_messages=False,
read_message_history=True))
dead_perm = discord.ChannelPermissions(
target=self.game.dead_role,
overwrite=discord.PermissionOverwrite(read_messages=False,
send_messages=False,
read_message_history=False))
dead_perm2 = discord.ChannelPermissions(
target=self.dead_role,
overwrite=discord.PermissionOverwrite(read_messages=True,
send_messages=False,
read_message_history=True))
self.channel = await self.game.bot.create_channel(
self.game.server, "%s%s" % (self.game.channel_prefix, self.name),
everyone_perm, role_perm, observer_perm, dead_perm, dead_perm2)
await self.game.bot.edit_channel(self.channel, topic=self.topic)
async def open(context):
mafiaLobby = await bot.say("The Mafia Lobby has been opened! Type " +
prefix + "join to join.")
gameInfo["open"] = True
gameInfo["channel"] = await bot.create_channel(
context.message.server, "mafia-general",
discord.ChannelPermissions(
context.message.server.default_role,
discord.PermissionOverwrite(read_messages=False)))
gameInfo["mafia_channel"] = await bot.create_channel(
context.message.server, "mafia-private",
discord.ChannelPermissions(
context.message.server.default_role,
discord.PermissionOverwrite(read_messages=False)))
gameInfo["state"] = "Lobby"
gameInfo["player_count"] = 0
await bot.move_channel(gameInfo["channel"], 0)
await bot.move_channel(gameInfo["mafia_channel"], 1)
await bot.change_presence(game=discord.Game(name="Mafia [Lobby]"))
players = {}
async def addchannel(ctx, channel: str = None):
server = ctx.message.server
if channel is None:
await client.say("Please specify a channel name")
else:
if ctx.message.author.server_permissions.administrator == False:
await client.say(
'**You do not have permission to use this command**')
return
else:
everyone_perms = discord.PermissionOverwrite(send_messages=None,
read_messages=None)
everyone = discord.ChannelPermissions(target=server.default_role,
overwrite=everyone_perms)
await client.create_channel(server, channel, everyone)
await client.say("{} channel has been created.".format(channel))
async def setreactionverify(ctx):
author = ctx.message.author
server = ctx.message.server
everyone_perms = discord.PermissionOverwrite(send_messages=False,
read_messages=True)
everyone = discord.ChannelPermissions(target=server.default_role,
overwrite=everyone_perms)
await client.create_channel(server, '★verify-for-chatting★', everyone)
for channel in author.server.channels:
if channel.name == '★verify-for-chatting★':
react_message = await client.send_message(
channel,
'React with 🇻 to Verify | Sometimes it not works so you can also use mv!verify anywhere(Where you can send messages)'
)
reaction = '🇻'
await client.add_reaction(react_message, reaction)
async def setreactionverify(ctx):
author = ctx.message.author
server = ctx.message.server
everyone_perms = discord.PermissionOverwrite(send_messages=False,
read_messages=True)
everyone = discord.ChannelPermissions(target=server.default_role,
overwrite=everyone_perms)
await client.create_channel(server, '★verify-for-chatting★', everyone)
for channel in author.server.channels:
if channel.name == '★verify-for-chatting★':
react_message = await client.send_message(
channel,
'React with <a:happy:516183323052212236> to Verify | This verification system is to prevent our server from those who join and try to spam from self bots'
)
reaction = 'a:happy:516183323052212236'
await client.add_reaction(react_message, reaction)
async def voice(self, ctx, name:str=''): #actual command
"""Creates a voice channel use opptional argument <name> to spesify the name of the channel"""
if name =='': #Tests if no name was passed
name = ctx.message.author.name #Sets it to the name of whoever sent the message
try:
perms = discord.PermissionOverwrite(mute_members=True, deafen_members=True, manage_channels=True)#Sets permisions
perms = discord.ChannelPermissions(target=ctx.message.author, overwrite=perms)#Sets the channel permissions for the person who sent the message
channel = await self.bot.create_channel(ctx.message.server, name, perms, type=discord.ChannelType.voice)#creates a channel
self.check_empty.append([channel.id, ctx.message.server.id]) #Multidimentional list or array
dataIO.save_json("data/Tasty/VoiceChannel.json", self.check_empty)#saves the new file
except Exception as e:
print(e)
await self.bot.send_message(ctx.message.channel, "An error occured - check logs")
pass
async def setup(bot, message, **kwargs):
if (message.author is message.server.owner) and (message.channel
is not bot.conf.pug_chan):
mention = '<@{}> '.format(message.author.id)
#confirm
await bot.client.send_message(message.channel,
mention + STR_SETUP_CONFIRM)
check = await bot.client.wait_for_message(timeout=30,
author=message.author,
channel=message.channel)
if check is None:
raise CommandError('Setup timed out.')
elif not check.content.startswith('y'):
raise CommandError('Setup cancelled.')
#setup broadcast channel - MANDATORY
await bot.client.send_message(message.channel,
mention + STR_SETUP_CHAN)
check_brd_chan = await bot.client.wait_for_message(
timeout=30, author=message.author, channel=message.channel)
if check_brd_chan is None:
raise CommandError('Setup timed out.')
temp_brd_chan = discord.utils.get(message.server.channels,
name=check_brd_chan.content)
if temp_brd_chan is None or temp_brd_chan.id == bot.conf.pug_chan.id:
raise CommandError(
'Setup cancelled. Invalid channel or doesn\'t exist.')
elif not temp_brd_chan.permissions_for(bot.server.me).send_messages:
raise CommandError(
'Setup cancelled. That channel does not have proper permissions.'
)
else:
brd_chan = temp_brd_chan
await bot.client.send_message(
message.channel, mention +
'Broadcast channel set to <#{}>.'.format(brd_chan.id))
#setup pug role
await bot.client.send_message(message.channel,
mention + STR_SETUP_PUG_ROLE)
check_pug_role = await bot.client.wait_for_message(
timeout=30, author=message.author, channel=message.channel)
if check_pug_role is None:
raise CommandError('Setup timed out.')
temp_pug_role = discord.utils.get(message.server.roles,
name=check_pug_role.content)
if temp_pug_role is None:
pug_role = message.server.default_role
await bot.client.send_message(message.channel,
mention + STR_SETUP_BAD_ROLE)
else:
pug_role = temp_pug_role
await bot.client.send_message(
message.channel,
mention + 'PUG role set to {}.'.format(pug_role.name))
#setup mod role
await bot.client.send_message(message.channel,
mention + STR_SETUP_MOD_ROLE)
check_mod_role = await bot.client.wait_for_message(
timeout=30, author=message.author, channel=message.channel)
if check_mod_role is None:
raise CommandError('Setup timed out.')
temp_mod_role = discord.utils.get(message.server.roles,
name=check_mod_role.content)
if temp_mod_role is None or temp_mod_role is message.server.default_role or temp_mod_role.id == pug_role.id:
mod_role = discord.Object(id='')
await bot.client.send_message(message.channel,
mention + STR_SETUP_BAD_ROLE)
else:
mod_role = temp_mod_role
await bot.client.send_message(
message.channel,
mention + 'Moderator role set to {}.'.format(mod_role.name))
#save settings
try:
everyone_perms = discord.PermissionOverwrite(
add_reactions=True,
send_messages=True,
send_tts_messages=False,
attach_files=False)
this_bot_perms = discord.PermissionOverwrite(
add_reactions=True,
send_messages=True,
manage_messages=True,
read_message_history=True)
everyone = discord.ChannelPermissions(
target=message.server.default_role, overwrite=everyone_perms)
this_bot = discord.ChannelPermissions(target=message.server.me,
overwrite=this_bot_perms)
pug = await bot.client.create_channel(
message.server,
'pickup-games',
everyone,
this_bot,
type=discord.ChannelType.text)
topic_fmt = ' '.join([x for x in bot.conf.modes])
topic_msg = 'Type !create <gamemode> to make a lobby. Available gamemodes: {}'.format(
*topic_fmt)
await bot.client.edit_channel(pug, topic=topic_msg)
except discord.DiscordException as e:
await bot.client.send_message(
message.channel,
mention + 'Error: Setup failed.\n{}'.format(e.args))
else:
bot.conf.pug_chan = pug
bot.conf.brd_chan = brd_chan
bot.conf.pug_role = pug_role
bot.conf.mod_role = mod_role
bot.dump_config()
await bot.client.send_message(message.channel,
mention + STR_SETUP_SUCCESS)
await bot.on_ready()
async def on_member_join(self, member):
server = member.server
channel = server.default_channel
if member.bot: # BotRights
return
if server.id not in self.settings:
self.settings[server.id] = default_settings
dataIO.save_json('data/bouncer/settings.json', self.settings)
settings = self.settings[server.id]
if not settings["on"]:
return
perms = channel.permissions_for(server.me)
manage_channels = perms.manage_channels
add_reactions = perms.add_reactions
kick_members = perms.kick_members
manage_roles = perms.manage_roles
read_messages = perms.read_messages
send_messages = perms.send_messages
can_proceed = manage_channels and add_reactions and kick_members and manage_roles and read_messages and send_messages
if not can_proceed:
error = (
"Permission missing. Neccesary permissions: Manage channels, "
"add reactions, kick members, manage roles, read messages, send messages"
)
print(error)
await self.writelog(server, error)
return
mode = settings["mode"]
role_before = discord.utils.get(
server.roles,
id=settings["role_before"]) if settings["role_before"] else None
role_after = discord.utils.get(server.roles, id=settings["role_after"])
rules = settings["rules"]
welcome_message = settings["welcome_message"]
kick_message = settings["kick_message"]
timeout_message = settings["timeout_message"]
if not role_after:
error = "After-role is not set, aborting"
print(error)
await self.writelog(server, error)
return
if not kick_message or not welcome_message:
error = "Missing message in settings, aborting"
print(error)
await self.writelog(server, error)
return
if role_before:
await self.bot.add_roles(member, role_before)
try:
if mode == "dm":
result = await self.bounce(member,
rules.format(member,
server), member)
if result:
await self.bot.send_message(member, welcome_message)
if role_before:
await self.bot.remove_roles(member, role_before)
await self.bot.add_roles(member, role_after)
await self.writelog(
server,
"{0.name} has accepted the rules".format(member))
if not result and result is not None:
await self.bot.send_message(member, kick_message)
await self.bot.kick(member)
await self.writelog(
server,
"{0.name} has denied the rules and been kicked".format(
member))
elif result is None:
await self.bot.send_message(member, timeout_message)
await self.bot.kick(member)
await self.writelog(
server, "{0.name} has timed out".format(member))
else:
channel_name = "Welcome_" + member.id
everyone_perms = discord.PermissionOverwrite(
read_messages=False)
user_perms = discord.PermissionOverwrite(
read_messages=True,
add_reactions=False,
read_message_history=True)
bot_perms = discord.PermissionOverwrite(read_messages=True,
add_reaction=True,
manage_channels=True)
everyone = discord.ChannelPermissions(
target=server.default_role, overwrite=everyone_perms)
user = discord.ChannelPermissions(target=member,
overwrite=user_perms)
bot = discord.ChannelPermissions(target=server.me,
overwrite=bot_perms)
channel = await self.bot.create_channel(
server, channel_name, everyone, user, bot)
result = await self.bounce(channel,
rules.format(member,
server), member)
if result:
await self.bot.send_message(channel, welcome_message)
if role_before:
await self.bot.remove_roles(member, role_before)
await self.bot.add_roles(member, role_after)
await self.writelog(
server,
"{0.name} has accepted the rules".format(member))
await asyncio.sleep(180)
await self.bot.delete_channel(channel)
if not result and result is not None:
await self.bot.delete_channel(channel)
await self.bot.send_message(member, kick_message)
await self.bot.kick(member)
await self.writelog(
server,
"{0.name} has denied the rules and been kicked".format(
member))
elif result is None:
await self.bot.delete_channel(channel)
await self.bot.send_message(member, timeout_message)
await self.bot.kick(member)
await self.writelog(
server, "{0.name} has timed out".format(member))
except discord.errors.Forbidden:
print("Missing neccesary permisions. Ugh..")
await self.writelog(
server, "Missing some permission, member might be stuck")
except Exception as e:
print("[Bouncer]. Error: {}".format(e))
await self.writelog(
server,
"Unknown exception occured: {}. User is probably stuck,".
format(e))