twilio-ruby 5.0.0.alpha1 → 5.0.0.rc2

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

@@ -1,102 +0,0 @@
-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
-
-      alias to_s to_jwt
-
-      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('&')
-          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

@@ -1,50 +0,0 @@
-module Twilio
-  module JWT
-    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
-    end
-  end
-end

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

@@ -1,174 +0,0 @@
-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
-
-      def to_s
-        to_jwt
-      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(worskspace_sid)
-          [TASK_ROUTER_BASE_URL, TASK_ROUTER_VERSION, 'Workspaces', worskspace_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

data/lib/twilio-ruby/rest/accounts/v1.rb

@@ -1,39 +0,0 @@
-##
-# This code was generated by
-# \ / _    _  _|   _  _
-#  | (_)\/(_)(_|\/| |(/_  v1.0.0
-#       /       /
-
-module Twilio
-  module REST
-    class Accounts
-      class V1 < Version
-        ##
-        # Initialize the V1 version of Accounts
-        def initialize(domain)
-          super
-          @version = 'v1'
-          @credentials = nil
-        end
-
-        ##
-        # @return [Twilio::REST::Accounts::V1::CredentialInstance]
-        def credentials(sid=:unset)
-          if sid.nil?
-            raise ArgumentError, 'sid cannot be nil'
-          elsif sid == :unset
-            @credentials ||= CredentialList.new self
-          else
-            CredentialContext.new(self, sid)
-          end
-        end
-
-        ##
-        # Provide a user friendly representation
-        def to_s
-          '<Twilio::REST::Accounts::V1>'
-        end
-      end
-    end
-  end
-end

data/lib/twilio-ruby/rest/accounts/v1/credential.rb

@@ -1,105 +0,0 @@
-##
-# This code was generated by
-# \ / _    _  _|   _  _
-#  | (_)\/(_)(_|\/| |(/_  v1.0.0
-#       /       /
-
-module Twilio
-  module REST
-    class Accounts < Domain
-      class V1 < Version
-        class CredentialList < ListResource
-          ##
-          # Initialize the CredentialList
-          # @param [Version] version Version that contains the resource
-          # @return [CredentialList] CredentialList
-          def initialize(version)
-            super(version)
-
-            # Path Solution
-            @solution = {}
-
-            # Components
-            @public_key = nil
-          end
-
-          ##
-          # Access the public_key
-          # @param [String] sid The Credential Sid that uniquely identifies the Credential
-          #   to fetch
-          # @return [PublicKeyList]
-          # @return [PublicKeyContext] if sid was passed.
-          def public_key(sid=:unset)
-            raise ArgumentError, 'sid cannot be nil' if sid.nil?
-
-            if sid != :unset
-              return PublicKeyContext.new(
-                  @version,
-                  sid,
-              )
-            end
-
-              @public_key ||= PublicKeyList.new(
-                  @version,
-              )
-          end
-
-          ##
-          # Provide a user friendly representation
-          def to_s
-            '#<Twilio.Accounts.V1.CredentialList>'
-          end
-        end
-
-        class CredentialPage < Page
-          ##
-          # Initialize the CredentialPage
-          # @param [Version] version Version that contains the resource
-          # @param [Response] response Response from the API
-          # @param [Hash] solution Path solution for the resource
-          # @return [CredentialPage] CredentialPage
-          def initialize(version, response, solution)
-            super(version, response)
-
-            # Path Solution
-            @solution = solution
-          end
-
-          ##
-          # Build an instance of CredentialInstance
-          # @param [Hash] payload Payload response from the API
-          # @return [CredentialInstance] CredentialInstance
-          def get_instance(payload)
-            CredentialInstance.new(
-                @version,
-                payload,
-            )
-          end
-
-          ##
-          # Provide a user friendly representation
-          def to_s
-            '<Twilio.Accounts.V1.CredentialPage>'
-          end
-        end
-
-        class CredentialInstance < InstanceResource
-          ##
-          # Initialize the CredentialInstance
-          # @param [Version] version Version that contains the resource
-          # @param [Hash] payload payload that contains response from Twilio
-          # @return [CredentialInstance] CredentialInstance
-          def initialize(version, payload)
-            super(version)
-          end
-
-          ##
-          # Provide a user friendly representation
-          def to_s
-            "<Twilio.Accounts.V1.CredentialInstance>"
-          end
-        end
-      end
-    end
-  end
-end