Refactor skill role stuff

Author: michael-kenzel

src/components/anti-invite-links.ts

@@ -203,28 +203,12 @@ export default class AntiInviteLinks extends BotComponent {
         }
     }
 
-    async member_is_proficient_or_higher(member: Discord.GuildMember | null) {
-        if (!member) {
-            return false;
-        }
-        const skill_roles = member.roles.cache.filter(role =>
-            Object.values(this.wheatley.skill_roles).some(skill_role => role.id == skill_role.id),
-        );
-        if (skill_roles.size > 1) {
-            const skill_role_ranks = Object.values(this.wheatley.skill_roles).map(role => role.id);
-            const proficient_index = skill_role_ranks.indexOf(this.wheatley.skill_roles.proficient.id);
-            assert(proficient_index !== -1);
-            return skill_roles.some(role => skill_role_ranks.indexOf(role.id) >= proficient_index);
-        }
-        return false;
-    }
-
     async handle_message(message: Discord.Message) {
         if (await this.wheatley.check_permissions(message.author, Discord.PermissionFlagsBits.ModerateMembers)) {
             return;
         }
         const match = match_invite(message.content);
-        if (match && !(await this.is_allowed(match)) && !(await this.member_is_proficient_or_higher(message.member))) {
+        if (match && !(await this.is_allowed(match)) && !(await this.wheatley.is_established_member(message.author))) {
             const quote = await this.utilities.make_quote_embeds(message);
             await message.delete();
             assert(!(message.channel instanceof Discord.PartialGroupDMChannel));

src/components/moderation/modmail.ts

@@ -280,14 +280,8 @@ export default class Modmail extends BotComponent {
             });
             await this.log_action(interaction.member, "Modmail button spammed");
         } else {
-            const member = await this.wheatley.guild.members.fetch(interaction.user.id);
-            const non_beginner_skill_roles = member.roles.cache.filter(role =>
-                Object.values(this.wheatley.skill_roles).some(
-                    skill_role => role.id == skill_role.id && skill_role.name != "Beginner",
-                ),
-            );
-            if (non_beginner_skill_roles.size > 0) {
-                // fast-path people who can read
+            if (await this.wheatley.is_established_member(interaction.user)) {
+                // fast-path established members
                 await interaction.deferReply({
                     ephemeral: true,
                 });

src/components/role-manager.ts

@@ -5,14 +5,12 @@ import { unwrap } from "../utils/misc.js";
 import { M } from "../utils/debugging-and-logging.js";
 import { BotComponent } from "../bot-component.js";
 import { CommandSetBuilder } from "../command-abstractions/command-set-builder.js";
-import { skill_roles_order, skill_roles_order_id, Wheatley } from "../wheatley.js";
 import { set_interval } from "../utils/node.js";
 import { build_description } from "../utils/strings.js";
 
-type user_role_entry = {
+export type user_role_entry = {
     user_id: string;
     roles: string[];
-    last_known_skill_role: string | null;
 };
 
 type role_check = (member: Discord.GuildMember) => Promise<void>;
@@ -23,7 +21,6 @@ type role_update_listener = {
 };
 
 export default class RoleManager extends BotComponent {
-    private skill_role_log!: Discord.TextChannel;
     private staff_member_log!: Discord.TextChannel;
     interval: NodeJS.Timeout | null = null;
 
@@ -49,7 +46,6 @@ export default class RoleManager extends BotComponent {
     }
 
     override async setup(commands: CommandSetBuilder) {
-        this.skill_role_log = await this.utilities.get_channel(this.wheatley.channels.skill_role_log);
         this.staff_member_log = await this.utilities.get_channel(this.wheatley.channels.staff_member_log);
     }
 
@@ -85,20 +81,13 @@ export default class RoleManager extends BotComponent {
             this.wheatley.roles.linked_github.id,
         ]);
 
-        this.register_role_check(this.check_skill_roles.bind(this));
-        this.register_role_update_listener(new Set(skill_roles_order_id), this.check_for_skill_role_bump.bind(this));
-
         const check = () => {
             this.check_members().catch(this.wheatley.critical_error.bind(this.wheatley));
         };
         check();
         this.interval = set_interval(check, HOUR);
     }
 
-    get_highest_skill_role(roles: string[]) {
-        return skill_roles_order_id.filter(id => roles.includes(id)).at(-1) ?? null;
-    }
-
     async check_member_roles(member: Discord.GuildMember) {
         for (const check of this.role_checks) {
             await check(member);
@@ -108,10 +97,9 @@ export default class RoleManager extends BotComponent {
         const diff = old_roles?.symmetricDifference(current_roles);
         if (diff === undefined || diff.size > 0) {
             const role_ids = current_roles.map(role => role.id);
-            const skill_role = this.get_highest_skill_role(member.roles.cache.map(role => role.id));
             await this.database.user_roles.findOneAndUpdate(
                 { user_id: member.id },
-                { $set: skill_role ? { roles: role_ids, last_known_skill_role: skill_role } : { roles: role_ids } },
+                { $set: { roles: role_ids } },
                 { upsert: true },
             );
             const new_roles = new Set(role_ids);
@@ -124,53 +112,6 @@ export default class RoleManager extends BotComponent {
         }
     }
 
-    async check_skill_roles(member: Discord.GuildMember) {
-        const skill_roles = member.roles.cache.filter(role =>
-            Object.values(this.wheatley.skill_roles).some(skill_role => role.id == skill_role.id),
-        );
-        if (skill_roles.size > 1) {
-            M.log("removing duplicate skill roles for", member.user.tag);
-            skill_roles.sort((a, b) => b.rawPosition - a.rawPosition);
-            M.debug(skill_roles.map(x => x.name));
-            M.debug(skill_roles.map(x => x.name).slice(1));
-            for (const role of skill_roles.map(x => x).slice(1)) {
-                await member.roles.remove(role);
-            }
-        }
-    }
-
-    async check_for_skill_role_bump(member: Discord.GuildMember) {
-        const roles_entry = await this.database.user_roles.findOne({ user_id: member.id });
-        const last_known_skill_level =
-            roles_entry && roles_entry.last_known_skill_role
-                ? this.wheatley.get_skill_role_index(roles_entry.last_known_skill_role)
-                : -1;
-        const current_skill_role = this.get_highest_skill_role(member.roles.cache.map(role => role.id));
-        const current_skill_level = current_skill_role ? this.wheatley.get_skill_role_index(current_skill_role) : -1;
-        if (
-            current_skill_level > skill_roles_order.indexOf("beginner") &&
-            current_skill_level > last_known_skill_level
-        ) {
-            assert(current_skill_role);
-            M.log("Detected skill level increase for", member.user.tag);
-            await this.skill_role_log.send({
-                embeds: [
-                    new Discord.EmbedBuilder()
-                        .setAuthor({
-                            name: member.displayName,
-                            iconURL: member.displayAvatarURL(),
-                        })
-                        .setColor(unwrap(await this.wheatley.guild.roles.fetch(current_skill_role)).color)
-                        .setDescription(
-                            roles_entry?.last_known_skill_role
-                                ? `<@&${roles_entry.last_known_skill_role}> -> <@&${current_skill_role}>`
-                                : `<@&${current_skill_role}>`,
-                        ),
-                ],
-            });
-        }
-    }
-
     async check_members() {
         M.log("Starting role checks");
         try {

src/modules/tccpp/components/anti-screenshot.ts

@@ -103,9 +103,8 @@ export default class AntiScreenshot extends BotComponent {
     async anti_screenshot(starter_message: Discord.Message, thread: Discord.ThreadChannel) {
         await delay(1000);
         assert(starter_message);
-        assert(starter_message.member);
-        // trust people with skill roles
-        if (this.wheatley.has_skill_roles_other_than_beginner(starter_message.member)) {
+        // trust established members
+        if (await this.wheatley.is_established_member(starter_message.author)) {
             return;
         }
         // check if it has images and no code

src/modules/tccpp/components/establishment.ts

@@ -0,0 +1,34 @@
+import * as Discord from "discord.js";
+import { unwrap } from "../../../utils/misc.js";
+import { M } from "../../../utils/debugging-and-logging.js";
+import { BotComponent } from "../../../bot-component.js";
+import RoleManager from "../../../components/role-manager.js";
+import { CommandSetBuilder } from "../../../command-abstractions/command-set-builder.js";
+import SkillRoles from "./skill-roles.js";
+
+export default class TheEstablishment extends BotComponent {
+    // private established_role!: Discord.Role;
+
+    override async setup(commands: CommandSetBuilder) {
+        // const role_manager = unwrap(this.wheatley.components.get("RoleManager")) as RoleManager;
+        // role_manager.register_role_check(this.check_established.bind(this));
+        this.wheatley.is_established_member = this.is_established_member.bind(this);
+    }
+
+    private async is_established_member(
+        options: Discord.GuildMember | Discord.User | Discord.UserResolvable | Discord.FetchMemberOptions,
+    ) {
+        const member = await this.wheatley.try_fetch_guild_member(options);
+        if (!member) {
+            return false;
+        }
+        return (
+            SkillRoles.find_highest_skill_role_index(member.roles.cache) > 0 ||
+            member.premiumSince != null ||
+            member.permissions.has(Discord.PermissionFlagsBits.MuteMembers) ||
+            member.permissions.has(Discord.PermissionFlagsBits.ModerateMembers)
+        );
+    }
+
+    // private async check_established(member: Discord.GuildMember) {}
+}

src/modules/tccpp/components/formatting-error-detection.ts

@@ -5,6 +5,7 @@ import { strict as assert } from "assert";
 import { M } from "../../../utils/debugging-and-logging.js";
 import { colors, MINUTE } from "../../../common.js";
 import { BotComponent } from "../../../bot-component.js";
+import SkillRoles from "./skill-roles.js";
 import { build_description, parse_out } from "../../../utils/strings.js";
 import Code from "../../../components/code.js";
 import { SelfClearingMap, SelfClearingSet } from "../../../utils/containers.js";
@@ -121,10 +122,8 @@ export default class FormattingErrorDetection extends BotComponent {
     }
 
     has_likely_format_errors(message: Discord.Message) {
-        const has_skill_roles_other_than_beginner = message.member
-            ? this.wheatley.has_skill_roles_other_than_beginner(message.member)
-            : false;
-        if (has_skill_roles_other_than_beginner) {
+        // trust Proficient+ members
+        if (message.member && SkillRoles.find_highest_skill_role_index(message.member.roles.cache) >= 2) {
             return false;
         }
         return FormattingErrorDetection.has_likely_format_errors(message.content);

src/modules/tccpp/components/permissions-manager.ts

@@ -7,6 +7,7 @@ import { HOUR } from "../../../common.js";
 import { BotComponent } from "../../../bot-component.js";
 import { Wheatley } from "../../../wheatley.js";
 import { unwrap } from "../../../utils/misc.js";
+import { skill_role_ids } from "./skill-roles.js";
 
 const categories_map = {
     staff_logs: "1135927261472755712",
@@ -138,10 +139,10 @@ export default class PermissionManager extends BotComponent {
                 deny: [...acive_voice_permissions, SET_VOICE_STATUS_PERMISSION_BIT],
             },
             [this.wheatley.roles.voice.id]: { allow: acive_voice_permissions },
-            [this.wheatley.skill_roles.intermediate.id]: { allow: acive_voice_permissions },
-            [this.wheatley.skill_roles.proficient.id]: { allow: acive_voice_permissions },
-            [this.wheatley.skill_roles.advanced.id]: { allow: acive_voice_permissions },
-            [this.wheatley.skill_roles.expert.id]: { allow: acive_voice_permissions },
+            [skill_role_ids[1]]: { allow: acive_voice_permissions },
+            [skill_role_ids[2]]: { allow: acive_voice_permissions },
+            [skill_role_ids[3]]: { allow: acive_voice_permissions },
+            [skill_role_ids[4]]: { allow: acive_voice_permissions },
             [this.wheatley.roles.server_booster.id]: { allow: acive_voice_permissions },
             [this.wheatley.roles.no_voice.id]: no_interaction_at_all,
             [this.wheatley.roles.no_off_topic.id]: no_interaction_at_all,