new global models

.gitignore

@@ -2,4 +2,6 @@
 .env
 /venv
 .cargo
+assets
+out.json
 /.idea

Cargo.toml

@@ -1,58 +1,32 @@
 [package]
-name = "reminder-rs"
-version = "1.6.40"
-authors = ["Jude Southworth <judesouthworth@pm.me>"]
-edition = "2021"
-license = "AGPL-3.0 only"
-description = "Reminder Bot for Discord, now in Rust"
+name = "reminder_rs"
+version = "1.6.0"
+authors = ["jellywx <judesouthworth@pm.me>"]
+edition = "2018"
+workspaces = [".", "postman", "web", "entity", "migration"]
 
 [dependencies]
-poise = "0.5"
+poise = "0.2"
 dotenv = "0.15"
 tokio = { version = "1", features = ["process", "full"] }
 reqwest = "0.11"
-lazy-regex = "3.0"
-regex = "1.9"
+regex = "1.4"
 log = "0.4"
-env_logger = "0.10"
+env_logger = "0.8"
 chrono = "0.4"
-chrono-tz = { version = "0.8", features = ["serde"] }
+chrono-tz = { version = "0.5", features = ["serde"] }
 lazy_static = "1.4"
 num-integer = "0.1"
 serde = "1.0"
 serde_json = "1.0"
 serde_repr = "0.1"
-rmp-serde = "1.1"
-rand = "0.8"
+rmp-serde = "0.15"
+rand = "0.7"
 levenshtein = "1.0"
-sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "macros", "mysql", "bigdecimal", "chrono", "migrate"]}
-base64 = "0.21.0"
+base64 = "0.13.0"
 
 [dependencies.postman]
 path = "postman"
 
 [dependencies.reminder_web]
 path = "web"
-
-[package.metadata.deb]
-depends = "$auto, python3-dateparser (>= 1.0.0)"
-suggests = "mysql-server-8.0, nginx"
-maintainer-scripts = "debian"
-assets = [
-    ["target/release/reminder-rs", "usr/bin/reminder-rs", "755"],
-    ["conf/default.env", "etc/reminder-rs/config.env", "600"],
-    ["conf/Rocket.toml", "etc/reminder-rs/Rocket.toml", "600"],
-    ["web/static/**/*", "lib/reminder-rs/static", "644"],
-    ["web/templates/**/*", "lib/reminder-rs/templates", "644"],
-    ["healthcheck", "lib/reminder-rs/healthcheck", "755"],
-    ["cron.d/reminder_health", "etc/cron.d/reminder_health", "644"],
-#    ["nginx/reminder-rs", "etc/nginx/sites-available/reminder-rs", "755"]
-]
-conf-files = [
-    "/etc/reminder-rs/config.env",
-    "/etc/reminder-rs/Rocket.toml",
-]
-
-[package.metadata.deb.systemd-units]
-unit-scripts = "systemd"
-start = false

Containerfile

@@ -1,9 +0,0 @@
-FROM ubuntu:20.04
-
-ENV RUSTUP_HOME=/usr/local/rustup \
-    CARGO_HOME=/usr/local/cargo \
-    PATH=/usr/local/cargo/bin:$PATH
-
-RUN apt update && DEBIAN_FRONTEND=noninteractive TZ=Etc/UTC apt install -y gcc gcc-multilib cmake pkg-config libssl-dev curl mysql-client-8.0
-RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --no-modify-path --profile minimal --default-toolchain nightly
-RUN cargo install cargo-deb

README.md

@@ -7,36 +7,25 @@ reminders are paid on the hosted version of the bot. Keep reading if you want to
 
 You'll need rustc and cargo for compilation. To run, you'll need Python 3 still (due to no suitable replacement for dateparser in Rust)
 
-### Build APT package
+### Compiling
+Install build requirements: 
+`sudo apt install gcc gcc-multilib cmake libssl-dev build-essential`
 
-Recommended method.
+Install Rust from https://rustup.rs
 
-By default, this builds targeting Ubuntu 20.04. Modify the Containerfile if you wish to target a different platform. These instructions are written using `podman`, but `docker` should work too.
+Reminder Bot can then be built by running `cargo build --release` in the top level directory. It is necessary to create a 
+folder called 'assets' containing an image file with its name specified in the environment as `WEBHOOK_AVATAR`, of 
+dimensions 128x128px to be used as the webhook avatar.
 
-1. Install container software: `sudo apt install podman`.
-2. Install database server: `sudo apt install mysql-server-8.0`. Create a database called `reminders`
-3. Install SQLx CLI: `cargo install sqlx-cli`
-4. From the source code directory, execute `sqlx migrate run`
-5. Build container image: `podman build -t reminder-rs .`
-6. Build with podman: `podman run --rm --network=host -v "$PWD":/mnt -w /mnt -e "DATABASE_URL=mysql://user@localhost/reminders" reminder-rs cargo deb` 
+#### Compilation environment variables
+These environment variables must be provided when compiling the bot
+* `DATABASE_URL` - the URL of your MySQL database (`mysql://user[:password]@domain/database`)
+* `WEBHOOK_AVATAR` - accepts the name of an image file located in `$CARGO_MANIFEST_DIR/assets/` to be used as the avatar when creating webhooks. **IMPORTANT: image file must be 128x128 or smaller in size**
 
+### Setting up Python
+Reminder Bot by default looks for a venv within it's working directory to run Python out of. To set up a venv, install `python3-venv` and run `python3 -m venv venv`. Then, run `source venv/bin/activate` to activate the venv, and do `pip install dateparser` to install the required library
 
-### Compiling for other target
-
-1. Install requirements: 
-`sudo apt install gcc gcc-multilib cmake libssl-dev build-essential python3-dateparser`
-2. Install rustup from https://rustup.rs
-3. Install the nightly toolchain: `rustup toolchain default nightly`
-4. Install database server: `sudo apt install mysql-server-8.0`. Create a database called `reminders`.
-5. Install `sqlx-cli`: `cargo install sqlx-cli`.
-6. Run migrations: `sqlx migrate run`.
-7. Set environment variables:
-   * `DATABASE_URL` - the URL of your MySQL database (`mysql://user[:password]@domain/database`)
-8. Build: `cargo build --release`
-
-
-### Configuring
-
+### Environment Variables
 Reminder Bot reads a number of environment variables. Some are essential, and others have hardcoded fallbacks. Environment variables can be loaded from a .env file in the working directory.
 
 __Required Variables__
@@ -48,5 +37,10 @@ __Other Variables__
 * `LOCAL_TIMEZONE` - default `UTC`, necessary for calculations in the natural language processor
 * `SUBSCRIPTION_ROLES` - default `None`, accepts a list of Discord role IDs that are given to subscribed users
 * `CNC_GUILD` - default `None`, accepts a single Discord guild ID for the server that the subscription roles belong to
-* `PYTHON_LOCATION` - default `/usr/bin/python3`. Can be changed if your Python executable is located somewhere else
+* `PYTHON_LOCATION` - default `venv/bin/python3`. Can be changed if your Python executable is located somewhere else
 * `THEME_COLOR` - default `8fb677`. Specifies the hex value of the color to use on info message embeds 
+* `DM_ENABLED` - default `1`, if `1`, Reminder Bot will respond to direct messages
+
+### Todo List
+
+* Convert aliases to macros

Rocket.toml

@@ -1,6 +1,6 @@
 [default]
 address = "0.0.0.0"
-port = 18920
+port = 5000
 template_dir = "web/templates"
 limits = { json = "10MiB" }
 
@@ -11,18 +11,18 @@ secret_key = "tR8krio5FXTnnyIZNiJDXPondz0kI1v6X6BXZcBGIRY="
 certs = "web/private/rsa_sha256_cert.pem"
 key = "web/private/rsa_sha256_key.pem"
 
-[debug.rsa_sha256.tls]
+[rsa_sha256.tls]
 certs = "web/private/rsa_sha256_cert.pem"
 key = "web/private/rsa_sha256_key.pem"
 
-[debug.ecdsa_nistp256_sha256.tls]
+[ecdsa_nistp256_sha256.tls]
 certs = "web/private/ecdsa_nistp256_sha256_cert.pem"
 key = "web/private/ecdsa_nistp256_sha256_key_pkcs8.pem"
 
-[debug.ecdsa_nistp384_sha384.tls]
+[ecdsa_nistp384_sha384.tls]
 certs = "web/private/ecdsa_nistp384_sha384_cert.pem"
 key = "web/private/ecdsa_nistp384_sha384_key_pkcs8.pem"
 
-[debug.ed25519.tls]
+[ed25519.tls]
 certs = "web/private/ed25519_cert.pem"
 key = "eb/private/ed25519_key.pem"

build.rs

@@ -1,3 +0,0 @@
-fn main() {
-    println!("cargo:rerun-if-changed=migrations");
-}

conf/Rocket.toml

@@ -1,8 +0,0 @@
-[default]
-address = "127.0.0.1"
-port = 18920
-template_dir = "/lib/reminder-rs/templates"
-limits = { json = "10MiB" }
-
-[release]
-# secret_key = ""

conf/default.env

@@ -1,19 +0,0 @@
-DATABASE_URL=
-
-DISCORD_TOKEN=
-PATREON_GUILD_ID=
-PATREON_ROLE_ID=
-
-LOCAL_TIMEZONE=
-MIN_INTERVAL=
-PYTHON_LOCATION=/usr/bin/python3
-DONTRUN=
-SECRET_KEY=
-
-REMIND_INTERVAL=
-OAUTH2_DISCORD_CALLBACK=
-OAUTH2_CLIENT_ID=
-OAUTH2_CLIENT_SECRET=
-
-REPORT_EMAIL=
-LOG_TO_DATABASE=1

cron.d/reminder_health

@@ -1 +0,0 @@
-*/10 * * * * reminder /lib/reminder-rs/healthcheck

debian/postinst

@@ -1,9 +0,0 @@
-#!/bin/bash
-
-set -e
-
-id -u reminder &>/dev/null || useradd -r -M reminder
-
-chown -R reminder /etc/reminder-rs
-
-#DEBHELPER#

debian/postrm

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-set -e
-
-id -u reminder &>/dev/null || userdel reminder
-
-#DEBHELPER#

healthcheck

@@ -1,13 +0,0 @@
-#!/bin/bash
-
-export $(grep -v '^#' /etc/reminder-rs/config.env | xargs -d '\n')
-
-REGEX='mysql://([A-Za-z]+)@(.+)/(.+)'
-[[ $DATABASE_URL =~ $REGEX ]]
-
-VAR=$(mysql -u "${BASH_REMATCH[1]}" -h "${BASH_REMATCH[2]}" -N -D "${BASH_REMATCH[3]}" -e "SELECT COUNT(1) FROM reminders WHERE utc_time < NOW() - INTERVAL 10 MINUTE AND enabled = 1 AND status = 'pending'")
-
-if [ "$VAR" -gt 0 ]
-then
-  echo "This is to inform that there is a reminder backlog which must be resolved." | mail -s "Backlog: $VAR" "$REPORT_EMAIL"
-fi

migrations/20210603000000_initial.sql

@@ -1,229 +0,0 @@
-SET FOREIGN_KEY_CHECKS=0;
-
-CREATE TABLE guilds (
-    id INT UNSIGNED UNIQUE NOT NULL AUTO_INCREMENT,
-    guild BIGINT UNSIGNED UNIQUE NOT NULL,
-
-    name VARCHAR(100),
-
-    prefix VARCHAR(5) DEFAULT '$' NOT NULL,
-    timezone VARCHAR(32) DEFAULT 'UTC' NOT NULL,
-
-    default_channel_id INT UNSIGNED,
-    default_username VARCHAR(32) DEFAULT 'Reminder' NOT NULL,
-    default_avatar VARCHAR(512) DEFAULT 'https://raw.githubusercontent.com/reminder-bot/logos/master/Remind_Me_Bot_Logo_PPic.jpg' NOT NULL,
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (default_channel_id) REFERENCES channels(id) ON DELETE SET NULL
-);
-
-CREATE TABLE channels (
-    id INT UNSIGNED UNIQUE NOT NULL AUTO_INCREMENT,
-    channel BIGINT UNSIGNED UNIQUE NOT NULL,
-
-    name VARCHAR(100),
-
-    nudge SMALLINT NOT NULL DEFAULT 0,
-    blacklisted BOOL NOT NULL DEFAULT FALSE,
-
-    webhook_id BIGINT UNSIGNED UNIQUE,
-    webhook_token TEXT,
-
-    paused BOOL NOT NULL DEFAULT 0,
-    paused_until TIMESTAMP,
-
-    guild_id INT UNSIGNED,
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (guild_id) REFERENCES guilds(id) ON DELETE CASCADE
-);
-
-CREATE TABLE users (
-    id INT UNSIGNED AUTO_INCREMENT UNIQUE NOT NULL,
-    user BIGINT UNSIGNED UNIQUE NOT NULL,
-
-    name VARCHAR(37) NOT NULL,
-
-    dm_channel INT UNSIGNED UNIQUE NOT NULL,
-
-    language VARCHAR(2) DEFAULT 'EN' NOT NULL,
-    timezone VARCHAR(32) DEFAULT 'UTC' NOT NULL,
-    meridian_time BOOLEAN DEFAULT 0 NOT NULL,
-
-    allowed_dm BOOLEAN DEFAULT 1 NOT NULL,
-
-    patreon BOOLEAN NOT NULL DEFAULT 0,
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (dm_channel) REFERENCES channels(id) ON DELETE RESTRICT
-);
-
-CREATE TABLE roles (
-    id INT UNSIGNED UNIQUE NOT NULL AUTO_INCREMENT,
-    role BIGINT UNSIGNED UNIQUE NOT NULL,
-
-    name VARCHAR(100),
-
-    guild_id INT UNSIGNED NOT NULL,
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (guild_id) REFERENCES guilds(id) ON DELETE CASCADE
-);
-
-CREATE TABLE embeds (
-    id INT UNSIGNED AUTO_INCREMENT UNIQUE NOT NULL,
-
-    title VARCHAR(256) NOT NULL DEFAULT '',
-    description VARCHAR(2048) NOT NULL DEFAULT '',
-
-    image_url VARCHAR(512),
-    thumbnail_url VARCHAR(512),
-
-    footer VARCHAR(2048) NOT NULL DEFAULT '',
-    footer_icon VARCHAR(512),
-
-    color MEDIUMINT UNSIGNED NOT NULL DEFAULT 0x0,
-
-    PRIMARY KEY (id)
-);
-
-CREATE TABLE embed_fields (
-    id INT UNSIGNED AUTO_INCREMENT UNIQUE NOT NULL,
-
-    title VARCHAR(256) NOT NULL DEFAULT '',
-    value VARCHAR(1024) NOT NULL DEFAULT '',
-    inline BOOL NOT NULL DEFAULT 0,
-    embed_id INT UNSIGNED NOT NULL,
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (embed_id) REFERENCES embeds(id) ON DELETE CASCADE
-);
-
-CREATE TABLE messages (
-    id INT UNSIGNED AUTO_INCREMENT UNIQUE NOT NULL,
-
-    content VARCHAR(2048) NOT NULL DEFAULT '',
-    tts BOOL NOT NULL DEFAULT 0,
-    embed_id INT UNSIGNED,
-
-    attachment MEDIUMBLOB,
-    attachment_name VARCHAR(260),
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (embed_id) REFERENCES embeds(id) ON DELETE SET NULL
-);
-
-CREATE TABLE reminders (
-    id INT UNSIGNED AUTO_INCREMENT UNIQUE NOT NULL,
-    uid VARCHAR(64) UNIQUE NOT NULL,
-
-    name VARCHAR(24) NOT NULL DEFAULT 'Reminder',
-
-    message_id INT UNSIGNED NOT NULL,
-    channel_id INT UNSIGNED NOT NULL,
-
-    `time` INT UNSIGNED DEFAULT 0 NOT NULL,
-    `interval` INT UNSIGNED DEFAULT NULL,
-    expires TIMESTAMP DEFAULT NULL,
-
-    enabled BOOLEAN DEFAULT 1 NOT NULL,
-
-    avatar VARCHAR(512),
-    username VARCHAR(32),
-
-    method ENUM('remind', 'natural', 'dashboard', 'todo', 'countdown'),
-    set_at TIMESTAMP DEFAULT NOW(),
-    set_by INT UNSIGNED,
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE RESTRICT,
-    FOREIGN KEY (channel_id) REFERENCES channels(id) ON DELETE CASCADE,
-    FOREIGN KEY (set_by) REFERENCES users(id) ON DELETE SET NULL
-);
-
-CREATE TRIGGER message_cleanup AFTER DELETE ON reminders
-FOR EACH ROW
-    DELETE FROM messages WHERE id = OLD.message_id;
-
-CREATE TRIGGER embed_cleanup AFTER DELETE ON messages
-FOR EACH ROW
-    DELETE FROM embeds WHERE id = OLD.embed_id;
-
-CREATE TABLE todos (
-    id INT UNSIGNED AUTO_INCREMENT UNIQUE NOT NULL,
-    user_id INT UNSIGNED,
-    guild_id INT UNSIGNED,
-    channel_id INT UNSIGNED,
-    value VARCHAR(2000) NOT NULL,
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE SET NULL,
-    FOREIGN KEY (guild_id) REFERENCES guilds(id) ON DELETE CASCADE,
-    FOREIGN KEY (channel_id) REFERENCES channels(id) ON DELETE SET NULL
-);
-
-CREATE TABLE command_restrictions (
-    id INT UNSIGNED AUTO_INCREMENT UNIQUE NOT NULL,
-
-    role_id INT UNSIGNED NOT NULL,
-    command ENUM('todos', 'natural', 'remind', 'interval', 'timer', 'del', 'look', 'alias', 'countdown') NOT NULL,
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (role_id) REFERENCES roles(id) ON DELETE CASCADE,
-    UNIQUE KEY (`role_id`, `command`)
-);
-
-CREATE TABLE timers (
-    id INT UNSIGNED AUTO_INCREMENT UNIQUE NOT NULL,
-    start_time TIMESTAMP NOT NULL DEFAULT NOW(),
-    name VARCHAR(32) NOT NULL,
-    owner BIGINT UNSIGNED NOT NULL,
-
-    PRIMARY KEY (id)
-);
-
-CREATE TABLE events (
-    id INT UNSIGNED AUTO_INCREMENT UNIQUE NOT NULL,
-    `time` TIMESTAMP NOT NULL DEFAULT NOW(),
-
-    event_name ENUM('edit', 'enable', 'disable', 'delete') NOT NULL,
-    bulk_count INT UNSIGNED,
-
-    guild_id INT UNSIGNED NOT NULL,
-    user_id INT UNSIGNED,
-    reminder_id INT UNSIGNED,
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (guild_id) REFERENCES guilds(id) ON DELETE CASCADE,
-    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE SET NULL,
-    FOREIGN KEY (reminder_id) REFERENCES reminders(id) ON DELETE SET NULL
-);
-
-CREATE TABLE command_aliases (
-    id INT UNSIGNED AUTO_INCREMENT UNIQUE NOT NULL,
-
-    guild_id INT UNSIGNED NOT NULL,
-    name VARCHAR(12) NOT NULL,
-
-    command VARCHAR(2048) NOT NULL,
-
-    PRIMARY KEY (id),
-    FOREIGN KEY (guild_id) REFERENCES guilds(id) ON DELETE CASCADE,
-    UNIQUE KEY (`guild_id`, `name`)
-);
-
-CREATE TABLE guild_users (
-    guild INT UNSIGNED NOT NULL,
-    user INT UNSIGNED NOT NULL,
-
-    can_access BOOL NOT NULL DEFAULT 0,
-
-    FOREIGN KEY (guild) REFERENCES guilds(id) ON DELETE CASCADE,
-    FOREIGN KEY (user) REFERENCES users(id) ON DELETE CASCADE,
-    UNIQUE KEY (guild, user)
-);
-
-CREATE EVENT event_cleanup
-ON SCHEDULE AT CURRENT_TIMESTAMP + INTERVAL 1 DAY
-ON COMPLETION PRESERVE
-DO DELETE FROM events WHERE `time` < DATE_SUB(NOW(), INTERVAL 5 DAY);

migrations/20210922000000_macro.sql

@@ -1,11 +0,0 @@
-CREATE TABLE macro (
-    id INT UNSIGNED AUTO_INCREMENT,
-    guild_id INT UNSIGNED NOT NULL,
-
-    name VARCHAR(100) NOT NULL,
-    description VARCHAR(100),
-    commands TEXT NOT NULL,
-
-    FOREIGN KEY (guild_id) REFERENCES guilds(id) ON DELETE CASCADE,
-    PRIMARY KEY (id)
-);

migrations/20220201000000_reminder_variable_intervals.sql

@@ -1,2 +0,0 @@
-ALTER TABLE reminders RENAME COLUMN `interval` TO `interval_seconds`;
-ALTER TABLE reminders ADD COLUMN `interval_months` INT UNSIGNED DEFAULT NULL;

migrations/20220211000000_reminder_templates.sql

@@ -1,49 +0,0 @@
-CREATE TABLE reminder_template (
-    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
-
-    `name` VARCHAR(24) NOT NULL DEFAULT 'Reminder',
-
-    `guild_id` INT UNSIGNED NOT NULL,
-
-    `username` VARCHAR(32) DEFAULT NULL,
-    `avatar` VARCHAR(512) DEFAULT NULL,
-
-    `content` VARCHAR(2048) NOT NULL DEFAULT '',
-    `tts` BOOL NOT NULL DEFAULT 0,
-    `attachment` MEDIUMBLOB,
-    `attachment_name` VARCHAR(260),
-
-    `embed_title` VARCHAR(256) NOT NULL DEFAULT '',
-    `embed_description` VARCHAR(2048) NOT NULL DEFAULT '',
-    `embed_image_url` VARCHAR(512),
-    `embed_thumbnail_url` VARCHAR(512),
-    `embed_footer` VARCHAR(2048) NOT NULL DEFAULT '',
-    `embed_footer_url` VARCHAR(512),
-    `embed_author` VARCHAR(256) NOT NULL DEFAULT '',
-    `embed_author_url` VARCHAR(512),
-    `embed_color` INT UNSIGNED NOT NULL DEFAULT 0x0,
-    `embed_fields` JSON,
-
-    PRIMARY KEY (id),
-
-    FOREIGN KEY (`guild_id`) REFERENCES guilds (`id`) ON DELETE CASCADE
-);
-
-ALTER TABLE reminders ADD COLUMN embed_fields JSON;
-
-update reminders
-    inner join embed_fields as E
-    on E.reminder_id = reminders.id
-set embed_fields = (
-    select JSON_ARRAYAGG(
-        JSON_OBJECT(
-            'title', E.title,
-            'value', E.value,
-            'inline',
-            if(inline = 1, cast(TRUE as json), cast(FALSE as json))
-            )
-        )
-    from embed_fields
-    group by reminder_id
-    having reminder_id = reminders.id
-    );

migrations/20221210000000_reminder_daily_intervals.sql

@@ -1 +0,0 @@
-ALTER TABLE reminders ADD COLUMN `interval_days` INT UNSIGNED DEFAULT NULL;

migrations/20230511125236_reminder_threads.sql

@@ -1 +0,0 @@
-ALTER TABLE reminders ADD COLUMN `thread_id` BIGINT DEFAULT NULL;

migrations/20230511180231_ephemeral_confirmations.sql

@@ -1 +0,0 @@
-ALTER TABLE guilds ADD COLUMN ephemeral_confirmations BOOL NOT NULL DEFAULT 0;

migrations/20230722130906_increase_reminder_name.sql

@@ -1,2 +0,0 @@
-ALTER TABLE reminders MODIFY `name` VARCHAR(100) NOT NULL DEFAULT 'Reminder';
-ALTER TABLE reminder_template MODIFY `name` VARCHAR(100) NOT NULL DEFAULT 'Reminder';

migrations/20230730134827_stats.sql

@@ -1,9 +0,0 @@
-CREATE TABLE stat (
-    `id` BIGINT NOT NULL AUTO_INCREMENT,
-    `utc_time` DATETIME NOT NULL DEFAULT NOW(),
-    `type` ENUM('reminder_sent', 'reminder_failed'),
-    `reminder_id` INT UNSIGNED,
-    `message` TEXT,
-
-    PRIMARY KEY (`id`)
-);

migrations/20230731170452_reminder_archive.sql

@@ -1,2 +0,0 @@
-ALTER TABLE reminders ADD COLUMN `status` ENUM ('pending', 'sent', 'failed', 'deleted') NOT NULL DEFAULT 'pending';
-ALTER TABLE reminders ADD COLUMN `status_message` TEXT;

migrations/20230812111348_orphan_reminders.sql

@@ -1,19 +0,0 @@
--- Drop existing constraint
-ALTER TABLE `reminders` DROP CONSTRAINT `reminders_ibfk_1`;
-
-ALTER TABLE `reminders` MODIFY COLUMN `channel_id` INT UNSIGNED;
-ALTER TABLE `reminders` ADD COLUMN `guild_id` INT UNSIGNED;
-
-ALTER TABLE `reminders`
-    ADD CONSTRAINT `guild_id_fk`
-        FOREIGN KEY (`guild_id`)
-        REFERENCES `guilds`(`id`)
-        ON DELETE CASCADE;
-
-ALTER TABLE `reminders`
-    ADD CONSTRAINT `channel_id_fk`
-        FOREIGN KEY (`channel_id`)
-        REFERENCES `channels`(`id`)
-        ON DELETE SET NULL;
-
-UPDATE `reminders` SET `guild_id` = (SELECT guilds.`id` FROM `channels` INNER JOIN `guilds` ON channels.guild_id = guilds.id WHERE reminders.channel_id = channels.id);

migrations/20230903131153_reminder_status_timing.sql

@@ -1,4 +0,0 @@
-ALTER TABLE reminders ADD COLUMN `status_change_time` DATETIME;
-
--- This is a best-guess as to the status change time.
-UPDATE reminders SET `status_change_time` = `utc_time` WHERE `status` != 'pending';

models/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "models"
+version = "0.1.0"

models/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "models"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

models/entity/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "entity"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+chrono-tz = "^0.6"
+sea-orm = { version = "^0.8", features = ["sqlx-postgres", "runtime-tokio-native-tls", "macros"] }

models/entity/src/channel.rs

@@ -0,0 +1,60 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "channel")]
+pub struct Model {
+    #[sea_orm(primary_key, auto_increment = false)]
+    pub id: i64,
+    pub guild_id: Option<i64>,
+    pub nudge: i32,
+    pub webhook_id: Option<i64>,
+    pub webhook_token: Option<String>,
+    pub paused: bool,
+    pub paused_until: Option<DateTimeUtc>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::guild::Entity",
+        from = "Column::GuildId",
+        to = "super::guild::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    Guild,
+    #[sea_orm(has_many = "super::user::Entity")]
+    User,
+    #[sea_orm(has_many = "super::reminder::Entity")]
+    Reminder,
+    #[sea_orm(has_many = "super::todo::Entity")]
+    Todo,
+}
+
+impl Related<super::guild::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Guild.def()
+    }
+}
+
+impl Related<super::user::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::User.def()
+    }
+}
+
+impl Related<super::reminder::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Reminder.def()
+    }
+}
+
+impl Related<super::todo::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Todo.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

models/entity/src/command_macro.rs

@@ -0,0 +1,34 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "command_macro")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub guild_id: i64,
+    pub name: String,
+    pub description: Option<String>,
+    pub commands: Option<Json>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::guild::Entity",
+        from = "Column::GuildId",
+        to = "super::guild::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    Guild,
+}
+
+impl Related<super::guild::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Guild.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

models/entity/src/guild.rs

@@ -0,0 +1,48 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "guild")]
+pub struct Model {
+    #[sea_orm(primary_key, auto_increment = false)]
+    pub id: i64,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(has_many = "super::reminder_template::Entity")]
+    ReminderTemplate,
+    #[sea_orm(has_many = "super::channel::Entity")]
+    Channel,
+    #[sea_orm(has_many = "super::todo::Entity")]
+    Todo,
+    #[sea_orm(has_many = "super::command_macro::Entity")]
+    CommandMacro,
+}
+
+impl Related<super::reminder_template::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::ReminderTemplate.def()
+    }
+}
+
+impl Related<super::channel::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Channel.def()
+    }
+}
+
+impl Related<super::todo::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Todo.def()
+    }
+}
+
+impl Related<super::command_macro::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::CommandMacro.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

models/entity/src/lib.rs

@@ -0,0 +1 @@
+

models/entity/src/mod.rs

@@ -0,0 +1,14 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+pub mod prelude;
+
+pub mod channel;
+pub mod command_macro;
+pub mod guild;
+pub mod reminder;
+pub mod reminder_template;
+pub mod sea_orm_active_enums;
+pub mod seaql_migrations;
+pub mod timer;
+pub mod todo;
+pub mod user;

models/entity/src/prelude.rs

@@ -0,0 +1,8 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+pub use super::{
+    channel::Entity as Channel, command_macro::Entity as CommandMacro, guild::Entity as Guild,
+    reminder::Entity as Reminder, reminder_template::Entity as ReminderTemplate,
+    seaql_migrations::Entity as SeaqlMigrations, timer::Entity as Timer, todo::Entity as Todo,
+    user::Entity as User,
+};

models/entity/src/reminder.rs

@@ -0,0 +1,73 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+use sea_orm::entity::prelude::*;
+
+use super::sea_orm_active_enums::Timezone;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "reminder")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub uid: String,
+    pub name: String,
+    pub channel_id: i64,
+    pub utc_time: DateTimeUtc,
+    pub timezone: Timezone,
+    pub interval_seconds: Option<i32>,
+    pub interval_months: Option<i32>,
+    pub enabled: bool,
+    pub expires: Option<DateTimeUtc>,
+    pub username: Option<String>,
+    pub avatar: Option<String>,
+    pub content: Option<String>,
+    pub tts: bool,
+    pub attachment: Option<Vec<u8>>,
+    pub attachment_name: Option<String>,
+    pub embed_title: Option<String>,
+    pub embed_description: Option<String>,
+    pub embed_image_url: Option<String>,
+    pub embed_thumbnail_url: Option<String>,
+    pub embed_footer: Option<String>,
+    pub embed_footer_url: Option<String>,
+    pub embed_author: Option<String>,
+    pub embed_author_url: Option<String>,
+    pub embed_color: Option<i32>,
+    pub embed_fields: Option<Json>,
+    pub set_at: DateTimeUtc,
+    pub set_by: i64,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::channel::Entity",
+        from = "Column::ChannelId",
+        to = "super::channel::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    Channel,
+    #[sea_orm(
+        belongs_to = "super::user::Entity",
+        from = "Column::SetBy",
+        to = "super::user::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    User,
+}
+
+impl Related<super::channel::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Channel.def()
+    }
+}
+
+impl Related<super::user::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::User.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

models/entity/src/reminder_template.rs

@@ -0,0 +1,48 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "reminder_template")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub guild_id: i64,
+    pub name: String,
+    pub username: Option<String>,
+    pub avatar: Option<String>,
+    pub content: Option<String>,
+    pub tts: bool,
+    pub attachment: Option<Vec<u8>>,
+    pub attachment_name: Option<String>,
+    pub embed_title: Option<String>,
+    pub embed_description: Option<String>,
+    pub embed_image_url: Option<String>,
+    pub embed_thumbnail_url: Option<String>,
+    pub embed_footer: Option<String>,
+    pub embed_footer_url: Option<String>,
+    pub embed_author: Option<String>,
+    pub embed_author_url: Option<String>,
+    pub embed_color: Option<i32>,
+    pub embed_fields: Option<Json>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::guild::Entity",
+        from = "Column::GuildId",
+        to = "super::guild::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    Guild,
+}
+
+impl Related<super::guild::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Guild.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

models/entity/src/seaql_migrations.rs

@@ -0,0 +1,22 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "seaql_migrations")]
+pub struct Model {
+    #[sea_orm(primary_key, auto_increment = false)]
+    pub version: String,
+    pub applied_at: i64,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter)]
+pub enum Relation {}
+
+impl RelationTrait for Relation {
+    fn def(&self) -> RelationDef {
+        panic!("No RelationDef")
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

models/entity/src/timer.rs

@@ -0,0 +1,36 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "timer")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub start_time: DateTimeUtc,
+    pub name: String,
+    pub user_id: Option<i64>,
+    pub guild_id: Option<i64>,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::guild::Entity",
+        from = "Column::GuildId",
+        to = "super::guild::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    Guild2,
+    #[sea_orm(
+        belongs_to = "super::guild::Entity",
+        from = "Column::UserId",
+        to = "super::guild::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    Guild1,
+}
+
+impl ActiveModelBehavior for ActiveModel {}

models/entity/src/todo.rs

@@ -0,0 +1,62 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "todo")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: i32,
+    pub user_id: Option<i64>,
+    pub guild_id: Option<i64>,
+    pub channel_id: Option<i64>,
+    pub value: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::channel::Entity",
+        from = "Column::ChannelId",
+        to = "super::channel::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    Channel,
+    #[sea_orm(
+        belongs_to = "super::guild::Entity",
+        from = "Column::GuildId",
+        to = "super::guild::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    Guild,
+    #[sea_orm(
+        belongs_to = "super::user::Entity",
+        from = "Column::UserId",
+        to = "super::user::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    User,
+}
+
+impl Related<super::channel::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Channel.def()
+    }
+}
+
+impl Related<super::guild::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Guild.def()
+    }
+}
+
+impl Related<super::user::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::User.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

models/entity/src/user.rs

