blapi/dist/blapi.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
var bttps_1 = require("./bttps");
var fallbackListData_1 = require("./fallbackListData");
var listData; // TODO add type
var listAge = new Date();
var extendedLogging = false;
var useBotblockAPI = true;
/**
 * @param apiKeys A JSON object formatted like: {"botlist name":"API Keys for that list", etc.} ;
 * it also includes other metadata including sharddata
 */
function postToAllLists(apiKeys) {
    return __awaiter(this, void 0, void 0, function () {
        var currentDate, tmpListData, e_1;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    currentDate = new Date();
                    if (!(!listData || listAge < currentDate)) return [3 /*break*/, 4];
                    // we try to update the listdata every day
                    // in case new lists are added but the code is not restarted
                    listAge.setDate(currentDate.getDate() + 1);
                    _a.label = 1;
                case 1:
                    _a.trys.push([1, 3, , 4]);
                    return [4 /*yield*/, bttps_1.get('https://botblock.org/api/lists')];
                case 2:
                    tmpListData = _a.sent();
                    // make sure we only save it if nothing goes wrong
                    if (tmpListData) {
                        listData = tmpListData;
                    }
                    else {
                        throw new Error('Got empty list from botblock.');
                    }
                    return [3 /*break*/, 4];
                case 3:
                    e_1 = _a.sent();
                    console.error("BLAPI: " + e_1);
                    console.error("BLAPI : Something went wrong when contacting BotBlock for the API of the lists, so we're using an older preset. Some lists might not be available because of this.");
                    return [3 /*break*/, 4];
                case 4:
                    Object.entries(listData).forEach(function (_a) {
                        var listname = _a[0];
                        if (apiKeys[listname]
                            && (listData[listname].api_post || listname === 'discordbots.org')) {
                            // we even need to check this extra because botblock gives us nulls back
                            var list = listData[listname];
                            if (listname === 'discordbots.org') {
                                list = fallbackListData_1.fallbackData[listname];
                            }
                            var apiPath = list.api_post.replace(':id', apiKeys.bot_id);
                            // creating JSON object to send, reading out shard data
                            var sendObj = {}; // TODO type
                            sendObj[list.api_field] = apiKeys.server_count;
                            if (apiKeys.shard_id && list.api_shard_id) {
                                sendObj[list.api_shard_id] = apiKeys.shard_id;
                            }
                            if (apiKeys.shard_count && list.api_shard_count) {
                                sendObj[list.api_shard_count] = apiKeys.shard_count;
                            }
                            if (apiKeys.shards && list.api_shards) {
                                sendObj[list.api_shards] = apiKeys.shards;
                            }
                            bttps_1.post(apiPath, apiKeys[listname], sendObj, extendedLogging).catch(function (e) { return console.error("BLAPI: " + e); });
                        }
                    });
                    return [2 /*return*/];
            }
        });
    });
}
/**
 * @param client Discord.js client
 * @param apiKeys A JSON object formatted like: {"botlist name":"API Keys for that list", etc.}
 * @param repeatInterval Number of minutes between each repetition
 */
