840 lines
31 KiB
Python
840 lines
31 KiB
Python
"""
|
|
Max 25 reminders (propagating Discord restriction)
|
|
|
|
/reminders show
|
|
-- Widget which displays and allows removing reminders.
|
|
-- Points to /remindme for setting
|
|
/reminders clear
|
|
/reminders remove <reminder: acmpl>
|
|
-- Can we autocomplete an integer field?
|
|
/remindme at <time: time> <repeat every: acmpl str> <reminder: str>
|
|
/remindme in <days: int> <hours: int> <minutes: int> <repeat every: acmpl str> <reminder: str>
|
|
"""
|
|
from typing import Optional
|
|
import datetime as dt
|
|
from cachetools import TTLCache
|
|
|
|
import discord
|
|
from discord.ext import commands as cmds
|
|
from discord import app_commands as appcmds
|
|
from discord.app_commands import Transform
|
|
from discord.ui.select import select, SelectOption
|
|
|
|
from data import RowModel, Registry
|
|
from data.queries import ORDER
|
|
from data.columns import Integer, String, Timestamp, Bool
|
|
|
|
from meta import LionBot, LionCog, LionContext
|
|
from meta.app import shard_talk, appname_from_shard
|
|
from meta.logger import log_wrap, logging_context
|
|
|
|
from babel import ctx_translator, ctx_locale
|
|
|
|
from utils.lib import parse_duration, utc_now, strfdur, error_embed
|
|
from utils.monitor import TaskMonitor
|
|
from utils.transformers import DurationTransformer
|
|
from utils.ui import LeoUI, AButton, AsComponents
|
|
|
|
from . import babel, logger
|
|
|
|
_, _p, _np = babel._, babel._p, babel._np
|
|
|
|
|
|
class ReminderData(Registry, name='reminders'):
|
|
class Reminder(RowModel):
|
|
"""
|
|
Model representing a single reminder.
|
|
Since reminders are likely to change across shards,
|
|
does not use an explicit reference cache.
|
|
|
|
Schema
|
|
------
|
|
CREATE TABLE reminders(
|
|
reminderid SERIAL PRIMARY KEY,
|
|
userid BIGINT NOT NULL REFERENCES user_config(userid) ON DELETE CASCADE,
|
|
remind_at TIMESTAMP NOT NULL,
|
|
content TEXT NOT NULL,
|
|
message_link TEXT,
|
|
interval INTEGER,
|
|
created_at TIMESTAMP DEFAULT (now() at time zone 'utc'),
|
|
title TEXT,
|
|
footer TEXT
|
|
);
|
|
CREATE INDEX reminder_users ON reminders (userid);
|
|
"""
|
|
_tablename_ = 'reminders'
|
|
|
|
reminderid = Integer(primary=True)
|
|
|
|
userid = Integer() # User which created the reminder
|
|
remind_at = Timestamp() # Time when the reminder should be executed
|
|
content = String() # Content the user gave us to remind them
|
|
message_link = String() # Link to original confirmation message, for context
|
|
interval = Integer() # Repeat interval, if applicable
|
|
created_at = Timestamp() # Time when this reminder was originally created
|
|
title = String() # Title of the final reminder embed, only set in automated reminders
|
|
footer = String() # Footer of the final reminder embed, only set in automated reminders
|
|
failed = Bool() # Whether the reminder was already attempted and failed
|
|
|
|
@property
|
|
def timestamp(self) -> int:
|
|
"""
|
|
Time when this reminder should be executed (next) as an integer timestamp.
|
|
"""
|
|
return int(self.remind_at.timestamp())
|
|
|
|
@property
|
|
def embed(self) -> discord.Embed:
|
|
t = ctx_translator.get().t
|
|
|
|
embed = discord.Embed(
|
|
title=self.title or t(_p('reminder|embed', "You asked me to remind you!")),
|
|
colour=discord.Colour.orange(),
|
|
description=self.content,
|
|
timestamp=self.remind_at
|
|
)
|
|
|
|
if self.message_link:
|
|
embed.add_field(
|
|
name=t(_p('reminder|embed', "Context?")),
|
|
value="[{click}]({link})".format(
|
|
click=t(_p('reminder|embed', "Click Here")),
|
|
link=self.message_link
|
|
)
|
|
)
|
|
|
|
if self.interval:
|
|
embed.add_field(
|
|
name=t(_p('reminder|embed', "Next reminder")),
|
|
value=f"<t:{self.timestamp + self.interval}:R>"
|
|
)
|
|
|
|
if self.footer:
|
|
embed.set_footer(text=self.footer)
|
|
|
|
return embed
|
|
|
|
@property
|
|
def formatted(self):
|
|
"""
|
|
Single-line string format for the reminder, intended for an embed.
|
|
"""
|
|
t = ctx_translator.get().t
|
|
content = self.content
|
|
trunc_content = content[:50] + '...' * (len(content) > 50)
|
|
|
|
if interval := self.interval:
|
|
if not interval % (24 * 60 * 60):
|
|
# Exact day case
|
|
days = interval // (24 * 60 * 60)
|
|
repeat = t(_np(
|
|
'reminder|formatted|interval',
|
|
"Every day",
|
|
"Every `{days}` days",
|
|
days
|
|
)).format(days=days)
|
|
elif not interval % (60 * 60):
|
|
# Exact hour case
|
|
hours = interval // (60 * 60)
|
|
repeat = t(_np(
|
|
'reminder|formatted|interval',
|
|
"Every hour",
|
|
"Every `{hours}` hours",
|
|
hours
|
|
)).format(hours=hours)
|
|
else:
|
|
# Inexact interval, e.g 10m or 1h 10m.
|
|
# Use short duration format
|
|
repeat = t(_p(
|
|
'reminder|formatted|interval',
|
|
"Every `{duration}`"
|
|
)).format(duration=strfdur(interval))
|
|
|
|
repeat = f"({repeat})"
|
|
else:
|
|
repeat = ""
|
|
|
|
return "<t:{timestamp}:R>, [{content}]({jump_link}) {repeat}".format(
|
|
jump_link=self.message_link,
|
|
content=trunc_content,
|
|
timestamp=self.timestamp,
|
|
repeat=repeat
|
|
)
|
|
|
|
|
|
class ReminderMonitor(TaskMonitor[int]):
|
|
...
|
|
|
|
|
|
class Reminders(LionCog):
|
|
def __init__(self, bot: LionBot):
|
|
self.bot = bot
|
|
self.data = bot.db.load_registry(ReminderData())
|
|
|
|
# Whether this process should handle reminder execution
|
|
self.executor = (self.bot.shard_id == 0)
|
|
self.executor_name = appname_from_shard(0)
|
|
|
|
if self.executor:
|
|
self.monitor: Optional[ReminderMonitor] = ReminderMonitor(executor=self.execute_reminder)
|
|
else:
|
|
self.monitor = None
|
|
|
|
self.talk_reload = shard_talk.register_route('reload_reminders')(self.reload_reminders)
|
|
self.talk_schedule = shard_talk.register_route('schedule_reminders')(self.schedule_reminders)
|
|
self.talk_cancel = shard_talk.register_route('cancel_reminders')(self.cancel_reminders)
|
|
|
|
# Short term userid -> list[Reminder] cache, mainly for autocomplete
|
|
self._user_reminder_cache: TTLCache[int, list[ReminderData.Reminder]] = TTLCache(1000, ttl=60)
|
|
self._active_reminderlists: dict[int, ReminderListUI] = {}
|
|
|
|
async def cog_load(self):
|
|
await self.data.init()
|
|
|
|
if self.executor:
|
|
# Attach and populate the reminder monitor
|
|
self.monitor = ReminderMonitor(executor=self.execute_reminder)
|
|
await self.reload_reminders()
|
|
|
|
if self.bot.is_ready:
|
|
self.monitor.start()
|
|
|
|
@LionCog.listener()
|
|
async def on_ready(self):
|
|
if self.executor and not self.monitor._monitor_task:
|
|
# Start firing reminders
|
|
self.monitor.start()
|
|
|
|
async def get_reminders_for(self, userid: int):
|
|
"""
|
|
Retrieve a list of reminders for the given userid, using the cache.
|
|
"""
|
|
reminders = self._user_reminder_cache.get(userid, None)
|
|
if reminders is None:
|
|
reminders = await self.data.Reminder.fetch_where(
|
|
userid=userid
|
|
).order_by(self.data.Reminder.created_at, ORDER.ASC)
|
|
self._user_reminder_cache[userid] = reminders
|
|
return reminders
|
|
|
|
async def dispatch_update_for(self, userid: int):
|
|
"""
|
|
Announce that the given user's reminders have changed.
|
|
|
|
This triggers update of the cog reminder cache, and a reload of any active reminder list UIs.
|
|
"""
|
|
self._user_reminder_cache.pop(userid, None)
|
|
if userid in self._active_reminderlists:
|
|
await self._active_reminderlists[userid].refresh()
|
|
|
|
async def reload_reminders(self):
|
|
"""
|
|
Refresh reminder data and reminder tasks.
|
|
"""
|
|
if not self.executor:
|
|
raise ValueError("Only the executor shard can reload reminders!")
|
|
# Load all reminder tasks
|
|
reminders = await self.data.Reminder.fetch_where(failed=None)
|
|
tasks = [(r.reminderid, r.timestamp) for r in reminders]
|
|
self.monitor.set_tasks(*tasks)
|
|
logger.info(
|
|
f"Reloaded ReminderMonitor with {len(tasks)} active reminders."
|
|
)
|
|
|
|
async def cancel_reminders(self, *reminderids):
|
|
"""
|
|
ShardTalk Route.
|
|
Cancel the given reminderids in the ReminderMonitor.
|
|
"""
|
|
if not self.executor:
|
|
raise ValueError("Only the executor shard can cancel scheduled reminders!")
|
|
# If we are the executor shard, we know the monitor is loaded
|
|
# If reminders have not yet been loaded, cancelling is a no-op
|
|
# Since reminder loading is synchronous, we cannot get in a race state with loading
|
|
self.monitor.cancel_tasks(*reminderids)
|
|
logger.debug(
|
|
f"Cancelled reminders: {reminderids}",
|
|
)
|
|
|
|
async def schedule_reminders(self, *reminderids):
|
|
"""
|
|
ShardTalk Route.
|
|
Schedule the given new reminderids in the ReminderMonitor.
|
|
"""
|
|
if not self.executor:
|
|
raise ValueError("Only the executor shard can schedule reminders!")
|
|
# We refetch here to make sure the reminders actually exist
|
|
reminders = await self.data.Reminder.fetch_where(reminderid=reminderids)
|
|
self.monitor.schedule_tasks(*((reminder.reminderid, reminder.timestamp) for reminder in reminders))
|
|
logger.debug(
|
|
f"Scheduled new reminders: {tuple(reminder.reminderid for reminder in reminders)}",
|
|
)
|
|
|
|
async def execute_reminder(self, reminderid):
|
|
"""
|
|
Send the reminder with the given reminderid.
|
|
|
|
This should in general only be executed from the executor shard,
|
|
through a ReminderMonitor instance.
|
|
"""
|
|
with logging_context(action='Send Reminder', context=f"rid: {reminderid}"):
|
|
reminder = await self.data.Reminder.fetch(reminderid)
|
|
if reminder is None:
|
|
logger.warning(
|
|
f"Attempted to execute a reminder <rid: {reminderid}> that no longer exists!"
|
|
)
|
|
return
|
|
|
|
try:
|
|
# Try and find the user
|
|
userid = reminder.userid
|
|
if not (user := self.bot.get_user(userid)):
|
|
user = await self.bot.fetch_user(userid)
|
|
|
|
# Set the locale variables
|
|
locale = await self.bot.get_cog('BabelCog').get_user_locale(userid)
|
|
ctx_locale.set(locale)
|
|
ctx_translator.set(self.bot.translator)
|
|
|
|
# Build the embed
|
|
embed = reminder.embed
|
|
|
|
# Attempt to send to user
|
|
# TODO: Consider adding a View to this, for cancelling a repeated reminder or showing reminders
|
|
await user.send(embed=embed)
|
|
|
|
# Update the data as required
|
|
if reminder.interval:
|
|
now = utc_now()
|
|
# Use original reminder time to calculate repeat, avoiding drift
|
|
next_time = reminder.remind_at + dt.timedelta(seconds=reminder.interval)
|
|
# Skip any expired repeats, to avoid spamming requests after downtime
|
|
# TODO: Is this actually dst safe?
|
|
while next_time.timestamp() <= now.timestamp():
|
|
next_time + dt.timedelta(seconds=reminder.interval)
|
|
await reminder.update(remind_at=next_time)
|
|
self.monitor.schedule_task(reminder.reminderid, reminder.timestamp)
|
|
logger.debug(
|
|
f"Executed reminder <rid: {reminder.reminderid}> and scheduled repeat at {next_time}."
|
|
)
|
|
else:
|
|
await reminder.delete()
|
|
logger.debug(
|
|
f"Executed reminder <rid: {reminder.reminderid}>."
|
|
)
|
|
except discord.HTTPException:
|
|
await reminder.update(failed=True)
|
|
logger.debug(
|
|
f"Reminder <rid: {reminder.reminderid}> could not be sent.",
|
|
exc_info=True
|
|
)
|
|
except Exception:
|
|
await reminder.update(failed=True)
|
|
logger.exception(
|
|
f"Reminder <rid: {reminder.reminderid}> failed for an unknown reason!"
|
|
)
|
|
finally:
|
|
# Dispatch for analytics
|
|
self.bot.dispatch('reminder_sent', reminder)
|
|
|
|
@cmds.hybrid_group(
|
|
name=_p('cmd:reminders', "reminders")
|
|
)
|
|
async def reminders_group(self, ctx: LionContext):
|
|
pass
|
|
|
|
@reminders_group.command(
|
|
# No help string
|
|
name=_p('cmd:reminders_show', "show"),
|
|
description=_p(
|
|
'cmd:reminders_show|desc',
|
|
"Display your current reminders."
|
|
)
|
|
)
|
|
async def cmd_reminders_show(self, ctx: LionContext):
|
|
# No help string
|
|
"""
|
|
Display the reminder widget for this user.
|
|
"""
|
|
t = self.bot.translator.t
|
|
if not ctx.interaction:
|
|
return
|
|
|
|
if ctx.author.id in self._active_reminderlists:
|
|
await self._active_reminderlists[ctx.author.id].close(
|
|
msg=t(_p(
|
|
'cmd:reminders_show|close_elsewhere',
|
|
"Closing since the list was opened elsewhere."
|
|
))
|
|
)
|
|
ui = ReminderListUI(self.bot, ctx.author)
|
|
try:
|
|
self._active_reminderlists[ctx.author.id] = ui
|
|
await ui.run(ctx.interaction)
|
|
await ui.wait()
|
|
finally:
|
|
self._active_reminderlists.pop(ctx.author.id, None)
|
|
|
|
@reminders_group.command(
|
|
name=_p('cmd:reminders_clear', "clear"),
|
|
description=_p(
|
|
'cmd:reminders_clear|desc',
|
|
"Clear your reminder list."
|
|
)
|
|
)
|
|
async def cmd_reminders_clear(self, ctx: LionContext):
|
|
# No help string
|
|
"""
|
|
Confirm and then clear all the reminders for this user.
|
|
"""
|
|
if not ctx.interaction:
|
|
return
|
|
|
|
t = self.bot.translator.t
|
|
reminders = await self.data.Reminder.fetch_where(userid=ctx.author.id)
|
|
if not reminders:
|
|
await ctx.reply(
|
|
embed=discord.Embed(
|
|
description=t(_p(
|
|
'cmd:reminders_clear|error:no_reminders',
|
|
"You have no reminders to clear!"
|
|
)),
|
|
colour=discord.Colour.brand_red()
|
|
),
|
|
ephemeral=True
|
|
)
|
|
return
|
|
|
|
embed = discord.Embed(
|
|
title=t(_p('cmd:reminders_clear|confirm|title', "Are You Sure?")),
|
|
description=t(_np(
|
|
'cmd:reminders_clear|confirm|desc',
|
|
"Are you sure you want to delete your `{count}` reminder?",
|
|
"Are you sure you want to clear your `{count}` reminders?",
|
|
len(reminders)
|
|
)).format(count=len(reminders))
|
|
)
|
|
|
|
@AButton(label=t(_p('cmd:reminders_clear|confirm|button:yes', "Yes, clear my reminders")))
|
|
async def confirm(interaction, press):
|
|
await interaction.response.defer()
|
|
reminders = await self.data.Reminder.table.delete_where(userid=ctx.author.id)
|
|
await self.talk_cancel(*(r['reminderid'] for r in reminders)).send(self.executor_name, wait_for_reply=False)
|
|
await ctx.interaction.edit_original_response(
|
|
embed=discord.Embed(
|
|
description=t(_p(
|
|
'cmd:reminders_clear|success|desc',
|
|
"Your reminders have been cleared!"
|
|
)),
|
|
colour=discord.Colour.brand_green()
|
|
),
|
|
view=None
|
|
)
|
|
await press.view.close()
|
|
await self.dispatch_update_for(ctx.author.id)
|
|
|
|
@AButton(label=t(_p('cmd:reminders_clear|confirm|button:cancel', "Cancel")))
|
|
async def deny(interaction, press):
|
|
await interaction.response.defer()
|
|
await ctx.interaction.delete_original_response()
|
|
await press.view.close()
|
|
|
|
components = AsComponents(confirm, deny)
|
|
await ctx.interaction.response.send_message(embed=embed, view=components, ephemeral=True)
|
|
|
|
@reminders_group.command(
|
|
name=_p('cmd:reminders_cancel', "cancel"),
|
|
description=_p(
|
|
'cmd:reminders_cancel|desc',
|
|
"Cancel a single reminder. Use the menu in \"reminder show\" to cancel multiple reminders."
|
|
)
|
|
)
|
|
@appcmds.rename(
|
|
reminder=_p('cmd:reminders_cancel|param:reminder', 'reminder')
|
|
)
|
|
@appcmds.describe(
|
|
reminder=_p(
|
|
'cmd:reminders_cancel|param:reminder|desc',
|
|
"Start typing, then select a reminder to cancel."
|
|
)
|
|
)
|
|
async def cmd_reminders_cancel(self, ctx: LionContext, reminder: str):
|
|
# No help string
|
|
"""
|
|
Cancel a previously scheduled reminder.
|
|
|
|
Autocomplete lets the user select their reminder by number or truncated content.
|
|
Need to handle the case where reminderid is that truncated content.
|
|
"""
|
|
t = self.bot.translator.t
|
|
reminders = await self.get_reminders_for(ctx.author.id)
|
|
|
|
# Guard against no reminders
|
|
if not reminders:
|
|
await ctx.error_reply(
|
|
t(_p(
|
|
'cmd:reminders_cancel|error:no_reminders',
|
|
"There are no reminders to cancel!"
|
|
))
|
|
)
|
|
return
|
|
|
|
# Now attempt to parse reminder input
|
|
if reminder.startswith('rid:') and reminder[4:].isdigit():
|
|
# Assume reminderid, probably selected through autocomplete
|
|
rid = int(reminder[4:])
|
|
rem = next((rem for rem in reminders if rem.reminderid == rid), None)
|
|
elif reminder.strip('[] ').isdigit():
|
|
# Assume user reminder index
|
|
# Not strictly threadsafe, but should be okay 90% of the time
|
|
lid = int(reminder)
|
|
rem = next((rem for i, rem in enumerate(reminders, start=1) if i == lid), None)
|
|
else:
|
|
# Assume partial string from a reminder
|
|
partial = reminder
|
|
rem = next((rem for rem in reminders if partial in rem.content), None)
|
|
|
|
if rem is None:
|
|
await ctx.error_reply(
|
|
t(_p(
|
|
'cmd:reminders_cancel|error:no_match',
|
|
"I am not sure which reminder you want to cancel. "
|
|
"Please try again, selecting a reminder from the list of choices."
|
|
))
|
|
)
|
|
return
|
|
|
|
# At this point we have a valid reminder to cancel
|
|
await rem.delete()
|
|
await self.talk_cancel(rem.reminderid).send(self.executor_name, wait_for_reply=False)
|
|
await ctx.reply(
|
|
embed=discord.Embed(
|
|
description=t(_p(
|
|
'cmd:reminders_cancel|embed:success|desc',
|
|
"Reminder successfully cancelled."
|
|
)),
|
|
colour=discord.Colour.brand_green()
|
|
),
|
|
ephemeral=True
|
|
)
|
|
await self.dispatch_update_for(ctx.author.id)
|
|
|
|
@cmd_reminders_cancel.autocomplete('reminder')
|
|
async def cmd_reminders_cancel_acmpl_reminderid(self, interaction: discord.Interaction, partial: str):
|
|
t = self.bot.translator.t
|
|
|
|
reminders = await self.get_reminders_for(interaction.user.id)
|
|
if not reminders:
|
|
# Nothing to cancel case
|
|
name = t(_p(
|
|
'cmd:reminders_cancel|acmpl:reminder|error:no_reminders',
|
|
"There are no reminders to cancel!"
|
|
))
|
|
value = 'None'
|
|
choices = [
|
|
appcmds.Choice(name=name, value=value)
|
|
]
|
|
else:
|
|
# Build list of reminder strings
|
|
strings = []
|
|
for pos, reminder in enumerate(reminders, start=1):
|
|
strings.append(
|
|
(f"[{pos}] {reminder.content}", reminder)
|
|
)
|
|
# Extract matches
|
|
matches = [string for string in strings if partial.lower() in string[0].lower()]
|
|
|
|
if matches:
|
|
# Build list of valid choices
|
|
choices = [
|
|
appcmds.Choice(
|
|
name=string[0],
|
|
value=f"rid:{string[1].reminderid}"
|
|
)
|
|
for string in matches
|
|
]
|
|
else:
|
|
choices = [
|
|
appcmds.Choice(
|
|
name=t(_p(
|
|
'cmd:reminders_cancel|acmpl:reminder|error:no_matches',
|
|
"You do not have any reminders matching \"{partial}\""
|
|
)).format(partial=partial),
|
|
value=partial
|
|
)
|
|
]
|
|
return choices
|
|
|
|
@cmds.hybrid_group(
|
|
name=_p('cmd:remindme', "remindme")
|
|
)
|
|
async def remindme_group(self, ctx: LionContext):
|
|
# Base command group for scheduling reminders.
|
|
pass
|
|
|
|
# TODO: Waiting until we have timezone data and user time methods.
|
|
# @remindme_group.command(
|
|
# name=_p('cmd:remindme_at', "at"),
|
|
# description=_p(
|
|
# 'cmd:remindme_at|desc',
|
|
# "Schedule a reminder for a particular time."
|
|
# )
|
|
# )
|
|
# @appcmds.rename(
|
|
# time=_p('cmd:remindme_at|param:time', "time"),
|
|
# reminder=_p('cmd:remindme_at|param:reminder', "reminder"),
|
|
# every=_p('cmd:remindme_at|param:every', "every"),
|
|
# )
|
|
# @appcmds.describe(
|
|
# time=_p('cmd:remindme_at|param:time|desc', "When you want to be reminded.."),
|
|
# reminder=_p('cmd:remindme_at|param:reminder|desc', "What should the reminder be?"),
|
|
# every=_p('cmd:remindme_at|param:every|desc', "How often to repeat this reminder.")
|
|
# )
|
|
# async def cmd_remindme_at(
|
|
# self,
|
|
# ctx: LionContext,
|
|
# time: str,
|
|
# reminder: str,
|
|
# every: Optional[Transform[int, DurationTransformer(60)]] = None
|
|
# ):
|
|
# ...
|
|
|
|
@remindme_group.command(
|
|
name=_p('cmd:remindme_in', "in"),
|
|
description=_p(
|
|
'cmd:remindme_in|desc',
|
|
"Schedule a reminder for a given amount of time in the future."
|
|
)
|
|
)
|
|
@appcmds.rename(
|
|
time=_p('cmd:remindme_in|param:time', "time"),
|
|
reminder=_p('cmd:remindme_in|param:reminder', "reminder"),
|
|
every=_p('cmd:remindme_in|param:every', "every"),
|
|
)
|
|
@appcmds.describe(
|
|
time=_p('cmd:remindme_in|param:time|desc', "How far into the future to set the reminder (e.g. 1 day 10h 5m)."),
|
|
reminder=_p('cmd:remindme_in|param:reminder|desc', "What should the reminder be?"),
|
|
every=_p('cmd:remindme_in|param:every|desc', "How often to repeat this reminder. (e.g. 1 day, or 2h)")
|
|
)
|
|
async def cmd_remindme_in(
|
|
self,
|
|
ctx: LionContext,
|
|
time: Transform[int, DurationTransformer(60)],
|
|
reminder: appcmds.Range[str, 1, 1000], # TODO: Maximum length 1000?
|
|
every: Optional[Transform[int, DurationTransformer(60)]] = None
|
|
):
|
|
t = self.bot.translator.t
|
|
reminders = await self.data.Reminder.fetch_where(userid=ctx.author.id)
|
|
|
|
# Guard against too many reminders
|
|
if len(reminders) > 25:
|
|
await ctx.error_reply(
|
|
embed=error_embed(
|
|
t(_p(
|
|
'cmd_remindme_in|error:too_many|desc',
|
|
"Sorry, you have reached the maximum of `25` reminders!"
|
|
)),
|
|
title=t(_p(
|
|
'cmd_remindme_in|error:too_many|title',
|
|
"Could not create reminder!"
|
|
))
|
|
),
|
|
ephemeral=True
|
|
)
|
|
return
|
|
|
|
# Guard against too frequent reminders
|
|
if every is not None and every < 600:
|
|
await ctx.reply(
|
|
embed=error_embed(
|
|
t(_p(
|
|
'cmd_remindme_in|error:too_fast|desc',
|
|
"You cannot set a repeating reminder with a period less than 10 minutes."
|
|
)),
|
|
title=t(_p(
|
|
'cmd_remindme_in|error:too_fast|title',
|
|
"Could not create reminder!"
|
|
))
|
|
),
|
|
ephemeral=True
|
|
)
|
|
return
|
|
|
|
# Everything seems to be in order
|
|
# Create the reminder
|
|
now = utc_now()
|
|
rem = await self.data.Reminder.create(
|
|
userid=ctx.author.id,
|
|
remind_at=now + dt.timedelta(seconds=time),
|
|
content=reminder,
|
|
message_link=ctx.message.jump_url,
|
|
interval=every,
|
|
created_at=now
|
|
)
|
|
|
|
# Reminder created, request scheduling from executor shard
|
|
await self.talk_schedule(rem.reminderid).send(self.executor_name, wait_for_reply=False)
|
|
|
|
# TODO Add repeat to description
|
|
embed = discord.Embed(
|
|
title=t(_p(
|
|
'cmd:remindme_in|success|title',
|
|
"Reminder Set {timestamp}"
|
|
)).format(timestamp=f"<t:{rem.timestamp}:R>"),
|
|
description=f"> {rem.content}"
|
|
)
|
|
await ctx.reply(
|
|
embed=embed,
|
|
ephemeral=True
|
|
)
|
|
await self.dispatch_update_for(ctx.author.id)
|
|
|
|
|
|
class ReminderListUI(LeoUI):
|
|
def __init__(self, bot: LionBot, user: discord.User, **kwargs):
|
|
super().__init__(**kwargs)
|
|
|
|
self.bot = bot
|
|
self.user = user
|
|
|
|
cog = bot.get_cog('Reminders')
|
|
if cog is None:
|
|
raise ValueError("Cannot create a ReminderUI without the Reminder cog!")
|
|
self.cog: Reminders = cog
|
|
self.userid = user.id
|
|
|
|
# Original interaction which sent the UI message
|
|
# Since this is an ephemeral UI, we need this to update and delete
|
|
self._interaction: Optional[discord.Interaction] = None
|
|
self._reminders = []
|
|
|
|
async def cleanup(self):
|
|
# Cleanup after an ephemeral UI
|
|
# Just close if possible
|
|
if self._interaction and not self._interaction.is_expired():
|
|
try:
|
|
await self._interaction.delete_original_response()
|
|
except discord.HTTPException:
|
|
pass
|
|
|
|
@select()
|
|
async def select_remove(self, interaction: discord.Interaction, selection):
|
|
"""
|
|
Select a number of reminders to delete.
|
|
"""
|
|
await interaction.response.defer()
|
|
# Hopefully this is a list of reminderids
|
|
values = selection.values
|
|
# Delete from data
|
|
await self.cog.data.Reminder.table.delete_where(reminderid=values)
|
|
# Send cancellation
|
|
await self.cog.talk_cancel(*values).send(self.cog.executor_name, wait_for_reply=False)
|
|
self.cog._user_reminder_cache.pop(self.userid, None)
|
|
await self.refresh()
|
|
|
|
async def refresh_select_remove(self):
|
|
"""
|
|
Refresh the select remove component from current state.
|
|
"""
|
|
t = self.bot.translator.t
|
|
|
|
self.select_remove.placeholder = t(_p(
|
|
'ui:reminderlist|select:remove|placeholder',
|
|
"Select to cancel."
|
|
))
|
|
self.select_remove.options = [
|
|
SelectOption(
|
|
label=f"[{i}] {reminder.content[:50] + '...' * (len(reminder.content) > 50)}",
|
|
value=reminder.reminderid,
|
|
emoji=self.bot.config.emojis.getemoji('clock')
|
|
)
|
|
for i, reminder in enumerate(self._reminders, start=1)
|
|
]
|
|
self.select_remove.min_values = 1
|
|
self.select_remove.max_values = len(self._reminders)
|
|
|
|
async def refresh_reminders(self):
|
|
self._reminders = await self.cog.get_reminders_for(self.userid)
|
|
|
|
async def refresh(self):
|
|
"""
|
|
Refresh the UI message and components.
|
|
"""
|
|
if not self._interaction:
|
|
raise ValueError("Cannot refresh ephemeral UI without an origin interaction!")
|
|
|
|
await self.refresh_reminders()
|
|
await self.refresh_select_remove()
|
|
embed = await self.build_embed()
|
|
|
|
if self._reminders:
|
|
self.set_layout((self.select_remove,))
|
|
else:
|
|
self.set_layout()
|
|
|
|
try:
|
|
if not self._interaction.response.is_done():
|
|
# Fresh message
|
|
await self._interaction.response.send_message(embed=embed, view=self, ephemeral=True)
|
|
else:
|
|
# Update existing message
|
|
await self._interaction.edit_original_response(embed=embed, view=self)
|
|
except discord.HTTPException:
|
|
await self.close()
|
|
|
|
async def run(self, interaction: discord.Interaction):
|
|
"""
|
|
Run the UI responding to the given interaction.
|
|
"""
|
|
self._interaction = interaction
|
|
await self.refresh()
|
|
|
|
async def build_embed(self):
|
|
"""
|
|
Build the reminder list embed.
|
|
"""
|
|
t = self.bot.translator.t
|
|
reminders = self._reminders
|
|
|
|
if reminders:
|
|
lines = []
|
|
num_len = len(str(len(reminders)))
|
|
for i, reminder in enumerate(reminders):
|
|
lines.append(
|
|
"`[{:<{}}]` | {}".format(
|
|
i+1,
|
|
num_len,
|
|
reminder.formatted
|
|
)
|
|
)
|
|
description = '\n'.join(lines)
|
|
|
|
embed = discord.Embed(
|
|
description=description,
|
|
colour=discord.Colour.orange(),
|
|
timestamp=utc_now()
|
|
).set_author(
|
|
name=t(_p(
|
|
'ui:reminderlist|embed:list|author',
|
|
"{name}'s reminders"
|
|
)).format(name=self.user.display_name),
|
|
icon_url=self.user.avatar
|
|
).set_footer(
|
|
text=t(_p(
|
|
'ui:reminderlist|embed:list|footer',
|
|
"Click a reminder twice to jump to the context!"
|
|
))
|
|
)
|
|
else:
|
|
embed = discord.Embed(
|
|
description=t(_p(
|
|
'ui:reminderlist|embed:no_reminders|desc',
|
|
"You have no reminders to display!\n"
|
|
"Use {remindme} to create a new reminder."
|
|
)).format(
|
|
remindme=self.bot.core.cmd_name_cache['remindme'].mention,
|
|
)
|
|
)
|
|
|
|
return embed
|