twilio-ruby 6.8.0 → 7.10.7

data/lib/twilio-ruby/rest/studio/v2/flow/execution.rb

@@ -20,12 +20,14 @@ module Twilio
                 class FlowContext < InstanceContext
 
                      class ExecutionList < ListResource
+                
                     ##
                     # Initialize the ExecutionList
                     # @param [Version] version Version that contains the resource
                     # @return [ExecutionList] ExecutionList
                     def initialize(version, flow_sid: nil)
                         super(version)
+                        
                         # Path Solution
                         @solution = { flow_sid: flow_sid }
                         @uri = "/Flows/#{@solution[:flow_sid]}/Executions"
@@ -38,9 +40,9 @@ module Twilio
                     # @param [Object] parameters JSON data that will be added to the Flow's context and that can be accessed as variables inside your Flow. For example, if you pass in `Parameters={\\\"name\\\":\\\"Zeke\\\"}`, a widget in your Flow can reference the variable `{{flow.data.name}}`, which returns \\\"Zeke\\\". Note: the JSON value must explicitly be passed as a string, not as a hash object. Depending on your particular HTTP library, you may need to add quotes or URL encode the JSON string.
                     # @return [ExecutionInstance] Created ExecutionInstance
                     def create(
-                        to: nil, 
-                        from: nil, 
-                        parameters: :unset
+                      to: nil, 
+                      from: nil, 
+                      parameters: :unset
                     )
 
                         data = Twilio::Values.of({
@@ -49,7 +51,13 @@ module Twilio
                             'Parameters' => Twilio.serialize_object(parameters),
                         })
 
