mij-discord 1.0.5 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5fcf947865936bee821151da5e83bef481fd163
-  data.tar.gz: 97545b505d78aae0d38a65efe7d6608d41f2cb30
+  metadata.gz: a986d989e1c82e40f9c1c5346b3496a402491f3e
+  data.tar.gz: 8db9cd45703269a7c40e03beccc2c4dcf272b0d3
 SHA512:
-  metadata.gz: 684a85c5f4d1aea724672abe6d343eea34cc67dfca1e8cbaaa65ee6c4debb2fd9a83febfe5c98cc6586480070aed222ae9d08ce1b9ba1e287a46fd4ca07e3c2f
-  data.tar.gz: cda5fe4edf5ee6021610c4cf637b1ca598ebe8710dd3b88c3cce9b1ea2de7783e386642b6d81ba597b4bbe741f03500d2de117f2cd35bd94d6ca83827f353d75
+  metadata.gz: 31147c15e9b63573c41bba6b700b9be15002be8b7262ca42c2fc50a7fc0ed7486ca08e6833a98ee53f58a4cbbdc151d05b6a43ee0da399698f291b7925100e9c
+  data.tar.gz: e5d0c9e7383b825b8bb513177361cb9dbd56650fd8f3563ca18c878ac3a9269f816f2b3d84e43c5d18b97ac15b41f43316e5831d69f920cf828781cb5c31686a

data/lib/mij-discord/bot.rb

@@ -2,6 +2,18 @@
 
 module MijDiscord
   class Bot
