discord.txt

/*
  vars
  .channels {channel collection}
  .debug {boolean} - Displays debug messages
  .token {string} - set token with login() function only
  .guilds {guild collection} 
  .ready {boolean} - client loaded all info
  .webhooks {webhook collection}
  .users {user collection} - All users

  funcs
  .login(token)
  .newRichEmbed()
  
  events
  *onReady()
  *onSynced()
  onError(error)

  Notes:
  * Not all data will be ready when called
*/

const CACHE_TIME = 3600 * 2; // two hours

/*
  Predefine collections
*/
function onCreated() {
  this.ready    = false;
  this.guilds   = new TCollection().init("guilds",   this);
  this.channels = new TCollection().init("channels", this);
  this.webhooks = new TCollection().init("webhooks", this);
  this.users    = new TCollection().init("users",    this);
}

/*
  Caches app details and joined guilds.

  @param {string} token - Your applications token, optional to include token type.
*/
public function login(temp.token) {
  RC.debug("Client logging in (not really)");

  if (token.starts("Bearer"))
    return RC.error("Discord class doesn't support bearer token types, only bot");

  if (!token.starts("Bot"))
    token = "Bot" SPC temp.token;

  this.token    = temp.token;
  this.starting = true;

  this._syncAttempts = 0;
  temp.success = onSyncGuilds();

  if (temp.success) {
    this.starting = false;
    this.ready    = true;
    
    this.trigger("onReady");
    this.scheduleEvent(CACHE_TIME, "onSyncGuilds", null);
  }
}

/*
  Will begin to cache client and guild data

  @return {boolean} - Was successfull
*/
public function onSyncGuilds() {
  // Sync main data
  if (!this.cacheClientUser() || !this.cacheGuilds() || !this.cacheChannels()) {
    this._syncAttempts ++;
    temp.seconds = 15 * this._syncAttempts;
    this.triggerError(format("Failed to sync, will try again in %s", temp.seconds));
    this.scheduleEvent(temp.seconds, "onSyncGuilds", null);
    return false;
  }

  // Continue to sync other data w/o interruption
  this.scheduleEvent(this, "onSyncContinue", null);

  this.trigger("onSynced");
  RC.debug("Client resynced");

  // First time syncing
  if (!this.ready && this.starting) {
    this.starting = false;
    this.ready    = true;
    this.trigger("onReady");    
  }
  
  return true;
}

function onSyncContinue() {
  this.cacheWebhooks();
  this.cacheUsers();
}

/*
  Sync application details
  
  @return {boolean} - Successfull or not
*/
function cacheClientUser() {
  temp.req = this.makeRequest("get", this.endpoints.me, null, null, null, false);
  
  if (this.checkForError(temp.req) == true) return;
  
  temp.vars = temp.req.getdynamicvarnames();
  for (temp.var : temp.vars)
    this.user.(@ temp.var) = temp.req.(@ temp.var);

  return true;
}

/*
  Sync guilds client is in
  
  @return {boolean} - Successfull or not
*/
function cacheGuilds() {
  temp.req = this.makeRequest("get", this.endpoints.me.guilds, null, null, null, false);

  if (this.checkForError(temp.req) == true) return;
    
  for (temp.guild : temp.req) {
    temp.guild.join("discord_guild");
    temp.guild.init(this);
    this.guilds.add(temp.guild);
  }
  
  return true;
}

/*
  Sync all channel types
  
  @return {boolean} - Successfull or not
*/
function cacheChannels() {
  // Guild channels
  for (temp.guild : this.guilds) {
    temp.guild.channels = new TCollection().init("channels", temp.guild);
    
    temp.url = format(this.endpoints.guild.channels, temp.guild.id, "", false);
    temp.req = this.makeRequest("get", temp.url, null, null, null, false);

    if (checkForError(temp.req) == true) 
      return;
      
    for (temp.channel : temp.req) {
      temp.channel.join("discord_channel");
      temp.channel.init(this);
      this.channels.add(temp.channel);
      temp.guild.channels.add(temp.channel);
    }
  }

  // Private channels
  temp.req = this.makeRequest("get", this.endpoints.me.channels, null, null, null, false);
  
  if (checkForError(temp.req) == true) 
    return;

  for (temp.channel : temp.req) {
    temp.channel.join("discord_channel");
    temp.channel.init(this);
    this.channels.add(temp.channel);
  }
  
  return true;
}

/*
  Sync webhooks from all guilds
  
  @return {boolean} - Successfull or not
*/
function cacheWebhooks() {
  for (temp.guild : this.guilds) {
    temp.guild.webhooks = new TCollection().init("webhooks", temp.guild);
    
    temp.url = format(this.endpoints.guild.webhooks, temp.guild.id);
    temp.req = this.makeRequest("get", temp.url, null, null, null, false);
    
    if (this.checkForError(temp.req) == true) 
      return false;
    
    for (temp.webhook : temp.req) {
      temp.webhook.join("discord_webhook");
      temp.webhook.init(this);
      this.webhooks.add(temp.webhook);
      temp.guild.webhooks.add(temp.webhook);
      //TODO: Add to appropriate channel
    }
  }
  
  return true; 
}

/*
  Sync users and members
  
  @return {boolean} - Successfull or not  
*/
function cacheUsers() {
  for (temp.guild : this.guilds) {
    temp.guild.members = new TCollection().init("members", temp.guild);

    temp.req = this.makeRequest("get", format(this.endpoints.guild.members, temp.guild.id), {
      {"limit", 1000}
    }, null, null, false);
    
    if (this.checkForError(temp.req) == true) 
      return false;
    
    for (temp.member : temp.req) {
      temp.member.join("discord_member");
      temp.member.user.join("discord_user");
      temp.member.user.init(this);
      temp.member.init(this);
      this.users.add(temp.member.user);
      temp.guild.members.add(temp.member);
    }
  }

  return true;
}

/*
  Emebed object that can be parsed into json string

  @return TStaticVar
*/
public function newRichEmbed() {
  // yes all this is needed
  temp.obj            = new TStaticVar();
  temp.obj.base       = new TStaticVar();
  temp.obj.base.embed = new TStaticVar();
  temp.obj.join("discord_embed");
  return temp.obj;
}

/*
  Triggers error event with message

  @param {string} error - Error message to display
*/
public function triggerError(temp.error) 
  this.trigger("onError", temp.error);