ringcentral_sdk 0.5.2 → 1.0.0

data/lib/ringcentral_sdk/{platform.rb → rest/client.rb}

@@ -4,8 +4,8 @@ require 'faraday_middleware'
 require 'faraday_middleware/oauth2_refresh'
 require 'oauth2'
 
-module RingCentralSdk
-  class Platform
+module RingCentralSdk::REST
+  class Client
 
     ACCESS_TOKEN_TTL  = 600             # 10 minutes
     REFRESH_TOKEN_TTL = 36000           # 10 hours
@@ -18,37 +18,39 @@ module RingCentralSdk
     API_VERSION       = 'v1.0'
     URL_PREFIX        = '/restapi'
 
-    attr_accessor :server_url
-
-    attr_reader   :client
-    attr_reader   :oauth2client
-    attr_reader   :token
-    attr_reader   :user_agent
-    attr_reader   :redirect_uri
+    attr_reader :app_config
+    attr_reader :http
+    attr_reader :oauth2client
+    attr_reader :token
+    attr_reader :user_agent
+    attr_reader :messages
+
+    def initialize(app_key='', app_secret='', server_url=RingCentralSdk::RC_SERVER_SANDBOX, opts={})
+      init_attributes()
+      app_config = RingCentralSdk::REST::ConfigApp.new(app_key, app_secret, server_url, opts)
+      app_config(app_config)
+
+      if opts.key?(:username) && opts.key?(:password)
+        extension = opts.key?(:extension) ? opts[:extension] : ''
+        authorize_password(opts[:username], extension, opts[:password])
+      end
 
-    attr_reader   :messages
+      @messages = RingCentralSdk::REST::Messages.new(self)
+    end
 
-    def initialize(app_key, app_secret, server_url=RingCentralSdk::RC_SERVER_SANDBOX, opts={})
-      @app_key      = app_key.to_s
-      @app_secret   = app_secret.to_s
-      @server_url   = server_url
-      @token        = nil
-      @client       = nil
-      @redirect_uri = ''
-      @user_agent   = get_user_agent()
+    def app_config(app_config)
+      @app_config = app_config
       @oauth2client = new_oauth2_client()
-      if opts.is_a?(Hash)
-        @redirect_uri = opts.has_key?(:redirect_uri) ? opts[:redirect_uri] : ''
-        if opts.has_key?(:username) && opts.has_key?(:password)
-          extension = opts.has_key?(:extension) ? opts[:extension] : ''
-          authorize_password(opts[:username], extension, opts[:password])
-        end
-      end
-      @messages = RingCentralSdk::Helpers::Messages.new(self)
     end
 
-    def get_api_version_url()
-      return @server_url + URL_PREFIX + '/' + API_VERSION 
+    def init_attributes()
+      @token = nil
+      @http = nil
+      @user_agent = get_user_agent()
+    end
+
+    def api_version_url()
+      return @app_config.server_url + URL_PREFIX + '/' + API_VERSION 
     end
 
     def create_url(url, add_server=false, add_method=nil, add_token=false)
@@ -56,7 +58,7 @@ module RingCentralSdk
       has_http = !url.index('http://').nil? && !url.index('https://').nil?
 
       if add_server && ! has_http
-        built_url += @server_url
+        built_url += @app_config.server_url
       end
 
       if url.index(URL_PREFIX).nil? && ! has_http
@@ -92,21 +94,22 @@ module RingCentralSdk
     end
 
     def authorize_url(opts={})
-      if ! opts.has_key?(:redirect_uri) && @redirect_uri.to_s.length>0
-        opts[:redirect_uri] = @redirect_uri.to_s
-      end
-      @oauth2client.auth_code.authorize_url(opts)
+      @oauth2client.auth_code.authorize_url(_add_redirect_uri(opts))
     end
 
     def authorize_code(code, opts={})
-      if ! opts.has_key?(:redirect_uri) && @redirect_uri.to_s.length>0
-        opts[:redirect_uri] = @redirect_uri.to_s
-      end
-      token = @oauth2client.auth_code.get_token(code, opts)
+      token = @oauth2client.auth_code.get_token(code, _add_redirect_uri(opts))
       set_token(token)
       return token
     end
 
