@duque.edits/sdk 0.0.4 → 0.0.6

package/dist/structures/guild/Guild.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Guild = void 0;
+const GuildBetManager_1 = require("../../managers/bet/GuildBetManager");
+const GuildBetUserManager_1 = require("../../managers/betuser/GuildBetUserManager");
+const GroupedChannelManager_1 = require("../../managers/groupedchannel/GroupedChannelManager");
+const GuildMatchManager_1 = require("../../managers/match/GuildMatchManager");
+const GuildMediatorManager_1 = require("../../managers/mediator/GuildMediatorManager");
+const MessagesManager_1 = require("../../managers/messages/MessagesManager");
+const GuildPermissionManager_1 = require("../../managers/permission/GuildPermissionManager");
+const GuildTicketManager_1 = require("../../managers/ticket/GuildTicketManager");
+const GuildUserManager_1 = require("../../managers/user/GuildUserManager");
+const Routes_1 = require("../../rest/Routes");
+const Assertion_1 = require("../../utils/Assertion");
+const GuildShop_1 = require("../shop/GuildShop");
+/** The Guild */
+class Guild {
+    /** The data of this guild */
+    data;
+    /** The rest client */
+    rest;
+    /** The guild's id */
+    id;
+    /** Guild's client key */
+    clientKey;
+    /** Guild Permissions */
+    permissions;
+    /** Guild Ticket */
+    tickets;
+    /** Guild Ticket Configuration */
+    ticketsConfiguration;
+    /** Guild Daily Categories */
+    dailyCategories;
+    /** Guild Scores */
+    scores;
+    /** Guild Status */
+    status;
+    /** Guild Channel */
+    channels;
+    /** Guild Categories */
+    categories;
+    /** Guild Blacklist */
+    blacklist;
+    /** Guild Prefix */
+    prefix;
+    /** Guild Prices */
+    pricesAvailable;
+    /** Guild Prices Used */
+    pricesOn;
+    /** Guild Creation Date */
+    createdAt;
+    /** Guild Updated Date */
+    updatedAt;
+    /** Guild Bets */
+    bets;
+    /** Guild Users */
+    users;
+    /** Guild Bet Users */
+    betUsers;
+    /** Guild Matches */
+    matches;
+    /** Guild Mediators */
+    mediators;
+    /** Guild Messages */
+    messages;
+    /** Guild Emojis */
+    emojis;
+    /** Guild Roles */
+    roles;
+    /** Guild Shop */
+    shop;
+    permissionsManager;
+    /**
+     * The guild structure
+     * @param data The guild's data
+     * @param rest The rest client
+     */
+    constructor(data, rest) {
+        this.data = data;
+        this.rest = rest;
+        this.id = data?.id;
+        this.clientKey = data?.clientKey;
+        this.prefix = data?.prefix;
+        this.status = data?.status;
+        this.ticketsConfiguration = data?.ticketsConfiguration;
+        this.permissions = data?.permissions;
+        this.dailyCategories = data?.dailyCategories;
+        this.scores = data?.scores;
+        this.messages = new MessagesManager_1.MessagesManager(this, this.id, rest);
+        this.roles = data?.roles;
+        this.emojis = data?.emojis;
+        this.pricesAvailable = data?.pricesAvailable;
+        this.pricesOn = data?.pricesOn;
+        this.shop = new GuildShop_1.GuildShop(data?.shop, this, rest);
+        this.mediators = new GuildMediatorManager_1.GuildMediatorManager(this, rest);
+        this.bets = new GuildBetManager_1.GuildBetManager(this, rest);
+        this.users = new GuildUserManager_1.GuildUserManager(this, rest);
+        this.betUsers = new GuildBetUserManager_1.GuildBetUserManager(this, rest);
+        this.matches = new GuildMatchManager_1.GuildMatchManager(this, rest);
+        this.channels = new GroupedChannelManager_1.GroupedChannelManager(this, "channels", rest);
+        this.categories = new GroupedChannelManager_1.GroupedChannelManager(this, "categories", rest);
+        this.tickets = new GuildTicketManager_1.GuildTicketManager(this, rest);
+        this.permissionsManager = new GuildPermissionManager_1.GuildPermissionManager(this, rest);
+        this.bets.setAll(data?.bets);
+        this.users.setAll(data?.users);
+        this.betUsers.setAll(data?.betUsers);
+        this.channels.setAll(data?.channels);
+        this.categories.setAll(data?.categories);
+        this.matches.setAll(data?.matches);
+        this.mediators.setAll(data?.mediators);
+        this.tickets.setAll(data?.tickets);
+        this.permissionsManager.setAll(data?.permissions);
+        this.messages.setAll(data?.messages);
+        this.createdAt = data?.createdAt ? new Date(data?.createdAt) : new Date();
+        this.updatedAt = data?.updatedAt ? new Date(data?.updatedAt) : new Date();
+        this.blacklist = [];
+        for (let blacklisted of data?.blacklist) {
+            this.blacklist.push({
+                addedBy: blacklisted.addedBy,
+                id: blacklisted.id,
+                createdAt: blacklisted?.createdAt ? new Date(blacklisted?.createdAt) : new Date(),
+                updatedAt: blacklisted?.createdAt ? new Date(blacklisted?.createdAt) : new Date(),
+            });
+        }
+    }
+    async fetch() {
+        const route = Routes_1.Routes.guilds.get(this.id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const guild = new Guild(response, this.rest);
+        this.rest.guilds.cache.set(guild.id, guild);
+        return guild;
+    }
+    async setBlacklist(value, user, adminId) {
+        Assertion_1.Assertion.assertBoolean(value);
+        Assertion_1.Assertion.assertString(adminId);
+        const is_in_blacklist = this.blacklist.find((u) => u.id == user.id);
+        if (is_in_blacklist && value === true)
+            return this;
+        const route = Routes_1.Routes.guilds.resource(this.id, "blacklist");
+        const payload = { id: user.id, name: user.name, adminId, value };
+        const [response] = await Promise.all([
+            this.rest.request({
+                method: "PATCH",
+                url: route,
+                payload,
+            }),
+            user.setBlacklist(value),
+        ]);
+        for (let blacklisted of response?.blacklist) {
+            this.blacklist.push({
+                addedBy: blacklisted.addedBy,
+                id: blacklisted.id,
+                createdAt: blacklisted?.createdAt ? new Date(blacklisted?.createdAt) : new Date(),
+                updatedAt: blacklisted?.createdAt ? new Date(blacklisted?.createdAt) : new Date(),
+            });
+        }
+        this.rest.guilds.cache.set(this.id, this);
+        this.rest.emit("guildUpdate", this);
+        console.log({ bl: response?.blacklist });
+        return this;
+    }
+    async setStatus(key, status) {
+        Assertion_1.Assertion.assertString(status);
+        status = status.toLowerCase();
+        const route = Routes_1.Routes.fields(Routes_1.Routes.guilds.resource(this.id, "status"), key);
+        const payload = { status };
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.status = response.status;
+        this.rest.guilds.cache.set(this.id, this);
+        this.rest.emit("guildUpdate", this);
+        return this;
+    }
+    async addPrice(price) {
+        Assertion_1.Assertion.assertNumber(price);
+        const route = Routes_1.Routes.fields(Routes_1.Routes.guilds.resource(this.id, "price"), "pricesOn");
+        const payload = { price };
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.pricesAvailable = response.pricesAvailable;
+        this.pricesOn = response.pricesOn;
+        this.rest.guilds.cache.set(this.id, this);
+        this.rest.emit("guildUpdate", this);
+        return this;
+    }
+    async removePrice(price) {
+        Assertion_1.Assertion.assertNumber(price);
+        const route = Routes_1.Routes.fields(Routes_1.Routes.guilds.resource(this.id, "price"), "pricesOn");
+        const payload = { price };
+        const response = await this.rest.request({
+            method: "DELETE",
+            url: route,
+            payload,
+        });
+        this.pricesAvailable = response.pricesAvailable;
+        this.pricesOn = response.pricesOn;
+        this.rest.guilds.cache.set(this.id, this);
+        this.rest.emit("guildUpdate", this);
+        return this;
+    }
+    async setPrefix(prefix) {
+        Assertion_1.Assertion.assertString(prefix);
+        const route = Routes_1.Routes.fields(Routes_1.Routes.guilds.resource(this.id, "prefix"));
+        const payload = { prefix };
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.prefix = response.prefix;
+        this.rest.guilds.cache.set(this.id, this);
+        this.rest.emit("guildUpdate", this);
+        return this;
+    }
+    async addDailyCategory(category) {
+        Assertion_1.Assertion.assertString(category);
+        const route = Routes_1.Routes.fields(Routes_1.Routes.guilds.resource(this.id, "dailyCategories"));
+        const payload = { category };
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+            payload,
+        });
+        this.dailyCategories = response.dailyCategories;
+        this.rest.guilds.cache.set(this.id, this);
+        this.rest.emit("guildUpdate", this);
+        return this;
+    }
+    async removeDailyCategory(category) {
+        Assertion_1.Assertion.assertString(category);
+        const route = Routes_1.Routes.fields(Routes_1.Routes.guilds.resources(this.id, "dailyCategories", category));
+        const categories = [...new Set([...this.dailyCategories, category])];
+        const payload = { categories };
+        const response = await this.rest.request({
+            method: "DELETE",
+            url: route,
+            payload,
+        });
+        this.dailyCategories = response.dailyCategories;
+        this.rest.guilds.cache.set(this.id, this);
+        this.rest.emit("guildUpdate", this);
+        return this;
+    }
+}
+exports.Guild = Guild;

