selfbot-discord/src/client/ClientDataManager.js

Module discord.js v11 modifié

const Constants = require('../util/Constants');
const Util = require('../util/Util');
const Guild = require('../structures/Guild');
const User = require('../structures/User');
const Emoji = require('../structures/Emoji');
const GuildChannel = require('../structures/GuildChannel');
const TextChannel = require('../structures/TextChannel');
const VoiceChannel = require('../structures/VoiceChannel');
const CategoryChannel = require('../structures/CategoryChannel');
const NewsChannel = require('../structures/NewsChannel');
const StoreChannel = require('../structures/StoreChannel');
const DMChannel = require('../structures/DMChannel');
const GroupDMChannel = require('../structures/GroupDMChannel');

class ClientDataManager {
  constructor(client) {
    this.client = client;
  }

  get pastReady() {
    return this.client.ws.connection.status === Constants.Status.READY;
  }

  newGuild(data) {
    const already = this.client.guilds.has(data.id);
    const guild = new Guild(this.client, data);
    this.client.guilds.set(guild.id, guild);
    if (this.pastReady && !already) {
      /**
       * Emitted whenever the client joins a guild.
       * @event Client#guildCreate
       * @param {Guild} guild The created guild
       */
      if (this.client.options.fetchAllMembers) {
        guild.fetchMembers().then(() => { this.client.emit(Constants.Events.GUILD_CREATE, guild); });
      } else {
        this.client.emit(Constants.Events.GUILD_CREATE, guild);
      }
    }

    return guild;
  }

  newUser(data, cache = true) {
    if (this.client.users.has(data.id)) return this.client.users.get(data.id);
    const user = new User(this.client, data);
    if (cache) this.client.users.set(user.id, user);
    return user;
  }

  newChannel(data, guild) {
    const already = this.client.channels.has(data.id);
    let channel;

    if (data.type === Constants.ChannelTypes.DM) {
      channel = new DMChannel(this.client, data);
    } else if (data.type === Constants.ChannelTypes.GROUP_DM) {
      channel = new GroupDMChannel(this.client, data);
    } else {
      guild = guild || this.client.guilds.get(data.guild_id);
      if (already) {
        channel = this.client.channels.get(data.id);
      } else if (guild) {
        switch (data.type) {
          case Constants.ChannelTypes.TEXT:
            channel = new TextChannel(guild, data);
            break;
          case Constants.ChannelTypes.VOICE:
            channel = new VoiceChannel(guild, data);
            break;
          case Constants.ChannelTypes.CATEGORY:
            channel = new CategoryChannel(guild, data);
            break;
          case Constants.ChannelTypes.NEWS:
            channel = new NewsChannel(guild, data);
            break;
          case Constants.ChannelTypes.STORE:
            channel = new StoreChannel(guild, data);
            break;
        }

        if (channel) guild.channels.set(channel.id, channel);
      }
    }

    if (channel && !already) {
      if (this.pastReady) this.client.emit(Constants.Events.CHANNEL_CREATE, channel);
      this.client.channels.set(channel.id, channel);
      return channel;
    } else if (already) {
      return channel;
    }

    return null;
  }

  newEmoji(data, guild) {
    const already = guild.emojis.has(data.id);
    if (data && !already) {
      let emoji = new Emoji(guild, data);
      this.client.emit(Constants.Events.GUILD_EMOJI_CREATE, emoji);
      guild.emojis.set(emoji.id, emoji);
      return emoji;
    } else if (already) {
      return guild.emojis.get(data.id);
    }

    return null;
  }

  async newRelation(data) {
    if (data) {
      let user = this.client.users.has(data.id) ? this.client.users.get(data.id) : this.newUser(data.user);
      let type = Constants.RelationshipTypes[data.type] || data.type;
      let relation = {
        id: data.id,
        type,
        user
      }
      // if (!relation.user?.id) relation.user = await this.client.fetchUser(data.id).catch(console.error);
      this.client.emit(Constants.Events.RELATIONSHIP_ADD, relation);
      return relation;
    } else return null;
  }

  killEmoji(emoji) {
    if (!(emoji instanceof Emoji && emoji.guild)) return;
    this.client.emit(Constants.Events.GUILD_EMOJI_DELETE, emoji);
    emoji.guild.emojis.delete(emoji.id);
  }

  async killRelation(data) {
    let user = this.client.users.has(data.id) ? this.client.users.get(data.id) : this.newUser(data.id);
    let type = Constants.RelationshipTypes[data.type] || data.type;
    let relation = {
      id: data.id,
      type,
      user
    }
    if (!relation.user.id) relation.user = await this.client.fetchUser(data.id);
    this.client.emit(Constants.Events.RELATIONSHIP_REMOVE, relation);
    return relation;
  }

  killGuild(guild) {
    const already = this.client.guilds.has(guild.id);
    this.client.guilds.delete(guild.id);
    if (already && this.pastReady) this.client.emit(Constants.Events.GUILD_DELETE, guild);
  }

  killUser(user) {
    this.client.users.delete(user.id);
  }

  killChannel(channel) {
    this.client.channels.delete(channel.id);
    if (channel instanceof GuildChannel) channel.guild.channels.delete(channel.id);
  }

  updateGuild(currentGuild, newData) {
    const oldGuild = Util.cloneObject(currentGuild);
    currentGuild.setup(newData);
    if (this.pastReady) this.client.emit(Constants.Events.GUILD_UPDATE, oldGuild, currentGuild);
  }

  updateChannel(currentChannel, newData) {
    currentChannel.setup(newData);
  }

  updateEmoji(currentEmoji, newData) {
    const oldEmoji = Util.cloneObject(currentEmoji);
    currentEmoji.setup(newData);
    this.client.emit(Constants.Events.GUILD_EMOJI_UPDATE, oldEmoji, currentEmoji);
    return currentEmoji;
  }
}

module.exports = ClientDataManager;