twilio-ruby 4.13.0 → 5.40.0

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

@@ -1,230 +0,0 @@
-module Twilio
-  module TaskRouter
-    class Capability
-      TASK_ROUTER_BASE_URL = 'https://taskrouter.twilio.com'
-      TASK_ROUTER_VERSION = 'v1'
-      TASK_ROUTER_WEBSOCKET_BASE_URL = 'https://event-bridge.twilio.com/v1/wschannels'
-
-      REQUIRED = {required: true}
-      OPTIONAL = {required: false}
-
-      def initialize(account_sid, auth_token, workspace_sid, channel_id)
-        @account_sid = account_sid
-        @auth_token = auth_token
-        @policies = []
-
-        @workspace_sid = workspace_sid
-        @channel_id = channel_id
-
-        @baseUrl = "#{TASK_ROUTER_BASE_URL}/#{TASK_ROUTER_VERSION}/Workspaces/#{workspace_sid}"
-
-        validate_jwt
-
-        setup_resource
-
-        allow_websocket_requests(@channel_id)
-        allow(@resourceUrl, "GET")
-      end
-
-      def allow_fetch_subresources
-        allow(@resourceUrl + "/**", "GET")
-      end
-
-      def allow_updates
-        allow(@resourceUrl, "POST")
-      end
-
-      def allow_updates_subresources
-        allow(@resourceUrl + "/**", "POST")
-      end
-
-      def allow_delete
-        allow(@resourceUrl, "DELETE")
-      end
-
-      def allow_delete_subresources
-        allow(@resourceUrl + "/**", "DELETE")
-      end
-
-      # @deprecated Please use {Twilio::TaskRouter::WorkerCapability.allowActivityUpdates} instead
-      def allow_worker_activity_updates
-        if(@channel_id[0..1] == 'WK')
-          allow(@resourceUrl, "POST", nil, {ActivitySid: REQUIRED})
-        else
-          raise "Deprecreated function not applicable to non-Worker"
-        end
-      end
-
-      # @deprecated Please use {Twilio::TaskRouter::WorkerCapability} instead; added automatically in constructor
-      def allow_worker_fetch_attributes
-        if(@channel_id[0..1] == 'WK')
-          allow(@resourceUrl, "GET")
-        else
-          raise "Deprecated function not applicable to non Worker"
-        end
-      end
-
-      # @deprecated Please use {Twilio::TaskRouter::WorkerCapability.allowReservationUpdates} instead
-      def allow_task_reservation_updates
-        if(@channel_id[0..1] == 'WK')
-          task_url = "#{@baseUrl}/Tasks/**"
-          allow(task_url, "POST", nil, nil)
-        else
-          raise "Deprecated function not applicable to non Worker"
-        end
-      end
-
-      def add_policy(url, method, allowed = true, query_filters = nil, post_filters = nil)
-        policy = {
-            url: url,
-            method: method,
-            query_filter: query_filters || {},
-            post_filter: post_filters || {},
-            allow: allowed
-        }
-
-        @policies.push(policy)
-      end
-
-      def allow(url, method, query_filters = nil, post_filters = nil)
-        add_policy(url, method, true, query_filters, post_filters)
-      end
-
-      def deny(url, method, query_filters = nil, post_filters = nil)
-        add_policy(url, method, false, query_filters, post_filters)
-      end
-
-      def generate_token(ttl = 3600)
-        taskRouterAttributes = {
-            account_sid: @account_sid,
-            workspace_sid: @workspace_sid,
-            channel: @channel_id
-        }
-
-        if(@channel_id[0..1] == 'WK')
-          taskRouterAttributes['worker_sid'] = @channel_id
-        elsif(@channel_id[0..1] == 'WQ')
-          taskRouterAttributes['taskqueue_sid'] = @channel_id
-        end
-
-        generate_token_protected(ttl, taskRouterAttributes)
-      end
-
-      protected
-
-      def generate_token_protected(ttl = 3600, extraAttributes)
-        payload = {
-            iss: @account_sid,
-            exp: (Time.now.to_i + ttl),
-            version: TASK_ROUTER_VERSION,
-            friendly_name: @channel_id,
-            policies: @policies,
-        }
-        extraAttributes.each { |key, value|
-          payload[key] = value
-        }
-
-        JWT.encode payload, @auth_token
-      end
-
-      def setup_resource
-        if(@channel_id[0..1] == 'WS')
-          @resourceUrl = @baseUrl
-        elsif(@channel_id[0..1] == 'WK')
-          @resourceUrl = @baseUrl + "/Workers/" + @channel_id
-
-          @activityUrl = @baseUrl + "/Activities"
-          allow(@activityUrl, "GET")
-
-          @tasksUrl = @baseUrl + "/Tasks/**"
-          allow(@tasksUrl, "GET")
-
-          @workerReservationsUrl = @resourceUrl + "/Reservations/**"
-          allow(@workerReservationsUrl, "GET")
-
-        elsif(@channel_id[0..1] == 'WQ')
-          @resourceUrl = @baseUrl + "/TaskQueues/" + @channel_id
-        end
-      end
-
-      def allow_websocket_requests(channel_id)
-        worker_url = "#{TASK_ROUTER_WEBSOCKET_BASE_URL}/#{@account_sid}/#{channel_id}"
-        ['GET', 'POST'].each do |meth|
-          add_policy(worker_url, meth)
-        end
-      end
-
-      def validate_jwt
-        if(@account_sid.nil? or @account_sid[0..1] != 'AC')
-          raise "Invalid AccountSid provided #{@account_sid}"
-        end
-        if(@workspace_sid.nil? or @workspace_sid[0..1] != 'WS')
-          raise "Invalid WorkspaceSid provided #{@workspace_sid}"
-        end
-        if(@channel_id.nil?)
-          raise "ChannelId not provided"
-        end
-        @prefix = @channel_id[0..1]
-        if(@prefix != 'WS' and @prefix != 'WK' and @prefix != 'WQ')
-          raise "Invalid ChannelId provided: #{@channel_id}"
-        end
-      end
-    end
-    class WorkerCapability < Capability
-
-      def initialize(account_sid, auth_token, workspace_sid, worker_sid)
-        super(account_sid, auth_token, workspace_sid, worker_sid)
-        @tasksUrl = @baseUrl + "/Tasks/**"
-        @activityUrl = @baseUrl + "/Activities"
-        @workerReservationsUrl = @resourceUrl + "/Reservations/**"
-
-        allow(@activityUrl, "GET")
-        allow(@tasksUrl, "GET")
-        allow(@workerReservationsUrl, "GET")
-      end
-
-      def allow_activity_updates
-        allow(@resourceUrl, "POST", nil, {ActivitySid: REQUIRED})
-      end
-
-      def allow_reservation_updates
-        allow(@tasksUrl, "POST", nil, nil)
-        allow(@workerReservationsUrl, "POST", nil, nil)
-      end
-
-      protected
-
-      def setup_resource
-        @resourceUrl = @baseUrl + "/Workers/" + @channel_id
-      end
-
-    end
-
-    class WorkspaceCapability < Capability
-
-      def initialize(account_sid, auth_token, workspace_sid)
-        super(account_sid, auth_token, workspace_sid, workspace_sid)
-      end
-
-      protected
-
-      def setup_resource
-        @resourceUrl = @baseUrl
-      end
-
-    end
-
-    class TaskQueueCapability < Capability
-
-      def initialize(account_sid, auth_token, workspace_sid, taskqueue_sid)
-        super(account_sid, auth_token, workspace_sid, taskqueue_sid)
-      end
-
-      protected
-
-      def setup_resource
-        @resourceUrl = @baseUrl + "/TaskQueues/" + @channel_id
-      end
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-require 'json'
-
-module Twilio
-  module TaskRouter
-    class WorkflowConfiguration
-
-      def initialize(rules, default_target)
-        @rules = rules
-        @default_target = default_target
-      end
-
-      def rules
-        @rules
-      end
-
-      def default_target
-        @default_target
-      end
-
-      def to_json
-        filters = Array.new
-        @rules.each do |rule|
-          filters.push(rule.to_json)
-        end
-        
-        task_routing = {filters: filters, default_filter: @default_target.to_json}
-        config = {task_routing: task_routing}
-        config.to_json
-      end
-
-      def self.parse_json(json_data)
-        task_routing = JSON.parse(json_data)['task_routing']
-
-        filters = task_routing['filters']
-        rules = Array.new
-        filters.each do |rule|
-          rules.push(Twilio::TaskRouter::WorkflowRule.parse_json(rule))
-        end
-
-        default_filter = Twilio::TaskRouter::WorkflowRuleTarget.parse_json(task_routing['default_filter'])
-        Twilio::TaskRouter::WorkflowConfiguration.new rules, default_filter
-      end
-    end
-    class WorkflowRule
-
-      def initialize(expression, targets, friendly_name=nil)
-        @expression = expression
-        @targets = targets
-        @friendly_name = friendly_name
-      end
-
-      def expression
-        @expression
-      end
-
-      def targets
-        @targets
-      end
-
-      def friendly_name
-        @friendly_name
-      end
-
-      def to_json
-        rule = {expression: @expression}
-        ruleTargets = Array.new
-        @targets.each do |target|
-          ruleTargets.push(target.to_json)
-        end
-        rule['targets'] = ruleTargets
-        unless @friendly_name.nil?
-          rule['friendly_name'] = @friendly_name
-        end
-        rule
-      end
-
-      def self.parse_json(rule)
-        targets = Array.new
-        rule['targets'].each do |target|
-          targets.push(Twilio::TaskRouter::WorkflowRuleTarget.parse_json(target))
-        end
-        unless rule['filter_friendly_name'].nil?
-          friendly_name = rule['filter_friendly_name']
-        end
-        unless rule['friendly_name'].nil?
-          friendly_name = rule['friendly_name']
-        end
-        Twilio::TaskRouter::WorkflowRule.new rule['expression'], targets, friendly_name
-      end
-    end
-    class WorkflowRuleTarget
-
-      def initialize(queue, priority=nil, timeout=nil, expression=nil)
-        @queue = queue
-        @priority = priority
-        @timeout = timeout
-        @expression = expression
-      end
-
-      def queue
-        @queue
-      end
-
-      def priority
-        @priority
-      end
-
-      def timeout
-        @timeout
-      end
-
-      def expression
-        @expression
-      end
-
-      def to_json
-        target = {queue: @queue}
-        unless @priority.nil?
-          target['priority'] = @priority
-        end
-        unless @timeout.nil?
-          target['timeout'] = @timeout
-        end
-        unless @expression.nil?
-          target['expression'] = @expression
-        end
-        target
-      end
-
-      def self.parse_json(target)
-        Twilio::TaskRouter::WorkflowRuleTarget.new target['queue'], target['priority'], target['timeout'], target['expression']
-      end
-    end
-  end
-end

