twilio-ruby 4.13.0 → 5.0.0.alpha1

data/lib/twilio-ruby/framework/helper.rb

@@ -0,0 +1,9 @@
+module Twilio
+  module REST
+    def url_join(left, right)
+      left = left.sub(/\/+$/, '').sub(/^\/+/, '')
+      right = right.sub(/\/+$/, '').sub(/^\/+/, '')
+      "#{left}/#{right}"
+    end
+  end
+end

data/lib/twilio-ruby/framework/page.rb

@@ -0,0 +1,101 @@
+module Twilio
+  module REST
+    # Page Base Class
+    class Page
+      include Enumerable
+
+      META_KEYS = [
+        'end',
+        'first_page_uri',
+        'next_page_uri',
+        'last_page_uri',
+        'page',
+        'page_size',
+        'previous_page_uri',
+        'total',
+        'num_pages',
+        'start',
+        'uri'
+      ].freeze
+
+      def initialize(version, response)
+        payload = process_response(response)
+
+        @version = version
+        @payload = payload
+        @solution = {}
+        @records = load_page(payload)
+      end
+
+      def process_response(response)
+        if response.status_code != 200
+          raise Twilio::REST::TwilioError.new('Unable to fetch page', response)
+        end
+
+        response.body
+      end
+
+      def load_page(payload)
+        if payload['meta'] && payload['meta']['key']
+          return payload[payload['meta']['key']]
+        else
+          keys = payload.keys
+          key = keys - META_KEYS
+          return payload[key.first] if key.size == 1
+        end
+
+        raise Twilio::REST::TwilioError, 'Page Records can not be deserialized'
+      end
+
+      def previous_page_url
+        if @payload['meta'] && @payload['meta']['previous_page_url']
+          return @version.domain.absolute_url(URI.parse(@payload['meta']['previous_page_url']).request_uri)
+        elsif @payload['previous_page_uri']
+          return @version.domain.absolute_url(@payload['previous_page_uri'])
+        end
+
+        nil
+      end
+
+      def next_page_url
+        if @payload['meta'] && @payload['meta']['next_page_url']
+          return @version.domain.absolute_url(URI.parse(@payload['meta']['next_page_url']).request_uri)
+        elsif @payload['next_page_uri']
+          return @version.domain.absolute_url(@payload['next_page_uri'])
+        end
+
+        nil
+      end
+
+      def get_instance(payload)
+        raise Twilio::REST::TwilioError, 'Page.get_instance() must be implemented in the derived class'
+      end
+
+      def previous_page
+        return nil unless previous_page_url
+
+        response = @version.domain.request('GET', previous_page_url)
+
+        self.class.new(@version, response, @solution)
+      end
+
+      def next_page
+        return nil unless next_page_url
+
+        response = @version.domain.request('GET', next_page_url)
+
+        self.class.new(@version, response, @solution)
+      end
+
+      def each
+        @records.each do |record|
+          yield get_instance(record)
+        end
+      end
+
+      def to_s
+        '#<Page>'
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/resource.rb

@@ -0,0 +1,21 @@
+module Twilio
+  module REST
+    class ListResource
+      def initialize(version)
+        @version = version
+      end
+    end
+
+    class InstanceContext
+      def initialize(version)
+        @version = version
+      end
+    end
+
+    class InstanceResource
+      def initialize(version)
+        @version = version
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/serialize.rb

@@ -0,0 +1,70 @@
+module Twilio
+  def self.serialize_iso8601_date(date)
+    if date.eql?(:unset)
+      date
+    elsif date.is_a?(Date)
+      date.iso8601
+    elsif date.is_a?(Time)
+      date.strftime('%Y-%m-%d')
+    elsif date.is_a?(String)
+      date
+    end
+  end
+
+  def self.serialize_iso8601_datetime(date)
+    if date.eql?(:unset)
+      date
+    elsif date.is_a?(Date)
+      Time.new(date.year, date.month, date.day).utc.iso8601
+    elsif date.is_a?(Time)
+      date.utc.iso8601
+    elsif date.is_a?(String)
+      date
+    end
+  end
+
+  def self.deserialize_rfc2822(date)
+    Time.rfc2822(date) unless date.nil?
+  end
+
+  def self.deserialize_iso8601_date(date)
+    Date.parse(date) unless date.nil?
+  end
+
+  def self.deserialize_iso8601_datetime(date)
+    Time.parse(date) unless date.nil?
+  end
+
+  def self.serialize_object(object)
+    if object.is_a?(Hash) || object.is_a?(Array)
+      JSON.generate(object)
+    else
+      object
+    end
+  end
+
+  def self.flatten(map, result = {}, previous = [])
+    map.each do |key, value|
+      if value.is_a? Hash
+        self.flatten(value, result, previous + [key])
+      else
+        result[(previous + [key]).join('.')] = value
+      end
+    end
+
+    result
+  end
+
+  def self.prefixed_collapsible_map(map, prefix)
+    result = {}
+    if map.is_a? Hash
+      flattened = self.flatten(map)
+      result = {}
+      flattened.each do |key, value|
+        result[prefix + '.' + key] = value
+      end
+    end
+
+    result
+  end
+end

