miscord-beta/dist/ConnectionsManager.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const discord_js_1 = require("discord.js");
const Connection_1 = __importDefault(require("./Connection"));
const messenger_1 = require("./messenger");
class CMError extends Error {
}
exports.CMError = CMError;
class ConnectionsManager {
    constructor() {
        this.list = new discord_js_1.Collection();
    }
    async load() {
        const log = logger.withScope('CM:init');
        try {
            // load file and parse YAML
            let parsed = await config.loadConnections();
            if (!parsed || typeof parsed !== 'object')
                return this.save();
            for (let [name, endpoints] of Object.entries(parsed)) {
                log.trace(name, endpoints);
                if (name.startsWith('_'))
                    continue;
                if (!Array.isArray(endpoints) ||
                    endpoints.some(el => typeof el !== 'object'))
                    throw new CMError(`Incorrect connection syntax: ${name}`);
                this.list.set(name, new Connection_1.default(name, await ConnectionsManager.validateEndpoints(endpoints)));
            }
            await this.save();
        }
        catch (err) {
            if (err.code !== 'ENOENT')
                throw err;
            await this.save();
        }
    }
    static async validateEndpoints(endpoints) {
        const newEndpoints = [];
        for (let endpoint of endpoints) {
            if (!endpoint.type || !endpoint.id)
                throw new CMError(`Type or ID missing on endpoint: ${JSON.stringify(endpoint)}`);
            if (endpoint.type !== 'discord' && endpoint.type !== 'messenger') {
                throw new CMError(`Endpoint type incorrect, should be 'messenger' or 'discord', actual: ${endpoint.type}`);
            }
            if (typeof endpoint.id !== 'string')
                throw new CMError(`Endpoint ID is not a string (wrap it in single quotes): ${endpoint.id}`);
            if (endpoint.type === 'discord' && !discord.client.channels.get(endpoint.id))
                throw new CMError(`Channel ${endpoint.id} not found!`);
            if (endpoint.type === 'messenger') {
                try {
                    await messenger_1.getThread(endpoint.id);
                }
                catch (err) {
                    throw new CMError(`Thread ${endpoint.id} not found!`);
                }
            }
            if (endpoint.name) {
                newEndpoints.push(endpoint);
                continue;
            }
            endpoint.name = endpoint.type === 'discord'
                ? discord.client.channels.get(endpoint.id).name
                : (await messenger_1.getThread(endpoint.id)).name;
            newEndpoints.push(endpoint);
        }
        return newEndpoints;
    }
    static async createAutomaticDiscordChannel(threadID, name) {
        const log = logger.withScope('CM:createAutomaticDiscordChannel');
        // create new channel with specified name and set its parent
        const channel = await discord.guilds[0].createChannel(name, 'text');
        await channel.overwritePermissions(discord.guilds[0].roles.find(role => role.name === '@everyone').id, { VIEW_CHANNEL: false });
        log.debug(`Channel created, name: ${name}, id: ${channel.id}`);
        // set category if it's in the same guild
        if (discord.category && discord.category.guild.id === channel.guild.id)
            await channel.setParent(discord.category);
        // save newly created channel in the channels map
        const connection = new Connection_1.default(name)
            .addChannel({ id: channel.id, name })
            .addThread({ id: threadID.toString(), name });
        await connection.save();
        log.trace('new connection', connection, 1);
        return connection;
    }
    async getWithCreateFallback(threadID, name) {
        const log = logger.withScope('CM:getWithCreateFallback');
        let connection = this.getWith(threadID);
        if (!connection) {
            if (!config.discord.createChannels)
                return log.debug(`Channel creation disabled, ignoring. Name: ${name}, id: ${threadID}`);
            connection = await ConnectionsManager.createAutomaticDiscordChannel(threadID, name);
        }
        return connection;
    }
    getWith(id) {
        return this.list.find(connection => connection.has(id));
    }
    get(name) {
        return this.list.get(name);
    }
    has(id) {
        return this.list.some(connection => connection.has(id));
    }
    save() {
        const yamlConnections = Object.assign({
            __comment: 'This is your connections.yml file. More info at https://github.com/miscord/miscord/wiki/Connections.yml'
        }, ...this.list.map(connection => connection.toYAMLObject()));
        return config.saveConnections(yamlConnections);
    }
}
exports.default = ConnectionsManager;