@duque.edits/sdk 0.0.1

package/src/structures/bet/GuildBet.ts

@@ -0,0 +1,332 @@
+import { REST } from "../../rest/REST";
+import { Routes } from "../../rest/Routes";
+import { Guild } from "../guild/Guild";
+import { APIGuildBet } from "../../types/api/APIGuildBet";
+import { APIPlayer } from "../../types/api/APIPlayer";
+import { APIBetChannel } from "../../types/api/APIBetChannel";
+import { APIBetMessage } from "../../types/api/APIBetMessage";
+import { BaseMatchModes, BaseMatchStatus, Confirm, Logs, Optional } from "../../types/api";
+import { Assertion } from "../../utils/Assertion";
+import { ChannelManager } from "../../managers/channel/ChannelManager";
+import { GuildBetManager } from "../../managers/bet/GuildBetManager";
+import { MessagesManager } from "../../managers/messages/MessagesManager";
+
+type ExtendedMatchStatus = BaseMatchStatus | "waiting";
+
+export class GuildBet {
+  /** The bet's type */
+  type: Omit<BaseMatchModes, "5x5" | "6x6" | "5v5" | "6v6">;
+
+  /** The bet's mode */
+  mode: "misto" | "emu" | "mob" | "MISTO" | "EMU" | "MOB";
+
+  /** The bet's status */
+  status: "off" | "created" | "on" | "shutted" | "waiting";
+
+  /** The bet's maximum size */
+  maximumSize: number;
+
+  /** The bet's price */
+  price: number;
+
+  /** Who has payed the bet */
+  payedBy: APIPlayer[];
+
+  /** The bet's players */
+  players: APIPlayer[];
+
+  /** An array of team a */
+  teamA: APIPlayer[];
+
+  /** An array of team b */
+  teamB: APIPlayer[];
+
+  /** The bet's channel */
+  channels: ChannelManager<GuildBet>;
+
+  /** THe bet's messages */
+  messages: MessagesManager;
+
+  /** The id of the winner */
+  winner: string;
+
+  /** The id of the loser */
+  loser: string;
+
+  /** The bet's creator id */
+  creatorId: string;
+
+  /** The bet's mediator */
+  mediatorId: string;
+
+  /** The bet's confirmers */
+  confirmed: Confirm[];
+
+  /** The bet's embed id */
+  embedMessageId: string;
+
+  /** The bet's logs */
+  logs: Logs;
+
+  /** Creation Date */
+  createdAt: Date;
+
+  /** Updated Date */
+  updatedAt: Date;
+
+  /** GuildBet's id */
+  _id: string;
+
+  /** The given guild */
+  readonly guild: Guild;
+
+  /** The rest client */
+  readonly rest: REST;
+
+  readonly key: string;
+
+  readonly manager: GuildBetManager;
+  /**
+   * GuildBet bet
+   * @param data  The bet's data
+   * @param guild The guild
+   * @param rest The rest client
+   */
+  constructor(data: APIGuildBet, guild: Guild, manager: GuildBetManager, rest: REST) {
+    this.type = data.type;
+    this.mode = data.mode;
+    this.status = data.status;
+    this.maximumSize = data.maximumSize;
+    this.price = data.price;
+    this.payedBy = data.payedBy;
+    this.players = data.players;
+    this.teamA = data.teamA;
+    this.teamB = data.teamB;
+    this.winner = data.winner;
+    this.loser = data.loser;
+    this.creatorId = data.creatorId;
+    this.mediatorId = data.mediatorId;
+    this.confirmed = data.confirmed;
+    this.embedMessageId = data.embedMessageId;
+    this.winner = data?.winner;
+    this.loser = data?.loser;
+    this._id = data?._id;
+    this.logs = data.logs;
+
+    this.manager = manager;
+
+    this.key = "bets";
+    this.channels = new ChannelManager<GuildBet>(guild, this, rest);
+    this.messages = new MessagesManager(this?.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);
+  }
+  toString() {
+    return this._id || "1";
+  }
+  /**
+   * Fetches the bet
+   * @returns New Instance of the bet
+   */
+  async fetch() {
+    const route = Routes.guilds.bets.get(this.guild.id, this._id);
+    const response = await this.rest.request<APIGuildBet, {}>({
+      method: "get",
+      url: route,
+    });
+    const bt = new GuildBet(response, this.guild, this.manager, this.rest);
+    this.manager.cache.set(bt._id, bt);
+    return bt;
+  }
+
+  async addConfirmed(type: string, id: string) {
+    Assertion.assertString(type);
+    Assertion.assertString(id);
+
+    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "confirmed");
+    const payload = { entry: { type, id } };
+
+    const response = await this.rest.request<APIGuildBet, typeof payload>({
+      method: "PATCH",
+      url: route,
+      payload,
+    });
+
+    this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+    this.confirmed = response.confirmed;
+    this.manager.cache.set(this._id, this);
+    return response.confirmed.find((cn) => cn.type == type);
+  }
+  async setConfirmed(set: Confirm[]) {
+    Assertion.assertObject(set);
+
+    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "confirmed");
+
+    const response = await this.rest.request<APIGuildBet, typeof set>({
+      method: "PATCH",
+      url: route,
+      payload: set,
+    });
+    this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+    this.confirmed = response.confirmed;
+    this.manager.cache.set(this._id, this);
+    return this.confirmed;
+  }
+
+  async setStatus(status: ExtendedMatchStatus) {
+    Assertion.assertString(status);
+
+    const payload = { set: status.toLowerCase() };
+    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "status");
+    const response = await this.rest.request<APIGuildBet, typeof payload>({
+      method: "PATCH",
+      url: route,
+      payload,
+    });
+    this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+    this.status = response.status;
+    this.manager.cache.set(this._id, this);
+    return this;
+  }
+  async setWinner(userId: string) {
+    Assertion.assertString(userId);
+
+    const payload = { set: userId };
+    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "winner");
+    const response = await this.rest.request<APIGuildBet, {}>({
+      method: "PATCH",
+      url: route,
+      payload,
+    });
+    this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+    this.winner = response.winner;
+    this.manager.cache.set(this._id, this);
+    return response.winner;
+  }
+  async setLoser(userId: string) {
+    Assertion.assertString(userId);
+
+    const payload = { set: userId };
+    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "loser");
+    const response = await this.rest.request<APIGuildBet, {}>({
+      method: "PATCH",
+      url: route,
+      payload,
+    });
+    this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+    this.loser = response.loser;
+    this.manager.cache.set(this._id, this);
+    return response.loser;
+  }
+
+  async addChannel(id: string, type: string) {
+    const ch = await this.channels.create(id, type);
+    this.manager.cache.set(this._id, this);
+    return ch;
+  }
+  async addMessage(id: string, type: string, content?: string) {
+    const response = await this.messages.create({
+      userId: id,
+      type: type as "img",
+      content,
+    });
+
+    this.manager.cache.set(this._id, this);
+    this.rest.bets.set(this._id, this);
+    return response;
+  }
+  async setChannels(channels: APIBetChannel[]) {
+    Assertion.assertObject(channels);
+
+    const payload = { set: channels };
+    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "channels");
+    const response = await this.rest.request<APIGuildBet, {}>({
+      method: "PATCH",
+      url: route,
+      payload,
+    });
+    this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+    this.channels.setAll(response.channels);
+    this.manager.cache.set(this._id, this);
+    return this.channels;
+  }
+
+  async addPlayer(id: string, name: string) {
+    Assertion.assertString(id);
+    Assertion.assertString(name);
+
+    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "players");
+    const payload = { id, name };
+    const response = await this.rest.request<APIPlayer[], typeof payload>({
+      method: "POST",
+      url: route,
+      payload,
+    });
+
+    this.players = response;
+    this.manager.cache.set(this._id, this);
+    return this.players;
+  }
+  async removePlayer(id: string, name: string) {
+    Assertion.assertString(id);
+    Assertion.assertString(name);
+
+    const route = Routes.guilds.bets.resource(this.guild.id, this._id, "players", id);
+    const payload = { id, name };
+    const response = await this.rest.request<APIPlayer[], typeof payload>({
+      method: "DELETE",
+      url: route,
+      payload,
+    });
+    this.players = response;
+    this.manager.cache.set(this._id, this);
+    return this.players;
+  }
+
+  async update(data: Optional<APIGuildBet>) {
+    const route = Routes.guilds.bets.get(this.guild.id, this._id);
+    const payload = data;
+
+    const response = await this.rest.request<APIGuildBet, typeof payload>({
+      method: "patch",
+      url: route,
+      payload,
+    });
+    this.rest.emit("betUpdate", this, new GuildBet(response, this.guild, this.manager, this.rest));
+    for (const k in response) {
+      if (k === "id") continue;
+
+      if (Object.hasOwn(this, k)) {
+        if (k === "channels") {
+          this.channels.setAll(response["channels"]);
+          continue;
+        }
+        if (k === "messages") {
+          this.messages.setAll(response["messages"]);
+          continue;
+        }
+
+        (this as any)[k] = response[k as keyof APIGuildBet];
+      }
+    }
+    this.rest.bets.set(this._id, this);
+    this.manager.cache.set(this._id, this);
+    return this;
+  }
+  toJSON() {
+    const json: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(this)) {
+      if (typeof value !== "function") {
+        json[key] = value;
+      }
+    }
+    return json;
+  }
+}