-                        payload = @version.create('POST', @uri, data: data)
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        payload = @version.create('POST', @uri, data: data, headers: headers)
                         ExecutionInstance.new(
                             @version,
                             payload,
@@ -57,11 +65,50 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Create the ExecutionInstanceMetadata
+                    # @param [String] to The Contact phone number to start a Studio Flow Execution, available as variable `{{contact.channel.address}}`.
+                    # @param [String] from The Twilio phone number to send messages or initiate calls from during the Flow's Execution. Available as variable `{{flow.channel.address}}`. For SMS, this can also be a Messaging Service SID.
+                    # @param [Object] parameters JSON data that will be added to the Flow's context and that can be accessed as variables inside your Flow. For example, if you pass in `Parameters={\\\"name\\\":\\\"Zeke\\\"}`, a widget in your Flow can reference the variable `{{flow.data.name}}`, which returns \\\"Zeke\\\". Note: the JSON value must explicitly be passed as a string, not as a hash object. Depending on your particular HTTP library, you may need to add quotes or URL encode the JSON string.
+                    # @return [ExecutionInstance] Created ExecutionInstance
+                    def create_with_metadata(
+                      to: nil, 
+                      from: nil, 
+                      parameters: :unset
+                    )
+
+                        data = Twilio::Values.of({
+                            'To' => to,
+                            'From' => from,
+                            'Parameters' => Twilio.serialize_object(parameters),
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.create_with_metadata('POST', @uri, data: data, headers: headers)
+                        execution_instance = ExecutionInstance.new(
+                            @version,
+                            response.body,
+                            flow_sid: @solution[:flow_sid],
+                        )
+                        ExecutionInstanceMetadata.new(
+                            @version,
+                            execution_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                 
                     ##
                     # Lists ExecutionInstance records from the API as a list.
                     # Unlike stream(), this operation is eager and will load `limit` records into
                     # memory before returning.
+                    # @param [Status] status Only show Execution resources with the given status. Can be: `active` or `ended`.
                     # @param [Time] date_created_from Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
                     # @param [Time] date_created_to Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
@@ -71,8 +118,9 @@ module Twilio
                     #    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(date_created_from: :unset, date_created_to: :unset, limit: nil, page_size: nil)
+                    def list(status: :unset, date_created_from: :unset, date_created_to: :unset, limit: nil, page_size: nil)
                         self.stream(
+                            status: status,
                             date_created_from: date_created_from,
                             date_created_to: date_created_to,
                             limit: limit,
@@ -84,6 +132,7 @@ module Twilio
                     # Streams Instance records from the API as an Enumerable.
                     # This operation lazily loads records as efficiently as possible until the limit
                     # is reached.
+                    # @param [Status] status Only show Execution resources with the given status. Can be: `active` or `ended`.
                     # @param [Time] date_created_from Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
                     # @param [Time] date_created_to Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
                     # @param [Integer] limit Upper limit for the number of records to return. stream()
@@ -93,15 +142,48 @@ module Twilio
                     #    but a limit is defined, stream() will attempt to read the limit with the most
                     #    efficient page size, i.e. min(limit, 1000)
                     # @return [Enumerable] Enumerable that will yield up to limit results
-                    def stream(date_created_from: :unset, date_created_to: :unset, limit: nil, page_size: nil)
+                    def stream(status: :unset, date_created_from: :unset, date_created_to: :unset, limit: nil, page_size: nil)
                         limits = @version.read_limits(limit, page_size)
 
                         page = self.page(
+                            status: status,
                             date_created_from: date_created_from,
                             date_created_to: date_created_to,
                             page_size: limits[:page_size], )
 
-                        @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
+                        return [].each if page.nil?
+
+                        result = @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
+                        return [].each if result.nil?
+                        result
+                    end
+
+                    ##
+                    # Lists ExecutionPageMetadata records from the API as a list.
+                      # @param [Status] status Only show Execution resources with the given status. Can be: `active` or `ended`.
+                      # @param [Time] date_created_from Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+                      # @param [Time] date_created_to Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
+                    # @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(status: :unset, date_created_from: :unset, date_created_to: :unset, limit: nil, page_size: nil)
+                        limits = @version.read_limits(limit, page_size)
+                        params = Twilio::Values.of({
+                            'status' => status,
+                            'DateCreatedFrom' =>  Twilio.serialize_iso8601_datetime(date_created_from),
+                            'DateCreatedTo' =>  Twilio.serialize_iso8601_datetime(date_created_to),
+                            
+                            'PageSize' => limits[:page_size],
+                        });
+                        headers = Twilio::Values.of({})
+
+                        response = @version.page('GET', @uri, params: params, headers: headers)
+
+                        ExecutionPageMetadata.new(@version, response, @solution, limits[:limit])
                     end
 
                     ##
@@ -113,30 +195,39 @@ module Twilio
 
                         page = self.page(page_size: limits[:page_size], )
 
-                        @version.stream(page,
+                        return [].each if page.nil?
+
+                        result = @version.stream(page,
                             limit: limits[:limit],
-                            page_limit: limits[:page_limit]).each {|x| yield x}
+                            page_limit: limits[:page_limit])
+                        return [].each if result.nil?
+                        result.each {|x| yield x}
                     end
 
                     ##
                     # Retrieve a single page of ExecutionInstance records from the API.
                     # Request is executed immediately.
+                    # @param [Status] status Only show Execution resources with the given status. Can be: `active` or `ended`.
                     # @param [Time] date_created_from Only show Execution resources starting on or after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
                     # @param [Time] date_created_to Only show Execution resources starting before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time, given as `YYYY-MM-DDThh:mm:ss-hh:mm`.
                     # @param [String] page_token PageToken provided by the API
                     # @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 ExecutionInstance
-                    def page(date_created_from: :unset, date_created_to: :unset, page_token: :unset, page_number: :unset, page_size: :unset)
+                    def page(status: :unset, date_created_from: :unset, date_created_to: :unset, page_token: :unset, page_number: :unset,page_size: :unset)
                         params = Twilio::Values.of({
+                            'status' => status,
                             'DateCreatedFrom' =>  Twilio.serialize_iso8601_datetime(date_created_from),
                             'DateCreatedTo' =>  Twilio.serialize_iso8601_datetime(date_created_to),
                             'PageToken' => page_token,
                             '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)
 
                         ExecutionPage.new(@version, response, @solution)
                     end
@@ -172,6 +263,7 @@ module Twilio
                     # @return [ExecutionContext] ExecutionContext
                     def initialize(version, flow_sid, sid)
                         super(version)
+                        
 
                         # Path Solution
                         @solution = { flow_sid: flow_sid, sid: sid,  }
@@ -186,7 +278,31 @@ module Twilio
                     # @return [Boolean] True if delete succeeds, false otherwise
                     def delete
 
-                        @version.delete('DELETE', @uri)
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+
+                        @version.delete('DELETE', @uri, headers: headers)
+                    end
+
+                    ##
+                    # Delete the ExecutionInstanceMetadata
+                    # @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)
+                          execution_instance = ExecutionInstance.new(
+                              @version,
+                              response.body,
+                              account_sid: @solution[:account_sid],
+                              sid: @solution[:sid],
+                          )
+                          ExecutionInstanceMetadata.new(@version, execution_instance, response.headers, response.status_code)
                     end
 
                     ##
@@ -194,7 +310,13 @@ module Twilio
                     # @return [ExecutionInstance] Fetched ExecutionInstance
                     def fetch
 
-                        payload = @version.fetch('GET', @uri)
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        payload = @version.fetch('GET', @uri, headers: headers)
                         ExecutionInstance.new(
                             @version,
                             payload,
@@ -203,19 +325,51 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Fetch the ExecutionInstanceMetadata
+                    # @return [ExecutionInstance] Fetched ExecutionInstance
+                    def fetch_with_metadata
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.fetch_with_metadata('GET', @uri, headers: headers)
+                        execution_instance = ExecutionInstance.new(
+                            @version,
+                            response.body,
+                            flow_sid: @solution[:flow_sid],
+                            sid: @solution[:sid],
+                        )
+                        ExecutionInstanceMetadata.new(
+                            @version,
+                            execution_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                     ##
                     # Update the ExecutionInstance
                     # @param [Status] status 
                     # @return [ExecutionInstance] Updated ExecutionInstance
                     def update(
-                        status: nil
+                      status: nil
                     )
 
                         data = Twilio::Values.of({
                             'Status' => status,
                         })
 
-                        payload = @version.update('POST', @uri, data: data)
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        payload = @version.update('POST', @uri, data: data, headers: headers)
                         ExecutionInstance.new(
                             @version,
                             payload,
@@ -224,6 +378,39 @@ module Twilio
                         )
                     end
 
+                    ##
+                    # Update the ExecutionInstanceMetadata
+                    # @param [Status] status 
+                    # @return [ExecutionInstance] Updated ExecutionInstance
+                    def update_with_metadata(
+                      status: nil
+                    )
+
+                        data = Twilio::Values.of({
+                            'Status' => status,
+                        })
+
+                        headers = Twilio::Values.of({'Content-Type' => 'application/x-www-form-urlencoded', })
+                        
+                        
+                        
+                        
+                        
+                        response = @version.update_with_metadata('POST', @uri, data: data, headers: headers)
+                        execution_instance = ExecutionInstance.new(
+                            @version,
+                            response.body,
+                            flow_sid: @solution[:flow_sid],
+                            sid: @solution[:sid],
+                        )
+                        ExecutionInstanceMetadata.new(
+                            @version,
+                            execution_instance,
+                            response.headers,
+                            response.status_code
+                        )
+                    end
+
                     ##
                     # Access the execution_context
                     # @return [ExecutionContextList]
@@ -270,6 +457,53 @@ module Twilio
                     end
                 end
 
+                class ExecutionInstanceMetadata <  InstanceResourceMetadata
+                    ##
+                    # Initializes a new ExecutionInstanceMetadata.
+                    # @param [Version] version Version that contains the resource
+                    # @param [}ExecutionInstance] execution_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 [ExecutionInstanceMetadata] The initialized instance with metadata.
+                    def initialize(version, execution_instance, headers, status_code)
+                        super(version, headers, status_code)
+                        @execution_instance = execution_instance
+                    end
+
+                    def execution
+                        @execution_instance
+                    end
+
+                    def headers
+                        @headers
+                    end
+
+                    def status_code
+                        @status_code
+                    end
+
+                    def to_s
+                      "<Twilio.Api.V2010.ExecutionInstanceMetadata status=#{@status_code}>"
+                    end
+                end
+
+                class ExecutionListResponse < InstanceListResource
+                    # @param [Array<ExecutionInstance>] instance
+                    # @param [Hash{String => Object}] headers
+                    # @param [Integer] status_code
+                    def initialize(version, payload, key)
+                       @execution_instance = payload.body[key].map do |data|
+                        ExecutionInstance.new(version, data)
+                       end
+                       @headers = payload.headers
+                       @status_code = payload.status_code
+                    end
+
+                      def execution_instance
+                          @instance
+                      end
+                  end
+
                 class ExecutionPage < Page
                     ##
                     # Initialize the ExecutionPage
@@ -279,6 +513,7 @@ module Twilio
                     # @return [ExecutionPage] ExecutionPage
                     def initialize(version, response, solution)
                         super(version, response)
+                        
 
                         # Path Solution
                         @solution = solution
@@ -298,6 +533,66 @@ module Twilio
                         '<Twilio.Studio.V2.ExecutionPage>'
                     end
                 end
+
+                class ExecutionPageMetadata < PageMetadata
+                    attr_reader :execution_page
+
+                    def initialize(version, response, solution, limit)
+                        super(version, response)
+                        @execution_page = []
+                        @limit = limit
+                        key = get_key(response.body)
+                        records = 0
+                        while( limit != :unset && records < limit )
+                            @execution_page << ExecutionListResponse.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
+                        @execution_page.each do |record|
+                          yield record
+                        end
+                    end
+
+                    def to_s
+                      '<Twilio::REST::Studio::V2PageMetadata>';
+                    end
+                end
+                class ExecutionListResponse < InstanceListResource
+
+                    # @param [Array<ExecutionInstance>] 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
+                      @execution = data_list.map do |data|
+                        ExecutionInstance.new(version, data)
+                      end
+                      @headers = payload.headers
+                      @status_code = payload.status_code
+                    end
+
+                    def execution
+                        @execution
+                    end
+
+                    def headers
+                      @headers
+                    end
+
+                    def status_code
+                      @status_code
+                    end
+                end
+
                 class ExecutionInstance < InstanceResource
                     ##
                     # Initialize the ExecutionInstance
@@ -311,16 +606,20 @@ module Twilio
                     def initialize(version, payload , flow_sid: nil, sid: nil)
                         super(version)
                         
+                        
                         # Marshaled Properties
                         @properties = { 
                             'sid' => payload['sid'],
                             'account_sid' => payload['account_sid'],
                             'flow_sid' => payload['flow_sid'],
                             'contact_channel_address' => payload['contact_channel_address'],
+                            'contact_sid' => payload['contact_sid'],
+                            'flow_version' => payload['flow_version'] == nil ? payload['flow_version'] : payload['flow_version'].to_i,
                             'context' => payload['context'],
                             'status' => payload['status'],
                             'date_created' => Twilio.deserialize_iso8601_datetime(payload['date_created']),
                             'date_updated' => Twilio.deserialize_iso8601_datetime(payload['date_updated']),
+                            'initiated_by' => payload['initiated_by'],
                             'url' => payload['url'],
                             'links' => payload['links'],
                         }
@@ -365,6 +664,18 @@ module Twilio
                         @properties['contact_channel_address']
                     end
                     
+                    ##
+                    # @return [String] The SID of the Contact.
+                    def contact_sid
+                        @properties['contact_sid']
+                    end
+                    
+                    ##
+                    # @return [String] The Flow version number at the time of Execution creation.
+                    def flow_version
+                        @properties['flow_version']
+                    end
+                    
                     ##
                     # @return [Hash] The current state of the Flow's Execution. As a flow executes, we save its state in this context. We save data that your widgets can access as variables in configuration fields or in text areas as variable substitution.
                     def context
@@ -389,6 +700,12 @@ module Twilio
                         @properties['date_updated']
                     end
                     
+                    ##
+                    # @return [String] The SID or identifier that triggered this Execution. For example, a Call SID if triggered by an incoming call, a Message SID if triggered by an incoming message, a Request SID if triggered by a REST API request, and so on.
+                    def initiated_by
+                        @properties['initiated_by']
+                    end
+                    
                     ##
                     # @return [String] The absolute URL of the resource.
                     def url
@@ -422,7 +739,7 @@ module Twilio
                     # @param [Status] status 
                     # @return [ExecutionInstance] Updated ExecutionInstance
                     def update(
-                        status: nil
+                      status: nil
                     )
 
                         context.update(