yes

2025-08-14 16:15:16 +02:00
commit d2619420ef
27 changed files with 3497 additions and 0 deletions
@@ -0,0 +1,209 @@
+const { MongoClient, ServerApiVersion } = require('mongodb');
+require('dotenv').config();
+const uri = process.env.URI
+const delay = ms => new Promise(resolve => setTimeout(resolve, ms))
+const client = new MongoClient(uri, {
+    useNewUrlParser: true,
+    useUnifiedTopology: true,
+    serverApi: ServerApiVersion.v1
+});
+const expansions = new Map([
+    ["ARR", { "min": 0, "max": 50 }],
+    ["HW", { "min": 51, "max": 60 }],
+    ["SB", { "min": 61, "max": 70 }],
+    ["ShB", { "min": 71, "max": 80 }],
+    ["EW", { "min": 81, "max": 90 }],
+
+])
+
+async function getDutyData(interaction, database, user) {
+    var parameters = {
+        "type": interaction.options.getString('type'),
+        "min": interaction.options.getInteger('minlevel'),
+        "max": interaction.options.getInteger('maxlevel'),
+        "expansion": interaction.options.getString('expansion')
+    }
+    if (!parameters.type) {
+        //no type specified, randomizing...
+        database.listCollections().toArray(function (err, results) {
+            if (err) throw err;
+            let random = Math.floor(Math.random() * results.length)
+            parameters.type = results[random].name
+        })
+    }
+
+    if (parameters.expansion) {
+        //check if paramters are set correctly
+        if (!parameters.min) {
+            parameters.min = expansions.get(parameters.expansion).min
+        }
+        if (parameters.min < expansions.get(parameters.expansion).min) {
+            return console.log("mismatch min level and expansion")
+        }
+
+        if (!parameters.max) {
+            parameters.max = expansions.get(parameters.expansion).max
+        }
+        if (parameters.max > expansions.get(parameters.expansion).max) {
+            return console.log("mismatch max level and expansion")
+        }
+    } else {
+        if (!parameters.min) { parameters.min = 0 }
+        if (!parameters.max) { parameters.max = 90 }
+    }
+
+    if (parameters.type == 'pvp') {
+        parameters.expansion = 'ARR'
+        parameters.min = expansions.get(parameters.expansion).min
+        parameters.max = expansions.get(parameters.expansion).max
+    }
+
+    await delay(500) //wait for updates
+    database.collection(parameters.type).find({
+        level: { '$gte': parameters.min, '$lte': parameters.max }
+    }).toArray(async function (err, results2) {
+        let random = Math.floor(Math.random() * results2.length)
+        try {
+            let duty = results2[random]
+            let reply = `<@${user.id}>, Thou shalt playeth...${duty.name} [Level: ${duty.level}, Type: ${parameters.type}`
+            if (duty.expansion) {
+                reply += `, Expansion: ${duty.expansion}]`
+            } else {
+                reply += ']'
+            }
+
+            interaction.reply({
+                content: reply
+            })
+        } catch (error) {
+            interaction.reply({
+                content: `WAA!! (Impossible Combination found)`
+            })
+        }
+    })
+}
+async function getClassData(interaction, database, user) {
+    var collection = interaction.options.getString('type')
+    if (!collection) {
+        //no type specified
+        database.listCollections().toArray(function (err, cResults) {
+            let rdm = Math.floor(Math.random() * cResults.length)
+            collection = cResults[rdm].name
+        })
+    }
+
+    await delay(200) //wait for database.listCollections()
+
+    database.collection(collection).find({}).toArray(async function (err, results) {
+        if (err) throw err;
+        var response
+        try {
+            let rdm = Math.floor(Math.random() * results.length)
+            response = `<@${user.id}>, Thou shalt playeth...${results[rdm].job}`
+        } catch (error) {
+            response = 'Invalid Type specified!'
+        }
+        interaction.reply({
+            content: response,
+        })
+    })
+}
+module.exports = {
+    category: 'Random',
+    description: 'randomized helper', // Required for slash commands
+    slash: true, // Create both a slash and legacy command
+    options: [
+        {
+            name: "duty",
+            type: 1,
+            description: "random duty",
+            options: [
+                {
+                    name: 'type',
+                    description: 'what kind of duty would you like?',
+                    required: false,
+                    type: 3,
+                    choices: [
+                        { "name": 'Dungeons', "value": "dungeons" },
+                        { "name": 'Guildhests', "value": "guildhests" },
+                        { "name": 'PvP', "value": "pvp" },
+                        { "name": 'Normal Raids', "value": "nraids" },
+                        { "name": 'Alliance Raids', "value": "araids" },
+                        { "name": 'Trials', "value": "trials" },
+                        { "name": 'Extreme', "value": "extreme" },
+                        { "name": 'Savage', "value": "savage" },
+                        { "name": 'Ultimates', "value": "ultimates" },
+                        { "name": 'Roulettes', "value": "roulettes" },
+                    ],
+                },
+                {
+                    name: 'minlevel',
+                    description: 'Start of Level Range, assuming 0 if not specified',
+                    required: false,
+                    type: 4,
+                },
+                {
+                    name: 'maxlevel',
+                    description: 'End of Level Range, assuming 90 if not specified',
+                    required: false,
+                    type: 4,
+                },
+                {
+                    name: 'expansion',
+                    description: 'which expansion would you like?',
+                    required: false,
+                    type: 3,
+                    choices: [
+                        { "name": 'A Realm Reborn', "value": "ARR" },
+                        { "name": 'Heavensward', "value": "HW" },
+                        { "name": 'Stormblood', "value": "SB" },
+                        { "name": 'Shadowbringers', "value": "ShB" },
+                        { "name": 'Endwalker', "value": "EW" },
+                    ],
+                }
+            ],
+        },
+        {
+            name: "class",
+            type: 1,
+            description: "random class",
+            options: [
+                {
+                    name: 'type',
+                    description: 'specify class',
+                    required: false,
+                    type: 3,
+                    choices: [
+                        { "name": 'Healer', "value": "healer" },
+                        { "name": 'Tank', "value": "tank" },
+                        { "name": 'Melee', "value": "melee" },
+                        { "name": 'Ranged', "value": "ranged" },
+                        { "name": 'Caster', "value": "caster" },
+                    ],
+                }
+            ]
+        }
+
+    ],
+    callback: ({ interaction, user }) => {
+        switch (interaction.options._subcommand) {
+            case "duty":
+                client.connect(function (err, db) {
+                    if (err) throw err;
+
+                    var dbDuties = db.db("Duties")
+                    getDutyData(interaction, dbDuties, user)
+                })
+                break;
+            case "class":
+                client.connect(async function (err, db) {
+                    if (err) throw err;
+
+                    var dbClasses = db.db("Classes")
+                    getClassData(interaction, dbClasses, user)
+                })
+            default:
+                break;
+        }
+    },
+}