twilio-ruby 7.3.3 → 7.10.1

data/lib/twilio-ruby/rest/taskrouter/v1/workspace/task_queue/task_queues_statistics.rb

@@ -28,6 +28,7 @@ module Twilio
                     # @return [TaskQueuesStatisticsList] TaskQueuesStatisticsList
                     def initialize(version, workspace_sid: nil)
                         super(version)
+                        
                         # Path Solution
                         @solution = { workspace_sid: workspace_sid }
                         @uri = "/Workspaces/#{@solution[:workspace_sid]}/TaskQueues/Statistics"
@@ -96,6 +97,40 @@ module Twilio
                         @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
                     end
 
+                    ##
+                    # Lists TaskQueuesStatisticsPageMetadata records from the API as a list.
+                      # @param [Time] end_date Only calculate statistics from this date and time and earlier, specified in GMT as an [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time.
+                      # @param [String] friendly_name The `friendly_name` of the TaskQueue statistics to read.
+                      # @param [String] minutes Only calculate statistics since this many minutes in the past. The default is 15 minutes.
+                      # @param [Time] start_date Only calculate statistics from this date and time and later, specified in [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) format.
+                      # @param [String] task_channel Only calculate statistics on this TaskChannel. Can be the TaskChannel's SID or its `unique_name`, such as `voice`, `sms`, or `default`.
+                      # @param [String] split_by_wait_time A comma separated list of values that describes the thresholds, in seconds, to calculate statistics on. For each threshold specified, the number of Tasks canceled and reservations accepted above and below the specified thresholds in seconds are computed.
+                    # @param [Integer] limit Upper limit for the number of records to return. stream()
+                    #    guarantees to never return more than limit.  Default is no limit
+                    # @param [Integer] page_size Number of records to fetch per request, when
+                    #    not set will use the default value of 50 records.  If no page_size is defined
+                    #    but a limit is defined, stream() will attempt to read the limit with the most
+                    #    efficient page size, i.e. min(limit, 1000)
+                    # @return [Array] Array of up to limit results
+                    def list_with_metadata(end_date: :unset, friendly_name: :unset, minutes: :unset, start_date: :unset, task_channel: :unset, split_by_wait_time: :unset, limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+                        params = Twilio::Values.of({
+                            'EndDate' =>  Twilio.serialize_iso8601_datetime(end_date),
+                            'FriendlyName' => friendly_name,
+                            'Minutes' => minutes,
+                            'StartDate' =>  Twilio.serialize_iso8601_datetime(start_date),
+                            'TaskChannel' => task_channel,
+                            'SplitByWaitTime' => split_by_wait_time,
+                            
+                            'PageSize' => limits[:page_size],
+                        });
+                        headers = Twilio::Values.of({})
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        TaskQueuesStatisticsPageMetadata.new(@version, response, @solution, limits[:limit])
+                    end
+
                     ##
                     # When passed a block, yields TaskQueuesStatisticsInstance records from the API.
                     # This operation lazily loads records as efficiently as possible until the limit
@@ -123,7 +158,7 @@ module Twilio
                     # @param [Integer] page_number Page Number, this value is simply for client state
                     # @param [Integer] page_size Number of records to return, defaults to 50
                     # @return [Page] Page of TaskQueuesStatisticsInstance
-                    def page(end_date: :unset, friendly_name: :unset, minutes: :unset, start_date: :unset, task_channel: :unset, split_by_wait_time: :unset, page_token: :unset, page_number: :unset, page_size: :unset)
+                    def page(end_date: :unset, friendly_name: :unset, minutes: :unset, start_date: :unset, task_channel: :unset, split_by_wait_time: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
                             'EndDate' =>  Twilio.serialize_iso8601_datetime(end_date),
                             'FriendlyName' => friendly_name,
@@ -135,8 +170,11 @@ module Twilio
                             'Page' => page_number,
                             'PageSize' => page_size,
                         })
+                        headers = Twilio::Values.of({})
+                        
+                        
 
-                        response = @version.page('GET', @uri, params: params)
+                        response = @version.page('GET', @uri, params: params, headers: headers)
 
                         TaskQueuesStatisticsPage.new(@version, response, @solution)
                     end
@@ -171,6 +209,7 @@ module Twilio
                     # @return [TaskQueuesStatisticsPage] TaskQueuesStatisticsPage
                     def initialize(version, response, solution)
                         super(version, response)
+                        
 
                         # Path Solution
                         @solution = solution
@@ -190,6 +229,66 @@ module Twilio
                         '<Twilio.Taskrouter.V1.TaskQueuesStatisticsPage>'
                     end
                 end
