1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
import logging
import random
from typing import Callable, Optional
import discord
from discord.ext import commands
from bot.bot import Bot
from bot.constants import Colours, ERROR_REPLIES, Icons, Roles
from bot.utils.converters import WrappedMessageConverter
from bot.utils.decorators import whitelist_override
log = logging.getLogger(__name__)
# Number of seconds to wait for other users to bookmark the same message
TIMEOUT = 120
MESSAGE_NOT_FOUND_ERROR = (
"You must either provide a reference to a valid message, or reply to one."
"\n\nThe lookup strategy for a message is as follows (in order):"
"\n1. Lookup by '{channel ID}-{message ID}' (retrieved by shift-clicking on 'Copy ID')"
"\n2. Lookup by message ID (the message **must** be in the current channel)"
"\n3. Lookup by message URL"
)
class LinkTargetMessage(discord.ui.View):
"""The button that relays the user to the bookmarked message."""
def __init__(self, target_message: discord.Message):
super().__init__()
self.add_item(discord.ui.Button(label="View Message", url=target_message.jump_url))
class SendBookmark(discord.ui.View):
"""The button that sends the bookmark to other users."""
def __init__(
self,
action_bookmark_function: Callable[[discord.TextChannel, discord.Member, discord.Message, str], None],
author: discord.Member,
channel: discord.TextChannel,
target_message: discord.Message,
title: str
):
super().__init__()
self.bookmark_function = action_bookmark_function
self.clicked = [author.id]
self.channel = channel
self.target_message = target_message
self.title = title
@discord.ui.button(label="Receive Bookmark", style=discord.ButtonStyle.green)
async def button_callback(self, interaction: discord.Interaction, button: discord.Button) -> None:
"""The button callback."""
if interaction.user.id in self.clicked:
await interaction.response.send_message(
"You have already received a bookmark to that message.",
ephemeral=True,
)
return
self.clicked.append(interaction.user.id)
await self.bookmark_function(self.channel, interaction.user, self.target_message, self.title)
await interaction.response.send_message("You have received a bookmark to that message.", ephemeral=True)
class Bookmark(commands.Cog):
"""Creates personal bookmarks by relaying a message link to the user's DMs."""
def __init__(self, bot: Bot):
self.bot = bot
self.book_mark_context_menu = discord.app_commands.ContextMenu(
name="Bookmark",
callback=self.book_mark_context_menu_callback
)
self.bot.tree.add_command(self.book_mark_context_menu)
async def cog_load(self) -> None:
"""Carry out cog asynchronous initialisation."""
await self.bot.tree.sync()
@staticmethod
def build_bookmark_embed(target_message: discord.Message) -> discord.Embed:
"""Build the channel embed to the bookmark requester."""
return discord.Embed(
description=(
f"Click the button to be sent your very own bookmark to "
f"[this message]({target_message.jump_url})."
),
colour=Colours.soft_green,
)
@staticmethod
def build_bookmark_dm(target_message: discord.Message, title: str) -> discord.Embed:
"""Build the embed to DM the bookmark requester."""
embed = discord.Embed(
title=title,
description=target_message.content,
colour=Colours.soft_green
)
embed.set_author(
name=target_message.author,
icon_url=target_message.author.display_avatar.url,
)
embed.set_thumbnail(url=Icons.bookmark)
return embed
@staticmethod
def build_error_embed(message: str) -> discord.Embed:
"""Builds an error embed for a given message."""
return discord.Embed(
title=random.choice(ERROR_REPLIES),
description=message,
colour=Colours.soft_red
)
async def action_bookmark(
self,
channel: discord.TextChannel,
member: discord.Member,
target_message: discord.Message,
title: str
) -> None:
"""
Sends the given target_message as a bookmark to the member in DMs to the user.
Send an error embed instead if the member has DMs disabled.
"""
embed = self.build_bookmark_dm(target_message, title)
try:
await member.send(embed=embed, view=LinkTargetMessage(target_message))
except discord.Forbidden:
error_embed = self.build_error_embed(f"{member.mention}, please enable your DMs to receive the bookmark.")
await channel.send(embed=error_embed)
else:
log.info(f"{member} bookmarked {target_message.jump_url} with title '{title}'")
@staticmethod
async def user_is_permitted_to_bookmark(
author: discord.Member | discord.User,
channel: discord.TextChannel
) -> bool:
"""
Check if users have the right to bookmark a message in a particular channel.
This also notifies users in case they don't have the right to.
"""
permissions = channel.permissions_for(author)
if not permissions.read_messages:
log.info(f"{author} tried to bookmark a message in #{channel} but has no permissions.")
embed = discord.Embed(
title=random.choice(ERROR_REPLIES),
color=Colours.soft_red,
description="You don't have permission to view this channel.",
)
await channel.send(embed=embed)
return False
return True
async def book_mark_context_menu_callback(self, interaction: discord.Interaction, message: discord.Message) -> None:
"""The callback that will be invoked upon using the bookmark's context menu command."""
if not await self.user_is_permitted_to_bookmark(interaction.user, message.channel):
return
title = "Bookmark"
await self.action_bookmark(message.channel, interaction.user, message, title)
view = SendBookmark(self.action_bookmark, interaction.user, message.channel, message, title)
embed = self.build_bookmark_embed(message)
await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
@commands.group(name="bookmark", aliases=("bm", "pin"), invoke_without_command=True)
@commands.guild_only()
@whitelist_override(roles=(Roles.everyone,))
async def bookmark(
self,
ctx: commands.Context,
target_message: Optional[WrappedMessageConverter],
*,
title: str = "Bookmark"
) -> None:
"""
Send the author a link to the specified message via DMs.
Members can either give a message as an argument, or reply to a message.
Bookmarks can subsequently be deleted by using the `bookmark delete` command in DMs.
"""
target_message: Optional[discord.Message] = target_message or getattr(ctx.message.reference, "resolved", None)
if target_message is None:
raise commands.UserInputError(MESSAGE_NOT_FOUND_ERROR)
if not await self.user_is_permitted_to_bookmark(ctx.author, target_message.channel):
return
await self.action_bookmark(ctx.channel, ctx.author, target_message, title)
view = SendBookmark(self.action_bookmark, ctx.author, ctx.channel, target_message, title)
embed = self.build_bookmark_embed(target_message)
await ctx.send(embed=embed, view=view)
@bookmark.command(name="delete", aliases=("del", "rm"), root_aliases=("unbm", "unbookmark", "dmdelete", "dmdel"))
@whitelist_override(bypass_defaults=True, allow_dm=True)
async def delete_bookmark(
self,
ctx: commands.Context,
) -> None:
"""
Delete the Sir-Lancebot message that the command invocation is replying to.
This command allows deleting any message sent by Sir-Lancebot in the user's DM channel with the bot.
The command invocation must be a reply to the message that is to be deleted.
"""
target_message: Optional[discord.Message] = getattr(ctx.message.reference, "resolved", None)
if target_message is None:
raise commands.UserInputError("You must reply to the message from Sir-Lancebot you wish to delete.")
if not isinstance(ctx.channel, discord.DMChannel):
raise commands.UserInputError("You can only run this command your own DMs!")
elif target_message.channel != ctx.channel:
raise commands.UserInputError("You can only delete messages in your own DMs!")
elif target_message.author != self.bot.user:
raise commands.UserInputError("You can only delete messages sent by Sir Lancebot!")
await target_message.delete()
async def setup(bot: Bot) -> None:
"""Load the Bookmark cog."""
await bot.add_cog(Bookmark(bot))
|