@@ -0,0 +1,50 @@
+//! SeaORM Entity. Generated by sea-orm-codegen 0.8.0
+
+use sea_orm::entity::prelude::*;
+
+use super::sea_orm_active_enums::Timezone;
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "user")]
+pub struct Model {
+    #[sea_orm(primary_key, auto_increment = false)]
+    pub id: i64,
+    pub dm_channel: i64,
+    pub timezone: Timezone,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::channel::Entity",
+        from = "Column::DmChannel",
+        to = "super::channel::Column::Id",
+        on_update = "NoAction",
+        on_delete = "Cascade"
+    )]
+    Channel,
+    #[sea_orm(has_many = "super::reminder::Entity")]
+    Reminder,
+    #[sea_orm(has_many = "super::todo::Entity")]
+    Todo,
+}
+
+impl Related<super::channel::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Channel.def()
+    }
+}
+
+impl Related<super::reminder::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Reminder.def()
+    }
+}
+
+impl Related<super::todo::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Todo.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

models/migration/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "migration"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+name = "migration"
+path = "src/lib.rs"
+
+[dependencies]
+entity = { path = "../entity" }
+chrono-tz = "^0.6"
+
+[dependencies.sea-orm-migration]
+version = "^0.8.0"

models/migration/README.md

@@ -0,0 +1,37 @@
+# Running Migrator CLI
+
+- Apply all pending migrations
+    ```sh
+    cargo run
+    ```
+    ```sh
+    cargo run -- up
+    ```
+- Apply first 10 pending migrations
+    ```sh
+    cargo run -- up -n 10
+    ```
+- Rollback last applied migrations
+    ```sh
+    cargo run -- down
+    ```
+- Rollback last 10 applied migrations
+    ```sh
+    cargo run -- down -n 10
+    ```
+- Drop all tables from the database, then reapply all migrations
+    ```sh
+    cargo run -- fresh
+    ```
+- Rollback all applied migrations, then reapply all migrations
+    ```sh
+    cargo run -- refresh
+    ```
+- Rollback all applied migrations
+    ```sh
+    cargo run -- reset
+    ```
+- Check the status of all migrations
+    ```sh
+    cargo run -- status
+    ```

models/migration/src/lib.rs

@@ -0,0 +1,12 @@
+pub use sea_orm_migration::prelude::*;
+
+mod m20220101_000001_create_table;
+
+pub struct Migrator;
+
+#[async_trait::async_trait]
+impl MigratorTrait for Migrator {
+    fn migrations() -> Vec<Box<dyn MigrationTrait>> {
+        vec![Box::new(m20220101_000001_create_table::Migration)]
+    }
+}

models/migration/src/m20220101_000001_create_table.rs