package/dist/structures/match/GuildMatch.d.ts

@@ -0,0 +1,84 @@
+import { REST } from "../../rest/REST";
+import { Guild } from "../guild/Guild";
+import { APIGuildMatch } from "../../types/api/APIGuildMatch";
+import { APIPlayer } from "../../types/api/APIPlayer";
+import { APIBetChannel } from "../../types/api/APIBetChannel";
+import { BaseMatchModes, BaseMatchStatus, Confirm, Optional } from "../../types/api";
+import { ChannelManager } from "../../managers/channel/ChannelManager";
+import { GuildMatchManager } from "../../managers/match/GuildMatchManager";
+import { MessagesManager } from "../../managers/messages/MessagesManager";
+export declare class GuildMatch {
+    /** Match's type */
+    type: BaseMatchModes;
+    /** Match's status */
+    status: BaseMatchStatus;
+    /** Match's challenge */
+    challenge: boolean;
+    /** Match's players */
+    players: APIPlayer[];
+    /** Match's winners */
+    winners: APIPlayer[];
+    /** Match's losers */
+    losers: APIPlayer[];
+    /** Match;s messages */
+    messages: MessagesManager;
+    /** Matches channels */
+    channels: ChannelManager<GuildMatch>;
+    /** Match's maximum size */
+    maximumSize: number;
+    /** Match's kicked out */
+    kickedOut: APIPlayer[];
+    /** Match's team a */
+    teamA: APIPlayer[];
+    /** Match's team b */
+    teamB: APIPlayer[];
+    /** Match's confirmed */
+    confirmed: Confirm[];
+    /** Match's leaders */
+    leaders: APIPlayer[];
+    /** Match's mvp */
+    mvpId: string;
+    /** Match's creator id */
+    creatorId: string;
+    /** Match's room creator id */
+    roomCreatorId: string;
+    /** Creation Date */
+    createdAt: Date;
+    /** Updated Date */
+    updatedAt: Date;
+    /** Match's id */
+    _id: string;
+    manager: GuildMatchManager;
+    /** The given guild */
+    readonly guild: Guild;
+    /** The rest client */
+    readonly rest: REST;
+    readonly key: string;
+    /**
+     * GuildMatch match
+     * @param data  The match's data
+     * @param guild The guild
+     * @param rest The rest client
+     */
+    constructor(data: APIGuildMatch, guild: Guild, manager: GuildMatchManager, rest: REST);
+    /**
+     * Fetches the match
+     * @returns New Instance of the match
+     */
+    fetch(): Promise<GuildMatch>;
+    addMessage(id: string, type: string, content?: string): Promise<import("../..").APIMessage>;
+    addConfirmed(type: string, id: string): Promise<Confirm>;
+    setConfirmed(set: Confirm[]): Promise<GuildMatch>;
+    setStatus(status: BaseMatchStatus): Promise<GuildMatch>;
+    setWinners(players: Optional<APIPlayer>[] | Optional<APIPlayer>): Promise<GuildMatch>;
+    setLoser(players: Optional<APIPlayer>[] | Optional<APIPlayer>): Promise<GuildMatch>;
+    setMvp(userId: string): Promise<GuildMatch>;
+    setRoomCreatorId(userId: string): Promise<GuildMatch>;
+    kick(player: APIPlayer): Promise<this>;
+    addChannel(id: string, type: string): Promise<GuildMatch>;
+    setChannels(channels: APIBetChannel[]): Promise<GuildMatch>;
+    addPlayer(id: string, name: string): Promise<GuildMatch>;
+    removePlayer(id: string, name: string): Promise<GuildMatch>;
+    update(data: Optional<APIGuildMatch>): Promise<GuildMatch>;
+    toJSON(): Record<string, unknown>;
+}

