Knub 30 conversion base work; Work on Utility plugin Knub 30 conversion

backend/src/plugins/Utility/UtilityPlugin.ts

@@ -0,0 +1,30 @@
+import { zeppelinPlugin } from "../ZeppelinPluginBlueprint";
+import { ConfigSchema, UtilityPluginType } from "./types";
+import { GuildLogs } from "../../data/GuildLogs";
+import { GuildCases } from "../../data/GuildCases";
+import { GuildSavedMessages } from "../../data/GuildSavedMessages";
+import { GuildArchives } from "../../data/GuildArchives";
+import { Supporters } from "../../data/Supporters";
+import { ServerCmd } from "./commands/ServerCmd";
+import { RolesCmd } from "./commands/RolesCmd";
+import { LevelCmd } from "./commands/LevelCmd";
+
+export const UtilityPlugin = zeppelinPlugin<UtilityPluginType>()("utility", {
+  configSchema: ConfigSchema,
+
+  commands: [
+    LevelCmd,
+    RolesCmd,
+    ServerCmd,
+  ],
+
+  onLoad({ state, guild }) {
+    state.logs = new GuildLogs(guild.id);
+    state.cases = GuildCases.getGuildInstance(guild.id);
+    state.savedMessages = GuildSavedMessages.getGuildInstance(guild.id);
+    state.archives = GuildArchives.getGuildInstance(guild.id);
+    state.supporters = new Supporters();
+
+    state.lastReload = Date.now();
+  }
+});

backend/src/plugins/Utility/commands/LevelCmd.ts

@@ -0,0 +1,23 @@
+import { utilityCmd } from "../types";
+import { customArgumentHelpers as ct } from "../../../customArgumentTypes";
+import { helpers } from "knub";
+
+const { getMemberLevel } = helpers;
+
+export const LevelCmd = utilityCmd(
+  "level",
+  {
+    member: ct.resolvedMember({ required: false }),
+  },
+
+  {
+    description: "Show the permission level of a user",
+    usage: "!level 106391128718245888",
+  },
+
+  ({ message, args, pluginData }) => {
+    const member = args.member || message.member;
+    const level = getMemberLevel(pluginData, member);
+    message.channel.createMessage(`The permission level of ${member.username}#${member.discriminator} is **${level}**`);
+  }
+);

backend/src/plugins/Utility/commands/RolesCmd.ts

@@ -0,0 +1,113 @@
+import { utilityCmd } from "../types";
+import { baseTypeHelpers as t } from "knub";
+import { Role, TextChannel } from "eris";
+import { chunkArray, sorter, trimLines } from "../../../utils";
+import { refreshMembersIfNeeded } from "../refreshMembers";
+import { sendErrorMessage } from "../../../pluginUtils";
+
+export const RolesCmd = utilityCmd(
+  "roles",
+  {
+    search: t.string({ catchAll: true }),
+
+    counts: t.switchOption(),
+    sort: t.string({ option: true }),
+  },
+
+  {
+    description: "List all roles or roles matching a search",
+    usage: "!roles mod",
+    permission: "can_roles",
+  },
+
+  async ({ message: msg, args, pluginData }) => {
+    const { guild } = pluginData;
+
+    let roles: Array<{ _memberCount?: number } & Role> = Array.from((msg.channel as TextChannel).guild.roles.values());
+    let sort = args.sort;
+
+    if (args.search) {
+      const searchStr = args.search.toLowerCase();
+      roles = roles.filter(r => r.name.toLowerCase().includes(searchStr) || r.id === searchStr);
+    }
+
+    if (args.counts) {
+      await refreshMembersIfNeeded(guild);
+
+      // If the user requested role member counts as well, calculate them and sort the roles by their member count
+      const roleCounts: Map<string, number> = Array.from(guild.members.values()).reduce((map, member) => {
+        for (const roleId of member.roles) {
+          if (!map.has(roleId)) map.set(roleId, 0);
+          map.set(roleId, map.get(roleId) + 1);
+        }
+
+        return map;
+      }, new Map());
+
+      // The "everyone" role always has all members in it
+      roleCounts.set(guild.id, guild.memberCount);
+
+      for (const role of roles) {
+        role._memberCount = roleCounts.has(role.id) ? roleCounts.get(role.id) : 0;
+      }
+
+      if (!sort) sort = "-memberCount";
+      roles.sort((a, b) => {
+        if (a._memberCount > b._memberCount) return -1;
+        if (a._memberCount < b._memberCount) return 1;
+        return 0;
+      });
+    } else {
+      // Otherwise sort by name
+      roles.sort((a, b) => {
+        if (a.name.toLowerCase() > b.name.toLowerCase()) return 1;
+        if (a.name.toLowerCase() < b.name.toLowerCase()) return -1;
+        return 0;
+      });
+    }
+
+    if (!sort) sort = "name";
+
+    let sortDir: "ASC" | "DESC" = "ASC";
+    if (sort && sort[0] === "-") {
+      sort = sort.slice(1);
+      sortDir = "DESC";
+    }
+
+    if (sort === "position" || sort === "order") {
+      roles.sort(sorter("position", sortDir));
+    } else if (sort === "memberCount" && args.counts) {
+      roles.sort(sorter("_memberCount", sortDir));
+    } else if (sort === "name") {
+      roles.sort(sorter(r => r.name.toLowerCase(), sortDir));
+    } else {
+      sendErrorMessage(pluginData, msg.channel, "Unknown sorting method");
+      return;
+    }
+
+    const longestId = roles.reduce((longest, role) => Math.max(longest, role.id.length), 0);
+
+    const chunks = chunkArray(roles, 20);
+    for (const [i, chunk] of chunks.entries()) {
+      const roleLines = chunk.map(role => {
+        const paddedId = role.id.padEnd(longestId, " ");
+        let line = `${paddedId} ${role.name}`;
+        if (role._memberCount != null) {
+          line += role._memberCount === 1 ? ` (${role._memberCount} member)` : ` (${role._memberCount} members)`;
+        }
+        return line;
+      });
+
+      if (i === 0) {
+        msg.channel.createMessage(
+          trimLines(`
+          ${args.search ? "Total roles found" : "Total roles"}: ${roles.length}
+          \`\`\`py\n${roleLines.join("\n")}\`\`\`
+        `),
+        );
+      } else {
+        msg.channel.createMessage("```py\n" + roleLines.join("\n") + "```");
+      }
+    }
+  }
+);

