Migrate Post to new Plugin structure

backend/src/plugins/Post/util/actualPostCmd.ts

@@ -0,0 +1,185 @@
+import { Message, Channel, TextChannel } from "eris";
+import { StrictMessageContent, errorMessage, DBDateFormat, stripObjectToScalars, MINUTES } from "src/utils";
+import moment from "moment-timezone";
+import { LogType } from "src/data/LogType";
+import humanizeDuration from "humanize-duration";
+import { sendErrorMessage, sendSuccessMessage } from "src/pluginUtils";
+import { PluginData } from "knub";
+import { PostPluginType } from "../types";
+import { parseScheduleTime } from "./parseScheduleTime";
+import { postMessage } from "./postMessage";
+
+const MIN_REPEAT_TIME = 5 * MINUTES;
+const MAX_REPEAT_TIME = Math.pow(2, 32);
+const MAX_REPEAT_UNTIL = moment().add(100, "years");
+
+export async function actualPostCmd(
+  pluginData: PluginData<PostPluginType>,
+  msg: Message,
+  targetChannel: Channel,
+  content: StrictMessageContent,
+  opts?: {
+    "enable-mentions"?: boolean;
+    schedule?: string;
+    repeat?: number;
+    "repeat-until"?: string;
+    "repeat-times"?: number;
+  },
+) {
+  if (!(targetChannel instanceof TextChannel)) {
+    msg.channel.createMessage(errorMessage("Channel is not a text channel"));
+    return;
+  }
+
+  if (content == null && msg.attachments.length === 0) {
+    msg.channel.createMessage(errorMessage("Message content or attachment required"));
+    return;
+  }
+
+  if (opts.repeat) {
+    if (opts.repeat < MIN_REPEAT_TIME) {
+      return sendErrorMessage(
+        pluginData,
+        msg.channel,
+        `Minimum time for -repeat is ${humanizeDuration(MIN_REPEAT_TIME)}`,
+      );
+    }
+    if (opts.repeat > MAX_REPEAT_TIME) {
+      return sendErrorMessage(pluginData, msg.channel, `Max time for -repeat is ${humanizeDuration(MAX_REPEAT_TIME)}`);
+    }
+  }
+
+  // If this is a scheduled or repeated post, figure out the next post date
+  let postAt;
+  if (opts.schedule) {
+    // Schedule the post to be posted later
+    postAt = parseScheduleTime(opts.schedule);
+    if (!postAt) {
+      return sendErrorMessage(pluginData, msg.channel, "Invalid schedule time");
+    }
+  } else if (opts.repeat) {
+    postAt = moment().add(opts.repeat, "ms");
+  }
+
+  // For repeated posts, make sure repeat-until or repeat-times is specified
+  let repeatUntil: moment.Moment = null;
+  let repeatTimes: number = null;
+  let repeatDetailsStr: string = null;
+
+  if (opts["repeat-until"]) {
+    repeatUntil = parseScheduleTime(opts["repeat-until"]);
+
+    // Invalid time
+    if (!repeatUntil) {
+      return sendErrorMessage(pluginData, msg.channel, "Invalid time specified for -repeat-until");
+    }
+    if (repeatUntil.isBefore(moment())) {
+      return sendErrorMessage(pluginData, msg.channel, "You can't set -repeat-until in the past");
+    }
+    if (repeatUntil.isAfter(MAX_REPEAT_UNTIL)) {
+      return sendErrorMessage(
+        pluginData,
+        msg.channel,
+        "Unfortunately, -repeat-until can only be at most 100 years into the future. Maybe 99 years would be enough?",
+      );
+    }
+  } else if (opts["repeat-times"]) {
+    repeatTimes = opts["repeat-times"];
+    if (repeatTimes <= 0) {
+      return sendErrorMessage(pluginData, msg.channel, "-repeat-times must be 1 or more");
+    }
+  }
+
+  if (repeatUntil && repeatTimes) {
+    return sendErrorMessage(pluginData, msg.channel, "You can only use one of -repeat-until or -repeat-times at once");
+  }
+
+  if (opts.repeat && !repeatUntil && !repeatTimes) {
+    return sendErrorMessage(
+      pluginData,
+      msg.channel,
+      "You must specify -repeat-until or -repeat-times for repeated messages",
+    );
+  }
+
+  if (opts.repeat) {
+    repeatDetailsStr = repeatUntil
+      ? `every ${humanizeDuration(opts.repeat)} until ${repeatUntil.format(DBDateFormat)}`
+      : `every ${humanizeDuration(opts.repeat)}, ${repeatTimes} times in total`;
+  }
+
+  // Save schedule/repeat information in DB
+  if (postAt) {
+    if (postAt < moment()) {
+      return sendErrorMessage(pluginData, msg.channel, "Post can't be scheduled to be posted in the past");
+    }
+
+    await pluginData.state.scheduledPosts.create({
+      author_id: msg.author.id,
+      author_name: `${msg.author.username}#${msg.author.discriminator}`,
+      channel_id: targetChannel.id,
+      content,
+      attachments: msg.attachments,
+      post_at: postAt.format(DBDateFormat),
+      enable_mentions: opts["enable-mentions"],
+      repeat_interval: opts.repeat,
+      repeat_until: repeatUntil ? repeatUntil.format(DBDateFormat) : null,
+      repeat_times: repeatTimes ?? null,
+    });
+
+    if (opts.repeat) {
+      pluginData.state.logs.log(LogType.SCHEDULED_REPEATED_MESSAGE, {
+        author: stripObjectToScalars(msg.author),
+        channel: stripObjectToScalars(targetChannel),
+        date: postAt.format("YYYY-MM-DD"),
+        time: postAt.format("HH:mm:ss"),
+        repeatInterval: humanizeDuration(opts.repeat),
+        repeatDetails: repeatDetailsStr,
+      });
+    } else {
+      pluginData.state.logs.log(LogType.SCHEDULED_MESSAGE, {
+        author: stripObjectToScalars(msg.author),
+        channel: stripObjectToScalars(targetChannel),
+        date: postAt.format("YYYY-MM-DD"),
+        time: postAt.format("HH:mm:ss"),
+      });
+    }
+  }
+
+  // When the message isn't scheduled for later, post it immediately
+  if (!opts.schedule) {
+    await postMessage(pluginData, targetChannel, content, msg.attachments, opts["enable-mentions"]);
+  }
+
+  if (opts.repeat) {
+    pluginData.state.logs.log(LogType.REPEATED_MESSAGE, {
+      author: stripObjectToScalars(msg.author),
+      channel: stripObjectToScalars(targetChannel),
+      date: postAt.format("YYYY-MM-DD"),
+      time: postAt.format("HH:mm:ss"),
+      repeatInterval: humanizeDuration(opts.repeat),
+      repeatDetails: repeatDetailsStr,
+    });
+  }
+
+  // Bot reply schenanigans
+  let successMessage = opts.schedule
+    ? `Message scheduled to be posted in <#${targetChannel.id}> on ${postAt.format("YYYY-MM-DD [at] HH:mm:ss")} (UTC)`
+    : `Message posted in <#${targetChannel.id}>`;
+
+  if (opts.repeat) {
+    successMessage += `. Message will be automatically reposted every ${humanizeDuration(opts.repeat)}`;
+
+    if (repeatUntil) {
+      successMessage += ` until ${repeatUntil.format("YYYY-MM-DD [at] HH:mm:ss")} (UTC)`;
+    } else if (repeatTimes) {
+      successMessage += `, ${repeatTimes} times in total`;
+    }
+
+    successMessage += ".";
+  }
+
+  if (targetChannel.id !== msg.channel.id || opts.schedule || opts.repeat) {
+    sendSuccessMessage(pluginData, msg.channel, successMessage);
+  }
+}

