async def on_ready():
app_info = await bot.application_info()
bot.owner = app_info.owner
permissions = Permissions()
permissions.update(send_messages=True,
embed_links=True,
add_reactions=True,
manage_messages=True,
manage_roles=True,
manage_channels=True,
use_application_commands=True)
# Add the ErrorLog object if the channel is specified
if bot.config["error_log_channel"]:
error_channel = await bot.fetch_channel(bot.config["error_log_channel"]
)
bot.errorlog = ErrorLog(bot, error_channel)
print("\n"
"#-------------------------------#\n"
"| Loading initial cogs...\n"
"#-------------------------------#")
for cog in INIT_EXTENSIONS:
try:
await bot.load_extension(f"cogs.{cog}")
print(f"| Loaded initial cog {cog}")
except ExtensionAlreadyLoaded:
continue
except Exception as e:
if hasattr(e, "original"):
print(
f"| Failed to load extension {cog}\n| {type(e.original).__name__}: {e.original}"
)
else:
print(
f"| Failed to load extension {cog}\n| {type(e).__name__}: {e}"
)
error = exc_info()
await bot.errorlog.send(error, event="Load Initial Cog")
print(f"| Syncing commands...", end="\r")
await bot.tree.sync()
await bot.tree.sync(guild=await bot.fetch_guild(699399549218717707))
print(f"| Commands synced ")
print(f"#-------------------------------#\n"
f"| Successfully logged in.\n"
f"#-------------------------------#\n"
f"| User: {bot.user}\n"
f"| User ID: {bot.user.id}\n"
f"| Owner: {bot.owner}\n"
f"| Guilds: {len(bot.guilds)}\n"
f"| OAuth URL: {oauth_url(app_info.id, permissions=permissions)}\n"
f"#------------------------------#\n")
async def permissions_for(self, member):
base = await self._permissions_for(member)
denied = Permissions.voice()
base.value &= ~denied.value
return base
def generate_oauth():
client_id = os.getenv("CLIENT_ID", "")
guild_id = os.getenv("GUILD_ID", "")
# Has send messages permisison
permissions = Permissions(permissions=2048)
Client().get_guild(guild_id)
generated_url = oauth_url(client_id, permissions)
print(f"Generated oauth for given client id: {generated_url}")
def __init__(self, id, name, guild, position, permissions):
""" init with an id, a name, a guild, a position,
permissions (true -> add all permissions -> same as owner)
and MagicMock for state.
*** @everyone have same id than guild *** """
role_data = {'id': id, 'name': name, 'position': position}
if permissions is True:
role_data['permissions'] = Permissions.all().value
super().__init__(data=role_data, guild=guild, state=MagicMock())
async def on_ready():
await bot.connect_dbl(autopost=True)
app_info = await bot.application_info()
bot.owner = bot.get_user(app_info.owner.id)
permissions = Permissions()
permissions.update(send_messages=True,
embed_links=True,
manage_messages=True,
manage_webhooks=True,
add_reactions=True,
attach_files=True)
print(f"\n"
f"#-------------------------------#\n"
f"| Loading initial cogs...\n"
f"#-------------------------------#")
for cog in INIT_EXTENSIONS:
try:
bot.load_extension(f"cogs.{cog}")
print(f"| Loaded initial cog {cog}")
except Exception as e:
print(
f"| Failed to load extension {cog}\n| {type(e).__name__}: {e}"
)
print(f"#-------------------------------#\n"
f"| Successfully logged in.\n"
f"#-------------------------------#\n"
f"| User: {bot.user}\n"
f"| User ID: {bot.user.id}\n"
f"| Owner: {bot.owner}\n"
f"| Guilds: {len(bot.guilds)}\n"
f"| Users: {len(list(bot.get_all_members()))}\n"
f"| OAuth URL: {oauth_url(app_info.id, permissions)}\n"
f"#------------------------------#\n"
f"| {choice(LOADING_CHOICES)}\n"
f"#-------------------------------#\n")
def _calculated_id(self):
"""Calculate an id used by the client."""
if not self.list:
return str(self.channel_id)
# list of strings holding the hash input
ovs_i = []
for actor_id, overwrite in self.list.overwrites.items():
allow, deny = (
Permissions(overwrite['allow']),
Permissions(overwrite['deny'])
)
if allow.bits.read_messages:
ovs_i.append(f'allow:{actor_id}')
elif deny.bits.read_messages:
ovs_i.append(f'deny:{actor_id}')
hash_in = ','.join(ovs_i)
return str(mmh3(hash_in))
async def role_update(self, role: dict):
"""Update a role.
This function only takes care of updating
any permission-related info, and removing
the group if it lost the permissions to
read the channel.
"""
if not self.list:
return
role_id = int(role['id'])
group_idx = self._get_role_as_group_idx(role_id)
if not group_idx and role['hoist']:
# this is a new group, so we'll treat it accordingly.
log.debug('role_update promote to new_role call rid={}',
role_id)
return await self.new_role(role)
if not group_idx:
log.debug('role is not group {} (gid={}, cid={})',
role_id, self.guild_id, self.channel_id)
return
group = self.list.groups[group_idx]
group.permissions = Permissions(role['permissions'])
await self._fetch_overwrites()
# if the role can't read the channel anymore,
# we have to delete it just like an actual role
# deletion event.
# role_delte will take care of sending the
# respective GUILD_MEMBER_LIST_UPDATE events
# down to the subscribers.
if not self._can_read_chan(group):
log.debug('role_update promote to role_delete '
'call rid={} (lost perms)',
role_id)
return await self.role_delete(role_id)
if not role['hoist']:
log.debug('role_update promote to role_delete '
'call rid={} (no hoist)',
role_id)
return await self.role_delete(role_id)
def __init__(self, data: Dict[str, Any]) -> None:
self.id = int(data["id"])
self.name = data["name"]
self.permissions = Permissions(int(data.get("permissions", 0)))
self.position = data.get("position", 0)
self.colour = Colour(data.get("color", 0))
self.hoist = data.get("hoist", False)
self.managed = data.get("managed", False)
self.mentionable = data.get("mentionable", False)
self.tags: Optional[RoleTags]
try:
self.tags = RoleTags(data=data["tags"]) # type: ignore
except KeyError:
self.tags = None
async def on_guild_join(guild):
global separator, data
QMrole = discord.utils.find(lambda r: r.name == 'Queue Manager',
guild.roles)
if not QMrole:
QMrole = await guild.create_role(name='Queue Manager',
permissions=Permissions(285346816),
colour=Colour.dark_green(),
hoist=True)
try:
await guild.owner.add_roles(QMrole)
except discord.errors.Forbidden:
print('Bot does not have "Manage Role" Permissions')
print('\n{} online in {} (id: {}):'.format(bot.user.name, guild.name,
guild.id))
print('Loading data')
try:
data[guild.id] = loadFromJson(guild)
except FileNotFoundError:
print('No saved data found. Creating data file.')
data[guild.id] = {
'serverID': guild.id,
'servername': guild.name,
'queue': [],
'config': {
'autofollow': True
}
}
saveToJson(guild, data[guild.id])
for channel in guild.text_channels:
#print(channel.name)
if queueManagerPresent(guild):
await channel.send(
'{} is online for your queueing pleasure'.format(
bot.user.display_name))
async def get_role_groups(self) -> List[GroupInfo]:
"""Get role information, but only:
- the ID
- the name
- the position
- the permissions
of all HOISTED roles AND roles that
have permissions to read the channel
being referred to this :class:`GuildMemberList`
instance.
The list is sorted by each role's position.
"""
roledata = await self.storage.db.fetch("""
SELECT id, name, hoist, position, permissions
FROM roles
WHERE guild_id = $1
""", self.guild_id)
hoisted = [
GroupInfo(row['id'], row['name'],
row['position'],
Permissions(row['permissions']))
for row in roledata if row['hoist']
]
# sort role list by position
hoisted = sorted(hoisted, key=lambda group: group.position,
reverse=True)
# we need to store the overwrites since
# we have incoming presences to manage.
await self._fetch_overwrites()
return list(filter(self._can_read_chan, hoisted))
async def new_role(self, role: dict):
"""Add a new role to the list.
Only adds the new role to the list if the role
has the necessary permissions to start with.
"""
if not self.list:
return
group_id = int(role['id'])
new_group = GroupInfo(
group_id, role['name'],
role['position'], Permissions(role['permissions'])
)
# check if new role has good perms
await self._fetch_overwrites()
if not self._can_read_chan(new_group):
log.info('ignoring incoming group {}', new_group)
return
log.debug('new_role: inserted rid={} (gid={}, cid={})',
group_id, self.guild_id, self.channel_id)
# maintain role sorting
self.list.groups.insert(role['position'], new_group)
# since this is a new group, we can set it
# as a new empty list (as nobody is in the
# new role by default)
# NOTE: maybe that assumption changes
# when bots come along.
self.list.data[new_group.gid] = []
async def r2d2(self, ctx: Context):
if "CLIENT_ID" in os.environ:
client_id = os.environ["CLIENT_ID"]
permission = Permissions(administrator=True)
link = oauth_url(client_id, permissions=permission)
await ctx.send(f"Share me! {link}")
def __init__(self, data: Dict[str, Any]) -> None:
self.name = data["name"]
self.id = int(data["id"])
self.type = ChannelType(data["type"])
self.permissions = Permissions(int(data["permissions"]))
def __init__(self, data: Dict[Any, Any], state: ConnectionState,
guild: Optional[Guild]) -> None:
self.permissions = (Permissions(int(data["permissions"]))
if "permissions" in data else None)
super().__init__(data=data, state=state, guild=guild) # type: ignore
async def _permissions_for(self, member):
if self.guild.owner_id == member.id:
return Permissions.all()
default = await self.guild.default_role()
base = Permissions(default.permissions.value)
roles = await self.guild.roles()
for role in roles:
if role.id in member._roles:
base.value |= role._permissions
if base.administrator:
return Permissions.all()
try:
maybe_everyone = self._overwrites[0]
if maybe_everyone.id == self.guild.id:
base.handle_overwrite(allow=maybe_everyone.allow,
deny=maybe_everyone.deny)
remaining_overwrites = self._overwrites[1:]
else:
remaining_overwrites = self._overwrites
except IndexError:
remaining_overwrites = self._overwrites
denies = 0
allows = 0
for overwrite in remaining_overwrites:
if overwrite.type == "role" and overwrite.id in roles:
denies |= overwrite.deny
allows |= overwrite.allow
base.handle_overwrite(allow=allows, deny=denies)
for overwrite in remaining_overwrites:
if overwrite.type == "member" and overwrite.id == member.id:
base.handle_overwrite(allow=overwrite.allow,
deny=overwrite.deny)
break
if not base.read_messages:
denied = Permissions.all_channel()
base.value &= ~denied.value
return base
def is_admin(self):
return self.raw_user.guild_permissions == Permissions.all()