+    def _add_redirect_uri(opts={})
+      if !opts.key?(:redirect_uri) && @app_config.redirect_url.to_s.length > 0
+        opts[:redirect_uri] = @app_config.redirect_url.to_s
+      end
+      return opts
+    end
+
     def authorize_password(username, extension='', password='', remember=false)
       token = @oauth2client.password.get_token(username, password, {
         :extension => extension,
@@ -115,6 +118,10 @@ module RingCentralSdk
       return token
     end
 
+    def authorize_user(user, remember=false)
+      authorize_password(user.username, user.extension, user.password)
+    end
+
     def set_token(token)
       if token.is_a?(Hash)
         token = OAuth2::AccessToken::from_hash(@oauth2client, token)
@@ -124,9 +131,9 @@ module RingCentralSdk
         raise "Token is not a OAuth2::AccessToken"
       end
 
-      @token  = token
+      @token = token
 
-      @client = Faraday.new(:url => get_api_version_url()) do |conn|
+      @http = Faraday.new(:url => api_version_url()) do |conn|
         conn.request  :oauth2_refresh, @token
         conn.request  :json
         conn.request  :url_encoded
@@ -138,8 +145,8 @@ module RingCentralSdk
     end
 
     def new_oauth2_client()
-      return OAuth2::Client.new(@app_key, @app_secret,
-        :site          => @server_url,
+      return OAuth2::Client.new(@app_config.key, @app_config.secret,
+        :site          => @app_config.server_url,
         :authorize_url => AUTHZ_ENDPOINT,
         :token_url     => TOKEN_ENDPOINT)
     end
@@ -150,26 +157,26 @@ module RingCentralSdk
       elsif client.is_a?(OAuth2::Client)
         @oauth2client = client
       else
-        raise "client is not an OAuth2::Client"
+        fail "client is not an OAuth2::Client"
       end
     end
 
     def get_api_key()
-      api_key = (@app_key.is_a?(String) && @app_secret.is_a?(String)) \
-        ? Base64.encode64("#{@app_key}:#{@app_secret}").gsub(/[\s\t\r\n]/,'') : ''
+      api_key = (@app_config.key.is_a?(String) && @app_config.secret.is_a?(String)) \
+        ? Base64.encode64("#{@app_config.key}:#{@app_config.secret}").gsub(/[\s\t\r\n]/,'') : ''
       return api_key
     end
 
-    def send_request(helper=nil)
-      unless helper.is_a?(RingCentralSdk::Helpers::Request)
-        raise 'Request is not a RingCentralSdk::Helpers::Request'
+    def send_request(request=nil)
+      unless request.is_a?(RingCentralSdk::REST::Request::Base)
+        fail 'Request is not a RingCentralSdk::REST::Request::Base'
       end
 
-      if helper.method.downcase == 'post'
-        resp       =  @client.post do |req|
-          req.url helper.url
-          req.headers['Content-Type'] = helper.content_type if helper.content_type
-          req.body = helper.body if helper.body
+      if request.method.downcase == 'post'
+        resp       =  @http.post do |req|
+          req.url request.url
+          req.headers['Content-Type'] = request.content_type if request.content_type
+          req.body = request.body if request.body
         end
         return resp
       end
@@ -185,12 +192,11 @@ module RingCentralSdk
     end
 
     def create_subscription()
-      return RingCentralSdk::Subscription.new(self)
+      return RingCentralSdk::REST::Subscription.new(self)
     end
 
     alias_method :authorize, :authorize_password
     alias_method :login, :authorize_password
-    alias_method :request, :send_request
-    private :get_api_version_url
+    private :api_version_url
   end
 end

data/lib/ringcentral_sdk/rest/config.rb

@@ -0,0 +1,93 @@
+require 'dotenv'
+
+module RingCentralSdk::REST
+  class Config
+    attr_accessor :user
+    attr_accessor :app
+    attr_accessor :env
+
+    def initialize
+      @app = RingCentralSdk::REST::ConfigApp.new
+      @user = RingCentralSdk::REST::ConfigUser.new
+      @env = RingCentralSdk::REST::ConfigEnvRc.new
+    end
+
+    def load_dotenv
+      Dotenv.load
+      @app.load_env()
+      @user.load_env()
+      @env.load_env()
+      return self
+    end
+  end
+end
+
+module RingCentralSdk::REST
+  class ConfigUser
+    attr_accessor :username
+    attr_accessor :extension
+    attr_accessor :password
+
+    def load_env
+      @username = ENV['RC_USER_USERNAME']
+      @extension = ENV['RC_USER_EXTENSION']
+      @password = ENV['RC_USER_PASSWORD']
+    end
+
+    def nilify
+      @username = ''
+      @extension = ''
+      @password = ''
+    end
+  end
+end
+
+module RingCentralSdk::REST
+  class ConfigApp
+    attr_accessor :key
+    attr_accessor :secret
+    attr_accessor :server_url
+    attr_accessor :redirect_url
+
+    def initialize(app_key='', app_secret='', server_url=RingCentralSdk::RC_SERVER_SANDBOX, opts={})
+      @key = app_key
+      @secret = app_secret
+      @server_url = server_url
+      if opts.key?(:redirect_url)
+        @redirect_url = opts[:redirect_url]
+      elsif opts.key?(:redirect_uri)
+        @redirect_url = opts[:redirect_uri]
+      else
+        @redirect_url = ''
+      end
+    end
+
+    def load_env
+      ['RC_APP_KEY', 'RC_APP_SECRET', 'RC_APP_SERVER_URL', 'RC_APP_REDIRECT_URL'].each do |var|
+        if !ENV.key?(var)
+          fail "environment variable '#{var}' not found"
+        end
+      end
+      
+      @key = ENV['RC_APP_KEY']
+      @secret = ENV['RC_APP_SECRET']
+      @server_url = ENV['RC_APP_SERVER_URL']
+      @redirect_url = ENV['RC_APP_REDIRECT_URL']
+    end
+  end
+end
+
+module RingCentralSdk::REST
+  class ConfigEnvRc
+    attr_accessor :data
+    def initialize
+      @data = {}
+    end
+    def load_env
+      ENV.each do |k,v|
+        next unless k.index('RC_') == 0
+        @data[k] = v
+      end
+    end
+  end
+end

data/lib/ringcentral_sdk/rest/extension.rb

@@ -0,0 +1,12 @@
+module RingCentralSdk::REST
+  class Extension
+  	attr_reader :extension_id
+  	attr_reader :presence
+  	attr_accessor :client
+  	def initialize(extension_id, opts={})
+  	  @extension_id = extension_id
+  	  @client = opts.has_key?(:client) ? opts[:client] : nil
+      @presence = RingCentralSdk::REST::ExtensionPresence.new(extension_id, opts)
+  	end
+  end
+end

data/lib/ringcentral_sdk/rest/extension_presence.rb

@@ -0,0 +1,104 @@
+module RingCentralSdk::REST
+  class ExtensionPresence
+    attr_accessor :client
+    attr_accessor :account_id
+    attr_accessor :extension_id
+    attr_accessor :presence_data
+
+    def initialize(extension_id, opts={})
+      @client = opts.key?(:client) ? opts[:client] : nil
+      @account_id = '~'
+      @extension_id = extension_id.to_s
+      @presence_data = {}
+    end
+
+    def retrieve()
+      if @extension_id !~ /^[0-9]+$/
+        raise "extension_id is not an integer"
+      end
+
+      res = @client.http.get do |req|
+        req.url "account/#{@account_id}/extension/#{@extension_id}/presence"
+      end
+
+      @presence_data = res.body
+
+      return @presence_data
+    end
+
+    def department_calls_enable(enable)
+      retrieve()
+
+      if !@presence_data.key?('dndStatus')
+        raise 'invalid presence info'
+      end
+
+      current_status = @presence_data['dndStatus']
+      new_status = new_status_dnd_department_calls(current_status, enable)
+
+      if current_status != new_status
+        update({:dndStatus => new_status})
+      end
+
+      return new_status
+    end
+
+    def department_calls_enabled?(reload=false)
+      if reload
+        retrieve()
+      elsif !@presence_data.key?('dndStatus')
+        retrieve()
+      end
+
+      current_status = @presence_data['dndStatus']
+
+      status_enabled = {
+        'DoNotAcceptAnyCalls' => false,
+        'DoNotAcceptDepartmentCalls' => false,
+        'TakeAllCalls' => true,
+        'TakeDepartmentCallsOnly' => true
+      }
+
+      return status_enabled.key?(current_status) ?
+        status_enabled[current_status] : nil
+    end
+
+    def update(body=nil)
+      if body.nil?
+        raise 'HTTP request body is required to update presence'
+      end
+
+      res = @client.http.put do |req|
+        req.url "account/#{@account_id}/extension/#{@extension_id}/presence"
+        req.headers['Content-Type'] = 'application/json'
+        req.body = body
+      end
+      
+      @presence_data = res.body
+
+      return @presence_data
+    end
+
+    def new_status_dnd_department_calls(current_status, enable)
+      new_statuses = {
+        :enable => {
+          'DoNotAcceptAnyCalls' => 'TakeDepartmentCallsOnly',
+          'DoNotAcceptDepartmentCalls' => 'TakeAllCalls'
+        },
+        :disable => {
+          'TakeAllCalls' => 'DoNotAcceptDepartmentCalls',
+          'TakeDepartmentCallsOnly' => 'DoNotAcceptAnyCalls'
+        }
+      }
+
+      action = enable ? :enable : :disable
+
+      new_status = current_status
+
+      new_status = new_statuses[action][current_status.to_s] \
+        if new_statuses[action].key?(current_status.to_s)
+
+      return new_status
+    end
+  end
+end

data/lib/ringcentral_sdk/rest/messages.rb

@@ -0,0 +1,46 @@
+module RingCentralSdk::REST
+  class Messages
+    attr_reader :sms
+    attr_reader :fax
+
+    def initialize(client)
+      @client = client
+      @sms = RingCentralSdk::REST::MessagesSMS.new(client)
+      @fax = RingCentralSdk::REST::MessagesFax.new(client)
+    end
+  end
+end
+
+module RingCentralSdk::REST
+  class MessagesSMS
+    def initialize(client)
+      @client = client
+    end
+
+    def create(opts)
+      response = @client.http.post do |req|
+        req.url 'account/~/extension/~/sms'
+        req.headers['Content-Type'] = 'application/json'
+        req.body = {
+          :from =>   { :phoneNumber => opts[:from].to_s },
+          :to   => [ { :phoneNumber => opts[:to].to_s } ],
+          :text => opts[:text].to_s
+        }
+      end
+      return response
+    end
+  end
+end
+
+module RingCentralSdk::REST
+  class MessagesFax
+    def initialize(client)
+      @client = client
+    end
+
+    def create(opts)
+      fax = RingCentralSdk::REST::Request::Fax.new(opts)
+      return @client.send_request(fax)
+    end
+  end
+end

data/lib/ringcentral_sdk/{helpers/request.rb → rest/request/base.rb}

@@ -1,5 +1,5 @@
-module RingCentralSdk::Helpers
-  class Request
+module RingCentralSdk::REST::Request
+  class Base
     def method()
       return 'get'
     end

data/lib/ringcentral_sdk/rest/request/fax.rb

@@ -0,0 +1,121 @@
+require 'base64'
+require 'mime'
+require 'mime/types'
+require 'mime_builder'
+require 'multi_json'
+
+module RingCentralSdk::REST::Request
+  class Fax < RingCentralSdk::REST::Request::Base
+    attr_reader :msg
+
+    attr_reader :account_id
+    attr_reader :extension_id
+
+    def initialize(opts={})
+      @metadata_part_encode_base64 = true
+
+      @msg = MIME::Multipart::Mixed.new
+      @msg.headers.delete('Content-Id')
+
+      add_path(opts)
+      add_part_meta(opts)
+      add_part_text(opts[:text])
+      add_parts(opts[:files])
+      add_parts(opts[:parts])
+    end
+
+    def add_path(opts={})
+      if opts.key?(:accountId) && opts[:accountId].to_s.length>0
+        @account_id = opts[:accountId]
+      else
+        @account_id = '~'
+      end
+      if opts.key?(:extensionId) && opts[:extensionId].to_s.length>0
+        @extension_id = opts[:extensionId]
+      else
+        @extension_id = '~'
+      end
+    end
+
+    def add_part_meta(opts={})
+      meta = create_metadata opts
+      json = MultiJson.encode meta
+      json = Base64.encode64(json) if @metadata_part_encode_base64
+      json_part = MIME::Text.new(json)
+      json_part.headers.delete('Content-Id')
+      json_part.headers.set('Content-Type', 'application/json')
+      json_part.headers.set('Content-Transfer-Encoding', 'base64') if @metadata_part_encode_base64
+      @msg.add(json_part)
+      true
+    end
+
+    def create_metadata(opts={})
+      meta = {}
+      return meta unless opts.is_a?(Hash)
+
+      inf = RingCentralSdk::REST::Request::Inflator::ContactInfo.new
+      meta[:to] = inf.inflate_to_array opts[:to]
+
+      processed = {
+        :accountId => 1,
+        :extensionId => 1,
+        :to    => 1,
+        :text  => 1,
+        :files => 1,
+        :parts => 1
+      }
+
+      opts.each do |k,v|
+        meta[k] = v unless processed.key?(k)
+      end
+
+      meta
+    end
+
+    def add_part_text(text=nil, opts={})
+      return unless !text.nil? && text.to_s.length>0
+      opts[:content_id_disable] = true
+      text_part = MIMEBuilder::Text.new(text, opts)
+      @msg.add(text_part.mime)
+    end
+
+    def add_parts(parts=[])
+      return if parts.nil?
+      unless parts.is_a?(Array)
+        raise 'invalid parameter[0]. needs to be an array'
+      end
+      parts.each do |part|
+        if part.is_a?(String)
+          file_part = MIMEBuilder::Filepath.new(part)
+          @msg.add(file_part.mime)
+        elsif part.is_a? Hash
+          part[:content_id_disable] = true
+          part[:is_attachment] = true
+          if part.key? :filename
+            file_part = MIMEBuilder::Filepath.new(part[:filename], part)
+            @msg.add(file_part.mime)
+          elsif part.key? :text
+            text_part = MIMEBuilder::Text.new(part[:text], part)
+            @msg.add(text_part.mime)
+          end
+        end
+      end
+    end
+
+    def method()
+      'post'
+    end
+
+    def url()
+      "account/#{@account_id.to_s}/extension/#{@extension_id.to_s}/fax"
+    end
+
+    def content_type()
+      @msg.headers.get('Content-Type').to_s
+    end
+
+    def body()
+      @msg.body.to_s
+    end
+  end
+end

data/lib/ringcentral_sdk/{helpers → rest/request}/inflator/contact_info.rb

@@ -1,4 +1,4 @@
-module RingCentralSdk::Helpers::Inflator
+module RingCentralSdk::REST::Request::Inflator
   class ContactInfo
     def inflate_to_array(any=nil)
       contacts   = []

data/lib/ringcentral_sdk/rest/request/inflator.rb

@@ -0,0 +1,3 @@
+module RingCentralSdk::REST::Request::Inflator
+  autoload :ContactInfo, 'ringcentral_sdk/rest/request/inflator/contact_info'
+end

data/lib/ringcentral_sdk/rest/request.rb

@@ -0,0 +1,5 @@
+module RingCentralSdk::REST::Request
+  autoload :Base, 'ringcentral_sdk/rest/request/base'
+  autoload :Fax, 'ringcentral_sdk/rest/request/fax'
+  autoload :Inflator, 'ringcentral_sdk/rest/request/inflator'
+end

data/lib/ringcentral_sdk/{simple.rb → rest/simple_client.rb}

@@ -1,14 +1,14 @@
-module RingCentralSdk
-  class Simple
-    attr_accessor :rcsdk
+module RingCentralSdk::REST
+  class SimpleClient
+    attr_accessor :client
 
-    def initialize(rcsdk)
-      @rcsdk = rcsdk
+    def initialize(client)
+      @client = client
     end
 
     def send(request)
       if request.is_a?(RingCentralSdk::Helpers::Request)
-        return @rcsdk.request(request)
+        return @client.request(request)
       elsif ! request.is_a?(Hash)
         raise "Request is not a RingCentralSdk::Helpers::Request or Hash"
       end
@@ -29,19 +29,19 @@ module RingCentralSdk
     end
 
     def delete(opts={})
-      return @rcsdk.client.delete do |req|
+      return @client.http.delete do |req|
         req.url build_url(opts[:path])
       end
     end
 
     def get(opts={})
-      return @rcsdk.client.get do |req|
+      return @client.http.get do |req|
         req.url build_url(opts[:path])
       end
     end
 
     def post(opts={})
-      return @rcsdk.client.post do |req|
+      return @client.http.post do |req|
         req.url build_url(opts[:path])
         if opts.has_key?(:body)
           req.body = opts[:body]
@@ -53,7 +53,7 @@ module RingCentralSdk
     end
 
     def put(opts={})
-      return @rcsdk.client.put do |req|
+      return @client.http.put do |req|
         req.url build_url(opts[:path])
         if opts.has_key?(:body)
           req.body = opts[:body]