sendbird 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 345394b76bf73ff1d473718670ae6093b7e0d659
-  data.tar.gz: 9ef4b5eb091e0c85f4aef67994c7bab7cb82c9d8
+  metadata.gz: 96641c7ad6c001d69d96555bcae0d61fbf6fa3db
+  data.tar.gz: 7fc0e43271a581040130ff43e7444151c333b3db
 SHA512:
-  metadata.gz: dc88d376b180ddbe99ad6f48ca957843ce80bcdb7a45bcdec25e1fff42aef90f0ed0b8be96743356120bae4d47bb3be47593091e32d44d3da10794dbcd092875
-  data.tar.gz: 2b5731b29fdcbaa32c33eaa344f97419d49f1c14bc077b680fb65d1f7b5dc728967ddc1c40e8308bf30d246a52ef7240303e5557e18ec522042311ff11551a8f
+  metadata.gz: 3dbe8cb40265ff89e2b23ca19875d35860a65d51df3d8b02ba2fe4fe53ff35443cea9b1639cd3e6dea032b1f534bad2764e9be154d6e2a2c7940f1de1ad56431
+  data.tar.gz: 4244a7940324e66f5a70746cffff360353c79df2f518493d1a01a10a44bc7ff6701345696c8967725a5568b315a8ed4bd8a5511176c80f8300cc5e9cad576920

data/.gitignore

@@ -9,3 +9,4 @@
 /tmp/
 /config/secrets.yml
 .ruby-gemset
+.ruby-version

data/.travis.yml

@@ -3,3 +3,5 @@ language: ruby
 rvm:
   - 2.3.0
 before_install: gem install bundler -v 1.13.1
+script:
+  - rake

data/README.md

