twilio-ruby 4.13.0 → 5.0.0.alpha1

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

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,174 @@
+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.rb

@@ -1,16 +1,42 @@
+##
+# This code was generated by
+# \ / _    _  _|   _  _
+#  | (_)\/(_)(_|\/| |(/_  v1.0.0
+#       /       /
+
 module Twilio
   module REST
-    class Accounts < ListResource; end
+    class Accounts < Domain
+      ##
+      # Initialize the Accounts Domain
+      def initialize(twilio)
+        super
+
+        @base_url = 'https://accounts.twilio.com'
+        @host = 'accounts.twilio.com'
+        @port = 443
+
+        # Versions
+        @v1 = nil
+      end
+
+      ##
+      # Version v1 of accounts
+      def v1
+        @v1 ||= V1.new self
+      end
+
+      ##
+      # @return [Twilio::REST::Accounts::V1::CredentialInstance]
+      def credentials
+        self.v1.credentials()
+      end
 
-    class Account < InstanceResource
-      def initialize(path, client, params={})
-        super path, client, params
-        resource :sandbox, :available_phone_numbers, :incoming_phone_numbers,
-          :calls, :outgoing_caller_ids, :conferences, :sms, :recordings,
-          :transcriptions, :notifications, :applications, :connect_apps,
-          :authorized_connect_apps, :queues, :usage, :messages, :media, :sip,
-          :tokens, :addresses, :keys
+      ##
+      # Provide a user friendly representation
+      def to_s
+        '#<Twilio::REST::Accounts>'
       end
     end
   end
-end
+end

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

@@ -0,0 +1,39 @@
+##
+# 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

@@ -0,0 +1,105 @@
+##
+# 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