@@ -0,0 +1,553 @@
+use chrono_tz::{Tz, TZ_VARIANTS};
+use sea_orm_migration::prelude::*;
+
+use crate::extension::postgres::Type;
+
+pub struct Migration;
+
+impl MigrationName for Migration {
+    fn name(&self) -> &str {
+        "m20220101_000001_create_table"
+    }
+}
+
+#[derive(Iden)]
+pub enum Guild {
+    Table,
+    Id,
+}
+
+#[derive(Iden)]
+pub enum Channel {
+    Table,
+    Id,
+    GuildId,
+    Nudge,
+    WebhookId,
+    WebhookToken,
+    Paused,
+    PausedUntil,
+}
+
+#[derive(Iden)]
+pub enum User {
+    Table,
+    Id,
+    DmChannel,
+    Timezone,
+}
+
+#[derive(Iden)]
+pub enum Reminder {
+    Table,
+    Id,
+    Uid,
+    Name,
+    ChannelId,
+    UtcTime,
+    Timezone,
+    IntervalSeconds,
+    IntervalMonths,
+    Enabled,
+    Expires,
+    Username,
+    Avatar,
+    Content,
+    Tts,
+    Attachment,
+    AttachmentName,
+    EmbedTitle,
+    EmbedDescription,
+    EmbedImageUrl,
+    EmbedThumbnailUrl,
+    EmbedFooter,
+    EmbedFooterUrl,
+    EmbedAuthor,
+    EmbedAuthorUrl,
+    EmbedColor,
+    EmbedFields,
+    SetAt,
+    SetBy,
+}
+
+#[derive(Iden)]
+pub enum ReminderTemplate {
+    Table,
+    Id,
+    GuildId,
+    Name,
+    Username,
+    Avatar,
+    Content,
+    Tts,
+    Attachment,
+    AttachmentName,
+    EmbedTitle,
+    EmbedDescription,
+    EmbedImageUrl,
+    EmbedThumbnailUrl,
+    EmbedFooter,
+    EmbedFooterUrl,
+    EmbedAuthor,
+    EmbedAuthorUrl,
+    EmbedColor,
+    EmbedFields,
+}
+
+#[derive(Iden)]
+pub enum Timer {
+    Table,
+    Id,
+    StartTime,
+    Name,
+    UserId,
+    GuildId,
+}
+
+#[derive(Iden)]
+pub enum Todo {
+    Table,
+    Id,
+    UserId,
+    GuildId,
+    ChannelId,
+    Value,
+}
+
+#[derive(Iden)]
+pub enum CommandMacro {
+    Table,
+    Id,
+    GuildId,
+    Name,
+    Description,
+    Commands,
+}
+
+pub enum Timezone {
+    Type,
+    Tz(Tz),
+}
+
+impl Iden for Timezone {
+    fn unquoted(&self, s: &mut dyn Write) {
+        write!(
+            s,
+            "{}",
+            match self {
+                Self::Type => "timezone".to_string(),
+                Self::Tz(tz) => tz.to_string(),
+            }
+        )
+        .unwrap();
+    }
+}
+
+#[async_trait::async_trait]
+impl MigrationTrait for Migration {
+    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .create_type(
+                Type::create()
+                    .as_enum(Timezone::Type)
+                    .values(TZ_VARIANTS.iter().map(|tz| Timezone::Tz(tz.to_owned())))
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_table(
+                Table::create()
+                    .table(Guild::Table)
+                    .if_not_exists()
+                    .col(ColumnDef::new(Guild::Id).big_integer().not_null().primary_key())
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_table(
+                Table::create()
+                    .table(Channel::Table)
+                    .if_not_exists()
+                    .col(ColumnDef::new(Channel::Id).big_integer().not_null().primary_key())
+                    .col(ColumnDef::new(Channel::GuildId).big_integer())
+                    .col(ColumnDef::new(Channel::Nudge).integer().not_null().default(0))
+                    .col(ColumnDef::new(Channel::WebhookId).big_integer())
+                    .col(ColumnDef::new(Channel::WebhookToken).string())
+                    .col(ColumnDef::new(Channel::Paused).boolean().not_null().default(false))
+                    .col(ColumnDef::new(Channel::PausedUntil).date_time())
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_channel_guild")
+                    .from(Channel::Table, Channel::GuildId)
+                    .to(Guild::Table, Guild::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_table(
+                Table::create()
+                    .table(User::Table)
+                    .if_not_exists()
+                    .col(ColumnDef::new(User::Id).big_integer().not_null().primary_key())
+                    .col(ColumnDef::new(User::DmChannel).big_integer().not_null())
+                    .col(
+                        ColumnDef::new(User::Timezone)
+                            .custom(Timezone::Type)
+                            .not_null()
+                            .default("UTC"),
+                    )
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_user_channel")
+                    .from(User::Table, User::DmChannel)
+                    .to(Channel::Table, Channel::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_table(
+                Table::create()
+                    .table(Reminder::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(Reminder::Id)
+                            .integer()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(ColumnDef::new(Reminder::Uid).string().char_len(64).not_null())
+                    .col(
+                        ColumnDef::new(Reminder::Name)
+                            .string()
+                            .char_len(24)
+                            .default("Reminder")
+                            .not_null(),
+                    )
+                    .col(ColumnDef::new(Reminder::ChannelId).big_integer().not_null())
+                    .col(ColumnDef::new(Reminder::UtcTime).date_time().not_null())
+                    .col(
+                        ColumnDef::new(Reminder::Timezone)
+                            .custom(Timezone::Type)
+                            .not_null()
+                            .default("UTC"),
+                    )
+                    .col(ColumnDef::new(Reminder::IntervalSeconds).integer())
+                    .col(ColumnDef::new(Reminder::IntervalMonths).integer())
+                    .col(ColumnDef::new(Reminder::Enabled).boolean().not_null().default(false))
+                    .col(ColumnDef::new(Reminder::Expires).date_time())
+                    .col(ColumnDef::new(Reminder::Username).string_len(32))
+                    .col(ColumnDef::new(Reminder::Avatar).string_len(512))
+                    .col(ColumnDef::new(Reminder::Content).string_len(2000))
+                    .col(ColumnDef::new(Reminder::Tts).boolean().not_null().default(false))
+                    .col(ColumnDef::new(Reminder::Attachment).binary_len(8 * 1024 * 1024))
+                    .col(ColumnDef::new(Reminder::AttachmentName).string_len(260))
+                    .col(ColumnDef::new(Reminder::EmbedTitle).string_len(256))
+                    .col(ColumnDef::new(Reminder::EmbedDescription).string_len(4096))
+                    .col(ColumnDef::new(Reminder::EmbedImageUrl).string_len(500))
+                    .col(ColumnDef::new(Reminder::EmbedThumbnailUrl).string_len(500))
+                    .col(ColumnDef::new(Reminder::EmbedFooter).string_len(2048))
+                    .col(ColumnDef::new(Reminder::EmbedFooterUrl).string_len(500))
+                    .col(ColumnDef::new(Reminder::EmbedAuthor).string_len(256))
+                    .col(ColumnDef::new(Reminder::EmbedAuthorUrl).string_len(500))
+                    .col(ColumnDef::new(Reminder::EmbedColor).integer())
+                    .col(ColumnDef::new(Reminder::EmbedFields).json())
+                    .col(ColumnDef::new(Reminder::SetAt).date_time().not_null().default("NOW()"))
+                    .col(ColumnDef::new(Reminder::SetBy).big_integer().not_null())
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_reminder_channel")
+                    .from(Reminder::Table, Reminder::ChannelId)
+                    .to(Channel::Table, Channel::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_reminder_user")
+                    .from(Reminder::Table, Reminder::SetBy)
+                    .to(User::Table, User::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_table(
+                Table::create()
+                    .table(ReminderTemplate::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(ReminderTemplate::Id)
+                            .integer()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(ColumnDef::new(ReminderTemplate::GuildId).big_integer().not_null())
+                    .col(
+                        ColumnDef::new(ReminderTemplate::Name)
+                            .string()
+                            .char_len(24)
+                            .default("Reminder")
+                            .not_null(),
+                    )
+                    .col(ColumnDef::new(ReminderTemplate::Username).string_len(32))
+                    .col(ColumnDef::new(ReminderTemplate::Avatar).string_len(512))
+                    .col(ColumnDef::new(ReminderTemplate::Content).string_len(2000))
+                    .col(ColumnDef::new(ReminderTemplate::Tts).boolean().not_null().default(false))
+                    .col(ColumnDef::new(ReminderTemplate::Attachment).binary_len(8 * 1024 * 1024))
+                    .col(ColumnDef::new(ReminderTemplate::AttachmentName).string_len(260))
+                    .col(ColumnDef::new(ReminderTemplate::EmbedTitle).string_len(256))
+                    .col(ColumnDef::new(ReminderTemplate::EmbedDescription).string_len(4096))
+                    .col(ColumnDef::new(ReminderTemplate::EmbedImageUrl).string_len(500))
+                    .col(ColumnDef::new(ReminderTemplate::EmbedThumbnailUrl).string_len(500))
+                    .col(ColumnDef::new(ReminderTemplate::EmbedFooter).string_len(2048))
+                    .col(ColumnDef::new(ReminderTemplate::EmbedFooterUrl).string_len(500))
+                    .col(ColumnDef::new(ReminderTemplate::EmbedAuthor).string_len(256))
+                    .col(ColumnDef::new(ReminderTemplate::EmbedAuthorUrl).string_len(500))
+                    .col(ColumnDef::new(ReminderTemplate::EmbedColor).integer())
+                    .col(ColumnDef::new(ReminderTemplate::EmbedFields).json())
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_reminder_template_guild")
+                    .from(ReminderTemplate::Table, ReminderTemplate::GuildId)
+                    .to(Guild::Table, Guild::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_table(
+                Table::create()
+                    .table(Timer::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(Timer::Id)
+                            .integer()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(ColumnDef::new(Timer::StartTime).date_time().not_null().default("NOW()"))
+                    .col(ColumnDef::new(Timer::Name).string_len(32).not_null().default("Timer"))
+                    .col(ColumnDef::new(Timer::UserId).big_integer())
+                    .col(ColumnDef::new(Timer::GuildId).big_integer())
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_timer_user")
+                    .from(Timer::Table, Timer::UserId)
+                    .to(Guild::Table, Guild::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_timer_guild")
+                    .from(Timer::Table, Timer::GuildId)
+                    .to(Guild::Table, Guild::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_table(
+                Table::create()
+                    .table(Todo::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(Todo::Id)
+                            .integer()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(ColumnDef::new(Todo::UserId).big_integer())
+                    .col(ColumnDef::new(Todo::GuildId).big_integer())
+                    .col(ColumnDef::new(Todo::ChannelId).big_integer())
+                    .col(ColumnDef::new(Todo::Value).string_len(2000).not_null())
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_todo_user")
+                    .from(Todo::Table, Todo::UserId)
+                    .to(User::Table, User::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_todo_guild")
+                    .from(Todo::Table, Todo::GuildId)
+                    .to(Guild::Table, Guild::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_todo_channel")
+                    .from(Todo::Table, Todo::ChannelId)
+                    .to(Channel::Table, Channel::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_table(
+                Table::create()
+                    .table(CommandMacro::Table)
+                    .if_not_exists()
+                    .col(
+                        ColumnDef::new(CommandMacro::Id)
+                            .integer()
+                            .not_null()
+                            .auto_increment()
+                            .primary_key(),
+                    )
+                    .col(ColumnDef::new(CommandMacro::GuildId).big_integer().not_null())
+                    .col(ColumnDef::new(CommandMacro::Name).string_len(100).not_null())
+                    .col(ColumnDef::new(CommandMacro::Description).string_len(100))
+                    .col(ColumnDef::new(CommandMacro::Commands).json())
+                    .to_owned(),
+            )
+            .await?;
+
+        manager
+            .create_foreign_key(
+                ForeignKey::create()
+                    .name("fk_command_macro_guild")
+                    .from(CommandMacro::Table, CommandMacro::GuildId)
+                    .to(Guild::Table, Guild::Id)
+                    .on_delete(ForeignKeyAction::Cascade)
+                    .to_owned(),
+            )
+            .await?;
+
+        Ok(())
+    }
+
+    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
+        manager
+            .drop_foreign_key(
+                ForeignKey::drop().table(Channel::Table).name("fk_channel_guild").to_owned(),
+            )
+            .await?;
+        manager
+            .drop_foreign_key(
+                ForeignKey::drop().table(User::Table).name("fk_user_channel").to_owned(),
+            )
+            .await?;
+        manager
+            .drop_foreign_key(
+                ForeignKey::drop().table(Reminder::Table).name("fk_reminder_channel").to_owned(),
+            )
+            .await?;
+        manager
+            .drop_foreign_key(
+                ForeignKey::drop().table(Reminder::Table).name("fk_reminder_user").to_owned(),
+            )
+            .await?;
+        manager
+            .drop_foreign_key(
+                ForeignKey::drop()
+                    .table(ReminderTemplate::Table)
+                    .name("fk_reminder_template_guild")
+                    .to_owned(),
+            )
+            .await?;
+        manager
+            .drop_foreign_key(
+                ForeignKey::drop().table(Timer::Table).name("fk_timer_user").to_owned(),
+            )
+            .await?;
+        manager
+            .drop_foreign_key(
+                ForeignKey::drop().table(Timer::Table).name("fk_timer_guild").to_owned(),
+            )
+            .await?;
+        manager
+            .drop_foreign_key(ForeignKey::drop().table(Todo::Table).name("fk_todo_user").to_owned())
+            .await?;
+        manager
+            .drop_foreign_key(
+                ForeignKey::drop().table(Todo::Table).name("fk_todo_guild").to_owned(),
+            )
+            .await?;
+        manager
+            .drop_foreign_key(
+                ForeignKey::drop().table(Todo::Table).name("fk_todo_channel").to_owned(),
+            )
+            .await?;
+        manager
+            .drop_foreign_key(
+                ForeignKey::drop()
+                    .table(CommandMacro::Table)
+                    .name("fk_command_macro_guild")
+                    .to_owned(),
+            )
+            .await?;
+
+        manager.drop_table(Table::drop().table(Guild::Table).to_owned()).await?;
+        manager.drop_table(Table::drop().table(Channel::Table).to_owned()).await?;
+        manager.drop_table(Table::drop().table(User::Table).to_owned()).await?;
+        manager.drop_table(Table::drop().table(Reminder::Table).to_owned()).await?;
+        manager.drop_table(Table::drop().table(ReminderTemplate::Table).to_owned()).await?;
+        manager.drop_table(Table::drop().table(Timer::Table).to_owned()).await?;
+        manager.drop_table(Table::drop().table(Todo::Table).to_owned()).await?;
+        manager.drop_table(Table::drop().table(CommandMacro::Table).to_owned()).await?;
+
+        manager.drop_type(Type::drop().name(Timezone::Type).to_owned()).await?;
+
+        Ok(())
+    }
+}

models/migration/src/main.rs

@@ -0,0 +1,6 @@
+use sea_orm_migration::prelude::*;
+
+#[async_std::main]
+async fn main() {
+    cli::run_cli(migration::Migrator).await;
+}

models/src/lib.rs

@@ -0,0 +1 @@
+

nginx/reminder-rs

@@ -1,41 +0,0 @@
-server {
-        server_name www.reminder-bot.com;
-
-        return 301 $scheme://reminder-bot.com$request_uri;
-}
-
-server {
-        listen 80;
-        server_name reminder-bot.com;
-
-	    return 301 https://reminder-bot.com$request_uri;
-}
-
-server {
-        listen 443 ssl;
-        server_name reminder-bot.com;
-
-        ssl_certificate /etc/letsencrypt/live/reminder-bot.com/fullchain.pem;
-        ssl_certificate_key /etc/letsencrypt/live/reminder-bot.com/privkey.pem;
-
-        access_log /var/log/nginx/access.log;
-        error_log /var/log/nginx/error.log;
-
-        proxy_buffer_size 128k;
-        proxy_buffers 4 256k;
-        proxy_busy_buffers_size 256k;
-
-        location / {
-                proxy_pass http://localhost:18920;
-                proxy_redirect off;
-                proxy_set_header Host $host;
-                proxy_set_header X-Real-IP $remote_addr;
-                proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-		        proxy_set_header X-Forwarded-Proto $scheme;
-        }
-
-        location /static {
-                alias /var/www/reminder-rs/static;
-                expires 30d;
-        }
-}

postman/Cargo.toml

@@ -5,12 +5,14 @@ edition = "2021"
 
 [dependencies]
 tokio = { version = "1", features = ["process", "full"] }
-regex = "1.9"
+regex = "1.4"
 log = "0.4"
+env_logger = "0.8"
 chrono = "0.4"
-chrono-tz = { version = "0.8", features = ["serde"] }
+chrono-tz = { version = "0.5", features = ["serde"] }
 lazy_static = "1.4"
 num-integer = "0.1"
 serde = "1.0"
-sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "macros", "mysql", "bigdecimal", "chrono", "json"]}
-serenity = { version = "0.11", default-features = false, features = ["builder", "cache", "client", "gateway", "http", "model", "utils", "rustls_backend"] }
+serde_json = "1.0"
+sqlx = { version = "0.5", features = ["runtime-tokio-rustls", "macros", "mysql", "bigdecimal", "chrono", "json"]}
+serenity = { version = "0.11.1", default-features = false, features = ["builder", "cache", "client", "gateway", "http", "model", "utils", "rustls_backend"] }

postman/src/sender.rs

@@ -1,6 +1,4 @@
-use std::env;
-
-use chrono::{DateTime, Days, Duration, Months};
+use chrono::Duration;
 use chrono_tz::Tz;
 use lazy_static::lazy_static;
 use log::{error, info, warn};
@@ -9,7 +7,7 @@ use regex::{Captures, Regex};
 use serde::Deserialize;
 use serenity::{
     builder::CreateEmbed,
-    http::{CacheHttp, Http, HttpError},
+    http::{CacheHttp, Http, HttpError, StatusCode},
     model::{
         channel::{Channel, Embed as SerenityEmbed},
         id::ChannelId,
@@ -32,7 +30,6 @@ lazy_static! {
         Regex::new(r#"<<timefrom:(?P<time>\d+):(?P<format>.+)?>>"#).unwrap();
     pub static ref TIMENOW_REGEX: Regex =
         Regex::new(r#"<<timenow:(?P<timezone>(?:\w|/|_)+):(?P<format>.+)?>>"#).unwrap();
-    pub static ref LOG_TO_DATABASE: bool = env::var("LOG_TO_DATABASE").map_or(true, |v| v == "1");
 }
 
 fn fmt_displacement(format: &str, seconds: u64) -> String {
@@ -65,8 +62,7 @@ pub fn substitute(string: &str) -> String {
         let format = caps.name("format").map(|m| m.as_str());
 
         if let (Some(final_time), Some(format)) = (final_time, format) {
-            match NaiveDateTime::from_timestamp_opt(final_time, 0) {
-                Some(dt) => {
+            let dt = NaiveDateTime::from_timestamp(final_time, 0);
             let now = Utc::now().naive_utc();
 
             let difference = {
@@ -78,10 +74,6 @@ pub fn substitute(string: &str) -> String {
             };
 
             fmt_displacement(format, difference.num_seconds() as u64)
-                }
-
-                None => String::new(),
-            }
         } else {
             String::new()
         }
@@ -154,7 +146,7 @@ impl Embed {
                 embed.description = substitute(&embed.description);
                 embed.footer = substitute(&embed.footer);
 
-                embed.fields.iter_mut().for_each(|field| {
+                embed.fields.iter_mut().for_each(|mut field| {
                     field.title = substitute(&field.title);
                     field.value = substitute(&field.value);
                 });
@@ -234,14 +226,15 @@ impl Into<CreateEmbed> for Embed {
     }
 }
 
+#[derive(Debug)]
 pub struct Reminder {
     id: u32,
 
-    channel_id: Option<u64>,
+    channel_id: u64,
     webhook_id: Option<u64>,
     webhook_token: Option<String>,
 
-    channel_paused: Option<bool>,
+    channel_paused: bool,
     channel_paused_until: Option<NaiveDateTime>,
     enabled: bool,
 
@@ -251,12 +244,11 @@ pub struct Reminder {
     attachment: Option<Vec<u8>>,
     attachment_name: Option<String>,
 
-    utc_time: DateTime<Utc>,
+    utc_time: NaiveDateTime,
     timezone: String,
     restartable: bool,
-    expires: Option<DateTime<Utc>>,
+    expires: Option<NaiveDateTime>,
     interval_seconds: Option<u32>,
-    interval_days: Option<u32>,
     interval_months: Option<u32>,
 
     avatar: Option<String>,
@@ -290,35 +282,19 @@ SELECT
     reminders.`restartable` AS restartable,
     reminders.`expires` AS 'expires',
     reminders.`interval_seconds` AS 'interval_seconds',
-    reminders.`interval_days` AS 'interval_days',
     reminders.`interval_months` AS 'interval_months',
 
     reminders.`avatar` AS avatar,
     reminders.`username` AS username
 FROM
     reminders
-LEFT JOIN
+INNER JOIN
     channels
 ON
     reminders.channel_id = channels.id
 WHERE
-    reminders.`status` = 'pending' AND
-    reminders.`id` IN (
-        SELECT
-            MIN(id)
-        FROM
-            reminders
-        WHERE
-            reminders.`utc_time` <= NOW() AND
-            `status` = 'pending' AND
-            (
-                reminders.`interval_seconds` IS NOT NULL
-                OR reminders.`interval_months` IS NOT NULL
-                OR reminders.`interval_days` IS NOT NULL
-                OR reminders.enabled
-            )
-        GROUP BY channel_id
-    )
+    reminders.`utc_time` < NOW()
+LIMIT 25
             "#,
         )
         .fetch_all(pool)
@@ -344,8 +320,7 @@ WHERE
     async fn reset_webhook(&self, pool: impl Executor<'_, Database = Database> + Copy) {
         let _ = sqlx::query!(
             "
-            UPDATE channels SET webhook_id = NULL, webhook_token = NULL
-            WHERE channel = ?
+UPDATE channels SET webhook_id = NULL, webhook_token = NULL WHERE channel = ?
             ",
             self.channel_id
         )
@@ -354,74 +329,56 @@ WHERE
     }
 
     async fn refresh(&self, pool: impl Executor<'_, Database = Database> + Copy) {
-        if self.interval_seconds.is_some()
-            || self.interval_months.is_some()
-            || self.interval_days.is_some()
-        {
-            // If all intervals are zero then dont care
-            if self.interval_seconds == Some(0)
-                && self.interval_days == Some(0)
-                && self.interval_months == Some(0)
-            {
-                self.set_sent(pool).await;
-            }
+        if self.interval_seconds.is_some() || self.interval_months.is_some() {
+            let now = Utc::now().naive_local();
+            let mut updated_reminder_time = self.utc_time;
 
-            let now = Utc::now();
-            let mut updated_reminder_time =
-                self.utc_time.with_timezone(&self.timezone.parse().unwrap_or(Tz::UTC));
-            let mut fail_count = 0;
-
-            while updated_reminder_time < now && fail_count < 4 {
             if let Some(interval) = self.interval_months {
-                    if interval != 0 {
-                        updated_reminder_time = updated_reminder_time
-                            .checked_add_months(Months::new(interval))
-                            .unwrap_or_else(|| {
-                                warn!(
-                                    "{}: Could not add {} months to a reminder",
-                                    interval, self.id
-                                );
-                                fail_count += 1;
-
-                                updated_reminder_time
-                            });
+                match sqlx::query!(
+                    // use the second date_add to force return value to datetime
+                    "SELECT DATE_ADD(DATE_ADD(?, INTERVAL ? MONTH), INTERVAL 0 SECOND) AS new_time",
+                    updated_reminder_time,
+                    interval
+                )
+                .fetch_one(pool)
+                .await
+                {
+                    Ok(row) => match row.new_time {
+                        Some(datetime) => {
+                            updated_reminder_time = datetime;
                         }
+                        None => {
+                            warn!("Could not update interval by months: got NULL");
+
+                            updated_reminder_time += Duration::days(30);
                         }
+                    },
 
-                if let Some(interval) = self.interval_days {
-                    if interval != 0 {
-                        updated_reminder_time = updated_reminder_time
-                            .checked_add_days(Days::new(interval as u64))
-                            .unwrap_or_else(|| {
-                                warn!("{}: Could not add {} days to a reminder", self.id, interval);
-                                fail_count += 1;
+                    Err(e) => {
+                        warn!("Could not update interval by months: {:?}", e);
 
-                                updated_reminder_time
-                            })
+                        // naively fallback to adding 30 days
+                        updated_reminder_time += Duration::days(30);
+                    }
                 }
             }
 
             if let Some(interval) = self.interval_seconds {
+                while updated_reminder_time < now {
                     updated_reminder_time += Duration::seconds(interval as i64);
                 }
             }
 
-            if fail_count >= 4 {
-                self.log_error(
-                    pool,
-                    "Failed to update 4 times and so is being deleted",
-                    None::<&'static str>,
-                )
-                .await;
-                self.set_failed(pool, "Failed to update 4 times and so is being deleted").await;
-            } else if self.expires.map_or(false, |expires| updated_reminder_time > expires) {
-                self.set_sent(pool).await;
+            if self.expires.map_or(false, |expires| {
+                NaiveDateTime::from_timestamp(updated_reminder_time.timestamp(), 0) > expires
+            }) {
+                self.force_delete(pool).await;
             } else {
                 sqlx::query!(
                     "
-                    UPDATE reminders SET `utc_time` = ? WHERE `id` = ?
+UPDATE reminders SET `utc_time` = ? WHERE `id` = ?
                     ",
-                    updated_reminder_time.with_timezone(&Utc),
+                    updated_reminder_time,
                     self.id
                 )
                 .execute(pool)
@@ -429,84 +386,15 @@ WHERE
                 .expect(&format!("Could not update time on Reminder {}", self.id));
             }
         } else {
-            self.set_sent(pool).await;
+            self.force_delete(pool).await;
         }
     }
 
-    async fn log_error(
-        &self,
-        pool: impl Executor<'_, Database = Database> + Copy,
-        error: &'static str,
-        debug_info: Option<impl std::fmt::Debug>,
-    ) {
-        let message = match debug_info {
-            Some(info) => format!(
-                "{}
-{:?}",
-                error, info
-            ),
-
-            None => error.to_string(),
-        };
-
-        error!("[Reminder {}] {}", self.id, message);
-
-        if *LOG_TO_DATABASE {
+    async fn force_delete(&self, pool: impl Executor<'_, Database = Database> + Copy) {
         sqlx::query!(
             "
-                INSERT INTO stat (type, reminder_id, message)
-                VALUES ('reminder_failed', ?, ?)
+DELETE FROM reminders WHERE `id` = ?
             ",
-                self.id,
-                message,
-            )
-            .execute(pool)
-            .await
-            .expect("Could not log error to database");
-        }
-    }
-
-    async fn log_success(&self, pool: impl Executor<'_, Database = Database> + Copy) {
-        if *LOG_TO_DATABASE {
-            sqlx::query!(
-                "
-                INSERT INTO stat (type, reminder_id)
-                VALUES ('reminder_sent', ?)
-                ",
-                self.id,
-            )
-            .execute(pool)
-            .await
-            .expect("Could not log success to database");
-        }
-    }
-
-    async fn set_sent(&self, pool: impl Executor<'_, Database = Database> + Copy) {
-        sqlx::query!(
-            "
-            UPDATE reminders
-            SET `status` = 'sent', `status_change_time` = NOW()
-            WHERE `id` = ?
-            ",
-            self.id
-        )
-        .execute(pool)
-        .await
-        .expect(&format!("Could not delete Reminder {}", self.id));
-    }
-
-    async fn set_failed(
-        &self,
-        pool: impl Executor<'_, Database = Database> + Copy,
-        message: &'static str,
-    ) {
-        sqlx::query!(
-            "
-            UPDATE reminders
-            SET `status` = 'failed', `status_message` = ?, `status_change_time` = NOW()
-            WHERE `id` = ?
-            ",
-            message,
             self.id
         )
         .execute(pool)
@@ -515,9 +403,7 @@ WHERE
     }
 
     async fn pin_message<M: Into<u64>>(&self, message_id: M, http: impl AsRef<Http>) {
-        if let Some(channel_id) = self.channel_id {
-            let _ = http.as_ref().pin_message(channel_id, message_id.into(), None).await;
-        }
+        let _ = http.as_ref().pin_message(self.channel_id, message_id.into(), None).await;
     }
 
     pub async fn send(
@@ -527,11 +413,10 @@ WHERE
     ) {
         async fn send_to_channel(
             cache_http: impl CacheHttp,
-            channel_id: u64,
             reminder: &Reminder,
             embed: Option<CreateEmbed>,
         ) -> Result<()> {
-            let channel = ChannelId(channel_id).to_channel(&cache_http).await;
+            let channel = ChannelId(reminder.channel_id).to_channel(&cache_http).await;
 
             match channel {
                 Ok(Channel::Guild(channel)) => {
@@ -563,7 +448,6 @@ WHERE
                         Err(e) => Err(e),
                     }
                 }
-
                 Ok(Channel::Private(channel)) => {
                     match channel
                         .send_message(&cache_http.http(), |m| {
@@ -593,9 +477,7 @@ WHERE
                         Err(e) => Err(e),
                     }
                 }
-
                 Err(e) => Err(e),
-
                 _ => Err(Error::Other("Channel not of valid type")),
             }
         }
@@ -611,10 +493,8 @@ WHERE
                     w.content(&reminder.content).tts(reminder.tts);
 
                     if let Some(username) = &reminder.username {
-                        if !username.is_empty() {
                         w.username(username);
                     }
-                    }
 
                     if let Some(avatar) = &reminder.avatar {
                         w.avatar_url(avatar);
@@ -650,19 +530,15 @@ WHERE
             }
         }
 
-        match self.channel_id {
-            Some(channel_id) => {
         if self.enabled
-                    && !(self.channel_paused.unwrap_or(false)
+            && !(self.channel_paused
                 && self
                     .channel_paused_until
                     .map_or(true, |inner| inner >= Utc::now().naive_local()))
         {
             let _ = sqlx::query!(
                 "
-                        UPDATE `channels`
-                        SET paused = 0, paused_until = NULL
-                        WHERE `channel` = ?
+UPDATE `channels` SET paused = 0, paused_until = NULL WHERE `channel` = ?
                 ",
                 self.channel_id
             )
@@ -674,112 +550,40 @@ WHERE
             let result = if let (Some(webhook_id), Some(webhook_token)) =
                 (self.webhook_id, &self.webhook_token)
             {
-                        let webhook_res = cache_http
-                            .http()
-                            .get_webhook_with_token(webhook_id, webhook_token)
-                            .await;
+                let webhook_res =
+                    cache_http.http().get_webhook_with_token(webhook_id, webhook_token).await;
 
                 if let Ok(webhook) = webhook_res {
                     send_to_webhook(cache_http, &self, webhook, embed).await
                 } else {
-                            warn!("Webhook vanished for reminder {}: {:?}", self.id, webhook_res);
+                    warn!("Webhook vanished: {:?}", webhook_res);
 
                     self.reset_webhook(pool).await;
-                            send_to_channel(cache_http, channel_id, &self, embed).await
+                    send_to_channel(cache_http, &self, embed).await
                 }
             } else {
-                        send_to_channel(cache_http, channel_id, &self, embed).await
+                send_to_channel(cache_http, &self, embed).await
             };
 
             if let Err(e) = result {
+                error!("Error sending {:?}: {:?}", self, e);
+
                 if let Error::Http(error) = e {
-                            if let HttpError::UnsuccessfulRequest(http_error) = *error {
-                                match http_error.error.code {
-                                    10003 => {
-                                        self.log_error(
-                                            pool,
-                                            "Could not be sent as channel does not exist",
-                                            None::<&'static str>,
-                                        )
-                                        .await;
-                                        self.set_failed(
-                                            pool,
-                                            "Could not be sent as channel does not exist",
-                                        )
-                                        .await;
-                                    }
-                                    10004 => {
-                                        self.log_error(
-                                            pool,
-                                            "Could not be sent as guild does not exist",
-                                            None::<&'static str>,
-                                        )
-                                        .await;
-                                        self.set_failed(
-                                            pool,
-                                            "Could not be sent as guild does not exist",
-                                        )
-                                        .await;
-                                    }
-                                    50001 => {
-                                        self.log_error(
-                                            pool,
-                                            "Could not be sent as missing access",
-                                            None::<&'static str>,
-                                        )
-                                        .await;
-                                        self.set_failed(
-                                            pool,
-                                            "Could not be sent as missing access",
-                                        )
-                                        .await;
-                                    }
-                                    50007 => {
-                                        self.log_error(
-                                            pool,
-                                            "Could not be sent as user has DMs disabled",
-                                            None::<&'static str>,
-                                        )
-                                        .await;
-                                        self.set_failed(
-                                            pool,
-                                            "Could not be sent as user has DMs disabled",
-                                        )
-                                        .await;
-                                    }
-                                    50013 => {
-                                        self.log_error(
-                                            pool,
-                                            "Could not be sent as permissions are invalid",
-                                            None::<&'static str>,
-                                        )
-                                        .await;
-                                        self.set_failed(
-                                            pool,
-                                            "Could not be sent as permissions are invalid",
-                                        )
-                                        .await;
-                                    }
-                                    _ => {
-                                        self.log_error(
-                                            pool,
-                                            "HTTP error sending reminder",
-                                            Some(http_error),
-                                        )
-                                        .await;
+                    if error.status_code() == Some(StatusCode::NOT_FOUND) {
+                        warn!("Seeing channel is deleted. Removing reminder");
+                        self.force_delete(pool).await;
+                    } else if let HttpError::UnsuccessfulRequest(error) = *error {
+                        if error.error.code == 50007 {
+                            warn!("User cannot receive DMs");
+                            self.force_delete(pool).await;
+                        } else {
                             self.refresh(pool).await;
                         }
                     }
                 } else {
-                                self.log_error(pool, "(Likely) a parsing error", Some(error)).await;
                     self.refresh(pool).await;
                 }
             } else {
-                            self.log_error(pool, "Non-HTTP error", Some(e)).await;
-                            self.refresh(pool).await;
-                        }
-                    } else {
-                        self.log_success(pool).await;
                 self.refresh(pool).await;
             }
         } else {
@@ -788,13 +592,4 @@ WHERE
             self.refresh(pool).await;
         }
     }
-
-            None => {
-                info!("Reminder {} is orphaned", self.id);
-
-                self.log_error(pool, "Orphaned", Option::<u8>::None).await;
-                self.set_failed(pool, "Could not be sent as channel was deleted").await;
-            }
-        }
-    }
 }

src/commands/autocomplete.rs

@@ -1,117 +0,0 @@
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use chrono_tz::TZ_VARIANTS;
-use poise::AutocompleteChoice;
-
-use crate::{models::CtxData, time_parser::natural_parser, Context};
-
-pub async fn timezone_autocomplete(ctx: Context<'_>, partial: &str) -> Vec<String> {
-    if partial.is_empty() {
-        ctx.data().popular_timezones.iter().map(|t| t.to_string()).collect::<Vec<String>>()
-    } else {
-        TZ_VARIANTS
-            .iter()
-            .filter(|tz| tz.to_string().contains(&partial))
-            .take(25)
-            .map(|t| t.to_string())
-            .collect::<Vec<String>>()
-    }
-}
-
-pub async fn macro_name_autocomplete(ctx: Context<'_>, partial: &str) -> Vec<String> {
-    sqlx::query!(
-        "
-SELECT name
-FROM macro
-WHERE
-    guild_id = (SELECT id FROM guilds WHERE guild = ?)
-    AND name LIKE CONCAT(?, '%')",
-        ctx.guild_id().unwrap().0,
-        partial,
-    )
-    .fetch_all(&ctx.data().database)
-    .await
-    .unwrap_or_default()
-    .iter()
-    .map(|s| s.name.clone())
-    .collect()
-}
-
-pub async fn time_hint_autocomplete(
-    ctx: Context<'_>,
-    partial: &str,
-) -> Vec<AutocompleteChoice<String>> {
-    if partial.is_empty() {
-        vec![AutocompleteChoice {
-            name: "Start typing a time...".to_string(),
-            value: "now".to_string(),
-        }]
-    } else {
-        match natural_parser(partial, &ctx.timezone().await.to_string()).await {
-            Some(timestamp) => match SystemTime::now().duration_since(UNIX_EPOCH) {
-                Ok(now) => {
-                    let diff = timestamp - now.as_secs() as i64;
-
-                    if diff < 0 {
-                        vec![AutocompleteChoice {
-                            name: "Time is in the past".to_string(),
-                            value: "1 year ago".to_string(),
-                        }]
-                    } else {
-                        if diff > 86400 {
-                            vec![
-                                AutocompleteChoice {
-                                    name: partial.to_string(),
-                                    value: partial.to_string(),
-                                },
-                                AutocompleteChoice {
-                                    name: format!(
-                                        "In approximately {} days, {} hours",
-                                        diff / 86400,
-                                        (diff % 86400) / 3600
-                                    ),
-                                    value: partial.to_string(),
-                                },
-                            ]
-                        } else if diff > 3600 {
-                            vec![
-                                AutocompleteChoice {
-                                    name: partial.to_string(),
-                                    value: partial.to_string(),
-                                },
-                                AutocompleteChoice {
-                                    name: format!("In approximately {} hours", diff / 3600),
-                                    value: partial.to_string(),
-                                },
-                            ]
-                        } else {
-                            vec![
-                                AutocompleteChoice {
-                                    name: partial.to_string(),
-                                    value: partial.to_string(),
-                                },
-                                AutocompleteChoice {
-                                    name: format!("In approximately {} minutes", diff / 60),
-                                    value: partial.to_string(),
-                                },
-                            ]
-                        }
-                    }
-                }
-                Err(_) => {
-                    vec![AutocompleteChoice {
-                        name: partial.to_string(),
-                        value: partial.to_string(),
-                    }]
-                }
-            },
-
-            None => {
-                vec![AutocompleteChoice {
-                    name: "Time not recognised".to_string(),
-                    value: "now".to_string(),
-                }]
-            }
-        }
-    }
-}

src/commands/command_macro/delete.rs

@@ -1,46 +0,0 @@
-use super::super::autocomplete::macro_name_autocomplete;
-use crate::{Context, Error};
-
-/// Delete a recorded macro
-#[poise::command(
-    slash_command,
-    rename = "delete",
-    guild_only = true,
-    default_member_permissions = "MANAGE_GUILD",
-    identifying_name = "delete_macro"
-)]
-pub async fn delete_macro(
-    ctx: Context<'_>,
-    #[description = "Name of macro to delete"]
-    #[autocomplete = "macro_name_autocomplete"]
-    name: String,
-) -> Result<(), Error> {
-    match sqlx::query!(
-        "
-SELECT id FROM macro WHERE guild_id = (SELECT id FROM guilds WHERE guild = ?) AND name = ?",
-        ctx.guild_id().unwrap().0,
-        name
-    )
-    .fetch_one(&ctx.data().database)
-    .await
-    {
-        Ok(row) => {
-            sqlx::query!("DELETE FROM macro WHERE id = ?", row.id)
-                .execute(&ctx.data().database)
-                .await
-                .unwrap();
-
-            ctx.say(format!("Macro \"{}\" deleted", name)).await?;
-        }
-
-        Err(sqlx::Error::RowNotFound) => {
-            ctx.say(format!("Macro \"{}\" not found", name)).await?;
-        }
-
-        Err(e) => {
-            panic!("{}", e);
-        }
-    }
-
-    Ok(())
-}

src/commands/command_macro/list.rs

@@ -1,89 +0,0 @@
-use poise::CreateReply;
-
-use crate::{
-    component_models::pager::{MacroPager, Pager},
-    consts::THEME_COLOR,
-    models::{command_macro::CommandMacro, CtxData},
-    Context, Error,
-};
-
-/// List recorded macros
-#[poise::command(
-    slash_command,
-    rename = "list",
-    guild_only = true,
-    default_member_permissions = "MANAGE_GUILD",
-    identifying_name = "list_macro"
-)]
-pub async fn list_macro(ctx: Context<'_>) -> Result<(), Error> {
-    let macros = ctx.command_macros().await?;
-
-    let resp = show_macro_page(&macros, 0);
-
-    ctx.send(|m| {
-        *m = resp;
-        m
-    })
-    .await?;
-
-    Ok(())
-}
-
-pub fn max_macro_page<U, E>(macros: &[CommandMacro<U, E>]) -> usize {
-    ((macros.len() as f64) / 25.0).ceil() as usize
-}
-
-pub fn show_macro_page<U, E>(macros: &[CommandMacro<U, E>], page: usize) -> CreateReply {
-    let pager = MacroPager::new(page);
-
-    if macros.is_empty() {
-        let mut reply = CreateReply::default();
-
-        reply.embed(|e| {
-            e.title("Macros")
-                .description("No Macros Set Up. Use `/macro record` to get started.")
-                .color(*THEME_COLOR)
-        });
-
-        return reply;
-    }
-
-    let pages = max_macro_page(macros);
-
-    let mut page = page;
-    if page >= pages {
-        page = pages - 1;
-    }
-
-    let lower = (page * 25).min(macros.len());
-    let upper = ((page + 1) * 25).min(macros.len());
-
-    let fields = macros[lower..upper].iter().map(|m| {
-        if let Some(description) = &m.description {
-            (
-                m.name.clone(),
-                format!("*{}*\n- Has {} commands", description, m.commands.len()),
-                true,
-            )
-        } else {
-            (m.name.clone(), format!("- Has {} commands", m.commands.len()), true)
-        }
-    });
-
-    let mut reply = CreateReply::default();
-
-    reply
-        .embed(|e| {
-            e.title("Macros")
-                .fields(fields)
-                .footer(|f| f.text(format!("Page {} of {}", page + 1, pages)))
-                .color(*THEME_COLOR)
-        })
-        .components(|comp| {
-            pager.create_button_row(pages, comp);
-
-            comp
-        });
-
-    reply
-}

src/commands/command_macro/migrate.rs

@@ -1,229 +0,0 @@
-use lazy_regex::regex;
-use poise::serenity_prelude::command::CommandOptionType;
-use regex::Captures;
-use serde_json::{json, Value};
-
-use crate::{models::command_macro::RawCommandMacro, Context, Error, GuildId};
-
-struct Alias {
-    name: String,
-    command: String,
-}
-
-/// Migrate old $alias reminder commands to macros. Only macro names that are not taken will be used.
-#[poise::command(
-    slash_command,
-    rename = "migrate",
-    guild_only = true,
-    default_member_permissions = "MANAGE_GUILD",
-    identifying_name = "migrate_macro"
-)]
-pub async fn migrate_macro(ctx: Context<'_>) -> Result<(), Error> {
-    let guild_id = ctx.guild_id().unwrap();
-    let mut transaction = ctx.data().database.begin().await?;
-
-    let aliases = sqlx::query_as!(
-        Alias,
-        "SELECT name, command FROM command_aliases WHERE guild_id = (SELECT id FROM guilds WHERE guild = ?)",
-        guild_id.0
-    )
-    .fetch_all(&mut *transaction)
-    .await?;
-
-    let mut added_aliases = 0;
-
-    for alias in aliases {
-        match parse_text_command(guild_id, alias.name, &alias.command) {
-            Some(cmd_macro) => {
-                sqlx::query!(
-                    "INSERT INTO macro (guild_id, name, description, commands) VALUES ((SELECT id FROM guilds WHERE guild = ?), ?, ?, ?)",
-                    cmd_macro.guild_id.0,
-                    cmd_macro.name,
-                    cmd_macro.description,
-                    cmd_macro.commands
-                )
-                .execute(&mut *transaction)
-                .await?;
-
-                added_aliases += 1;
-            }
-
-            None => {}
-        }
-    }
-
-    transaction.commit().await?;
-
-    ctx.send(|b| b.content(format!("Added {} macros.", added_aliases))).await?;
-
-    Ok(())
-}
-
-fn parse_text_command(
-    guild_id: GuildId,
-    alias_name: String,
-    command: &str,
-) -> Option<RawCommandMacro> {
-    match command.split_once(" ") {
-        Some((command_word, args)) => {
-            let command_word = command_word.to_lowercase();
-
-            if command_word == "r"
-                || command_word == "i"
-                || command_word == "remind"
-                || command_word == "interval"
-            {
-                let matcher = regex!(
-                    r#"(?P<mentions>(?:<@\d+>\s+|<@!\d+>\s+|<#\d+>\s+)*)(?P<time>(?:(?:\d+)(?:s|m|h|d|:|/|-|))+)(?:\s+(?P<interval>(?:(?:\d+)(?:s|m|h|d|))+))?(?:\s+(?P<expires>(?:(?:\d+)(?:s|m|h|d|:|/|-|))+))?\s+(?P<content>.*)"#s
-                );
-
-                match matcher.captures(&args) {
-                    Some(captures) => {
-                        let mut args: Vec<Value> = vec![];
-
-                        if let Some(group) = captures.name("time") {
-                            let content = group.as_str();
-                            args.push(json!({
-                                "name": "time",
-                                "value": content,
-                                "type": CommandOptionType::String,
-                            }));
-                        }
-
-                        if let Some(group) = captures.name("content") {
-                            let content = group.as_str();
-                            args.push(json!({
-                                "name": "content",
-                                "value": content,
-                                "type": CommandOptionType::String,
-                            }));
-                        }
-
-                        if let Some(group) = captures.name("interval") {
-                            let content = group.as_str();
-                            args.push(json!({
-                                "name": "interval",
-                                "value": content,
-                                "type": CommandOptionType::String,
-                            }));
-                        }
-
-                        if let Some(group) = captures.name("expires") {
-                            let content = group.as_str();
-                            args.push(json!({
-                                "name": "expires",
-                                "value": content,
-                                "type": CommandOptionType::String,
-                            }));
-                        }
-
-                        if let Some(group) = captures.name("mentions") {
-                            let content = group.as_str();
-                            args.push(json!({
-                                "name": "channels",
-                                "value": content,
-                                "type": CommandOptionType::String,
-                            }));
-                        }
-
-                        Some(RawCommandMacro {
-                            guild_id,
-                            name: alias_name,
-                            description: None,
-                            commands: json!([
-                                {
-                                    "command_name": "remind",
-                                    "options": args,
-                                }
-                            ]),
-                        })
-                    }
-
-                    None => None,
-                }
-            } else if command_word == "n" || command_word == "natural" {
-                let matcher_primary = regex!(
-                    r#"(?P<time>.*?)(?:\s+)(?:send|say)(?:\s+)(?P<content>.*?)(?:(?:\s+)to(?:\s+)(?P<mentions>((?:<@\d+>)|(?:<@!\d+>)|(?:<#\d+>)|(?:\s+))+))?$"#s
-                );
-                let matcher_secondary = regex!(
-                    r#"(?P<msg>.*)(?:\s+)every(?:\s+)(?P<interval>.*?)(?:(?:\s+)(?:until|for)(?:\s+)(?P<expires>.*?))?$"#s
-                );
-
-                match matcher_primary.captures(&args) {
-                    Some(captures) => {
-                        let captures_secondary = matcher_secondary.captures(&args);
-
-                        let mut args: Vec<Value> = vec![];
-
-                        if let Some(group) = captures.name("time") {
-                            let content = group.as_str();
-                            args.push(json!({
-                                "name": "time",
-                                "value": content,
-                                "type": CommandOptionType::String,
-                            }));
-                        }
-
-                        if let Some(group) = captures.name("content") {
-                            let content = group.as_str();
-                            args.push(json!({
-                                "name": "content",
-                                "value": content,
-                                "type": CommandOptionType::String,
-                            }));
-                        }
-
-                        if let Some(group) =
-                            captures_secondary.as_ref().and_then(|c: &Captures| c.name("interval"))
-                        {
-                            let content = group.as_str();
-                            args.push(json!({
-                                "name": "interval",
-                                "value": content,
-                                "type": CommandOptionType::String,
-                            }));
-                        }
-
-                        if let Some(group) =
-                            captures_secondary.and_then(|c: Captures| c.name("expires"))
-                        {
-                            let content = group.as_str();
-                            args.push(json!({
-                                "name": "expires",
-                                "value": content,
-                                "type": CommandOptionType::String,
-                            }));
-                        }
-
-                        if let Some(group) = captures.name("mentions") {
-                            let content = group.as_str();
-                            args.push(json!({
-                                "name": "channels",
-                                "value": content,
-                                "type": CommandOptionType::String,
-                            }));
-                        }
-
-                        Some(RawCommandMacro {
-                            guild_id,
-                            name: alias_name,
-                            description: None,
-                            commands: json!([
-                                {
-                                    "command_name": "remind",
-                                    "options": args,
-                                }
-                            ]),
-                        })
-                    }
-
-                    None => None,
-                }
-            } else {
-                None
-            }
-        }
-
-        None => None,
-    }
-}

src/commands/command_macro/mod.rs

@@ -1,19 +0,0 @@
-use crate::{Context, Error};
-
-pub mod delete;
-pub mod list;
-pub mod migrate;
-pub mod record;
-pub mod run;
-
-/// Record and replay command sequences
-#[poise::command(
-    slash_command,
-    rename = "macro",
-    guild_only = true,
-    default_member_permissions = "MANAGE_GUILD",
-    identifying_name = "macro_base"
-)]
-pub async fn macro_base(_ctx: Context<'_>) -> Result<(), Error> {
-    Ok(())
-}

src/commands/command_macro/record.rs

@@ -1,151 +0,0 @@
-use std::collections::hash_map::Entry;
-
-use crate::{consts::THEME_COLOR, models::command_macro::CommandMacro, Context, Error};
-
-/// Start recording up to 5 commands to replay
-#[poise::command(
-    slash_command,
-    rename = "record",
-    guild_only = true,
-    default_member_permissions = "MANAGE_GUILD",
-    identifying_name = "record_macro"
-)]
-pub async fn record_macro(
-    ctx: Context<'_>,
-    #[description = "Name for the new macro"] name: String,
-    #[description = "Description for the new macro"] description: Option<String>,
-) -> Result<(), Error> {
-    if name.len() > 100 {
-        ctx.say("Name must be less than 100 characters").await?;
-
-        return Ok(());
-    }
-
-    if description.as_ref().map_or(0, |d| d.len()) > 100 {
-        ctx.say("Description must be less than 100 characters").await?;
-
-        return Ok(());
-    }
-
-    let guild_id = ctx.guild_id().unwrap();
-
-    let row = sqlx::query!(
-        "
-SELECT 1 as _e FROM macro WHERE guild_id = (SELECT id FROM guilds WHERE guild = ?) AND name = ?",
-        guild_id.0,
-        name
-    )
-    .fetch_one(&ctx.data().database)
-    .await;
-
-    if row.is_ok() {
-        ctx.send(|m| {
-            m.ephemeral(true).embed(|e| {
-                e.title("Unique Name Required")
-                    .description(
-                        "A macro already exists under this name.
-Please select a unique name for your macro.",
-                    )
-                    .color(*THEME_COLOR)
-            })
-        })
-        .await?;
-    } else {
-        let okay = {
-            let mut lock = ctx.data().recording_macros.write().await;
-
-            if let Entry::Vacant(e) = lock.entry((guild_id, ctx.author().id)) {
-                e.insert(CommandMacro { guild_id, name, description, commands: vec![] });
-                true
-            } else {
-                false
-            }
-        };
-
-        if okay {
-            ctx.send(|m| {
-                m.ephemeral(true).embed(|e| {
-                    e.title("Macro Recording Started")
-                        .description(
-                            "Run up to 5 commands, or type `/macro finish` to stop at any point.
-Any commands ran as part of recording will be inconsequential",
-                        )
-                        .color(*THEME_COLOR)
-                })
-            })
-            .await?;
-        } else {
-            ctx.send(|m| {
-                m.ephemeral(true).embed(|e| {
-                    e.title("Macro Already Recording")
-                        .description(
-                            "You are already recording a macro in this server.
-Please use `/macro finish` to end this recording before starting another.",
-                        )
-                        .color(*THEME_COLOR)
-                })
-            })
-            .await?;
-        }
-    }
-
-    Ok(())
-}
-
-/// Finish current macro recording
-#[poise::command(
-    slash_command,
-    rename = "finish",
-    guild_only = true,
-    default_member_permissions = "MANAGE_GUILD",
-    identifying_name = "finish_macro"
-)]
-pub async fn finish_macro(ctx: Context<'_>) -> Result<(), Error> {
-    let key = (ctx.guild_id().unwrap(), ctx.author().id);
-
-    {
-        let lock = ctx.data().recording_macros.read().await;
-        let contained = lock.get(&key);
-
-        if contained.map_or(true, |cmacro| cmacro.commands.is_empty()) {
-            ctx.send(|m| {
-                m.embed(|e| {
-                    e.title("No Macro Recorded")
-                        .description("Use `/macro record` to start recording a macro")
-                        .color(*THEME_COLOR)
-                })
-            })
-            .await?;
-        } else {
-            let command_macro = contained.unwrap();
-            let json = serde_json::to_string(&command_macro.commands).unwrap();
-
-            sqlx::query!(
-                "INSERT INTO macro (guild_id, name, description, commands) VALUES ((SELECT id FROM guilds WHERE guild = ?), ?, ?, ?)",
-                command_macro.guild_id.0,
-                command_macro.name,
-                command_macro.description,
-                json
-            )
-                .execute(&ctx.data().database)
-                .await
-                .unwrap();
-
-            ctx.send(|m| {
-                m.embed(|e| {
-                    e.title("Macro Recorded")
-                        .description("Use `/macro run` to execute the macro")
-                        .color(*THEME_COLOR)
-                })
-            })
-            .await?;
-        }
-    }
-
-    {
-        let mut lock = ctx.data().recording_macros.write().await;
-        lock.remove(&key);
-    }
-
-    Ok(())
-}

src/commands/command_macro/run.rs

@@ -1,56 +0,0 @@
-use super::super::autocomplete::macro_name_autocomplete;
-use crate::{models::command_macro::guild_command_macro, Context, Data, Error, THEME_COLOR};
-
-/// Run a recorded macro
-#[poise::command(
-    slash_command,
-    rename = "run",
-    guild_only = true,
-    default_member_permissions = "MANAGE_GUILD",
-    identifying_name = "run_macro"
-)]
-pub async fn run_macro(
-    ctx: poise::ApplicationContext<'_, Data, Error>,
-    #[description = "Name of macro to run"]
-    #[autocomplete = "macro_name_autocomplete"]
-    name: String,
-) -> Result<(), Error> {
-    match guild_command_macro(&Context::Application(ctx), &name).await {
-        Some(command_macro) => {
-            Context::Application(ctx)
-                .send(|b| {
-                    b.embed(|e| {
-                        e.title("Running Macro").color(*THEME_COLOR).description(format!(
-                            "Running macro {} ({} commands)",
-                            command_macro.name,
-                            command_macro.commands.len()
-                        ))
-                    })
-                })
-                .await?;
-
-            for command in command_macro.commands {
-                if let Some(action) = command.action {
-                    match (action)(poise::ApplicationContext { args: &command.options, ..ctx })
-                        .await
-                    {
-                        Ok(()) => {}
-                        Err(e) => {
-                            println!("{:?}", e);
-                        }
-                    }
-                } else {
-                    Context::Application(ctx)
-                        .say(format!("Command \"{}\" not found", command.command_name))
-                        .await?;
-                }
-            }
-        }
-
-        None => {
-            Context::Application(ctx).say(format!("Macro \"{}\" not found", name)).await?;
-        }
-    }
-
-    Ok(())
-}

src/commands/info_cmds.rs

@@ -6,8 +6,8 @@ use crate::{models::CtxData, Context, Error, THEME_COLOR};
 fn footer(
     ctx: Context<'_>,
 ) -> impl FnOnce(&mut serenity::CreateEmbedFooter) -> &mut serenity::CreateEmbedFooter {
-    let shard_count = ctx.serenity_context().cache.shard_count();
-    let shard = ctx.serenity_context().shard_id;
+    let shard_count = ctx.discord().cache.shard_count();
+    let shard = ctx.discord().shard_id;
 
     move |f| {
         f.text(format!(
@@ -49,7 +49,6 @@ __Todo Commands__
 
 __Setup Commands__
 `/timezone` - Set your timezone (necessary for `/remind` to work properly)
-`/dm allow/block` - Change your DM settings for reminders.
 
 __Advanced Commands__
 `/macro` - Record and replay command sequences

src/commands/mod.rs

@@ -1,5 +1,3 @@
-mod autocomplete;
-pub mod command_macro;
 pub mod info_cmds;
 pub mod moderation_cmds;
 pub mod reminder_cmds;

src/commands/moderation_cmds.rs

@@ -1,10 +1,32 @@
+use std::collections::hash_map::Entry;
+
 use chrono::offset::Utc;
 use chrono_tz::{Tz, TZ_VARIANTS};
 use levenshtein::levenshtein;
-use log::warn;
+use poise::CreateReply;
 
-use super::autocomplete::timezone_autocomplete;
-use crate::{consts::THEME_COLOR, models::CtxData, Context, Error};
+use crate::{
+    component_models::pager::{MacroPager, Pager},
+    consts::{EMBED_DESCRIPTION_MAX_LENGTH, THEME_COLOR},
+    models::{
+        command_macro::{guild_command_macro, CommandMacro},
+        CtxData,
+    },
+    Context, Data, Error,
+};
+
+async fn timezone_autocomplete(ctx: Context<'_>, partial: String) -> Vec<String> {
+    if partial.is_empty() {
+        ctx.data().popular_timezones.iter().map(|t| t.to_string()).collect::<Vec<String>>()
+    } else {
+        TZ_VARIANTS
+            .iter()
+            .filter(|tz| tz.to_string().contains(&partial))
+            .take(25)
+            .map(|t| t.to_string())
+            .collect::<Vec<String>>()
+    }
+}
 
 /// Select your timezone
 #[poise::command(slash_command, identifying_name = "timezone")]
@@ -102,154 +124,376 @@ You may want to use one of the popular timezones below, otherwise click [here](h
     Ok(())
 }
 
-/// Configure server settings
+async fn macro_name_autocomplete(ctx: Context<'_>, partial: String) -> Vec<String> {
+    sqlx::query!(
+        "
+SELECT name
+FROM macro
+WHERE
+    guild_id = (SELECT id FROM guilds WHERE guild = ?)
+    AND name LIKE CONCAT(?, '%')",
+        ctx.guild_id().unwrap().0,
+        partial,
+    )
+    .fetch_all(&ctx.data().database)
+    .await
+    .unwrap_or_default()
+    .iter()
+    .map(|s| s.name.clone())
+    .collect()
+}
+
+/// Record and replay command sequences
 #[poise::command(
     slash_command,
-    rename = "settings",
-    identifying_name = "settings",
-    guild_only = true
+    rename = "macro",
+    guild_only = true,
+    default_member_permissions = "MANAGE_GUILD",
+    identifying_name = "macro_base"
 )]
-pub async fn settings(_ctx: Context<'_>) -> Result<(), Error> {
+pub async fn macro_base(_ctx: Context<'_>) -> Result<(), Error> {
     Ok(())
 }
 
-/// Configure ephemeral setup
+/// Start recording up to 5 commands to replay
 #[poise::command(
     slash_command,
-    rename = "ephemeral",
-    identifying_name = "ephemeral_confirmations",
-    guild_only = true
+    rename = "record",
+    guild_only = true,
+    default_member_permissions = "MANAGE_GUILD",
+    identifying_name = "record_macro"
 )]
-pub async fn ephemeral_confirmations(_ctx: Context<'_>) -> Result<(), Error> {
-    Ok(())
-}
+pub async fn record_macro(
+    ctx: Context<'_>,
+    #[description = "Name for the new macro"] name: String,
+    #[description = "Description for the new macro"] description: Option<String>,
+) -> Result<(), Error> {
+    let guild_id = ctx.guild_id().unwrap();
 
-/// Set reminder confirmations to be sent "ephemerally" (private and cleared automatically)
-#[poise::command(
-    slash_command,
-    rename = "on",
-    identifying_name = "set_ephemeral_confirmations",
-    guild_only = true
-)]
-pub async fn set_ephemeral_confirmations(ctx: Context<'_>) -> Result<(), Error> {
-    let mut guild_data = ctx.guild_data().await.unwrap()?;
-    guild_data.ephemeral_confirmations = true;
-    guild_data.commit_changes(&ctx.data().database).await;
+    let row = sqlx::query!(
+        "
+SELECT 1 as _e FROM macro WHERE guild_id = (SELECT id FROM guilds WHERE guild = ?) AND name = ?",
+        guild_id.0,
+        name
+    )
+    .fetch_one(&ctx.data().database)
+    .await;
 
-    ctx.send(|r| {
-        r.ephemeral(true).embed(|e| {
-            e.title("Confirmations ephemeral")
-                .description("Reminder confirmations will be sent privately, and removed when your client restarts.")
-                .color(*THEME_COLOR)
-        })
-    })
-    .await?;
-
-    Ok(())
-}
-
-/// Set reminder confirmations to persist indefinitely
-#[poise::command(
-    slash_command,
-    rename = "off",
-    identifying_name = "unset_ephemeral_confirmations",
-    guild_only = true
-)]
-pub async fn unset_ephemeral_confirmations(ctx: Context<'_>) -> Result<(), Error> {
-    let mut guild_data = ctx.guild_data().await.unwrap()?;
-    guild_data.ephemeral_confirmations = false;
-    guild_data.commit_changes(&ctx.data().database).await;
-
-    ctx.send(|r| {
-        r.ephemeral(true).embed(|e| {
-            e.title("Confirmations public")
+    if row.is_ok() {
+        ctx.send(|m| {
+            m.ephemeral(true).embed(|e| {
+                e.title("Unique Name Required")
                     .description(
-                    "Reminder confirmations will be sent as regular messages, and won't be removed automatically.",
+                        "A macro already exists under this name.
+Please select a unique name for your macro.",
                     )
                     .color(*THEME_COLOR)
             })
         })
         .await?;
-
-    Ok(())
-}
-
-/// Configure whether other users can set reminders to your direct messages
-#[poise::command(slash_command, rename = "dm", identifying_name = "allowed_dm")]
-pub async fn allowed_dm(_ctx: Context<'_>) -> Result<(), Error> {
-    Ok(())
-}
-
-/// Allow other users to set reminders in your direct messages
-#[poise::command(slash_command, rename = "allow", identifying_name = "set_allowed_dm")]
-pub async fn set_allowed_dm(ctx: Context<'_>) -> Result<(), Error> {
-    let mut user_data = ctx.author_data().await?;
-    user_data.allowed_dm = true;
-    user_data.commit_changes(&ctx.data().database).await;
-
-    ctx.send(|r| {
-        r.ephemeral(true).embed(|e| {
-            e.title("DMs permitted")
-                .description("You will receive a message if a user sets a DM reminder for you.")
-                .color(*THEME_COLOR)
-        })
-    })
-    .await?;
-
-    Ok(())
-}
-
-/// Block other users from setting reminders in your direct messages
-#[poise::command(slash_command, rename = "block", identifying_name = "unset_allowed_dm")]
-pub async fn unset_allowed_dm(ctx: Context<'_>) -> Result<(), Error> {
-    let mut user_data = ctx.author_data().await?;
-    user_data.allowed_dm = false;
-    user_data.commit_changes(&ctx.data().database).await;
-
-    ctx.send(|r| {
-        r.ephemeral(true).embed(|e| {
-            e.title("DMs blocked")
-                .description(
-                    "You can still set DM reminders for yourself or for users with DMs enabled.",
-                )
-                .color(*THEME_COLOR)
-        })
-    })
-    .await?;
-
-    Ok(())
-}
-
-/// View the webhook being used to send reminders to this channel
-#[poise::command(
-    slash_command,
-    identifying_name = "webhook_url",
-    required_permissions = "ADMINISTRATOR"
-)]
-pub async fn webhook(ctx: Context<'_>) -> Result<(), Error> {
-    match ctx.channel_data().await {
-        Ok(data) => {
-            if let (Some(id), Some(token)) = (data.webhook_id, data.webhook_token) {
-                ctx.send(|b| {
-                    b.ephemeral(true).content(format!(
-                        "**Warning!**
-This link can be used by users to anonymously send messages, with or without permissions.
-Do not share it!
-|| https://discord.com/api/webhooks/{}/{} ||",
-                        id, token,
-                    ))
-                })
-                .await?;
     } else {
-                ctx.say("No webhook configured on this channel.").await?;
-            }
-        }
-        Err(e) => {
-            warn!("Error fetching channel data: {:?}", e);
+        let okay = {
+            let mut lock = ctx.data().recording_macros.write().await;
 
-            ctx.say("No webhook configured on this channel.").await?;
+            if let Entry::Vacant(e) = lock.entry((guild_id, ctx.author().id)) {
+                e.insert(CommandMacro { guild_id, name, description, commands: vec![] });
+                true
+            } else {
+                false
+            }
+        };
+
+        if okay {
+            ctx.send(|m| {
+                m.ephemeral(true).embed(|e| {
+                    e.title("Macro Recording Started")
+                        .description(
+                            "Run up to 5 commands, or type `/macro finish` to stop at any point.
+Any commands ran as part of recording will be inconsequential",
+                        )
+                        .color(*THEME_COLOR)
+                })
+            })
+            .await?;
+        } else {
+            ctx.send(|m| {
+                m.ephemeral(true).embed(|e| {
+                    e.title("Macro Already Recording")
+                        .description(
+                            "You are already recording a macro in this server.
+Please use `/macro finish` to end this recording before starting another.",
+                        )
+                        .color(*THEME_COLOR)
+                })
+            })
+            .await?;
         }
     }
 
     Ok(())
 }
+
+/// Finish current macro recording
+#[poise::command(
+    slash_command,
+    rename = "finish",
+    guild_only = true,
+    default_member_permissions = "MANAGE_GUILD",
+    identifying_name = "finish_macro"
+)]
+pub async fn finish_macro(ctx: Context<'_>) -> Result<(), Error> {
+    let key = (ctx.guild_id().unwrap(), ctx.author().id);
+
+    {
+        let lock = ctx.data().recording_macros.read().await;
+        let contained = lock.get(&key);
+
+        if contained.map_or(true, |cmacro| cmacro.commands.is_empty()) {
+            ctx.send(|m| {
+                m.embed(|e| {
+                    e.title("No Macro Recorded")
+                        .description("Use `/macro record` to start recording a macro")
+                        .color(*THEME_COLOR)
+                })
+            })
+            .await?;
+        } else {
+            let command_macro = contained.unwrap();
+            let json = serde_json::to_string(&command_macro.commands).unwrap();
+
+            sqlx::query!(
+                "INSERT INTO macro (guild_id, name, description, commands) VALUES ((SELECT id FROM guilds WHERE guild = ?), ?, ?, ?)",
+                command_macro.guild_id.0,
+                command_macro.name,
+                command_macro.description,
+                json
+            )
+                .execute(&ctx.data().database)
+                .await
+                .unwrap();
+
+            ctx.send(|m| {
+                m.embed(|e| {
+                    e.title("Macro Recorded")
+                        .description("Use `/macro run` to execute the macro")
+                        .color(*THEME_COLOR)
+                })
+            })
+            .await?;
+        }
+    }
+
+    {
+        let mut lock = ctx.data().recording_macros.write().await;
+        lock.remove(&key);
+    }
+
+    Ok(())
+}
+
+/// List recorded macros
+#[poise::command(
+    slash_command,
+    rename = "list",
+    guild_only = true,
+    default_member_permissions = "MANAGE_GUILD",
+    identifying_name = "list_macro"
+)]
+pub async fn list_macro(ctx: Context<'_>) -> Result<(), Error> {
+    let macros = ctx.command_macros().await?;
+
+    let resp = show_macro_page(&macros, 0);
+
+    ctx.send(|m| {
+        *m = resp;
+        m
+    })
+    .await?;
+
+    Ok(())
+}
+
+/// Run a recorded macro
+#[poise::command(
+    slash_command,
+    rename = "run",
+    guild_only = true,
+    default_member_permissions = "MANAGE_GUILD",
+    identifying_name = "run_macro"
+)]
+pub async fn run_macro(
+    ctx: poise::ApplicationContext<'_, Data, Error>,
+    #[description = "Name of macro to run"]
+    #[autocomplete = "macro_name_autocomplete"]
+    name: String,
+) -> Result<(), Error> {
+    match guild_command_macro(&Context::Application(ctx), &name).await {
+        Some(command_macro) => {
+            ctx.defer_response(false).await?;
+
+            for command in command_macro.commands {
+                if let Some(action) = command.action {
+                    match (action)(poise::ApplicationContext { args: &command.options, ..ctx })
+                        .await
+                    {
+                        Ok(()) => {}
+                        Err(e) => {
+                            println!("{:?}", e);
+                        }
+                    }
+                } else {
+                    Context::Application(ctx)
+                        .say(format!("Command \"{}\" not found", command.command_name))
+                        .await?;
+                }
+            }
+        }
+
+        None => {
+            Context::Application(ctx).say(format!("Macro \"{}\" not found", name)).await?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Delete a recorded macro
+#[poise::command(
+    slash_command,
+    rename = "delete",
+    guild_only = true,
+    default_member_permissions = "MANAGE_GUILD",
+    identifying_name = "delete_macro"
+)]
+pub async fn delete_macro(
+    ctx: Context<'_>,
+    #[description = "Name of macro to delete"]
+    #[autocomplete = "macro_name_autocomplete"]
+    name: String,
+) -> Result<(), Error> {
+    match sqlx::query!(
+        "
+SELECT id FROM macro WHERE guild_id = (SELECT id FROM guilds WHERE guild = ?) AND name = ?",
+        ctx.guild_id().unwrap().0,
+        name
+    )
+    .fetch_one(&ctx.data().database)
+    .await
+    {
+        Ok(row) => {
+            sqlx::query!("DELETE FROM macro WHERE id = ?", row.id)
+                .execute(&ctx.data().database)
+                .await
+                .unwrap();
+
+            ctx.say(format!("Macro \"{}\" deleted", name)).await?;
+        }
+
+        Err(sqlx::Error::RowNotFound) => {
+            ctx.say(format!("Macro \"{}\" not found", name)).await?;
+        }
+
+        Err(e) => {
+            panic!("{}", e);
+        }
+    }
+
+    Ok(())
+}
+
+pub fn max_macro_page<U, E>(macros: &[CommandMacro<U, E>]) -> usize {
+    let mut skipped_char_count = 0;
+
+    macros
+        .iter()
+        .map(|m| {
+            if let Some(description) = &m.description {
+                format!("**{}**\n- *{}*\n- Has {} commands", m.name, description, m.commands.len())
+            } else {
+                format!("**{}**\n- Has {} commands", m.name, m.commands.len())
+            }
+        })
+        .fold(1, |mut pages, p| {
+            skipped_char_count += p.len();
+
+            if skipped_char_count > EMBED_DESCRIPTION_MAX_LENGTH {
+                skipped_char_count = p.len();
+                pages += 1;
+            }
+
+            pages
+        })
+}
+
+pub fn show_macro_page<U, E>(macros: &[CommandMacro<U, E>], page: usize) -> CreateReply {
+    let pager = MacroPager::new(page);
+
+    if macros.is_empty() {
+        let mut reply = CreateReply::default();
+
+        reply.embed(|e| {
+            e.title("Macros")
+                .description("No Macros Set Up. Use `/macro record` to get started.")
+                .color(*THEME_COLOR)
+        });
+
+        return reply;
+    }
+
+    let pages = max_macro_page(macros);
+
+    let mut page = page;
+    if page >= pages {
+        page = pages - 1;
+    }
+
+    let mut char_count = 0;
+    let mut skipped_char_count = 0;
+
+    let mut skipped_pages = 0;
+
+    let display_vec: Vec<String> = macros
+        .iter()
+        .map(|m| {
+            if let Some(description) = &m.description {
+                format!("**{}**\n- *{}*\n- Has {} commands", m.name, description, m.commands.len())
+            } else {
+                format!("**{}**\n- Has {} commands", m.name, m.commands.len())
+            }
+        })
+        .skip_while(|p| {
+            skipped_char_count += p.len();
+
+            if skipped_char_count > EMBED_DESCRIPTION_MAX_LENGTH {
+                skipped_char_count = p.len();
+                skipped_pages += 1;
+            }
+
+            skipped_pages < page
+        })
+        .take_while(|p| {
+            char_count += p.len();
+
+            char_count < EMBED_DESCRIPTION_MAX_LENGTH
+        })
+        .collect::<Vec<String>>();
+
+    let display = display_vec.join("\n");
+
+    let mut reply = CreateReply::default();
+
+    reply
+        .embed(|e| {
+            e.title("Macros")
+                .description(display)
+                .footer(|f| f.text(format!("Page {} of {}", page + 1, pages)))
+                .color(*THEME_COLOR)
+        })
+        .components(|comp| {
+            pager.create_button_row(pages, comp);
+
+            comp
+        });
+
+    reply
+}

src/commands/reminder_cmds.rs

@@ -1,18 +1,19 @@
-use std::{collections::HashSet, string::ToString};
+use std::{
+    collections::HashSet,
+    string::ToString,
+    time::{SystemTime, UNIX_EPOCH},
+};
 
-use chrono::{DateTime, NaiveDateTime, Utc};
+use chrono::NaiveDateTime;
 use chrono_tz::Tz;
-use log::warn;
 use num_integer::Integer;
 use poise::{
-    serenity_prelude::{
-        builder::CreateEmbed, component::ButtonStyle, model::channel::Channel, ReactionType,
-    },
-    CreateReply, Modal,
+    serenity::{builder::CreateEmbed, model::channel::Channel},
+    serenity_prelude::{ButtonStyle, ReactionType},
+    CreateReply,
 };
 
 use crate::{
-    commands::autocomplete::{time_hint_autocomplete, timezone_autocomplete},
     component_models::{
         pager::{DelPager, LookPager, Pager},
         ComponentDataModel, DelSelector, UndoReminder,
@@ -35,7 +36,7 @@ use crate::{
     },
     time_parser::natural_parser,
     utils::{check_guild_subscription, check_subscription},
-    ApplicationContext, Context, Error,
+    Context, Error,
 };
 
 /// Pause all reminders on the current channel until a certain time or indefinitely
@@ -57,8 +58,8 @@ pub async fn pause(
             let parsed = natural_parser(&until, &timezone.to_string()).await;
 
             if let Some(timestamp) = parsed {
-                match NaiveDateTime::from_timestamp_opt(timestamp, 0) {
-                    Some(dt) => {
+                let dt = NaiveDateTime::from_timestamp(timestamp, 0);
+
                 channel.paused = true;
                 channel.paused_until = Some(dt);
 
@@ -69,15 +70,6 @@ pub async fn pause(
                     timestamp
                 ))
                 .await?;
-                    }
-
-                    None => {
-                        ctx.say(format!(
-                            "Time processed could not be interpreted as `DateTime`. Please write the time as clearly as possible",
-                        ))
-                        .await?;
-                    }
-                }
             } else {
                 ctx.say(
                     "Time could not be processed. Please write the time as clearly as possible",
@@ -216,7 +208,7 @@ pub async fn look(
         }),
     };
 
-    let channel_opt = ctx.channel_id().to_channel_cached(&ctx);
+    let channel_opt = ctx.channel_id().to_channel_cached(&ctx.discord());
 
     let channel_id = if let Some(Channel::Guild(channel)) = channel_opt {
         if Some(channel.guild_id) == ctx.guild_id() {
@@ -228,7 +220,8 @@ pub async fn look(
         ctx.channel_id()
     };
 
-    let channel_name = if let Some(Channel::Guild(channel)) = channel_id.to_channel_cached(&ctx) {
+    let channel_name =
+        if let Some(Channel::Guild(channel)) = channel_id.to_channel_cached(&ctx.discord()) {
             Some(channel.name)
         } else {
             None
@@ -250,7 +243,7 @@ pub async fn look(
                 char_count < EMBED_DESCRIPTION_MAX_LENGTH
             })
             .collect::<Vec<String>>()
-            .join("");
+            .join("\n");
 
         let pages = reminders
             .iter()
@@ -294,7 +287,8 @@ pub async fn delete(ctx: Context<'_>) -> Result<(), Error> {
     let timezone = ctx.timezone().await;
 
     let reminders =
-        Reminder::from_guild(&ctx, &ctx.data().database, ctx.guild_id(), ctx.author().id).await;
+        Reminder::from_guild(&ctx.discord(), &ctx.data().database, ctx.guild_id(), ctx.author().id)
+            .await;
 
     let resp = show_delete_page(&reminders, 0, timezone);
 
@@ -436,8 +430,11 @@ pub fn show_delete_page(reminders: &[Reminder], page: usize, timezone: Tz) -> Cr
     reply
 }
 
-fn time_difference(start_time: DateTime<Utc>) -> String {
-    let delta = (Utc::now() - start_time).num_seconds();
+fn time_difference(start_time: NaiveDateTime) -> String {
+    let unix_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() as i64;
+    let now = NaiveDateTime::from_timestamp(unix_time, 0);
+
+    let delta = (now - start_time).num_seconds();
 
     let (minutes, seconds) = delta.div_rem(&60);
     let (hours, minutes) = minutes.div_rem(&60);
@@ -551,104 +548,23 @@ pub async fn delete_timer(
     Ok(())
 }
 
-#[derive(poise::Modal)]
-#[name = "Reminder"]
-struct ContentModal {
-    #[name = "Content"]
-    #[placeholder = "Message..."]
-    #[paragraph]
-    #[max_length = 2000]
-    content: String,
-}
-
-/// Create a reminder with multi-line content. Press "+4 more" for other options.
-#[poise::command(
-    slash_command,
-    identifying_name = "multiline",
-    default_member_permissions = "MANAGE_GUILD"
-)]
-pub async fn multiline(
-    ctx: ApplicationContext<'_>,
-    #[description = "A description of the time to set the reminder for"]
-    #[autocomplete = "time_hint_autocomplete"]
-    time: String,
-    #[description = "Channel or user mentions to set the reminder for"] channels: Option<String>,
-    #[description = "(Patreon only) Time to wait before repeating the reminder. Leave blank for one-shot reminder"]
-    interval: Option<String>,
-    #[description = "(Patreon only) For repeating reminders, the time at which the reminder will stop repeating"]
-    expires: Option<String>,
-    #[description = "Set the TTS flag on the reminder message, similar to the /tts command"]
-    tts: Option<bool>,
-    #[description = "Set a timezone override for this reminder only"]
-    #[autocomplete = "timezone_autocomplete"]
-    timezone: Option<String>,
-) -> Result<(), Error> {
-    let tz = timezone.map(|t| t.parse::<Tz>().ok()).flatten();
-    let data_opt = ContentModal::execute(ctx).await?;
-
-    match data_opt {
-        Some(data) => {
-            create_reminder(
-                Context::Application(ctx),
-                time,
-                data.content,
-                channels,
-                interval,
-                expires,
-                tts,
-                tz,
-            )
-            .await
-        }
-
-        None => {
-            warn!("Unexpected None encountered in /multiline");
-            Ok(Context::Application(ctx)
-                .send(|m| m.content("Unexpected error.").ephemeral(true))
-                .await
-                .map(|_| ())?)
-        }
-    }
-}
-
-/// Create a reminder. Press "+4 more" for other options. Use "/multiline" for multiline content.
+/// Create a new reminder
 #[poise::command(
     slash_command,
     identifying_name = "remind",
     default_member_permissions = "MANAGE_GUILD"
 )]
 pub async fn remind(
-    ctx: ApplicationContext<'_>,
-    #[description = "A description of the time to set the reminder for"]
-    #[autocomplete = "time_hint_autocomplete"]
-    time: String,
+    ctx: Context<'_>,
+    #[description = "A description of the time to set the reminder for"] time: String,
     #[description = "The message content to send"] content: String,
     #[description = "Channel or user mentions to set the reminder for"] channels: Option<String>,
     #[description = "(Patreon only) Time to wait before repeating the reminder. Leave blank for one-shot reminder"]
     interval: Option<String>,
-    #[description = "(Patreon only) For repeating reminders, the time at which the reminder will stop repeating"]
+    #[description = "(Patreon only) For repeating reminders, the time at which the reminder will stop sending"]
     expires: Option<String>,
     #[description = "Set the TTS flag on the reminder message, similar to the /tts command"]
     tts: Option<bool>,
-    #[description = "Set a timezone override for this reminder only"]
-    #[autocomplete = "timezone_autocomplete"]
-    timezone: Option<String>,
-) -> Result<(), Error> {
-    let tz = timezone.map(|t| t.parse::<Tz>().ok()).flatten();
-
-    create_reminder(Context::Application(ctx), time, content, channels, interval, expires, tts, tz)
-        .await
-}
-
-async fn create_reminder(
-    ctx: Context<'_>,
-    time: String,
-    content: String,
-    channels: Option<String>,
-    interval: Option<String>,
-    expires: Option<String>,
-    tts: Option<bool>,
-    timezone: Option<Tz>,
 ) -> Result<(), Error> {
     if interval.is_none() && expires.is_some() {
         ctx.say("`expires` can only be used with `interval`").await?;
@@ -656,16 +572,10 @@ async fn create_reminder(
         return Ok(());
     }
 
-    let ephemeral =
-        ctx.guild_data().await.map_or(false, |gr| gr.map_or(false, |g| g.ephemeral_confirmations));
-    if ephemeral {
-        ctx.defer_ephemeral().await?;
-    } else {
     ctx.defer().await?;
-    }
 
     let user_data = ctx.author_data().await.unwrap();
-    let timezone = timezone.unwrap_or(ctx.timezone().await);
+    let timezone = ctx.timezone().await;
 
     let time = natural_parser(&time, &timezone.to_string()).await;
 
@@ -692,9 +602,9 @@ async fn create_reminder(
             };
 
             let (processed_interval, processed_expires) = if let Some(repeat) = &interval {
-                if check_subscription(&ctx, ctx.author().id).await
+                if check_subscription(&ctx.discord(), ctx.author().id).await
                     || (ctx.guild_id().is_some()
-                        && check_guild_subscription(&ctx, ctx.guild_id().unwrap()).await)
+                        && check_guild_subscription(&ctx.discord(), ctx.guild_id().unwrap()).await)
                 {
                     (
                         parse_duration(repeat)
@@ -709,10 +619,9 @@ async fn create_reminder(
                         },
                     )
                 } else {
-                    ctx.send(|b| {
-                        b.content(
-                        "`repeat` is only available to Patreon subscribers or self-hosted users")
-                    })
+                    ctx.say(
+                        "`repeat` is only available to Patreon subscribers or self-hosted users",
+                    )
                     .await?;
 
                     return Ok(());
@@ -722,17 +631,12 @@ async fn create_reminder(
             };
 
             if processed_interval.is_none() && interval.is_some() {
-                ctx.send(|b| {
-                    b.content(
-                    "Repeat interval could not be processed. Try similar to `1 hour` or `4 days`")
-                })
+                ctx.say(
+                    "Repeat interval could not be processed. Try similar to `1 hour` or `4 days`",
+                )
                 .await?;
             } else if processed_expires.is_none() && expires.is_some() {
-                ctx.send(|b| {
-                    b.ephemeral(true).content(
-                        "Expiry time failed to process. Please make it as clear as possible",
-                    )
-                })
+                ctx.say("Expiry time failed to process. Please make it as clear as possible")
                     .await?;
             } else {
                 let mut builder = MultiReminderBuilder::new(&ctx, ctx.guild_id())
@@ -790,7 +694,6 @@ async fn create_reminder(
                 }
             }
         }
-
         None => {
             ctx.say("Time could not be processed").await?;
         }

src/commands/todo_cmds.rs

@@ -6,7 +6,6 @@ use crate::{
         ComponentDataModel, TodoSelector,
     },
     consts::{EMBED_DESCRIPTION_MAX_LENGTH, SELECT_MAX_ENTRIES, THEME_COLOR},
-    models::CtxData,
     Context, Error,
 };
 
@@ -117,9 +116,6 @@ pub async fn todo_channel_add(
     ctx: Context<'_>,
     #[description = "The task to add to the todo list"] task: String,
 ) -> Result<(), Error> {
-    // ensure channel is cached
-    let _ = ctx.channel_data().await;
-
     sqlx::query!(
         "INSERT INTO todos (guild_id, channel_id, value)
 VALUES ((SELECT id FROM guilds WHERE guild = ?), (SELECT id FROM channels WHERE channel = ?), ?)",
@@ -340,18 +336,7 @@ pub fn show_todo_page(
                                 opt.create_option(|o| {
                                     o.label(format!("Mark {} complete", count + first_num))
                                         .value(id)
-                                        .description({
-                                            let c = disp.split_once(' ').unwrap_or(("", "")).1;
-
-                                            if c.len() > 100 {
-                                                format!(
-                                                    "{}...",
-                                                    c.chars().take(97).collect::<String>()
-                                                )
-                                            } else {
-                                                c.to_string()
-                                            }
-                                        })
+                                        .description(disp.split_once(' ').unwrap_or(("", "")).1)
                                 });
                             }
 

src/component_models/mod.rs

@@ -2,29 +2,28 @@ pub(crate) mod pager;
 
 use std::io::Cursor;
 
-use base64::{engine::general_purpose, Engine};
 use chrono_tz::Tz;
 use log::warn;
 use poise::{
-    serenity_prelude as serenity,
-    serenity_prelude::{
+    serenity::{
         builder::CreateEmbed,
+        client::Context,
         model::{
-            application::interaction::{
-                message_component::MessageComponentInteraction, InteractionResponseType,
-                MessageFlags,
-            },
             channel::Channel,
+            interactions::{
+                message_component::MessageComponentInteraction, InteractionResponseType,
             },
-        Context,
+            prelude::InteractionApplicationCommandCallbackDataFlags,
         },
+    },
+    serenity_prelude as serenity,
 };
 use rmp_serde::Serializer;
 use serde::{Deserialize, Serialize};
 
 use crate::{
     commands::{
-        command_macro::list::{max_macro_page, show_macro_page},
+        moderation_cmds::{max_macro_page, show_macro_page},
         reminder_cmds::{max_delete_page, show_delete_page},
         todo_cmds::{max_todo_page, show_todo_page},
     },
@@ -52,12 +51,11 @@ impl ComponentDataModel {
     pub fn to_custom_id(&self) -> String {
         let mut buf = Vec::new();
         self.serialize(&mut Serializer::new(&mut buf)).unwrap();
-        general_purpose::STANDARD.encode(buf)
+        base64::encode(buf)
     }
 
     pub fn from_custom_id(data: &String) -> Self {
-        let buf = general_purpose::STANDARD
-            .decode(data)
+        let buf = base64::decode(data)
             .map_err(|e| format!("Could not decode `custom_id' {}: {:?}", data, e))
             .unwrap();
         let cur = Cursor::new(buf);
@@ -115,7 +113,7 @@ impl ComponentDataModel {
                         char_count < EMBED_DESCRIPTION_MAX_LENGTH
                     })
                     .collect::<Vec<String>>()
-                    .join("");
+                    .join("\n");
 
                 let mut embed = CreateEmbed::default();
                 embed
@@ -166,21 +164,12 @@ impl ComponentDataModel {
                     .await;
             }
             ComponentDataModel::DelSelector(selector) => {
-                for id in &component.data.values {
-                    match id.parse::<u32>() {
-                        Ok(id) => {
-                            if let Some(reminder) = Reminder::from_id(&data.database, id).await {
-                                reminder.delete(&data.database).await.unwrap();
-                            } else {
-                                warn!("Attempt to delete non-existent reminder");
-                            }
-                        }
+                let selected_id = component.data.values.join(",");
 
-                        Err(e) => {
-                            warn!("Error casting ID to integer: {:?}.", e);
-                        }
-                    }
-                }
+                sqlx::query!("DELETE FROM reminders WHERE FIND_IN_SET(id, ?)", selected_id)
+                    .execute(&data.database)
+                    .await
+                    .unwrap();
 
                 let reminders = Reminder::from_guild(
                     &ctx,
@@ -271,7 +260,7 @@ WHERE guilds.guild = ?",
                             r.kind(InteractionResponseType::ChannelMessageWithSource)
                                 .interaction_response_data(|d| {
                                     d.flags(
-                                        MessageFlags::EPHEMERAL,
+                                        InteractionApplicationCommandCallbackDataFlags::EPHEMERAL,
                                     )
                                     .content("Only the user who performed the command can use these components")
                                 })
@@ -325,7 +314,7 @@ WHERE guilds.guild = ?",
                             r.kind(InteractionResponseType::ChannelMessageWithSource)
                                 .interaction_response_data(|d| {
                                     d.flags(
-                                        MessageFlags::EPHEMERAL,
+                                        InteractionApplicationCommandCallbackDataFlags::EPHEMERAL,
                                     )
                                     .content("Only the user who performed the command can use these components")
                                 })

src/component_models/pager.rs

@@ -1,7 +1,7 @@
 // todo split pager out into a single struct
 use chrono_tz::Tz;
-use poise::serenity_prelude::{
-    builder::CreateComponents, model::application::component::ButtonStyle,
+use poise::serenity::{
+    builder::CreateComponents, model::interactions::message_component::ButtonStyle,
 };
 use serde::{Deserialize, Serialize};
 use serde_repr::*;

src/consts.rs

@@ -2,7 +2,7 @@ pub const DAY: u64 = 86_400;
 pub const HOUR: u64 = 3_600;
 pub const MINUTE: u64 = 60;
 
-pub const EMBED_DESCRIPTION_MAX_LENGTH: usize = 4096;
+pub const EMBED_DESCRIPTION_MAX_LENGTH: usize = 4000;
 pub const SELECT_MAX_ENTRIES: usize = 25;
 
 pub const CHARACTERS: &str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
@@ -12,18 +12,22 @@ pub const MACRO_MAX_COMMANDS: usize = 5;
 
 use std::{collections::HashSet, env, iter::FromIterator};
 
-use poise::serenity_prelude::model::prelude::AttachmentType;
+use poise::serenity::model::prelude::AttachmentType;
 use regex::Regex;
 
 lazy_static! {
     pub static ref DEFAULT_AVATAR: AttachmentType<'static> = (
-        include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/assets/webhook.jpg")) as &[u8],
-        "webhook.jpg",
+        include_bytes!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/assets/",
+            env!("WEBHOOK_AVATAR", "WEBHOOK_AVATAR not provided for compilation")
+        )) as &[u8],
+        env!("WEBHOOK_AVATAR"),
     )
         .into();
     pub static ref REGEX_CHANNEL_USER: Regex = Regex::new(r#"\s*<(#|@)(?:!)?(\d+)>\s*"#).unwrap();
     pub static ref SUBSCRIPTION_ROLES: HashSet<u64> = HashSet::from_iter(
-        env::var("PATREON_ROLE_ID")
+        env::var("SUBSCRIPTION_ROLES")
             .map(|var| var
                 .split(',')
                 .filter_map(|item| { item.parse::<u64>().ok() })
@@ -31,7 +35,7 @@ lazy_static! {
             .unwrap_or_else(|_| Vec::new())
     );
     pub static ref CNC_GUILD: Option<u64> =
-        env::var("PATREON_GUILD_ID").map(|var| var.parse::<u64>().ok()).ok().flatten();
+        env::var("CNC_GUILD").map(|var| var.parse::<u64>().ok()).ok().flatten();
     pub static ref MIN_INTERVAL: i64 =
         env::var("MIN_INTERVAL").ok().and_then(|inner| inner.parse::<i64>().ok()).unwrap_or(600);
     pub static ref MAX_TIME: i64 = env::var("MAX_TIME")
@@ -44,5 +48,5 @@ lazy_static! {
         .map_or(THEME_COLOR_FALLBACK, |inner| u32::from_str_radix(&inner, 16)
             .unwrap_or(THEME_COLOR_FALLBACK));
     pub static ref PYTHON_LOCATION: String =
-        env::var("PYTHON_LOCATION").unwrap_or_else(|_| "/usr/bin/python3".to_string());
+        env::var("PYTHON_LOCATION").unwrap_or_else(|_| "venv/bin/python3".to_string());
 }

src/event_handlers.rs

@@ -1,12 +1,12 @@
-use std::{collections::HashMap, env};
+use std::{collections::HashMap, env, sync::atomic::Ordering};
 
-use log::error;
+use log::{error, info, warn};
 use poise::{
+    serenity::{model::interactions::Interaction, utils::shard_id},
     serenity_prelude as serenity,
-    serenity_prelude::{model::application::interaction::Interaction, utils::shard_id},
 };
 
-use crate::{component_models::ComponentDataModel, Data, Error, THEME_COLOR};
+use crate::{component_models::ComponentDataModel, Data, Error};
 
 pub async fn listener(
     ctx: &serenity::Context,
@@ -17,6 +17,45 @@ pub async fn listener(
         poise::Event::Ready { .. } => {
             ctx.set_activity(serenity::Activity::watching("for /remind")).await;
         }
+        poise::Event::CacheReady { .. } => {
+            info!("Cache Ready! Preparing extra processes");
+
+            if !data.is_loop_running.load(Ordering::Relaxed) {
+                let kill_tx = data.broadcast.clone();
+                let kill_recv = data.broadcast.subscribe();
+
+                let ctx1 = ctx.clone();
+                let ctx2 = ctx.clone();
+
+                let pool1 = data.database.clone();
+                let pool2 = data.database.clone();
+
+                let run_settings = env::var("DONTRUN").unwrap_or_else(|_| "".to_string());
+
+                if !run_settings.contains("postman") {
+                    tokio::spawn(async move {
+                        match postman::initialize(kill_recv, ctx1, &pool1).await {
+                            Ok(_) => {}
+                            Err(e) => {
+                                error!("postman exiting: {}", e);
+                            }
+                        };
+                    });
+                } else {
+                    warn!("Not running postman");
+                }
+
+                if !run_settings.contains("web") {
+                    tokio::spawn(async move {
+                        reminder_web::initialize(kill_tx, ctx2, pool2).await.unwrap();
+                    });
+                } else {
+                    warn!("Not running web");
+                }
+
+                data.is_loop_running.swap(true, Ordering::Relaxed);
+            }
+        }
         poise::Event::ChannelDelete { channel } => {
             sqlx::query!("DELETE FROM channels WHERE channel = ?", channel.id.as_u64())
                 .execute(&data.database)
@@ -27,36 +66,46 @@ pub async fn listener(
             if *is_new {
                 let guild_id = guild.id.as_u64().to_owned();
 
-                sqlx::query!("INSERT IGNORE INTO guilds (guild) VALUES (?)", guild_id)
+                sqlx::query!("INSERT INTO guilds (guild) VALUES (?)", guild_id)
                     .execute(&data.database)
-                    .await?;
+                    .await
+                    .unwrap();
 
-                if let Err(e) = post_guild_count(ctx, &data.http, guild_id).await {
-                    error!("DiscordBotList: {:?}", e);
+                if let Ok(token) = env::var("DISCORDBOTS_TOKEN") {
+                    let shard_count = ctx.cache.shard_count();
+                    let current_shard_id = shard_id(guild_id, shard_count);
+
+                    let guild_count = ctx
+                        .cache
+                        .guilds()
+                        .iter()
+                        .filter(|g| {
+                            shard_id(g.as_u64().to_owned(), shard_count) == current_shard_id
+                        })
+                        .count() as u64;
+
+                    let mut hm = HashMap::new();
+                    hm.insert("server_count", guild_count);
+                    hm.insert("shard_id", current_shard_id);
+                    hm.insert("shard_count", shard_count);
+
+                    let response = data
+                        .http
+                        .post(
+                            format!(
+                                "https://top.gg/api/bots/{}/stats",
+                                ctx.cache.current_user_id().as_u64()
+                            )
+                            .as_str(),
+                        )
+                        .header("Authorization", token)
+                        .json(&hm)
+                        .send()
+                        .await;
+
+                    if let Err(res) = response {
+                        println!("DiscordBots Response: {:?}", res);
                     }
-
-                let default_channel = guild.default_channel_guaranteed();
-
-                if let Some(default_channel) = default_channel {
-                    default_channel
-                        .send_message(&ctx, |m| {
-                            m.embed(|e| {
-                                e.title("Thank you for adding Reminder Bot!").description(
-                                    "To get started:
-• Set your timezone with `/timezone`
-• Set up permissions in Server Settings 🠚 Integrations 🠚 Reminder Bot (desktop only)
-• Create your first reminder with `/remind`
-
-__Support__
-If you need any support, please come and ask us! Join our [Discord](https://discord.jellywx.com).
-
-__Updates__
-To stay up to date on the latest features and fixes, join our [Discord](https://discord.jellywx.com).
-",
-                                ).color(*THEME_COLOR)
-                            })
-                        })
-                        .await?;
                 }
             }
         }
@@ -77,38 +126,3 @@ To stay up to date on the latest features and fixes, join our [Discord](https://
 
     Ok(())
 }
-
-async fn post_guild_count(
-    ctx: &serenity::Context,
-    http: &reqwest::Client,
-    guild_id: u64,
-) -> Result<(), reqwest::Error> {
-    if let Ok(token) = env::var("DISCORDBOTS_TOKEN") {
-        let shard_count = ctx.cache.shard_count();
-        let current_shard_id = shard_id(guild_id, shard_count);
-
-        let guild_count = ctx
-            .cache
-            .guilds()
-            .iter()
-            .filter(|g| shard_id(g.as_u64().to_owned(), shard_count) == current_shard_id)
-            .count() as u64;
-
-        let mut hm = HashMap::new();
-        hm.insert("server_count", guild_count);
-        hm.insert("shard_id", current_shard_id);
-        hm.insert("shard_count", shard_count);
-
-        http.post(
-            format!("https://top.gg/api/bots/{}/stats", ctx.cache.current_user_id().as_u64())
-                .as_str(),
-        )
-        .header("Authorization", token)
-        .json(&hm)
-        .send()
-        .await
-        .map(|_| ())
-    } else {
-        Ok(())
-    }
-}

src/hooks.rs

@@ -1,14 +1,9 @@
-use poise::{
-    serenity_prelude::model::channel::Channel, ApplicationCommandOrAutocompleteInteraction,
-};
+use poise::serenity::model::channel::Channel;
 
 use crate::{consts::MACRO_MAX_COMMANDS, models::command_macro::RecordedCommand, Context, Error};
 
 async fn macro_check(ctx: Context<'_>) -> bool {
     if let Context::Application(app_ctx) = ctx {
-        if let ApplicationCommandOrAutocompleteInteraction::ApplicationCommand(_) =
-            app_ctx.interaction
-        {
         if let Some(guild_id) = ctx.guild_id() {
             if ctx.command().identifying_name != "finish_macro" {
                 let mut lock = ctx.data().recording_macros.write().await;
@@ -40,33 +35,31 @@ async fn macro_check(ctx: Context<'_>) -> bool {
             }
         }
     }
-    }
 
     true
 }
 
 async fn check_self_permissions(ctx: Context<'_>) -> bool {
     if let Some(guild) = ctx.guild() {
-        let user_id = ctx.serenity_context().cache.current_user_id();
-
-        let manage_webhooks =
-            guild.member_permissions(&ctx, user_id).await.map_or(false, |p| p.manage_webhooks());
+        let user_id = ctx.discord().cache.current_user_id();
 
+        let manage_webhooks = guild
+            .member_permissions(&ctx.discord(), user_id)
+            .await
+            .map_or(false, |p| p.manage_webhooks());
         let (view_channel, send_messages, embed_links) = ctx
             .channel_id()
-            .to_channel(&ctx)
-            .await
-            .ok()
+            .to_channel_cached(&ctx.discord())
             .and_then(|c| {
                 if let Channel::Guild(channel) = c {
-                    let perms = channel.permissions_for_user(&ctx, user_id).ok()?;
-
-                    Some((perms.view_channel(), perms.send_messages(), perms.embed_links()))
+                    channel.permissions_for_user(&ctx.discord(), user_id).ok()
                 } else {
                     None
                 }
             })
-            .unwrap_or((false, false, false));
+            .map_or((false, false, false), |p| {
+                (p.view_channel(), p.send_messages(), p.embed_links())
+            });
 
         if manage_webhooks && send_messages && embed_links {
             true
@@ -82,8 +75,8 @@ async fn check_self_permissions(ctx: Context<'_>) -> bool {
 {}     **Manage Webhooks**",
                         if view_channel { "✅" } else { "❌" },
                         if send_messages { "✅" } else { "❌" },
-                        if embed_links { "✅" } else { "❌" },
                         if manage_webhooks { "✅" } else { "❌" },
+                        if embed_links { "✅" } else { "❌" },
                     ))
                 })
                 .await;

src/interval_parser.rs

@@ -110,14 +110,13 @@ impl OverflowOp for u64 {
 #[derive(Copy, Clone)]
 pub struct Interval {
     pub month: u64,
-    pub day: u64,
     pub sec: u64,
 }
 
 struct Parser<'a> {
     iter: Chars<'a>,
     src: &'a str,
-    current: (u64, u64, u64, u64),
+    current: (u64, u64, u64),
 }
 
 impl<'a> Parser<'a> {
@@ -141,17 +140,17 @@ impl<'a> Parser<'a> {
         Ok(None)
     }
     fn parse_unit(&mut self, n: u64, start: usize, end: usize) -> Result<(), Error> {
-        let (mut month, mut day, mut sec, nsec) = match &self.src[start..end] {
-            "nanos" | "nsec" | "ns" => (0, 0u64, 0u64, n),
-            "usec" | "us" => (0, 0, 0u64, n.mul(1000)?),
-            "millis" | "msec" | "ms" => (0, 0, 0u64, n.mul(1_000_000)?),
-            "seconds" | "second" | "secs" | "sec" | "s" => (0, 0, n, 0),
-            "minutes" | "minute" | "min" | "mins" | "m" => (0, 0, n.mul(60)?, 0),
-            "hours" | "hour" | "hr" | "hrs" | "h" => (0, 0, n.mul(3600)?, 0),
-            "days" | "day" | "d" => (0, n, 0, 0),
-            "weeks" | "week" | "w" => (0, n.mul(7)?, 0, 0),
-            "months" | "month" | "M" => (n, 0, 0, 0),
-            "years" | "year" | "y" => (n.mul(12)?, 0, 0, 0),
+        let (mut month, mut sec, nsec) = match &self.src[start..end] {
+            "nanos" | "nsec" | "ns" => (0u64, 0u64, n),
+            "usec" | "us" => (0, 0u64, n.mul(1000)?),
+            "millis" | "msec" | "ms" => (0, 0u64, n.mul(1_000_000)?),
+            "seconds" | "second" | "secs" | "sec" | "s" => (0, n, 0),
+            "minutes" | "minute" | "min" | "mins" | "m" => (0, n.mul(60)?, 0),
+            "hours" | "hour" | "hr" | "hrs" | "h" => (0, n.mul(3600)?, 0),
+            "days" | "day" | "d" => (0, n.mul(86400)?, 0),
+            "weeks" | "week" | "w" => (0, n.mul(86400 * 7)?, 0),
+            "months" | "month" | "M" => (n, 0, 0),
+            "years" | "year" | "y" => (12, 0, 0),
             _ => {
                 return Err(Error::UnknownUnit {
                     start,
@@ -161,16 +160,15 @@ impl<'a> Parser<'a> {
                 });
             }
         };
-        let mut nsec = self.current.3 + nsec;
+        let mut nsec = self.current.2 + nsec;
         if nsec > 1_000_000_000 {
             sec += nsec / 1_000_000_000;
             nsec %= 1_000_000_000;
         }
-        sec += self.current.2;
-        day += self.current.1;
+        sec += self.current.1;
         month += self.current.0;
 
-        self.current = (month, day, sec, nsec);
+        self.current = (month, sec, nsec);
 
         Ok(())
     }
@@ -217,13 +215,7 @@ impl<'a> Parser<'a> {
             self.parse_unit(n, start, off)?;
             n = match self.parse_first_char()? {
                 Some(n) => n,
-                None => {
-                    return Ok(Interval {
-                        month: self.current.0,
-                        day: self.current.1,
-                        sec: self.current.2,
-                    })
-                }
+                None => return Ok(Interval { month: self.current.0, sec: self.current.1 }),
             };
         }
     }
@@ -255,73 +247,5 @@ impl<'a> Parser<'a> {
 /// assert_eq!(parse_duration("32ms"), Ok(Duration::new(0, 32_000_000)));
 /// ```
 pub fn parse_duration(s: &str) -> Result<Interval, Error> {
-    Parser { iter: s.chars(), src: s, current: (0, 0, 0, 0) }.parse()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parse_seconds() {
-        let interval = parse_duration("10 seconds").unwrap();
-
-        assert_eq!(interval.sec, 10);
-        assert_eq!(interval.day, 0);
-        assert_eq!(interval.month, 0);
-    }
-
-    #[test]
-    fn parse_minutes() {
-        let interval = parse_duration("10 minutes").unwrap();
-
-        assert_eq!(interval.sec, 600);
-        assert_eq!(interval.day, 0);
-        assert_eq!(interval.month, 0);
-    }
-
-    #[test]
-    fn parse_hours() {
-        let interval = parse_duration("10 hours").unwrap();
-
-        assert_eq!(interval.sec, 36_000);
-        assert_eq!(interval.day, 0);
-        assert_eq!(interval.month, 0);
-    }
-
-    #[test]
-    fn parse_days() {
-        let interval = parse_duration("10 days").unwrap();
-
-        assert_eq!(interval.sec, 0);
-        assert_eq!(interval.day, 10);
-        assert_eq!(interval.month, 0);
-    }
-
-    #[test]
-    fn parse_weeks() {
-        let interval = parse_duration("10 weeks").unwrap();
-
-        assert_eq!(interval.sec, 0);
-        assert_eq!(interval.day, 70);
-        assert_eq!(interval.month, 0);
-    }
-
-    #[test]
-    fn parse_months() {
-        let interval = parse_duration("10 months").unwrap();
-
-        assert_eq!(interval.sec, 0);
-        assert_eq!(interval.day, 0);
-        assert_eq!(interval.month, 10);
-    }
-
-    #[test]
-    fn parse_years() {
-        let interval = parse_duration("10 years").unwrap();
-
-        assert_eq!(interval.sec, 0);
-        assert_eq!(interval.day, 0);
-        assert_eq!(interval.month, 120);
-    }
+    Parser { iter: s.chars(), src: s, current: (0, 0, 0) }.parse()
 }

src/main.rs

@@ -18,12 +18,12 @@ use std::{
     env,
     error::Error as StdError,
     fmt::{Debug, Display, Formatter},
-    path::Path,
+    sync::atomic::AtomicBool,
 };
 
 use chrono_tz::Tz;
-use log::{error, warn};
-use poise::serenity_prelude::model::{
+use dotenv::dotenv;
+use poise::serenity::model::{
     gateway::GatewayIntents,
     id::{GuildId, UserId},
 };
@@ -31,7 +31,7 @@ use sqlx::{MySql, Pool};
 use tokio::sync::{broadcast, broadcast::Sender, RwLock};
 
 use crate::{
-    commands::{command_macro, info_cmds, moderation_cmds, reminder_cmds, todo_cmds},
+    commands::{info_cmds, moderation_cmds, reminder_cmds, todo_cmds},
     consts::THEME_COLOR,
     event_handlers::listener,
     hooks::all_checks,
@@ -43,14 +43,14 @@ type Database = MySql;
 
 type Error = Box<dyn std::error::Error + Send + Sync>;
 type Context<'a> = poise::Context<'a, Data, Error>;
-type ApplicationContext<'a> = poise::ApplicationContext<'a, Data, Error>;
 
 pub struct Data {
     database: Pool<Database>,
     http: reqwest::Client,
     recording_macros: RwLock<HashMap<(GuildId, UserId), CommandMacro<Data, Error>>>,
     popular_timezones: Vec<Tz>,
-    _broadcast: Sender<()>,
+    is_loop_running: AtomicBool,
+    broadcast: Sender<()>,
 }
 
 impl Debug for Data {
@@ -75,7 +75,7 @@ impl Display for Ended {
 
 impl StdError for Ended {}
 
-#[tokio::main(flavor = "multi_thread")]
+#[tokio::main]
 async fn main() -> Result<(), Box<dyn StdError + Send + Sync>> {
     let (tx, mut rx) = broadcast::channel(16);
 
@@ -88,11 +88,7 @@ async fn main() -> Result<(), Box<dyn StdError + Send + Sync>> {
 async fn _main(tx: Sender<()>) -> Result<(), Box<dyn StdError + Send + Sync>> {
     env_logger::init();
 
-    if Path::new("/etc/reminder-rs/config.env").exists() {
-        dotenv::from_path("/etc/reminder-rs/config.env")?;
-    } else {
-        let _ = dotenv::dotenv();
-    }
+    dotenv()?;
 
     let discord_token = env::var("DISCORD_TOKEN").expect("Missing DISCORD_TOKEN from environment");
 
@@ -107,32 +103,13 @@ async fn _main(tx: Sender<()>) -> Result<(), Box<dyn StdError + Send + Sync>> {
             moderation_cmds::timezone(),
             poise::Command {
                 subcommands: vec![
-                    moderation_cmds::set_allowed_dm(),
-                    moderation_cmds::unset_allowed_dm(),
+                    moderation_cmds::delete_macro(),
+                    moderation_cmds::finish_macro(),
+                    moderation_cmds::list_macro(),
+                    moderation_cmds::record_macro(),
+                    moderation_cmds::run_macro(),
                 ],
-                ..moderation_cmds::allowed_dm()
-            },
-            poise::Command {
-                subcommands: vec![poise::Command {
-                    subcommands: vec![
-                        moderation_cmds::set_ephemeral_confirmations(),
-                        moderation_cmds::unset_ephemeral_confirmations(),
-                    ],
-                    ..moderation_cmds::ephemeral_confirmations()
-                }],
-                ..moderation_cmds::settings()
-            },
-            moderation_cmds::webhook(),
-            poise::Command {
-                subcommands: vec![
-                    command_macro::delete::delete_macro(),
-                    command_macro::record::finish_macro(),
-                    command_macro::list::list_macro(),
-                    command_macro::record::record_macro(),
-                    command_macro::run::run_macro(),
-                    command_macro::migrate::migrate_macro(),
-                ],
-                ..command_macro::macro_base()
+                ..moderation_cmds::macro_base()
             },
             reminder_cmds::pause(),
             reminder_cmds::offset(),
@@ -147,7 +124,6 @@ async fn _main(tx: Sender<()>) -> Result<(), Box<dyn StdError + Send + Sync>> {
                 ],
                 ..reminder_cmds::timer_base()
             },
-            reminder_cmds::multiline(),
             reminder_cmds::remind(),
             poise::Command {
                 subcommands: vec![
@@ -175,36 +151,15 @@ async fn _main(tx: Sender<()>) -> Result<(), Box<dyn StdError + Send + Sync>> {
         ],
         allowed_mentions: None,
         command_check: Some(|ctx| Box::pin(all_checks(ctx))),
-        event_handler: |ctx, event, _framework, data| Box::pin(listener(ctx, event, data)),
-        on_error: |error| {
-            Box::pin(async move {
-                match error {
-                    poise::FrameworkError::CommandCheckFailed { .. } => {
-                        // suppress error
-                    }
-                    error => {
-                        if let Err(e) = poise::builtins::on_error(error).await {
-                            log::error!("Error while handling error: {}", e);
-                        }
-                    }
-                }
-            })
-        },
+        listener: |ctx, event, _framework, data| Box::pin(listener(ctx, event, data)),
         ..Default::default()
     };
 
     let database =
         Pool::connect(&env::var("DATABASE_URL").expect("No database URL provided")).await.unwrap();
 
-    sqlx::migrate!().run(&database).await?;
-
     let popular_timezones = sqlx::query!(
-        "SELECT IFNULL(timezone, 'UTC') AS timezone
-        FROM users
-        WHERE timezone IS NOT NULL
-        GROUP BY timezone
-        ORDER BY COUNT(timezone) DESC
-        LIMIT 21"
+        "SELECT timezone FROM users GROUP BY timezone ORDER BY COUNT(timezone) DESC LIMIT 21"
     )
     .fetch_all(&database)
     .await
@@ -213,50 +168,27 @@ async fn _main(tx: Sender<()>) -> Result<(), Box<dyn StdError + Send + Sync>> {
     .map(|t| t.timezone.parse::<Tz>().unwrap())
     .collect::<Vec<Tz>>();
 
-    poise::Framework::builder()
+    poise::Framework::build()
         .token(discord_token)
-        .setup(move |ctx, _bot, framework| {
+        .user_data_setup(move |ctx, _bot, framework| {
             Box::pin(async move {
-                register_application_commands(ctx, framework, None).await.unwrap();
-
-                let kill_tx = tx.clone();
-                let kill_recv = tx.subscribe();
-
-                let ctx1 = ctx.clone();
-                let ctx2 = ctx.clone();
-
-                let pool1 = database.clone();
-                let pool2 = database.clone();
-
-                let run_settings = env::var("DONTRUN").unwrap_or_else(|_| "".to_string());
-
-                if !run_settings.contains("postman") {
-                    tokio::spawn(async move {
-                        match postman::initialize(kill_recv, ctx1, &pool1).await {
-                            Ok(_) => {}
-                            Err(e) => {
-                                error!("postman exiting: {}", e);
-                            }
-                        };
-                    });
-                } else {
-                    warn!("Not running postman");
-                }
-
-                if !run_settings.contains("web") {
-                    tokio::spawn(async move {
-                        reminder_web::initialize(kill_tx, ctx2, pool2).await.unwrap();
-                    });
-                } else {
-                    warn!("Not running web");
-                }
+                register_application_commands(
+                    ctx,
+                    framework,
+                    env::var("DEBUG_GUILD")
+                        .map(|inner| GuildId(inner.parse().expect("DEBUG_GUILD not valid")))
+                        .ok(),
+                )
+                .await
+                .unwrap();
 
                 Ok(Data {
                     http: reqwest::Client::new(),
                     database,
                     popular_timezones,
                     recording_macros: Default::default(),
-                    _broadcast: tx,
+                    is_loop_running: AtomicBool::new(false),
+                    broadcast: tx,
                 })
             })
         })

src/models/channel_data.rs

@@ -1,5 +1,5 @@
 use chrono::NaiveDateTime;
-use poise::serenity_prelude::model::channel::Channel;
+use poise::serenity::model::channel::Channel;
 use sqlx::MySqlPool;
 
 pub struct ChannelData {
@@ -10,7 +10,6 @@ pub struct ChannelData {
     pub webhook_id: Option<u64>,
     pub webhook_token: Option<String>,
     pub paused: bool,
-    pub db_guild_id: Option<u32>,
     pub paused_until: Option<NaiveDateTime>,
 }
 
@@ -24,9 +23,7 @@ impl ChannelData {
         if let Ok(c) = sqlx::query_as_unchecked!(
             Self,
             "
-            SELECT id, name, nudge, blacklisted, webhook_id, webhook_token, paused, paused_until,
-                guild_id AS db_guild_id
-            FROM channels WHERE channel = ?
+SELECT id, name, nudge, blacklisted, webhook_id, webhook_token, paused, paused_until FROM channels WHERE channel = ?
             ",
             channel_id
         )
@@ -35,17 +32,13 @@ impl ChannelData {
         {
             Ok(c)
         } else {
-            let props =
-                channel.to_owned().guild().map(|g| (g.guild_id.as_u64().to_owned(), g.name));
+            let props = channel.to_owned().guild().map(|g| (g.guild_id.as_u64().to_owned(), g.name));
 
-            let (guild_id, channel_name) =
-                if let Some((a, b)) = props { (Some(a), Some(b)) } else { (None, None) };
+            let (guild_id, channel_name) = if let Some((a, b)) = props { (Some(a), Some(b)) } else { (None, None) };
 
             sqlx::query!(
                 "
-                INSERT IGNORE INTO channels
-                (channel, name, guild_id)
-                VALUES (?, ?, (SELECT id FROM guilds WHERE guild = ?))
+INSERT IGNORE INTO channels (channel, name, guild_id) VALUES (?, ?, (SELECT id FROM guilds WHERE guild = ?))
                 ",
                 channel_id,
                 channel_name,
@@ -57,10 +50,7 @@ impl ChannelData {
             Ok(sqlx::query_as_unchecked!(
                 Self,
                 "
-                SELECT id, name, nudge, blacklisted, webhook_id, webhook_token, paused,
-                    paused_until, guild_id AS db_guild_id
-                FROM channels
-                WHERE channel = ?
+SELECT id, name, nudge, blacklisted, webhook_id, webhook_token, paused, paused_until FROM channels WHERE channel = ?
                 ",
                 channel_id
             )
@@ -72,10 +62,8 @@ impl ChannelData {
     pub async fn commit_changes(&self, pool: &MySqlPool) {
         sqlx::query!(
             "
-            UPDATE channels
-            SET name = ?, nudge = ?, blacklisted = ?, webhook_id = ?, webhook_token = ?,
-                paused = ?, paused_until = ?
-            WHERE id = ?
+UPDATE channels SET name = ?, nudge = ?, blacklisted = ?, webhook_id = ?, webhook_token = ?, paused = ?, paused_until \
+             = ? WHERE id = ?
             ",
             self.name,
             self.nudge,

src/models/command_macro.rs

@@ -1,8 +1,7 @@
-use poise::serenity_prelude::model::{
-    application::interaction::application_command::CommandDataOption, id::GuildId,
+use poise::serenity::model::{
+    id::GuildId, interactions::application_command::ApplicationCommandInteractionDataOption,
 };
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
 
 use crate::{Context, Data, Error};
 
@@ -20,7 +19,7 @@ pub struct RecordedCommand<U, E> {
     #[serde(default = "default_none::<U, E>")]
     pub action: Option<Func<U, E>>,
     pub command_name: String,
-    pub options: Vec<CommandDataOption>,
+    pub options: Vec<ApplicationCommandInteractionDataOption>,
 }
 
 pub struct CommandMacro<U, E> {
@@ -30,13 +29,6 @@ pub struct CommandMacro<U, E> {
     pub commands: Vec<RecordedCommand<U, E>>,
 }
 
-pub struct RawCommandMacro {
-    pub guild_id: GuildId,
-    pub name: String,
-    pub description: Option<String>,
-    pub commands: Value,
-}
-
 pub async fn guild_command_macro(
     ctx: &Context<'_>,
     name: &str,

src/models/guild_data.rs

@@ -1,48 +0,0 @@
-use poise::serenity_prelude::GuildId;
-use sqlx::MySqlPool;
-
-pub struct GuildData {
-    pub ephemeral_confirmations: bool,
-    pub id: u32,
-}
-
-impl GuildData {
-    pub async fn from_guild(
-        guild_id: GuildId,
-        pool: &MySqlPool,
-    ) -> Result<Self, Box<dyn std::error::Error + Sync + Send>> {
-        if let Ok(c) = sqlx::query_as_unchecked!(
-            Self,
-            "SELECT id, ephemeral_confirmations FROM guilds WHERE guild = ?",
-            guild_id.0
-        )
-        .fetch_one(pool)
-        .await
-        {
-            Ok(c)
-        } else {
-            sqlx::query!("INSERT IGNORE INTO guilds (guild) VALUES (?)", guild_id.0)
-                .execute(&pool.clone())
-                .await?;
-
-            Ok(sqlx::query_as_unchecked!(
-                Self,
-                "SELECT id, ephemeral_confirmations FROM guilds WHERE guild = ?",
-                guild_id.0
-            )
-            .fetch_one(pool)
-            .await?)
-        }
-    }
-
-    pub async fn commit_changes(&self, pool: &MySqlPool) {
-        sqlx::query!(
-            "UPDATE guilds SET ephemeral_confirmations = ? WHERE id = ?",
-            self.ephemeral_confirmations,
-            self.id
-        )
-        .execute(pool)
-        .await
-        .unwrap();
-    }
-}

src/models/mod.rs

@@ -1,15 +1,14 @@
 pub mod channel_data;
 pub mod command_macro;
-pub mod guild_data;
 pub mod reminder;
 pub mod timer;
 pub mod user_data;
 
 use chrono_tz::Tz;
-use poise::serenity_prelude::{async_trait, model::id::UserId, ChannelType};
+use poise::serenity::{async_trait, model::id::UserId};
 
 use crate::{
-    models::{channel_data::ChannelData, guild_data::GuildData, user_data::UserData},
+    models::{channel_data::ChannelData, user_data::UserData},
     CommandMacro, Context, Data, Error, GuildId,
 };
 
@@ -19,8 +18,6 @@ pub trait CtxData {
 
     async fn author_data(&self) -> Result<UserData, Error>;
 
-    async fn guild_data(&self) -> Option<Result<GuildData, Error>>;
-
     async fn timezone(&self) -> Tz;
 
     async fn channel_data(&self) -> Result<ChannelData, Error>;
@@ -30,21 +27,15 @@ pub trait CtxData {
 
 #[async_trait]
 impl CtxData for Context<'_> {
-    async fn user_data<U: Into<UserId> + Send>(&self, user_id: U) -> Result<UserData, Error> {
-        UserData::from_user(user_id, &self.serenity_context(), &self.data().database).await
+    async fn user_data<U: Into<UserId> + Send>(
+        &self,
+        user_id: U,
+    ) -> Result<UserData, Box<dyn std::error::Error + Sync + Send>> {
+        UserData::from_user(user_id, &self.discord(), &self.data().database).await
     }
 
-    async fn author_data(&self) -> Result<UserData, Error> {
-        UserData::from_user(&self.author().id, &self.serenity_context(), &self.data().database)
-            .await
-    }
-
-    async fn guild_data(&self) -> Option<Result<GuildData, Error>> {
-        if let Some(guild_id) = self.guild_id() {
-            Some(GuildData::from_guild(guild_id, &self.data().database).await)
-        } else {
-            None
-        }
+    async fn author_data(&self) -> Result<UserData, Box<dyn std::error::Error + Sync + Send>> {
+        UserData::from_user(&self.author().id, &self.discord(), &self.data().database).await
     }
 
     async fn timezone(&self) -> Tz {
@@ -52,20 +43,7 @@ impl CtxData for Context<'_> {
     }
 
     async fn channel_data(&self) -> Result<ChannelData, Box<dyn std::error::Error + Sync + Send>> {
-        // If we're in a thread, get the parent channel.
-        let recv_channel = self.channel_id().to_channel(&self).await?;
-
-        let channel = match recv_channel.guild() {
-            Some(guild_channel) => {
-                if guild_channel.kind == ChannelType::PublicThread {
-                    guild_channel.parent_id.unwrap().to_channel_cached(&self).unwrap()
-                } else {
-                    self.channel_id().to_channel_cached(&self).unwrap()
-                }
-            }
-
-            None => self.channel_id().to_channel_cached(&self).unwrap(),
-        };
+        let channel = self.channel_id().to_channel_cached(&self.discord()).unwrap();
 
         ChannelData::from_channel(&channel, &self.data().database).await
     }

src/models/reminder/builder.rs

@@ -2,14 +2,14 @@ use std::{collections::HashSet, fmt::Display};
 
 use chrono::{Duration, NaiveDateTime, Utc};
 use chrono_tz::Tz;
-use poise::serenity_prelude::{
+use poise::serenity::{
     http::CacheHttp,
     model::{
         channel::GuildChannel,
         id::{ChannelId, GuildId, UserId},
         webhook::Webhook,
     },
-    ChannelType, Result as SerenityResult,
+    Result as SerenityResult,
 };
 use sqlx::MySqlPool;
 
@@ -51,12 +51,9 @@ pub struct ReminderBuilder {
     pool: MySqlPool,
     uid: String,
     channel: u32,
-    guild: Option<u32>,
-    thread_id: Option<u64>,
     utc_time: NaiveDateTime,
     timezone: String,
-    interval_seconds: Option<i64>,
-    interval_days: Option<i64>,
+    interval_secs: Option<i64>,
     interval_months: Option<i64>,
     expires: Option<NaiveDateTime>,
     content: String,
@@ -87,11 +84,9 @@ impl ReminderBuilder {
 INSERT INTO reminders (
     `uid`,
     `channel_id`,
-    `guild_id`,
     `utc_time`,
     `timezone`,
     `interval_seconds`,
-    `interval_days`,
     `interval_months`,
     `expires`,
     `content`,
@@ -111,18 +106,14 @@ INSERT INTO reminders (
     ?,
     ?,
     ?,
-    ?,
-    ?,
     ?
 )
             ",
                         self.uid,
                         self.channel,
-                        self.guild,
                         utc_time,
                         self.timezone,
-                        self.interval_seconds,
-                        self.interval_days,
+                        self.interval_secs,
                         self.interval_months,
                         self.expires,
                         self.content,
@@ -184,15 +175,17 @@ impl<'a> MultiReminderBuilder<'a> {
     }
 
     pub fn time<T: Into<i64>>(mut self, time: T) -> Self {
-        if let Some(utc_time) = NaiveDateTime::from_timestamp_opt(time.into(), 0) {
-            self.utc_time = utc_time;
-        }
+        self.utc_time = NaiveDateTime::from_timestamp(time.into(), 0);
 
         self
     }
 
     pub fn expires<T: Into<i64>>(mut self, time: Option<T>) -> Self {
-        self.expires = time.map(|t| NaiveDateTime::from_timestamp_opt(t.into(), 0)).flatten();
+        if let Some(t) = time {
+            self.expires = Some(NaiveDateTime::from_timestamp(t.into(), 0));
+        } else {
+            self.expires = None;
+        }
 
         self
     }
@@ -219,78 +212,59 @@ impl<'a> MultiReminderBuilder<'a> {
 
         let mut ok_locs = HashSet::new();
 
-        if self
-            .interval
-            .map_or(false, |i| ((i.sec + i.day * DAY + i.month * 30 * DAY) as i64) < *MIN_INTERVAL)
-        {
+        if self.interval.map_or(false, |i| ((i.sec + i.month * 30 * DAY) as i64) < *MIN_INTERVAL) {
             errors.insert(ReminderError::ShortInterval);
-        } else if self
-            .interval
-            .map_or(false, |i| ((i.sec + i.day * DAY + i.month * 30 * DAY) as i64) > *MAX_TIME)
+        } else if self.interval.map_or(false, |i| ((i.sec + i.month * 30 * DAY) as i64) > *MAX_TIME)
         {
             errors.insert(ReminderError::LongInterval);
         } else {
             for scope in self.scopes {
-                let thread_id = None;
                 let db_channel_id = match scope {
                     ReminderScope::User(user_id) => {
-                        if let Ok(user) = UserId(user_id).to_user(&self.ctx).await {
+                        if let Ok(user) = UserId(user_id).to_user(&self.ctx.discord()).await {
                             let user_data = UserData::from_user(
                                 &user,
-                                &self.ctx.serenity_context(),
+                                &self.ctx.discord(),
                                 &self.ctx.data().database,
                             )
                             .await
                             .unwrap();
 
                             if let Some(guild_id) = self.guild_id {
-                                if guild_id.member(&self.ctx, user).await.is_err() {
+                                if guild_id.member(&self.ctx.discord(), user).await.is_err() {
                                     Err(ReminderError::InvalidTag)
-                                } else if self.set_by.map_or(true, |i| i != user_data.id)
-                                    && !user_data.allowed_dm
-                                {
-                                    Err(ReminderError::UserBlockedDm)
                                 } else {
-                                    Ok((user_data.dm_channel, None))
+                                    Ok(user_data.dm_channel)
                                 }
                             } else {
-                                Ok((user_data.dm_channel, None))
+                                Ok(user_data.dm_channel)
                             }
                         } else {
                             Err(ReminderError::InvalidTag)
                         }
                     }
                     ReminderScope::Channel(channel_id) => {
-                        let channel = ChannelId(channel_id).to_channel(&self.ctx).await.unwrap();
+                        let channel =
+                            ChannelId(channel_id).to_channel(&self.ctx.discord()).await.unwrap();
 
-                        if let Some(mut guild_channel) = channel.clone().guild() {
+                        if let Some(guild_channel) = channel.clone().guild() {
                             if Some(guild_channel.guild_id) != self.guild_id {
                                 Err(ReminderError::InvalidTag)
                             } else {
-                                let mut channel_data = if guild_channel.kind
-                                    == ChannelType::PublicThread
-                                {
-                                    // fixme jesus christ
-                                    let parent = guild_channel
-                                        .parent_id
-                                        .unwrap()
-                                        .to_channel(&self.ctx)
-                                        .await
-                                        .unwrap();
-                                    guild_channel = parent.clone().guild().unwrap();
-                                    ChannelData::from_channel(&parent, &self.ctx.data().database)
-                                        .await
-                                        .unwrap()
-                                } else {
+                                let mut channel_data =
                                     ChannelData::from_channel(&channel, &self.ctx.data().database)
                                         .await
-                                        .unwrap()
-                                };
+                                        .unwrap();
 
                                 if channel_data.webhook_id.is_none()
                                     || channel_data.webhook_token.is_none()
                                 {
-                                    match create_webhook(&self.ctx, guild_channel, "Reminder").await
+                                    match create_webhook(
+                                        &self.ctx.discord(),
+                                        guild_channel,
+                                        "Reminder",
+                                    )
+                                    .await
                                     {
                                         Ok(webhook) => {
                                             channel_data.webhook_id =
@@ -301,13 +275,13 @@ impl<'a> MultiReminderBuilder<'a> {
                                                 .commit_changes(&self.ctx.data().database)
                                                 .await;
 
-                                            Ok((channel_data.id, channel_data.db_guild_id))
+                                            Ok(channel_data.id)
                                         }
 
                                         Err(e) => Err(ReminderError::DiscordError(e.to_string())),
                                     }
                                 } else {
-                                    Ok((channel_data.id, channel_data.db_guild_id))
+                                    Ok(channel_data.id)
                                 }
                             }
                         } else {
@@ -321,13 +295,10 @@ impl<'a> MultiReminderBuilder<'a> {
                         let builder = ReminderBuilder {
                             pool: self.ctx.data().database.clone(),
                             uid: generate_uid(),
-                            channel: c.0,
-                            guild: c.1,
-                            thread_id,
+                            channel: c,
                             utc_time: self.utc_time,
                             timezone: self.timezone.to_string(),
-                            interval_seconds: self.interval.map(|i| i.sec as i64),
-                            interval_days: self.interval.map(|i| i.day as i64),
+                            interval_secs: self.interval.map(|i| i.sec as i64),
                             interval_months: self.interval.map(|i| i.month as i64),
                             expires: self.expires,
                             content: self.content.content.clone(),

src/models/reminder/errors.rs

@@ -7,7 +7,6 @@ pub enum ReminderError {
     PastTime,
     ShortInterval,
     InvalidTag,
-    UserBlockedDm,
     DiscordError(String),
 }
 
@@ -31,9 +30,6 @@ impl ToString for ReminderError {
             ReminderError::InvalidTag => {
                 "Couldn't find a location by your tag. Your tag must be either a channel or a user (not a role)".to_string()
             }
-            ReminderError::UserBlockedDm => {
-                "User has DM reminders disabled".to_string()
-            }
             ReminderError::DiscordError(s) => format!("A Discord error occurred: **{}**", s),
         }
     }

src/models/reminder/look_flags.rs

@@ -1,4 +1,4 @@
-use poise::serenity_prelude::model::id::ChannelId;
+use poise::serenity::model::id::ChannelId;
 use serde::{Deserialize, Serialize};
 use serde_repr::*;
 

src/models/reminder/mod.rs

@@ -6,11 +6,11 @@ pub mod look_flags;
 
 use std::hash::{Hash, Hasher};
 
-use chrono::{DateTime, NaiveDateTime, Utc};
+use chrono::{NaiveDateTime, TimeZone};
 use chrono_tz::Tz;
-use poise::serenity_prelude::{
-    model::id::{ChannelId, GuildId, UserId},
-    Cache,
+use poise::{
+    serenity::model::id::{ChannelId, GuildId, UserId},
+    serenity_prelude::Cache,
 };
 use sqlx::Executor;
 
@@ -24,9 +24,8 @@ pub struct Reminder {
     pub id: u32,
     pub uid: String,
     pub channel: u64,
-    pub utc_time: DateTime<Utc>,
+    pub utc_time: NaiveDateTime,
     pub interval_seconds: Option<u32>,
-    pub interval_days: Option<u32>,
     pub interval_months: Option<u32>,
     pub expires: Option<NaiveDateTime>,
     pub enabled: bool,
@@ -60,7 +59,6 @@ SELECT
     channels.channel,
     reminders.utc_time,
     reminders.interval_seconds,
-    reminders.interval_days,
     reminders.interval_months,
     reminders.expires,
     reminders.enabled,
@@ -97,7 +95,6 @@ SELECT
     channels.channel,
     reminders.utc_time,
     reminders.interval_seconds,
-    reminders.interval_days,
     reminders.interval_months,
     reminders.expires,
     reminders.enabled,
@@ -141,7 +138,6 @@ SELECT
     channels.channel,
     reminders.utc_time,
     reminders.interval_seconds,
-    reminders.interval_days,
     reminders.interval_months,
     reminders.expires,
     reminders.enabled,
@@ -159,7 +155,6 @@ LEFT JOIN
 ON
     reminders.set_by = users.id
 WHERE
-    `status` = 'pending' AND
     channels.channel = ? AND
     FIND_IN_SET(reminders.enabled, ?)
 ORDER BY
@@ -200,7 +195,6 @@ SELECT
     channels.channel,
     reminders.utc_time,
     reminders.interval_seconds,
-    reminders.interval_days,
     reminders.interval_months,
     reminders.expires,
     reminders.enabled,
@@ -218,7 +212,6 @@ LEFT JOIN
 ON
     reminders.set_by = users.id
 WHERE
-    `status` = 'pending' AND
     FIND_IN_SET(channels.channel, ?)
                 ",
                     channels
@@ -235,7 +228,6 @@ SELECT
     channels.channel,
     reminders.utc_time,
     reminders.interval_seconds,
-    reminders.interval_days,
     reminders.interval_months,
     reminders.expires,
     reminders.enabled,
@@ -253,7 +245,6 @@ LEFT JOIN
 ON
     reminders.set_by = users.id
 WHERE
-    `status` = 'pending' AND
     channels.guild_id = (SELECT id FROM guilds WHERE guild = ?)
                 ",
                     guild_id.as_u64()
@@ -271,7 +262,6 @@ SELECT
     channels.channel,
     reminders.utc_time,
     reminders.interval_seconds,
-    reminders.interval_days,
     reminders.interval_months,
     reminders.expires,
     reminders.enabled,
@@ -289,7 +279,6 @@ LEFT JOIN
 ON
     reminders.set_by = users.id
 WHERE
-    `status` = 'pending' AND
     channels.id = (SELECT dm_channel FROM users WHERE user = ?)
             ",
                 user.as_u64()
@@ -304,13 +293,7 @@ WHERE
         &self,
         db: impl Executor<'_, Database = Database>,
     ) -> Result<(), sqlx::Error> {
-        sqlx::query!(
-            "UPDATE reminders SET `status` = 'deleted', `status_change_time` = NOW() WHERE uid = ?",
-            self.uid
-        )
-        .execute(db)
-        .await
-        .map(|_| ())
+        sqlx::query!("DELETE FROM reminders WHERE uid = ?", self.uid).execute(db).await.map(|_| ())
     }
 
     pub fn display_content(&self) -> &str {
@@ -327,32 +310,30 @@ WHERE
             count + 1,
             self.display_content(),
             self.channel,
-            self.utc_time.with_timezone(timezone).format("%Y-%m-%d %H:%M:%S")
+            timezone.timestamp(self.utc_time.timestamp(), 0).format("%Y-%m-%d %H:%M:%S")
         )
     }
 
     pub fn display(&self, flags: &LookFlags, timezone: &Tz) -> String {
         let time_display = match flags.time_display {
-            TimeDisplayType::Absolute => {
-                self.utc_time.with_timezone(timezone).format("%Y-%m-%d %H:%M:%S").to_string()
-            }
+            TimeDisplayType::Absolute => timezone
+                .timestamp(self.utc_time.timestamp(), 0)
+                .format("%Y-%m-%d %H:%M:%S")
+                .to_string(),
 
             TimeDisplayType::Relative => format!("<t:{}:R>", self.utc_time.timestamp()),
         };
 
-        if self.interval_seconds.is_some()
-            || self.interval_days.is_some()
-            || self.interval_months.is_some()
-        {
+        if self.interval_seconds.is_some() || self.interval_months.is_some() {
             format!(
-                "'{}' *occurs next at* **{}**, repeating (set by {})\n",
+                "'{}' *occurs next at* **{}**, repeating (set by {})",
                 self.display_content(),
                 time_display,
                 self.set_by.map(|i| format!("<@{}>", i)).unwrap_or_else(|| "unknown".to_string())
             )
         } else {
             format!(
-                "'{}' *occurs next at* **{}** (set by {})\n",
+                "'{}' *occurs next at* **{}** (set by {})",
                 self.display_content(),
                 time_display,
                 self.set_by.map(|i| format!("<@{}>", i)).unwrap_or_else(|| "unknown".to_string())

src/models/timer.rs

@@ -1,9 +1,9 @@
-use chrono::{DateTime, Utc};
+use chrono::NaiveDateTime;
 use sqlx::MySqlPool;
 
 pub struct Timer {
     pub name: String,
-    pub start_time: DateTime<Utc>,
+    pub start_time: NaiveDateTime,
     pub owner: u64,
 }
 

src/models/user_data.rs

@@ -1,6 +1,6 @@
 use chrono_tz::Tz;
 use log::error;
-use poise::serenity_prelude::{http::CacheHttp, model::id::UserId};
+use poise::serenity::{http::CacheHttp, model::id::UserId};
 use sqlx::MySqlPool;
 
 use crate::consts::LOCAL_TIMEZONE;
@@ -10,7 +10,6 @@ pub struct UserData {
     pub user: u64,
     pub dm_channel: u32,
     pub timezone: String,
-    pub allowed_dm: bool,
 }
 
 impl UserData {
@@ -22,7 +21,7 @@ impl UserData {
 
         match sqlx::query!(
             "
-SELECT IFNULL(timezone, 'UTC') AS timezone FROM users WHERE user = ?
+SELECT timezone FROM users WHERE user = ?
             ",
             user_id
         )
@@ -47,7 +46,7 @@ SELECT IFNULL(timezone, 'UTC') AS timezone FROM users WHERE user = ?
         match sqlx::query_as_unchecked!(
             Self,
             "
-SELECT id, user, dm_channel, IF(timezone IS NULL, ?, timezone) AS timezone, allowed_dm FROM users WHERE user = ?
+SELECT id, user, dm_channel, IF(timezone IS NULL, ?, timezone) AS timezone FROM users WHERE user = ?
             ",
             *LOCAL_TIMEZONE,
             user_id.0
@@ -84,7 +83,7 @@ INSERT INTO users (name, user, dm_channel, timezone) VALUES ('', ?, (SELECT id F
                 Ok(sqlx::query_as_unchecked!(
                     Self,
                     "
-SELECT id, user, dm_channel, timezone, allowed_dm FROM users WHERE user = ?
+SELECT id, user, dm_channel, timezone FROM users WHERE user = ?
                     ",
                     user_id.0
                 )
@@ -103,10 +102,9 @@ SELECT id, user, dm_channel, timezone, allowed_dm FROM users WHERE user = ?
     pub async fn commit_changes(&self, pool: &MySqlPool) {
         sqlx::query!(
             "
-UPDATE users SET timezone = ?, allowed_dm = ? WHERE id = ?
+UPDATE users SET timezone = ? WHERE id = ?
             ",
             self.timezone,
-            self.allowed_dm,
             self.id
         )
         .execute(pool)

src/utils.rs

@@ -1,11 +1,10 @@
 use poise::{
-    serenity_prelude as serenity,
-    serenity_prelude::{
+    serenity::{
         builder::CreateApplicationCommands,
         http::CacheHttp,
-        interaction::MessageFlags,
         model::id::{GuildId, UserId},
     },
+    serenity_prelude as serenity,
 };
 
 use crate::{
@@ -14,10 +13,10 @@ use crate::{
 };
 
 pub async fn register_application_commands(
-    ctx: &serenity::Context,
+    ctx: &poise::serenity::client::Context,
     framework: &poise::Framework<Data, Error>,
     guild_id: Option<GuildId>,
-) -> Result<(), serenity::Error> {
+) -> Result<(), poise::serenity::Error> {
     let mut commands_builder = CreateApplicationCommands::default();
     let commands = &framework.options().commands;
     for command in commands {
@@ -28,7 +27,7 @@ pub async fn register_application_commands(
             commands_builder.add_application_command(context_menu_command);
         }
     }
-    let commands_builder = poise::serenity_prelude::json::Value::Array(commands_builder.0);
+    let commands_builder = poise::serenity::json::Value::Array(commands_builder.0);
 
     if let Some(guild_id) = guild_id {
         ctx.http.create_guild_application_commands(guild_id.0, &commands_builder).await?;
@@ -83,7 +82,7 @@ pub fn send_as_initial_response(
         components,
         ephemeral,
         allowed_mentions,
-        reply: _,
+        reference_message: _, // can't reply to a message in interactions
     } = data;
 
     if let Some(content) = content {
@@ -103,6 +102,6 @@ pub fn send_as_initial_response(
         });
     }
     if ephemeral {
-        f.flags(MessageFlags::EPHEMERAL);
+        f.flags(serenity::InteractionApplicationCommandCallbackDataFlags::EPHEMERAL);
     }
 }

systemd/reminder-rs.service

@@ -1,14 +0,0 @@
-[Unit]
-Description=Reminder Bot
-
-[Service]
-User=reminder
-Type=simple
-ExecStart=/usr/bin/reminder-rs
-WorkingDirectory=/etc/reminder-rs
-Restart=always
-RestartSec=4
-Environment="reminder_rs=warn,postman=warn"
-
-[Install]
-WantedBy=multi-user.target

web/Cargo.toml

@@ -7,15 +7,15 @@ edition = "2018"
 [dependencies]
 rocket = { git = "https://github.com/SergioBenitez/Rocket", branch = "master", features = ["tls", "secrets", "json"] }
 rocket_dyn_templates = { git = "https://github.com/SergioBenitez/Rocket", branch = "master", features = ["tera"] }
-serenity = { version = "0.11", default-features = false, features = ["builder", "cache", "client", "gateway", "http", "model", "utils", "rustls_backend"] }
+serenity = { version = "0.11.1", default-features = false, features = ["builder", "cache", "client", "gateway", "http", "model", "utils", "rustls_backend"] }
 oauth2 = "4"
 log = "0.4"
 reqwest = "0.11"
 serde = { version = "1.0", features = ["derive"] }
-sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "macros", "mysql", "chrono", "json"] }
+serde_json = "1.0"
+sqlx = { version = "0.5", features = ["runtime-tokio-rustls", "macros", "mysql", "chrono", "json"] }
 chrono = "0.4"
-chrono-tz = "0.8"
+chrono-tz = "0.5"
 lazy_static = "1.4.0"
 rand = "0.7"
 base64 = "0.13"
-csv = "1.1"

web/src/consts.rs

@@ -2,7 +2,6 @@ pub const DISCORD_OAUTH_TOKEN: &'static str = "https://discord.com/api/oauth2/to
 pub const DISCORD_OAUTH_AUTHORIZE: &'static str = "https://discord.com/api/oauth2/authorize";
 pub const DISCORD_API: &'static str = "https://discord.com/api";
 
-pub const MAX_NAME_LENGTH: usize = 100;
 pub const MAX_CONTENT_LENGTH: usize = 2000;
 pub const MAX_EMBED_DESCRIPTION_LENGTH: usize = 4096;
 pub const MAX_EMBED_TITLE_LENGTH: usize = 256;
@@ -27,12 +26,16 @@ use serenity::model::prelude::AttachmentType;
 
 lazy_static! {
     pub static ref DEFAULT_AVATAR: AttachmentType<'static> = (
-        include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/../assets/webhook.jpg")) as &[u8],
-        "webhook.jpg",
+        include_bytes!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/../assets/",
+            env!("WEBHOOK_AVATAR", "WEBHOOK_AVATAR not provided for compilation")
+        )) as &[u8],
+        env!("WEBHOOK_AVATAR"),
     )
         .into();
     pub static ref SUBSCRIPTION_ROLES: HashSet<u64> = HashSet::from_iter(
-        env::var("PATREON_ROLE_ID")
+        env::var("SUBSCRIPTION_ROLES")
             .map(|var| var
                 .split(',')
                 .filter_map(|item| { item.parse::<u64>().ok() })
@@ -40,7 +43,7 @@ lazy_static! {
             .unwrap_or_else(|_| Vec::new())
     );
     pub static ref CNC_GUILD: Option<u64> =
-        env::var("PATREON_GUILD_ID").map(|var| var.parse::<u64>().ok()).ok().flatten();
+        env::var("CNC_GUILD").map(|var| var.parse::<u64>().ok()).ok().flatten();
     pub static ref MIN_INTERVAL: u32 = env::var("MIN_INTERVAL")
         .ok()
         .map(|inner| inner.parse::<u32>().ok())

web/src/lib.rs

@@ -6,7 +6,7 @@ mod consts;
 mod macros;
 mod routes;
 
-use std::{collections::HashMap, env, path::Path};
+use std::{collections::HashMap, env};
 
 use oauth2::{basic::BasicClient, AuthUrl, ClientId, ClientSecret, RedirectUrl, TokenUrl};
 use rocket::{
@@ -72,14 +72,10 @@ pub async fn initialize(
     db_pool: Pool<Database>,
 ) -> Result<(), Box<dyn std::error::Error>> {
     info!("Checking environment variables...");
-
-    if env::var("OFFLINE").map_or(true, |v| v != "1") {
     env::var("OAUTH2_CLIENT_ID").expect("`OAUTH2_CLIENT_ID' not supplied");
     env::var("OAUTH2_CLIENT_SECRET").expect("`OAUTH2_CLIENT_SECRET' not supplied");
     env::var("OAUTH2_DISCORD_CALLBACK").expect("`OAUTH2_DISCORD_CALLBACK' not supplied");
-        env::var("PATREON_GUILD_ID").expect("`PATREON_GUILD_ID' not supplied");
-    }
-
+    env::var("PATREON_GUILD_ID").expect("`PATREON_GUILD' not supplied");
     info!("Done!");
 
     let oauth2_client = BasicClient::new(
@@ -92,9 +88,6 @@ pub async fn initialize(
 
     let reqwest_client = reqwest::Client::new();
 
-    let static_path =
-        if Path::new("web/static").exists() { "web/static" } else { "/lib/reminder-rs/static" };
-
     rocket::build()
         .attach(Template::fairing())
         .register(
@@ -112,7 +105,7 @@ pub async fn initialize(
         .manage(reqwest_client)
         .manage(serenity_context)
         .manage(db_pool)
-        .mount("/static", FileServer::from(static_path))
+        .mount("/static", FileServer::from(concat!(env!("CARGO_MANIFEST_DIR"), "/static")))
         .mount(
             "/",
             routes![
@@ -120,8 +113,7 @@ pub async fn initialize(
                 routes::cookies,
                 routes::privacy,
                 routes::terms,
-                routes::return_to_same_site,
-                routes::report::report_error,
+                routes::return_to_same_site
             ],
         )
         .mount(
@@ -139,19 +131,11 @@ pub async fn initialize(
                 routes::help_iemanager,
             ],
         )
-        .mount(
-            "/login",
-            routes![
-                routes::login::discord_login,
-                routes::login::discord_logout,
-                routes::login::discord_callback
-            ],
-        )
+        .mount("/login", routes![routes::login::discord_login, routes::login::discord_callback])
         .mount(
             "/dashboard",
             routes![
-                routes::dashboard::dashboard_1,
-                routes::dashboard::dashboard_2,
+                routes::dashboard::dashboard,
                 routes::dashboard::dashboard_home,
                 routes::dashboard::user::get_user_info,
                 routes::dashboard::user::update_user_info,
@@ -162,18 +146,12 @@ pub async fn initialize(
                 routes::dashboard::guild::get_reminder_templates,
                 routes::dashboard::guild::create_reminder_template,
                 routes::dashboard::guild::delete_reminder_template,
-                routes::dashboard::guild::create_guild_reminder,
+                routes::dashboard::guild::create_reminder,
                 routes::dashboard::guild::get_reminders,
                 routes::dashboard::guild::edit_reminder,
                 routes::dashboard::guild::delete_reminder,
-                routes::dashboard::export::export_reminders,
-                routes::dashboard::export::export_reminder_templates,
-                routes::dashboard::export::export_todos,
-                routes::dashboard::export::import_reminders,
-                routes::dashboard::export::import_todos,
             ],
         )
-        .mount("/admin", routes![routes::admin::admin_dashboard_home, routes::admin::bot_data])
         .launch()
         .await?;
 
@@ -190,8 +168,6 @@ pub async fn initialize(
 }
 
 pub async fn check_subscription(cache_http: impl CacheHttp, user_id: impl Into<UserId>) -> bool {
-    offline!(true);
-
     if let Some(subscription_guild) = *CNC_GUILD {
         let guild_member = GuildId(subscription_guild).member(cache_http, user_id).await;
 
@@ -213,8 +189,6 @@ pub async fn check_guild_subscription(
     cache_http: impl CacheHttp,
     guild_id: impl Into<GuildId>,
 ) -> bool {
-    offline!(true);
-
     if let Some(guild) = cache_http.cache().unwrap().guild(guild_id) {
         let owner = guild.owner_id;
 

web/src/macros.rs

@@ -1,15 +1,7 @@
-macro_rules! offline {
-    ($field:expr) => {
-        if std::env::var("OFFLINE").map_or(false, |v| v == "1") {
-            return $field;
-        }
-    };
-}
-
 macro_rules! check_length {
     ($max:ident, $field:expr) => {
         if $field.len() > $max {
-            return Err(json!({ "error": format!("{} exceeded", stringify!($max)) }));
+            return json!({ "error": format!("{} exceeded", stringify!($max)) });
         }
     };
     ($max:ident, $field:expr, $($fields:expr),+) => {
@@ -33,7 +25,7 @@ macro_rules! check_length_opt {
 macro_rules! check_url {
     ($field:expr) => {
         if !($field.starts_with("http://") || $field.starts_with("https://")) {
-            return Err(json!({ "error": "URL invalid" }));
+            return json!({ "error": "URL invalid" });
         }
     };
     ($field:expr, $($fields:expr),+) => {
@@ -60,45 +52,29 @@ macro_rules! check_authorization {
 
         let user_id = $cookies.get_private("userid").map(|c| c.value().parse::<u64>().ok()).flatten();
 
-        if std::env::var("OFFLINE").map_or(true, |v| v != "1") {
         match user_id {
             Some(user_id) => {
                 match GuildId($guild).to_guild_cached($ctx) {
                     Some(guild) => {
-                            let member_res = guild.member($ctx, UserId(user_id)).await;
+                        let member = guild.member($ctx, UserId(user_id)).await;
 
-                            match member_res {
+                        match member {
                             Err(_) => {
-                                    return Err(json!({"error": "User not in guild"}));
+                                return json!({"error": "User not in guild"})
                             }
 
-                                Ok(member) => {
-                                    let permissions_res = member.permissions($ctx);
-
-                                    match permissions_res {
-                                        Err(_) => {
-                                            return Err(json!({"error": "Couldn't fetch permissions"}));
+                            Ok(_) => {}
+                        }
                     }
 
-                                        Ok(permissions) => {
-                                            if !(permissions.manage_messages() || permissions.manage_guild() || permissions.administrator()) {
-                                                return Err(json!({"error": "Incorrect permissions"}));
-                                            }
-                                        }
-                                    }
+                    None => {
+                        return json!({"error": "Bot not in guild"})
                     }
                 }
             }
 
             None => {
-                            return Err(json!({"error": "Bot not in guild"}));
-                        }
-                    }
-                }
-
-                None => {
-                    return Err(json!({"error": "User not authorized"}));
-                }
+                return json!({"error": "User not authorized"});
             }
         }
     }
@@ -141,9 +117,3 @@ macro_rules! update_field {
         update_field!($pool, $error, $reminder.[$($fields),+]);
     };
 }
-
-macro_rules! json_err {
-    ($message:expr) => {
-        Err(json!({ "error": $message }))
-    };
-}

web/src/routes/admin.rs

@@ -1,218 +0,0 @@
-use std::{collections::HashMap, env};
-
-use chrono::{DateTime, Utc};
-use rocket::{
-    http::{CookieJar, Status},
-    serde::json::json,
-    State,
-};
-use rocket_dyn_templates::Template;
-use serde::Serialize;
-use sqlx::{MySql, Pool};
-
-use crate::routes::JsonResult;
-
-fn is_admin(cookies: &CookieJar<'_>) -> bool {
-    cookies
-        .get_private("userid")
-        .map_or(false, |cookie| Some(cookie.value().to_string()) == env::var("ADMIN_ID").ok())
-}
-
-#[get("/")]
-pub async fn admin_dashboard_home(cookies: &CookieJar<'_>) -> Result<Template, Status> {
-    if let Some(cookie) = cookies.get_private("userid") {
-        let map: HashMap<&str, String> = HashMap::new();
-        if Some(cookie.value().to_string()) == env::var("ADMIN_ID").ok() {
-            Ok(Template::render("admin_dashboard", &map))
-        } else {
-            Err(Status::Forbidden)
-        }
-    } else {
-        Err(Status::Unauthorized)
-    }
-}
-
-#[derive(Serialize)]
-struct TimeFrame {
-    time_key: DateTime<Utc>,
-    count: i64,
-}
-
-#[get("/data")]
-pub async fn bot_data(cookies: &CookieJar<'_>, pool: &State<Pool<MySql>>) -> JsonResult {
-    if !is_admin(cookies) {
-        return json_err!("Not authorized");
-    }
-
-    let backlog = sqlx::query!(
-        "SELECT COUNT(1) AS backlog FROM reminders WHERE `utc_time` < NOW() AND enabled = 1 AND `status` = 'pending'"
-    )
-    .fetch_one(pool.inner())
-    .await
-    .unwrap();
-
-    let schedule_once = sqlx::query_as_unchecked!(
-        TimeFrame,
-        "SELECT
-            FROM_UNIXTIME(FLOOR(UNIX_TIMESTAMP(`utc_time`) / 300) * 300) AS `time_key`,
-            COUNT(1) AS `count`
-        FROM reminders
-        WHERE
-            `utc_time` < DATE_ADD(NOW(), INTERVAL 1 DAY) AND
-            `utc_time` >= NOW() AND
-            `enabled` = 1 AND
-            `status` = 'pending' AND
-            `interval_seconds` IS NULL AND
-            `interval_months` IS NULL AND
-            `interval_days` IS NULL
-        GROUP BY `time_key`
-        ORDER BY `time_key`"
-    )
-    .fetch_all(pool.inner())
-    .await
-    .unwrap();
-
-    let schedule_interval = sqlx::query_as_unchecked!(
-        TimeFrame,
-        "SELECT
-            FROM_UNIXTIME(FLOOR(UNIX_TIMESTAMP(`utc_time`) / 300) * 300) AS `time_key`,
-            COUNT(1) AS `count`
-        FROM reminders
-        WHERE
-            `utc_time` < DATE_ADD(NOW(), INTERVAL 1 DAY) AND
-            `utc_time` >= NOW() AND
-            `status` = 'pending' AND
-            `enabled` = 1 AND (
-                `interval_seconds` IS NOT NULL OR
-                `interval_months` IS NOT NULL OR
-                `interval_days` IS NOT NULL
-            )
-        GROUP BY `time_key`
-        ORDER BY `time_key`"
-    )
-    .fetch_all(pool.inner())
-    .await
-    .unwrap();
-
-    let schedule_once_long = sqlx::query_as_unchecked!(
-        TimeFrame,
-        "SELECT
-            FROM_UNIXTIME(FLOOR(UNIX_TIMESTAMP(`utc_time`) / 86400) * 86400) AS `time_key`,
-            COUNT(1) AS `count`
-        FROM reminders
-        WHERE
-            `utc_time` < DATE_ADD(NOW(), INTERVAL 31 DAY) AND
-            `utc_time` >= NOW() AND
-            `enabled` = 1 AND
-            `status` = 'pending' AND
-            `interval_seconds` IS NULL AND
-            `interval_months` IS NULL AND
-            `interval_days` IS NULL
-        GROUP BY `time_key`
-        ORDER BY `time_key`"
-    )
-    .fetch_all(pool.inner())
-    .await
-    .unwrap();
-
-    let schedule_interval_long = sqlx::query_as_unchecked!(
-        TimeFrame,
-        "SELECT
-            FROM_UNIXTIME(FLOOR(UNIX_TIMESTAMP(`utc_time`) / 86400) * 86400) AS `time_key`,
-            COUNT(1) AS `count`
-        FROM reminders
-        WHERE
-            `utc_time` < DATE_ADD(NOW(), INTERVAL 31 DAY) AND
-            `utc_time` >= NOW() AND
-            `status` = 'pending' AND
-            `enabled` = 1 AND (
-                `interval_seconds` IS NOT NULL OR
-                `interval_months` IS NOT NULL OR
-                `interval_days` IS NOT NULL
-            )
-        GROUP BY `time_key`
-        ORDER BY `time_key`"
-    )
-    .fetch_all(pool.inner())
-    .await
-    .unwrap();
-
-    let history = sqlx::query_as_unchecked!(
-        TimeFrame,
-        "SELECT
-            FROM_UNIXTIME(FLOOR(UNIX_TIMESTAMP(`utc_time`) / 86400) * 86400) AS `time_key`,
-            COUNT(1) AS `count`
-        FROM stat
-        WHERE
-            `utc_time` > DATE_SUB(NOW(), INTERVAL 31 DAY) AND
-            `type` = 'reminder_sent'
-        GROUP BY `time_key`
-        ORDER BY `time_key`"
-    )
-    .fetch_all(pool.inner())
-    .await
-    .unwrap();
-
-    let history_failed = sqlx::query_as_unchecked!(
-        TimeFrame,
-        "SELECT
-            FROM_UNIXTIME(FLOOR(UNIX_TIMESTAMP(`utc_time`) / 86400) * 86400) AS `time_key`,
-            COUNT(1) AS `count`
-        FROM stat
-        WHERE
-            `utc_time` > DATE_SUB(NOW(), INTERVAL 31 DAY) AND
-            `type` = 'reminder_failed'
-        GROUP BY `time_key`
-        ORDER BY `time_key`"
-    )
-    .fetch_all(pool.inner())
-    .await
-    .unwrap();
-
-    let interval_count = sqlx::query!(
-        "SELECT COUNT(1) AS count
-        FROM reminders
-        WHERE
-            `status` = 'pending' AND (
-                `interval_seconds` IS NOT NULL OR
-                `interval_months` IS NOT NULL OR
-                `interval_days` IS NOT NULL
-            )"
-    )
-    .fetch_one(pool.inner())
-    .await
-    .unwrap();
-
-    let reminder_count = sqlx::query!(
-        "SELECT COUNT(1) AS count
-        FROM reminders
-        WHERE
-            `status` = 'pending' AND
-            `interval_seconds` IS NULL AND
-            `interval_months` IS NULL AND
-            `interval_days` IS NULL"
-    )
-    .fetch_one(pool.inner())
-    .await
-    .unwrap();
-
-    Ok(json!({
-        "backlog": backlog.backlog,
-        "scheduleShort": {
-            "once": schedule_once,
-            "interval": schedule_interval
-        },
-        "scheduleLong": {
-            "once": schedule_once_long,
-            "interval": schedule_interval_long,
-        },
-        "historyLong": {
-            "sent": history,
-            "failed": history_failed,
-        },
-        "count": {
-            "reminders": reminder_count.count,
-            "intervals": interval_count.count,
-        }
-    }))
-}

web/src/routes/dashboard/export.rs

@@ -1,426 +0,0 @@
-use csv::{QuoteStyle, WriterBuilder};
-use rocket::{
-    http::CookieJar,
-    serde::json::{json, serde_json, Json},
-    State,
-};
-use serenity::{
-    client::Context,
-    model::id::{ChannelId, GuildId},
-};
-use sqlx::{MySql, Pool};
-
-use crate::routes::{
-    dashboard::{
-        create_reminder, ImportBody, ReminderCreate, ReminderCsv, ReminderTemplateCsv, TodoCsv,
-    },
-    JsonResult,
-};
-
-#[get("/api/guild/<id>/export/reminders")]
-pub async fn export_reminders(
-    id: u64,
-    cookies: &CookieJar<'_>,
-    ctx: &State<Context>,
-    pool: &State<Pool<MySql>>,
-) -> JsonResult {
-    check_authorization!(cookies, ctx.inner(), id);
-
-    let mut csv_writer = WriterBuilder::new().quote_style(QuoteStyle::Always).from_writer(vec![]);
-
-    let channels_res = GuildId(id).channels(&ctx.inner()).await;
-
-    match channels_res {
-        Ok(channels) => {
-            let channels = channels
-                .keys()
-                .into_iter()
-                .map(|k| k.as_u64().to_string())
-                .collect::<Vec<String>>()
-                .join(",");
-
-            let result = sqlx::query_as_unchecked!(
-                ReminderCsv,
-                "SELECT
-                 reminders.attachment,
-                 reminders.attachment_name,
-                 reminders.avatar,
-                 CONCAT('#', channels.channel) AS channel,
-                 reminders.content,
-                 reminders.embed_author,
-                 reminders.embed_author_url,
-                 reminders.embed_color,
-                 reminders.embed_description,
-                 reminders.embed_footer,
-                 reminders.embed_footer_url,
-                 reminders.embed_image_url,
-                 reminders.embed_thumbnail_url,
-                 reminders.embed_title,
-                 reminders.embed_fields,
-                 reminders.enabled,
-                 reminders.expires,
-                 reminders.interval_seconds,
-                 reminders.interval_days,
-                 reminders.interval_months,
-                 reminders.name,
-                 reminders.restartable,
-                 reminders.tts,
-                 reminders.username,
-                 reminders.utc_time
-                FROM reminders
-                LEFT JOIN channels ON channels.id = reminders.channel_id
-                WHERE FIND_IN_SET(channels.channel, ?)",
-                channels
-            )
-            .fetch_all(pool.inner())
-            .await;
-
-            match result {
-                Ok(reminders) => {
-                    reminders.iter().for_each(|reminder| {
-                        csv_writer.serialize(reminder).unwrap();
-                    });
-
-                    match csv_writer.into_inner() {
-                        Ok(inner) => match String::from_utf8(inner) {
-                            Ok(encoded) => Ok(json!({ "body": encoded })),
-
-                            Err(e) => {
-                                warn!("Failed to write UTF-8: {:?}", e);
-
-                                Err(json!({"error": "Failed to write UTF-8"}))
-                            }
-                        },
-
-                        Err(e) => {
-                            warn!("Failed to extract CSV: {:?}", e);
-
-                            Err(json!({"error": "Failed to extract CSV"}))
-                        }
-                    }
-                }
-
-                Err(e) => {
-                    warn!("Failed to complete SQL query: {:?}", e);
-
-                    Err(json!({"error": "Failed to query reminders"}))
-                }
-            }
-        }
-
-        Err(e) => {
-            warn!("Could not fetch channels from {}: {:?}", id, e);
-
-            Err(json!({"error": "Failed to get guild channels"}))
-        }
-    }
-}
-
-#[put("/api/guild/<id>/export/reminders", data = "<body>")]
-pub async fn import_reminders(
-    id: u64,
-    cookies: &CookieJar<'_>,
-    body: Json<ImportBody>,
-    ctx: &State<Context>,
-    pool: &State<Pool<MySql>>,
-) -> JsonResult {
-    check_authorization!(cookies, ctx.inner(), id);
-
-    let user_id =
-        cookies.get_private("userid").map(|c| c.value().parse::<u64>().ok()).flatten().unwrap();
-
-    match base64::decode(&body.body) {
-        Ok(body) => {
-            let mut reader = csv::Reader::from_reader(body.as_slice());
-
-            for result in reader.deserialize::<ReminderCsv>() {
-                match result {
-                    Ok(record) => {
-                        let channel_id = record.channel.split_at(1).1;
-
-                        match channel_id.parse::<u64>() {
-                            Ok(channel_id) => {
-                                let reminder = ReminderCreate {
-                                    attachment: record.attachment,
-                                    attachment_name: record.attachment_name,
-                                    avatar: record.avatar,
-                                    channel: channel_id,
-                                    content: record.content,
-                                    embed_author: record.embed_author,
-                                    embed_author_url: record.embed_author_url,
-                                    embed_color: record.embed_color,
-                                    embed_description: record.embed_description,
-                                    embed_footer: record.embed_footer,
-                                    embed_footer_url: record.embed_footer_url,
-                                    embed_image_url: record.embed_image_url,
-                                    embed_thumbnail_url: record.embed_thumbnail_url,
-                                    embed_title: record.embed_title,
-                                    embed_fields: record
-                                        .embed_fields
-                                        .map(|s| serde_json::from_str(&s).ok())
-                                        .flatten(),
-                                    enabled: record.enabled,
-                                    expires: record.expires,
-                                    interval_seconds: record.interval_seconds,
-                                    interval_days: record.interval_days,
-                                    interval_months: record.interval_months,
-                                    name: record.name,
-                                    restartable: record.restartable,
-                                    tts: record.tts,
-                                    username: record.username,
-                                    utc_time: record.utc_time,
-                                };
-
-                                create_reminder(
-                                    ctx.inner(),
-                                    pool.inner(),
-                                    GuildId(id),
-                                    UserId(user_id),
-                                    reminder,
-                                )
-                                .await?;
-                            }
-
-                            Err(_) => {
-                                return json_err!(format!(
-                                    "Failed to parse channel {}",
-                                    channel_id
-                                ));
-                            }
-                        }
-                    }
-
-                    Err(e) => {
-                        warn!("Couldn't deserialize CSV row: {:?}", e);
-
-                        return json_err!("Deserialize error. Aborted");
-                    }
-                }
-            }
-
-            Ok(json!({}))
-        }
-
-        Err(_) => {
-            json_err!("Malformed base64")
-        }
-    }
-}
-
-#[get("/api/guild/<id>/export/todos")]
-pub async fn export_todos(
-    id: u64,
-    cookies: &CookieJar<'_>,
-    ctx: &State<Context>,
-    pool: &State<Pool<MySql>>,
-) -> JsonResult {
-    check_authorization!(cookies, ctx.inner(), id);
-
-    let mut csv_writer = WriterBuilder::new().quote_style(QuoteStyle::Always).from_writer(vec![]);
-
-    match sqlx::query_as_unchecked!(
-        TodoCsv,
-        "SELECT value, CONCAT('#', channels.channel) AS channel_id FROM todos
-        LEFT JOIN channels ON todos.channel_id = channels.id
-        INNER JOIN guilds ON todos.guild_id = guilds.id
-        WHERE guilds.guild = ?",
-        id
-    )
-    .fetch_all(pool.inner())
-    .await
-    {
-        Ok(todos) => {
-            todos.iter().for_each(|todo| {
-                csv_writer.serialize(todo).unwrap();
-            });
-
-            match csv_writer.into_inner() {
-                Ok(inner) => match String::from_utf8(inner) {
-                    Ok(encoded) => Ok(json!({ "body": encoded })),
-
-                    Err(e) => {
-                        warn!("Failed to write UTF-8: {:?}", e);
-
-                        json_err!("Failed to write UTF-8")
-                    }
-                },
-
-                Err(e) => {
-                    warn!("Failed to extract CSV: {:?}", e);
-
-                    json_err!("Failed to extract CSV")
-                }
-            }
-        }
-
-        Err(e) => {
-            warn!("Could not fetch templates from {}: {:?}", id, e);
-
-            json_err!("Failed to query templates")
-        }
-    }
-}
-
-#[put("/api/guild/<id>/export/todos", data = "<body>")]
-pub async fn import_todos(
-    id: u64,
-    cookies: &CookieJar<'_>,
-    body: Json<ImportBody>,
-    ctx: &State<Context>,
-    pool: &State<Pool<MySql>>,
-) -> JsonResult {
-    check_authorization!(cookies, ctx.inner(), id);
-
-    let channels_res = GuildId(id).channels(&ctx.inner()).await;
-
-    match channels_res {
-        Ok(channels) => match base64::decode(&body.body) {
-            Ok(body) => {
-                let mut reader = csv::Reader::from_reader(body.as_slice());
-
-                let query_placeholder = "(?, (SELECT id FROM channels WHERE channel = ?), (SELECT id FROM guilds WHERE guild = ?))";
-                let mut query_params = vec![];
-
-                for result in reader.deserialize::<TodoCsv>() {
-                    match result {
-                        Ok(record) => match record.channel_id {
-                            Some(channel_id) => {
-                                let channel_id = channel_id.split_at(1).1;
-
-                                match channel_id.parse::<u64>() {
-                                    Ok(channel_id) => {
-                                        if channels.contains_key(&ChannelId(channel_id)) {
-                                            query_params.push((record.value, Some(channel_id), id));
-                                        } else {
-                                            return json_err!(format!(
-                                                "Invalid channel ID {}",
-                                                channel_id
-                                            ));
-                                        }
-                                    }
-
-                                    Err(_) => {
-                                        return json_err!(format!(
-                                            "Invalid channel ID {}",
-                                            channel_id
-                                        ));
-                                    }
-                                }
-                            }
-
-                            None => {
-                                query_params.push((record.value, None, id));
-                            }
-                        },
-
-                        Err(e) => {
-                            warn!("Couldn't deserialize CSV row: {:?}", e);
-
-                            return json_err!("Deserialize error. Aborted");
-                        }
-                    }
-                }
-
-                let query_str = format!(
-                    "INSERT INTO todos (value, channel_id, guild_id) VALUES {}",
-                    vec![query_placeholder].repeat(query_params.len()).join(",")
-                );
-                let mut query = sqlx::query(&query_str);
-
-                for param in query_params {
-                    query = query.bind(param.0).bind(param.1).bind(param.2);
-                }
-
-                let res = query.execute(pool.inner()).await;
-
-                match res {
-                    Ok(_) => Ok(json!({})),
-
-                    Err(e) => {
-                        warn!("Couldn't execute todo query: {:?}", e);
-
-                        json_err!("An unexpected error occured.")
-                    }
-                }
-            }
-
-            Err(_) => {
-                json_err!("Malformed base64")
-            }
-        },
-
-        Err(e) => {
-            warn!("Couldn't fetch channels for guild {}: {:?}", id, e);
-
-            json_err!("Couldn't fetch channels.")
-        }
-    }
-}
-
-#[get("/api/guild/<id>/export/reminder_templates")]
-pub async fn export_reminder_templates(
-    id: u64,
-    cookies: &CookieJar<'_>,
-    ctx: &State<Context>,
-    pool: &State<Pool<MySql>>,
-) -> JsonResult {
-    check_authorization!(cookies, ctx.inner(), id);
-
-    let mut csv_writer = WriterBuilder::new().quote_style(QuoteStyle::Always).from_writer(vec![]);
-
-    match sqlx::query_as_unchecked!(
-        ReminderTemplateCsv,
-        "SELECT
-         name,
-         attachment,
-         attachment_name,
-         avatar,
-         content,
-         embed_author,
-         embed_author_url,
-         embed_color,
-         embed_description,
-         embed_footer,
-         embed_footer_url,
-         embed_image_url,
-         embed_thumbnail_url,
-         embed_title,
-         embed_fields,
-         tts,
-         username
-        FROM reminder_template WHERE guild_id = (SELECT id FROM guilds WHERE guild = ?)",
-        id
-    )
-    .fetch_all(pool.inner())
-    .await
-    {
-        Ok(templates) => {
-            templates.iter().for_each(|template| {
-                csv_writer.serialize(template).unwrap();
-            });
-
-            match csv_writer.into_inner() {
-                Ok(inner) => match String::from_utf8(inner) {
-                    Ok(encoded) => Ok(json!({ "body": encoded })),
-
-                    Err(e) => {
-                        warn!("Failed to write UTF-8: {:?}", e);
-
-                        json_err!("Failed to write UTF-8")
-                    }
-                },
-
-                Err(e) => {
-                    warn!("Failed to extract CSV: {:?}", e);
-
-                    json_err!("Failed to extract CSV")
-                }
-            }
-        }
-        Err(e) => {
-            warn!("Could not fetch templates from {}: {:?}", id, e);
-
-            json_err!("Failed to query templates")
-        }
-    }
-}

web/src/routes/dashboard/guild.rs

@@ -1,8 +1,10 @@
 use std::env;
 
+use base64;
+use chrono::Utc;
 use rocket::{
     http::CookieJar,
-    serde::json::{json, Json},
+    serde::json::{json, Json, Value as JsonValue},
     State,
 };
 use serde::Serialize;
@@ -18,17 +20,14 @@ use sqlx::{MySql, Pool};
 use crate::{
     check_guild_subscription, check_subscription,
     consts::{
-        MAX_CONTENT_LENGTH, MAX_EMBED_AUTHOR_LENGTH, MAX_EMBED_DESCRIPTION_LENGTH,
+        DAY, MAX_CONTENT_LENGTH, MAX_EMBED_AUTHOR_LENGTH, MAX_EMBED_DESCRIPTION_LENGTH,
         MAX_EMBED_FIELDS, MAX_EMBED_FIELD_TITLE_LENGTH, MAX_EMBED_FIELD_VALUE_LENGTH,
         MAX_EMBED_FOOTER_LENGTH, MAX_EMBED_TITLE_LENGTH, MAX_URL_LENGTH, MAX_USERNAME_LENGTH,
         MIN_INTERVAL,
     },
-    routes::{
-        dashboard::{
-            create_database_channel, create_reminder, template_name_default, DeleteReminder,
-            DeleteReminderTemplate, PatchReminder, Reminder, ReminderCreate, ReminderTemplate,
-        },
-        JsonResult,
+    routes::dashboard::{
+        create_database_channel, generate_uid, name_default, template_name_default, DeleteReminder,
+        DeleteReminderTemplate, PatchReminder, Reminder, ReminderTemplate,
     },
 };
 
@@ -45,8 +44,7 @@ pub async fn get_guild_patreon(
     id: u64,
     cookies: &CookieJar<'_>,
     ctx: &State<Context>,
-) -> JsonResult {
-    offline!(Ok(json!({ "patreon": true })));
+) -> JsonValue {
     check_authorization!(cookies, ctx.inner(), id);
 
     match GuildId(id).to_guild_cached(ctx.inner()) {
@@ -61,10 +59,12 @@ pub async fn get_guild_patreon(
                     .contains(&RoleId(env::var("PATREON_ROLE_ID").unwrap().parse().unwrap()))
             });
 
-            Ok(json!({ "patreon": patreon }))
+            json!({ "patreon": patreon })
         }
 
-        None => json_err!("Bot not in guild"),
+        None => {
+            json!({"error": "Bot not in guild"})
+        }
     }
 }
 
@@ -73,13 +73,7 @@ pub async fn get_guild_channels(
     id: u64,
     cookies: &CookieJar<'_>,
     ctx: &State<Context>,
-) -> JsonResult {
-    offline!(Ok(json!(vec![ChannelInfo {
-        name: "general".to_string(),
-        id: "1".to_string(),
-        webhook_avatar: None,
-        webhook_name: None,
-    }])));
+) -> JsonValue {
     check_authorization!(cookies, ctx.inner(), id);
 
     match GuildId(id).to_guild_cached(ctx.inner()) {
@@ -103,10 +97,12 @@ pub async fn get_guild_channels(
                 })
                 .collect::<Vec<ChannelInfo>>();
 
-            Ok(json!(channel_info))
+            json!(channel_info)
         }
 
-        None => json_err!("Bot not in guild"),
+        None => {
+            json!({"error": "Bot not in guild"})
+        }
     }
 }
 
@@ -117,8 +113,7 @@ struct RoleInfo {
 }
 
 #[get("/api/guild/<id>/roles")]
-pub async fn get_guild_roles(id: u64, cookies: &CookieJar<'_>, ctx: &State<Context>) -> JsonResult {
-    offline!(Ok(json!(vec![RoleInfo { name: "@everyone".to_string(), id: "1".to_string() }])));
+pub async fn get_guild_roles(id: u64, cookies: &CookieJar<'_>, ctx: &State<Context>) -> JsonValue {
     check_authorization!(cookies, ctx.inner(), id);
 
     let roles_res = ctx.cache.guild_roles(id);
@@ -130,12 +125,12 @@ pub async fn get_guild_roles(id: u64, cookies: &CookieJar<'_>, ctx: &State<Conte
                 .map(|(_, r)| RoleInfo { id: r.id.to_string(), name: r.name.to_string() })
                 .collect::<Vec<RoleInfo>>();
 
-            Ok(json!(roles))
+            json!(roles)
         }
         None => {
             warn!("Could not fetch roles from {}", id);
 
-            json_err!("Could not get roles")
+            json!({"error": "Could not get roles"})
         }
     }
 }
@@ -146,7 +141,7 @@ pub async fn get_reminder_templates(
     cookies: &CookieJar<'_>,
     ctx: &State<Context>,
     pool: &State<Pool<MySql>>,
-) -> JsonResult {
+) -> JsonValue {
     check_authorization!(cookies, ctx.inner(), id);
 
     match sqlx::query_as_unchecked!(
@@ -157,11 +152,13 @@ pub async fn get_reminder_templates(
     .fetch_all(pool.inner())
     .await
     {
-        Ok(templates) => Ok(json!(templates)),
+        Ok(templates) => {
+            json!(templates)
+        }
         Err(e) => {
             warn!("Could not fetch templates from {}: {:?}", id, e);
 
-            json_err!("Could not get templates")
+            json!({"error": "Could not get templates"})
         }
     }
 }
@@ -173,7 +170,7 @@ pub async fn create_reminder_template(
     cookies: &CookieJar<'_>,
     ctx: &State<Context>,
     pool: &State<Pool<MySql>>,
-) -> JsonResult {
+) -> JsonValue {
     check_authorization!(cookies, ctx.inner(), id);
 
     // validate lengths
@@ -257,12 +254,12 @@ pub async fn create_reminder_template(
     .await
     {
         Ok(_) => {
-            Ok(json!({}))
+            json!({})
         }
         Err(e) => {
-            warn!("Could not create template for {}: {:?}", id, e);
+            warn!("Could not fetch templates from {}: {:?}", id, e);
 
-            json_err!("Could not create template")
+            json!({"error": "Could not get templates"})
         }
     }
 }
@@ -274,7 +271,7 @@ pub async fn delete_reminder_template(
     cookies: &CookieJar<'_>,
     ctx: &State<Context>,
     pool: &State<Pool<MySql>>,
-) -> JsonResult {
+) -> JsonValue {
     check_authorization!(cookies, ctx.inner(), id);
 
     match sqlx::query!(
@@ -285,55 +282,181 @@ pub async fn delete_reminder_template(
     .await
     {
         Ok(_) => {
-            Ok(json!({}))
+            json!({})
         }
         Err(e) => {
             warn!("Could not delete template from {}: {:?}", id, e);
 
-            json_err!("Could not delete template")
+            json!({"error": "Could not delete template"})
         }
     }
 }
 
 #[post("/api/guild/<id>/reminders", data = "<reminder>")]
-pub async fn create_guild_reminder(
+pub async fn create_reminder(
     id: u64,
-    reminder: Json<ReminderCreate>,
+    reminder: Json<Reminder>,
     cookies: &CookieJar<'_>,
     serenity_context: &State<Context>,
     pool: &State<Pool<MySql>>,
-) -> JsonResult {
+) -> JsonValue {
     check_authorization!(cookies, serenity_context.inner(), id);
 
     let user_id =
         cookies.get_private("userid").map(|c| c.value().parse::<u64>().ok()).flatten().unwrap();
 
-    create_reminder(
+    // validate channel
+    let channel = ChannelId(reminder.channel).to_channel_cached(&serenity_context.inner());
+    let channel_exists = channel.is_some();
+
+    let channel_matches_guild =
+        channel.map_or(false, |c| c.guild().map_or(false, |c| c.guild_id.0 == id));
+
+    if !channel_matches_guild || !channel_exists {
+        warn!(
+            "Error in `create_reminder`: channel {} not found for guild {} (channel exists: {})",
+            reminder.channel, id, channel_exists
+        );
+
+        return json!({"error": "Channel not found"});
+    }
+
+    let channel = create_database_channel(
         serenity_context.inner(),
+        ChannelId(reminder.channel),
         pool.inner(),
-        GuildId(id),
-        UserId(user_id),
-        reminder.into_inner(),
     )
+    .await;
+
+    if let Err(e) = channel {
+        warn!("`create_database_channel` returned an error code: {:?}", e);
+
+        return json!({"error": "Failed to configure channel for reminders. Please check the bot permissions"});
+    }
+
+    let channel = channel.unwrap();
+
+    // validate lengths
+    check_length!(MAX_CONTENT_LENGTH, reminder.content);
+    check_length!(MAX_EMBED_DESCRIPTION_LENGTH, reminder.embed_description);
+    check_length!(MAX_EMBED_TITLE_LENGTH, reminder.embed_title);
+    check_length!(MAX_EMBED_AUTHOR_LENGTH, reminder.embed_author);
+    check_length!(MAX_EMBED_FOOTER_LENGTH, reminder.embed_footer);
+    check_length_opt!(MAX_EMBED_FIELDS, reminder.embed_fields);
+    if let Some(fields) = &reminder.embed_fields {
+        for field in &fields.0 {
+            check_length!(MAX_EMBED_FIELD_VALUE_LENGTH, field.value);
+            check_length!(MAX_EMBED_FIELD_TITLE_LENGTH, field.title);
+        }
+    }
+    check_length_opt!(MAX_USERNAME_LENGTH, reminder.username);
+    check_length_opt!(
+        MAX_URL_LENGTH,
+        reminder.embed_footer_url,
+        reminder.embed_thumbnail_url,
+        reminder.embed_author_url,
+        reminder.embed_image_url,
+        reminder.avatar
+    );
+
+    // validate urls
+    check_url_opt!(
+        reminder.embed_footer_url,
+        reminder.embed_thumbnail_url,
+        reminder.embed_author_url,
+        reminder.embed_image_url,
+        reminder.avatar
+    );
+
+    // validate time and interval
+    if reminder.utc_time < Utc::now().naive_utc() {
+        return json!({"error": "Time must be in the future"});
+    }
+    if reminder.interval_seconds.is_some() || reminder.interval_months.is_some() {
+        if reminder.interval_months.unwrap_or(0) * 30 * DAY as u32
+            + reminder.interval_seconds.unwrap_or(0)
+            < *MIN_INTERVAL
+        {
+            return json!({"error": "Interval too short"});
+        }
+    }
+
+    // check patreon if necessary
+    if reminder.interval_seconds.is_some() || reminder.interval_months.is_some() {
+        if !check_guild_subscription(serenity_context.inner(), GuildId(id)).await
+            && !check_subscription(serenity_context.inner(), user_id).await
+        {
+            return json!({"error": "Patreon is required to set intervals"});
+        }
+    }
+
+    // base64 decode error dropped here
+    let attachment_data = reminder.attachment.as_ref().map(|s| base64::decode(s).ok()).flatten();
+    let name = if reminder.name.is_empty() { name_default() } else { reminder.name.clone() };
+
+    let new_uid = generate_uid();
+
+    // write to db
+    match sqlx::query!(
+        "INSERT INTO reminders (
+         uid,
+         attachment,
+         attachment_name,
+         channel_id,
+         avatar,
+         content,
+         embed_author,
+         embed_author_url,
+         embed_color,
+         embed_description,
+         embed_footer,
+         embed_footer_url,
+         embed_image_url,
+         embed_thumbnail_url,
+         embed_title,
+         embed_fields,
+         enabled,
+         expires,
+         interval_seconds,
+         interval_months,
+         name,
+         restartable,
+         tts,
+         username,
+         `utc_time`
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+        new_uid,
+        attachment_data,
+        reminder.attachment_name,
+        channel,
+        reminder.avatar,
+        reminder.content,
+        reminder.embed_author,
+        reminder.embed_author_url,
+        reminder.embed_color,
+        reminder.embed_description,
+        reminder.embed_footer,
+        reminder.embed_footer_url,
+        reminder.embed_image_url,
+        reminder.embed_thumbnail_url,
+        reminder.embed_title,
+        reminder.embed_fields,
+        reminder.enabled,
+        reminder.expires,
+        reminder.interval_seconds,
+        reminder.interval_months,
+        name,
+        reminder.restartable,
+        reminder.tts,
+        reminder.username,
+        reminder.utc_time,
+    )
+    .execute(pool.inner())
     .await
-}
-
-#[get("/api/guild/<id>/reminders?<status>")]
-pub async fn get_reminders(
-    id: u64,
-    cookies: &CookieJar<'_>,
-    serenity_context: &State<Context>,
-    pool: &State<Pool<MySql>>,
-    status: Option<String>,
-) -> JsonResult {
-    check_authorization!(cookies, serenity_context.inner(), id);
-
-    let status = status.unwrap_or("pending".to_string());
-
-    sqlx::query_as_unchecked!(
+    {
+        Ok(_) => sqlx::query_as_unchecked!(
             Reminder,
-        "
-        SELECT
+            "SELECT
              reminders.attachment,
              reminders.attachment_name,
              reminders.avatar,
@@ -348,35 +471,100 @@ pub async fn get_reminders(
              reminders.embed_image_url,
              reminders.embed_thumbnail_url,
              reminders.embed_title,
-         IFNULL(reminders.embed_fields, '[]') AS embed_fields,
+             reminders.embed_fields,
              reminders.enabled,
              reminders.expires,
              reminders.interval_seconds,
-         reminders.interval_days,
              reminders.interval_months,
              reminders.name,
              reminders.restartable,
              reminders.tts,
              reminders.uid,
              reminders.username,
-         reminders.utc_time,
-         reminders.status,
-         reminders.status_change_time,
-         reminders.status_message
+             reminders.utc_time
             FROM reminders
             LEFT JOIN channels ON channels.id = reminders.channel_id
-        WHERE FIND_IN_SET(`status`, ?) AND reminders.guild_id = (SELECT id FROM guilds WHERE guild = ?)",
-        status,
-        id
+            WHERE uid = ?",
+            new_uid
         )
-    .fetch_all(pool.inner())
+        .fetch_one(pool.inner())
         .await
-    .map(|r| Ok(json!(r)))
+        .map(|r| json!(r))
         .unwrap_or_else(|e| {
             warn!("Failed to complete SQL query: {:?}", e);
 
-        json_err!("Could not load reminders")
+            json!({"error": "Could not load reminder"})
+        }),
+
+        Err(e) => {
+            warn!("Error in `create_reminder`: Could not execute query: {:?}", e);
+
+            json!({"error": "Unknown error"})
+        }
+    }
+}
+
+#[get("/api/guild/<id>/reminders")]
+pub async fn get_reminders(id: u64, ctx: &State<Context>, pool: &State<Pool<MySql>>) -> JsonValue {
+    let channels_res = GuildId(id).channels(&ctx.inner()).await;
+
+    match channels_res {
+        Ok(channels) => {
+            let channels = channels
+                .keys()
+                .into_iter()
+                .map(|k| k.as_u64().to_string())
+                .collect::<Vec<String>>()
+                .join(",");
+
+            sqlx::query_as_unchecked!(
+                Reminder,
+                "SELECT
+                 reminders.attachment,
+                 reminders.attachment_name,
+                 reminders.avatar,
+                 channels.channel,
+                 reminders.content,
+                 reminders.embed_author,
+                 reminders.embed_author_url,
+                 reminders.embed_color,
+                 reminders.embed_description,
+                 reminders.embed_footer,
+                 reminders.embed_footer_url,
+                 reminders.embed_image_url,
+                 reminders.embed_thumbnail_url,
+                 reminders.embed_title,
+                 reminders.embed_fields,
+                 reminders.enabled,
+                 reminders.expires,
+                 reminders.interval_seconds,
+                 reminders.interval_months,
+                 reminders.name,
+                 reminders.restartable,
+                 reminders.tts,
+                 reminders.uid,
+                 reminders.username,
+                 reminders.utc_time
+                FROM reminders
+                LEFT JOIN channels ON channels.id = reminders.channel_id
+                WHERE FIND_IN_SET(channels.channel, ?)",
+                channels
+            )
+            .fetch_all(pool.inner())
+            .await
+            .map(|r| json!(r))
+            .unwrap_or_else(|e| {
+                warn!("Failed to complete SQL query: {:?}", e);
+
+                json!({"error": "Could not load reminders"})
             })
+        }
+        Err(e) => {
+            warn!("Could not fetch channels from {}: {:?}", id, e);
+
+            json!([])
+        }
+    }
 }
 
 #[patch("/api/guild/<id>/reminders", data = "<reminder>")]
@@ -385,109 +573,35 @@ pub async fn edit_reminder(
     reminder: Json<PatchReminder>,
     serenity_context: &State<Context>,
     pool: &State<Pool<MySql>>,
-    cookies: &CookieJar<'_>,
-) -> JsonResult {
-    check_authorization!(cookies, serenity_context.inner(), id);
-
+) -> JsonValue {
     let mut error = vec![];
 
-    let user_id =
-        cookies.get_private("userid").map(|c| c.value().parse::<u64>().ok()).flatten().unwrap();
-
-    if reminder.message_ok() {
-        update_field!(pool.inner(), error, reminder.[
-            content,
-            embed_author,
-            embed_description,
-            embed_footer,
-            embed_title,
-            embed_fields,
-            username
-        ]);
-    } else {
-        error.push("Message exceeds limits.".to_string());
-    }
-
     update_field!(pool.inner(), error, reminder.[
         attachment,
         attachment_name,
         avatar,
+        content,
+        embed_author,
         embed_author_url,
         embed_color,
+        embed_description,
+        embed_footer,
         embed_footer_url,
         embed_image_url,
         embed_thumbnail_url,
+        embed_title,
+        embed_fields,
         enabled,
         expires,
+        interval_seconds,
+        interval_months,
         name,
         restartable,
         tts,
+        username,
         utc_time
     ]);
 
-    if reminder.interval_days.flatten().is_some()
-        || reminder.interval_months.flatten().is_some()
-        || reminder.interval_seconds.flatten().is_some()
-    {
-        if check_guild_subscription(&serenity_context.inner(), id).await
-            || check_subscription(&serenity_context.inner(), user_id).await
-        {
-            let new_interval_length = match reminder.interval_days {
-                Some(interval) => interval.unwrap_or(0),
-                None => sqlx::query!(
-                    "SELECT interval_days AS days FROM reminders WHERE uid = ?",
-                    reminder.uid
-                )
-                .fetch_one(pool.inner())
-                .await
-                .map_err(|e| {
-                    warn!("Error updating reminder interval: {:?}", e);
-                    json!({ "reminder": Option::<Reminder>::None, "errors": vec!["Unknown error"] })
-                })?
-                .days
-                .unwrap_or(0),
-            } * 86400 + match reminder.interval_months {
-                Some(interval) => interval.unwrap_or(0),
-                None => sqlx::query!(
-                    "SELECT interval_months AS months FROM reminders WHERE uid = ?",
-                    reminder.uid
-                )
-                .fetch_one(pool.inner())
-                .await
-                .map_err(|e| {
-                    warn!("Error updating reminder interval: {:?}", e);
-                    json!({ "reminder": Option::<Reminder>::None, "errors": vec!["Unknown error"] })
-                })?
-                .months
-                .unwrap_or(0),
-            } * 2592000 + match reminder.interval_seconds {
-                Some(interval) => interval.unwrap_or(0),
-                None => sqlx::query!(
-                    "SELECT interval_seconds AS seconds FROM reminders WHERE uid = ?",
-                    reminder.uid
-                )
-                .fetch_one(pool.inner())
-                .await
-                .map_err(|e| {
-                    warn!("Error updating reminder interval: {:?}", e);
-                    json!({ "reminder": Option::<Reminder>::None, "errors": vec!["Unknown error"] })
-                })?
-                .seconds
-                .unwrap_or(0),
-            };
-
-            if new_interval_length < *MIN_INTERVAL {
-                error.push(String::from("New interval is too short."));
-            } else {
-                update_field!(pool.inner(), error, reminder.[
-                    interval_days,
-                    interval_months,
-                    interval_seconds
-                ]);
-            }
-        }
-    }
-
     if reminder.channel > 0 {
         let channel = ChannelId(reminder.channel).to_channel_cached(&serenity_context.inner());
         match channel {
@@ -500,7 +614,7 @@ pub async fn edit_reminder(
                         reminder.channel, id
                     );
 
-                    return Err(json!({"error": "Channel not found"}));
+                    return json!({"error": "Channel not found"});
                 }
 
                 let channel = create_database_channel(
@@ -513,9 +627,7 @@ pub async fn edit_reminder(
                 if let Err(e) = channel {
                     warn!("`create_database_channel` returned an error code: {:?}", e);
 
-                    return Err(
-                        json!({"error": "Failed to configure channel for reminders. Please check the bot permissions"}),
-                    );
+                    return json!({"error": "Failed to configure channel for reminders. Please check the bot permissions"});
                 }
 
                 let channel = channel.unwrap();
@@ -543,15 +655,14 @@ pub async fn edit_reminder(
                     reminder.channel, id
                 );
 
-                return Err(json!({"error": "Channel not found"}));
+                return json!({"error": "Channel not found"});
             }
         }
     }
 
     match sqlx::query_as_unchecked!(
         Reminder,
-        "
-        SELECT reminders.attachment,
+        "SELECT reminders.attachment,
          reminders.attachment_name,
          reminders.avatar,
          channels.channel,
@@ -569,17 +680,13 @@ pub async fn edit_reminder(
          reminders.enabled,
          reminders.expires,
          reminders.interval_seconds,
-         reminders.interval_days,
          reminders.interval_months,
          reminders.name,
          reminders.restartable,
          reminders.tts,
          reminders.uid,
          reminders.username,
-         reminders.utc_time,
-         reminders.status,
-         reminders.status_change_time,
-         reminders.status_message
+         reminders.utc_time
         FROM reminders
         LEFT JOIN channels ON channels.id = reminders.channel_id
         WHERE uid = ?",
@@ -588,12 +695,12 @@ pub async fn edit_reminder(
     .fetch_one(pool.inner())
     .await
     {
-        Ok(reminder) => Ok(json!({"reminder": reminder, "errors": error})),
+        Ok(reminder) => json!({"reminder": reminder, "errors": error}),
 
         Err(e) => {
             warn!("Error exiting `edit_reminder': {:?}", e);
 
-            Err(json!({"reminder": Option::<Reminder>::None, "errors": vec!["Unknown error"]}))
+            json!({"reminder": Option::<Reminder>::None, "errors": vec!["Unknown error"]})
         }
     }
 }
@@ -602,20 +709,19 @@ pub async fn edit_reminder(
 pub async fn delete_reminder(
     reminder: Json<DeleteReminder>,
     pool: &State<Pool<MySql>>,
-) -> JsonResult {
-    match sqlx::query!(
-        "UPDATE reminders SET `status` = 'deleted', `status_change_time` = NOW() WHERE uid = ?",
-        reminder.uid
-    )
+) -> JsonValue {
+    match sqlx::query!("DELETE FROM reminders WHERE uid = ?", reminder.uid)
         .execute(pool.inner())
         .await
     {
-        Ok(_) => Ok(json!({})),
+        Ok(_) => {
+            json!({})
+        }
 
         Err(e) => {
             warn!("Error in `delete_reminder`: {:?}", e);
 
-            Err(json!({"error": "Could not delete reminder"}))
+            json!({"error": "Could not delete reminder"})
         }
     }
 }

web/src/routes/dashboard/mod.rs

@@ -1,30 +1,18 @@
 use std::collections::HashMap;
 
-use chrono::{naive::NaiveDateTime, Utc};
+use chrono::naive::NaiveDateTime;
 use rand::{rngs::OsRng, seq::IteratorRandom};
-use rocket::{http::CookieJar, response::Redirect, serde::json::json};
+use rocket::{http::CookieJar, response::Redirect};
 use rocket_dyn_templates::Template;
-use serde::{Deserialize, Deserializer, Serialize};
-use serenity::{
-    client::Context,
-    http::Http,
-    model::id::{ChannelId, GuildId, UserId},
-};
+use serde::{Deserialize, Serialize};
+use serenity::{http::Http, model::id::ChannelId};
 use sqlx::{types::Json, Executor};
 
 use crate::{
-    check_guild_subscription, check_subscription,
-    consts::{
-        CHARACTERS, DAY, DEFAULT_AVATAR, MAX_CONTENT_LENGTH, MAX_EMBED_AUTHOR_LENGTH,
-        MAX_EMBED_DESCRIPTION_LENGTH, MAX_EMBED_FIELDS, MAX_EMBED_FIELD_TITLE_LENGTH,
-        MAX_EMBED_FIELD_VALUE_LENGTH, MAX_EMBED_FOOTER_LENGTH, MAX_EMBED_TITLE_LENGTH,
-        MAX_NAME_LENGTH, MAX_URL_LENGTH, MAX_USERNAME_LENGTH, MIN_INTERVAL,
-    },
-    routes::JsonResult,
+    consts::{CHARACTERS, DEFAULT_AVATAR},
     Database, Error,
 };
 
-pub mod export;
 pub mod guild;
 pub mod user;
 
@@ -46,18 +34,6 @@ fn id_default() -> u32 {
     0
 }
 
-fn interval_default() -> Unset<Option<u32>> {
-    None
-}
-
-fn deserialize_optional_field<'de, T, D>(deserializer: D) -> Result<Option<Option<T>>, D::Error>
-where
-    D: Deserializer<'de>,
-    T: Deserialize<'de>,
-{
-    Ok(Some(Option::deserialize(deserializer)?))
-}
-
 #[derive(Serialize, Deserialize)]
 pub struct ReminderTemplate {
     #[serde(default = "id_default")]
@@ -84,28 +60,6 @@ pub struct ReminderTemplate {
     username: Option<String>,
 }
 
-#[derive(Serialize, Deserialize)]
-pub struct ReminderTemplateCsv {
-    #[serde(default = "template_name_default")]
-    name: String,
-    attachment: Option<Vec<u8>>,
-    attachment_name: Option<String>,
-    avatar: Option<String>,
-    content: String,
-    embed_author: String,
-    embed_author_url: Option<String>,
-    embed_color: u32,
-    embed_description: String,
-    embed_footer: String,
-    embed_footer_url: Option<String>,
-    embed_image_url: Option<String>,
-    embed_thumbnail_url: Option<String>,
-    embed_title: String,
-    embed_fields: Option<String>,
-    tts: bool,
-    username: Option<String>,
-}
-
 #[derive(Deserialize)]
 pub struct DeleteReminderTemplate {
     id: u32,
@@ -118,8 +72,8 @@ pub struct EmbedField {
     inline: bool,
 }
 
-#[derive(Deserialize)]
-pub struct ReminderCreate {
+#[derive(Serialize, Deserialize)]
+pub struct Reminder {
     #[serde(with = "base64s")]
     attachment: Option<Vec<u8>>,
     attachment_name: Option<String>,
@@ -140,39 +94,6 @@ pub struct ReminderCreate {
     enabled: bool,
     expires: Option<NaiveDateTime>,
     interval_seconds: Option<u32>,
-    interval_days: Option<u32>,
-    interval_months: Option<u32>,
-    #[serde(default = "name_default")]
-    name: String,
-    restartable: bool,
-    tts: bool,
-    username: Option<String>,
-    utc_time: NaiveDateTime,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Reminder {
-    #[serde(with = "base64s")]
-    attachment: Option<Vec<u8>>,
-    attachment_name: Option<String>,
-    avatar: Option<String>,
-    #[serde(with = "string_opt")]
-    channel: Option<u64>,
-    content: String,
-    embed_author: String,
-    embed_author_url: Option<String>,
-    embed_color: u32,
-    embed_description: String,
-    embed_footer: String,
-    embed_footer_url: Option<String>,
-    embed_image_url: Option<String>,
-    embed_thumbnail_url: Option<String>,
-    embed_title: String,
-    embed_fields: Option<Json<Vec<EmbedField>>>,
-    enabled: bool,
-    expires: Option<NaiveDateTime>,
-    interval_seconds: Option<u32>,
-    interval_days: Option<u32>,
     interval_months: Option<u32>,
     #[serde(default = "name_default")]
     name: String,
@@ -182,53 +103,16 @@ pub struct Reminder {
     uid: String,
     username: Option<String>,
     utc_time: NaiveDateTime,
-    status: String,
-    status_message: Option<String>,
-    status_change_time: Option<NaiveDateTime>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct ReminderCsv {
-    #[serde(with = "base64s")]
-    attachment: Option<Vec<u8>>,
-    attachment_name: Option<String>,
-    avatar: Option<String>,
-    channel: String,
-    content: String,
-    embed_author: String,
-    embed_author_url: Option<String>,
-    embed_color: u32,
-    embed_description: String,
-    embed_footer: String,
-    embed_footer_url: Option<String>,
-    embed_image_url: Option<String>,
-    embed_thumbnail_url: Option<String>,
-    embed_title: String,
-    embed_fields: Option<String>,
-    enabled: bool,
-    expires: Option<NaiveDateTime>,
-    interval_seconds: Option<u32>,
-    interval_days: Option<u32>,
-    interval_months: Option<u32>,
-    #[serde(default = "name_default")]
-    name: String,
-    restartable: bool,
-    tts: bool,
-    username: Option<String>,
-    utc_time: NaiveDateTime,
 }
 
 #[derive(Deserialize)]
 pub struct PatchReminder {
     uid: String,
     #[serde(default)]
-    #[serde(deserialize_with = "deserialize_optional_field")]
     attachment: Unset<Option<String>>,
     #[serde(default)]
-    #[serde(deserialize_with = "deserialize_optional_field")]
     attachment_name: Unset<Option<String>>,
     #[serde(default)]
-    #[serde(deserialize_with = "deserialize_optional_field")]
     avatar: Unset<Option<String>>,
     #[serde(default = "channel_default")]
     #[serde(with = "string")]
@@ -238,7 +122,6 @@ pub struct PatchReminder {
     #[serde(default)]
     embed_author: Unset<String>,
     #[serde(default)]
-    #[serde(deserialize_with = "deserialize_optional_field")]
     embed_author_url: Unset<Option<String>>,
     #[serde(default)]
     embed_color: Unset<u32>,
@@ -247,13 +130,10 @@ pub struct PatchReminder {
     #[serde(default)]
     embed_footer: Unset<String>,
     #[serde(default)]
-    #[serde(deserialize_with = "deserialize_optional_field")]
     embed_footer_url: Unset<Option<String>>,
     #[serde(default)]
-    #[serde(deserialize_with = "deserialize_optional_field")]
     embed_image_url: Unset<Option<String>>,
     #[serde(default)]
-    #[serde(deserialize_with = "deserialize_optional_field")]
     embed_thumbnail_url: Unset<Option<String>>,
     #[serde(default)]
     embed_title: Unset<String>,
@@ -262,16 +142,10 @@ pub struct PatchReminder {
     #[serde(default)]
     enabled: Unset<bool>,
     #[serde(default)]
-    #[serde(deserialize_with = "deserialize_optional_field")]
     expires: Unset<Option<NaiveDateTime>>,
-    #[serde(default = "interval_default")]
-    #[serde(deserialize_with = "deserialize_optional_field")]
+    #[serde(default)]
     interval_seconds: Unset<Option<u32>>,
-    #[serde(default = "interval_default")]
-    #[serde(deserialize_with = "deserialize_optional_field")]
-    interval_days: Unset<Option<u32>>,
-    #[serde(default = "interval_default")]
-    #[serde(deserialize_with = "deserialize_optional_field")]
+    #[serde(default)]
     interval_months: Unset<Option<u32>>,
     #[serde(default)]
     name: Unset<String>,
@@ -280,36 +154,11 @@ pub struct PatchReminder {
     #[serde(default)]
     tts: Unset<bool>,
     #[serde(default)]
-    #[serde(deserialize_with = "deserialize_optional_field")]
     username: Unset<Option<String>>,
     #[serde(default)]
     utc_time: Unset<NaiveDateTime>,
 }
 
-impl PatchReminder {
-    fn message_ok(&self) -> bool {
-        self.content.as_ref().map_or(true, |c| c.len() <= MAX_CONTENT_LENGTH)
-            && self.embed_author.as_ref().map_or(true, |c| c.len() <= MAX_EMBED_AUTHOR_LENGTH)
-            && self
-                .embed_description
-                .as_ref()
-                .map_or(true, |c| c.len() <= MAX_EMBED_DESCRIPTION_LENGTH)
-            && self.embed_footer.as_ref().map_or(true, |c| c.len() <= MAX_EMBED_FOOTER_LENGTH)
-            && self.embed_title.as_ref().map_or(true, |c| c.len() <= MAX_EMBED_TITLE_LENGTH)
-            && self.embed_fields.as_ref().map_or(true, |c| {
-                c.0.len() <= MAX_EMBED_FIELDS
-                    && c.0.iter().all(|f| {
-                        f.title.len() <= MAX_EMBED_FIELD_TITLE_LENGTH
-                            && f.value.len() <= MAX_EMBED_FIELD_VALUE_LENGTH
-                    })
-            })
-            && self
-                .username
-                .as_ref()
-                .map_or(true, |c| c.as_ref().map_or(true, |v| v.len() <= MAX_USERNAME_LENGTH))
-    }
-}
-
 pub fn generate_uid() -> String {
     let mut generator: OsRng = Default::default();
 
@@ -323,7 +172,15 @@ pub fn generate_uid() -> String {
 mod string {
     use std::{fmt::Display, str::FromStr};
 
-    use serde::{de, Deserialize, Deserializer};
+    use serde::{de, Deserialize, Deserializer, Serializer};
+
+    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        T: Display,
+        S: Serializer,
+    {
+        serializer.collect_str(value)
+    }
 
     pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
     where
@@ -335,34 +192,6 @@ mod string {
     }
 }
 
-mod string_opt {
-    use std::{fmt::Display, str::FromStr};
-
-    use serde::{de, Deserialize, Deserializer, Serializer};
-
-    pub fn serialize<T, S>(value: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        T: Display,
-        S: Serializer,
-    {
-        match value {
-            Some(value) => serializer.collect_str(value),
-            None => serializer.serialize_none(),
-        }
-    }
-
-    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
-    where
-        T: FromStr,
-        T::Err: Display,
-        D: Deserializer<'de>,
-    {
-        Option::deserialize(deserializer)?
-            .map(|d: String| d.parse().map_err(de::Error::custom))
-            .transpose()
-    }
-}
-
 mod base64s {
     use serde::{de, Deserialize, Deserializer, Serializer};
 
@@ -391,266 +220,13 @@ pub struct DeleteReminder {
     uid: String,
 }
 
-#[derive(Deserialize)]
-pub struct ImportBody {
-    body: String,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct TodoCsv {
-    value: String,
-    channel_id: Option<String>,
-}
-
-pub async fn create_reminder(
-    ctx: &Context,
-    pool: impl sqlx::Executor<'_, Database = Database> + Copy,
-    guild_id: GuildId,
-    user_id: UserId,
-    reminder: ReminderCreate,
-) -> JsonResult {
-    // check guild in db
-    match sqlx::query!("SELECT 1 as A FROM guilds WHERE guild = ?", guild_id.0)
-        .fetch_one(pool)
-        .await
-    {
-        Err(sqlx::Error::RowNotFound) => {
-            if sqlx::query!("INSERT INTO guilds (guild) VALUES (?)", guild_id.0)
-                .execute(pool)
-                .await
-                .is_err()
-            {
-                return Err(json!({"error": "Guild could not be created"}));
-            }
-        }
-        _ => {}
-    }
-
-    // validate channel
-    let channel = ChannelId(reminder.channel).to_channel_cached(&ctx);
-    let channel_exists = channel.is_some();
-
-    let channel_matches_guild =
-        channel.map_or(false, |c| c.guild().map_or(false, |c| c.guild_id == guild_id));
-
-    if !channel_matches_guild || !channel_exists {
-        warn!(
-            "Error in `create_reminder`: channel {:?} not found for guild {} (channel exists: {})",
-            reminder.channel, guild_id, channel_exists
-        );
-
-        return Err(json!({"error": "Channel not found"}));
-    }
-
-    let channel = create_database_channel(&ctx, ChannelId(reminder.channel), pool).await;
-
-    if let Err(e) = channel {
-        warn!("`create_database_channel` returned an error code: {:?}", e);
-
-        return Err(
-            json!({"error": "Failed to configure channel for reminders. Please check the bot permissions"}),
-        );
-    }
-
-    let channel = channel.unwrap();
-
-    // validate lengths
-    check_length!(MAX_NAME_LENGTH, reminder.name);
-    check_length!(MAX_CONTENT_LENGTH, reminder.content);
-    check_length!(MAX_EMBED_DESCRIPTION_LENGTH, reminder.embed_description);
-    check_length!(MAX_EMBED_TITLE_LENGTH, reminder.embed_title);
-    check_length!(MAX_EMBED_AUTHOR_LENGTH, reminder.embed_author);
-    check_length!(MAX_EMBED_FOOTER_LENGTH, reminder.embed_footer);
-    check_length_opt!(MAX_EMBED_FIELDS, reminder.embed_fields);
-    if let Some(fields) = &reminder.embed_fields {
-        for field in &fields.0 {
-            check_length!(MAX_EMBED_FIELD_VALUE_LENGTH, field.value);
-            check_length!(MAX_EMBED_FIELD_TITLE_LENGTH, field.title);
-        }
-    }
-    check_length_opt!(MAX_USERNAME_LENGTH, reminder.username);
-    check_length_opt!(
-        MAX_URL_LENGTH,
-        reminder.embed_footer_url,
-        reminder.embed_thumbnail_url,
-        reminder.embed_author_url,
-        reminder.embed_image_url,
-        reminder.avatar
-    );
-
-    // validate urls
-    check_url_opt!(
-        reminder.embed_footer_url,
-        reminder.embed_thumbnail_url,
-        reminder.embed_author_url,
-        reminder.embed_image_url,
-        reminder.avatar
-    );
-
-    // validate time and interval
-    if reminder.utc_time < Utc::now().naive_utc() {
-        return Err(json!({"error": "Time must be in the future"}));
-    }
-    if reminder.interval_seconds.is_some()
-        || reminder.interval_days.is_some()
-        || reminder.interval_months.is_some()
-    {
-        if reminder.interval_months.unwrap_or(0) * 30 * DAY as u32
-            + reminder.interval_days.unwrap_or(0) * DAY as u32
-            + reminder.interval_seconds.unwrap_or(0)
-            < *MIN_INTERVAL
-        {
-            return Err(json!({"error": "Interval too short"}));
-        }
-    }
-
-    // check patreon if necessary
-    if reminder.interval_seconds.is_some()
-        || reminder.interval_days.is_some()
-        || reminder.interval_months.is_some()
-    {
-        if !check_guild_subscription(&ctx, guild_id).await
-            && !check_subscription(&ctx, user_id).await
-        {
-            return Err(json!({"error": "Patreon is required to set intervals"}));
-        }
-    }
-
-    // base64 decode error dropped here
-    let attachment_data = reminder.attachment.as_ref().map(|s| base64::decode(s).ok()).flatten();
-    let name = if reminder.name.is_empty() { name_default() } else { reminder.name.clone() };
-    let username = if reminder.username.as_ref().map(|s| s.is_empty()).unwrap_or(true) {
-        None
-    } else {
-        reminder.username
-    };
-
-    let new_uid = generate_uid();
-
-    // write to db
-    match sqlx::query!(
-        "
-        INSERT INTO reminders (
-         uid,
-         attachment,
-         attachment_name,
-         channel_id,
-         guild_id,
-         avatar,
-         content,
-         embed_author,
-         embed_author_url,
-         embed_color,
-         embed_description,
-         embed_footer,
-         embed_footer_url,
-         embed_image_url,
-         embed_thumbnail_url,
-         embed_title,
-         embed_fields,
-         enabled,
-         expires,
-         interval_seconds,
-         interval_days,
-         interval_months,
-         name,
-         restartable,
-         tts,
-         username,
-         `utc_time`
-        ) VALUES (?, ?, ?, ?,
-        (SELECT id FROM guilds WHERE guild = ?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
-        ?, ?, ?, ?, ?)",
-        new_uid,
-        attachment_data,
-        reminder.attachment_name,
-        channel,
-        guild_id.0,
-        reminder.avatar,
-        reminder.content,
-        reminder.embed_author,
-        reminder.embed_author_url,
-        reminder.embed_color,
-        reminder.embed_description,
-        reminder.embed_footer,
-        reminder.embed_footer_url,
-        reminder.embed_image_url,
-        reminder.embed_thumbnail_url,
-        reminder.embed_title,
-        reminder.embed_fields,
-        reminder.enabled,
-        reminder.expires,
-        reminder.interval_seconds,
-        reminder.interval_days,
-        reminder.interval_months,
-        name,
-        reminder.restartable,
-        reminder.tts,
-        username,
-        reminder.utc_time,
-    )
-    .execute(pool)
-    .await
-    {
-        Ok(_) => sqlx::query_as_unchecked!(
-            Reminder,
-            "SELECT
-             reminders.attachment,
-             reminders.attachment_name,
-             reminders.avatar,
-             channels.channel,
-             reminders.content,
-             reminders.embed_author,
-             reminders.embed_author_url,
-             reminders.embed_color,
-             reminders.embed_description,
-             reminders.embed_footer,
-             reminders.embed_footer_url,
-             reminders.embed_image_url,
-             reminders.embed_thumbnail_url,
-             reminders.embed_title,
-             reminders.embed_fields,
-             reminders.enabled,
-             reminders.expires,
-             reminders.interval_seconds,
-             reminders.interval_days,
-             reminders.interval_months,
-             reminders.name,
-             reminders.restartable,
-             reminders.tts,
-             reminders.uid,
-             reminders.username,
-             reminders.utc_time,
-             reminders.status,
-             reminders.status_change_time,
-             reminders.status_message
-            FROM reminders
-            LEFT JOIN channels ON channels.id = reminders.channel_id
-            WHERE uid = ?",
-            new_uid
-        )
-        .fetch_one(pool)
-        .await
-        .map(|r| Ok(json!(r)))
-        .unwrap_or_else(|e| {
-            warn!("Failed to complete SQL query: {:?}", e);
-
-            Err(json!({"error": "Could not load reminder"}))
-        }),
-
-        Err(e) => {
-            warn!("Error in `create_reminder`: Could not execute query: {:?}", e);
-
-            Err(json!({"error": "Unknown error"}))
-        }
-    }
-}
-
 async fn create_database_channel(
     ctx: impl AsRef<Http>,
     channel: ChannelId,
     pool: impl Executor<'_, Database = Database> + Copy,
 ) -> Result<u32, crate::Error> {
+    println!("{:?}", channel);
+
     let row =
         sqlx::query!("SELECT webhook_token, webhook_id FROM channels WHERE channel = ?", channel.0)
             .fetch_one(pool)
@@ -725,17 +301,7 @@ pub async fn dashboard_home(cookies: &CookieJar<'_>) -> Result<Template, Redirec
 }
 
 #[get("/<_>")]
-pub async fn dashboard_1(cookies: &CookieJar<'_>) -> Result<Template, Redirect> {
-    if cookies.get_private("userid").is_some() {
-        let map: HashMap<&str, String> = HashMap::new();
-        Ok(Template::render("dashboard", &map))
-    } else {
-        Err(Redirect::to("/login/discord"))
-    }
-}
-
-#[get("/<_>/<_>")]
-pub async fn dashboard_2(cookies: &CookieJar<'_>) -> Result<Template, Redirect> {
+pub async fn dashboard(cookies: &CookieJar<'_>) -> Result<Template, Redirect> {
     if cookies.get_private("userid").is_some() {
         let map: HashMap<&str, String> = HashMap::new();
         Ok(Template::render("dashboard", &map))

web/src/routes/dashboard/user.rs

@@ -54,8 +54,6 @@ pub async fn get_user_info(
     ctx: &State<Context>,
     pool: &State<Pool<MySql>>,
 ) -> JsonValue {
-    offline!(json!(UserInfo { name: "Discord".to_string(), patreon: true, timezone: None }));
-
     if let Some(user_id) =
         cookies.get_private("userid").map(|u| u.value().parse::<u64>().ok()).flatten()
     {
@@ -63,10 +61,7 @@ pub async fn get_user_info(
             .member(&ctx.inner(), user_id)
             .await;
 
-        let timezone = sqlx::query!(
-            "SELECT IFNULL(timezone, 'UTC') AS timezone FROM users WHERE user = ?",
-            user_id
-        )
+        let timezone = sqlx::query!("SELECT timezone FROM users WHERE user = ?", user_id)
             .fetch_one(pool.inner())
             .await
             .map_or(None, |q| Some(q.timezone));
@@ -118,8 +113,6 @@ pub async fn update_user_info(
 
 #[get("/api/user/guilds")]
 pub async fn get_user_guilds(cookies: &CookieJar<'_>, reqwest_client: &State<Client>) -> JsonValue {
-    offline!(json!(vec![GuildInfo { id: "1".to_string(), name: "Guild".to_string() }]));
-
     if let Some(access_token) = cookies.get_private("access_token") {
         let request_res = reqwest_client
             .get(format!("{}/users/@me/guilds", DISCORD_API))

web/src/routes/login.rs

@@ -11,7 +11,7 @@ use rocket::{
 };
 use serenity::model::user::User;
 
-use crate::{consts::DISCORD_API, routes};
+use crate::consts::DISCORD_API;
 
 #[get("/discord")]
 pub async fn discord_login(
@@ -25,6 +25,7 @@ pub async fn discord_login(
         // Set the desired scopes.
         .add_scope(Scope::new("identify".to_string()))
         .add_scope(Scope::new("guilds".to_string()))
+        .add_scope(Scope::new("email".to_string()))
         // Set the PKCE code challenge.
         .set_pkce_challenge(pkce_challenge)
         .url();
@@ -52,15 +53,6 @@ pub async fn discord_login(
     Redirect::to(auth_url.to_string())
 }
 
-#[get("/discord/logout")]
-pub async fn discord_logout(cookies: &CookieJar<'_>) -> Redirect {
-    cookies.remove_private(Cookie::named("username"));
-    cookies.remove_private(Cookie::named("userid"));
-    cookies.remove_private(Cookie::named("access_token"));
-
-    Redirect::to(uri!(routes::index))
-}
-
 #[get("/discord/authorized?<code>&<state>")]
 pub async fn discord_callback(
     code: &str,
@@ -144,14 +136,14 @@ pub async fn discord_callback(
                     Err(Flash::new(
                         Redirect::to(uri!(super::return_to_same_site(""))),
                         "warning",
-                        "Your login request was rejected. The server may be misconfigured. Please retry or alert us in Discord.",
+                        "Your login request was rejected",
                     ))
                 }
             }
         } else {
-            Err(Flash::new(Redirect::to(uri!(super::return_to_same_site(""))), "danger", "Your request failed to validate, and so has been rejected (CSRF Validation Failure)"))
+            Err(Flash::new(Redirect::to(uri!(super::return_to_same_site(""))), "danger", "Your request failed to validate, and so has been rejected (error: CSRF Validation Failure)"))
         }
     } else {
-        Err(Flash::new(Redirect::to(uri!(super::return_to_same_site(""))), "warning", "Your request was missing information, and so has been rejected (CSRF Validation Tokens Missing)"))
+        Err(Flash::new(Redirect::to(uri!(super::return_to_same_site(""))), "warning", "Your request was missing information, and so has been rejected (error: CSRF Validation Tokens Missing)"))
     }
 }

web/src/routes/mod.rs

@@ -1,15 +1,11 @@
-pub mod admin;
 pub mod dashboard;
 pub mod login;
-pub mod report;
 
 use std::collections::HashMap;
 
-use rocket::{request::FlashMessage, serde::json::Value as JsonValue};
+use rocket::request::FlashMessage;
 use rocket_dyn_templates::Template;
 
-pub type JsonResult = Result<JsonValue, JsonValue>;
-
 #[get("/")]
 pub async fn index(flash: Option<FlashMessage<'_>>) -> Template {
     let mut map: HashMap<&str, String> = HashMap::new();

web/src/routes/report.rs

@@ -1,48 +0,0 @@
-use rocket::{
-    http::CookieJar,
-    serde::{
-        json::{json, Json},
-        Deserialize,
-    },
-};
-
-use crate::routes::JsonResult;
-
-#[derive(Deserialize)]
-pub struct ClientError {
-    #[serde(rename = "reporterId")]
-    reporter_id: String,
-    url: String,
-    #[serde(rename = "relativeTimestamp")]
-    relative_timestamp: i64,
-    #[serde(rename = "errorMessage")]
-    error_message: String,
-    #[serde(rename = "errorLine")]
-    error_line: u64,
-    #[serde(rename = "errorFile")]
-    error_file: String,
-    #[serde(rename = "errorType")]
-    error_type: String,
-}
-
-#[post("/report", data = "<client_error>")]
-pub async fn report_error(cookies: &CookieJar<'_>, client_error: Json<ClientError>) -> JsonResult {
-    if let Some(user_id) = cookies.get_private("userid") {
-        error!(
-            "User {} reports a client-side error.
-{}, {}:{} at {}ms
-{}: {}
-Chain: {}",
-            user_id,
-            client_error.url,
-            client_error.error_file,
-            client_error.error_line,
-            client_error.relative_timestamp,
-            client_error.error_type,
-            client_error.error_message,
-            client_error.reporter_id
-        );
-    }
-
-    Ok(json!({}))
-}

web/static/css/style.css

@@ -11,22 +11,10 @@ div.reminderContent.is-collapsed .column.discord-frame {
     display: none;
 }
 
-div.reminderContent.is-collapsed .column.settings {
+div.reminderContent.is-collapsed .collapses {
     display: none;
 }
 
-div.reminderContent.is-collapsed .button-row {
-    display: none;
-}
-
-div.reminderContent.is-collapsed .button-row-edit {
-    display: none;
-}
-
-div.reminderContent.is-collapsed .reminder-topbar {
-    padding-bottom: 0;
-}
-
 div.reminderContent.is-collapsed .invert-collapses {
     display: inline-flex;
 }
@@ -35,42 +23,42 @@ div.reminderContent .invert-collapses {
     display: none;
 }
 
+div.reminderContent.is-collapsed .settings {
+    display: flex;
+    flex-direction: row;
+    padding-bottom: 0;
+}
+
+div.reminderContent.is-collapsed .channel-field {
+    display: inline-flex;
+    order: 1;
+}
+
+div.reminderContent.is-collapsed .reminder-topbar {
+    display: inline-flex;
+    margin-bottom: 0px;
+    flex-grow: 1;
+    order: 2;
+}
+
 div.reminderContent.is-collapsed input[name="name"] {
     display: inline-flex;
     flex-grow: 1;
     border: none;
+    font-weight: 700;
     background: none;
-    box-shadow: none;
-    opacity: 1;
 }
 
-div.reminderContent.is-collapsed .hide-box {
+div.reminderContent.is-collapsed button.hide-box {
     display: inline-flex;
 }
 
-div.reminderContent.is-collapsed .hide-box i {
+div.reminderContent.is-collapsed button.hide-box i {
     transform: rotate(90deg);
 }
 /* END */
 
 /* dashboard styles */
-.hide-box {
-    border: none;
-    background: none;
-}
-
-.hide-box:focus {
-    outline: none;
-    box-shadow: none !important;
-}
-
-.channel-bar {
-    display: flex;
-    justify-content: center;
-    flex-direction: column;
-    font-weight: bold;
-}
-
 button.inline-btn {
     height: 100%;
     padding: 5px;
@@ -97,86 +85,18 @@ div.discord-embed {
     position: relative;
 }
 
-div.split-controls {
-    display: flex;
-    flex-direction: column;
-    justify-content: space-between;
-    flex-grow: 2;
-}
-
-.reminder-topbar > div {
-    padding-left: 6px;
-    padding-right: 6px;
-}
-
-.settings {
-    display: flex;
-    flex-direction: column;
-}
-
-.name-bar {
-    flex-grow: 1;
-    flex-shrink: 1;
-}
-
-.hide-button-bar {
-    flex-grow: 0;
-    flex-shrink: 0;
-}
-
-.patreon-only {
-    padding-bottom: 16px;
-}
-
-.tts-row {
-    padding-bottom: 10px;
-}
-
-.reminder-topbar {
-    display: flex;
-    margin-bottom: 0 !important;
-}
-
-.reminder-settings {
-    margin-top: 0 !important;
-}
-
-.reminder-settings > .column {
-    flex-grow: 0;
-    flex-shrink: 0;
-    flex-basis: 50%;
-}
-
 div.reminderContent {
-    margin-top: 10px;
-    margin-bottom: 10px;
-    padding: 14px;
+    padding: 2px;
     background-color: #f5f5f5;
     border-radius: 8px;
+    margin: 8px;
+}
+
+div.interval-group > button {
+    margin-left: auto;
 }
 
 /* Interval inputs */
-div.interval-group {
-    height: unset !important;
-}
-
-div.interval-group .clear:focus {
-    outline: none;
-    box-shadow: none !important;
-}
-
-div.interval-group .no-break {
-    text-wrap: avoid;
-    white-space: nowrap;
-}
-
-div.interval-group .clear {
-    border: none;
-    background: none;
-    padding: 1px;
-    margin-right: -3px;
-}
-
 div.interval-group > .interval-group-left input {
     -webkit-appearance: none;
     border-style: none;
@@ -190,13 +110,12 @@ div.interval-group > .interval-group-left input.w2 {
 }
 
 div.interval-group > .interval-group-left input.w3 {
-    width: 3ch;
+    width: 6ch;
 }
 
 div.interval-group {
     display: flex;
     flex-direction: row;
-    justify-content: space-between;
 }
 /* !Interval inputs */
 
@@ -261,23 +180,6 @@ div#pageNavbar a {
     text-align: center;
 }
 
-.navbar-burger {
-    flex-shrink: 0;
-}
-
-.navbar-item.pageTitle {
-    flex-shrink: 1;
-    white-space: nowrap;
-    overflow: hidden;
-}
-
-.dashboard-burger, .dashboard-burger:active, .dashboard-burger.is-active {
-    background-color: #adc99c !important;
-    border-radius: 14px;
-    padding: 6px;
-    background-clip: content-box;
-}
-
 div#pageNavbar a:hover {
     background-color: #4a4a4a;
 }
@@ -309,19 +211,10 @@ div.dashboard-sidebar:not(.mobile-sidebar) {
     flex-direction: column;
 }
 
-ul.guildList {
-    flex-grow: 1;
-    flex-shrink: 1;
-    overflow: auto;
-}
-
 div.dashboard-sidebar:not(.mobile-sidebar) .aside-footer {
-    flex-shrink: 0;
-    flex-grow: 0;
-}
-
-div.dashboard-sidebar svg {
-    flex-shrink: 0;
+    position: fixed;
+    bottom: 0;
+    width: 226px;
 }
 
 div.mobile-sidebar {
@@ -400,7 +293,10 @@ input.default-width {
 }
 
 .message-input:placeholder-shown {
-    font-style: italic;
+    border-top: none;
+    border-left: none;
+    border-right: none;
+    border-bottom-style: dashed;
     background-color: #40444b;
     color: #fff;
 }
@@ -471,7 +367,8 @@ input.default-width {
 .customizable.is-400x300 img {
     margin-top: 10px;
     width: 100%;
-    height: 100px;
+    min-height: 100px;
+    max-height: 400px;
 }
 
 .customizable.is-32x32 img {
@@ -565,7 +462,6 @@ input.default-width {
     flex-grow: 1;
     flex-shrink: 1;
     flex-basis: auto;
-    margin-right: 4px;
 }
 
 .embed-body input, .embed-body textarea {
@@ -615,84 +511,21 @@ input.default-width {
     border-bottom: 1px solid #fff;
 }
 
-.channel-selector {
-    width: 100%;
-}
-
-.select {
-    width: 100%;
-}
-
-li.highlight {
-    margin-bottom: 0 !important;
-}
-
-.button-row {
-    display: flex;
-}
-
-.button-row .button-row-reminder {
-    flex-grow: 0;
-    padding: 2px;
-}
-
-.button-row-template {
-    display: flex;
-    flex-grow: 1;
-    justify-content: space-between;
-}
-
-.button-row .button-row-template > div {
-    padding: 2px;
-}
-
-@media only screen and (max-width: 1023px) {
-    p.title.pageTitle {
-        display: none;
-    }
-
-    .dashboard-frame {
-        margin-top: 4rem !important;
-    }
-
+@media only screen and (max-width: 768px) {
     .customizable.thumbnail img {
         width: 60px;
         height: 60px;
     }
-}
 
-@media only screen and (max-width: 768px) {
-    .button-row {
-        display: flex;
-        flex-direction: column;
-    }
-
-    .button-row .button-row-reminder {
-        width: 100%;
-    }
-
-    .button-row .button-row-template > div {
-        flex-basis: 0;
-        flex-grow: 1;
-    }
-
-    .button-row button {
-        width: 100%;
-    }
-
-    .reminder-settings {
-        margin-bottom: 0 !important;
-    }
-
-    .tts-row {
-        padding-bottom: 0;
+    .customizable.is-24x24 img {
+        width: 16px;
+        height: 16px;
     }
 }
 
 /* loader */
 #loader {
     position: fixed;
-    top: 0;
     background-color: rgba(255, 255, 255, 0.8);
     width: 100vw;
     z-index: 999;
@@ -704,86 +537,6 @@ li.highlight {
 
 /* END */
 
-div.reminderError {
-    margin: 10px;
-    padding: 14px;
-    background-color: #f5f5f5;
-    border-radius: 8px;
-}
-
-div.reminderError .errorHead {
-    display: flex;
-    flex-direction: row;
-}
-
-div.reminderError .errorIcon {
-    padding: 8px;
-    border-radius: 4px;
-    margin-right: 12px;
-}
-
-div.reminderError .errorIcon .fas {
-    display: none
-}
-
-div.reminderError[data-case="deleted"] .errorIcon {
-    background-color: #e7e5e4;
-}
-
-div.reminderError[data-case="failed"] .errorIcon {
-    background-color: #fecaca;
-}
-
-div.reminderError[data-case="sent"] .errorIcon {
-    background-color: #d9f99d;
-}
-
-div.reminderError[data-case="deleted"] .errorIcon .fas.fa-trash {
-    display: block;
-}
-
-div.reminderError[data-case="failed"] .errorIcon .fas.fa-exclamation-triangle {
-    display: block;
-}
-
-div.reminderError[data-case="sent"] .errorIcon .fas.fa-check {
-    display: block;
-}
-
-div.reminderError .errorHead .reminderName {
-    font-size: 1rem;
-    display: flex;
-    flex-direction: column;
-    justify-content: center;
-    color: rgb(54, 54, 54);
-    flex-grow: 1;
-}
-
-div.reminderError .errorHead .reminderTime {
-    font-size: 1rem;
-    display: flex;
-    flex-direction: column;
-    flex-shrink: 1;
-    justify-content: center;
-    color: rgb(54, 54, 54);
-    background-color: #ffffff;
-    padding: 8px;
-    border-radius: 4px;
-    border-color: #e5e5e5;
-    border-width: 1px;
-    border-style: solid;
-}
-
-div.reminderError .reminderMessage {
-    font-size: 1rem;
-    display: flex;
-    flex-direction: column;
-    justify-content: center;
-    color: rgb(54, 54, 54);
-    flex-grow: 1;
-    font-style: italic;
-}
-
 /* other stuff */
 
 .half-rem {
@@ -815,44 +568,11 @@ div.reminderError .reminderMessage {
     background-color: white;
 }
 
-a.switch-pane {
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-}
-
-.guild-submenu {
-    display: none;
-}
-
-.guild-submenu li {
-    font-size: 0.8rem;
-}
-
-a.switch-pane.is-active ~ .guild-submenu {
-    display: block;
-}
-
-.feedback {
-    background-color: #5865F2;
-}
-
 .is-locked {
     pointer-events: none;
-}
-
-.is-locked > :not(.patreon-invert) {
     opacity: 0.4;
 }
 
-.is-locked .patreon-invert {
-    display: block;
-}
-
-.patreon-invert {
-    display: none;
-}
-
 .is-locked .foreground {
     pointer-events: auto;
 }
@@ -860,27 +580,3 @@ a.switch-pane.is-active ~ .guild-submenu {
 .is-locked .field:last-of-type {
     display: none;
 }
-
-.stat-row {
-    display: flex;
-    flex-direction: row;
-}
-
-.stat-box {
-    flex-grow: 1;
-    border-radius: 6px;
-    background-color: #fcfcfc;
-    border-color: #efefef;
-    border-style: solid;
-    border-width: 1px;
-    margin: 4px;
-    padding: 4px;
-}
-
-.figure {
-    text-align: center;
-}
-
-.figure-num {
-    font-size: 2rem;
-}

web/static/favicon/site.webmanifest

@@ -1,15 +1,14 @@
 {
-    "name": "Reminder Bot Dashboard",
-    "short_name": "Reminders",
-    "start_url": "/dashboard",
+    "name": "",
+    "short_name": "",
     "icons": [
         {
-            "src": "/static/favicon/android-chrome-192x192.png",
+            "src": "/android-chrome-192x192.png",
             "sizes": "192x192",
             "type": "image/png"
         },
         {
-            "src": "/static/favicon/android-chrome-512x512.png",
+            "src": "/android-chrome-512x512.png",
             "sizes": "512x512",
             "type": "image/png"
         }