Created Color-Me module

default-locales.json

@@ -400,6 +400,18 @@
     "status-role": {
       "fulfilled": "Status-role condition is fulfilled",
       "not-fulfilled": "Status-role condition is no longer fulfilled"
+    },
+    "color-me": {
+      "create-log-reason": "%user redeemed their boosting-rewards by requesting the creation of this role",
+      "edit-log-reason": "%user edited their boosting-reward-role",
+      "delete-unboost-log-reason": "%user stopped boosting, so their role got deleted",
+      "delete-manual-log-reason": "%user deleted their role manually",
+      "command-description": "Request a Custom role as a reward for boosting. This has a cooldown of 24 hours",
+      "manage-subcommand-description": "Create or edit your custom role",
+      "name-option-description": "The name of your custom role",
+      "color-option-description": "The color of your custom role",
+      "remove-subcommand-description": "Remove your custom role",
+      "confirm-option-remove-description": "Do you really want to delete your custom role? This will not reset any running cooldowns"
     }
   }
 }

modules/color-me/commands/color-me.js

@@ -0,0 +1,228 @@
+const {localize} = require('../../../src/functions/localize');
+const {client} = require('../../../main');
+const {embedType, dateToDiscordTimestamp} = require('../../../src/functions/helpers');
+let roleColor;
+let pos;
+let cooldownModel;
+let cancel = false;
+
+module.exports.beforeSubcommand = async function (interaction) {
+    await interaction.deferReply({ephemeral: true});
+};
+
+module.exports.subcommands = {
+    'manage': async function (interaction) {
+        const moduleConf = interaction.client.configurations['color-me']['config'];
+        const moduleStrings = interaction.client.configurations['color-me']['strings'];
+        const moduleModel = interaction.client.models['color-me']['Role'];
+
+        if (moduleConf.rolePosition) {
+            pos = interaction.guild.roles.resolve(moduleConf.rolePosition).position;
+        } else {
+            pos = 0;
+        }
+        if (await cooldown(moduleConf['updateCooldown'] * 3600000, interaction.user.id)) {
+            let role = await moduleModel.findOne({
+                attributes: ['roleID'],
+                raw: true,
+                where: {
+                    userID: interaction.user.id
+                }
+            });
+            if (role) {
+                role = role.roleID;
+                await color(interaction, moduleStrings);
+                if (cancel) return;
+                if (interaction.guild.roles.cache.find(r => r.id === role)) {
+                    role = interaction.guild.roles.resolve(role);
+                    role.edit(
+                        {
+                            name: interaction.options.getString('name'),
+                            color: roleColor,
+                            reason: localize('color-me', 'edit-log-reason', {
+                                user: interaction.user.username
+                            })
+                        }
+                    );
+                    await interaction.editReply(await embedType(moduleStrings['updated'], {}, { ephemeral: true }));
+                } else {
+                    if (interaction.guild.roles.cache.size < 250) {
+
+                        role = await interaction.guild.roles.create(
+                            {
+                                name: interaction.options.getString('name'),
+                                color: roleColor,
+                                hoist: moduleConf.listRoles,
+                                permissions: '',
+                                position: pos,
+                                mentionable: false,
+                                reason: localize('color-me', 'create-log-reason', {
+                                    user: interaction.user.username
+                                })
+                            }
+                        );
+                    } else {
+                        await interaction.editReply(await embedType(moduleStrings['roleLimit'], {}, { ephemeral: true }));
+                    }
+                    await moduleModel.update({
+                        userID: interaction.user.id,
+                        roleID: role.id,
+                        name: role.name,
+                        color: role.hexColor,
+                        timestamp: new Date()
+                    }, {
+                        where: {
+                            userID: interaction.user.id
+                        }
+                    });
+                    if (!interaction.member.roles.cache.has(role)) {
+                        await interaction.member.roles.add(role);
+                    }
+                    await interaction.editReply(await embedType(moduleStrings['updated'], {}, { ephemeral: true }));
+                }
+            } else {
+                await color(interaction, moduleStrings);
+                if (cancel) return;
+                try {
+                    role = await interaction.guild.roles.create(
+                        {
+                            name: interaction.options.getString('name'),
+                            color: roleColor,
+                            hoist: moduleConf.listRoles,
+                            permissions: '',
+                            position: pos,
+                            mentionable: false,
+                            reason: localize('color-me', 'create-log-reason', {
+                                user: interaction.user.username
+                            })
+                        }
+                    );
+                    await moduleModel.create({
+                        userID: interaction.user.id,
+                        roleID: role.id,
+                        name: role.name,
+                        color: role.hexColor,
+                        timestamp: new Date()
+                    });
+                    await interaction.member.roles.add(role);
+                    await interaction.editReply(await embedType(moduleStrings['created'], {}, { ephemeral: true }));
+                } catch (e) {
+                    await interaction.editReply(await embedType(moduleStrings['roleLimit'], {}, { ephemeral: true }));
+                }
+
+            }
+        } else {
+            cooldownModel = await moduleModel.findOne({
+                where: {
+                    userId: interaction.member.id
+                }
+            });
+            await interaction.editReply((await embedType(moduleStrings['cooldown'], {
+                '%cooldown%': dateToDiscordTimestamp(new Date(cooldownModel.timestamp.getTime() + moduleConf['updateCooldown'] * 3600000), 'R')
+            }, { ephemeral: true })));
+        }
+    },
+
+
+    'remove': async function (interaction) {
+        const moduleStrings = interaction.client.configurations['color-me']['strings'];
+        const moduleModel = interaction.client.models['color-me']['Role'];
+        let role = await moduleModel.findOne({
+            attributes: ['roleID'],
+            raw: true,
+            where: {
+                userID: interaction.member.id
+            }
+        });
+        if (role) {
+            role = role.roleID;
+            if (interaction.guild.roles.cache.find(r => r.id === role)) {
+                role = interaction.guild.roles.resolve(role);
+                role.delete(localize('color-me', 'delete-manual-log-reason', {
+                    user: interaction.member.user.username
+                }));
+                await interaction.editReply(await embedType(moduleStrings['removed'], {}, { ephemeral: true }));
+            }
+        }
+    }
+};
+
+module.exports.config = {
+    name: 'color-me',
+    description: localize('color-me', 'command-description'),
+    defaultPermission: false,
+    options: [
+        {
+            type: 'SUB_COMMAND',
+            name: 'manage',
+            description: localize('color-me', 'manage-subcommand-description'),
+            options: [
+                {
+                    type: 'STRING',
+                    required: true,
+                    name: 'name',
+                    description: localize('color-me', 'name-option-description')
+                },
+                {
+                    type: 'STRING',
+                    required: false,
+                    name: 'color',
+                    description: localize('color-me', 'color-option-description')
+                }
+            ]
+        },
+        {
+            type: 'SUB_COMMAND',
+            name: 'remove',
+            description: localize('color-me', 'remove-subcommand-description'),
+            options: [
+                {
+                    type: 'BOOLEAN',
+                    required: true,
+                    name: 'confirm',
+                    description: localize('color-me', 'confirm-option-remove-description')
+                }
+            ]
+        }
+    ]
+};
+
+/**
+ * Gets a color from the String of a command option
+ */
+async function color(interaction, moduleStrings) {
+    if (interaction.options.getString('color')) {
+        roleColor = interaction.options.getString('color');
+        if (!roleColor.startsWith('#')) {
+            roleColor = '#' + roleColor;
+        }
+        if (!(/^#[0-9A-F]{6}$/i).test(roleColor)) {
+            await interaction.editReply(await embedType(moduleStrings['invalidColor'], {}, { ephemeral: true }));
+            cancel = true;
+        }
+    } else {
+        roleColor = 'DEFAULT';
+    }
+}
+
+/**
+ ** Function to handle the cooldown stuff
+ * @private
+ * @param {integer} duration The duration of the cooldown (in ms)
+ * @param {userId} userId Id of the User
+ * @returns {Promise<boolean>}
+ */
+async function cooldown(duration, userId) {
+    const model = client.models['color-me']['Role'];
+    cooldownModel = await model.findOne({
+        where: {
+            userId: userId
+        }
+    });
+    if (cooldownModel) {
+        // check cooldown duration
+        return cooldownModel.timestamp.getTime() + duration <= Date.now();
+    } else {
+        return true;
+    }
+}

modules/color-me/configs/config.json

@@ -0,0 +1,54 @@
+{
+  "filename": "config.json",
+  "humanname-de": "Konfiguration",
+  "humanname-en": "Configuration",
+  "description-en": "Configure the function of the module here",
+  "description-de": "Stelle hier die Funktionen des Modules ein",
+  "content": [
+    {
+      "field_name": "recreateRole",
+      "humanname-en": "Recreate roles",
+      "humanname-de": "Rollen wiederherstellen",
+      "description-en": "Should the role be created again if the user boosts again?",
+      "description-de": "Soll die Rolle wiederhergestellt werden, wenn ein Nutzer erneut boostet?",
+      "type": "boolean",
+      "default": true
+    },
+    {
+      "field_name": "listRoles",
+      "humanname-en": "Separate roles in member-list",
+      "humanname-de": "Rollen in Mitgliederliste separieren",
+      "description-en": "Should the role be listed separately in the member-list?",
+      "description-de": "Soll die Rolle in der Mitgliederliste separat gelistet werden?",
+      "type": "boolean",
+      "default": false
+    },
+    {
+      "field_name": "removeOnUnboost",
+      "humanname-en": "Remove role on unboost",
+      "humanname-de": "Rolle bei Unboost entfernen",
+      "description-en": "Should the role be deleted automatically, if the user stops boosting your server? (disable, if also non-boosters should be able to use this command)",
+      "description-de": "Soll die Rolle automatisch gelöscht werden, wenn der Nutzer den Server nicht mehr boostet? (deaktivieren, wenn auch nicht-Booster den Befehl verwenden können sollen)",
+      "type": "boolean",
+      "default": false
+    },
+    {
+      "field_name": "updateCooldown",
+      "humanname-en": "Role update cooldown",
+      "humanname-de": "Rollenbearbeitungscooldown",
+      "description-en": "The amount of time a user needs to wait util they can edit their role again (in hours)",
+      "description-de": "Die Dauer, die Benutzer*innen warten müssen, bevor ihre Rolle wieder bearbeitet werden kann (in Stunden)",
+      "type": "integer",
+      "default": 24
+    },
+    {
+      "field_name": "rolePosition",
+      "humanname-en": "Role position",
+      "humanname-de": "Rollenposition",
+      "description-en": "The role, beneath which the custom-roles should be created",
+      "description-de": "Die Rolle unter welcher die Custom-Rollen erstellt werden sollen",
+      "type": "roleID",
+      "default": ""
+    }
+  ]
+}

modules/color-me/configs/strings.json

@@ -0,0 +1,86 @@
+{
+  "filename": "strings.json",
+  "humanname-de": "Nachrichten",
+  "humanname-en": "Messages",
+  "description-en": "Edit the messages and strings of the module here",
+  "description-de": "Stelle hier die Nachrichten des Modules ein",
+  "content": [
+    {
+      "field_name": "created",
+      "humanname-en": "Role created",
+      "humanname-de": "Rolle erstellt",
+      "default-en": "Your role was created successfully.",
+      "default-de": "Deine Rolle wurde erfolgreich erstellt.",
+      "type": "string",
+      "allowEmbed": true,
+      "description-en": "This messages gets send when a booster sucessfully created their custom role",
+      "description-de": "Diese Nachricht wird verschickt, wenn ein Booster seine/ihre Custom-Rolle erstellt hat",
+      "params-de": {}
+    },
+    {
+      "field_name": "updated",
+      "humanname-en": "Role updated",
+      "humanname-de": "Rolle aktualisiert",
+      "default-en": "Your role was updated successfully.",
+      "default-de": "Deine Rolle wurde erfolgreich aktualisiert.",
+      "type": "string",
+      "allowEmbed": true,
+      "description-en": "This messages gets send when a booster sucessfully updates their custom role",
+      "description-de": "Diese Nachricht wird verschickt, wenn ein Booster seine/ihre Custom-Rolle aktualisiert hat",
+      "params-de": {}
+    },
+    {
+      "field_name": "removed",
+      "humanname-en": "Role removed",
+      "humanname-de": "Rolle entfernt",
+      "default-en": "Your role was removed successfully.",
+      "default-de": "Deine Rolle wurde erfolgreich entfernt.",
+      "type": "string",
+      "allowEmbed": true,
+      "description-en": "This messages gets send when a booster deleted their custom role",
+      "description-de": "Diese Nachricht wird verschickt, wenn ein Booster seine/ihre Custom-Rolle entfernt hat",
+      "params-de": {}
+    },
+    {
+      "field_name": "roleLimit",
+      "humanname-en": "Role-limit reached",
+      "humanname-de": "Rollenlimit erreicht",
+      "default-en": "Your role couldn't be created. This could be, because this server has reached the maximum of roles set by Discord. Ask the staff to delete an unnecessary role to make space for your role or try again later.",
+      "default-de": "Deine Rolle konnte nicht erstellt werden. Das kann daran liegen, dass dieser Server die von Discord vorgegebene maximale Rollenzahl erreicht hat. Frag das Team nach der Löschung einer überflüssigen Rolle um Platz zu machen, oder versuche es später erneut.",
+      "type": "string",
+      "allowEmbed": true,
+      "description-en": "This messages gets send when a booster-role couldn't be created",
+      "description-de": "Diese Nachricht wird verschickt, wenn eine Booster-Rolle nicht erstellt werden konnte",
+      "params-de": {}
+    },
+    {
+      "field_name": "cooldown",
+      "humanname-en": "Cooldown",
+      "humanname-de": "Cooldown",
+      "default-en": "Your role couldn't be edited, since you have to wait until %cooldown% for the cooldown to expire.",
+      "default-de": "Deine Rolle konnte nicht bearbeitet werden, da du bis %cooldown% warten musst, dass der Cooldown abläuft.",
+      "type": "string",
+      "allowEmbed": true,
+      "description-en": "This messages gets send when a booster-role couldn't be edited, since the user is on cooldown",
+      "description-de": "Diese Nachricht wird verschickt, wenn eine Booster-Rolle nicht bearbeitet werden konnte, da der Nutzer den Cooldown abwarten muss",
+      "params-de": [
+        {
+      "name": "%cooldown%",
+      "description": "Timestamp the cooldown expires at"
+        }
+      ]
+    },
+    {
+      "field_name": "invalidColor",
+      "humanname-en": "Invalid Color",
+      "humanname-de": "Falsche Farbe",
+      "default-en": "The color you provided is not a valid HEX-Code.",
+      "default-de": "Die angegebene Farbe ist kein gültiger HEX-Code.",
+      "type": "string",
+      "allowEmbed": true,
+      "description-en": "This messages gets send when the user provides a wrong color code",
+      "description-de": "Diese Nachricht wird verschickt, wenn der Nutzer einen falschen Farbcode angibt",
+      "params-de": {}
+    }
+  ]
+}