backend/src/plugins/Utility/commands/SearchCmd.ts

@@ -0,0 +1,12 @@
+import { utilityCmd } from "../types";
+import { baseTypeHelpers as t } from "knub";
+
+export const SearchCmd = utilityCmd(
+  ["search", "s"],
+  {
+    query: t.string({ catchAll: true }),
+
+  },
+  {},
+  () => {}
+);

backend/src/plugins/Utility/commands/ServerCmd.ts

@@ -0,0 +1,126 @@
+import { CategoryChannel, EmbedOptions, TextChannel, VoiceChannel } from "eris";
+import moment from "moment-timezone";
+import { embedPadding, formatNumber, memoize, MINUTES, trimLines } from "../../../utils";
+import { utilityCmd } from "../types";
+import humanizeDuration from "humanize-duration";
+
+export const ServerCmd = utilityCmd(
+  "server",
+  {},
+
+  {
+    permission: "can_server",
+    description: "Show information about the server",
+    usage: "!server",
+  },
+
+  async ({ message }) => {
+    const embed: EmbedOptions = {
+      fields: [],
+      color: parseInt("6b80cf", 16),
+    };
+
+    embed.thumbnail = { url: this.guild.iconURL };
+
+    const createdAt = moment(this.guild.createdAt);
+    const serverAge = humanizeDuration(moment().valueOf() - this.guild.createdAt, {
+      largest: 2,
+      round: true,
+    });
+
+    const owner = this.bot.users.get(this.guild.ownerID);
+    const ownerName = owner ? `${owner.username}#${owner.discriminator}` : "Unknown#0000";
+
+    embed.fields.push({
+      name: `Server information - ${this.guild.name}`,
+      value:
+        trimLines(`
+          Created: **${serverAge} ago** (${createdAt.format("YYYY-MM-DD[T]HH:mm:ss")})
+          Owner: **${ownerName}** (${this.guild.ownerID})
+          Voice region: **${this.guild.region}**
+          ${this.guild.features.length > 0 ? "Features: " + this.guild.features.join(", ") : ""}
+        `) + embedPadding,
+    });
+
+    const restGuild = await memoize(
+      () => this.bot.getRESTGuild(this.guildId),
+      `getRESTGuild_${this.guildId}`,
+      10 * MINUTES,
+    );
+
+    // For servers with a vanity URL, we can use the numbers from the invite for online count
+    // (which is nowadays usually more accurate for large servers)
+    const invite = this.guild.vanityURL
+      ? await memoize(
+        () => this.bot.getInvite(this.guild.vanityURL, true),
+        `getInvite_${this.guild.vanityURL}`,
+        10 * MINUTES,
+      )
+      : null;
+
+    const totalMembers = invite ? invite.memberCount : this.guild.memberCount;
+
+    const onlineMemberCount = invite
+      ? invite.presenceCount
+      : this.guild.members.filter(m => m.status !== "offline").length;
+    const offlineMemberCount = this.guild.memberCount - onlineMemberCount;
+
+    let memberCountTotalLines = `Total: **${formatNumber(totalMembers)}**`;
+    if (restGuild.maxMembers) {
+      memberCountTotalLines += `\nMax: **${formatNumber(restGuild.maxMembers)}**`;
+    }
+
+    let memberCountOnlineLines = `Online: **${formatNumber(onlineMemberCount)}**`;
+    if (restGuild.maxPresences) {
+      memberCountOnlineLines += `\nMax online: **${formatNumber(restGuild.maxPresences)}**`;
+    }
+
+    embed.fields.push({
+      name: "Members",
+      inline: true,
+      value: trimLines(`
+          ${memberCountTotalLines}
+          ${memberCountOnlineLines}
+          Offline: **${formatNumber(offlineMemberCount)}**
+        `),
+    });
+
+    const totalChannels = this.guild.channels.size;
+    const categories = this.guild.channels.filter(channel => channel instanceof CategoryChannel);
+    const textChannels = this.guild.channels.filter(channel => channel instanceof TextChannel);
+    const voiceChannels = this.guild.channels.filter(channel => channel instanceof VoiceChannel);
+
+    embed.fields.push({
+      name: "Channels",
+      inline: true,
+      value:
+        trimLines(`
+          Total: **${totalChannels}** / 500
+          Categories: **${categories.length}**
+          Text: **${textChannels.length}**
+          Voice: **${voiceChannels.length}**
+        `) + embedPadding,
+    });
+
+    const maxEmojis =
+      {
+        0: 50,
+        1: 100,
+        2: 150,
+        3: 250,
+      }[this.guild.premiumTier] || 50;
+
+    embed.fields.push({
+      name: "Other stats",
+      inline: true,
+      value:
+        trimLines(`
+          Roles: **${this.guild.roles.size}** / 250
+          Emojis: **${this.guild.emojis.length}** / ${maxEmojis}
+          Boosts: **${this.guild.premiumSubscriptionCount ?? 0}** (level ${this.guild.premiumTier})
+        `) + embedPadding,
+    });
+
+    message.channel.createMessage({ embed });
+  }
+);

