twilio-ruby 3.11.5 → 5.0.0

data/lib/rack/twilio_webhook_authentication.rb

@@ -0,0 +1,46 @@
+module Rack
+  # Middleware that authenticates webhooks from Twilio using the request
+  # validator.
+  #
+  # The middleware takes an auth token with which to set up the request
+  # validator and any number of paths. When a path matches the incoming request
+  # path, the request will be checked for authentication.
+  #
+  # Example:
+  #
+  # require 'rack'
+  # use Rack::TwilioWebhookAuthentication, ENV['AUTH_TOKEN'], /\/messages/
+  #
+  # The above appends this middleware to the stack, using an auth token saved in
+  # the ENV and only against paths that match /\/messages/. If the request
+  # validates then it gets passed on to the action as normal. If the request
+  # doesn't validate then the middleware responds immediately with a 403 status.
+
+  class TwilioWebhookAuthentication
+    def initialize(app, auth_token, *paths, &auth_token_lookup)
+      @app = app
+      @auth_token = auth_token
+      define_singleton_method(:get_auth_token, auth_token_lookup) if block_given?
+      @path_regex = Regexp.union(paths)
+    end
+
+    def call(env)
+      return @app.call(env) unless env['PATH_INFO'].match(@path_regex)
+      request = Rack::Request.new(env)
+      original_url = request.url
+      params = request.post? ? request.POST : {}
+      auth_token = @auth_token || get_auth_token(params['AccountSid'])
+      validator = Twilio::Security::RequestValidator.new(auth_token)
+      signature = env['HTTP_X_TWILIO_SIGNATURE'] || ''
+      if validator.validate(original_url, params, signature)
+        @app.call(env)
+      else
+        [
+          403,
+          { 'Content-Type' => 'text/plain' },
+          ['Twilio Request Validation Failed.']
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Twilio
+  module REST
+    class Domain
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+        @host = nil
+        @base_url = nil
+        @port = nil
+      end
+
+      def absolute_url(uri)
+        "#{@base_url.chomp('/')}/#{uri.chomp('/').gsub(/^\//, '')}"
+      end
+
+      def request(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        url = uri.match(/^http/) ? uri : absolute_url(uri)
+
+        @client.request(
+          @host,
+          @port,
+          method,
+          url,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Twilio
+  module REST
+    class TwilioError < StandardError
+      attr_reader :message, :body
+
+      def initialize(message, body = nil)
+        @message = message
+        @body = body
+      end
+
+      def to_s
+        "#{@message}: #{@body || 'no body'}"
+      end
+    end
+
+    class RestError < TwilioError
+      attr_reader :message, :code, :status_code
+
+      def initialize(message, code, status_code)
+        @message = message
+        @code = code
+        @status_code = status_code
+      end
+
+      def to_s
+        "[HTTP #{status_code}] #{code} : #{message}"
+      end
+    end
+  end
+end

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