async def modify_webhook(self,
webhook_id,
webhook_token=None,
name=None,
avatar=None) -> Dict:
if not webhook_token:
r = Route("PATCH",
"/webhooks/{webhook_id}".format(webhook_id=webhook_id))
else:
r = Route(
"PATCH", "/webhooks/{webhook_id}/{webhook_token}".format(
webhook_id=webhook_id, webhook_token=webhook_token))
payload = {}
if name:
payload["name"] = name
if avatar:
payload["avatar"] = avatar
if not payload:
raise KeyError("Must include either `name`, `avatar`, or both")
return await self.http.request(r, json=payload)
async def collect_discoverable_guilds(self):
limit = 48
offset = 0
params = {"offset": offset, "limit": limit}
request = await self.http.request(
Route("GET", f"/discoverable-guilds"), params=params
)
guild_dict = {guild["id"]: guild for guild in request["guilds"]}
while request["total"] > 0:
await asyncio.sleep(0.5)
offset += limit
params = {"offset": offset, "limit": limit}
request = await self.http.request(
Route("GET", f"/discoverable-guilds"), params=params
)
temp_dict = {guild["id"]: guild for guild in request["guilds"]}
guild_dict.update(temp_dict)
return guild_dict
async def get_webhook(self, webhook_id, webhook_token) -> Dict:
if not webhook_token:
r = Route("GET",
"/webhooks/{webhook_id}".format(webhook_id=webhook_id))
else:
r = Route(
"GET", "/webhooks/{webhook_id}/{webhook_token}".format(
webhook_id=webhook_id, webhook_token=webhook_token))
return await self.http.request(r)
async def delete_webhook(self, webhook_id, webhook_token=None) -> None:
if not webhook_token:
r = Route("DELETE",
"/webhooks/{webhook_id}".format(webhook_id=webhook_id))
else:
r = Route(
"DELETE", "/webhooks/{webhook_id}/{webhook_token}".format(
webhook_id=webhook_id, webhook_token=webhook_token))
await self.http.request(r)
async def get_banner(user_id):
"""Manualy request to discord api since discord.py haven't implement banner"""
rr = Route('GET', 'None')
rr.url = f'https://discord.com/api/v9/users/{user_id}'
res = await bot.http.request(rr)
if res['banner'] is None:
return False
fmt = "gif"
url = f"https://cdn.discordapp.com/banners/{user_id}/{res['banner']}.{fmt}"
http = urllib3.PoolManager()
request = http.request("GET", url)
if request.status != 200:
fmt = "png"
return f"https://cdn.discordapp.com/banners/{user_id}/{res['banner']}.{fmt}?size=512"
async def setup(self):
# --- step 0. set sane message notifications
await self.bot.http.request(
Route("PATCH", "/guilds/{guild_id}", guild_id=self.guild.id),
json={"default_message_notifications": 1},
)
# --- step 1. tweak base permissions
perms = discord.Permissions()
for sane_perm in PARTY_PERMISSIONS:
setattr(perms, sane_perm, True)
await self.guild.default_role.edit(permissions=perms)
# --- step 2. we need to be first
await self.general.send("welcome to the party! \N{PARTY POPPER}")
# --- step 3. create party role for the creator
self.creator_role = creator = await self.guild.create_role(
name="party creator",
color=discord.Color(0xFF6666),
hoist=True,
mentionable=True,
permissions=Permissions.all(),
)
# --- step 4. partygoers need a role
self.partygoer_role = partygoer = await self.guild.create_role(
name="partygoer", color=discord.Color(0x66CCFF), hoist=True)
# --- step 5. move roles
await creator.edit(position=2)
await partygoer.edit(position=1)
# --- step 6. add listeners
self.bot.add_listener(self.handle_join, "on_member_join")
async def on_interaction(i: Interaction):
log.info('interaction channel=%s', i.channel)
# log.info('interaction data is %s', i.data)
iid = i.data['id']
itoken = i.data['token']
msg = 'What?'
embeds = []
greet_command = '%s-greet' % client.user.name.lower()
todays_matches = '%s-foci-ma' % client.user.name.lower()
command_data = i.data['data']
if command_data['name'] == greet_command:
greetee = get_command_option(command_data, 'name')
age = get_command_option(command_data, 'age')
if age is not None:
greetee += ' (%s)' % age
msg = 'Hello, %s!' % greetee
elif command_data['name'] == todays_matches:
embed = await get_todays_matches()
embeds.append(embed)
payload = {'type': 4, 'data': {'content': msg, 'embeds': embeds}}
http_client: HTTPClient = i.state.http
route = Route('POST', '/interactions/%s/%s/callback' % (iid, itoken))
await http_client.request(route, json=payload)
async def get_channel_webhooks(self, channel) -> List[Dict]:
if isinstance(channel, Channel):
channel = channel.id
r = Route("GET",
"/channels/{channel_id}/webhooks".format(channel_id=channel))
return await self.http.request(r)
async def delete(self):
if self.id:
route = Route(
"DELETE",
"/webhooks/{application_id}/{interaction_token}/messages/{message_id}",
application_id=Bloxlink.user.id,
interaction_token=self.interaction_token,
message_id=self.id)
else:
route = Route(
"DELETE",
"/webhooks/{application_id}/{interaction_token}/messages/@original",
application_id=Bloxlink.user.id,
interaction_token=self.interaction_token)
await self._state.http.request(route)
async def edit_button_msg(
self,
message: Message,
content: str = "",
*,
tts: bool = False,
embed: Embed = None,
allowed_mentions: AllowedMentions = None,
buttons: List[Button] = None,
**options,
):
state = self.bot._get_state()
if embed:
embed = embed.to_dict()
if allowed_mentions:
if state.allowed_mentions:
allowed_mentions = state.allowed_mentions.merge(allowed_mentions).to_dict()
else:
allowed_mentions = allowed_mentions.to_dict()
else:
allowed_mentions = state.allowed_mentions and state.allowed_mentions.to_dict()
data = {
"content": content,
**self._get_buttons_json(buttons),
**options,
"embed": embed,
"allowed_mentions": allowed_mentions,
"tts": tts,
}
await self.bot.http.request(
Route("PATCH", f"/channels/{message.channel.id}/messages/{message.id}"), json=data
)
def send_message_components(
*,
content: Optional[str] = None,
state: ConnectionState,
channel_id: int,
embed: Optional[Embed] = None,
components: Optional[Sequence[Union[ActionRow, Button, Select]]] = None,
) -> Any:
allowed_mentions = state.allowed_mentions and state.allowed_mentions.to_dict(
) # type: ignore
components = [c.to_dict()
for c in components] if components is not None else None
r = Route("POST", "/channels/{channel_id}/messages", channel_id=channel_id)
payload: Dict[str, Any] = {}
if content:
payload["content"] = content
if embed:
payload["embeds"] = [embed.to_dict()]
if allowed_mentions:
payload["allowed_mentions"] = allowed_mentions
if components:
payload["components"] = components
return state.http.request(r, json=payload) # type: ignore
async def send_button_msg(
self,
channel: TextChannel,
content: str = "",
*,
tts: bool = False,
embed: Embed = None,
allowed_mentions: AllowedMentions = None,
buttons: List[Button] = None,
**options,
) -> Message:
state = self.bot._get_state()
if embed:
embed = embed.to_dict()
if allowed_mentions:
if state.allowed_mentions:
allowed_mentions = state.allowed_mentions.merge(allowed_mentions).to_dict()
else:
allowed_mentions = allowed_mentions.to_dict()
else:
allowed_mentions = state.allowed_mentions and state.allowed_mentions.to_dict()
data = {
"content": content,
**self._get_buttons_json(buttons),
**options,
"embed": embed,
"allowed_mentions": allowed_mentions,
"tts": tts,
}
data = await self.bot.http.request(
Route("POST", f"/channels/{channel.id}/messages"), json=data
)
return Message(state=state, channel=channel, data=data)
def send_message_components(self, channel_id, content, *, tts=False, embed=None, nonce=None, allowed_mentions=None,
message_reference=None, components=None):
r = Route('POST', '/channels/{channel_id}/messages', channel_id=channel_id)
payload = {}
if content:
payload['content'] = content
if tts:
payload['tts'] = True
if embed:
payload['embed'] = embed
if nonce:
payload['nonce'] = nonce
if allowed_mentions:
payload['allowed_mentions'] = allowed_mentions
if message_reference:
payload['message_reference'] = message_reference
if components:
payload['components'] = components
return self.request(r, json=payload)
async def respond(self,
type: int,
content: str,
embed: Optional[discord.Embed] = None,
embeds: Optional[List[discord.Embed]] = None,
tts: Optional[bool] = None,
flags: Optional[int] = None):
Route('POST', '')
async def send_to(self,
dest,
content=None,
files=None,
embed=None,
allowed_mentions=AllowedMentions(everyone=False,
roles=False),
send_as_slash_command=True,
hidden=False,
reference=None,
mention_author=None,
fail_on_dm=None):
msg = None
if fail_on_dm and isinstance(dest, (DMChannel, User, Member)):
return None
if isinstance(dest, Webhook):
msg = await dest.send(content,
username=self.bot_name,
avatar_url=self.bot_avatar,
embed=embed,
files=files,
wait=True,
allowed_mentions=allowed_mentions)
elif self.slash_command and send_as_slash_command:
payload = {
"content": content,
"embeds": [embed.to_dict()] if embed else None,
"flags": 1 << 6 if hidden else None
}
route = Route("POST",
"/webhooks/{application_id}/{interaction_token}",
application_id=Bloxlink.user.id,
interaction_token=self.slash_command["token"])
response = await self.channel._state.http.request(route,
json=payload)
msg = InteractionWebhook(
interaction_token=self.slash_command["token"],
data=response,
state=self.channel._state,
channel=self.channel)
else:
msg = await dest.send(content,
embed=embed,
files=files,
allowed_mentions=allowed_mentions,
reference=reference,
mention_author=mention_author)
self.bot_responses.append(msg.id)
return msg
async def move_channels(self, server: discord.Server,
channels: List[discord.Channel]):
payload = [{
'id': c.id,
'position': index
} for index, c in enumerate(channels)]
r = Route('PATCH', '/guilds/{guild_id}/channels', guild_id=server.id)
logger.debug('using payload: {0!r}'.format(payload))
await self.bot.http.request(r, json=payload)
def request_guild_members(self, guild_id, query, limit=1):
return self.request(
Route(
"GET",
"/guilds/{guild_id}/members/search?query={query}&limit={limit}",
guild_id=guild_id,
query=query,
limit=limit,
))
async def get_connections(self, access, refresh):
async with self.oauth.get_oauth2_http(access, refresh) as http:
all_connections = await http.request(
Route('GET', '/users/@me/connections'))
verified = []
for connection in all_connections:
if connection["verified"]:
verified.append(connection)
return verified
def put_slash_commands(self, commands, guild_id=None):
r = Route(
"PUT",
"/applications/{application_id}/commands" if not guild_id else
"/applications/{application_id}/guilds/{guild_id}/commands",
application_id=self.bot.user.id,
guild_id=guild_id,
)
return self.bot.http.request(
r, json=[command.to_dict(with_id=False) for command in commands])
async def _raw_send_no_mention(self, ctx, text: str):
"""Send chat as a raw payload to never mention included roles and @s."""
r = Route("POST",
"/channels/{channel_id}/messages",
channel_id=ctx.channel.id)
payload = {}
payload["content"] = text
payload["allowed_mentions"] = {"parse": []}
await self.bot.http.request(r, json=payload)
async def slash_ack(self):
if self.slash_command:
route = Route(
"POST",
"/interactions/{interaction_id}/{interaction_token}/callback",
interaction_id=self.slash_command["id"],
interaction_token=self.slash_command["token"])
payload = {"type": 5}
await self.channel._state.http.request(route, json=payload)
async def send_message(
bot: Red,
channel_id: int,
*,
content: Optional[str] = None,
embed: Optional[discord.Embed] = None,
file: Optional[discord.File] = None,
url_button: Optional[URLButton] = None,
):
"""Send a message with a URL button, with pure dpy 1.7."""
payload = {}
if content:
payload["content"] = content
if embed:
payload["embed"] = embed.to_dict()
if url_button:
payload["components"] = [{"type": 1, "components": [url_button.to_dict()]}] # type:ignore
if file:
form = [
{
"name": "file",
"value": file.fp,
"filename": file.filename,
"content_type": "application/octet-stream",
},
{"name": "payload_json", "value": discord.utils.to_json(payload)},
]
r = Route("POST", "/channels/{channel_id}/messages", channel_id=channel_id)
await bot._connection.http.request(r, form=form, files=[file])
else:
r = Route("POST", "/channels/{channel_id}/messages", channel_id=channel_id)
await bot._connection.http.request(r, json=payload)
def tmp_post_request():
payload = {
'name': name,
'type': str(discord.ChannelType.voice),
'permission_overwrites': permissions_payload,
'parent_id': target_category
}
return self.http.request(
Route('POST',
'/guilds/{guild_id}/channels',
guild_id=message.server.id),
json=payload,
# reason=None
)
async def edit(self, content=None, embed=None, *args, **kwargs):
payload = {
"content": content,
"embeds": [embed.to_dict()] if embed else None
}
route = Route(
"PATCH",
"/webhooks/{application_id}/{interaction_token}/messages/{message_id}",
application_id=Bloxlink.user.id,
interaction_token=self.interaction_token,
message_id=self.id)
await self._state.http.request(route, json=payload)
def raw_delete_slash_command(self, command_id, guild_id=None):
url = (
"applications/{application_id}/commands/{command_id}"
if not guild_id else
"applications/{my_application_id}/guilds/{guild_id}/commands/{command_id}"
)
r = Route(
"DELETE",
url,
application_id=self.bot.user.id,
command_id=command_id,
guild_id=guild_id,
)
return self.bot.http.request(r)
async def edit_role_icon(
bot,
role: Role,
*,
reason=None,
icon: bytes = None,
unicode_emoji: str = None,
reset: bool = False,
):
"""|coro|
Changes specified role's icon
Parameters
-----------
role: :class:`discord.Role`
A role to edit
icon: :class:`bytes`
A :term:`py:bytes-like object` representing the image to upload.
unicode_emoji: :class:`str`
A unicode emoji to set
reason: Optional[:class:`str`]
The reason for editing this role. Shows up on the audit log.
Raises
-------
Forbidden
You do not have permissions to change the role.
HTTPException
Editing the role failed.
InvalidArgument
Wrong image format passed for ``icon``.
:param bot:
"""
if not icon and not unicode_emoji and not reset:
raise discord.InvalidArgument("You must specify icon or unicode_emoji")
if reset:
fields = {"unicode_emoji": None, "icon": None}
else:
fields = {
"unicode_emoji": unicode_emoji,
"icon": _bytes_to_base64_data(icon) if icon else None,
}
r = Route("PATCH",
"/guilds/{guild_id}/roles/{role_id}",
guild_id=role.guild.id,
role_id=role.id)
await bot.http.request(r, json=fields, reason=reason)
async def join_guild(self, guild_id: int, user_id: int,
access_token: str, **kwargs) -> Optional[str]:
r = Route('PUT',
'/guilds/{guild_id}/members/{user_id}',
guild_id=guild_id,
user_id=user_id)
try:
await bot.http.request(r,
json={
"access_token": access_token,
**kwargs
})
return None
except HTTPException as e:
return e.text
async def slowmode(self,
ctx,
timeout: int = 10,
channel: discord.Channel = None):
"""Slows a channel."""
if channel is None:
channel = ctx.message.channel
try:
await self.bot.http.request(Route('PATCH',
'/channels/{channel_id}',
channel_id=channel.id),
json={"rate_limit_per_user": timeout})
await self.bot.say(
f"Ratelimit set to {timeout} seconds in {channel}.")
except:
await self.bot.say("Failed to set ratelimit.")
def send_files(self,
channel_id,
*,
files,
content=None,
tts=False,
embed=None,
nonce=None,
allowed_mentions=None,
message_reference=None,
components=None):
r = Route('POST', '/channels/{channel_id}/messages', channel_id=channel_id)
form = []
payload = {'tts': tts}
if content:
payload['content'] = content
if embed:
payload['embed'] = embed
if nonce:
payload['nonce'] = nonce
if allowed_mentions:
payload['allowed_mentions'] = allowed_mentions
if message_reference:
payload['message_reference'] = message_reference
if components:
payload['components'] = components
form.append({'name': 'payload_json', 'value': utils.to_json(payload)})
if len(files) == 1:
file = files[0]
form.append({
'name': 'file',
'value': file.fp,
'filename': file.filename,
'content_type': 'application/octet-stream'
})
else:
for index, file in enumerate(files):
form.append({
'name': 'file%s' % index,
'value': file.fp,
'filename': file.filename,
'content_type': 'application/octet-stream'
})
return self.request(r, form=form, files=files)
async def respond(self,
response_type: InteractionResponseType,
content: Optional[str] = None,
embed: Optional[Embed] = None,
embeds: Optional[List[Embed]] = None,
allowed_mentions: Optional[AllowedMentions] = None,
tts: Optional[bool] = None,
flags: Optional[int] = None):
state = self.client._get_state()
data: JSON = {}
if content:
data['content'] = content
if embed and embeds:
embeds.append(embed)
elif embed:
embeds = [embed]
if embeds and len(embeds) <= 10:
data['embeds'] = list(map(embed.to_dict() for embed in embeds))
if allowed_mentions:
if state.allowed_mentions:
data['allowed_mentions'] = state.allowed_mentions.merge(
allowed_mentions).to_dict()
else:
data['allowed_mentions'] = allowed_mentions.to_dict()
else:
data[
'allowed_mentions'] = state.allowed_mentions and state.allowed_mentions.to_dict(
)
if tts:
data['tts'] = tts
await self.client.http.request(
Route(
"POST",
f"/interactions/{self.interaction_id}/{self.interaction_token}/callback"
),
json={
"type": response_type.value,
"data": data
},
)