data/lib/twilio-ruby/twiml/response.rb

@@ -1,16 +0,0 @@
-module Twilio
-  module TwiML
-    class Response
-
-      attr_reader :text
-      alias_method :to_xml , :text
-
-      def initialize(&block)
-        xml = Builder::XmlMarkup.new
-        xml.instruct!
-        @text = xml.Response &block
-      end
-
-    end
-  end
-end

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

@@ -1,158 +0,0 @@
-module Twilio
-  module Util
-    class AccessToken
-      attr_accessor :account_sid,
-                    :signing_key_id,
-                    :secret,
-                    :ttl,
-                    :identity,
-                    :nbf
-
-      def initialize(account_sid, signing_key_id, secret, ttl=3600, identity=nil, nbf=nil)
-        @account_sid = account_sid
-        @signing_key_sid = signing_key_id
-        @secret = secret
-        @ttl = ttl
-        @identity = identity
-        @nbf = nbf
-        @grants = []
-      end
-
-      def add_grant(grant)
-        @grants.push(grant)
-      end
-
-      def to_jwt(algorithm='HS256')
-        now = Time.now.to_i - 1
-        headers = {
-            'cty' => 'twilio-fpa;v=1',
-        }
-
-        grants = {}
-        if @identity
-          grants['identity'] = @identity
-        end
-
-        @grants.each { |grant| grants[grant.key] = grant.payload }
-
-        payload = {
-            'jti' => "#{@signing_key_sid}-#{now}",
-            'iss' => @signing_key_sid,
-            'sub' => @account_sid,
-            'exp' => now + @ttl,
-            'grants' => grants
-        }
-
-        payload['nbf'] = @nbf unless @nbf.nil?
-
-        JWT.encode payload, @secret, algorithm, headers
-      end
-
-      def to_s
-        to_jwt
-      end
-
-      class ConversationsGrant
-        attr_accessor :configuration_profile_sid
-
-        def key
-          'rtc'
-        end
-
-        def payload
-          payload = {}
-          if @configuration_profile_sid
-            payload['configuration_profile_sid'] = @configuration_profile_sid
-          end
-
-          payload
-        end
-
-      end
-
-      class IpMessagingGrant
-        attr_accessor :service_sid,
-                      :endpoint_id,
-                      :deployment_role_sid,
-                      :push_credential_sid
-
-        def key
-          'ip_messaging'
-        end
-
-        def payload
-          payload = {}
-          if @service_sid
-            payload['service_sid'] = @service_sid
-          end
-          if @endpoint_id
-            payload['endpoint_id'] = @endpoint_id
-          end
-          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
-        attr_accessor :outgoing_application_sid,
-                      :outgoing_application_params,
-                      :push_credential_sid,
-                      :endpoint_id
-
-        def key
-          'voice'
-        end
-
-        def 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
-
-          if endpoint_id
-            payload[:endpoint_id] = endpoint_id
-          end
-
-          payload
-        end
-      end
-
-      class VideoGrant
-        attr_accessor :configuration_profile_sid
-
-        def key
-          'video'
-        end
-
-        def payload
-          payload = {}
-
-          if configuration_profile_sid
-            payload[:configuration_profile_sid] = configuration_profile_sid
-          end
-
-          payload
-        end
-      end
-
-    end
-  end
-end