@@ -1,28 +1,254 @@
 # Sendbird
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/sendbird`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Sendbird is a ruby Wrapper for the Sendbird [API](https://docs.sendbird.com/platform)
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
 ```ruby
 gem 'sendbird'
 ```
 
-And then execute:
+## Requirements
 
-    $ bundle
+You must provide:
+  - Your list of applications, been the Applications name and its Api Key.
+  - Your username and password.
+You can find your applications list [here](https://dashboard.sendbird.com).
+By setting a default, will set the api_key in the request where need, if not you will have to provide a app parameter to every method call.
 
-Or install it yourself as:
 
-    $ gem install sendbird
+Rails way:
+```ruby
+Sendbird.config do |c|
+  c.applications = {app_name: 'API_KEY'}
+  c.user = 'username'
+  c.password = 'password'
+  c.default_app = 'app_name'
+end
+```
+
+Ruby way:
+```ruby
+Sendbird.applications = {app_name: 'API_KEY'}
+Sendbird.user = 'username'
+Sendbird.password = 'password'
+Sendbird.default_app = 'app_name'
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+## Api
+
+There are two types of classes inside the Wrapper the one ending with Api, like `Sendbird::UserApi` or `Sendbird::MessageApi`, this classes act like simple wrapper for the Sendbird api.
+
+The Sendbird Api is quite big, to understand how to work with this gem, just remenber that every event from the api map to a class method from that Api class.
+
+Example:
+```ruby
+body = {
+    "user_id" => "string",               
+    "nickname" => "string",   
+    "profile_url" => "string",   
+    "issue_access_token" => "boolean"  
+}
+Sendbird::UserApi.create(body)
+```
+
+All methods that accept a variables in the uri, they will argument in order for the method, and all request arguments or parameters, are the last arguments as hash.
+
+Example for event [Message send](https://docs.sendbird.com/platform#messages):
+```ruby
+request_body = {
+    "message_type" => "MESG",
+    "user_id" => "string",     
+    "message" => "string",     
+    "data" => "string",        
+    "mark_as_read" => "boolean"
+}
+Sendbird::MessageApi.send('group_channels', 'group_channels_url', request_body)
+```
+
+Example for event [User list](https://docs.sendbird.com/platform#messages):
+```ruby
+request_parameters = {
+    "token" => "string",
+    "limit" => "int",     
+    "user_ids" => "string"
+}
+Sendbird::UserApi.list(request_parameters)
+```
+
+Example for sending a message to a different app:
+```ruby
+request_parameters = {
+  "token" => "string",
+  "limit" => "int",     
+  "user_ids" => "string",
+  "app" => 'string' # This app has to be in the configuration
+}
+Sendbird::UserApi.list(request_parameters)
+```
+
+All methods return a `Sendbird::Response` with have the next methods:
+#### body
+  Returns the parsed body of the request
+#### status
+  Returns the status code of the request
+#### error_code
+  Returns the error_code from the request, if their is one
+#### error_message
+  Returns the error_message from the request, if their is one  
+
+## List of all classes and it's class methods.
+
+### Sendbird::UserApi
+```ruby
+view(user_id)
+create(body)
+list(params={})
+update(user_id, body)
+unread_count(user_id)
+activate(user_id, body)
+block(user_id, body)
+unblock(user_id, unblock_user_id)
+block_list(user_id, params={})
+mark_as_read_all(user_id)
+register_gcm_token(user_id, token)
+register_apns_token(user_id, token)
+unregister_gcm_token(user_id, token)
+unregister_apns_token(user_id, token)
+unregister_all_device_token(user_id)
+push_preferences(user_id)
+update_push_preferences(user_id, body)
+delete_push_preferences(user_id)
+```  
+
+### Sendbird::OpenChannelApi
+```ruby
+view(channel_url, params={})
+create(body={})
+list(params={})
+destroy(channel_url)
+update(channel_url, body)
+participants(channel_url, params)
+freeze(channel_url, body)
+ban_user(channel_url, body)
+ban_list(channel_url, params={})
+ban_update(channel_url, user_id, body)
+ban_delete(channel_url, user_id)
+ban_view(channel_url, user_id)
+mute(channel_url, body)
+mute_list(channel_url, params={})
+mute_delete(channel_url, user_id)
+mute_view(channel_url, user_id)
+```
+
+### Sendbird::GroupChannelApi
+```ruby
+create(body)
+list(params={})
+update(channel_url, body)
+destroy(channel_url)
+view(channel_url, params={})
+members(channel_url, params={})
+is_member?(channel_url, user_id)
+invite(channel_url, body)
+hide(channel_url, body)
+leave(channel_url, body)
+```
+
+### Sendbird::MetaCounterApi && Sendbird::MetaDataApi
+```ruby
+create(channel_type, channel_url, body)
+view(channel_type, channel_url, params={})
+view_by_key(channel_type, channel_url, key)
+update(channel_type, channel_url, body)
+update_by_key(channel_type, channel_url, key, body)
+destroy(channel_type, channel_url)
+destroy_by_key(channel_type, channel_url, key)
+```
+
+### Sendbird::ApplicationApi
+```ruby
+create(body)
+list(params={})
+destroy_all
+destroy
+profanaty(body={})
+ccu
+mau(params={})
+dau(params={})
+daily_message_count(params={})
+gcm_push_configuration
+apns_push_configuration
+```
+
+## Interface
+
+This is the second type of class inside the gem, acts as interface.
+
+Currently only supporting `User`, in the future I will add the rest of interfaces.
+
+There are three ways to interact with the user interface:
+
+#### Block
+```ruby
+Sendbird::User.new('testing_user_interface_1') do |u|
+  u.nickname('Yolo')
+  u.profile_url('udbue')
+  u.timezone('Europe/London')
+  u.request!
+end
+```
+
+#### Chain Methods
+```ruby
+user = Sendbird::User.new('testing_user_interface_1')
+user.nickname('Yolo').profile_url('udbue').timezone('Europe/London').request!
+```
+
+#### Simple methods
+```ruby
+user = Sendbird::User.new('testing_user_interface_1')
+user.nickname='Yolo'
+user.profile_url=('udbue')
+user.timezone=('Europe/London')
+user.request!
+```
+
+This interface provide you with multiple methods to work with the Sendbird Api:
+
+```ruby
+user_information=(user_information={})
+nickname=(nickname)
+profile_url=(profile_url)
+issue_access_token=(issue_access_token)
+push_preferences=(push_preferences={})
+timezone=(timezone)  
+start_hour=(start_hour)
+end_hour=(end_hour)
+start_min=(start_min)
+end_min=(end_min)
+activate
+deactivate  
+mark_as_read_all
+register_gcm_token(token)
+register_apns_token(token)
+unregister_gcm_token(token)
+unregister_apns_token(token)
+unregister_all_device_token
+```  
+
+The interface will store all the pending requests called before the `request!`, when triggering the `request!` method will optimize how many request, have to be done, you don't have to worry about that.
+
+The User interface also provide some attributes: `gcm_tokens` and `apns_tokens`, they will store the different token this user have, so by triggering any of the `register_*` methods will store or remove from this attributes.
+
+The user interface also provide some getter methods that will execute the request instantly, this methods return the info response body. This methods are:
+```ruby
+get_user  
+get_unread_count
+get_push_preferences
+```
 
 ## Development
 
@@ -38,4 +264,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/[USERN
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/config/secrets.example.yml

@@ -1 +1,6 @@
-api_key:
+applications:
+  App_name: 'api_key'
+  App_name: 'api_key'
+user:
+password:
+default_app:

data/lib/sendbird.rb

@@ -1,14 +1,19 @@
 require "sendbird/client"
 require "sendbird/configuration"
+require "sendbird/invalid_request"
 require "sendbird/response"
+require "sendbird/request_handler"
+require "sendbird/application_api"
 require "sendbird/user_api"
 require "sendbird/user"
-require "sendbird/open_channel"
+require "sendbird/open_channel_api"
+require "sendbird/group_channel_api"
 require "sendbird/group_channel"
+require "sendbird/message_api"
 require "sendbird/message"
 require "sendbird/meta_base"
-require "sendbird/meta_data"
-require "sendbird/meta_counter"
+require "sendbird/meta_data_api"
+require "sendbird/meta_counter_api"
 require "sendbird/version"
 
 module Sendbird

data/lib/sendbird/application_api.rb

@@ -0,0 +1,57 @@
+module Sendbird
+  class ApplicationApi
+    extend Client
+    ENDPOINT = 'applications'.freeze
+
+    class << self
+      def create(body)
+        post_http_basic(path: build_url, body: body)
+      end
+
+      def list(params={})
+        get_http_basic(path: build_url, params: params)
+      end
+
+      # Right now this endpoint is failing in there site
+      # def view
+      #   get(path: build_url)
+      # end
+
+      def destroy_all
+        delete_http_basic(path: build_url)
+      end
+
+      def destroy
+        delete(path: build_url)
+      end
+
+      def profanaty(body={})
+        put(path: build_url('profanity'), body: body)
+      end
+
+      def ccu
+        get(path: build_url('ccu'))
+      end
+
+      def mau(params={})
+        get(path: build_url('mau'), params: params)
+      end
+
+      def dau(params={})
+        get(path: build_url('dau'), params: params)
+      end
+
+      def daily_message_count(params={})
+        get(path: build_url('daily_count'), params: params)
+      end
+
+      def gcm_push_configuration
+        get(path: build_url('push', 'gcm'))
+      end
+
+      def apns_push_configuration
+        get(path: build_url('push', 'apns'))
+      end
+    end
+  end
+end

data/lib/sendbird/client.rb

@@ -3,12 +3,24 @@ require 'faraday'
 module Sendbird
   module Client
     class ApiKeyMissingError < StandardError; end
+    class HttpBasicMissing < StandardError; end
+    class NotValidApplication < StandardError; end
+
     PUBLIC_METHODS = [:get, :post, :put, :delete]
 
     PUBLIC_METHODS.each do |method|
       define_method(method) do |path: , params: nil , body: nil|
-        fail ApiKeyMissingError.new(api_key_message) if Sendbird.api_key.nil?
-        response = request(method: method, path: path, params: params, body: body)
+        params, body, app = get_app_from_params_or_body(params, body)
+        fail ApiKeyMissingError.new(api_key_message) unless api_key(app)
+        response = api_token_request(method: method, path: path, params: params, body: body)
+        Response.new(response.status, response.body)
+      end
+    end
+
+    PUBLIC_METHODS.each do |method|
+      define_method("#{method}_http_basic") do |path: , params: nil , body: nil|
+        fail HttpBasicMissing.new(http_basic_message) if sendbird_user.nil? || sendbird_password.nil?
+        response = http_basic_request(method: method, path: path, params: params, body: body)
         Response.new(response.status, response.body)
       end
     end
@@ -22,7 +34,33 @@ module Sendbird
       end
     end
 
+
     private
+
+    def get_app_from_params_or_body(params, body)
+      app = if params && params.has_key?(:app)
+        params.delete(:app)
+      elsif body && body.has_key?(:app)
+        body.delete(:app)
+      else
+        nil
+      end
+      [params, body, app]
+    end
+
+    def api_key(app)
+      if app
+        if api_key = Sendbird.applications[app]
+          @api_key = api_key
+        else
+          fail NotValidApplication.new(invalid_application_message(app))
+        end
+      else
+        @api_key = Sendbird.applications[Sendbird.default_app]
+      end
+      @api_key
+    end
+
     def conn
       @conn ||= Faraday.new(url: Sendbird::Configuration::SENDBIRD_ENDPOINT) do |c|
                   c.request  :url_encoded
@@ -30,17 +68,49 @@ module Sendbird
                 end
     end
 
-    def request(method:, path:, params:, body:)
+    def http_basic_conn
+      @http_basic_conn ||= Faraday.new(url: Sendbird::Configuration::SENDBIRD_ENDPOINT) do |c|
+                  c.request  :url_encoded
+                  c.adapter  Faraday.default_adapter
+                  c.basic_auth(sendbird_user, sendbird_password)
+                end
+    end
+
+    def sendbird_user
+      Sendbird.user
+    end
+
+    def sendbird_password
+      Sendbird.password
+    end
+
+    def api_token_request(method:, path:, params:, body:)
       conn.send(method) do |req|
         req.url path, params
-        req.headers['Api-Token'] = Sendbird.api_key
+        req.headers['Api-Token'] = @api_key
+        req.headers['Content-Type'] = 'application/json, charset=utf8'
+        req.body = body.to_json if body
+      end
+    end
+
+    def http_basic_request(method:, path:, params:, body:)
+      http_basic_conn.send(method) do |req|
+        req.url path, params
         req.headers['Content-Type'] = 'application/json, charset=utf8'
         req.body = body.to_json if body
       end
     end
 
     def api_key_message
-      'Please set up your api key'
+      'Plase set up your applications and default_app'
+    end
+
+    def http_basic_message
+      'Please set up you http basic information to be able to execute this requets'
+    end
+
+    def invalid_application_message(app)
+      "Application name (#{app}) not found in the configuration, please check your configuration"
     end
   end
 end

data/lib/sendbird/configuration.rb

@@ -1,6 +1,6 @@
 module Sendbird
   module Configuration
-    PUBLIC_METHODS = [:api_key]
+    PUBLIC_METHODS = [:applications, :user, :password, :default_app]
 
     SENDBIRD_ENDPOINT = 'https://api.sendbird.com/v3/'
 

data/lib/sendbird/group_channel.rb

@@ -1,48 +1,52 @@
 module Sendbird
   class GroupChannel
-    extend Client
-    ENDPOINT = 'group_channels'.freeze
-
-    class << self
-      def create(body)
-        post(path: build_url, body: body)
-      end
-
-      def list(params={})
-        get(path: build_url, params: params)
-      end
-
-      def update(channel_url, body)
-        put(path: build_url(channel_url), body: body)
-      end
-
-      def destroy(channel_url)
-        delete(path: build_url(channel_url))
-      end
+    class MissingUserId < StandardError; end
+    include RequestHandler
+
+    api_class GroupChannelApi
+    default_arg :channel_url
+
+    attr_reader :channel_url, :user_id, :pending_requests
+    def initialize(channel_url, user_id = :missing_user_id)
+      @channel_url = channel_url
+      @user_id = user_id
+      @pending_requests = {}
+      yield(self) if block_given?
+    end
 
-      def view(channel_url, params={})
-        get(path: build_url(channel_url), params: params)
-      end
+    def name=(name)
+      merge_arguments(:update, {name: name})
+      self
+    end
 
-      def members(channel_url, params={})
-        get(path: build_url(channel_url, 'members'), params: params)
-      end
+    def cover_url=(cover_url)
+      merge_arguments(:update, {cover_url: cover_url})
+      self
+    end
 
-      def is_member?(channel_url, user_id)
-        get(path: build_url(channel_url, 'members', user_id))
-      end
+    def data=(data)
+      merge_arguments(:update, {data: data})
+      self
+    end
 
-      def invite(channel_url, body)
-        post(path: build_url(channel_url, 'invite'), body: body)
-      end
+    def is_distinct=(is_distinct)
+      merge_arguments(:update, {is_distinct: is_distinct})
+      self
+    end
 
-      def hide(channel_url, body)
-        put(path: build_url(channel_url, 'hide'), body: body)
-      end
+    def send_message(type, data)
+      message.send(type, data)
+    end
 
-      def leave(channel_url, body)
-        put(path: build_url(channel_url, 'leave'), body: body)
+    def message
+      return @message if defined?(@message)
+      if user_id == :missing_user_id
+        raise MissingUserId, 'Please provide an user_id at initialize to been able to use send_message'
       end
+      @message ||= Message.new(user_id, channel_url, 'group_channels')
     end
+
+    private
+    attr_writer :pending_requests
   end
 end

data/lib/sendbird/group_channel_api.rb

@@ -0,0 +1,48 @@
+module Sendbird
+  class GroupChannelApi
+    extend Client
+    ENDPOINT = 'group_channels'.freeze
+
+    class << self
+      def create(body)
+        post(path: build_url, body: body)
+      end
+
+      def list(params={})
+        get(path: build_url, params: params)
+      end
+
+      def update(channel_url, body)
+        put(path: build_url(channel_url), body: body)
+      end
+
+      def destroy(channel_url)
+        delete(path: build_url(channel_url))
+      end
+
+      def view(channel_url, params={})
+        get(path: build_url(channel_url), params: params)
+      end
+
+      def members(channel_url, params={})
+        get(path: build_url(channel_url, 'members'), params: params)
+      end
+
+      def is_member?(channel_url, user_id)
+        get(path: build_url(channel_url, 'members', user_id))
+      end
+
+      def invite(channel_url, body)
+        post(path: build_url(channel_url, 'invite'), body: body)
+      end
+
+      def hide(channel_url, body)
+        put(path: build_url(channel_url, 'hide'), body: body)
+      end
+
+      def leave(channel_url, body)
+        put(path: build_url(channel_url, 'leave'), body: body)
+      end
+    end
+  end
+end

data/lib/sendbird/invalid_request.rb

@@ -0,0 +1,4 @@
+module Sendbird
+  class InvalidRequest < StandardError
+  end
+end

data/lib/sendbird/message.rb

@@ -1,42 +1,44 @@
 module Sendbird
   class Message
-    extend Client
+    class InvalidMessageType < StandardError; end
+    attr_reader :user_id, :channel_url, :channel_type
 
-    class << self
-      def send(channel_type, channel_url, body)
-        post(path: build_url(channel_type, channel_url, 'messages'), body: body)
-      end
-
-      # Get messages function can be called only
-      #  from Park or Enterprise plan.
-      def list(channel_type, channel_url, params)
-        get(path: build_url(channel_type, channel_url, 'messages'), params: params)
-      end
-
-      def view(channel_type, channel_url, message_id)
-        get(path: build_url(channel_type, channel_url, 'messages', message_id))
-      end
-
-      def destroy(channel_type, channel_url, message_id)
-        delete(path: build_url(channel_type, channel_url, 'messages', message_id))
-      end
-
-      def mark_as_read(channel_type, channel_url, body)
-        put(path: build_url(channel_type, channel_url, 'messages', 'mark_as_read'), body: body)
-      end
+    def initialize(user_id, channel_url, channel_type)
+      @user_id = user_id
+      @channel_url = channel_url
+      @channel_type = channel_type
+    end
 
-      def count(channel_type, channel_url)
-        get(path: build_url(channel_type, channel_url, 'messages', 'total_count'))
-      end
+    def send(type, data)
+      MessageApi.send(channel_type, channel_url, message_body(type).merge(data))
+      self
+    end
 
-      def unread_count(channel_type, channel_url, params)
-        get(path: build_url(channel_type, channel_url, 'messages', 'unread_count'), params: params)
+    private
+    def message_type(type)
+      case type
+      when :text then 'MESG'
+      when :file then 'FILE'
+      when :admin then 'ADMM'
+      else
+        raise InvalidMessageType, "Please provide a valid message type, valid types are: [:text, :file, :admin]"
       end
     end
 
-    def self.build_url(*args)
-      args_dup = args.dup
-      args_dup.join('/')
+    def message_body(type)
+      case type
+      when :text, :file
+        {
+          "message_type": message_type(type),
+          "user_id": user_id
+        }
+      when :admin
+        {
+          "message_type": message_type(type),
+        }
+      else
+        raise InvalidMessageType, "Please provide a valid message type, valid types are: [:text, :file, :admin]"
+      end
     end
   end
 end

data/lib/sendbird/message_api.rb

@@ -0,0 +1,42 @@
+module Sendbird
+  class MessageApi
+    extend Client
+
+    class << self
+      def send(channel_type, channel_url, body)
+        post(path: build_url(channel_type, channel_url, 'messages'), body: body)
+      end
+
+      # Get messages function can be called only
+      #  from Park or Enterprise plan.
+      def list(channel_type, channel_url, params)
+        get(path: build_url(channel_type, channel_url, 'messages'), params: params)
+      end
+
+      def view(channel_type, channel_url, message_id)
+        get(path: build_url(channel_type, channel_url, 'messages', message_id))
+      end
+
+      def destroy(channel_type, channel_url, message_id)
+        delete(path: build_url(channel_type, channel_url, 'messages', message_id))
+      end
+
+      def mark_as_read(channel_type, channel_url, body)
+        put(path: build_url(channel_type, channel_url, 'messages', 'mark_as_read'), body: body)
+      end
+
+      def count(channel_type, channel_url)
+        get(path: build_url(channel_type, channel_url, 'messages', 'total_count'))
+      end
+
+      def unread_count(channel_type, channel_url, params)
+        get(path: build_url(channel_type, channel_url, 'messages', 'unread_count'), params: params)
+      end
+    end
+
+    def self.build_url(*args)
+      args_dup = args.dup
+      args_dup.join('/')
+    end
+  end
+end

data/lib/sendbird/{meta_counter.rb → meta_counter_api.rb}

@@ -1,5 +1,5 @@
 module Sendbird
-  class MetaCounter < MetaBase
+  class MetaCounterApi < MetaBase
     ENDPOINT = 'metacounter'.freeze
   end
 end

data/lib/sendbird/{meta_data.rb → meta_data_api.rb}

@@ -1,5 +1,5 @@
 module Sendbird
-  class MetaData < MetaBase
+  class MetaDataApi < MetaBase
     ENDPOINT = 'metadata'.freeze
   end
 end

data/lib/sendbird/{open_channel.rb → open_channel_api.rb}

@@ -1,5 +1,5 @@
 module Sendbird
-  class OpenChannel
+  class OpenChannelApi
     extend Client
     ENDPOINT = 'open_channels'.freeze
 

data/lib/sendbird/request_handler.rb

@@ -0,0 +1,41 @@
+require_relative "./request_handler/request"
+require_relative "./request_handler/request_merger"
+
+module Sendbird
+  module RequestHandler
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def request!
+        Request.new(pending_requests, api_class, default_arg).execute
+      rescue InvalidRequest => e
+        raise e
+      ensure
+        self.pending_requests = {}
+      self
+    end
+
+    def merge_arguments(method, args, callback=nil)
+      self.pending_requests = RequestMerger.call(pending_requests, method, args, callback)
+    end
+
+    def default_arg
+      self.send(self.class.instance_variable_get(:@default_arg))
+    end
+
+    def api_class
+      self.class.instance_variable_get(:@api_class)
+    end
+
+    module ClassMethods
+      def api_class(api_class)
+        @api_class = api_class
+      end
+
+      def default_arg(method)
+        @default_arg = method
+      end
+    end
+  end
+end

data/lib/sendbird/request_handler/request.rb

@@ -0,0 +1,41 @@
+module Sendbird
+  module RequestHandler
+    class Request
+      attr_reader :pending_requests, :api_class, :default_argument
+      def initialize(pending_requests, api_class, default_argument)
+        @pending_requests = pending_requests
+        @api_class = api_class
+        @default_argument = default_argument
+      end
+
+      def execute
+        pending_requests.each do |method, params|
+          response = case params[:args]
+                     when Array
+                       if params[:args].any?
+                         api_class.send(method, default_argument, *params[:args])
+                       else
+                         api_class.send(method, default_argument)
+                       end
+                     when Hash
+                       api_class.send(method, default_argument, params[:args])
+                     end
+          handle_response_status(response, method, params[:args])
+          execute_callbacks(params[:callback], response)
+        end
+      end
+
+      def handle_response_status(response, method, arguments)
+        if response.status != 200
+          raise InvalidRequest, "#{response.error_message} executing #{method} with arguments: #{arguments}"
+        end
+      end
+
+      def execute_callbacks(callbacks, response)
+        callbacks.each do |cb|
+          cb.call(response)
+        end
+      end
+    end
+  end
+end

data/lib/sendbird/request_handler/request_merger.rb

@@ -0,0 +1,44 @@
+module Sendbird
+  module RequestHandler
+    class RequestMerger
+      def self.call(pending_requests, method, args, callback)
+        new(pending_requests, method, args, callback).merge
+      end
+
+      attr_reader :pending_requests, :method, :args, :callback
+      def initialize(pending_requests, method, args, callback)
+        @pending_requests = pending_requests
+        @method = method
+        @args = args
+        @callback = callback
+      end
+
+      def merge
+        pending_requests[method] ||= {}
+        case args
+        when Hash
+          merge_hash_arguments(args)
+        else
+          merge_rest_of_arguments(args)
+        end
+        append_callbacks(args)
+        pending_requests
+      end
+
+      def merge_hash_arguments(args)
+        pending_requests[method][:args] ||= {}
+        pending_requests[method][:args] = pending_requests[method][:args].merge(args)
+      end
+
+      def merge_rest_of_arguments(args)
+        pending_requests[method][:args] ||= []
+        pending_requests[method][:args] = pending_requests[method][:args] << args if args
+      end
+
+      def append_callbacks(args)
+        pending_requests[method][:callback] ||= []
+        pending_requests[method][:callback] = pending_requests[method][:callback] << callback if callback
+      end
+    end
+  end
+end

data/lib/sendbird/user.rb

@@ -1,56 +1,178 @@
 module Sendbird
-  class User < Struct.new(:user_id, :nickname, :profile_url, :access_token, :last_seen_at, :is_online)
-    def self.create_or_initialize(params)
-      case params
-      when Response
-        new(*params.body.map{|x| x.last})
-      when Hash
-        response = UserApi.show(params[:user_id])
-        if response.status == 200
-          new(*response.body.map{|x| x.last})
-        else
-          new_user = UserApi.create(params)
-          new(*new_user.body.map{|x| x.last})
-        end
+  class User
+    include RequestHandler
+
+    api_class UserApi
+    default_arg :user_id
+
+    attr_reader :user_id, :pending_requests, :gcm_tokens, :apns_tokens
+    def initialize(user_id)
+      @user_id = user_id
+      @gcm_tokens = []
+      @apns_tokens = []
+      @pending_requests = {}
+      yield(self) if block_given?
+    end
+
+    def in_sync?
+      pending_requests.empty?
+    end
+
+    #Getters
+    def get_user
+      response = UserApi.view(user_id)
+      if response.status == 200
+        response.body
+      else
+        raise InvalidRequest.new(
+          error_message(
+            response.error_message,
+            __method__,
+            user_id
+          )
+        )
+      end
+    end
+
+    def get_unread_count
+      response = UserApi.unread_count(user_id)
+      if response.status == 200
+        response.body['unread_count']
+      else
+        raise InvalidRequest.new(
+          error_message(
+            response.error_message,
+            __method__,
+            user_id
+          )
+        )
       end
     end
 
-    private_class_method :new
+    def get_push_preferences
+      response = UserApi.push_preferences(user_id)
+      if response.status == 200
+        response.body
+      else
+        raise InvalidRequest.new(
+          error_message(
+            response.error_message,
+            __method__,
+            user_id
+          )
+        )
+      end
+    end
 
-    def view
-      UserApi.show(user_id)
+    # Setters
+    def user_information=(user_information={})
+      merge_arguments(:update, user_information)
+      self
     end
+    alias_method :user_information, :user_information=
 
-    def update(body)
-      UserApi.update(user_id, body)
+    def nickname=(nickname)
+      merge_arguments(:update, {nickname: nickname})
+      self
     end
+    alias_method :nickname, :nickname=
 
-    def unread_count
-      UserApi.unread_count(user_id)
+    def profile_url=(profile_url)
+      merge_arguments(:update, {profile_url: profile_url})
+      self
     end
+    alias_method :profile_url, :profile_url=
 
-    def mark_as_read_all
-      UserApi.mark_as_read_all(user_id)
+    def issue_access_token=(issue_access_token)
+      merge_arguments(:update, {issue_access_token: issue_access_token})
+      self
+    end
+    alias_method :issue_access_token, :issue_access_token=
+
+    def activate
+      merge_arguments(:activate, { activate: true })
+      self
+    end
+
+    def deactivate
+      merge_arguments(:activate, { activate: false })
+      self
+    end
+
+    def push_preferences=(push_preferences={})
+      merge_arguments(:update_push_preferences, push_preferences)
+      self
     end
+    alias_method :push_preferences, :push_preferences=
+
+    def timezone=(timezone)
+      merge_arguments(:update_push_preferences, { timezone: timezone })
+      self
+    end
+    alias_method :timezone, :timezone=
+
+    def start_hour=(start_hour)
+      merge_arguments(:update_push_preferences, { start_hour: start_hour })
+      self
+    end
+    alias_method :start_hour, :start_hour=
+
+    def end_hour=(end_hour)
+      merge_arguments(:update_push_preferences, { end_hour: end_hour })
+      self
+    end
+    alias_method :end_hour, :end_hour=
+
+    def start_min=(start_min)
+      merge_arguments(:update_push_preferences, { start_min: start_min })
+      self
+    end
+    alias_method :start_min, :start_min=
+
+    def end_min=(end_min)
+      merge_arguments(:update_push_preferences, { end_min: end_min })
+      self
+    end
+    alias_method :end_min, :end_min=
 
     def register_gcm_token(token)
-      UserApi.register_gcm_token(user_id, token)
+      merge_arguments(:register_gcm_token, token, ->(response){ self.gcm_tokens << response.body['token'] })
+      self
     end
 
     def register_apns_token(token)
-      UserApi.register_apns_token(user_id, token)
+      merge_arguments(:register_apns_token, token, ->(response){ self.apns_tokens << response.body['token'] })
+      self
     end
 
     def unregister_gcm_token(token)
-      UserApi.unregister_gcm_token(user_id, token)
+      merge_arguments(:unregister_gcm_token, token, ->(response){ self.gcm_tokens.delete(response.body['token'])})
+      self
     end
 
     def unregister_apns_token(token)
-      UserApi.unregister_apns_token(user_id, token)
+      merge_arguments(:unregister_apns_token, token, ->(response){ self.apns_tokens.delete(response.body['token'])})
+      self
     end
 
     def unregister_all_device_token
-      UserApi.unregister_all_device_token(user_id)
+      merge_arguments(:unregister_all_device_token, nil, ->(response) { self.apns_tokens = []; self.gcm_tokens = []; })
+      self
+    end
+
+    def mark_as_read_all
+      merge_arguments(:mark_as_read_all, {})
+      self
+    end
+
+    def group_channel(channel_url)
+      GroupChannel.new(channel_url, user_id)
+    end
+
+    private
+    attr_writer :pending_requests, :apns_tokens, :gcm_tokens
+    def error_message(error_message, method_name, args)
+      "Invalid request for User with user_id: #{user_id}, error message: #{error_message} the request method was #{method_name} with args: #{args}"
     end
   end
 end

data/lib/sendbird/user_api.rb

@@ -4,7 +4,7 @@ module Sendbird
     ENDPOINT = 'users'.freeze
 
     class << self
-      def show(user_id)
+      def view(user_id)
         get(path: build_url(user_id))
       end
 

data/lib/sendbird/version.rb

@@ -1,3 +1,3 @@
 module Sendbird
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sendbird
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - GustavoCaso
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-17 00:00:00.000000000 Z
+date: 2016-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,14 +128,21 @@ files:
 - bin/setup
 - config/secrets.example.yml
 - lib/sendbird.rb
+- lib/sendbird/application_api.rb
 - lib/sendbird/client.rb
 - lib/sendbird/configuration.rb
 - lib/sendbird/group_channel.rb
+- lib/sendbird/group_channel_api.rb
+- lib/sendbird/invalid_request.rb
 - lib/sendbird/message.rb
+- lib/sendbird/message_api.rb
 - lib/sendbird/meta_base.rb
-- lib/sendbird/meta_counter.rb
-- lib/sendbird/meta_data.rb
-- lib/sendbird/open_channel.rb
+- lib/sendbird/meta_counter_api.rb
+- lib/sendbird/meta_data_api.rb
+- lib/sendbird/open_channel_api.rb
+- lib/sendbird/request_handler.rb
+- lib/sendbird/request_handler/request.rb
+- lib/sendbird/request_handler/request_merger.rb
 - lib/sendbird/response.rb
 - lib/sendbird/user.rb
 - lib/sendbird/user_api.rb