pusher-chatkit-server 0.7.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 97b9c094a0c0badebd620b39d97a9c02588be71f5a7e71fbf673956ad4f21ad7
-  data.tar.gz: f88fd18b50cddb239d9e04c103a4da55d182cb16a39a123400462b2903ec5fd2
+SHA1:
+  metadata.gz: fd50747b8046dc072876ab55a6d14fdeff1ced9b
+  data.tar.gz: d7cf32176bd955ac6fec9688dc6084848206d5e1
 SHA512:
-  metadata.gz: 360a38b3e0cdffa1a2714d084613f6e145976c9daf333a2f122f784d2082e9744b099ef896d73164b97fa7de9d3fc9fb81107ab73fc213312f5aaba8b22c2f92
-  data.tar.gz: 4107ba5646b2804e3ae5041014984939a6fb20d44233f432698a380458ccf72439ba2cf7383f79471f6c32d284a6b7a8947d21e40c03f6b7ca23c4dcb86a1ee7
+  metadata.gz: a3bdffe4d4c45b5b327d37da0d203a4692147172045ae22e857e8052039c7090b8a1dd583bb3a394434063792a7f8dc2f07150e859bf2894676acd54cac432c2
+  data.tar.gz: ed6bbf3cb9da4888ebfb9780cb19b30217a86251681fc50817fc45e73b062f5716a5034098b91ddb4d1bcd8715164ccc08cfe3c850b0e7066182ada9f68c2595

data/lib/chatkit/client.rb

@@ -1,15 +1,18 @@
 require 'pusher-platform'
 require 'json'
+require 'cgi'
+
+require_relative './error'
+require_relative './missing_parameter_error'
+require_relative './response_error'
 
 module Chatkit
+
   ROOM_SCOPE = "room"
   GLOBAL_SCOPE = "global"
 
-  class Error < RuntimeError
-  end
-
   class Client