package/src/structures/betuser/GuildBetUser.ts

@@ -0,0 +1,247 @@
+import { REST } from "../../rest/REST";
+import { Routes } from "../../rest/Routes";
+import { Daily, Items, Optional, ProfileCard } from "../../types/api";
+import { APIGuildBetUser } from "../../types/api/APIGuildBetUser";
+import { GuildBetUserManager } from "../../managers/betuser/GuildBetUserManager";
+
+export class GuildBetUser implements APIGuildBetUser {
+  /** User daily */
+  daily: Omit<Daily, "points">;
+
+  /** User's name */
+  name: string;
+
+  /** User's name */
+  id: string;
+
+  /** User's credit */
+  credit: number;
+
+  /** User's wins */
+  wins: number;
+
+  /** User's mvps */
+  mvps: number;
+
+  /** User's losses */
+  losses: number;
+
+  /** User's bets played */
+  betsPlayed: string[];
+
+  /** User's blacklist */
+  blacklist: boolean;
+
+  /** User's coins */
+  coins: number;
+
+  /** User's items */
+  items: Items;
+
+  /** User's profile card */
+  profileCard: ProfileCard;
+
+  /** Creation Date */
+  createdAt: Date;
+
+  /** Updated Date */
+  updatedAt: Date;
+
+  /** The given manager */
+  readonly manager: GuildBetUserManager;
+
+  /** The rest client */
+  readonly rest: REST;
+
+  /**
+   * Bet user
+   * @param data  The user's data
+   * @param manager The manager
+   * @param rest The rest client
+   */
+  constructor(data: APIGuildBetUser, manager: GuildBetUserManager, rest: REST) {
+    this.name = data.name;
+    this.id = data.id;
+    this.credit = data.credit;
+    this.wins = data.wins;
+    this.mvps = data.mvps;
+    this.losses = data.losses;
+    this.coins = data.coins;
+    this.blacklist = data.blacklist;
+    this.items = data.items;
+    this.betsPlayed = data.betsPlayed;
+    this.profileCard = data.profileCard;
+    this.daily = data?.daily;
+
+    this.createdAt = data?.createdAt ? new Date(data?.createdAt) : new Date();
+    this.updatedAt = data?.updatedAt ? new Date(data?.updatedAt) : new Date();
+
+    this.manager = manager;
+    this.rest = rest;
+  }
+  /** String representation of this user */
+  toString() {
+    return `<@${this.id}>`;
+  }
+  /**
+   * Fetches the user
+   * @returns New Instance of the user
+   */
+  async fetch() {
+    const route = Routes.guilds.betUsers.get(this.manager.guild.id, this.id);
+    const response = await this.rest.request<APIGuildBetUser, {}>({
+      method: "get",
+      url: route,
+    });
+    const user = new GuildBetUser(response, this.manager, this.rest);
+
+    this.manager.cache.set(user.id, user);
+    this.rest.betUsers.set(user.id, user);
+    return user;
+  }
+
+  /**
+   * Add a propery
+   * @param key The desired key
+   * @param value The desired value
+   * @returns GuildBetUser
+   */
+  async add<K extends keyof BetUserAddOptions, V extends BetUserAddOptions[K]>(
+    key: K,
+    value: V
+  ) {
+    const route = Routes.guilds.betUsers.resource(
+      this.manager.guild.id,
+      this.id,
+      key
+    );
+    const payload = { [key]: value, name: this.name };
+
+    const resp = await this.rest.request<APIGuildBetUser, typeof payload>({
+      method: "patch",
+      url: route,
+      payload,
+    });
+
+    this[key] = resp[key];
+    this.manager.cache.set(this.id, this);
+    this.rest.betUsers.set(this.id, this);
+    return this;
+  }
+
+  /**
+   * Set the user blacklist
+   * @param value Value to set to
+   * @returns GuildBetUser
+   */
+  async setBlacklist(value: boolean) {
+    const route = Routes.guilds.betUsers.resource(
+      this.manager.guild.id,
+      this.id,
+      "blacklist"
+    );
+    const payload = { value, name: this.name };
+    await this.rest.request<APIGuildBetUser, typeof payload>({
+      method: "patch",
+      url: route,
+      payload,
+    });
+    this.blacklist = value;
+    this.manager.cache.set(this.id, this);
+    this.rest.betUsers.set(this.id, this);
+    return this;
+  }
+
+  /**
+   * Update certain property
+   * @param data The new data to update with
+   * @returns
+   */
+  async update(
+    data: Omit<Optional<APIGuildBetUser>, "daily"> & { type?: "add" | "remove" }
+  ) {
+    const route = Routes.guilds.betUsers.get(this.manager.guild.id, this.id);
+    const payload: Record<string, any> = {};
+
+    const numericFields = [
+      "coins",
+      "wins",
+      "credit",
+      "losses",
+      "mvps",
+    ] as const;
+    const arrayFields = ["items", "betsPlayed"] as const;
+
+    if (data.type === "add" || data.type === "remove") {
+      for (const key in data) {
+        if (key === "type") continue;
+
+        const value = data[key as keyof typeof data];
+
+        if (numericFields.includes(key as any)) {
+          const current = this[key as keyof typeof this] as number;
+          const num = value as number;
+          payload[key] = Math.max(
+            0,
+            data.type === "add" ? current + num : num - current
+          );
+        } else if (key === "blacklist") {
+          payload["blacklist"] = value;
+        } else if (arrayFields.includes(key as any)) {
+          const current = this[key as keyof typeof this] as any[];
+          const incoming = value as any[];
+
+          payload[key] =
+            data.type === "add"
+              ? [...new Set([...current, ...incoming])]
+              : current.filter((x) => !incoming.includes(x));
+        }
+      }
+    }
+
+    const response = await this.rest.request<APIGuildBetUser, typeof payload>({
+      method: "patch",
+      url: route,
+      payload,
+    });
+
+    for (const k in response) {
+      if (k === "id") continue;
+      if (Object.hasOwn(this, k)) {
+        (this as any)[k] = response[k as keyof APIGuildBetUser];
+      }
+    }
+    this.rest.betUsers.set(this.id, this);
+    this.manager.cache.set(this.id, this);
+    return this;
+  }
+  async delete() {
+    const route = Routes.guilds.betUsers.delete(this.manager.guild.id, this.id);
+    const response = await this.rest.request<boolean, {}>({
+      method: "DELETE",
+      url: route,
+    });
+
+    this.rest.emit("betUserDelete", this);
+    this.manager.cache.delete(this.id);
+    this.rest.betUsers.set(this.id, this);
+    return response;
+  }
+  toJSON() {
+    const json: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(this)) {
+      if (typeof value !== "function") {
+        json[key] = value;
+      }
+    }
+    return json;
+  }
+}
+
+export type BetUserAddOptions = {
+  coins: number;
+  credit: number;
+  wins: number;
+  losses: number;
+  mvps: number;
+};

