@elara-services/leveling
Version:
A package for XP/Leveling on Discord.
895 lines • 76.6 kB
JavaScript
"use strict";
var _API_instances, _API_client, _API_displayUser, _API_getServer, _API_getSettings, _API_getUser, _API_handleIgnore;
Object.defineProperty(exports, "__esModule", { value: true });
exports.API = void 0;
const tslib_1 = require("tslib");
const utils_1 = require("@elara-services/utils");
const canvas_1 = require("../canvas");
const utils_2 = require("../utils");
const message = `Unable to find/create the user's profile.`;
const server_not_found = `Unable to find/create the server's data.`;
const toggle = (bool) => (bool ? `Enabled` : `Disabled`);
class API {
constructor(client) {
_API_instances.add(this);
_API_client.set(this, void 0);
tslib_1.__classPrivateFieldSet(this, _API_client, client, "f");
}
get servers() {
return {
/**
* Get a certain server's data
*/
get: async (guildId) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
return utils_1.status.data(data.toJSON());
},
setWebhook: async (guildId, options) => {
const r = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!r) {
return utils_1.status.error(server_not_found);
}
if (!utils_1.is.object(options)) {
return utils_1.status.error(`You didn't provide any options.`);
}
const change = [];
if (utils_1.is.string(options.name)) {
change.push(`[NAME]: Set to: ${options.name}`);
r.webhook.name = options.name;
}
else if (utils_1.is.null(options.name)) {
r.webhook.name = "";
change.push(`[NAME]: Reset`);
}
if (utils_1.is.string(options.image)) {
if (!options.image.match(/https:\/\/|.(png|jpg|webp|jpeg)/gi)) {
return utils_1.status.error(`Invalid image provided.`);
}
change.push(`[IMAGE]: Set to: ${options.image}`);
r.webhook.image = options.image;
}
else if (utils_1.is.null(options.image)) {
change.push(`[IMAGE]: Reset`);
r.webhook.image = "";
}
if (!utils_1.is.array(change)) {
return utils_1.status.error(`Nothing needed to be changed.`);
}
await (0, utils_2.save)(r);
return utils_1.status.success(`Updated the following:\n${change.join("\n")}`);
},
/**
* Fetch multiple servers data
*/
fetchAll: async (guildIds) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.settings
.find(utils_1.is.array(guildIds)
? {
guildId: {
$in: guildIds,
},
}
: {})
.lean()
.catch(() => []);
if (!utils_1.is.array(data)) {
return utils_1.status.error(`Unable to fetch any server data.`);
}
return utils_1.status.data(data);
},
/**
* Toggle on/off certain features for the server.
*/
toggle: async (guildId, type) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
if (type === "useWebhook") {
data.toggles.useWebhook = (0, utils_2.tog)(data.toggles.useWebhook);
await (0, utils_2.save)(data);
return utils_1.status.success(`${toggle(data.toggles.useWebhook)} useWebhook for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
if (type === "leveling") {
data.enabled = (0, utils_2.tog)(data.enabled);
await (0, utils_2.save)(data);
return utils_1.status.success(`${toggle(data.enabled)} leveling for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
else if (type === "resetOnLeave") {
data.toggles.resetOnLeave = (0, utils_2.tog)(data.toggles.resetOnLeave);
await (0, utils_2.save)(data);
return utils_1.status.success(`${toggle(data.toggles.resetOnLeave)} resetOnLeave for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
else if (type === "stackRoles") {
data.toggles.stackRoles = (0, utils_2.tog)(data.toggles.stackRoles);
await (0, utils_2.save)(data);
return utils_1.status.success(`${toggle(data.toggles.stackRoles)} stack roles for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
else if (type === "weeklyleaderboard") {
data.toggles.weekly.track = (0, utils_2.tog)(data.toggles.weekly.track);
await (0, utils_2.save)(data);
return utils_1.status.success(`${toggle(data.toggles.weekly.track)} weekly leaderboard for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
else if (type === "voice.xp") {
data.toggles.voice.xp = (0, utils_2.tog)(data.toggles.voice.xp);
await (0, utils_2.save)(data);
return utils_1.status.success(`${toggle(data.toggles.voice.xp)} voice earning for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
else if (type === "voice.unmutedRequired") {
data.toggles.voice.shouldBeUnmuted = (0, utils_2.tog)(data.toggles.voice.shouldBeUnmuted);
await (0, utils_2.save)(data);
return utils_1.status.success(`${toggle(data.toggles.voice.shouldBeUnmuted)} talking required for voice earning for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
else if (type === "weekly.announce") {
data.announce.weekly.enabled = (0, utils_2.tog)(data.announce.weekly.enabled);
await (0, utils_2.save)(data);
return utils_1.status.success(`${toggle(data.announce.weekly.enabled)} weekly leaderboard announcements for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
else if (type === "earnXPOnSlashCommands") {
data.toggles.earnXPOnSlashCommands = (0, utils_2.tog)(data.toggles.earnXPOnSlashCommands);
await (0, utils_2.save)(data);
return utils_1.status.success(`${toggle(data.toggles.earnXPOnSlashCommands)} earning XP for \`/\` commands for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
return utils_1.status.error(`You failed to provide any valid toggle options.`);
},
/**
* Set the cooldown for XP earned on a certain server or create a custom cooldown for certain roles.
* NOTE: This is in seconds!
*/
cooldown: async (guildId, seconds, roles) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const time = utils_1.ms.get(seconds * 1000, true);
const str = [];
if (utils_1.is.array(roles, false)) {
const changes = [];
const find = data.cooldowns.find((c) => c.seconds === seconds);
if (find) {
for (const role of roles) {
if (find.roles.includes(role)) {
changes.push(`- ${role}`);
find.roles = find.roles.filter((c) => c !== role);
}
else {
changes.push(`+ ${role}`);
find.roles.push(role);
}
}
if (!utils_1.is.array(find.roles)) {
data.cooldowns = data.cooldowns.filter((c) => c.seconds !== seconds);
}
}
else {
changes.push(...roles.map((c) => `+ ${c}`));
data.cooldowns.push({ seconds, roles });
}
str.push(`Set a custom cooldown (${time}) on ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)} and updated for the following roles:\n${changes.join("\n")}`);
}
else {
str.push(`Set the main cooldown (${time}) on ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
data.cooldown = seconds;
}
await (0, utils_2.save)(data);
return utils_1.status.success(str.join(" "));
},
/**
* Set the min/max XP earned for messages on a certain server.
*/
setXP: async (guildId, options) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const changes = [];
if (utils_1.is.number(options.min)) {
changes.push(`min (${options.min})`);
data.xp.min = options.min;
}
if (utils_1.is.number(options.max)) {
changes.push(`max (${options.max})`);
data.xp.max = options.max;
}
await (0, utils_2.save)(data);
return utils_1.status.success(`I've set the XP (${changes.join(", ")}) for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
weekly: {
/**
* Set/Reset a certain channel for the weekly leaderboard announcements
*/
setChannel: async (guildId, channelId) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
let reason = ``;
if (data.announce.weekly.channel === channelId) {
data.announce.weekly.channel = "";
reason = `I've reset the weekly announcement channel for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`;
}
else {
data.announce.weekly.channel = channelId;
reason = `I've set the weekly announcement channel to (${channelId}) for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`;
}
await (0, utils_2.save)(data);
return utils_1.status.success(reason);
},
/**
* Set/Reset weekly leaderboard ping roles
* These role(s) will get mentioned when a new weekly leaderboard is posted.
*/
setRoles: async (guildId, roles) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
let reason = "";
if (!utils_1.is.array(data.announce.weekly.roles)) {
reason = `Added (${roles.length}) roles to the weekly announcement ping roles to ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`;
data.announce.weekly.roles = roles;
}
else {
const arr = [];
for (const role of roles) {
if (data.announce.weekly.roles.includes(role)) {
arr.push(`- ${role}`);
data.announce.weekly.roles =
data.announce.weekly.roles.filter((c) => c !== role);
}
else {
arr.push(`+ ${role}`);
data.announce.weekly.roles.push(role);
}
}
if (utils_1.is.array(arr)) {
reason = `Updated the weekly announcement ping roles:\n${arr.join(" | ")} in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`;
}
}
await (0, utils_2.save)(data);
return utils_1.status.success(reason);
},
},
/**
* Import leaderboards from other bots
*/
import: async (guildId, targetGuildId, type = "amari") => {
const data = await (0, utils_2.fetchAllUsers)(targetGuildId, type);
if (!utils_1.is.array(data)) {
return utils_1.status.error(`Unable to find anyone from (${type}) bot that needed to be imported.`);
}
const newData = data.map((c) => ({
guildId,
userId: c.id,
level: c.level,
xp: c.level * c.level * 100,
color: "",
background: "",
stats: {
messages: c.messages,
voice: 0,
},
toggles: {
dms: true,
locked: false,
pings: true,
},
cooldowns: [],
}));
const dbs = await tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users
.find({ guildId })
.catch(console.error);
let amount = 0;
if (!utils_1.is.array(dbs)) {
amount = newData.length;
await tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users
.insertMany(newData)
.catch(console.error);
}
else {
const insert = newData.filter((c) => !dbs.find((r) => c.userId === r.id));
if (utils_1.is.array(insert)) {
amount = insert.length;
await tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users
.insertMany(insert)
.catch(console.error);
}
}
return utils_1.status.success(`I've imported (${amount}) users from (${type}) leaderboard for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
announce: {
/**
* Toggle on/off certain features for a certain server.
*/
toggle: async (guildId, type) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
if (type === "ping") {
data.announce.channel.ping = (0, utils_2.tog)(data.announce.channel.ping);
await (0, utils_2.save)(data);
return utils_1.status.success(data.announce.channel.ping
? `I'll now mention users when announcing levels`
: `I'll not mention users when announcing levels`);
}
else if (type === "onlyRegisteredLevels") {
data.toggles.onlyRegisteredLevels = (0, utils_2.tog)(data.toggles.onlyRegisteredLevels);
await (0, utils_2.save)(data);
return utils_1.status.success(data.toggles.onlyRegisteredLevels
? `I'll only announce levels that is registered.`
: `I'll announce all level ups`);
}
data.announce[type].enabled = (0, utils_2.tog)(data.announce[type].enabled);
await (0, utils_2.save)(data);
return utils_1.status.success(`${toggle(data.announce[type].enabled)} (${type}) announcements for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
/**
* Set/Reset the content/embeds for certain types on a certain server.
*/
setMessage: async (guildId, type, options) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
if (utils_1.is.string(options.content, false)) {
data.announce[type].options.content = options.content;
}
if (utils_1.is.array(options.embeds, false)) {
data.announce[type].options.embeds = options.embeds;
}
await (0, utils_2.save)(data);
return utils_1.status.success(`Updated (${type}) announcement message for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
/**
* Set/Reset the announcement channel for level ups.
*/
setChannel: async (guildId, channelId) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
data.announce.channel.channel = channelId;
await (0, utils_2.save)(data);
return utils_1.status.success(channelId
? `I've set the announce channel to <#${channelId}> (${channelId}) in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`
: `Reset the announce channel in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
},
levels: {
/**
* Add a level to a certain server.
* NOTE: (add: Will add roles to the users once they level up, remove: Will remove roles from the user once they level up)
*/
add: async (guildId, level, options) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const roles = {
add: options?.add || [],
remove: options?.remove || [],
};
const find = data.levels.find((c) => c.level === level);
if (find) {
return utils_1.status.error(`Level (${level}) is already registered.`);
}
data.levels.push({
level,
levelName: options?.levelName || `Level ${level}`,
roles,
options: {
content: options?.options?.content || "",
embeds: options?.options?.embeds || [],
},
});
await (0, utils_2.save)(data);
const str = [];
if (utils_1.is.array(roles.add)) {
str.push(`- Add Roles: ${roles.add
.map((c) => `<@&${c}>`)
.join(", ")}`);
}
if (utils_1.is.array(roles.remove)) {
str.push(`- Remove Roles: ${roles.remove
.map((c) => `<@&${c}>`)
.join(", ")}`);
}
return utils_1.status.success(`Registered (${level}) Level on ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}${str.length ? `\n${str.join("\n")}` : ""}`);
},
/**
* Remove a certain level from a certain server.
*/
remove: async (guildId, level) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const find = data.levels.find((c) => c.level === level);
if (!find) {
return utils_1.status.error(`Unable to find (${level}) level in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
data.levels = data.levels.filter((c) => c.level !== level);
await (0, utils_2.save)(data);
return utils_1.status.success(`Removed (${level}) level from ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
/**
* Set/Reset a certain level's (ADD) roles
* These roles will get added once the user reaches this level
*/
addRoles: async (guildId, level, roles) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const find = data.levels.find((c) => c.level === level);
if (!find) {
return utils_1.status.error(`Unable to find (${level}) level in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
for (const role of roles) {
if (find.roles.add.includes(role)) {
find.roles.add = find.roles.add.filter((c) => c !== role);
}
else {
find.roles.add.push(role);
}
}
await (0, utils_2.save)(data);
return utils_1.status.success(`Updated (${level}) level's (add) roles in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
/**
* Set/Reset a certain level's (REMOVE) roles
* These roles will get removed once the user reaches this level
*/
removeRoles: async (guildId, level, roles) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const find = data.levels.find((c) => c.level === level);
if (!find) {
return utils_1.status.error(`Unable to find (${level}) level in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
for (const role of roles) {
if (find.roles.remove.includes(role)) {
find.roles.remove = find.roles.remove.filter((c) => c !== role);
}
else {
find.roles.remove.push(role);
}
}
await (0, utils_2.save)(data);
return utils_1.status.success(`Updated (${level}) level's (remove) roles in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
/**
* Set/Reset a certain level's announcement message for a certain server.
*/
setMessage: async (guildId, options, level) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const find = data.levels.find((c) => c.level === level);
if (!find) {
return utils_1.status.error(`Unable to find (${level}) level in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
if (utils_1.is.string(options.content, false)) {
find.options.content = options.content;
}
if (utils_1.is.array(options.embeds, false)) {
find.options.embeds = options.embeds;
}
await (0, utils_2.save)(data);
return utils_1.status.success(`Updated (${level}) level's message options in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
get: async (guildId, level) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const find = data.levels.find((c) => c.level === level);
if (!find) {
return utils_1.status.error(`Unable to find level (${level})`);
}
return utils_1.status.data(find);
},
getLevelName: async (guildId, level) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.success(`Level ${level}`);
}
const find = data.levels.find((c) => c.level === level);
if (!find) {
return utils_1.status.success(`Level ${level}`);
}
return utils_1.status.success(find.levelName || `Level ${find.level}`);
},
},
multipliers: {
/**
* Add a multiplier to a certain server.
*/
add: async (guildId, multiplier, options) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const find = data.multipliers.find((c) => c.multiplier === multiplier);
if (find) {
return utils_1.status.error(`Multiplier (${multiplier}) already exists in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
data.multipliers.push({
multiplier,
channels: options?.channels || [],
roles: options?.roles || [],
});
await (0, utils_2.save)(data);
return utils_1.status.success(`Added (${multiplier}) multiplier to ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
/**
* Remove a multiplier from a certain server.
*/
remove: async (guildId, multiplier) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const find = data.multipliers.find((c) => c.multiplier === multiplier);
if (!find) {
return utils_1.status.error(`Multiplier (${multiplier}) doesn't exist in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
data.multipliers = data.multipliers.filter((c) => c.multiplier !== find.multiplier);
await (0, utils_2.save)(data);
return utils_1.status.success(`Removed (${multiplier}) multiplier to ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
},
/**
* Add/Remove certain channels from being able to use this multiplier in a certain server.
*/
channels: async (guildId, multiplier, channels) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const find = data.multipliers.find((c) => c.multiplier === multiplier);
if (!find) {
return utils_1.status.error(`Multiplier (${multiplier}) doesn't exist in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
for (const channel of channels) {
if (find.channels.includes(channel)) {
find.channels = find.channels.filter((c) => c !== channel);
}
else {
find.channels.push(channel);
}
}
await (0, utils_2.save)(data);
return utils_1.status.success(`Multiplier (${multiplier}) channels is now updated.`);
},
/**
* Add/Remove certain roles from being able to use this multiplier in a certain server.
*/
roles: async (guildId, multiplier, roles) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const find = data.multipliers.find((c) => c.multiplier === multiplier);
if (!find) {
return utils_1.status.error(`Multiplier (${multiplier}) doesn't exist in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
for (const role of roles) {
if (find.roles.includes(role)) {
find.roles = find.roles.filter((c) => c !== role);
}
else {
find.roles.push(role);
}
}
await (0, utils_2.save)(data);
return utils_1.status.success(`Multiplier (${multiplier}) roles is now updated.`);
},
},
ignore: {
/**
* Toggle on/off certain channels from being ignored in a certain server. (they will not gain XP)
*/
channels: async (guildId, channels) => tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_handleIgnore).call(this, guildId, "channels", channels),
/**
* Toggle on/off certain roles from being ignored in a certain server. (they will not gain XP)
*/
roles: async (guildId, roles) => tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_handleIgnore).call(this, guildId, "roles", roles),
/**
* Toggle on/off certain users from being ignored in a certain server. (they will not gain XP)
*/
users: async (guildId, users) => tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_handleIgnore).call(this, guildId, "users", users),
},
leaderboard: {
/**
* Get the leaderboard for a certain server.
*/
get: async (guildId, options, board) => {
let page = options?.page || 1;
let perPage = options?.perPage || null;
const sort = options?.sort || "top";
const sortBy = options?.sortBy || "level";
if (page && !perPage) {
perPage = 10;
}
const data = board ||
(await tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users
.find({ guildId })
.lean()
.catch(() => []));
if (!utils_1.is.array(data)) {
return utils_1.status.error(`Unable to find anyone on the leaderboard.`);
}
const getSorted = () => {
if (sort === "top") {
return data.sort((a, b) => b[sortBy] - a[sortBy]);
}
return data.sort((a, b) => a[sortBy] - b[sortBy]);
};
const fetchedSorted = getSorted();
const sorted = [];
let i = 0;
for (const f of fetchedSorted) {
i++;
sorted.push({
position: i,
...f,
});
}
if (perPage) {
const pages = (0, utils_1.chunk)(sorted, perPage);
if (!pages[page - 1]) {
page = 1;
}
if (!utils_1.is.array(pages[page - 1])) {
return utils_1.status.error(`Unable to find anyone on the leaderboard.`);
}
return {
status: true,
data: pages[page - 1],
query: {
page,
pages: pages.length,
sort,
sortBy,
perPage,
},
};
}
return {
status: true,
data: sorted,
query: {
page,
pages: (0, utils_1.chunk)(sorted, perPage || 10).length,
sort,
sortBy,
perPage,
},
};
},
/**
* Get the formatted leaderboard for a certain server.
* This will fetch the users information to have their Discord info in the returned data.
*/
formatted: async (guildId, options, forceStatic, board) => {
const DB = await this.servers.leaderboard.get(guildId, options, board);
if (!DB.status) {
return DB;
}
const fetchData = async (dbs) => {
const users = [];
for await (const db of dbs) {
const user = await utils_1.discord.user(tslib_1.__classPrivateFieldGet(this, _API_client, "f").client, db.userId, { fetch: true, mock: true });
users.push({
...db,
user: {
username: user?.username ?? "unknown_user",
displayName: user?.displayName ?? "Unknown User",
globalName: user?.globalName ?? null,
discriminator: user?.discriminator ?? "0",
tag: user?.tag ?? "Unknown User#0",
id: db.userId,
avatar: (0, utils_2.getUserAvatar)(user),
accentColor: user?.hexAccentColor || null,
banner: user?.banner
? user.bannerURL()
: null,
bot: user?.bot || false,
createdAt: new Date(parseInt(`${utils_1.snowflakes.get(db.userId)
.timestamp}`)),
},
});
}
return users;
};
if (DB.query.perPage) {
const pages = (0, utils_1.chunk)(DB.data, DB.query.perPage);
if (!pages[DB.query.page - 1]) {
DB.query.page = 1;
}
if (!utils_1.is.array(pages[DB.query.page - 1])) {
return utils_1.status.error(`Unable to find anyone on the leaderboard.`);
}
return {
status: true,
data: await fetchData(pages[DB.query.page - 1]),
query: DB.query,
};
}
return {
status: true,
data: await fetchData(DB.data),
query: DB.query,
};
},
/**
* Set the leaderboard background (or color) for a certain server
* NOTE: Only available to 'canvacord' leaderboard type
*/
setBackground: async (guildId, options) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const changed = [];
if (options) {
if (utils_1.is.string(options.url, false)) {
if (!options.url.match(/http(s):\/\//gi)) {
options.url = "";
}
data.background.url = options.url || "";
changed.push(`Background URL: ${data.background.url || "Reset"}`);
}
if (utils_1.is.string(options.color, false)) {
data.background.color = options.color || "";
changed.push(`Background Color: ${data.background.color || "Reset"}`);
}
}
if (!utils_1.is.array(changed)) {
return utils_1.status.error(`Nothing needed to be updated.`);
}
await (0, utils_2.save)(data);
return utils_1.status.success(`I've updated the Leaderboard background info:\n${changed.join("\n")}`);
},
},
/**
* Delete all data belonging to a certain server (main data)
*/
delete: async (guildId) => {
const o = { guildId };
const removed = {
data: null,
weekly: [],
users: [],
};
const [data, weekly, users] = await Promise.all([
tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.settings
.findOne(o)
.catch(() => null),
tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.weekly.find(o).catch(() => []),
tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users.find(o).catch(() => []),
]);
if (data) {
removed.data = data;
}
if (utils_1.is.array(weekly)) {
removed.weekly = weekly;
}
if (utils_1.is.array(users)) {
removed.users = users;
}
await Promise.all([
// @ts-ignore
data?.deleteOne()?.catch(() => null),
tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users
.deleteMany({ guildId })
.catch(() => null),
tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.weekly
.deleteMany({ guildId })
.catch(() => null),
]);
return {
status: true,
message: `Deleted (${guildId}) server's data.`,
data: removed,
};
},
users: {
get: async (guildId) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const users = await tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users
.find({
guildId,
})
.lean()
.catch(() => []);
if (!utils_1.is.array(users)) {
return utils_1.status.error(`There is 0 users on the leaderboard for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
return utils_1.status.data(users);
},
count: async (guildId) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const count = await tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users
.countDocuments({ guildId })
.catch(() => 0);
if (!utils_1.is.number(count)) {
return utils_1.status.error(`No one has a leveling profile for ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
return utils_1.status.data({ count });
},
reset: async (guildId) => {
const data = await tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getSettings).call(this, guildId);
if (!data) {
return utils_1.status.error(server_not_found);
}
const count = await this.servers.users.count(guildId);
if (!count.status) {
return count;
}
const users = await this.servers.users.get(guildId);
if (!users.status) {
return users;
}
const deleted = await tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users
.deleteMany({
guildId,
})
.catch(() => null);
if (!deleted || !utils_1.is.number(deleted.deletedCount)) {
return utils_1.status.error(`Unable to delete any leveling profiles in ${tslib_1.__classPrivateFieldGet(this, _API_instances, "m", _API_getServer).call(this, guildId)}`);
}
return utils_1.status.data({
count: deleted.deletedCount,
users: users.data,
});
},
left: async (guildId, dry = true) => {
const guild = tslib_1.__classPrivateFieldGet(this, _API_client, "f").client.guilds.resolve(guildId);
if (!guild || !guild.available) {
return utils_1.status.error(`Can't find server (${guildId}) or it's not available.`);
}
if (!(0, utils_1.hasBit)((0, utils_2.getClientIntents)(tslib_1.__classPrivateFieldGet(this, _API_client, "f").client), 2)) {
return utils_1.status.error(`The bot isn't using the "Server Members" intent, I cannot fetch the members list.`);
}
const members = await guild.members
.fetch()
.catch(() => null);
if (!members?.size) {
return utils_1.status.error(`Unable to fetch the members for the server.`);
}
const dbs = await tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users
.find({
guildId,
})
.catch(() => []);
const users = dbs.filter((c) => !members.has(c.userId));
if (!users.length) {
return utils_1.status.error(`No one needed to be removed.`);
}
if (dry === true) {
return utils_1.status.data({
count: users.length,
deleted: false,
});
}
const r = await tslib_1.__classPrivateFieldGet(this, _API_client, "f").dbs.users
.deleteMany({
_id: {
$in: users.map((c) => c._id),
},
})
.c