Reorganize project. Add folder for shared code between backend/dashboard. Switch from jest to ava for tests.

backend/src/plugins/Logs.ts

@@ -0,0 +1,594 @@
+import { decorators as d, IPluginOptions, logger } from "knub";
+import { GuildLogs } from "../data/GuildLogs";
+import { LogType } from "../data/LogType";
+import { Attachment, Channel, Constants as ErisConstants, Embed, Guild, Member, TextChannel, User } from "eris";
+import DiscordRESTError from "eris/lib/errors/DiscordRESTError"; // tslint:disable-line
+import {
+  createChunkedMessage,
+  disableCodeBlocks,
+  disableLinkPreviews,
+  findRelevantAuditLogEntry,
+  messageSummary,
+  noop,
+  stripObjectToScalars,
+  UnknownUser,
+  useMediaUrls,
+  verboseChannelMention,
+  verboseUserMention,
+  verboseUserName,
+} from "../utils";
+import DefaultLogMessages from "../data/DefaultLogMessages.json";
+import moment from "moment-timezone";
+import humanizeDuration from "humanize-duration";
+import isEqual from "lodash.isequal";
+import diff from "lodash.difference";
+import { GuildSavedMessages } from "../data/GuildSavedMessages";
+import { SavedMessage } from "../data/entities/SavedMessage";
+import { GuildArchives } from "../data/GuildArchives";
+import { GuildCases } from "../data/GuildCases";
+import { trimPluginDescription, ZeppelinPlugin } from "./ZeppelinPlugin";
+import { renderTemplate, TemplateParseError } from "../templateFormatter";
+import cloneDeep from "lodash.clonedeep";
+import * as t from "io-ts";
+import { TSafeRegex } from "../validatorUtils";
+
+const LogChannel = t.partial({
+  include: t.array(t.string),
+  exclude: t.array(t.string),
+  batched: t.boolean,
+  batch_time: t.number,
+  excluded_users: t.array(t.string),
+  excluded_message_regexes: t.array(TSafeRegex),
+});
+type TLogChannel = t.TypeOf<typeof LogChannel>;
+
+const LogChannelMap = t.record(t.string, LogChannel);
+type TLogChannelMap = t.TypeOf<typeof LogChannelMap>;
+
+const ConfigSchema = t.type({
+  channels: LogChannelMap,
+  format: t.intersection([
+    t.record(t.string, t.string),
+    t.type({
+      timestamp: t.string,
+    }),
+  ]),
+  ping_user: t.boolean,
+});
+type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
+
+export class LogsPlugin extends ZeppelinPlugin<TConfigSchema> {
+  public static pluginName = "logs";
+  public static configSchema = ConfigSchema;
+
+  public static pluginInfo = {
+    prettyName: "Logs",
+  };
+
+  protected guildLogs: GuildLogs;
+  protected savedMessages: GuildSavedMessages;
+  protected archives: GuildArchives;
+  protected cases: GuildCases;
+
+  protected logListener;
+
+  protected batches: Map<string, string[]>;
+
+  private onMessageDeleteFn;
+  private onMessageDeleteBulkFn;
+  private onMessageUpdateFn;
+
+  private excludedUserProps = ["user", "member", "mod"];
+
+  public static getStaticDefaultOptions(): IPluginOptions<TConfigSchema> {
+    return {
+      config: {
+        channels: {},
+        format: {
+          timestamp: "YYYY-MM-DD HH:mm:ss",
+          ...DefaultLogMessages,
+        },
+        ping_user: true,
+      },
+
+      overrides: [
+        {
+          level: ">=50",
+          config: {
+            ping_user: false,
+          },
+        },
+      ],
+    };
+  }
+
+  onLoad() {
+    this.guildLogs = new GuildLogs(this.guildId);
+    this.savedMessages = GuildSavedMessages.getGuildInstance(this.guildId);
+    this.archives = GuildArchives.getGuildInstance(this.guildId);
+    this.cases = GuildCases.getGuildInstance(this.guildId);
+
+    this.logListener = ({ type, data }) => this.log(type, data);
+    this.guildLogs.on("log", this.logListener);
+
+    this.batches = new Map();
+
+    this.onMessageDeleteFn = this.onMessageDelete.bind(this);
+    this.savedMessages.events.on("delete", this.onMessageDeleteFn);
+
+    this.onMessageDeleteBulkFn = this.onMessageDeleteBulk.bind(this);
+    this.savedMessages.events.on("deleteBulk", this.onMessageDeleteBulkFn);
+
+    this.onMessageUpdateFn = this.onMessageUpdate.bind(this);
+    this.savedMessages.events.on("update", this.onMessageUpdateFn);
+  }
+
+  onUnload() {
+    this.guildLogs.removeListener("log", this.logListener);
+
+    this.savedMessages.events.off("delete", this.onMessageDeleteFn);
+    this.savedMessages.events.off("deleteBulk", this.onMessageDeleteBulkFn);
+    this.savedMessages.events.off("update", this.onMessageUpdateFn);
+  }
+
+  async log(type, data) {
+    const logChannels: TLogChannelMap = this.getConfig().channels;
+    const typeStr = LogType[type];
+
+    logChannelLoop: for (const [channelId, opts] of Object.entries(logChannels)) {
+      const channel = this.guild.channels.get(channelId);
+      if (!channel || !(channel instanceof TextChannel)) continue;
+
+      if ((opts.include && opts.include.includes(typeStr)) || (opts.exclude && !opts.exclude.includes(typeStr))) {
+        // If this log entry is about an excluded user, skip it
+        // TODO: Quick and dirty solution, look into changing at some point
+        if (opts.excluded_users) {
+          for (const prop of this.excludedUserProps) {
+            if (data && data[prop] && opts.excluded_users.includes(data[prop].id)) {
+              continue logChannelLoop;
+            }
+          }
+        }
+
+        if (type === LogType.MESSAGE_DELETE && opts.excluded_message_regexes && data.message.data.content) {
+          for (const regex of opts.excluded_message_regexes) {
+            if (regex.test(data.message.data.content)) {
+              return;
+            }
+          }
+        }
+
+        if (type === LogType.MESSAGE_EDIT && opts.excluded_message_regexes && data.before.data.content) {
+          for (const regex of opts.excluded_message_regexes) {
+            if (regex.test(data.before.data.content)) {
+              return;
+            }
+          }
+        }
+
+        const message = await this.getLogMessage(type, data);
+        if (message) {
+          if (opts.batched) {
+            // If we're batching log messages, gather all log messages within the set batch_time into a single message
+            if (!this.batches.has(channel.id)) {
+              this.batches.set(channel.id, []);
+              setTimeout(async () => {
+                const batchedMessage = this.batches.get(channel.id).join("\n");
+                this.batches.delete(channel.id);
+                createChunkedMessage(channel, batchedMessage).catch(noop);
+              }, opts.batch_time || 2000);
+            }
+
+            this.batches.get(channel.id).push(message);
+          } else {
+            // If we're not batching log messages, just send them immediately
+            await createChunkedMessage(channel, message).catch(noop);
+          }
+        }
+      }
+    }
+  }
+
+  async getLogMessage(type, data): Promise<string> {
+    const config = this.getConfig();
+    const format = config.format[LogType[type]] || "";
+    if (format === "") return;
+
+    let formatted;
+    try {
+      const values = {
+        ...data,
+        userMention: async userOrMember => {
+          if (!userOrMember) return "";
+
+          let user;
+          let member;
+
+          if (userOrMember.user) {
+            member = userOrMember;
+            user = member.user;
+          } else {
+            user = userOrMember;
+            member = this.guild.members.get(user.id) || { id: user.id, user };
+          }
+
+          const memberConfig = this.getMatchingConfig({ member, userId: user.id }) || ({} as any);
+
+          return memberConfig.ping_user ? verboseUserMention(user) : verboseUserName(user);
+        },
+        channelMention: channel => {
+          if (!channel) return "";
+          return verboseChannelMention(channel);
+        },
+        messageSummary: (msg: SavedMessage) => {
+          if (!msg) return "";
+          return messageSummary(msg);
+        },
+      };
+
+      if (type === LogType.BOT_ALERT) {
+        const valuesWithoutTmplEval = { ...values };
+        values.tmplEval = str => {
+          return renderTemplate(str, valuesWithoutTmplEval);
+        };
+      }
+
+      formatted = await renderTemplate(format, values);
+    } catch (e) {
+      if (e instanceof TemplateParseError) {
+        logger.error(`Error when parsing template:\nError: ${e.message}\nTemplate: ${format}`);
+        return;
+      } else {
+        throw e;
+      }
+    }
+
+    formatted = formatted.trim();
+
+    const timestampFormat = config.format.timestamp;
+    if (timestampFormat) {
+      const timestamp = moment().format(timestampFormat);
+      return `\`[${timestamp}]\` ${formatted}`;
+    } else {
+      return formatted;
+    }
+  }
+
+  async findRelevantAuditLogEntry(actionType: number, userId: string, attempts?: number, attemptDelay?: number) {
+    try {
+      return await findRelevantAuditLogEntry(this.guild, actionType, userId, attempts, attemptDelay);
+    } catch (e) {
+      if (e instanceof DiscordRESTError && e.code === 50013) {
+        this.guildLogs.log(LogType.BOT_ALERT, {
+          body: "Missing permissions to read audit log",
+        });
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  @d.event("guildMemberAdd")
+  async onMemberJoin(_, member) {
+    const newThreshold = moment().valueOf() - 1000 * 60 * 60;
+    const accountAge = humanizeDuration(moment().valueOf() - member.createdAt, {
+      largest: 2,
+      round: true,
+    });
+
+    this.guildLogs.log(LogType.MEMBER_JOIN, {
+      member: stripObjectToScalars(member, ["user", "roles"]),
+      new: member.createdAt >= newThreshold ? " :new:" : "",
+      account_age: accountAge,
+    });
+
+    const cases = (await this.cases.with("notes").getByUserId(member.id)).filter(c => !c.is_hidden);
+    cases.sort((a, b) => (a.created_at > b.created_at ? -1 : 1));
+
+    if (cases.length) {
+      const recentCaseLines = [];
+      const recentCases = cases.slice(0, 2);
+      for (const theCase of recentCases) {
+        recentCaseLines.push(this.cases.getSummaryText(theCase));
+      }
+
+      let recentCaseSummary = recentCaseLines.join("\n");
+      if (recentCases.length < cases.length) {
+        const remaining = cases.length - recentCases.length;
+        if (remaining === 1) {
+          recentCaseSummary += `\n*+${remaining} case*`;
+        } else {
+          recentCaseSummary += `\n*+${remaining} cases*`;
+        }
+      }
+
+      this.guildLogs.log(LogType.MEMBER_JOIN_WITH_PRIOR_RECORDS, {
+        member: stripObjectToScalars(member, ["user", "roles"]),
+        recentCaseSummary,
+      });
+    }
+  }
+
+  @d.event("guildMemberRemove")
+  onMemberLeave(_, member) {
+    this.guildLogs.log(LogType.MEMBER_LEAVE, {
+      member: stripObjectToScalars(member, ["user", "roles"]),
+    });
+  }
+
+  @d.event("guildBanAdd")
+  async onMemberBan(_, user) {
+    const relevantAuditLogEntry = await this.findRelevantAuditLogEntry(
+      ErisConstants.AuditLogActions.MEMBER_BAN_ADD,
+      user.id,
+    );
+    const mod = relevantAuditLogEntry ? relevantAuditLogEntry.user : new UnknownUser();
+
+    this.guildLogs.log(
+      LogType.MEMBER_BAN,
+      {
+        mod: stripObjectToScalars(mod),
+        user: stripObjectToScalars(user),
+      },
+      user.id,
+    );
+  }
+
+  @d.event("guildBanRemove")
+  async onMemberUnban(_, user) {
+    const relevantAuditLogEntry = await this.findRelevantAuditLogEntry(
+      ErisConstants.AuditLogActions.MEMBER_BAN_REMOVE,
+      user.id,
+    );
+    const mod = relevantAuditLogEntry ? relevantAuditLogEntry.user : new UnknownUser();
+
+    this.guildLogs.log(
+      LogType.MEMBER_UNBAN,
+      {
+        mod: stripObjectToScalars(mod),
+        userId: user.id,
+      },
+      user.id,
+    );
+  }
+
+  @d.event("guildMemberUpdate")
+  async onMemberUpdate(_, member: Member, oldMember: Member) {
+    if (!oldMember) return;
+
+    if (member.nick !== oldMember.nick) {
+      this.guildLogs.log(LogType.MEMBER_NICK_CHANGE, {
+        member,
+        oldNick: oldMember.nick != null ? oldMember.nick : "<none>",
+        newNick: member.nick != null ? member.nick : "<none>",
+      });
+    }
+
+    if (!isEqual(oldMember.roles, member.roles)) {
+      const addedRoles = diff(member.roles, oldMember.roles);
+      const removedRoles = diff(oldMember.roles, member.roles);
+
+      const relevantAuditLogEntry = await this.findRelevantAuditLogEntry(
+        ErisConstants.AuditLogActions.MEMBER_ROLE_UPDATE,
+        member.id,
+      );
+      const mod = relevantAuditLogEntry ? relevantAuditLogEntry.user : new UnknownUser();
+
+      if (addedRoles.length && removedRoles.length) {
+        // Roles added *and* removed
+        this.guildLogs.log(
+          LogType.MEMBER_ROLE_CHANGES,
+          {
+            member,
+            addedRoles: addedRoles
+              .map(roleId => this.guild.roles.get(roleId) || { id: roleId, name: `Unknown (${roleId})` })
+              .map(r => r.name)
+              .join(", "),
+            removedRoles: removedRoles
+              .map(roleId => this.guild.roles.get(roleId) || { id: roleId, name: `Unknown (${roleId})` })
+              .map(r => r.name)
+              .join(", "),
+            mod: stripObjectToScalars(mod),
+          },
+          member.id,
+        );
+      } else if (addedRoles.length) {
+        // Roles added
+        this.guildLogs.log(
+          LogType.MEMBER_ROLE_ADD,
+          {
+            member,
+            roles: addedRoles
+              .map(roleId => this.guild.roles.get(roleId) || { id: roleId, name: `Unknown (${roleId})` })
+              .map(r => r.name)
+              .join(", "),
+            mod: stripObjectToScalars(mod),
+          },
+          member.id,
+        );
+      } else if (removedRoles.length && !addedRoles.length) {
+        // Roles removed
+        this.guildLogs.log(
+          LogType.MEMBER_ROLE_REMOVE,
+          {
+            member,
+            roles: removedRoles
+              .map(roleId => this.guild.roles.get(roleId) || { id: roleId, name: `Unknown (${roleId})` })
+              .map(r => r.name)
+              .join(", "),
+            mod: stripObjectToScalars(mod),
+          },
+          member.id,
+        );
+      }
+    }
+  }
+
+  @d.event("userUpdate", null, false)
+  async onUserUpdate(user: User, oldUser: User) {
+    if (!oldUser) return;
+
+    if (!this.guild.members.has(user.id)) return;
+
+    if (user.username !== oldUser.username || user.discriminator !== oldUser.discriminator) {
+      this.guildLogs.log(LogType.MEMBER_USERNAME_CHANGE, {
+        user: stripObjectToScalars(user),
+        oldName: `${oldUser.username}#${oldUser.discriminator}`,
+        newName: `${user.username}#${user.discriminator}`,
+      });
+    }
+  }
+
+  @d.event("channelCreate")
+  onChannelCreate(channel) {
+    this.guildLogs.log(LogType.CHANNEL_CREATE, {
+      channel: stripObjectToScalars(channel),
+    });
+  }
+
+  @d.event("channelDelete")
+  onChannelDelete(channel) {
+    this.guildLogs.log(LogType.CHANNEL_DELETE, {
+      channel: stripObjectToScalars(channel),
+    });
+  }
+
+  @d.event("guildRoleCreate")
+  onRoleCreate(_, role) {
+    this.guildLogs.log(LogType.ROLE_CREATE, {
+      role: stripObjectToScalars(role),
+    });
+  }
+
+  @d.event("guildRoleDelete")
+  onRoleDelete(_, role) {
+    this.guildLogs.log(LogType.ROLE_DELETE, {
+      role: stripObjectToScalars(role),
+    });
+  }
+
+  // Uses events from savesMessages
+  async onMessageUpdate(savedMessage: SavedMessage, oldSavedMessage: SavedMessage) {
+    // To log a message update, either the message content or a rich embed has to change
+    let logUpdate = false;
+
+    const oldEmbedsToCompare = ((oldSavedMessage.data.embeds || []) as Embed[])
+      .map(e => cloneDeep(e))
+      .filter(e => (e as Embed).type === "rich");
+
+    const newEmbedsToCompare = ((savedMessage.data.embeds || []) as Embed[])
+      .map(e => cloneDeep(e))
+      .filter(e => (e as Embed).type === "rich");
+
+    for (const embed of [...oldEmbedsToCompare, ...newEmbedsToCompare]) {
+      if (embed.thumbnail) {
+        delete embed.thumbnail.width;
+        delete embed.thumbnail.height;
+      }
+
+      if (embed.image) {
+        delete embed.image.width;
+        delete embed.image.height;
+      }
+    }
+
+    if (
+      oldSavedMessage.data.content !== savedMessage.data.content ||
+      oldEmbedsToCompare.length !== newEmbedsToCompare.length ||
+      JSON.stringify(oldEmbedsToCompare) !== JSON.stringify(newEmbedsToCompare)
+    ) {
+      logUpdate = true;
+    }
+
+    if (!logUpdate) {
+      return;
+    }
+
+    const user = await this.resolveUser(savedMessage.user_id);
+    const channel = this.guild.channels.get(savedMessage.channel_id);
+
+    this.guildLogs.log(LogType.MESSAGE_EDIT, {
+      user: stripObjectToScalars(user),
+      channel: stripObjectToScalars(channel),
+      before: oldSavedMessage,
+      after: savedMessage,
+    });
+  }
+
+  // Uses events from savesMessages
+  async onMessageDelete(savedMessage: SavedMessage) {
+    const user = await this.resolveUser(savedMessage.user_id);
+    const channel = this.guild.channels.get(savedMessage.channel_id);
+
+    if (user) {
+      // Replace attachment URLs with media URLs
+      if (savedMessage.data.attachments) {
+        for (const attachment of savedMessage.data.attachments as Attachment[]) {
+          attachment.url = useMediaUrls(attachment.url);
+        }
+      }
+
+      this.guildLogs.log(
+        LogType.MESSAGE_DELETE,
+        {
+          user: stripObjectToScalars(user),
+          channel: stripObjectToScalars(channel),
+          messageDate: moment(savedMessage.data.timestamp, "x").format(this.getConfig().format.timestamp),
+          message: savedMessage,
+        },
+        savedMessage.id,
+      );
+    } else {
+      this.guildLogs.log(
+        LogType.MESSAGE_DELETE_BARE,
+        {
+          messageId: savedMessage.id,
+          channel: stripObjectToScalars(channel),
+        },
+        savedMessage.id,
+      );
+    }
+  }
+
+  // Uses events from savesMessages
+  async onMessageDeleteBulk(savedMessages: SavedMessage[]) {
+    const channel = this.guild.channels.get(savedMessages[0].channel_id);
+    const archiveId = await this.archives.createFromSavedMessages(savedMessages, this.guild);
+    const archiveUrl = this.archives.getUrl(this.knub.getGlobalConfig().url, archiveId);
+
+    this.guildLogs.log(
+      LogType.MESSAGE_DELETE_BULK,
+      {
+        count: savedMessages.length,
+        channel,
+        archiveUrl,
+      },
+      savedMessages[0].id,
+    );
+  }
+
+  @d.event("voiceChannelJoin")
+  onVoiceChannelJoin(member: Member, channel: Channel) {
+    this.guildLogs.log(LogType.VOICE_CHANNEL_JOIN, {
+      member: stripObjectToScalars(member, ["user", "roles"]),
+      channel: stripObjectToScalars(channel),
+    });
+  }
+
+  @d.event("voiceChannelLeave")
+  onVoiceChannelLeave(member: Member, channel: Channel) {
+    this.guildLogs.log(LogType.VOICE_CHANNEL_LEAVE, {
+      member: stripObjectToScalars(member, ["user", "roles"]),
+      channel: stripObjectToScalars(channel),
+    });
+  }
+
+  @d.event("voiceChannelSwitch")
+  onVoiceChannelSwitch(member: Member, newChannel: Channel, oldChannel: Channel) {
+    this.guildLogs.log(LogType.VOICE_CHANNEL_MOVE, {
+      member: stripObjectToScalars(member, ["user", "roles"]),
+      oldChannel: stripObjectToScalars(oldChannel),
+      newChannel: stripObjectToScalars(newChannel),
+    });
+  }
+}