data/lib/twilio-ruby/util/capability.rb

@@ -1,64 +0,0 @@
-module Twilio
-  module Util
-    class Capability
-
-      include Twilio::Util
-
-      def initialize(account_sid = nil, auth_token = nil)
-        @account_sid = account_sid || Twilio.account_sid
-        @auth_token = auth_token || Twilio.auth_token
-        if @account_sid.nil? || @auth_token.nil?
-          raise ArgumentError, 'Account SID and auth token are required'
-        end
-        @capabilities = []
-      end
-
-      def allow_client_incoming(client_name)
-        @client_name = client_name # stash for use in outgoing
-        scope_params = { 'clientName' => client_name }
-        @capabilities << scope_uri_for('client', 'incoming', scope_params)
-      end
-
-      def allow_client_outgoing(app_sid, params = {})
-        @allow_client_outgoing = true
-        @outgoing_scope_params = { 'appSid' => app_sid }
-        unless params.empty?
-          @outgoing_scope_params['appParams'] = url_encode params
-        end
-      end
-
-      def allow_event_stream(filters = {})
-        scope_params = { 'path' => '/2010-04-01/Events' }
-        scope_params['params'] = filters unless filters.empty?
-        @capabilities << scope_uri_for('stream', 'subscribe', scope_params)
-      end
-
-      def scope_uri_for(service, privilege, params = {})
-        scope_uri = "scope:#{service}:#{privilege}"
-        scope_uri << "?#{url_encode(params)}" unless params.empty?
-      end
-
-      def generate(ttl = 3600)
-
-        capabilities = @capabilities.clone # we need a local copy to work on
-
-        # build the outgoing scope lazily so that we can use @client_name
-        if @allow_client_outgoing
-          params = @outgoing_scope_params
-          params.merge!('clientName' => @client_name) if @client_name
-          capabilities << scope_uri_for('client', 'outgoing', params)
-        end
-
-        payload = {
-          'scope' => capabilities.join(' '),
-          'iss' => @account_sid,
-          'exp' => (Time.now.to_i + ttl),
-        }
-
-        JWT.encode payload, @auth_token
-
-      end
-
-    end
-  end
-end

