async def create_game(client, message): # Get the second player join_request = await client.send_message( message.channel, "One more player needed. " "Reply '>Join' in 30 seconds to join") reply = await client.wait_for_message(timeout=30, channel=message.channel, content=">Join") if reply.content is None: # Delete the call for players, & close the game await client.send_message(message.channel, "Game cancelled: Player timeout reached") await client.delete_message(join_request) return -1 # Create a game channel default_permissions = PermissionOverwrite(read_messages=False) player_permissions = PermissionOverwrite(read_messages=True) channel = await client.create_channel( message.server, 'checkers', (message.server.default_role, default_permissions), (message.server.me, player_permissions), (message.author, player_permissions), (reply.author, player_permissions), type=ChannelType.text) checkers = Checkers(client, channel, message.channel, [message.author, message.author]) await checkers.announcerules() return checkers, "checkers"
async def start_voice(self, a, b, session_id): """ Begin voice chat session between two people """ everyone_perms = PermissionOverwrite(read_messages=False) my_perms = PermissionOverwrite(read_messages=True) guild = self.bot.get_guild(self.guild_id) if guild is None: raise ConnectionError(f"Cannot connect to Guild({GUILD_ID})") ch = await guild.create_voice_channel(f"{SESSION_CHANNEL_PREFIX}{a.name}-{b.name}", overwrites={guild.default_role: everyone_perms, a: my_perms, b: my_perms}, category=self.bot.get_channel(self.category_channel_id)) self.active_channels.add(ch) # Move members into voice channel a_member = guild.get_member(a.id) b_member = guild.get_member(b.id) await a_member.edit(voice_channel=ch) await b_member.edit(voice_channel=ch) logging.info(f"Waiting for users {a} and {b} to join Voice Channel...") async def ch_filled(): """ Ensure both members have joined the voice chat. """ while not len(self.bot.get_channel(ch.id).members) == 2: await asyncio.sleep(.1) try: await asyncio.wait_for(ch_filled(), PREP_TIME) except asyncio.TimeoutError: logging.info(f"Members didn't connect. Closing session {session_id}...") await self.close_session(a, b, ch) else: logging.info(f"Beginning Session [{session_id}]({a}, {b})...") await asyncio.sleep(SESSION_TIME) await self.end_voice(a, b, ch, session_id)
async def save_guild_config(self, guild: Guild, config: Dict[str, Any]): for channel in guild.text_channels: if channel.name == self.BOT_CONFIG_CHANNEL: config_channel = channel break else: config_channel = await guild.create_text_channel( self.BOT_CONFIG_CHANNEL, overwrites={ guild.default_role: PermissionOverwrite( read_messages=False ), self.user: PermissionOverwrite(read_messages=True) } ) json_config = json.dumps(config, separators=(',', ':')) i = 0 # last_message = config_channel.last_message # async for message in config_channel.history(before=last_message): # await message.delete() # if last_message: # await last_message.delete() while True: json_chunk = json_config[i*1990:(i+1)*1990] if not json_chunk: break await config_channel.send( f'```\n{"^" if i != 0 else ""}{json_chunk}```' ) i += 1
async def on_guild_join(self, guild: Guild): if guild.id not in self.join_locks: self.join_locks[guild.id] = Event() debug(f"Setting up Configuration for guild {guild.name}") if not self.permission_check(guild): await guild.text_channels[0].send( "I don't have the correct permissions, make sure manage_channels and" " manage_messages are enabled.") await guild.leave() return overwrites = { guild.default_role: PermissionOverwrite(read_messages=False), guild.me: PermissionOverwrite(read_messages=True, manage_messages=True), **{ role: PermissionOverwrite(read_messages=True) for role in guild.roles if role.permissions.manage_channels } } channel = await guild.create_text_channel( self.bot.channel_name, overwrites=overwrites, topic= "This is the configuration channel for f-lute, please do NOT delete this, or the bot will leave" ) self.join_locks[guild.id].set()
async def hide(ctx): """Makes voice channel invisible // can only be used by channel owner.""" await bot.wait_until_ready() channeldata = load_json(channeldata_file) if str(ctx.message.author.id) in [ x for v in channeldata.values() for x in v ]: channel_id = get_key(str(ctx.message.author.id), channeldata) channel_obj = ctx.guild.get_channel(int(channel_id)) # if channel_obj.name.startswith(emotes[2]): // prevented by 2 name edits per 10 min rate limit :( # await channel_obj.edit(name=emotes[2] + channel_obj.name) # // prevented by 2 name edits per 10 min rate limit :( overwrites = PermissionOverwrite(view_channel=False) await channel_obj.set_permissions(target=ctx.guild.default_role, overwrite=overwrites) for m in channel_obj.members: await channel_obj.set_permissions( target=m, overwrite=PermissionOverwrite(view_channel=True)) channeldata[channel_id] = [str(ctx.message.author.id), "true"] json_file = open(channeldata_file, 'w+') json_file.write(json.dumps(channeldata, indent=4)) json_file.close() await ctx.message.delete() else: embed = discord.Embed( title='', description='{} You do not own a channel!'.format(emotes[4]), color=embed_color) await ctx.channel.send(embed=embed)
async def lock(ctx): """Makes voice channel private // can only be used by channel owner.""" await bot.wait_until_ready() channeldata = load_json(channeldata_file) if str(ctx.message.author.id) in [ x for v in channeldata.values() for x in v ]: channel_obj = ctx.guild.get_channel( int(get_key(str(ctx.message.author.id), channeldata))) # if emotes[0] in channel_obj.name: # embed = discord.Embed( # title='', # description='{} is already locked!'.format(channel_obj.name), # color=embed_color # ) # await ctx.send(embed=embed) # c_name = channel_obj.name.replace(emotes[1], emotes[0]) # Replace unlock with lock. # await channel_obj.edit(name=c_name) # // prevented by 2 name edits per 10 min rate limit :( overwrites = PermissionOverwrite(connect=False) await channel_obj.set_permissions(target=ctx.guild.default_role, overwrite=overwrites) for m in channel_obj.members: await channel_obj.set_permissions( target=m, overwrite=PermissionOverwrite(connect=True)) await ctx.message.add_reaction(emotes[0]) else: embed = discord.Embed( title='', description='{} You do not own a channel!'.format(emotes[4]), color=embed_color) await ctx.channel.send(embed=embed)
def get_overwrites(members: t.List[Member], guild: Guild) -> t.Dict[t.Union[Member, Role], PermissionOverwrite]: """Get code jam team channels permission overwrites.""" # First member is always the team leader team_channel_overwrites = { members[0]: PermissionOverwrite( manage_messages=True, read_messages=True, manage_webhooks=True, connect=True ), guild.default_role: PermissionOverwrite(read_messages=False, connect=False), guild.get_role(Roles.verified): PermissionOverwrite( read_messages=False, connect=False ) } # Rest of members should just have read_messages for member in members[1:]: team_channel_overwrites[member] = PermissionOverwrite( read_messages=True, connect=True ) return team_channel_overwrites
async def on_voice_state_update(self, member, before, after): if after.channel != None: channelQ = get_private(after.channel.id) else: channelQ = get_private(before.channel.id) if channelQ != None: channels = session.query(Private).all() if after.channel == None: channelQ.count_members = 0 else: channelQ.count_members = len(after.channel.members) for channel in channels: channeld = member.guild.get_channel(channel.channel_id) if channeld.members == []: await channeld.delete() session.delete(channel) session.commit() else: if after.channel.id == 649676227329654834: channel = await member.guild.create_voice_channel( member.name, category=after.channel.category) add_private(Private(channel_id=channel.id, count_members=1)) await member.move_to(channel) overwrite = PermissionOverwrite() overwrite.manage_channels = True await channel.set_permissions(member, overwrite=overwrite)
async def test_sent_correct_message(self): """Appropriate failure/success message was sent by the command.""" unsilenced_overwrite = PermissionOverwrite(send_messages=True, add_reactions=True) test_cases = ( (True, silence.MSG_UNSILENCE_SUCCESS, unsilenced_overwrite), (False, silence.MSG_UNSILENCE_FAIL, unsilenced_overwrite), (False, silence.MSG_UNSILENCE_MANUAL, self.text_overwrite), (False, silence.MSG_UNSILENCE_MANUAL, PermissionOverwrite(send_messages=False)), (False, silence.MSG_UNSILENCE_MANUAL, PermissionOverwrite(add_reactions=False)), ) targets = (None, MockTextChannel()) for (was_unsilenced, message, overwrite), target in itertools.product(test_cases, targets): ctx = MockContext() ctx.channel.overwrites_for.return_value = overwrite if target: target.overwrites_for.return_value = overwrite with mock.patch.object(self.cog, "_unsilence", return_value=was_unsilenced): with mock.patch.object(self.cog, "send_message") as send_message: with self.subTest(was_unsilenced=was_unsilenced, overwrite=overwrite, target=target): await self.cog.unsilence.callback(self.cog, ctx, channel=target) call_args = (message, ctx.channel, target or ctx.channel) send_message.assert_awaited_once_with(*call_args, alert_target=was_unsilenced)
async def update_board_for_turn(self, board: ConnectFourBoard) -> None: ow: dict = self.channel.overwrites if self.player_one: allow = not board.is_connect_four and self.is_player_ones_turn if board.play_count == 1 and self.last_move_by.id == self.player_one.id: allow = False ow[self.player_one.member] = PermissionOverwrite( read_messages=True, send_messages=allow) if self.player_two: allow = not board.is_connect_four and ( not self.is_player_ones_turn) ow[self.player_two.member] = PermissionOverwrite( read_messages=True, send_messages=allow) if board.is_connect_four: ow[self.channel.guild.default_role] = PermissionOverwrite( read_messages=True, send_messages=False) await self.channel.edit(overwrites=ow) if board.is_connect_four: await self.channel.send("CONNECT FOUR {0} !!!!".format( self.last_move_by.mention)) await self.channel.send("This game will close in 15 seconds")
async def rebuild_course_channels(ctx): if not roles["admin"] in ctx.author.roles: await handle_no_permissions(ctx) return await ctx.message.add_reaction('✅') for course in courses_by_degree: permissions = { guild.default_role: PermissionOverwrite(read_messages=False) } for degree in courses_by_degree[course]['degrees']: degree_obj = next( (item for item in degrees if item["name"] == degree), None) if degree_obj is not None: permissions[degree_obj["role"]] = PermissionOverwrite( read_messages=True) course_channel = get(courses_category.text_channels, name=course.lower()) if course_channel is None: await courses_category.create_text_channel( course.lower(), overwrites=permissions, topic=courses_by_degree[course]['name']) else: await course_channel.edit(overwrites=permissions, topic=courses_by_degree[course]['name'])
async def create_game_channel(self, name: str, user: BunkUser, all_users: bool = True) -> TextChannel: channel: TextChannel = None game_channel: str = self.config.custom_games_channel if game_channel is not None: gc_ref: TextChannel = await self.channels.get_by_name(game_channel) c_name: str = "{0}-{1}".format(name, user.name) ow: dict = { self.server.default_role: PermissionOverwrite(read_messages=all_users, send_messages=all_users), self.server.get_member(user.id): PermissionOverwrite(read_messages=True, send_messages=True), self.server.get_member(self.bot.user.id): PermissionOverwrite(read_messages=True, send_messages=True) } if gc_ref is not None: is_cat: bool = isinstance(gc_ref, CategoryChannel) if not is_cat: await self.channels.log_error("Cannot create game under a non-category channel.", "GameService") else: c_name = self.get_game_name(gc_ref, c_name) channel = await gc_ref.create_text_channel(c_name, overwrites=ow, slowmode_delay=1) else: c_name = self.get_game_name(None, c_name) channel = await self.bot.server.create_text_channel(c_name, overwrites=ow, slowmode_delay=1) else: await self.channels.log_error("Cannot create custom game - CUSTOM-GAMES channel cannot be found", "GameService") return channel
async def create_gamemode(self, ctx: Context, gamemode: str): gamemode_identifier = gamemode.lower() api: Api = self.bot.get_cog("Api") guild_config: dict = api.get_server_settings(ctx.guild) if guild_config is None: return await ctx.send( "Please set up the config first." f" This can be done by running the {ctx.prefix}setup command") if gamemode_identifier in guild_config["matchmaking_channels"].keys(): return await ctx.send("A gamemode with this name already exists?") matchmaking_category = self.bot.get_channel( guild_config["categories"]["matchmaking"]) if matchmaking_category is None: return await ctx.send( "What the hell did you do? Contact support right now to get this resolved." ) configured_user_role = ctx.guild.get_role( guild_config["roles"]["configured"]) matchmaking_category_permissions = { configured_user_role: PermissionOverwrite(read_messages=True), ctx.guild.default_role: PermissionOverwrite(read_messages=False, speak=False) } vc = await matchmaking_category.create_voice_channel( name=gamemode, overwrites=matchmaking_category_permissions, reason="[Que-Management] Adding new gamemode") guild_config["matchmaking_channels"][gamemode_identifier] = vc.id api.update_server_settings(ctx.guild, guild_config) await ctx.send("Updated!")
async def mute(cmd, message, args): channel = message.channel server = message.server if not message.mentions: await cmd.bot.send_message(message.channel, cmd.help()) return user_q = message.mentions[0] overwrite = PermissionOverwrite() overwrite.send_messages = False if message.author is not user_q: if check_man_msg(message.author, channel) and check_man_roles( message.author, channel): try: for chan in server.channels: if str(chan.type).lower() == 'text': if check_write(user_q, chan): await cmd.bot.edit_channel_permissions( chan, user_q, overwrite) await cmd.bot.send_message( message.channel, 'Execution Successful.\nUser **' + user_q.name + '** was muted') except Exception as e: cmd.log.error(e) await cmd.bot.send_message(message.channel, str(e)) else: response = await cmd.bot.send_message( message.channel, 'Only a user with the **Manage Messages and Manage Roles** privilege can use this command. :x:' ) await asyncio.sleep(10) await cmd.bot.delete_message(response)
async def create_team(bot: Bot, team: str, author: Member) -> Role: """creates a new team""" team_role: Optional[Role] = get(bot.guilds[0].roles, name=team) if team_role is not None: return team_role team_role: Role = await bot.guilds[0].create_role(name=team, color=get_color()) await bot.guilds[0].get_member(author.id).add_roles(team_role) t_cat_overwrites = { bot.guilds[0].default_role: PermissionOverwrite(**{"view_channel": False}), team_role: PermissionOverwrite(**{"view_channel": True}) } team_category: CategoryChannel = await bot.guilds[0].create_category( name=team, overwrites=t_cat_overwrites) t_cha_overwrites = { bot.guilds[0].default_role: PermissionOverwrite(**{"view_channel": False}), team_role: PermissionOverwrite(**{"view_channel": True}) } await bot.guilds[0].create_text_channel(name="Team Chat", overwrites=t_cha_overwrites, category=team_category) await bot.guilds[0].create_voice_channel(name="Team Talk", overwrites=t_cha_overwrites, category=team_category) return team_role
def update_overwrite(ctx: commands.Context, overwrite: discord.PermissionOverwrite, permissions: dict): base_perms = dict(iter(discord.PermissionOverwrite())) old_perms = copy(permissions) user_perms = ctx.channel.permissions_for(ctx.author) invalid_perms = [] valid_perms = [] not_allowed: List[str] = [] for perm in old_perms.keys(): if perm not in base_perms.keys(): invalid_perms.append(f"`{perm}`") del permissions[perm] else: valid_perms.append(f"`{perm}`") overwrite.update(**permissions) if invalid_perms: invalid = ( f"\nThe following permissions were invalid:\n{humanize_list(invalid_perms)}\n" ) possible = humanize_list( [f"`{perm}`" for perm in base_perms.keys()]) invalid += f"Possible permissions are:\n{possible}" else: invalid = "" return overwrite, valid_perms, invalid, not_allowed
async def _create_anonc_chat_channel(self, guild, member) -> AnoncChannel: overwrites = { guild.default_role: PermissionOverwrite.from_pair( Permissions.none(), # allow Permissions.all() # deny ), member: PermissionOverwrite(send_messages=True, read_messages=True, manage_messages=True, attach_files=True, read_message_history=True) } anonc_id = random_string(4) while self.get_anonc_chat_channel_from_anonc_id(anonc_id): anonc_id = random_string(4) anonc_id_role = None if self.use_role: anonc_id_role = await guild.create_role(name=anonc_id, mentionable=True) channel = await guild.create_text_channel('anon chat', overwrites=overwrites, topic=anonc_id, nsfw=self.nsfw) webhook = await channel.create_webhook(name=str(member.id)) return AnoncChannel(channel, webhook, member, anonc_id_role)
async def close(self, ctx): if ctx.channel.name != 'submission-discussion': return if not ctx.channel.permissions_for(ctx.author).administrator: return overwrites = ctx.channel.overwrites for key, value in overwrites.items(): if isinstance(key, Member): author = key break overwrites = { ctx.guild.default_role: PermissionOverwrite(read_messages=False), author: PermissionOverwrite(read_messages=True, send_messages=False, add_reactions=False), self.admin_role: PermissionOverwrite(read_messages=True, send_messages=True, add_reactions=True) } embed = Embed(title="This discussion has been closed.", color=0x4F71C6) await ctx.channel.send(embed=embed) await ctx.channel.edit(name=ctx.channel.name + '-' + str(author.id), category=self.archived_submissions_category, overwrites=overwrites, sync_permissions=True)
async def on_voice_state_update(user, vc_before, vc_after): global guild #remove permissions from previous channel first if vc_before.channel != None: #Skip non join/leave/switch vc channel events if vc_before.channel == vc_after.channel: return vc_txt_before = get_channel_name(vc_before.channel.name) channel = get(vc_before.channel.category.text_channels, name=vc_txt_before) #Txt Channel might not exist the first few times if channel != None: if len(vc_before.channel.members) == 0: await channel.delete() else: await channel.set_permissions(user, read_messages=False) if vc_after.channel != None: vc_txt_after = get_channel_name(vc_after.channel.name) channel = get(vc_after.channel.category.text_channels, name=vc_txt_after) if channel == None: overwrites = { guild.default_role: PermissionOverwrite(read_messages=False), user: PermissionOverwrite(read_messages=True) } channel = await vc_after.channel.category.create_text_channel( name=vc_txt_after, overwrites=overwrites) else: await channel.set_permissions(user, read_messages=True)
async def _create_text_channel(self): """ Creates the user-related text-channel """ channels = handler.load_json(JSON_CHANNEL_IDS_FILE) author = self.ctx.author self.users_using[str(author.id)] = 0 channel: TextChannel = await self.ctx.guild.create_text_channel(f'{self.manga["name"]}-{author.name}') ow = PermissionOverwrite() ow.send_messages = False ow.read_messages = True await channel.set_permissions(author, overwrite=ow) default_role = utils.get(self.ctx.guild.roles, name='@everyone') ow.read_messages = False await channel.set_permissions(default_role, overwrite=ow) channels[str(self.ctx.guild.id)][str(author.id)] = str(channel.id) handler.dump_json(JSON_CHANNEL_IDS_FILE, channels) return channel
async def groups_create(self, ctx: Context, name: str, *, description: str): """Create a group for you and your friends! Name must NOT include spaces and is CaSe SeNsItIvE! """ if len(name) > 48: await ctx.send( ":anger: Please use a name shorter than 48 characters.") return sid = str(ctx.guild.id) if sid not in self.db: self.db[sid] = {} # Try to make a role, text, and voice channel for the group try: role = await ctx.guild.create_role(name=name, reason="Groups plugin") ow = { ctx.guild.default_role: PermissionOverwrite(read_messages=False), role: PermissionOverwrite(read_messages=True), } category = await ctx.guild.create_category(name=name, reason="Groups plugin", overwrites=ow) text = await ctx.guild.create_text_channel( name=name.lower(), reason="Groups plugin", category=category, topic=description, ) voice = await ctx.guild.create_voice_channel( name=name, reason="Groups plugin", category=category) self.db[sid][name] = { "info": { "leader": str(ctx.author.id), "description": description, "category": str(category.id), "text_channel": str(text.id), "voice_channel": str(voice.id), "role": str(role.id), } } update_db(self.sql_db, self.db, "servers") await ctx.author.add_roles(role, reason="Group created.") except Exception as e: await ctx.send(f":anger: Something went wrong: `{e}`") return await ctx.send(":white_check_mark: Group created!") await text.send( f"Welcome to your group {ctx.author.mention}! Try the `group invite` command!" )
async def on_voice_state_update(self, member, before, after): """invoked when a member changes their VoiceState""" if member.bot: return if before.channel and before.channel != after.channel: if not before.channel.members: if str(before.channel.id) in self.VCs['party_tchannels']: await member.guild.get_channel( self.VCs['party_tchannels'][str(before.channel.id)] ).delete() del self.VCs['party_tchannels'][str(before.channel.id)] self.save() if before.channel.id in self.VCs['party_vchannels']: await before.channel.delete() self.VCs['party_vchannels'].remove(before.channel.id) self.save() if str(before.channel.id) in self.VCs['party_tchannels']: tc = member.guild.get_channel(self.VCs['party_tchannels'][str( before.channel.id)]) await tc.set_permissions(member, overwrite=None) if not after.channel: return if member.nick: member_name = member.nick else: member_name = member.name if str(after.channel.id) in self.VCs['party_tchannels']: tc = member.guild.get_channel(self.VCs['party_tchannels'][str( after.channel.id)]) await tc.set_permissions(member, read_messages=True) return if after.channel.id in self.VCs['text_enabled_channels'] or ( member.guild.id in self.VCs['allow_text'] and after.channel.id in self.VCs['party_vchannels']): overwrites = { member.guild.default_role: PermissionOverwrite(read_messages=False, read_message_history=False), member: PermissionOverwrite(read_messages=True) } tc = await member.guild.create_text_channel( f'party of {member_name}', overwrites=overwrites, category=after.channel.category) self.VCs['party_tchannels'][str(after.channel.id)] = tc.id self.save() return if after.channel.id not in self.VCs['vc_enabled_channels']: return vc = await member.guild.create_voice_channel( f'{member_name}\'s Party', category=after.channel.category) if vc.id not in self.VCs['party_vchannels']: self.VCs['party_vchannels'].append(vc.id) self.save() await member.move_to(vc)
async def create_channel(self, ctx, name, role: Role = None): overwrites = {} if role: overwrites = { ctx.guild.default_role: PermissionOverwrite(read_messages=False), role: PermissionOverwrite(read_messages=True) } new_channel = await ctx.guild.create_text_channel(name, overwrites=overwrites) await ctx.send(f'Created new channel - {new_channel.name}')
def set( self, target: Union[discord.Role, discord.Member], permission_overwrite: discord.PermissionOverwrite, ): """Set the permissions for a target.""" if not permission_overwrite.is_empty(): self.__overwrites[target] = discord.PermissionOverwrite( ).from_pair(*permission_overwrite.pair())
async def member_join( self, member: Member, channel: VoiceChannel, group: Optional[DynamicVoiceGroup], dyn_channel: Optional[DynamicVoiceChannel], ): await member.add_roles(*await gather_roles(member.guild, channel.id)) if dyn_channel is not None: if group is not None: await member.add_roles( *await gather_roles(member.guild, group.channel_id)) text_chat: Optional[TextChannel] = self.bot.get_channel( dyn_channel.text_chat_id) if text_chat is not None: if not group.public: await channel.set_permissions(member, read_messages=True, connect=True) await text_chat.set_permissions(member, read_messages=True) await self.send_voice_msg( text_chat, group.public, translations.voice_channel, translations.f_dyn_voice_joined(member.mention)) return if group is None: return if member.bot: await member.move_to(None) return if channel.category is not None and len( channel.category.channels) >= 49 or len( channel.guild.channels) >= 499: await member.move_to(None) return guild: Guild = channel.guild number = len(await db_thread( db.all, DynamicVoiceChannel, group_id=group.id)) + 1 chan: VoiceChannel = await channel.clone(name=group.name + " " + str(number)) category: Union[CategoryChannel, Guild] = channel.category or guild overwrites = { guild.default_role: PermissionOverwrite(read_messages=False, connect=False), guild.me: PermissionOverwrite(read_messages=True, connect=True), } if (team_role := guild.get_role(await Settings.get(int, "team_role"))) is not None: overwrites[team_role] = PermissionOverwrite(read_messages=True, connect=True)
async def on_new_draft(self, drafts): """Create channels for drafts and add correct users if need to keep track of discord channel id -> draft id use send_update_drafts when know the channel ids. """ logger.info("FantasyBot: on new draft") # for guild in self.guilds: # TODO guild = self.get_guild(GUILD_ID) if guild is None: logger.error( f'FantasyBot:on_new_draft: cant find guild with id {GUILD_ID}') return for draft in drafts: logger.info( f'FantasyBot:on_new_draft: handling draft {draft["draft_id"]}') if draft['league_id'] != FANTASY_LEAGUE_ID: logger.error( f'FantasyBot:on_new_draft: unexpected league id {draft["league_id"]}' ) return overwrites = { guild.default_role: PermissionOverwrite(read_messages=False) } for team_draft in draft["team_drafts"]: member = guild.get_member(team_draft["meta"]["discord_id"]) if member is None: logger.error( f'FantasyBot:on_new_draft: failed to find member') # return continue overwrites[member] = PermissionOverwrite(read_messages=True) category = dget(guild.categories, name=CATEGORY_NAME) if category is None: logger.error( "FantasyBot:on_new_draft: failed to find catgeory") return logger.info( f'FantasyBot:on_new_draft: creating new channel for draft {draft["draft_id"]}' ) # TODO CT should go into the fantasydota category (or a drafts subcategory) new_channel = await guild.create_text_channel( f'draft {draft["draft_id"]}', overwrites=overwrites, category=category) self.fantasy_handler.draft_ids_to_channel_ids[ draft["draft_id"]] = new_channel.id self.fantasy_handler.channel_ids_to_draft_ids[ new_channel.id] = draft["draft_id"] await self.fantasy_handler.client.send_update_drafts([ DraftUpdate(draft["draft_id"], meta={'channel_id': new_channel.id}) ]) await new_channel.send(f'Welcome drafters!') await new_channel.send( self.fantasy_handler.future_draft_choices(draft["draft_id"]))
async def webhook_project_repository(self, message: Message) -> None: """Generate a channel and webhook for a repository.""" assert message.content.startswith("webhook!") url = message.content[len("webhook!"):] async with self.session.get(url) as resp: if not resp.status in range(200, 300): await message.channel.send( f"{message.author.mention} - I couldn't verify that link, I got a HTTP/{resp.status} back.", delete_after=3.0) await sleep(2) await message.delete() return kwargs = {"topic": url, "reason": f"Invoked by {message.author!s}"} match = await self.client.loop.run_in_executor( None, partial(search, r"([^/][\w-]+)(?:/)([^/].+)$", url)) if match is not None: name = "-".join(match.groups()) else: self.logger.error("Failed to match against %s", repr(url)) name = url if len(name) > 80: name = name[:80] assert len(name) <= 80 kwargs["name"] = name category = self.client.get_channel(self._category_id) assert category is not None member_role = message.guild.get_role(self._member_role_id) assert member_role is not None kwargs["overwrites"] = { **category.overwrites, member_role: PermissionOverwrite(read_messages=False, read_message_history=False), message.author: PermissionOverwrite(read_messages=True, read_message_history=True, send_messages=True), } channel = await category.create_text_channel(**kwargs) webhook = await channel.create_webhook(name=name) await channel.send( ALLOCATED_MESSAGE.format(message=message, webhook=webhook)) self.client.schedule_task(self._activate_webhook_channel(channel))
async def getUserChannelCategory(guild): category = utils.get(guild.categories, name="Benutzerkanäle") if not category: categoryoverwrites = { guild.default_role: PermissionOverwrite(read_messages=False, send_messages=False, connect=False, speak=False, move_members=False, use_voice_activation=True) } textchanneloverwrites = { guild.default_role: PermissionOverwrite(read_messages=True, send_messages=True) } voicechanneloverwrites = { guild.default_role: PermissionOverwrite(read_messages=True, connect=True, speak=False, move_members=False) } category = await guild.create_category_channel(name="Benutzerkanäle", overwrites=categoryoverwrites, reason="Bereite Benutzerkanäle vor...") await category.create_text_channel(name="benutzerkanäle", overwrites=textchanneloverwrites, reason="Bereite Benutzerkanäle vor...", topic="Befehle: /textchannelcreate - /textchanneldelete") await category.create_voice_channel(name="Sprachkanal erstellen", overwrites=voicechanneloverwrites, reason="Bereite Benutzerkanäle vor...") return category
async def groups_create(self, ctx: Context, name: str, *, description: str): """Create a group for you and your friends! Name must NOT include spaces! """ sid = str(ctx.guild.id) if sid not in db: db[sid] = {} # Try to make a role, text, and voice channel for the group try: role = await ctx.guild.create_role(name=name, reason=GP) # Set overwrites for the category ow = { ctx.guild.default_role: PermissionOverwrite(read_messages=False), role: PermissionOverwrite(read_messages=True) } category = await ctx.guild.create_category(name=name, reason=GP, overwrites=ow) text = await ctx.guild.create_text_channel(name=name.lower(), reason=GP, category=category, topic=description) voice = await ctx.guild.create_voice_channel(name=name, reason=GP, category=category) db[sid] = { name: { "info": { "description": description, "category": str(category.id), "text_channel": str(text.id), "voice_channel": str(voice.id), "role": str(role.id) } } } update_db(sql_db, db, "servers") await ctx.author.add_roles(role, reason="Group created.") except Exception as e: await ctx.send(f":anger: Something went wrong: `{e}`") return await ctx.send(":white_check_mark: Group created!") await text.send( f"Welcome to your group {ctx.author.mention}! Try the `group invite` command!" )
async def get_default_vc(self): try: self.selected_channel = self.channel.guild.voice_channels[0] except IndexError: self.selected_channel = await self.channel.guild.create_voice_channel( "Flute Music", overwrites={ self.channel.guild.default_role: PermissionOverwrite(speak=False), self.channel.guild.me: PermissionOverwrite(speak=True), })