-    attr_accessor :api_instance, :authorizer_instance
+    attr_accessor :api_instance, :authorizer_instance, :cursors_instance
 
     def initialize(options)
       base_options = {
@@ -17,20 +20,31 @@ module Chatkit
         key: options[:key],
         port: options[:port],
         host: options[:host],
-        client: options[:client]
+        client: options[:client],
+        sdk_info: PusherPlatform::SDKInfo.new({
+          product_name: 'chatkit',
+          version: '0.7.2'
+        })
       }
 
       @api_instance = PusherPlatform::Instance.new(
-        base_options.merge!({
+        base_options.merge({
           service_name: 'chatkit',
-          service_version: 'v1'
+          service_version: 'v2'
         })
       )
 
       @authorizer_instance = PusherPlatform::Instance.new(
-        base_options.merge!({
+        base_options.merge({
           service_name: 'chatkit_authorizer',
-          service_version: 'v1'
+          service_version: 'v2'
+        })
+      )
+
+      @cursors_instance = PusherPlatform::Instance.new(
+        base_options.merge({
+          service_name: 'chatkit_cursors',
+          service_version: 'v2'
         })
       )
     end
@@ -43,269 +57,658 @@ module Chatkit
       @api_instance.authenticate(auth_payload, { user_id: user_id })
     end
 
-    def authenticate_with_request(request, options)
-      @api_instance.authenticate_with_request(request, options)
-    end
-
     def generate_access_token(options)
+      if options.empty?
+        raise Chatkit::Error.new("You must provide a either a user_id or `su: true`")
+      end
+
       @api_instance.generate_access_token(options)
     end
 
     def generate_su_token(options = {})
-      generate_access_token({ su: true }.merge(options))[:token]
+      generate_access_token({ su: true }.merge(options))
     end
 
     # User API
 
-    def create_user(id, name, avatar_url = nil, custom_data = nil)
+    def create_user(options)
+      if options[:id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide an ID for the user you want to create")
+      end
+
+      if options[:name].nil?
+        raise Chatkit::MissingParameterError.new("You must provide a name for the user you want to create")
+      end
+
       body = {
-        id: id,
-        name: name
+        id: options[:id],
+        name: options[:name]
       }
 
-      unless avatar_url.nil?
-        body[:avatar_url] = avatar_url
+      unless options[:avatar_url].nil?
+        body[:avatar_url] = options[:avatar_url]
       end
 
-      unless custom_data.nil?
-        body[:custom_data] = custom_data
+      unless options[:custom_data].nil?
+        body[:custom_data] = options[:custom_data]
       end
 
-      @api_instance.request(
+      api_request({
         method: "POST",
         path: "/users",
-        headers: {
-          "Content-Type": "application/json",
-        },
         body: body,
-        jwt: generate_su_token
-      )
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    def create_users(options)
+      if options[:users].nil?
+        raise Chatkit::MissingParameterError.new("You must provide a list of users that you want to create")
+      end
+
+      api_request({
+        method: "POST",
+        path: "/batch_users",
+        body: options,
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    def update_user(options)
+      if options[:id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user you want to update")
+      end
+
+      payload = {}
+      payload[:name] = options[:name] unless options[:name].nil?
+      payload[:avatar_url] = options[:avatar_url] unless options[:avatar_url].nil?
+      payload[:custom_data] = options[:custom_data] unless options[:custom_data].nil?
+
+      api_request({
+        method: "PUT",
+        path: "/users/#{CGI::escape options[:id]}",
+        body: payload,
+        jwt: generate_su_token({ user_id: options[:id] })[:token]
+      })
     end
 
-    def delete_user(id)
-      @api_instance.request(
+    def delete_user(options)
+      if options[:id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user you want to delete")
+      end
+
+      api_request({
         method: "DELETE",
-        path: "/users/#{id}",
-        jwt: generate_su_token
-      )
+        path: "/users/#{CGI::escape options[:id]}",
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    def get_user(options)
+      if options[:id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user you want to fetch")
+      end
+
+      api_request({
+        method: "GET",
+        path: "/users/#{CGI::escape options[:id]}",
+        jwt: generate_su_token[:token]
+      })
     end
 
-    def get_users(from_id)
+    def get_users(options = nil)
       request_options = {
         method: "GET",
         path: "/users",
-        jwt: generate_su_token
+        jwt: generate_su_token[:token]
       }
 
-      unless from_id == nil && from_id == ""
-        request_options.merge!({ query: { from_id: from_id }})
+      unless options.nil?
+        query = {}
+        query[:from_ts] = options[:from_timestamp] unless options[:from_timestamp].nil?
+        query[:limit] = options[:limit] unless options[:limit].nil?
+
+        request_options.merge!({
+          query: query
+        })
       end
 
-      @api_instance.request(request_options)
+      api_request(request_options)
     end
 
-    def get_users_by_ids(user_ids)
-      @api_instance.request(
+    def get_users_by_id(options)
+      if options[:user_ids].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the IDs of the users you want to fetch")
+      end
+
+      api_request({
         method: "GET",
         path: "/users_by_ids",
         query: {
-          user_ids: user_ids.join(",")
-          },
-        jwt: generate_su_token
-      )
+          id: options[:user_ids],
+        },
+        jwt: generate_su_token[:token]
+      })
     end
 
     # Room API
 
-    def get_room(room_id)
-      @api_instance.request(
-        method: "GET",
-        path: "/rooms/#{room_id}",
-        jwt: generate_su_token
-      )
+    def create_room(options)
+      if options[:creator_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user creating the room")
+      end
+
+      if options[:name].nil?
+        raise Chatkit::MissingParameterError.new("You must provide a name for the room")
+      end
+
+      body = {
+        name: options[:name],
+        private: options[:private] || false
+      }
+
+      unless options[:user_ids].nil?
+        body[:user_ids] = options[:user_ids]
+      end
+
+      api_request({
+        method: "POST",
+        path: "/rooms",
+        body: body,
+        jwt: generate_su_token({ user_id: options[:creator_id] })[:token]
+      })
     end
 
-    def get_room_messages(user_id, room_id, initial_id = nil, direction = nil, limit = nil)
-      query_params = {}
+    def update_room(options)
+      if options[:id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the room to update")
+      end
+
+      payload = {}
+      payload[:name] = options[:name] unless options[:name].nil?
+      payload[:private] = options[:private] unless options[:private].nil?
+
+      api_request({
+        method: "PUT",
+        path: "/rooms/#{CGI::escape options[:id]}",
+        body: payload,
+        jwt: generate_su_token[:token]
+      })
+    end
 
-      query_params[:initial_id] = initial_id unless initial_id.nil?
-      query_params[:direction] = direction unless direction.nil?
-      query_params[:limit] = limit unless limit.nil?
+    def delete_room(options)
+      if options[:id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the room to delete")
+      end
 
-      @api_instance.request(
+      api_request({
+        method: "DELETE",
+        path: "/rooms/#{CGI::escape options[:id]}",
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    def get_room(options)
+      if options[:id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the room to fetch")
+      end
+
+      api_request({
         method: "GET",
-        path: "/rooms/#{room_id}/messages",
-        query: query_params,
-        jwt: generate_su_token({ user_id: user_id })
-      )
+        path: "/rooms/#{CGI::escape options[:id]}",
+        jwt: generate_su_token[:token]
+      })
     end
 
-    def get_rooms(user_id, from_id = nil)
+    def get_rooms(options = nil)
       request_options = {
         method: "GET",
         path: "/rooms",
-        jwt: generate_su_token({ user_id: user_id })
+        jwt: generate_su_token[:token]
+      }
+
+      unless options.nil?
+        query = {}
+        query[:include_private] = !options[:include_private].nil? ? options[:include_private] : false
+        query[:from_id] = options[:from_id] unless options[:from_id].nil?
+
+        request_options.merge!({
+          query: query
+        })
+      end
+
+      api_request(request_options)
+    end
+
+    def get_user_rooms(options)
+      get_rooms_for_user(options)
+    end
+
+    def get_user_joinable_rooms(options)
+      options[:joinable] = true
+      get_rooms_for_user(options)
+    end
+
+    def add_users_to_room(options)
+      if options[:room_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the room you want to add users to")
+      end
+
+      if options[:user_ids].nil?
+        raise Chatkit::MissingParameterError.new("You must provide a list of IDs of the users you want to add to the room")
+      end
+
+      api_request({
+        method: "PUT",
+        path: "/rooms/#{CGI::escape options[:room_id]}/users/add",
+        body: { user_ids: options[:user_ids] },
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    def remove_users_from_room(options)
+      if options[:room_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the room you want to remove users from")
+      end
+
+      if options[:user_ids].nil?
+        raise Chatkit::MissingParameterError.new("You must provide a list of IDs of the users you want to remove from the room")
+      end
+
+      api_request({
+        method: "PUT",
+        path: "/rooms/#{CGI::escape options[:room_id]}/users/remove",
+        body: { user_ids: options[:user_ids] },
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    # Messages API
+
+    def get_room_messages(options)
+      if options[:room_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the room to fetch messages from")
+      end
+
+      query_params = {}
+      query_params[:initial_id] = options[:initial_id] unless options[:initial_id].nil?
+      query_params[:direction] = options[:direction] unless options[:direction].nil?
+      query_params[:limit] = options[:limit] unless options[:limit].nil?
+
+      api_request({
+        method: "GET",
+        path: "/rooms/#{CGI::escape options[:room_id]}/messages",
+        query: query_params,
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    def send_message(options)
+      if options[:room_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the room to send the message to")
+      end
+
+      if options[:sender_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user sending the message")
+      end
+
+      if options[:text].nil?
+        raise Chatkit::MissingParameterError.new("You must provide some text for the message")
+      end
+
+      attachment = options[:attachment]
+
+      unless attachment.nil?
+        if attachment[:resource_link].nil?
+          raise Chatkit::MissingParameterError.new("You must provide a resource_link for the message attachment")
+        end
+
+        valid_file_types = ['image', 'video', 'audio', 'file']
+
+        if attachment[:type].nil? || !valid_file_types.include?(attachment[:type])
+          raise Chatkit::MissingParameterError.new(
+            "You must provide a valid type for the message attachment, i.e. one of: #{valid_file_types.join(', ')}"
+          )
+        end
+      end
+
+      payload = {
+        text: options[:text],
+        attachment: options[:attachment]
       }
 
-      unless from_id == nil && from_id == ""
-        request_options.merge!({ query: { from_id: from_id }})
+      api_request({
+        method: "POST",
+        path: "/rooms/#{CGI::escape options[:room_id]}/messages",
+        body: payload,
+        jwt: generate_su_token({ user_id: options[:sender_id] })[:token]
+      })
+    end
+
+    def delete_message(options)
+      if options[:id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the message you want to delete")
       end
 
-      @api_instance.request(request_options)
+      api_request({
+        method: "DELETE",
+        path: "/messages/#{options[:id]}",
+        jwt: generate_su_token[:token]
+      })
     end
 
-    # Authorizer API
+    # Roles and permissions API
 
-    def create_room_role(name, permissions)
-      create_role(name, ROOM_SCOPE, permissions)
+    def create_global_role(options)
+      options[:scope] = GLOBAL_SCOPE
+      create_role(options)
     end
 
-    def create_global_role(name, permissions)
-      create_role(name, GLOBAL_SCOPE, permissions)
+    def create_room_role(options)
+      options[:scope] = ROOM_SCOPE
+      create_role(options)
     end
 
-    def delete_room_role(role_name)
-      delete_role(role_name, ROOM_SCOPE)
+    def delete_global_role(options)
+      options[:scope] = GLOBAL_SCOPE
+      delete_role(options)
     end
 
-    def delete_global_role(role_name)
-      delete_role(role_name, GLOBAL_SCOPE)
+    def delete_room_role(options)
+      options[:scope] = ROOM_SCOPE
+      delete_role(options)
     end
 
-    def assign_global_role_to_user(user_id, role_name)
-      assign_role_to_user(user_id, role_name, nil)
+    def assign_global_role_to_user(options)
+      assign_role_to_user(options)
     end
 
-    def assign_room_role_to_user(user_id, role_name, room_id)
-      assign_role_to_user(user_id, role_name, room_id)
+    def assign_room_role_to_user(options)
+      if options[:room_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide a room ID to assign a room role to a user")
+      end
+
+      assign_role_to_user(options)
     end
 
     def get_roles
-      resp = @authorizer_instance.request(
+      authorizer_request({
         method: "GET",
         path: "/roles",
-        jwt: generate_su_token
-      )
-
-      JSON.parse(resp.body)
+        jwt: generate_su_token[:token]
+      })
     end
 
-    def get_user_roles(user_id)
-      resp = @authorizer_instance.request(
+    def get_user_roles(options)
+      if options[:user_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user whose roles you want to fetch")
+      end
+
+      authorizer_request({
         method: "GET",
-        path: "/users/#{user_id}/roles",
-        jwt: generate_su_token
-      )
+        path: "/users/#{CGI::escape options[:user_id]}/roles",
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    def remove_global_role_for_user(options)
+      remove_role_for_user(options)
+    end
+
+    def remove_room_role_for_user(options)
+      if options[:room_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide a room ID")
+      end
+
+      remove_role_for_user(options)
+    end
 
-      JSON.parse(resp.body)
+    def get_permissions_for_global_role(options)
+      options[:scope] = GLOBAL_SCOPE
+      get_permissions_for_role(options)
     end
 
-    def remove_global_role_for_user(user_id)
-      remove_role_for_user(user_id, nil)
+    def get_permissions_for_room_role(options)
+      options[:scope] = ROOM_SCOPE
+      get_permissions_for_role(options)
     end
 
-    def remove_room_role_for_user(user_id, room_id)
-      remove_role_for_user(user_id, room_id)
+    def update_permissions_for_global_role(options)
+      options[:scope] = GLOBAL_SCOPE
+      update_permissions_for_role(options)
     end
 
-    def get_permissions_for_global_role(role_name)
-      get_permissions_for_role(role_name, GLOBAL_SCOPE)
+    def update_permissions_for_room_role(options)
+      options[:scope] = ROOM_SCOPE
+      update_permissions_for_role(options)
     end
 
-    def get_permissions_for_room_role(role_name)
-      get_permissions_for_role(role_name, ROOM_SCOPE)
+    # Cursors API
+
+    def get_read_cursor(options)
+      if options[:user_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user whose read cursor you want to fetch")
+      end
+
+      if options[:room_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the room that you want the read cursor for")
+      end
+
+      cursors_request({
+        method: "GET",
+        path: "/cursors/0/rooms/#{CGI::escape options[:room_id]}/users/#{CGI::escape options[:user_id]}",
+        jwt: generate_su_token[:token]
+      })
     end
 
-    def update_role_permissions(role_name, scope, permissions_to_add = [], permissions_to_remove = [])
-      if permissions_to_add.empty? && permissions_to_remove.empty?
-        raise Chatkit::Error.new("permissions_to_add and permissions_to_remove cannot both be empty")
+    def set_read_cursor(options)
+      if options[:user_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user whose read cursor you want to set")
       end
 
-      body = {}
-      body[:add_permissions] = permissions_to_add unless permissions_to_add.empty?
-      body[:remove_permissions] = permissions_to_remove unless permissions_to_remove.empty?
+      if options[:room_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the room you want to set the user's cursor in")
+      end
+
+      if options[:position].nil?
+        raise Chatkit::MissingParameterError.new("You must provide position of the read cursor")
+      end
 
-      @authorizer_instance.request(
+      cursors_request({
         method: "PUT",
-        path: "/roles/#{role_name}/scope/#{scope}/permissions",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: body,
-        jwt: generate_su_token
-      )
+        path: "/cursors/0/rooms/#{CGI::escape options[:room_id]}/users/#{CGI::escape options[:user_id]}",
+        body: { position: options[:position] },
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    def get_user_read_cursors(options)
+      if options[:user_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user whose read cursors you want to fetch")
+      end
+
+      cursors_request({
+        method: "GET",
+        path: "/cursors/0/users/#{CGI::escape options[:user_id]}",
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    def get_room_read_cursors(options)
+      if options[:room_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the room that you want the read cursors for")
+      end
+
+      cursors_request({
+        method: "GET",
+        path: "/cursors/0/rooms/#{CGI::escape options[:room_id]}",
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    # Service-specific helpers
+
+    def api_request(options)
+      make_request(@api_instance, options)
+    end
+
+    def authorizer_request(options)
+      make_request(@authorizer_instance, options)
+    end
+
+    def cursors_request(options)
+      make_request(@cursors_instance, options)
     end
 
     private
 
-    def create_role(name, scope, permissions)
-      @authorizer_instance.request(
+    def make_request(instance, options)
+      options.merge!({ headers: { "Content-Type": "application/json" } })
+      begin
+        format_response(instance.request(options))
+      rescue PusherPlatform::ErrorResponse => e
+        raise Chatkit::ResponseError.new(e)
+      rescue PusherPlatform::Error => e
+        raise Chatkit::Error.new(e.message)
+      end
+    end
+
+    def format_response(res)
+      body = res.body.empty? ? nil : JSON.parse(res.body, { symbolize_names: true })
+
+      {
+        status: res.status,
+        headers: res.headers,
+        body: body
+      }
+    end
+
+    def get_rooms_for_user(options)
+      if options[:id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user whose rooms you want to fetch")
+      end
+
+      request_options = {
+        method: "GET",
+        path: "/users/#{CGI::escape options[:id]}/rooms",
+        jwt: generate_su_token[:token]
+      }
+
+      unless options[:joinable].nil?
+        request_options.merge!({ query: { joinable: options[:joinable] }})
+      end
+
+      api_request(request_options)
+    end
+
+    def create_role(options)
+      if options[:name].nil?
+        raise Chatkit::MissingParameterError.new("You must provide a name for the role")
+      end
+
+      if options[:permissions].nil?
+        raise Chatkit::MissingParameterError.new("You must provide permissions for the role, even if it's an empty list")
+      end
+
+      authorizer_request({
         method: "POST",
         path: "/roles",
-        headers: {
-          "Content-Type": "application/json"
-        },
         body: {
-          scope: scope,
-          name: name,
-          permissions: permissions,
+          scope: options[:scope],
+          name: options[:name],
+          permissions: options[:permissions],
         },
-        jwt: generate_su_token
-      )
+        jwt: generate_su_token[:token]
+      })
     end
 
-    def delete_role(role_name, scope)
-      @authorizer_instance.request(
+    def delete_role(options)
+      if options[:name].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the role's name")
+      end
+
+      authorizer_request({
         method: "DELETE",
-        path: "/roles/#{role_name}/scope/#{scope}",
-        jwt: generate_su_token
-      )
+        path: "/roles/#{CGI::escape options[:name]}/scope/#{options[:scope]}",
+        jwt: generate_su_token[:token]
+      })
     end
 
-    def assign_role_to_user(user_id, role_name, room_id)
-      body = { name: role_name }
+    def assign_role_to_user(options)
+      if options[:name].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the role's name")
+      end
+
+      if options[:user_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user you want to assign the role to")
+      end
+
+      body = { name: options[:name] }
 
-      unless room_id.nil?
-        body.merge!(room_id: room_id)
+      unless options[:room_id].nil?
+        body.merge!(room_id: options[:room_id])
       end
 
-      @authorizer_instance.request(
+      authorizer_request({
         method: "PUT",
-        path: "/users/#{user_id}/roles",
-        headers: {
-          "Content-Type": "application/json",
-        },
+        path: "/users/#{CGI::escape options[:user_id]}/roles",
         body: body,
-        jwt: generate_su_token
-      )
+        jwt: generate_su_token[:token]
+      })
     end
 
-    def remove_role_for_user(user_id, room_id)
-      options = {
+    def remove_role_for_user(options)
+      if options[:user_id].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the ID of the user you want to remove the role for")
+      end
+
+      request_options = {
         method: "DELETE",
-        path: "/users/#{user_id}/roles",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        query: { room_id: room_id },
-        jwt: generate_su_token
+        path: "/users/#{CGI::escape options[:user_id]}/roles",
+        jwt: generate_su_token[:token]
       }
 
-      unless room_id.nil?
-        options.merge!(body: { room_id: room_id })
+      unless options[:room_id].nil?
+        request_options.merge!({ query: { room_id: options[:room_id] }})
       end
 
-      @authorizer_instance.request(options)
+      authorizer_request(request_options)
     end
 
-    def get_permissions_for_role(role_name, scope)
-      resp = @authorizer_instance.request(
+    def get_permissions_for_role(options)
+      if options[:name].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the name of the role you want to fetch the permissions of")
+      end
+
+      authorizer_request({
         method: "GET",
-        path: "/roles/#{role_name}/scope/#{scope}/permissions",
-        jwt: generate_su_token
-      )
+        path: "/roles/#{CGI::escape options[:name]}/scope/#{options[:scope]}/permissions",
+        jwt: generate_su_token[:token]
+      })
+    end
+
+    def update_permissions_for_role(options)
+      if options[:name].nil?
+        raise Chatkit::MissingParameterError.new("You must provide the name of the role you want to update the permissions of")
+      end
+
+      permissions_to_add = options[:permissions_to_add]
+      permissions_to_remove = options[:permissions_to_remove]
 
-      JSON.parse(resp.body)
+      if (permissions_to_add.nil? || permissions_to_add.empty?) && (permissions_to_remove.nil? || permissions_to_remove.empty?)
+        raise Chatkit::MissingParameterError.new("permissions_to_add and permissions_to_remove cannot both be empty")
+      end
+
+      body = {}
+      body[:add_permissions] = permissions_to_add unless permissions_to_add.nil? || permissions_to_add.empty?
+      body[:remove_permissions] = permissions_to_remove unless permissions_to_remove.nil? ||permissions_to_remove.empty?
+
+      authorizer_request({
+        method: "PUT",
+        path: "/roles/#{CGI::escape options[:name]}/scope/#{options[:scope]}/permissions",
+        body: body,
+        jwt: generate_su_token[:token]
+      })
     end
   end
 end

data/lib/chatkit/error.rb

@@ -0,0 +1,4 @@
+module Chatkit
+  class Error < StandardError
+  end
+end

data/lib/chatkit/missing_parameter_error.rb

@@ -0,0 +1,16 @@
+require_relative './error'
+
+module Chatkit
+  class MissingParameterError < Chatkit::Error
+    attr_accessor :message
+
+    def initialize(message)
+      @message = message
+    end
+
+    def to_s
+      "Chatkit::MissingParameterError - #{@message}"
+    end
+
+  end
+end

data/lib/chatkit/response_error.rb

@@ -0,0 +1,37 @@
+require_relative './error'
+
+module Chatkit
+  class ResponseError < Chatkit::Error
+    attr_reader :status, :headers, :error_description, :error, :error_uri
+
+    def initialize(platform_error)
+      @status = platform_error.status
+      @headers = platform_error.headers
+      @error = platform_error.error
+      @error_description = platform_error.error_description
+      @error_uri = platform_error.error_uri
+    end
+
+    def to_s
+      output = "Chatkit::ResponseError - status: #{@status} description: #{@error_description}."
+      output += " Find out more at #{@error_uri}" if @error_uri
+      output
+    end
+
+    def as_json(options = {})
+      json = {
+        status: @status,
+        headers: @headers,
+        error: @error,
+        error_description: @error_description,
+      }
+      json[:error_uri] = @error_uri unless @error_uri.nil?
+      json
+    end
+
+    def to_json(*options)
+      as_json(*options).to_json(*options)
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pusher-chatkit-server
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Pusher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-20 00:00:00.000000000 Z
+date: 2018-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pusher-platform
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: 0.11.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.2
+        version: 0.11.2
 description: 
 email: support@pusher.com
 executables: []
@@ -32,6 +32,9 @@ extra_rdoc_files: []
 files:
 - lib/chatkit.rb
 - lib/chatkit/client.rb
+- lib/chatkit/error.rb
+- lib/chatkit/missing_parameter_error.rb
+- lib/chatkit/response_error.rb
 homepage: 
 licenses:
 - MIT
@@ -52,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: Pusher Chatkit Ruby SDK