data/lib/twilio-ruby/framework/twilio_response.rb

@@ -0,0 +1,15 @@
+module Twilio
+  class TwilioResponse
+    attr_accessor :status_code, :body
+
+    def initialize(status_code, body)
+      @status_code = status_code
+      body = '{}' if !body || body.empty?
+      @body = JSON.parse(body)
+    end
+
+    def to_s
+      "[#{status_code}] #{body}"
+    end
+  end
+end

data/lib/twilio-ruby/framework/values.rb

@@ -0,0 +1,7 @@
+module Twilio
+  class Values
+    def self.of(hash)
+      hash.delete_if { |_, v| v.eql?(:unset) }
+    end
+  end
+end

data/lib/twilio-ruby/framework/version.rb

@@ -0,0 +1,164 @@
+module Twilio
+  module REST
+    class Version
+      attr_accessor :domain
+
+      class RecordStream
+        include Enumerable
+
+        def initialize(page, limit: nil, page_limit: nil)
+          @page = page
+          @limit = limit
+          @page_limit = page_limit
+        end
+
+        def each
+          current_record = 0
+          current_page = 1
+
+          while @page
+            @page.each do |record|
+              yield record
+              current_record += 1
+              return nil if @limit && @limit <= current_record
+            end
+
+            return nil if @page_limit && @page_limit <= current_page
+
+            @page = @page.next_page
+            current_page += 1
+          end
+        end
+      end
+
+      def initialize(domain)
+        @domain = domain
+        @version = nil
+      end
+
+      def absolute_url(uri)
+        @domain.absolute_url(relative_uri(uri))
+      end
+
+      def relative_uri(uri)
+        "#{@version.chomp('/').gsub(/^\//, '')}/#{uri.chomp('/').gsub(/^\//, '')}"
+      end
+
+      def request(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        url = relative_uri(uri)
+        params = params.delete_if { |_k, v| v.nil? }
+        data = data
+        @domain.request(method, url, params, data, headers, auth, timeout)
+      end
+
+      def exception(response, header)
+        message = header
+        code = response.status_code
+
+        if response.body.key?('message')
+          message += ": #{response.body['message']}"
+        end
+
+        code = response.body['code'] if response.body.key?('code')
+
+        Twilio::REST::RestError.new(message, code, response.status_code)
+      end
+
+      def fetch(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to fetch record')
+        end
+
+        response.body
+      end
+
+      def update(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to update record')
+        end
+
+        response.body
+      end
+
+      def delete(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to delete record')
+        end
+
+        response.status_code == 204
+      end
+
+      def read_limits(limit = nil, page_size = nil)
+        page_limit = nil
+
+        unless limit.nil?
+          # If there is no user-specified page_size, pick the most network efficient size
+          page_size = limit
+          page_limit = (limit / page_size.to_f).ceil
+        end
+
+        {
+          limit: limit || nil,
+          page_size: page_size || nil,
+          page_limit: page_limit
+        }
+      end
+
+      def page(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+      end
+
+      def stream(page, limit: nil, page_limit: nil)
+        RecordStream.new(page, limit: limit, page_limit: page_limit)
+      end
+
+      def create(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(method, uri, params, data, headers, auth, timeout)
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to create record')
+        end
+
+        response.body
+      end
+    end
+  end
+end

data/lib/twilio-ruby/http/http_client.rb

@@ -0,0 +1,46 @@
+require 'faraday'
+
+module Twilio
+  module HTTP
+    class Client
+      attr_accessor :adapter
+
+      def initialize(proxy_addr = nil, proxy_port = nil, proxy_user = nil, proxy_pass = nil, ssl_ca_file = nil)
+        @proxy_addr = proxy_addr
+        @proxy_port = proxy_port
+        @proxy_user = proxy_user
+        @proxy_pass = proxy_pass
+        @ssl_ca_file = ssl_ca_file
+        @adapter = Faraday.default_adapter
+
+        # Set default params encoder
+        Faraday::Utils.default_params_encoder = Faraday::FlatParamsEncoder
+      end
+
+      def request(host, port, method, url, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        @connection = Faraday.new(url: host + ':' + port.to_s, ssl: { verify: true }) do |f|
+          f.request :url_encoded
+          f.adapter @adapter
+          f.headers = headers
+          f.basic_auth(auth[0], auth[1])
+          if @proxy_addr
+            f.proxy '#{@proxy_user}:#{@proxy_pass}@#{@proxy_addr}:#{@proxy_port}'
+          end
+          f.options.open_timeout = timeout
+          f.options.timeout = timeout
+        end
+
+        response = @connection.send(method.downcase.to_sym, url, method == 'GET' ? params : data)
+
+        @last_response = response
+        if response.body && !response.body.empty?
+          object = response.body
+        elsif response.status == 400
+          object = { message: 'Bad request', code: 400 }.to_json
+        end
+
+        TwilioResponse.new(response.status, object)
+      end
+    end
+  end
+end

data/lib/twilio-ruby/jwt/access_token.rb

@@ -0,0 +1,232 @@
+module Twilio
+  module JWT
+    module AccessTokenGrant
+      def _key
+        raise NotImplementedError
+      end
+
+      def _generate_payload
+        raise NotImplementedError
+      end
+    end
+
+    class AccessToken < BaseJWT
+      attr_accessor :account_sid,
+                    :signing_key_id,
+                    :secret,
+                    :identity,
+                    :grants,
+                    :nbf,
+                    :ttl,
+                    :valid_until
+
+      def initialize(
+        account_sid,
+        signing_key_sid,
+        secret,
+        grants = [],
+        identity: nil,
+        nbf: nil,
+        ttl: 3600,
+        valid_until: nil
+      )
+        super(secret_key: secret,
+              issuer: signing_key_sid,
+              subject: account_sid,
+              nbf: nbf,
+              ttl: ttl,
+              valid_until: valid_until)
+        @account_sid = account_sid
+        @signing_key_sid = signing_key_sid
+        @secret = secret
+        @identity = identity
+        @nbf = nbf
+        @grants = grants
+        @ttl = ttl
+        @valid_until = valid_until
+      end
+
+      def add_grant(grant)
+        @grants.push(grant)
+      end
+
+      def to_s
+        to_jwt
+      end
+
+      protected
+
+      def _generate_payload
+        now = Time.now.to_i
+        grants = {}
+        grants[:identity] = @identity if @identity
+
+        @grants.each { |grant| grants[grant._key] = grant._generate_payload } unless @grants.empty?
+
+        payload = {
+          jti: "#{@signing_key_sid}-#{now}",
+          grants: grants
+        }
+
+        payload
+      end
+
+      protected
+
+      def _generate_headers
+        headers = {
+          cty: 'twilio-fpa;v=1'
+        }
+
+        headers
+      end
+
+      class IpMessagingGrant
+        include AccessTokenGrant
+        attr_accessor :service_sid,
+                      :endpoint_id,
+                      :deployment_role_sid,
+                      :push_credential_sid
+
+        def _key
+          'ip_messaging'
+        end
+
+        def _generate_payload
+          payload = {}
+
+          payload[:service_sid] = service_sid if service_sid
+
+          payload[:endpoint_id] = endpoint_id if endpoint_id
+
+          if deployment_role_sid
+            payload[:deployment_role_sid] = deployment_role_sid
+          end
+
+          if push_credential_sid
+            payload[:push_credential_sid] = push_credential_sid
+          end
+
+          payload
+        end
+      end
+
+      class VoiceGrant
+        include AccessTokenGrant
+        attr_accessor :outgoing_application_sid,
+                      :outgoing_application_params,
+                      :push_credential_sid,
+                      :endpoint_id
+
+        def _key
+          'voice'
+        end
+
+        def _generate_payload
+          payload = {}
+
+          if outgoing_application_sid
+            outgoing = {}
+            outgoing[:application_sid] = outgoing_application_sid
+            if outgoing_application_params
+              outgoing[:params] = outgoing_application_params
+            end
+
+            payload[:outgoing] = outgoing
+          end
+
+          if push_credential_sid
+            payload[:push_credential_sid] = push_credential_sid
+          end
+
+          payload[:endpoint_id] = endpoint_id if endpoint_id
+
+          payload
+        end
+      end
+
+      class SyncGrant
+        include AccessTokenGrant
+        attr_accessor :service_sid,
+                      :endpoint_id
+
+        def _key
+          'data_sync'
+        end
+
+        def _generate_payload
+          payload = {}
+
+          payload['service_sid'] = service_sid if service_sid
+          payload['endpoint_id'] = endpoint_id if endpoint_id
+
+          payload
+        end
+      end
+
+      class ConversationsGrant
+        include AccessTokenGrant
+        attr_accessor :configuration_profile_sid
+
+        def _key
+          'rtc'
+        end
+
+        def _generate_payload
+          payload = {}
+
+          if configuration_profile_sid
+            payload[:configuration_profile_sid] = configuration_profile_sid
+          end
+
+          payload
+        end
+
+        class << self
+          extend Gem::Deprecate
+          deprecate :new, 'VideoGrant.new', 2017, 5
+        end
+      end
+
+      class VideoGrant
+        include AccessTokenGrant
+        attr_accessor :room
+
+        def _key
+          'video'
+        end
+
+        def _generate_payload
+          payload = {}
+
+          payload[:room] = room if room
+
+          payload
+        end
+      end
+
+      class TaskRouterGrant
+        include AccessTokenGrant
+        attr_accessor :workspace_sid,
+                      :worker_sid,
+                      :role
+
+        def _key
+          'task_router'
+        end
+
+        def _generate_payload
+          payload = {}
+
+          payload[:workspace_sid] = workspace_sid if workspace_sid
+
+          payload[:worker_sid] = worker_sid if worker_sid
+
+          payload[:role] = role if role
+
+          payload
+        end
+      end
+    end
+  end
+end