backend/src/plugins/Post/util/formatContent.ts

@@ -0,0 +1,3 @@
+export function formatContent(str) {
+  return str.replace(/\\n/g, "\n");
+}

backend/src/plugins/Post/util/parseScheduleTime.ts

@@ -0,0 +1,32 @@
+import moment, { Moment } from "moment-timezone";
+import { convertDelayStringToMS } from "src/utils";
+
+export function parseScheduleTime(str): Moment {
+  const dt1 = moment(str, "YYYY-MM-DD HH:mm:ss");
+  if (dt1 && dt1.isValid()) return dt1;
+
+  const dt2 = moment(str, "YYYY-MM-DD HH:mm");
+  if (dt2 && dt2.isValid()) return dt2;
+
+  const date = moment(str, "YYYY-MM-DD");
+  if (date && date.isValid()) return date;
+
+  const t1 = moment(str, "HH:mm:ss");
+  if (t1 && t1.isValid()) {
+    if (t1.isBefore(moment())) t1.add(1, "day");
+    return t1;
+  }
+
+  const t2 = moment(str, "HH:mm");
+  if (t2 && t2.isValid()) {
+    if (t2.isBefore(moment())) t2.add(1, "day");
+    return t2;
+  }
+
+  const delayStringMS = convertDelayStringToMS(str, "m");
+  if (delayStringMS) {
+    return moment().add(delayStringMS, "ms");
+  }
+
+  return null;
+}

backend/src/plugins/Post/util/postMessage.ts