+    class AuthInfo
+      attr_reader :token
+
+      attr_reader :type
+
+      def initialize(token, type)
+        @token, @type = token, type
+      end
+
+      alias_method :to_s, :token
+    end
+
     EVENTS = {
       ready: MijDiscord::Events::Ready,
       heartbeat: MijDiscord::Events::Heartbeat,
@@ -48,24 +60,13 @@ module MijDiscord
 
     UNAVAILABLE_SERVER_TIMEOUT = 10
 
-    USER_STATUS = {
-      online: :online,
-      idle: :idle,
-      away: :idle,
-      dnd: :dnd,
-      busy: :dnd,
-      invisible: :invisible,
-      hidden: :invisible,
-      offline: :offline
-    }.freeze
+    USER_STATUS = [:online, :idle, :dnd, :invisible, :offline].freeze
 
     attr_reader :name
 
-    attr_reader :type
-
     attr_reader :client_id
 
-    attr_reader :token
+    attr_reader :auth
 
     attr_reader :shard_key
 
@@ -77,18 +78,20 @@ module MijDiscord
 
     def initialize(client_id:, token:, type: :bot, name: nil,
     shard_id: nil, num_shards: nil, ignore_bots: false, ignore_self: true)
-      @client_id, @type, @name = client_id.to_id, type, name || ''
+      @client_id, @name = client_id.to_id, name || ''
 
-      @token = case @type
+      token = case type
         when :bot then "Bot #{token}"
         when :user then "#{token}"
         else raise ArgumentError, 'Invalid bot type'
       end
 
+      @auth = AuthInfo.new(token, type)
+
       @cache = MijDiscord::Cache::BotCache.new(self)
 
       @shard_key = [shard_id, num_shards] if num_shards
-      @gateway = MijDiscord::Core::Gateway.new(self, @token, @shard_key)
+      @gateway = MijDiscord::Core::Gateway.new(self, @auth, @shard_key)
 
       @ignore_bots, @ignore_self, @ignored_ids = ignore_bots, ignore_self, Set.new
 
@@ -189,19 +192,19 @@ module MijDiscord
     def application
       raise 'Cannot get OAuth application for non-bot user' if @type != :bot
 
-      response = MijDiscord::Core::API.oauth_application(@token)
+      response = MijDiscord::Core::API.oauth_application(@auth)
       MijDiscord::Data::Application.new(JSON.parse(response), self)
     end
 
     def invite(invite)
       code = parse_invite_code(invite)
-      response = MijDiscord::Core::API::Invite.resolve(@token, code)
+      response = MijDiscord::Core::API::Invite.resolve(@auth, code)
       MijDiscord::Data::Invite.new(JSON.parse(response), self)
     end
 
     def accept_invite(invite)
       code = parse_invite_code(invite)
-      MijDiscord::Core::API::Invite.accept(@token, code)
+      MijDiscord::Core::API::Invite.accept(@auth, code)
       nil
     end
 
@@ -213,7 +216,7 @@ module MijDiscord
     end
 
     def create_server(name, region = 'eu-central')
-      response = API::Server.create(@token, name, region)
+      response = API::Server.create(@auth, name, region)
       id = JSON.parse(response)['id'].to_i
 
       loop do
@@ -296,7 +299,7 @@ module MijDiscord
     def change_status(status: nil, game: nil, url: nil)
       gateway_check
 
-      status = status.nil? ? @profile.status : USER_STATUS[status]
+      status = status.nil? ? @profile.status : USER_STATUS.find(status)
       raise ArgumentError, "Status '#{status}' is not valid" unless status
 
       game_obj = case game
@@ -391,7 +394,7 @@ module MijDiscord
           server = @cache.remove_server(data['id'])
 
           if data['unavailable'].eql?(true)
-            MijDiscord::LOGGER.warn('Dispatch') { "Server <#{server.id}> died due to outage" }
+            MijDiscord::LOGGER.warn('Dispatch') { "Server <#{data['id']}> died due to outage" }
             return
           end
 

data/lib/mij-discord/cache.rb

@@ -31,7 +31,7 @@ module MijDiscord::Cache
       return nil if local
 
       begin
-        response = MijDiscord::Core::API::Server.resolve(@bot.token, id)
+        response = MijDiscord::Core::API::Server.resolve(@bot.auth, id)
       rescue RestClient::ResourceNotFound
         return nil
       end
@@ -46,7 +46,7 @@ module MijDiscord::Cache
       return nil if local
 
       begin
-        response = MijDiscord::Core::API::Channel.resolve(@bot.token, id)
+        response = MijDiscord::Core::API::Channel.resolve(@bot.auth, id)
       rescue RestClient::ResourceNotFound
         return nil
       rescue MijDiscord::Errors::NoPermission
@@ -69,7 +69,7 @@ module MijDiscord::Cache
       return @pm_channels[id] if @pm_channels.has_key?(id)
       return nil if local
 
-      response = MijDiscord::Core::API::User.create_pm(@bot.token, id)
+      response = MijDiscord::Core::API::User.create_pm(@bot.auth, id)
       channel = MijDiscord::Data::Channel.create(JSON.parse(response), @bot, nil)
 
       @channels[channel.id] = @pm_channels[id] = channel
@@ -81,7 +81,7 @@ module MijDiscord::Cache
       return nil if local
 
       begin
-        response = MijDiscord::Core::API::User.resolve(@bot.token, id)
+        response = MijDiscord::Core::API::User.resolve(@bot.auth, id)
       rescue RestClient::ResourceNotFound
         return nil
       end
@@ -175,7 +175,7 @@ module MijDiscord::Cache
       return nil if local
 
       begin
-        response = MijDiscord::Core::API::Server.resolve_member(@bot.token, @server.id, id)
+        response = MijDiscord::Core::API::Server.resolve_member(@bot.auth, @server.id, id)
       rescue RestClient::ResourceNotFound
         return nil
       end
@@ -267,7 +267,7 @@ module MijDiscord::Cache
       return nil if local
 
       begin
-        response = MijDiscord::Core::API::Channel.message(@bot.token, @channel.id, key)
+        response = MijDiscord::Core::API::Channel.message(@bot.auth, @channel.id, key)
       rescue RestClient::ResourceNotFound
         return nil
       end

data/lib/mij-discord/core/api.rb

@@ -8,8 +8,8 @@ module MijDiscord::Core::API
   class << self
     attr_accessor :bot_name
 
-    def user_agent(kind)
-      case kind
+    def user_agent(auth)
+      case auth&.type
         when :bot
           bot_name = @bot_name || 'generic'
           ua_base = "DiscordBot (https://github.com/Mijyuoon/mij-discord, v#{MijDiscord::VERSION})"
@@ -20,14 +20,6 @@ module MijDiscord::Core::API
       end
     end
 
-    def token_type(token)
-      case token
-        when /^Bot (.+)$/ then :bot
-        when /^mfa\.(.+)$/ then :user
-        else :user
-      end
-    end
-
     # Make an icon URL from server and icon IDs
     def icon_url(server_id, icon_id, format = :webp)
       "#{CDN_URL}/icons/#{server_id}/#{icon_id}.#{format}"
@@ -66,100 +58,100 @@ module MijDiscord::Core::API
     end
 
     # Logout from the server
-    def logout(token)
+    def logout(auth)
       request(
         :auth_logout,
         nil,
         :post,
         "#{APIBASE_URL}/auth/logout",
         nil,
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Create an OAuth application
-    def create_oauth_application(token, name, redirect_uris)
+    def create_oauth_application(auth, name, redirect_uris)
       request(
         :oauth2_applications,
         nil,
         :post,
         "#{APIBASE_URL}/oauth2/applications",
         { name: name, redirect_uris: redirect_uris }.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     end
 
     # Change an OAuth application's properties
-    def update_oauth_application(token, name, redirect_uris, description = '', icon = nil)
+    def update_oauth_application(auth, name, redirect_uris, description = '', icon = nil)
       request(
         :oauth2_applications,
         nil,
         :put,
         "#{APIBASE_URL}/oauth2/applications",
         { name: name, redirect_uris: redirect_uris, description: description, icon: icon }.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     end
 
     # Get the bot's OAuth application's information
-    def oauth_application(token)
+    def oauth_application(auth)
       request(
         :oauth2_applications_me,
         nil,
         :get,
         "#{APIBASE_URL}/oauth2/applications/@me",
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Acknowledge that a message has been received
     # The last acknowledged message will be sent in the ready packet,
     # so this is an easy way to catch up on messages
-    def acknowledge_message(token, channel_id, message_id)
+    def acknowledge_message(auth, channel_id, message_id)
       request(
         :channels_cid_messages_mid_ack,
         nil, # This endpoint is unavailable for bot accounts and thus isn't subject to its rate limit requirements.
         :post,
         "#{APIBASE_URL}/channels/#{channel_id}/messages/#{message_id}/ack",
         nil,
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Get the gateway to be used
-    def gateway(token)
+    def gateway(auth)
       request(
         :gateway,
         nil,
         :get,
         "#{APIBASE_URL}/gateway",
-        Authorization: token
+        Authorization: auth,
       )
     end
 
     # Validate a token (this request will fail if the token is invalid)
-    def validate_token(token)
+    def validate_token(auth)
       request(
         :auth_login,
         nil,
         :post,
         "#{APIBASE_URL}/auth/login",
         {}.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     end
 
     # Get a list of available voice regions
-    def voice_regions(token)
+    def voice_regions(auth)
       request(
         :voice_regions,
         nil,
         :get,
         "#{APIBASE_URL}/voice/regions",
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     end
@@ -177,8 +169,7 @@ module MijDiscord::Core::API
       ratelimit_delta, response = nil, nil
 
       if (params = attributes.last).is_a?(Hash)
-        ua_type = token_type(params[:Authorization])
-        params[:user_agent] = user_agent(ua_type)
+        params[:user_agent] = user_agent(params[:Authorization])
         ratelimit_delta = params.delete(:header_bypass_delay)
       end
 

data/lib/mij-discord/core/api/channel.rb

@@ -4,19 +4,19 @@ module MijDiscord::Core::API::Channel
   class << self
     # Get a channel's data
     # https://discordapp.com/developers/docs/resources/channel#get-channel
-    def resolve(token, channel_id)
+    def resolve(auth, channel_id)
       MijDiscord::Core::API.request(
         :channels_cid,
         channel_id,
         :get,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}",
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Update a channel's data
     # https://discordapp.com/developers/docs/resources/channel#modify-channel
-    def update(token, channel_id, name, topic, nsfw, parent_id, position, bitrate, user_limit, overwrites, reason = nil)
+    def update(auth, channel_id, name, topic, nsfw, parent_id, position, bitrate, user_limit, overwrites, reason = nil)
       MijDiscord::Core::API.request(
         :channels_cid,
         channel_id,
@@ -28,7 +28,7 @@ module MijDiscord::Core::API::Channel
           bitrate: bitrate, user_limit: user_limit,
           permission_overwrites: overwrites
         }.delete_if {|_, v| v.nil? }.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json,
         'X-Audit-Log-Reason': reason
       )
@@ -36,51 +36,51 @@ module MijDiscord::Core::API::Channel
 
     # Delete a channel
     # https://discordapp.com/developers/docs/resources/channel#deleteclose-channel
-    def delete(token, channel_id, reason = nil)
+    def delete(auth, channel_id, reason = nil)
       MijDiscord::Core::API.request(
         :channels_cid,
         channel_id,
         :delete,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}",
-        Authorization: token,
+        Authorization: auth,
         'X-Audit-Log-Reason': reason
       )
     end
 
     # Get a list of messages from a channel's history
     # https://discordapp.com/developers/docs/resources/channel#get-channel-messages
-    def messages(token, channel_id, amount, before = nil, after = nil, around = nil)
+    def messages(auth, channel_id, amount, before = nil, after = nil, around = nil)
       MijDiscord::Core::API.request(
         :channels_cid_messages,
         channel_id,
         :get,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages?limit=#{amount}#{"&before=#{before}" if before}#{"&after=#{after}" if after}#{"&around=#{around}" if around}",
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Get a single message from a channel's history by id
     # https://discordapp.com/developers/docs/resources/channel#get-channel-message
-    def message(token, channel_id, message_id)
+    def message(auth, channel_id, message_id)
       MijDiscord::Core::API.request(
         :channels_cid_messages_mid,
         channel_id,
         :get,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages/#{message_id}",
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Send a message to a channel
     # https://discordapp.com/developers/docs/resources/channel#create-message
-    def create_message(token, channel_id, message, tts = false, embed = nil, mentions = [])
+    def create_message(auth, channel_id, message, tts = false, embed = nil, mentions = [])
       MijDiscord::Core::API.request(
         :channels_cid_messages_mid,
         channel_id,
         :post,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages",
         { content: message, mentions: mentions, tts: tts, embed: embed }.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     rescue RestClient::BadRequest => e
@@ -93,60 +93,60 @@ module MijDiscord::Core::API::Channel
 
     # Send a file as a message to a channel
     # https://discordapp.com/developers/docs/resources/channel#upload-file
-    def upload_file(token, channel_id, file, caption = nil, tts = false)
+    def upload_file(auth, channel_id, file, caption = nil, tts = false)
       MijDiscord::Core::API.request(
         :channels_cid_messages_mid,
         channel_id,
         :post,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages",
         { file: file, content: caption, tts: tts },
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Edit a message
     # https://discordapp.com/developers/docs/resources/channel#edit-message
-    def edit_message(token, channel_id, message_id, message, mentions = [], embed = nil)
+    def edit_message(auth, channel_id, message_id, message, mentions = [], embed = nil)
       MijDiscord::Core::API.request(
         :channels_cid_messages_mid,
         channel_id,
         :patch,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages/#{message_id}",
         { content: message, mentions: mentions, embed: embed }.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     end
 
     # Delete a message
     # https://discordapp.com/developers/docs/resources/channel#delete-message
-    def delete_message(token, channel_id, message_id)
+    def delete_message(auth, channel_id, message_id)
       MijDiscord::Core::API.request(
         :channels_cid_messages_mid,
         channel_id,
         :delete,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages/#{message_id}",
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Delete messages in bulk
     # https://discordapp.com/developers/docs/resources/channel#bulk-delete-messages
-    def bulk_delete_messages(token, channel_id, messages = [])
+    def bulk_delete_messages(auth, channel_id, messages = [])
       MijDiscord::Core::API.request(
         :channels_cid_messages_bulk_delete,
         channel_id,
         :post,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages/bulk-delete",
         { messages: messages }.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     end
 
     # Create a reaction on a message using this client
     # https://discordapp.com/developers/docs/resources/channel#create-reaction
-    def create_reaction(token, channel_id, message_id, emoji)
+    def create_reaction(auth, channel_id, message_id, emoji)
       emoji = URI.encode(emoji) unless emoji.ascii_only?
       MijDiscord::Core::API.request(
         :channels_cid_messages_mid_reactions_emoji_me,
@@ -154,7 +154,7 @@ module MijDiscord::Core::API::Channel
         :put,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages/#{message_id}/reactions/#{emoji}/@me",
         nil,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json,
         header_bypass_delay: 0.25
       )
@@ -162,67 +162,67 @@ module MijDiscord::Core::API::Channel
 
     # Delete this client's own reaction on a message
     # https://discordapp.com/developers/docs/resources/channel#delete-own-reaction
-    def delete_own_reaction(token, channel_id, message_id, emoji)
+    def delete_own_reaction(auth, channel_id, message_id, emoji)
       emoji = URI.encode(emoji) unless emoji.ascii_only?
       MijDiscord::Core::API.request(
         :channels_cid_messages_mid_reactions_emoji_me,
         channel_id,
         :delete,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages/#{message_id}/reactions/#{emoji}/@me",
-        Authorization: token,
+        Authorization: auth,
         header_bypass_delay: 0.25
       )
     end
 
     # Delete another client's reaction on a message
     # https://discordapp.com/developers/docs/resources/channel#delete-user-reaction
-    def delete_user_reaction(token, channel_id, message_id, emoji, user_id)
+    def delete_user_reaction(auth, channel_id, message_id, emoji, user_id)
       emoji = URI.encode(emoji) unless emoji.ascii_only?
       MijDiscord::Core::API.request(
         :channels_cid_messages_mid_reactions_emoji_uid,
         channel_id,
         :delete,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages/#{message_id}/reactions/#{emoji}/#{user_id}",
-        Authorization: token,
+        Authorization: auth,
         header_bypass_delay: 0.25
       )
     end
 
     # Get a list of clients who reacted with a specific reaction on a message
     # https://discordapp.com/developers/docs/resources/channel#get-reactions
-    def get_reactions(token, channel_id, message_id, emoji)
+    def get_reactions(auth, channel_id, message_id, emoji)
       emoji = URI.encode(emoji) unless emoji.ascii_only?
       MijDiscord::Core::API.request(
         :channels_cid_messages_mid_reactions_emoji,
         channel_id,
         :get,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages/#{message_id}/reactions/#{emoji}",
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Deletes all reactions on a message from all clients
     # https://discordapp.com/developers/docs/resources/channel#delete-all-reactions
-    def delete_all_reactions(token, channel_id, message_id)
+    def delete_all_reactions(auth, channel_id, message_id)
       MijDiscord::Core::API.request(
         :channels_cid_messages_mid_reactions,
         channel_id,
         :delete,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/messages/#{message_id}/reactions",
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Update a channels permission for a role or member
     # https://discordapp.com/developers/docs/resources/channel#edit-channel-permissions
-    def update_permission(token, channel_id, overwrite_id, allow, deny, type, reason = nil)
+    def update_permission(auth, channel_id, overwrite_id, allow, deny, type, reason = nil)
       MijDiscord::Core::API.request(
         :channels_cid_permissions_oid,
         channel_id,
         :put,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/permissions/#{overwrite_id}",
         { type: type, id: overwrite_id, allow: allow, deny: deny }.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json,
         'X-Audit-Log-Reason': reason
       )
@@ -230,26 +230,26 @@ module MijDiscord::Core::API::Channel
 
     # Get a channel's invite list
     # https://discordapp.com/developers/docs/resources/channel#get-channel-invites
-    def invites(token, channel_id)
+    def invites(auth, channel_id)
       MijDiscord::Core::API.request(
         :channels_cid_invites,
         channel_id,
         :get,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/invites",
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Create an instant invite from a server or a channel id
     # https://discordapp.com/developers/docs/resources/channel#create-channel-invite
-    def create_invite(token, channel_id, max_age = 0, max_uses = 0, temporary = false, unique = false, reason = nil)
+    def create_invite(auth, channel_id, max_age = 0, max_uses = 0, temporary = false, unique = false, reason = nil)
       MijDiscord::Core::API.request(
         :channels_cid_invites,
         channel_id,
         :post,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/invites",
         { max_age: max_age, max_uses: max_uses, temporary: temporary, unique: unique }.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json,
         'X-Audit-Log-Reason': reason
       )
@@ -257,89 +257,89 @@ module MijDiscord::Core::API::Channel
 
     # Delete channel permission
     # https://discordapp.com/developers/docs/resources/channel#delete-channel-permission
-    def delete_permission(token, channel_id, overwrite_id, reason = nil)
+    def delete_permission(auth, channel_id, overwrite_id, reason = nil)
       MijDiscord::Core::API.request(
         :channels_cid_permissions_oid,
         channel_id,
         :delete,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/permissions/#{overwrite_id}",
-        Authorization: token,
+        Authorization: auth,
         'X-Audit-Log-Reason': reason
       )
     end
 
     # Start typing (needs to be resent every 5 seconds to keep up the typing)
     # https://discordapp.com/developers/docs/resources/channel#trigger-typing-indicator
-    def start_typing(token, channel_id)
+    def start_typing(auth, channel_id)
       MijDiscord::Core::API.request(
         :channels_cid_typing,
         channel_id,
         :post,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/typing",
         nil,
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Get a list of pinned messages in a channel
     # https://discordapp.com/developers/docs/resources/channel#get-pinned-messages
-    def pinned_messages(token, channel_id)
+    def pinned_messages(auth, channel_id)
       MijDiscord::Core::API.request(
         :channels_cid_pins,
         channel_id,
         :get,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/pins",
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Pin a message
     # https://discordapp.com/developers/docs/resources/channel#add-pinned-channel-message
-    def pin_message(token, channel_id, message_id)
+    def pin_message(auth, channel_id, message_id)
       MijDiscord::Core::API.request(
         :channels_cid_pins_mid,
         channel_id,
         :put,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/pins/#{message_id}",
         nil,
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Unpin a message
     # https://discordapp.com/developers/docs/resources/channel#delete-pinned-channel-message
-    def unpin_message(token, channel_id, message_id)
+    def unpin_message(auth, channel_id, message_id)
       MijDiscord::Core::API.request(
         :channels_cid_pins_mid,
         channel_id,
         :delete,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/pins/#{message_id}",
-        Authorization: token
+        Authorization: auth
       )
     end
 
     # Create an empty group channel.
-    def create_empty_group(token, bot_user_id)
+    def create_empty_group(auth, bot_user_id)
       MijDiscord::Core::API.request(
         :users_uid_channels,
         nil,
         :post,
         "#{MijDiscord::Core::API::APIBASE_URL}/users/#{bot_user_id}/channels",
         {}.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     end
 
     # Create a group channel.
-    def create_group(token, pm_channel_id, user_id)
+    def create_group(auth, pm_channel_id, user_id)
       MijDiscord::Core::API.request(
         :channels_cid_recipients_uid,
         nil,
         :put,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{pm_channel_id}/recipients/#{user_id}",
         {}.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     rescue RestClient::InternalServerError
@@ -351,52 +351,52 @@ module MijDiscord::Core::API::Channel
     end
 
     # Add a user to a group channel.
-    def add_group_user(token, group_channel_id, user_id)
+    def add_group_user(auth, group_channel_id, user_id)
       MijDiscord::Core::API.request(
         :channels_cid_recipients_uid,
         nil,
         :put,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{group_channel_id}/recipients/#{user_id}",
         {}.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     end
 
     # Remove a user from a group channel.
-    def remove_group_user(token, group_channel_id, user_id)
+    def remove_group_user(auth, group_channel_id, user_id)
       MijDiscord::Core::API.request(
         :channels_cid_recipients_uid,
         nil,
         :delete,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{group_channel_id}/recipients/#{user_id}",
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     end
 
     # Leave a group channel.
-    def leave_group(token, group_channel_id)
+    def leave_group(auth, group_channel_id)
       MijDiscord::Core::API.request(
         :channels_cid,
         nil,
         :delete,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{group_channel_id}",
-        Authorization: token,
+        Authorization: auth,
         content_type: :json
       )
     end
 
     # Create a webhook
     # https://discordapp.com/developers/docs/resources/webhook#create-webhook
-    def create_webhook(token, channel_id, name, avatar = nil, reason = nil)
+    def create_webhook(auth, channel_id, name, avatar = nil, reason = nil)
       MijDiscord::Core::API.request(
         :channels_cid_webhooks,
         channel_id,
         :post,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/webhooks",
         { name: name, avatar: avatar }.to_json,
-        Authorization: token,
+        Authorization: auth,
         content_type: :json,
         'X-Audit-Log-Reason': reason
       )
@@ -404,13 +404,13 @@ module MijDiscord::Core::API::Channel
 
     # Get channel webhooks
     # https://discordapp.com/developers/docs/resources/webhook#get-channel-webhooks
-    def webhooks(token, channel_id)
+    def webhooks(auth, channel_id)
       MijDiscord::Core::API.request(
         :channels_cid_webhooks,
         channel_id,
         :get,
         "#{MijDiscord::Core::API::APIBASE_URL}/channels/#{channel_id}/webhooks",
-        Authorization: token
+        Authorization: auth
       )
     end
   end