data/lib/twilio-ruby/util/client_config.rb

@@ -1,29 +0,0 @@
-module Twilio
-  module Util
-    class ClientConfig
-      DEFAULTS = {
-          host: 'api.twilio.com',
-          port: 443,
-          use_ssl: true,
-          ssl_verify_peer: true,
-          ssl_ca_file: File.dirname(__FILE__) + '/../../../conf/cacert.pem',
-          timeout: 30,
-          proxy_addr: nil,
-          proxy_port: nil,
-          proxy_user: nil,
-          proxy_pass: nil,
-          retry_limit: 1
-      }
-
-      DEFAULTS.each_key do |attribute|
-        attr_accessor attribute
-      end
-
-      def initialize(opts={})
-        DEFAULTS.each do |attribute, value|
-          send("#{attribute}=".to_sym, opts.fetch(attribute, value))
-        end
-      end
-    end
-  end
-end

data/lib/twilio-ruby/util/request_validator.rb

@@ -1,37 +0,0 @@
-module Twilio
-  module Util
-    class RequestValidator
-
-      def initialize(auth_token = nil)
-        @auth_token = auth_token || Twilio.auth_token
-        raise ArgumentError, 'Auth token is required' if @auth_token.nil?
-      end
-
-      def validate(url, params, signature)
-        expected = build_signature_for url, params
-        secure_compare(expected, signature)
-      end
-
-      def build_signature_for(url, params)
-        data = url + params.sort.join
-        digest = OpenSSL::Digest.new('sha1')
-        Base64.encode64(OpenSSL::HMAC.digest(digest, @auth_token, data)).strip
-      end
-
-      private
-
-      # Compares two strings in constant time to avoid timing attacks.
-      # Borrowed from ActiveSupport::MessageVerifier.
-      # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/message_verifier.rb
-      def secure_compare(a, b)
-        return false unless a.bytesize == b.bytesize
-
-        l = a.unpack("C#{a.bytesize}")
-
-        res = 0
-        b.each_byte { |byte| res |= byte ^ l.shift }
-        res == 0
-      end
-    end
-  end
-end