@@ -0,0 +1,67 @@
+import { PluginData } from "knub";
+import { PostPluginType } from "../types";
+import { TextChannel, MessageContent, Attachment, Message, Role } from "eris";
+import { downloadFile, getRoleMentions } from "src/utils";
+import fs from "fs";
+import { formatContent } from "./formatContent";
+
+const fsp = fs.promises;
+
+export async function postMessage(
+  pluginData: PluginData<PostPluginType>,
+  channel: TextChannel,
+  content: MessageContent,
+  attachments: Attachment[] = [],
+  enableMentions: boolean = false,
+): Promise<Message> {
+  if (typeof content === "string") {
+    content = { content };
+  }
+
+  if (content && content.content) {
+    content.content = formatContent(content.content);
+  }
+
+  let downloadedAttachment;
+  let file;
+  if (attachments.length) {
+    downloadedAttachment = await downloadFile(attachments[0].url);
+    file = {
+      name: attachments[0].filename,
+      file: await fsp.readFile(downloadedAttachment.path),
+    };
+  }
+
+  const rolesMadeMentionable: Role[] = [];
+  if (enableMentions && content.content) {
+    const mentionedRoleIds = getRoleMentions(content.content);
+    if (mentionedRoleIds != null) {
+      for (const roleId of mentionedRoleIds) {
+        const role = pluginData.guild.roles.get(roleId);
+        if (role && !role.mentionable) {
+          await role.edit({
+            mentionable: true,
+          });
+          rolesMadeMentionable.push(role);
+        }
+      }
+    }
+
+    content.allowedMentions.everyone = false;
+  }
+
+  const createdMsg = await channel.createMessage(content, file);
+  pluginData.state.savedMessages.setPermanent(createdMsg.id);
+
+  for (const role of rolesMadeMentionable) {
+    role.edit({
+      mentionable: false,
+    });
+  }
+
+  if (downloadedAttachment) {
+    downloadedAttachment.deleteFn();
+  }
+
+  return createdMsg;
+}

backend/src/plugins/Post/util/scheduledPostLoop.ts

@@ -0,0 +1,82 @@
+import { PluginData } from "knub";
+import { PostPluginType } from "../types";
+import { logger } from "src/logger";
+import { stripObjectToScalars, DBDateFormat, SECONDS } from "src/utils";
+import { LogType } from "src/data/LogType";
+import moment from "moment-timezone";
+import { TextChannel, User } from "eris";
+import { postMessage } from "./postMessage";
+
+const SCHEDULED_POST_CHECK_INTERVAL = 5 * SECONDS;
+
+export async function scheduledPostLoop(pluginData: PluginData<PostPluginType>) {
+  const duePosts = await pluginData.state.scheduledPosts.getDueScheduledPosts();
+  for (const post of duePosts) {
+    const channel = pluginData.guild.channels.get(post.channel_id);
+    if (channel instanceof TextChannel) {
+      const [username, discriminator] = post.author_name.split("#");
+      const author: Partial<User> = pluginData.client.users.get(post.author_id) || {
+        id: post.author_id,
+        username,
+        discriminator,
+      };
+
+      try {
+        const postedMessage = await postMessage(
+          pluginData,
+          channel,
+          post.content,
+          post.attachments,
+          post.enable_mentions,
+        );
+        pluginData.state.logs.log(LogType.POSTED_SCHEDULED_MESSAGE, {
+          author: stripObjectToScalars(author),
+          channel: stripObjectToScalars(channel),
+          messageId: postedMessage.id,
+        });
+      } catch (e) {
+        pluginData.state.logs.log(LogType.BOT_ALERT, {
+          body: `Failed to post scheduled message by {userMention(author)} to {channelMention(channel)}`,
+          channel: stripObjectToScalars(channel),
+          author: stripObjectToScalars(author),
+        });
+        logger.warn(
+          `Failed to post scheduled message to #${channel.name} (${channel.id}) on ${pluginData.guild.name} (${pluginData.guild.id})`,
+        );
+      }
+    }
+
+    let shouldClear = true;
+
+    if (post.repeat_interval) {
+      const nextPostAt = moment().add(post.repeat_interval, "ms");
+
+      if (post.repeat_until) {
+        const repeatUntil = moment(post.repeat_until, DBDateFormat);
+        if (nextPostAt.isSameOrBefore(repeatUntil)) {
+          await pluginData.state.scheduledPosts.update(post.id, {
+            post_at: nextPostAt.format(DBDateFormat),
+          });
+          shouldClear = false;
+        }
+      } else if (post.repeat_times) {
+        if (post.repeat_times > 1) {
+          await pluginData.state.scheduledPosts.update(post.id, {
+            post_at: nextPostAt.format(DBDateFormat),
+            repeat_times: post.repeat_times - 1,
+          });
+          shouldClear = false;
+        }
+      }
+    }
+
+    if (shouldClear) {
+      await pluginData.state.scheduledPosts.delete(post.id);
+    }
+  }
+
+  pluginData.state.scheduledPostLoopTimeout = setTimeout(
+    () => scheduledPostLoop(pluginData),
+    SCHEDULED_POST_CHECK_INTERVAL,
+  );
+}