package/src/structures/channel/Channel.ts

@@ -0,0 +1,78 @@
+import { ChannelManager } from "../../managers/channel/ChannelManager";
+import { REST } from "../../rest/REST";
+import { APIBaseChannel } from "../../types/api/APIBaseChannel";
+import { APIBetChannel } from "../../types/api/APIBetChannel";
+import { Assertion } from "../../utils/Assertion";
+import { GuildBet } from "../bet/GuildBet";
+import { Guild } from "../guild/Guild";
+import { GuildMatch } from "../match/GuildMatch";
+
+export interface ChannelData<S extends GuildBet | GuildMatch> {
+  baseUrl: string;
+
+  data: APIBaseChannel;
+  guild: Guild;
+  manager: ChannelManager<S>;
+}
+export class Channel<S extends GuildBet | GuildMatch> {
+  /** Channel's type */
+  type: string;
+
+  /** Channel's id */
+  id: string;
+
+  /** Creation Date */
+  createdAt: Date;
+
+  /** Updated Date */
+  updatedAt: Date;
+
+  data: ChannelData<S>;
+  rest: REST;
+  baseUrl: string;
+  guild: Guild;
+  manager: ChannelManager<S>;
+  constructor(data: ChannelData<S>, rest: REST) {
+    this.type = data?.data?.type;
+    this.id = data?.data?.id;
+    this.createdAt = data?.data?.createdAt
+      ? new Date(data?.data?.createdAt)
+      : new Date();
+    this.updatedAt = data?.data?.updatedAt
+      ? new Date(data?.data?.updatedAt)
+      : new Date();
+
+    this.guild = data?.guild;
+
+    this.manager = data?.manager;
+    this.baseUrl = data.baseUrl;
+
+    this.data = data;
+    this.rest = rest;
+  }
+  toString() {
+    return `<#${this.id}>`;
+  }
+  async setId(id: string) {
+    Assertion.assertString(id);
+
+    const payload = { id };
+    const response = await this.rest.request<APIBetChannel, typeof payload>({
+      method: "PATCH",
+      url: this.baseUrl,
+      payload,
+    });
+
+    this.id = response.id;
+    return this;
+  }
+  async delete() {
+    await this.rest.request<APIBetChannel, {}>({
+      method: "delete",
+      url: this.baseUrl,
+    });
+
+    this.manager.cache.delete(this.type);
+    return this;
+  }
+}