function handleInternal(client, apiKeys, repeatInterval) {
    return __awaiter(this, void 0, void 0, function () {
        var unchanged, _, shardCounts, e_2, newApiKeys;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    setTimeout(/* eslint-disable-next-line @typescript-eslint/no-misused-promises */ handleInternal.bind(null, client, apiKeys, repeatInterval), 60000 * repeatInterval); // call this function again in the next interval
                    if (!client.user) return [3 /*break*/, 7];
                    /* eslint-disable camelcase */
                    apiKeys.bot_id = client.user.id;
                    if (!(client.shard && client.shard.id === 0)) return [3 /*break*/, 5];
                    apiKeys.shard_count = client.shard.count;
                    _a.label = 1;
                case 1:
                    _a.trys.push([1, 3, , 4]);
                    return [4 /*yield*/, client.shard.broadcastEval('this.guilds.size')];
                case 2:
                    _ = _a.sent();
                    shardCounts = _.filter(function (count) { return count !== 0; });
                    if (shardCounts.length !== client.shard.count) {
                        // If not all shards are up yet, we skip this run of handleInternal
                        return [2 /*return*/];
                    }
                    apiKeys.shards = shardCounts;
                    apiKeys.server_count = apiKeys.shards.reduce(function (prev, val) { return prev + val; }, 0);
                    return [3 /*break*/, 4];
                case 3:
                    e_2 = _a.sent();
                    console.error('BLAPI: Error while fetching shard server counts:', e_2);
                    return [3 /*break*/, 4];
                case 4: return [3 /*break*/, 6];
                case 5:
                    if (!client.shard) {
                        /*
                           else if (client.ws && client.ws.shards) {
                            apiKeys.shard_count = client.ws.shards.size;
                            // Get array of shards
                            const shardCounts:Array<number> = [];
                            client.ws.shards.forEach(shard => {
                              let count = 0;
                              client.guilds.forEach(g => {
                                if (g.shardID === shard.id) count++;
                              });
                              shardCounts.push(count);
                            });
                            if (shardCounts.length !== client.ws.shards.size) {
                              // If not all shards are up yet, we skip this run of handleInternal
                              console.log(
                                "BLAPI: Not all shards are up yet, so we're skipping this run."
                              );
                              return;
                            }
                            apiKeys.shards = shardCounts;
                            apiKeys.server_count = apiKeys.shards.reduce(
                              (prev:number, val:number) => prev + val,
                              0
                            );
                            // Check if bot is not sharded at all, but still wants to send server count
                            // (it's recommended to shard your bot, even if it's only one shard)
                          } */
                        /* eslint-disable-next-line no-param-reassign */
                        apiKeys.server_count = client.guilds.size;
                    }
                    else {
                        unchanged = true;
                    } // nothing has changed, therefore we don't send any data
                    _a.label = 6;
                case 6:
                    if (!unchanged) {
                        if (repeatInterval > 2 && useBotblockAPI) {
                            // if the interval isnt below the BotBlock ratelimit, use their API
                            bttps_1.post('https://botblock.org/api/count', 'no key needed for this', apiKeys, extendedLogging).catch(function (e) { return console.error("BLAPI: " + e); });
                            // they blacklisted botblock, so we need to do this, posting their stats manually
                            if (apiKeys['discordbots.org']) {
                                newApiKeys = {};
                                newApiKeys.bot_id = apiKeys.bot_id;
                                newApiKeys['discordbots.org'] = apiKeys['discordbots.org'];
                                newApiKeys.server_count = apiKeys.server_count;
                                if (apiKeys.shard_count) {
                                    newApiKeys.shard_count = apiKeys.shard_count;
                                }
                                if (apiKeys.shards) {
                                    newApiKeys.shards = apiKeys.shards;
                                }
                                postToAllLists(newApiKeys);
                            }
                        }
                        else {
                            postToAllLists(apiKeys);
                        }
                    }
                    return [3 /*break*/, 8];
                case 7:
                    console.error("BLAPI : Discord client seems to not be connected yet, so we're skipping this run of the post. We will try again in " + repeatInterval + " minutes.");
                    _a.label = 8;
                case 8: return [2 /*return*/];
            }
        });
    });
}
/**
 * This function is for automated use with discord.js
 * @param discordClient Client via wich your code is connected to Discord
 * @param apiKeys A JSON object formatted like: {"botlist name":"API Keys for that list", etc.}
 * @param repeatInterval Number of minutes until you want to post again, leave out to use 30
 */
function handle(discordClient, apiKeys, repeatInterval) {
    // handle inputs
    /* eslint-disable-next-line no-param-reassign */
    if (!repeatInterval || repeatInterval < 1)
        repeatInterval = 30;
    return handleInternal(discordClient, apiKeys, repeatInterval);
}
exports.handle = handle;
/**
 * For when you don't use discord.js or just want to post to manual times
 * @param guildCount Integer value of guilds your bot is serving
 * @param botID Snowflake of the ID the user your bot is using
 * @param apiKeys A JSON object formatted like: {"botlist name":"API Keys for that list", etc.}
 * @param shardID (optional) The shard ID, which will be used to identify the
 * shards valid for posting
 * (and for super efficient posting with BLAPIs own distributer when not using botBlock)
 * @param shardCount (optional) The number of shards the bot has, which is posted to the lists
 * @param shards (optional) An array of guild counts of each single shard
 *  (this should be a complete list, and only a single shard will post it)
 */
function manualPost(guildCount, botID, apiKeys, shardID, shardCount, shards) {
    /* eslint-disable no-param-reassign */
    apiKeys.bot_id = botID;
    apiKeys.server_count = guildCount;
    // check if we want to use sharding
    if (shardID === 0 || (shardID && !shards)) {
        // if we don't have all the shard info in one place well try to post every shard itself
        apiKeys.shard_id = shardID;
        apiKeys.shard_count = shardCount;
        if (shards) {
            if (shards.length !== shardCount) {
                console.error("BLAPI: Shardcount (" + shardCount + ") does not equal the length of the shards array (" + shards.length + ").");
                return;
            }
            apiKeys.shards = shards;
            apiKeys.server_count = apiKeys.shards.reduce(function (prev, val) { return prev + val; }, 0);
        }
        /* eslint-enable camelcase */
    }
    /* eslint-enable no-param-reassign */
    if (useBotblockAPI) {
        bttps_1.post('https://botblock.org/api/count', 'no key needed for this', apiKeys, extendedLogging).catch(function (e) { return console.error("BLAPI: " + e); });
    }
    else {
        postToAllLists(apiKeys);
    }
}
exports.manualPost = manualPost;
function setLogging(setLog) {
    extendedLogging = setLog;
}
exports.setLogging = setLogging;
function setBotblock(useBotblock) {
    useBotblockAPI = useBotblock;
}
exports.setBotblock = setBotblock;