package/dist/structures/match/GuildMatch.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildMatch = void 0;
+const Routes_1 = require("../../rest/Routes");
+const Assertion_1 = require("../../utils/Assertion");
+const ChannelManager_1 = require("../../managers/channel/ChannelManager");
+const MessagesManager_1 = require("../../managers/messages/MessagesManager");
+class GuildMatch {
+    /** Match's type */
+    type;
+    /** Match's status */
+    status;
+    /** Match's challenge */
+    challenge;
+    /** Match's players */
+    players;
+    /** Match's winners */
+    winners;
+    /** Match's losers */
+    losers;
+    /** Match;s messages */
+    messages;
+    /** Matches channels */
+    channels;
+    /** Match's maximum size */
+    maximumSize;
+    /** Match's kicked out */
+    kickedOut;
+    /** Match's team a */
+    teamA;
+    /** Match's team b */
+    teamB;
+    /** Match's confirmed */
+    confirmed;
+    /** Match's leaders */
+    leaders;
+    /** Match's mvp */
+    mvpId;
+    /** Match's creator id */
+    creatorId;
+    /** Match's room creator id */
+    roomCreatorId;
+    /** Creation Date */
+    createdAt;
+    /** Updated Date */
+    updatedAt;
+    /** Match's id */
+    _id;
+    manager;
+    /** The given guild */
+    guild;
+    /** The rest client */
+    rest;
+    key;
+    /**
+     * GuildMatch match
+     * @param data  The match's data
+     * @param guild The guild
+     * @param rest The rest client
+     */
+    constructor(data, guild, manager, rest) {
+        this._id = data?._id;
+        this.manager = manager;
+        this.challenge = data?.challenge;
+        this.kickedOut = data?.kickedOut;
+        this.leaders = data?.leaders;
+        this.type = data?.type;
+        this.status = data?.status;
+        this.maximumSize = data?.maximumSize;
+        this.players = data?.players;
+        this.teamA = data?.teamA;
+        this.teamB = data?.teamB;
+        this.winners = data?.winners;
+        this.losers = data?.losers;
+        this.creatorId = data?.creatorId;
+        this.roomCreatorId = data?.roomCreatorId;
+        this.confirmed = data?.confirmed;
+        this.mvpId = data?.mvpId;
+        this.key = "matches";
+        this.channels = new ChannelManager_1.ChannelManager(guild, this, rest);
+        this.messages = new MessagesManager_1.MessagesManager(guild, this?._id, rest);
+        this.createdAt = data?.createdAt ? new Date(data?.createdAt) : new Date();
+        this.updatedAt = data?.updatedAt ? new Date(data?.updatedAt) : new Date();
+        this.guild = guild;
+        this.rest = rest;
+        this.channels.setAll(data?.channels);
+        this.messages.setAll(data?.messages);
+    }
+    /**
+     * Fetches the match
+     * @returns New Instance of the match
+     */
+    async fetch() {
+        const route = Routes_1.Routes.guilds.matches.get(this.guild.id, this._id);
+        const response = await this.rest.request({
+            method: "get",
+            url: route,
+        });
+        const match = new GuildMatch(response, this.guild, this.manager, this.rest);
+        this.manager.cache.set(match._id, match);
+        return match;
+    }
+    async addMessage(id, type, content) {
+        const response = await this.messages.create({
+            userId: id,
+            type: type,
+            content,
+        });
+        this.manager.cache.set(this._id, this);
+        this.rest.matches.set(this._id, this);
+        return response;
+    }
+    async addConfirmed(type, id) {
+        Assertion_1.Assertion.assertString(type);
+        Assertion_1.Assertion.assertString(id);
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "confirmed");
+        const payload = { type, id };
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("matchUpdate", this);
+        this.updatedAt = new Date();
+        this.confirmed = response;
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this.confirmed.find((c) => c.type === type);
+    }
+    async setConfirmed(set) {
+        Assertion_1.Assertion.assertObject(set);
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "confirmed");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload: set,
+        });
+        this.confirmed = response;
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async setStatus(status) {
+        Assertion_1.Assertion.assertString(status);
+        const payload = { set: status.toLowerCase() };
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "status");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("matchUpdate", this, new GuildMatch(response, this.guild, this.manager, this.rest));
+        this.status = response.status;
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async setWinners(players) {
+        if (!Array.isArray(players))
+            players = [players];
+        const payload = { winners: players };
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "winners");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("matchUpdate", this, new GuildMatch(response, this.guild, this.manager, this.rest));
+        this.winners = response.winners;
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async setLoser(players) {
+        if (!Array.isArray(players))
+            players = [players];
+        const payload = { losers: players };
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "losers");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("matchUpdate", this, new GuildMatch(response, this.guild, this.manager, this.rest));
+        this.losers = response.losers;
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async setMvp(userId) {
+        Assertion_1.Assertion.assertString(userId);
+        const payload = { id: userId };
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "mvp");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("matchUpdate", this, new GuildMatch(response, this.guild, this.manager, this.rest));
+        this.mvpId = response.mvpId;
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async setRoomCreatorId(userId) {
+        Assertion_1.Assertion.assertString(userId);
+        const payload = { id: userId };
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "roomCreatorId");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("matchUpdate", this, new GuildMatch(response, this.guild, this.manager, this.rest));
+        this.roomCreatorId = response.roomCreatorId;
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async kick(player) {
+        const payload = { ...player };
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "kickout");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("matchUpdate", this, new GuildMatch(response, this.guild, this.manager, this.rest));
+        this.kickedOut = response.kickedOut;
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async addChannel(id, type) {
+        await this.channels.create(id, type);
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async setChannels(channels) {
+        Assertion_1.Assertion.assertObject(channels);
+        const payload = { set: channels };
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "channels");
+        const response = await this.rest.request({
+            method: "PATCH",
+            url: route,
+            payload,
+        });
+        this.rest.emit("matchUpdate", this, new GuildMatch(response, this.guild, this.manager, this.rest));
+        this.channels.setAll(response.channels);
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async addPlayer(id, name) {
+        Assertion_1.Assertion.assertString(id);
+        Assertion_1.Assertion.assertString(name);
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "players");
+        const payload = { id, name };
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+            payload,
+        });
+        ({ response });
+        this.players = response.players;
+        this.rest.matches.set(this._id, this);
+        this.manager.cache.set(this._id, this);
+        return this;
+    }
+    async removePlayer(id, name) {
+        Assertion_1.Assertion.assertString(id);
+        Assertion_1.Assertion.assertString(name);
+        const route = Routes_1.Routes.guilds.matches.resource(this.guild.id, this._id, "players", id);
+        const payload = { id, name };
+        const response = await this.rest.request({
+            method: "DELETE",
+            url: route,
+            payload,
+        });
+        this.players = response.players;
+        this.rest.matches.set(this?._id, this);
+        this.manager.cache.set(this?._id, this);
+        return this;
+    }
+    async update(data) {
+        const route = Routes_1.Routes.guilds.matches.get(this.guild.id, this._id);
+        const payload = data;
+        const response = await this.rest.request({
+            method: "patch",
+            url: route,
+            payload,
+        });
+        this.rest.emit("matchUpdate", this, new GuildMatch(response, this.guild, this.manager, this.rest));
+        for (const k in response) {
+            if (k === "id" || k == "createdAt")
+                continue;
+            if (Object.hasOwn(this, k)) {
+                if (k === "channels") {
+                    ({ chs: response["channels"] });
+                    this.channels.setAll(response["channels"]);
+                    ({ chs2: this.channels.cache });
+                    continue;
+                }
+                if (k === "messages") {
+                    this.messages.setAll(response["messages"]);
+                    continue;
+                }
+                this[k] = response[k];
+            }
+        }
+        this.updatedAt = new Date();
+        this.manager.cache.set(this._id, this);
+        this.rest.matches.set(this._id, this);
+        return this;
+    }
+    toJSON() {
+        const json = {};
+        for (const [key, value] of Object.entries(this)) {
+            if (typeof value !== "function") {
+                json[key] = value;
+            }
+        }
+        return json;
+    }
+}
+exports.GuildMatch = GuildMatch;