+
+                class TaskQueuesStatisticsPageMetadata < PageMetadata
+                    attr_reader :task_queues_statistics_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @task_queues_statistics_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @task_queues_statistics_page << TaskQueuesStatisticsListResponse.new(version, @payload, key, limit - records)
+                            @payload = self.next_page
+                            break unless @payload
+                            records += @payload.body[key].size
+                        end
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    def each
+                        @task_queues_statistics_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Taskrouter::V1PageMetadata>';
+                    end
+                end
+                class TaskQueuesStatisticsListResponse < InstanceListResource
+
+                    # @param [Array<TaskQueuesStatisticsInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key, limit = :unset)
+                      data_list = payload.body[key]
+                      if limit != :unset
+                        data_list = data_list[0, limit]
+                      end
+                      @task_queues_statistics = data_list.map do |data|
+                        TaskQueuesStatisticsInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def task_queues_statistics
+                        @task_queues_statistics
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
                 class TaskQueuesStatisticsInstance < InstanceResource
                     ##
                     # Initialize the TaskQueuesStatisticsInstance
@@ -203,6 +302,7 @@ module Twilio
                     def initialize(version, payload , workspace_sid: nil)
                         super(version)
                         
+                        
                         # Marshaled Properties
                         @properties = { 
                             'account_sid' => payload['account_sid'],

data/lib/twilio-ruby/rest/taskrouter/v1/workspace/task_queue.rb

@@ -27,6 +27,7 @@ module Twilio
                     # @return [TaskQueueList] TaskQueueList
                     def initialize(version, workspace_sid: nil)
                         super(version)
+                        
                         # Path Solution
                         @solution = { workspace_sid: workspace_sid }
                         @uri = "/Workspaces/#{@solution[:workspace_sid]}/TaskQueues"
@@ -63,6 +64,10 @@ module Twilio
 
                         headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
                         
+                        
+                        
+                        
+                        
                         payload = @version.create('POST', @uri, data: data, headers: headers)
                         TaskQueueInstance.new(
                             @version,
@@ -71,6 +76,53 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Create the TaskQueueInstanceMetadata
+                    # @param [String] friendly_name A descriptive string that you create to describe the TaskQueue. For example `Support-Tier 1`, `Sales`, or `Escalation`.
+                    # @param [String] target_workers A string that describes the Worker selection criteria for any Tasks that enter the TaskQueue. For example, `'\\\"language\\\" == \\\"spanish\\\"'`. The default value is `1==1`. If this value is empty, Tasks will wait in the TaskQueue until they are deleted or moved to another TaskQueue. For more information about Worker selection, see [Describing Worker selection criteria](https://www.twilio.com/docs/taskrouter/api/taskqueues#target-workers).
+                    # @param [String] max_reserved_workers The maximum number of Workers to reserve for the assignment of a Task in the queue. Can be an integer between 1 and 50, inclusive and defaults to 1.
+                    # @param [TaskOrder] task_order 
+                    # @param [String] reservation_activity_sid The SID of the Activity to assign Workers when a task is reserved for them.
+                    # @param [String] assignment_activity_sid The SID of the Activity to assign Workers when a task is assigned to them.
+                    # @return [TaskQueueInstance] Created TaskQueueInstance
+                    def create_with_metadata(
+                      friendly_name: nil, 
+                      target_workers: :unset, 
+                      max_reserved_workers: :unset, 
+                      task_order: :unset, 
+                      reservation_activity_sid: :unset, 
+                      assignment_activity_sid: :unset
+                    )
+
+                        data = Twilio::Values.of({
+                            'FriendlyName' => friendly_name,
+                            'TargetWorkers' => target_workers,
+                            'MaxReservedWorkers' => max_reserved_workers,
+                            'TaskOrder' => task_order,
+                            'ReservationActivitySid' => reservation_activity_sid,
+                            'AssignmentActivitySid' => assignment_activity_sid,
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.create_with_metadata('POST', @uri, data: data, headers: headers)
+                        task_queue_instance = TaskQueueInstance.new(
+                            @version,
+                            response.body,
+                            workspace_sid: @solution[:workspace_sid],
+                        )
+                        TaskQueueInstanceMetadata.new(
+                            @version,
+                            task_queue_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                 
                     ##
                     # Lists TaskQueueInstance records from the API as a list.
@@ -126,6 +178,36 @@ module Twilio
                         @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
                     end
 
+                    ##
+                    # Lists TaskQueuePageMetadata records from the API as a list.
+                      # @param [String] friendly_name The `friendly_name` of the TaskQueue resources to read.
+                      # @param [String] evaluate_worker_attributes The attributes of the Workers to read. Returns the TaskQueues with Workers that match the attributes specified in this parameter.
+                      # @param [String] worker_sid The SID of the Worker with the TaskQueue resources to read.
+                      # @param [String] ordering Sorting parameter for TaskQueues
+                    # @param [Integer] limit Upper limit for the number of records to return. stream()
+                    #    guarantees to never return more than limit.  Default is no limit
+                    # @param [Integer] page_size Number of records to fetch per request, when
+                    #    not set will use the default value of 50 records.  If no page_size is defined
+                    #    but a limit is defined, stream() will attempt to read the limit with the most
+                    #    efficient page size, i.e. min(limit, 1000)
+                    # @return [Array] Array of up to limit results
+                    def list_with_metadata(friendly_name: :unset, evaluate_worker_attributes: :unset, worker_sid: :unset, ordering: :unset, limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+                        params = Twilio::Values.of({
+                            'FriendlyName' => friendly_name,
+                            'EvaluateWorkerAttributes' => evaluate_worker_attributes,
+                            'WorkerSid' => worker_sid,
+                            'Ordering' => ordering,
+                            
+                            'PageSize' => limits[:page_size],
+                        });
+                        headers = Twilio::Values.of({})
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        TaskQueuePageMetadata.new(@version, response, @solution, limits[:limit])
+                    end
+
                     ##
                     # When passed a block, yields TaskQueueInstance records from the API.
                     # This operation lazily loads records as efficiently as possible until the limit
@@ -151,7 +233,7 @@ module Twilio
                     # @param [Integer] page_number Page Number, this value is simply for client state
                     # @param [Integer] page_size Number of records to return, defaults to 50
                     # @return [Page] Page of TaskQueueInstance
-                    def page(friendly_name: :unset, evaluate_worker_attributes: :unset, worker_sid: :unset, ordering: :unset, page_token: :unset, page_number: :unset, page_size: :unset)
+                    def page(friendly_name: :unset, evaluate_worker_attributes: :unset, worker_sid: :unset, ordering: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
                             'FriendlyName' => friendly_name,
                             'EvaluateWorkerAttributes' => evaluate_worker_attributes,
@@ -161,8 +243,11 @@ module Twilio
                             'Page' => page_number,
                             'PageSize' => page_size,
                         })
+                        headers = Twilio::Values.of({})
+                        
+                        
 
-                        response = @version.page('GET', @uri, params: params)
+                        response = @version.page('GET', @uri, params: params, headers: headers)
 
                         TaskQueuePage.new(@version, response, @solution)
                     end
@@ -212,6 +297,7 @@ module Twilio
                     # @return [TaskQueueContext] TaskQueueContext
                     def initialize(version, workspace_sid, sid)
                         super(version)
+                        
 
                         # Path Solution
                         @solution = { workspace_sid: workspace_sid, sid: sid,  }
@@ -229,9 +315,31 @@ module Twilio
 
                         headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
                         
+                        
+                        
+
                         @version.delete('DELETE', @uri, headers: headers)
                     end
 
+                    ##
+                    # Delete the TaskQueueInstanceMetadata
+                    # @return [Boolean] True if delete succeeds, false otherwise
+                    def delete_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                          response = @version.delete_with_metadata('DELETE', @uri, headers: headers)
+                          taskQueue_instance = TaskQueueInstance.new(
+                              @version,
+                              response.body,
+                              account_sid: @solution[:account_sid],
+                              sid: @solution[:sid],
+                          )
+                          TaskQueueInstanceMetadata.new(@version, taskQueue_instance, response.headers, response.status_code)
+                    end
+
                     ##
                     # Fetch the TaskQueueInstance
                     # @return [TaskQueueInstance] Fetched TaskQueueInstance
@@ -239,6 +347,10 @@ module Twilio
 
                         headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
                         
+                        
+                        
+                        
+                        
                         payload = @version.fetch('GET', @uri, headers: headers)
                         TaskQueueInstance.new(
                             @version,
@@ -248,6 +360,32 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Fetch the TaskQueueInstanceMetadata
+                    # @return [TaskQueueInstance] Fetched TaskQueueInstance
+                    def fetch_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.fetch_with_metadata('GET', @uri, headers: headers)
+                        task_queue_instance = TaskQueueInstance.new(
+                            @version,
+                            response.body,
+                            workspace_sid: @solution[:workspace_sid],
+                            sid: @solution[:sid],
+                        )
+                        TaskQueueInstanceMetadata.new(
+                            @version,
+                            task_queue_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                     ##
                     # Update the TaskQueueInstance
                     # @param [String] friendly_name A descriptive string that you create to describe the TaskQueue. For example `Support-Tier 1`, `Sales`, or `Escalation`.
@@ -277,6 +415,10 @@ module Twilio
 
                         headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
                         
+                        
+                        
+                        
+                        
                         payload = @version.update('POST', @uri, data: data, headers: headers)
                         TaskQueueInstance.new(
                             @version,
@@ -286,6 +428,54 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Update the TaskQueueInstanceMetadata
+                    # @param [String] friendly_name A descriptive string that you create to describe the TaskQueue. For example `Support-Tier 1`, `Sales`, or `Escalation`.
+                    # @param [String] target_workers A string describing the Worker selection criteria for any Tasks that enter the TaskQueue. For example '\\\"language\\\" == \\\"spanish\\\"' If no TargetWorkers parameter is provided, Tasks will wait in the queue until they are either deleted or moved to another queue. Additional examples on how to describing Worker selection criteria below.
+                    # @param [String] reservation_activity_sid The SID of the Activity to assign Workers when a task is reserved for them.
+                    # @param [String] assignment_activity_sid The SID of the Activity to assign Workers when a task is assigned for them.
+                    # @param [String] max_reserved_workers The maximum number of Workers to create reservations for the assignment of a task while in the queue. Maximum of 50.
+                    # @param [TaskOrder] task_order 
+                    # @return [TaskQueueInstance] Updated TaskQueueInstance
+                    def update_with_metadata(
+                      friendly_name: :unset, 
+                      target_workers: :unset, 
+                      reservation_activity_sid: :unset, 
+                      assignment_activity_sid: :unset, 
+                      max_reserved_workers: :unset, 
+                      task_order: :unset
+                    )
+
+                        data = Twilio::Values.of({
+                            'FriendlyName' => friendly_name,
+                            'TargetWorkers' => target_workers,
+                            'ReservationActivitySid' => reservation_activity_sid,
+                            'AssignmentActivitySid' => assignment_activity_sid,
+                            'MaxReservedWorkers' => max_reserved_workers,
+                            'TaskOrder' => task_order,
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.update_with_metadata('POST', @uri, data: data, headers: headers)
+                        task_queue_instance = TaskQueueInstance.new(
+                            @version,
+                            response.body,
+                            workspace_sid: @solution[:workspace_sid],
+                            sid: @solution[:sid],
+                        )
+                        TaskQueueInstanceMetadata.new(
+                            @version,
+                            task_queue_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                     ##
                     # Access the cumulative_statistics
                     # @return [TaskQueueCumulativeStatisticsList]
@@ -335,6 +525,53 @@ module Twilio
                     end
                 end
 
+                class TaskQueueInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new TaskQueueInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}TaskQueueInstance] task_queue_instance The instance associated with the metadata.
+                    # @param [Hash] headers Header object with response headers.
+                    # @param [Integer] status_code The HTTP status code of the response.
+                    # @return [TaskQueueInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, task_queue_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @task_queue_instance = task_queue_instance
+                    end
+
+                    def task_queue
+                        @task_queue_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.TaskQueueInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class TaskQueueListResponse < InstanceListResource
+                    # @param [Array<TaskQueueInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @task_queue_instance = payload.body[key].map do |data|
+                        TaskQueueInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def task_queue_instance
+                          @instance
+                      end
+                  end
+
                 class TaskQueuePage < Page
                     ##
                     # Initialize the TaskQueuePage
@@ -344,6 +581,7 @@ module Twilio
                     # @return [TaskQueuePage] TaskQueuePage
                     def initialize(version, response, solution)
                         super(version, response)
+                        
 
                         # Path Solution
                         @solution = solution
@@ -363,6 +601,66 @@ module Twilio
                         '<Twilio.Taskrouter.V1.TaskQueuePage>'
                     end
                 end
+
+                class TaskQueuePageMetadata < PageMetadata
+                    attr_reader :task_queue_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @task_queue_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @task_queue_page << TaskQueueListResponse.new(version, @payload, key, limit - records)
+                            @payload = self.next_page
+                            break unless @payload
+                            records += @payload.body[key].size
+                        end
+                        # Path Solution
+                        @solution = solution
+                    end
+
+                    def each
+                        @task_queue_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Taskrouter::V1PageMetadata>';
+                    end
+                end
+                class TaskQueueListResponse < InstanceListResource
+
+                    # @param [Array<TaskQueueInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key, limit = :unset)
+                      data_list = payload.body[key]
+                      if limit != :unset
+                        data_list = data_list[0, limit]
+                      end
+                      @task_queue = data_list.map do |data|
+                        TaskQueueInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def task_queue
+                        @task_queue
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
                 class TaskQueueInstance < InstanceResource
                     ##
                     # Initialize the TaskQueueInstance
@@ -376,6 +674,7 @@ module Twilio
                     def initialize(version, payload , workspace_sid: nil, sid: nil)
                         super(version)
                         
+                        
                         # Marshaled Properties
                         @properties = { 
                             'account_sid' => payload['account_sid'],