discord js (#1)

* clear out fluxer.net

* basic discord.js bot with ping, and echo

* added creation of webhook

* simplifying webhook logic

* sending messages as webhook

* deleting orignal message

* adding sequelize file

* commented out pgadmin part while it's not working

* adding member sort of working

* changing names of values

* updating names of values and adding new method in memberHelper

* renamed messagehelper function

* deleted proxyhelper

* passed only channel id into webhook helper methods

* added new functions and got update working

* changed message match to better reducer

* adjusted webhook helper to use actual data

* refactored bot.js and removed unused methods

helpers/memberHelper.js

@@ -0,0 +1,137 @@
+import { db } from '../sequelize.js';
+
+const mh = {};
+
+const errorEnums = {
+    NO_MEMBER: "No member was found.",
+    NO_NAME_PROVIDED: "No member name was provided for",
+    NO_VALUE: "has not been set for this member.",
+    ADD_ERROR: "Error adding member.",
+    MEMBER_EXISTS: "A member with that name already exists.",
+    USER_NO_MEMBERS: "You have no members created."
+}
+
+mh.parse_member_command = async function(author_id, args){
+    console.log(author_id, args);
+    if (!args) {
+        return `${errorEnums.NO_NAME_PROVIDED} querying.`
+    }
+    switch(args[0]) {
+        case 'new':
+            return await add_new_member(author_id, args);
+        case 'delete':
+            return await delete_member(author_id, args);
+    }
+    switch(args[1]) {
+        case 'displayname':
+            return await set_display_name(author_id, args);
+        // case 'proxy':
+        //     return await set_proxy(author_id, args);
+        // case 'avatar':
+        //     return await set_avatar(author_id, args)
+        default:
+            return await get_member_info(author_id, args);
+    }
+}
+
+async function add_new_member(author_id, args) {
+    const member_name = args[1];
+    const display_name = args[2];
+    const proxy = args[3];
+    const propic = args[4];
+    if (!member_name) {
+        return `${errorEnums.NO_NAME_PROVIDED} adding.`;
+    }
+    const member = await get_member_info(author_id, member_name);
+    if (member !== errorEnums.NO_MEMBER) {
+        return errorEnums.MEMBER_EXISTS;
+    }
+    const trimmed_name = display_name ? display_name.replaceAll(' ', '') : null;
+    const trimmed_proxy = proxy ? proxy.trim() : null;
+    return await db.members.create({
+        name: member_name,
+        userid: author_id,
+        displayname: trimmed_name !== null ? display_name : null,
+        proxy: trimmed_proxy,
+        propic: propic
+    }).then((m) => {
+        let success = `Member was successfully added.\nName: ${m.dataValues.name}`
+        success += display_name ? `\nDisplay name: ${m.dataValues.displayname}` : "";
+        success += proxy ? `\nProxy tag: ${m.dataValues.proxy} `: "";
+        success += propic ? `\nProfile picture: ${m.dataValues.proxy} `: "";
+        return success;
+    }).catch(e => {
+        return `${errorEnums.ADD_ERROR}: ${e.message}`;
+    })
+}
+
+async function get_member_info(author_id, member_name) {
+    let member = await db.members.findOne({ where: { name: member_name, userid: author_id } });
+    if (member) {
+        let member_info = `Member name: ${member.name}`;
+        member_info += member.displayname ? `\nDisplay name: ${member.displayname}` : '\nDisplay name: unset';
+        member_info += member.proxy ? `\nProxy Tag: ${member.proxy}` : '\nProxy tag: unset';
+        member_info += member.propic ? `\nProfile pic: ${member.propic}` : '\nProfile pic: unset';
+        return member_info;
+    }
+    return errorEnums.NO_MEMBER;
+}
+
+async function set_display_name(author_id, args) {
+    const member_name = args[0];
+    const display_name = args[2];
+    const trimmed_name = display_name ? display_name.replaceAll(' ', '') : null;
+    console.log(trimmed_name, display_name);
+    if (!member_name) {
+        return `${errorEnums.NO_NAME_PROVIDED} display name.`;
+    }
+    else if (!display_name || trimmed_name === null ) {
+        let member = await get_member_info(author_id, args);
+        console.log(member.displayname);
+        if (member.displayname) {
+            return `Display name for ${member_name} is: ${member.displayname}.`;
+        }
+        return `Display name ${errorEnums.NO_VALUE}`
+    }
+    console.log(display_name);
+    return await update_member(author_id, args);
+}
+
+async function update_member(author_id, args) {
+    const member_name = args[0];
+    const column_Name = args[1];
+    const value = args[2];
+    return await db.members.update({[column_Name]: value}, { where: { name: member_name, userid: author_id } }).then(() => {
+        return `Updated ${column_Name} for ${member_name} to ${value}`;
+    }).catch(e => {
+        return `${errorEnums.NO_MEMBER}: ${e.message}`;
+    });
+}
+
+async function delete_member(author_id, args) {
+    const member_name = args[1];
+    if (!member_name) {
+        return `${errorEnums.NO_NAME_PROVIDED} deletion.`;
+    }
+    return await db.members.destroy({ where: { name: member_name, userid: author_id } }).then(() => {
+        return `${member_name} has been deleted.`;
+    }).catch(e => {
+        return `${errorEnums.NO_MEMBER}: ${e.message}`;
+    });
+}
+
+mh.get_member_by_proxy = async function(author_id, proxy) {
+    return await db.members.findOne({ where: { userid: author_id, proxy: proxy } }).catch(e => {
+        return `${errorEnums.NO_MEMBER}: ${e.message}`;
+    });
+}
+
+mh.get_members_by_author = async function(author_id) {
+    return await db.members.findAll({ where: { userid: author_id } }).catch(e => {
+        // I have no idea how this could possibly happen but better safe than sorry
+        return `${errorEnums.USER_NO_MEMBERS}: ${e.message}`;
+    });
+}
+
+
+export const memberHelper = mh;

helpers/messageHelper.js

@@ -0,0 +1,37 @@
+import {memberHelper} from "./memberHelper.js";
+
+const msgh = {};
+
+msgh.prefix = "pf;"
+
+msgh.parse_command_args = function(text, command_name) {
+    const message = text.slice(msgh.prefix.length + command_name.length).trim();
+    // slices up message arguments including retaining quoted strings
+    return message.match(/\\?.|^$/g).reduce((accumulator, chara) => {
+        if (chara === '"') {
+            // checks whether string is within quotes or not
+            accumulator.quote ^= 1;
+        } else if (!accumulator.quote && chara === ' '){
+            // if not currently in quoted string, push empty string to start word
+            accumulator.array.push('');
+        } else {
+            // accumulates characters to the last string in the array and removes escape characters
+            accumulator.array[accumulator.array.length-1] += chara.replace(/\\(.)/,"$1");
+        }
+        return accumulator;
+    }, {array: ['']}).array // initial array with empty string for the reducer
+}
+
+msgh.parse_proxy_tags = async function (author_id, text){
+    const members = await memberHelper.get_members_by_author(author_id);
+    const proxyMessage = {}
+    members.forEach(member => {
+        if (text.startsWith(member.proxy) && text.length > member.proxy.length) {
+            proxyMessage.proxy = member.proxy;
+            proxyMessage.message = text.slice(member.proxy.length).trim();
+        }
+    })
+    return proxyMessage;
+}
+
+export const messageHelper = msgh;

helpers/webhookHelper.js

@@ -0,0 +1,37 @@
+const wh = {};
+
+wh.get_or_create_webhook = async function (api, channel_id) {
+    const name = 'PluralFlux Proxy Webhook';
+    let webhook = await get_webhook(api, channel_id, name);
+    if (webhook === undefined) {
+        webhook = await api.channels.createWebhook(channel_id, {name: name});
+    }
+    return webhook;
+}
+
+async function get_webhook(api, channel_id, name) {
+    const all_webhooks = await api.channels.getWebhooks(channel_id);
+    if (all_webhooks.length === 0) {
+        return;
+    }
+    let pf_webhook;
+    all_webhooks.forEach((webhook) => {
+        if (webhook.name === name) {
+            pf_webhook = webhook;
+        }
+    })
+    return pf_webhook;
+}
+
+wh.replace_message = async function (api, data, text, member) {
+    if (text.length > 0) {
+        const webhook = await wh.get_or_create_webhook(api, data.channel_id);
+        await api.webhooks.execute(webhook.id, webhook.token, {content: text, username: member.displayname ?? member.name, propic: member.propic});
+        await api.channels.deleteMessage(data.channel_id, data.id);
+    }
+    else {
+        await api.channels.createMessage(data.channel_id, {content: '(Please input a message!)'});
+    }
+}
+
+export const webhookHelper = wh;