@duque.edits/sdk 0.1.4 → 0.1.6

package/dist/index.js

@@ -14,30 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./managers/bet/GuildBetManager"), exports);
-__exportStar(require("./managers/betuser/GuildBetUserManager"), exports);
-__exportStar(require("./managers/channel/ChannelManager"), exports);
-__exportStar(require("./managers/groupedchannel/GroupedChannelManager"), exports);
-__exportStar(require("./managers/guild/GuildManager"), exports);
-__exportStar(require("./managers/match/GuildMatchManager"), exports);
-__exportStar(require("./managers/mediator/GuildMediatorManager"), exports);
-__exportStar(require("./managers/messages/MessagesManager"), exports);
-__exportStar(require("./managers/permission/GuildPermissionManager"), exports);
-__exportStar(require("./managers/product/GuildProductManager"), exports);
-__exportStar(require("./managers/ticket/GuildTicketManager"), exports);
-__exportStar(require("./managers/user/GuildUserManager"), exports);
-__exportStar(require("./structures/bet/GuildBet"), exports);
-__exportStar(require("./structures/betuser/GuildBetUser"), exports);
-__exportStar(require("./structures/channel/Channel"), exports);
-__exportStar(require("./structures/groupedchannel/GroupedChannel"), exports);
-__exportStar(require("./structures/guild/Guild"), exports);
-__exportStar(require("./structures/match/GuildMatch"), exports);
-__exportStar(require("./structures/mediator/GuildMediator"), exports);
-__exportStar(require("./structures/product/GuildProduct"), exports);
-__exportStar(require("./structures/shop/GuildShop"), exports);
-__exportStar(require("./structures/ticket/GuildTicket"), exports);
-__exportStar(require("./structures/user/GuildUser"), exports);
-__exportStar(require("./structures/Collection"), exports);
-__exportStar(require("./rest/REST"), exports);
-__exportStar(require("./rest/Routes"), exports);
-__exportStar(require("./types/index"), exports);
+__exportStar(require("./managers"), exports);
+__exportStar(require("./structures"), exports);
+__exportStar(require("./rest"), exports);
+__exportStar(require("./types"), exports);

package/dist/managers/base.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseManager = void 0;
+const Collection_1 = require("../structures/Collection");
+class BaseManager {
+    /** This url of the manager */
+    base_url;
+    /** The rest client */
+    rest;
+    /** The guild of the manager */
+    guild;
+    /** Cache */
+    cache;
+    /** Internal data when manager is initialized */
+    _data;
+    constructor(guild, data) {
+        this.guild = guild;
+        this.rest = guild.rest;
+        this.cache = new Collection_1.Collection();
+        this._data = data;
+    }
+    get data() {
+        return this._data;
+    }
+}
+exports.BaseManager = BaseManager;

package/dist/managers/buffer/BufferManager.js

@@ -16,17 +16,23 @@ class BufferManager {
         const { rest } = this.guild;
         const cache = this[key];
         const { size, clear } = cache;
-        if (size >= 3) {
+        if (size >= 2) {
             const response = await rest.request({
                 method: "POST",
                 url: Routes_1.Routes.guilds.resources(this.guild.id, key, "bulk"),
                 payload: { [key]: this[key].toArray() },
             });
-            this.guild[key].setAll(response);
+            this.guild[key].set(response);
             clear();
             return response;
         }
         return;
     }
+    createMatch(id, data) {
+        this.matches.set(id, data);
+    }
+    createTicket(id, data) {
+        this.tickets.set(id, data);
+    }
 }
 exports.BufferManager = BufferManager;

package/dist/managers/guild/GuildManager.js

