twilio-ruby 3.11.5 → 5.71.0

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module Twilio
+  module HTTP
+    class Client
+      attr_accessor :adapter
+      attr_reader :timeout, :last_response, :last_request
+
+      def initialize(proxy_prot = nil, proxy_addr = nil, proxy_port = nil, proxy_user = nil, proxy_pass = nil,
+                     ssl_ca_file = nil, timeout: nil)
+        @proxy_prot = proxy_prot
+        @proxy_path = "#{proxy_addr}:#{proxy_port}" if proxy_addr && proxy_port
+        @proxy_auth = "#{proxy_user}:#{proxy_pass}@" if proxy_pass && proxy_user
+        @ssl_ca_file = ssl_ca_file
+        @timeout = timeout
+        @adapter = Faraday.default_adapter
+        @configure_connection_blocks = []
+      end
+
+      def configure_connection(&block)
+        raise ArgumentError, "#{__method__} must be given a block!" unless block_given?
+
+        @configure_connection_blocks << block
+        nil
+      end
+
+      def _request(request) # rubocop:disable Metrics/MethodLength
+        @connection = Faraday.new(url: request.host + ':' + request.port.to_s, ssl: { verify: true }) do |f|
+          f.options.params_encoder = Faraday::FlatParamsEncoder
+          f.request :url_encoded
+          f.headers = request.headers
+          if Faraday::VERSION.start_with?('2.')
+            f.request(:authorization, :basic, request.auth[0], request.auth[1])
+          else
+            f.request(:basic_auth, request.auth[0], request.auth[1])
+          end
+          f.proxy = "#{@proxy_prot}://#{@proxy_auth}#{@proxy_path}" if @proxy_prot && @proxy_path
+          f.options.open_timeout = request.timeout || @timeout
+          f.options.timeout = request.timeout || @timeout
+
+          @configure_connection_blocks.each { |block| block.call(f) }
+          f.adapter @adapter
+        end
+
+        @last_request = request
+        @last_response = nil
+
+        response = send(request)
+        if (500..599).include?(response.status)
+          object = { message: "Server error (#{response.status})", code: response.status }.to_json
+        elsif response.body && !response.body.empty?
+          object = response.body
+        elsif response.status == 400
+          object = { message: 'Bad request', code: 400 }.to_json
+        end
+
+        twilio_response = Twilio::Response.new(response.status, object, headers: response.headers)
+        @last_response = twilio_response
+
+        twilio_response
+      end
+
+      def send(request)
+        @connection.send(request.method.downcase.to_sym,
+                         request.url,
+                         request.method == 'GET' ? request.params : request.data)
+      rescue Faraday::Error => e
+        raise Twilio::REST::TwilioError, e
+      end
+
+      def request(host, port, method, url, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        request = Twilio::Request.new(host, port, method, url, params, data, headers, auth, timeout)
+        _request(request)
+      end
+    end
+  end
+end

data/lib/twilio-ruby/http.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, 'http/**/*.rb')].sort.each do |file|
+  require file
+end

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

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+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,
+                    :region
+
+      def initialize(
+        account_sid,
+        signing_key_sid,
+        secret,
+        grants = [],
+        identity: nil,
+        nbf: nil,
+        ttl: 3600,
+        valid_until: nil,
+        region: 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
+        @region = region
+      end
+
+      def add_grant(grant)
+        @grants.push(grant)
+      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[:twr] = region unless region&.nil?
+
+        headers
+      end
+
+      class ChatGrant
+        include AccessTokenGrant
+        attr_accessor :service_sid,
+                      :endpoint_id,
+                      :deployment_role_sid,
+                      :push_credential_sid
+
+        def _key
+          'chat'
+        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 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
+
+        class << self
+          extend Gem::Deprecate
+          deprecate :new, 'Chat.new', 2017, 7
+        end
+      end
+
+      class VoiceGrant
+        include AccessTokenGrant
+        attr_accessor :incoming_allow,
+                      :outgoing_application_sid,
+                      :outgoing_application_params,
+                      :push_credential_sid,
+                      :endpoint_id
+
+        def _key
+          'voice'
+        end
+
+        def _generate_payload
+          payload = {}
+          payload[:incoming] = { allow: true } if incoming_allow == true
+
+          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
+
+      class PlaybackGrant
+        include AccessTokenGrant
+        attr_accessor :grant
+
+        def _key
+          'player'
+        end
+
+        def _generate_payload
+          grant
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Twilio
+  module JWT
+    module Scope
+      def _generate_payload
+        raise 'Not Implemented'
+      end
+    end
+
+    class ClientCapability < BaseJWT
+      attr_accessor :account_sid,
+                    :auth_token,
+                    :client_name,
+                    :scopes
+
+      def initialize(account_sid, auth_token, scopes: [], nbf: nil, ttl: 3600, valid_until: nil)
+        super(secret_key: auth_token, issuer: account_sid, nbf: nbf, ttl: ttl, valid_until: valid_until)
+        @account_sid = account_sid
+        @auth_token = auth_token
+        @client_name = nil
+        @scopes = scopes
+      end
+
+      def add_scope(scope)
+        @scopes.push(scope)
+      end
+
+      protected
+
+      def _generate_payload
+        scope = ''
+        scope = @scopes.map(&:_generate_payload).join(' ') unless @scopes.empty?
+
+        payload = {
+          scope: scope
+        }
+
+        payload
+      end
+
+      class IncomingClientScope
+        include Scope
+
+        def initialize(client_name)
+          @client_name = client_name
+        end
+
+        def _generate_payload
+          prefix = 'scope:client:incoming'
+          suffix = 'clientName=' + CGI.escape(@client_name.to_s)
+
+          [prefix, suffix].join('?')
+        end
+      end
+
+      class OutgoingClientScope
+        include Scope
+
+        def initialize(application_sid, client_name = nil, params = {})
+          @application_sid = application_sid
+          @client_name = client_name
+          @params = params
+        end
+
+        def _generate_payload
+          prefix = 'scope:client:outgoing'
+          application_sid = "appSid=#{CGI.escape(@application_sid)}"
+          unless @client_name.nil?
+            client_name = "clientName=#{CGI.escape(@client_name)}"
+          end
+          unless @params.empty?
+            params = 'appParams=' + @params.map { |k, v| CGI.escape("#{k}=#{v}") }.join(CGI.escape('&'))
+          end
+
+          suffix = [application_sid, client_name, params].compact.join('&')
+          [prefix, suffix].join('?')
+        end
+      end
+
+      class EventStreamScope
+        include Scope
+
+        def initialize(filters = {})
+          @filters = filters
+          @path = '/2010-04-01/Events'
+        end
+
+        def _generate_payload
+          prefix = 'scope:stream:subscribe'
+          path = "path=#{CGI.escape(@path)}"
+          unless @filters.empty?
+            filters = 'params=' + @filters.map { |k, v| CGI.escape("#{k}=#{v}") }.join('&')
+          end
+
+          suffix = [path, filters].compact.join('&')
+          [prefix, suffix].join('?')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'jwt'
+
+module Twilio
+  module JWT
+    autoload :AccessToken, File.join(File.dirname(__FILE__), 'access_token.rb')
+    autoload :ClientCapability, File.join(File.dirname(__FILE__), 'client_capability.rb')
+    autoload :TaskRouterCapability, File.join(File.dirname(__FILE__), 'task_router.rb')
+
+    class BaseJWT
+      # valid_until overrides ttl if specified
+      def initialize(secret_key: nil, issuer: nil, subject: nil, nbf: nil, ttl: 3600, valid_until: nil)
+        if secret_key.nil?
+          raise ArgumentError, 'JWT does not have a signing key'
+        end
+
+        @secret_key = secret_key
+        @issuer = issuer
+        @subject = subject
+        @algorithm = 'HS256'
+        @nbf = nbf
+        @ttl = ttl
+        @valid_until = valid_until
+      end
+
+      def _generate_headers
+        {}
+      end
+
+      def _generate_payload
+        raise NotImplementedError
+      end
+
+      def headers
+        headers = _generate_headers.clone
+        headers['typ'] = 'JWT'
+        headers['alg'] = @algorithm
+        headers
+      end
+
+      def payload
+        payload = _generate_payload.clone
+
+        payload[:iss] = @issuer
+        payload[:nbf] = @nbf || Time.now.to_i
+        payload[:exp] = @valid_until.nil? ? Time.now.to_i + @ttl : @valid_until
+        payload[:sub] = @subject unless @subject.nil?
+
+        payload
+      end
+
+      def to_jwt
+        ::JWT.encode payload, @secret_key, @algorithm, headers
+      end
+      alias to_s to_jwt
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Twilio
+  module JWT
+    class TaskRouterCapability < BaseJWT
+      TASK_ROUTER_VERSION = 'v1'.freeze
+      def initialize(account_sid, auth_token, workspace_sid, channel_id, nbf: nil, ttl: 3600, valid_until: nil)
+        super(secret_key: auth_token,
+              issuer: account_sid,
+              nbf: nbf,
+              ttl: ttl,
+              valid_until: valid_until
+        )
+        @account_sid = account_sid
+        @auth_token = auth_token
+        @workspace_sid = workspace_sid
+        @channel_id = channel_id
+        @policies = []
+      end
+
+      def add_policy(policy)
+        @policies.push(policy)
+      end
+
+      protected
+
+      def _generate_payload
+        Twilio::JWT::TaskRouterCapability::TaskRouterUtils
+          .web_socket_policies(@account_sid, @channel_id)
+          .each { |policy| add_policy(policy) }
+        policies = @policies.map(&:_generate_payload)
+
+        payload = {
+          account_sid: @account_sid,
+          workspace_sid: @workspace_sid,
+          channel: @channel_id,
+          version: TASK_ROUTER_VERSION,
+          friendly_name: @channel_id,
+          policies: policies
+        }
+
+        if @channel_id[0..1] == 'WK'
+          payload[:worker_sid] = @channel_id
+        elsif @channel_id[0..1] == 'WQ'
+          payload[:taskqueue_sid] = @channel_id
+        end
+
+        payload
+      end
+
+      class Policy
+        attr_accessor :url,
+                      :method,
+                      :allowed,
+                      :post_filters,
+                      :query_filters
+
+        def initialize(url, method, allowed, post_filters = {}, query_filters = {})
+          @url = url
+          @method = method
+          @allowed = allowed
+          @post_filters = post_filters
+          @query_filters = query_filters
+        end
+
+        def _generate_payload
+          policy = {
+            url: @url,
+            method: @method,
+            query_filter: @query_filters,
+            post_filter: @post_filters,
+            allow: @allowed
+          }
+          policy
+        end
+      end
+
+      class TaskRouterUtils
+        TASK_ROUTER_VERSION = 'v1'.freeze
+        TASK_ROUTER_BASE_URL = 'https://taskrouter.twilio.com'.freeze
+        TASK_ROUTER_WEBSOCKET_BASE_URL = 'https://event-bridge.twilio.com/v1/wschannels'.freeze
+
+        def self.workspaces
+          [TASK_ROUTER_BASE_URL, TASK_ROUTER_VERSION, 'Workspaces'].join('/')
+        end
+
+        def self.workspace(workspace_sid)
+          [TASK_ROUTER_BASE_URL, TASK_ROUTER_VERSION, 'Workspaces', workspace_sid].join('/')
+        end
+
+        def self.all_workspaces
+          [TASK_ROUTER_BASE_URL, TASK_ROUTER_VERSION, 'Workspaces', '**'].join('/')
+        end
+
+        def self.tasks(workspace_sid)
+          [workspace(workspace_sid), 'Tasks'].join('/')
+        end
+
+        def self.task(workspace_sid, tasks_sid)
+          [workspace(workspace_sid), 'Tasks', tasks_sid].join('/')
+        end
+
+        def self.all_tasks(workspace_sid)
+          [workspace(workspace_sid), 'Tasks', '**'].join('/')
+        end
+
+        def self.task_queues(workspace_sid)
+          [workspace(workspace_sid), 'TaskQueues'].join('/')
+        end
+
+        def self.task_queue(workspace_sid, taskqueue_sid)
+          [workspace(workspace_sid), 'TaskQueues', taskqueue_sid].join('/')
+        end
+
+        def self.all_task_queues(workspace_sid)
+          [workspace(workspace_sid), 'TaskQueues', '**'].join('/')
+        end
+
+        def self.activities(workspace_sid)
+          [workspace(workspace_sid), 'Activities'].join('/')
+        end
+
+        def self.activity(workspace_sid, activity_sid)
+          [workspace(workspace_sid), 'Activities', activity_sid].join('/')
+        end
+
+        def self.all_activities(workspace_sid)
+          [workspace(workspace_sid), 'Activities', '**'].join('/')
+        end
+
+        def self.workers(workspace_sid)
+          [workspace(workspace_sid), 'Workers'].join('/')
+        end
+
+        def self.worker(workspace_sid, worker_sid)
+          [workspace(workspace_sid), 'Workers', worker_sid].join('/')
+        end
+
+        def self.all_workers(workspace_sid)
+          [workspace(workspace_sid), 'Workers', '**'].join('/')
+        end
+
+        def self.reservations(workspace_sid, worker_sid)
+          [worker(workspace_sid, worker_sid), 'Reservations'].join('/')
+        end
+
+        def self.reservation(workspace_sid, worker_sid, reservation_sid)
+          [worker(workspace_sid, worker_sid), 'Reservations', reservation_sid].join('/')
+        end
+
+        def self.all_reservations(workspace_sid, worker_sid)
+          [worker(workspace_sid, worker_sid), 'Reservations', '**'].join('/')
+        end
+
+        def self.web_socket_policies(account_sid, channel_sid)
+          url = [TASK_ROUTER_WEBSOCKET_BASE_URL, account_sid, channel_sid].join('/')
+          get = Policy.new(url, 'GET', true)
+          post = Policy.new(url, 'POST', true)
+          [get, post]
+        end
+
+        def self.worker_policies(workspace_sid, worker_sid)
+          activities = Policy.new(self.activities(workspace_sid), 'GET', true)
+          tasks = Policy.new(all_tasks(workspace_sid), 'GET', true)
+          reservations = Policy.new(all_reservations(workspace_sid, worker_sid), 'GET', true)
+          fetch = Policy.new(worker(workspace_sid, worker_sid), 'GET', true)
+          [activities, tasks, reservations, fetch]
+        end
+      end
+    end
+  end
+end