backend/src/plugins/Utility/refreshMembers.ts

@@ -0,0 +1,20 @@
+import { Guild } from "eris";
+import { MINUTES, noop } from "../../utils";
+
+const MEMBER_REFRESH_FREQUENCY = 10 * MINUTES; // How often to do a full member refresh when using commands that need it
+const memberRefreshLog = new Map<string, { time: number, promise: Promise<void> }>();
+
+export async function refreshMembersIfNeeded(guild: Guild) {
+  const lastRefresh = memberRefreshLog.get(guild.id);
+  if (lastRefresh && Date.now() < lastRefresh.time + MEMBER_REFRESH_FREQUENCY) {
+    return lastRefresh.promise;
+  }
+
+  const loadPromise = guild.fetchAllMembers().then(noop);
+  memberRefreshLog.set(guild.id, {
+    time: Date.now(),
+    promise: loadPromise,
+  });
+
+  return loadPromise;
+}

backend/src/plugins/Utility/types.ts

@@ -0,0 +1,44 @@
+import * as t from "io-ts";
+import { BasePluginType, command, eventListener } from "knub";
+import { GuildLogs } from "../../data/GuildLogs";
+import { GuildCases } from "../../data/GuildCases";
+import { GuildSavedMessages } from "../../data/GuildSavedMessages";
+import { GuildArchives } from "../../data/GuildArchives";
+import { Supporters } from "../../data/Supporters";
+
+export const ConfigSchema = t.type({
+  can_roles: t.boolean,
+  can_level: t.boolean,
+  can_search: t.boolean,
+  can_clean: t.boolean,
+  can_info: t.boolean,
+  can_server: t.boolean,
+  can_reload_guild: t.boolean,
+  can_nickname: t.boolean,
+  can_ping: t.boolean,
+  can_source: t.boolean,
+  can_vcmove: t.boolean,
+  can_help: t.boolean,
+  can_about: t.boolean,
+  can_context: t.boolean,
+  can_jumbo: t.boolean,
+  jumbo_size: t.Integer,
+  can_avatar: t.boolean,
+});
+export type TConfigSchema = t.TypeOf<typeof ConfigSchema>;
+
+export interface UtilityPluginType extends BasePluginType {
+  config: TConfigSchema;
+  state: {
+    logs: GuildLogs;
+    cases: GuildCases;
+    savedMessages: GuildSavedMessages;
+    archives: GuildArchives;
+    supporters: Supporters;
+
+    lastReload: number;
+  };
+}
+
+export const utilityCmd = command<UtilityPluginType>();
+export const utilityEvent = eventListener<UtilityPluginType>();