@@ -24,17 +24,19 @@ class GuildManager {
      * @param id Id of the guild to fetch
      * @returns APIGuild
      */
-    async fetch(id) {
-        const route = Routes_1.Routes.guilds.get(id);
-        const response = await this.rest.request({
-            method: "get",
-            url: route,
-        });
-        const guild = new Guild_1.Guild(response, this.rest);
-        this.cache.set(guild.id, guild);
-        return guild;
-    }
-    async fetchAll() {
+    async fetch(options) {
+        if (options && options.cache)
+            return this.cache;
+        if (options && options.guildId) {
+            const route = Routes_1.Routes.guilds.get(options.guildId);
+            const response = await this.rest.request({
+                method: "get",
+                url: route,
+            });
+            const guild = new Guild_1.Guild(response, this.rest);
+            this.cache.set(guild.id, guild);
+            return guild;
+        }
         const route = Routes_1.Routes.guilds.getAll();
         const response = await this.rest.request({
             method: "get",
@@ -45,23 +47,22 @@ class GuildManager {
                 continue;
             const guild = new Guild_1.Guild(guildData, this.rest);
             this.cache.set(guild.id, guild);
-            this.rest.guilds.cache.set(guild.id, guild);
         }
         return this.cache;
     }
-    async delete(id) {
-        Assertion_1.Assertion.assertString(id);
-        const route = Routes_1.Routes.guilds.delete(id);
-        const guild = this.cache.get(id);
-        this.rest.emit("guildDelete", guild);
-        await this.rest.request({
-            method: "DELETE",
-            url: route,
-        });
-        this.cache.delete(id);
-        return this.cache;
-    }
-    async deleteAll() {
+    async delete(options) {
+        if (options && options.guildId) {
+            Assertion_1.Assertion.assertString(options.guildId);
+            const route = Routes_1.Routes.guilds.delete(options.guildId);
+            const guild = this.cache.get(options.guildId);
+            this.rest.emit("guildDelete", guild);
+            await this.rest.request({
+                method: "DELETE",
+                url: route,
+            });
+            this.cache.delete(options.guildId);
+            return this.cache;
+        }
         const route = Routes_1.Routes.guilds.deleteAll();
         this.rest.emit("guildsDelete", this.cache);
         const value = await this.rest.request({
@@ -71,5 +72,21 @@ class GuildManager {
         this.cache.clear();
         return value;
     }
+    set(data) {
+        if (!data)
+            return this.cache;
+        if (Array.isArray(data)) {
+            for (let _guild of data) {
+                const guild = new Guild_1.Guild(_guild, this.rest);
+                this.cache.set(guild.id, guild);
+            }
+            return this.cache;
+        }
+        else {
+            const guild = new Guild_1.Guild(data, this.rest);
+            this.cache.set(guild.id, guild);
+            return guild;
+        }
+    }
 }
 exports.GuildManager = GuildManager;

package/dist/managers/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./buffer/BufferManager"), exports);
+__exportStar(require("./guild/GuildManager"), exports);
+__exportStar(require("./match/GuildMatchManager"), exports);
+__exportStar(require("./permission/GuildPermissionManager"), exports);
+__exportStar(require("./user/GuildUserManager"), exports);
+__exportStar(require("./vipmember/VipMemberManager"), exports);
+__exportStar(require("./ticket/TicketManager"), exports);

package/dist/managers/match/GuildMatchManager.js

@@ -5,38 +5,51 @@ const Routes_1 = require("../../rest/Routes");
 const GuildMatch_1 = require("../../structures/match/GuildMatch");
 const Collection_1 = require("../../structures/Collection");
 const Assertion_1 = require("../../utils/Assertion");
-class GuildMatchManager {
-    /** A cache of users */
-    cache;
-    /** The rest client */
-    rest;
-    /** GuildMatch match guild */
-    guild;
+const base_1 = require("../base");
+class GuildMatchManager extends base_1.BaseManager {
     /**
      * Manage users with the given client
      * @param users An array of users
      * @param rest The rest client
      */
-    constructor(guild, rest) {
+    constructor(guild) {
+        super(guild, guild.rest);
         this.guild = guild;
+        this.rest = guild.rest;
+        this.base_url = Routes_1.Routes.guilds.resource(guild.id, "matches");
         this.cache = new Collection_1.Collection("matches");
-        this.rest = rest;
     }
     /**
      * Fetch a match
      * @param id Id of the match to fetch
      * @returns APIBetUser
      */
-    async fetch(id) {
-        const route = Routes_1.Routes.guilds.matches.get(this.guild.id, id);
+    async fetch(options) {
+        if (options && options.cache)
+            return this.cache;
+        if (options && options.matchId) {
+            const route = Routes_1.Routes.guilds.matches.get(this.guild.id, options.matchId);
+            const response = await this.rest.request({
+                method: "get",
+                url: route,
+            });
+            return this.set(response);
+        }
+        const route = Routes_1.Routes.guilds.matches.getAll(this.guild.id);
         const response = await this.rest.request({
             method: "get",
             url: route,
         });
-        const match = new GuildMatch_1.GuildMatch(response, this.guild, this, this.rest);
-        this.cache.set(match._id, match);
-        this.rest.matches.set(match._id, match);
-        return match;
+        if (!response)
+            return this.cache;
+        const coll = new Collection_1.Collection();
+        for (let match of response ?? []) {
+            const guildMatch = new GuildMatch_1.GuildMatch(match, this);
+            coll.set(match._id, guildMatch);
+            this.rest.matches.set(match._id, guildMatch);
+        }
+        this.cache = coll;
+        return coll;
     }
     async fetchAll() {
         const route = Routes_1.Routes.guilds.matches.getAll(this.guild.id);
@@ -48,23 +61,24 @@ class GuildMatchManager {
             this.cache.clear();
             return this.cache;
         }
-        this.setAll(response);
+        this.set(response);
         return this.cache;
     }
     set(data) {
-        if (!data?._id)
-            return;
-        const match = new GuildMatch_1.GuildMatch(data, this?.guild, this, this.rest);
-        this.cache.set(data?._id, match);
-        this.rest.matches.set(data?._id, match);
-        return match;
-    }
-    setAll(data) {
         if (!data)
             return this.cache;
-        for (let match of data || [])
-            this.set(match);
-        return this.cache;
+        if (Array.isArray(data)) {
+            for (let _match of data) {
+                const match = new GuildMatch_1.GuildMatch(_match, this);
+                this.cache.set(match._id, match);
+            }
+            return this.cache;
+        }
+        else {
+            const match = new GuildMatch_1.GuildMatch(data, this);
+            this.cache.set(match._id, match);
+            return match;
+        }
     }
     async create(payload) {
         Assertion_1.Assertion.assertObject(payload);
@@ -74,8 +88,7 @@ class GuildMatchManager {
             url: route,
             payload,
         });
-        const match = this.set(response);
-        return match;
+        return this.set(response);
     }
     async delete(id) {
         Assertion_1.Assertion.assertString(id);

package/dist/managers/message/MessagesManager.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagesManager = void 0;
+const Collection_1 = require("../../structures/Collection");
+class MessagesManager {
+    cache;
+    base_url;
+    rest;
+    constructor(structure, base_url) {
+        this.rest = structure.rest;
+        this.cache = new Collection_1.Collection();
+        this.base_url = base_url;
+    }
+    async fetch() {
+        const response = await this.rest.request({
+            method: "GET",
+            url: this.base_url,
+            payload: {},
+        });
+        this.cache.set(response._id, response);
+        return response;
+    }
+    async create(data) {
+        const messages = [...this.cache.toArray()];
+        if (Array.isArray(data))
+            messages.push(...data);
+        else
+            messages.push(data);
+        const response = await this.rest.request({
+            method: "POST",
+            url: this.base_url,
+            payload: { messages },
+        });
+        for (let message of response)
+            this.cache.set(message._id, message);
+        return response;
+    }
+    setAll(data) {
+        if (Array.isArray(data)) {
+            for (let message of data)
+                this.cache.set(message._id, message);
+        }
+        else
+            this.cache.set(data._id, data);
+        return this.cache;
+    }
+}
+exports.MessagesManager = MessagesManager;

package/dist/managers/permission/GuildPermissionManager.js

@@ -2,69 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GuildPermissionManager = void 0;
 const Routes_1 = require("../../rest/Routes");
-class GuildPermissionManager {
-    /** The rest client */
-    rest;
-    /** GuildBet bet guild */
-    guild;
-    permissions;
-    /**
-     * Manage users with the given client
-     * @param users An array of users
-     * @param rest The rest client
-     */
-    constructor(guild, rest) {
+const base_1 = require("../base");
+class GuildPermissionManager extends base_1.BaseManager {
+    constructor(guild) {
+        super(guild, guild.permissions);
         this.guild = guild;
-        this.rest = rest;
+        this.rest = guild.rest;
+        this.base_url = Routes_1.Routes.guilds.resource(guild.id, "permissions");
     }
-    /**
-     * Fetch a bet
-     * @param id Id of the bet to fetch
-     * @returns APIBetUser
-     */
-    async fetch() {
-        const route = Routes_1.Routes.guilds.resource(this.guild.id, "permissions");
+    async addRole(permissionId, roleId) {
+        const perm = this.guild.permissions[permissionId];
+        if (perm.includes(roleId))
+            return this.guild;
+        perm.push(roleId);
+        const perms = { ...this.guild.permissions, perm };
+        const payload = { set: perms };
         const response = await this.rest.request({
-            method: "get",
-            url: route,
-        });
-        this.setAll(response);
-    }
-    async addId(permissionId, roleId) {
-        const route = Routes_1.Routes.guilds.resources(this.guild.id, "permissions", permissionId, "ids");
-        const payload = { id: roleId };
-        const response = await this.rest.request({
-            method: "post",
-            url: route,
+            method: "PATCH",
+            url: this.base_url,
             payload,
         });
-        this.permissions[permissionId] = response;
+        this.guild.permissions = response.permissions;
+        this.rest.guilds.cache.set(this.guild.id, this.guild);
         return response;
     }
-    async removeId(permissionId, roleId) {
-        const route = Routes_1.Routes.guilds.resources(this.guild.id, "permissions", permissionId, "ids", roleId);
-        const payload = { id: roleId };
+    async removeRole(permissionId, roleId) {
+        let perm = this.guild.permissions[permissionId];
+        if (!perm.includes(roleId))
+            return this.guild;
+        perm = perm.filter((i) => i !== roleId);
+        let perms = { ...this.guild.permissions };
+        perms[permissionId] = perm;
+        const payload = { set: perms };
         const response = await this.rest.request({
-            method: "delete",
-            url: route,
+            method: "PATCH",
+            url: this.base_url,
             payload,
         });
-        this.permissions[permissionId] = response;
+        this.guild.permissions = response.permissions;
+        this.rest.guilds.cache.set(this.guild.id, this.guild);
         return response;
     }
-    setAll(data) {
-        if (!data)
-            return this.permissions;
-        this.permissions = data;
-    }
-    toJSON() {
-        const json = {};
-        for (const [key, value] of Object.entries(this)) {
-            if (typeof value !== "function") {
-                json[key] = value;
-            }
-        }
-        return json;
-    }
 }
 exports.GuildPermissionManager = GuildPermissionManager;

package/dist/managers/ticket/TicketManager.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketManager = void 0;
+const rest_1 = require("../../rest");
+const structures_1 = require("../../structures");
+const Collection_1 = require("../../structures/Collection");
+class TicketManager {
+    cache;
+    guild;
+    rest;
+    constructor(guild) {
+        this.guild = guild;
+        this.rest = guild.rest;
+        this.cache = new Collection_1.Collection("tickets");
+    }
+    async fetch(options) {
+        if (options && options.cache)
+            return this.cache;
+        if (options && options.ticketId) {
+            const route = rest_1.Routes.guilds.tickets.get(this.guild.id, options.ticketId);
+            const response = await this.rest.request({
+                method: "GET",
+                url: route,
+            });
+            return this.set(response);
+        }
+        const route = rest_1.Routes.guilds.tickets.getAll(this.guild.id);
+        const response = await this.rest.request({
+            method: "GET",
+            url: route,
+        });
+        return this.set(response);
+    }
+    async create(data) {
+        const route = rest_1.Routes.guilds.tickets.create(this.guild.id);
+        const response = await this.rest.request({
+            method: "POST",
+            url: route,
+            payload: data,
+        });
+        return this.set(response);
+    }
+    async delete(options) {
+        if (options && options.ticketId) {
+            const route = rest_1.Routes.guilds.tickets.delete(this.guild.id, options.ticketId);
+            await this.rest.request({
+                method: "DELETE",
+                url: route,
+            });
+            return true;
+        }
+        const route = rest_1.Routes.guilds.tickets.deleteAll(this.guild.id);
+        await this.rest.request({
+            method: "DELETE",
+            url: route,
+        });
+        this.cache.clear();
+        return true;
+    }
+    set(data) {
+        if (!data)
+            return this.cache;
+        if (Array.isArray(data)) {
+            for (let _ticket of data) {
+                const ticket = new structures_1.GuildTicket(_ticket, this);
+                this.cache.set(ticket._id, ticket);
+            }
+            return this.cache;
+        }
+        else {
+            const ticket = new structures_1.GuildTicket(data, this);
+            this.cache.set(ticket._id, ticket);
+            return ticket;
+        }
+    }
+}
+exports.TicketManager = TicketManager;