class Twilio::REST::Proxy::V1::ServiceContext::SessionContext::ParticipantList

PLEASE NOTE that this class contains beta products that are subject to change. Use them with caution.

Public Class Methods

new(version, service_sid: nil, session_sid: nil) click to toggle source

Initialize the ParticipantList @param [Version] version Version that contains the resource @param [String] service_sid The SID of the resource's parent

{Service}[https://www.twilio.com/docs/proxy/api/service] resource.

@param [String] session_sid The SID of the parent

{Session}[https://www.twilio.com/docs/proxy/api/session] resource.

@return [ParticipantList] ParticipantList

Calls superclass method Twilio::REST::ListResource::new
   # File lib/twilio-ruby/rest/proxy/v1/service/session/participant.rb
26 def initialize(version, service_sid: nil, session_sid: nil)
27   super(version)
28 
29   # Path Solution
30   @solution = {service_sid: service_sid, session_sid: session_sid}
31   @uri = "/Services/#{@solution[:service_sid]}/Sessions/#{@solution[:session_sid]}/Participants"
32 end

Public Instance Methods

create(identifier: nil, friendly_name: :unset, proxy_identifier: :unset, proxy_identifier_sid: :unset, fail_on_participant_conflict: :unset) click to toggle source

Create the ParticipantInstance @param [String] identifier The phone number of the Participant. @param [String] friendly_name The string that you assigned to describe the

participant. This value must be 255 characters or fewer. **This value should not
have PII.**

@param [String] proxy_identifier The proxy phone number to use for the

Participant. If not specified, Proxy will select a number from the pool.

@param [String] proxy_identifier_sid The SID of the Proxy Identifier to assign

to the Participant.

@param [Boolean] fail_on_participant_conflict [Experimental] For accounts with

the ProxyAllowParticipantConflict account flag, setting to true enables
per-request opt-in to allowing Proxy to reject a Participant create request that
could cause the same Identifier/ProxyIdentifier pair to be active in multiple
Sessions. Depending on the context, this could be a 409 error (Twilio error code
80623) or a 400 error (Twilio error code 80604). If not provided, requests will
be allowed to succeed and a Debugger notification (80802) will be emitted.
Having multiple, active Participants with the same Identifier/ProxyIdentifier
pair causes calls and messages from affected Participants to be routed
incorrectly. Please note, the default behavior for accounts without the
ProxyAllowParticipantConflict flag is to reject the request as described.  This
will eventually be the default for all accounts.

@return [ParticipantInstance] Created ParticipantInstance

    # File lib/twilio-ruby/rest/proxy/v1/service/session/participant.rb
137 def create(identifier: nil, friendly_name: :unset, proxy_identifier: :unset, proxy_identifier_sid: :unset, fail_on_participant_conflict: :unset)
138   data = Twilio::Values.of({
139       'Identifier' => identifier,
140       'FriendlyName' => friendly_name,
141       'ProxyIdentifier' => proxy_identifier,
142       'ProxyIdentifierSid' => proxy_identifier_sid,
143       'FailOnParticipantConflict' => fail_on_participant_conflict,
144   })
145 
146   payload = @version.create('POST', @uri, data: data)
147 
148   ParticipantInstance.new(
149       @version,
150       payload,
151       service_sid: @solution[:service_sid],
152       session_sid: @solution[:session_sid],
153   )
154 end
each() { |x| ... } click to toggle source

When passed a block, yields ParticipantInstance records from the API. This operation lazily loads records as efficiently as possible until the limit is reached.

   # File lib/twilio-ruby/rest/proxy/v1/service/session/participant.rb
72 def each
73   limits = @version.read_limits
74 
75   page = self.page(page_size: limits[:page_size], )
76 
77   @version.stream(page,
78                   limit: limits[:limit],
79                   page_limit: limits[:page_limit]).each {|x| yield x}
80 end
get_page(target_url) click to toggle source

Retrieve a single page of ParticipantInstance records from the API. Request is executed immediately. @param [String] target_url API-generated URL for the requested results page @return [Page] Page of ParticipantInstance

    # File lib/twilio-ruby/rest/proxy/v1/service/session/participant.rb
106 def get_page(target_url)
107   response = @version.domain.request(
108       'GET',
109       target_url
110   )
111   ParticipantPage.new(@version, response, @solution)
112 end
list(limit: nil, page_size: nil) click to toggle source

Lists ParticipantInstance records from the API as a list. Unlike stream(), this operation is eager and will load `limit` records into memory before returning. @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

   # File lib/twilio-ruby/rest/proxy/v1/service/session/participant.rb
45 def list(limit: nil, page_size: nil)
46   self.stream(limit: limit, page_size: page_size).entries
47 end
page(page_token: :unset, page_number: :unset, page_size: :unset) click to toggle source

Retrieve a single page of ParticipantInstance records from the API. Request is executed immediately. @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 ParticipantInstance

   # File lib/twilio-ruby/rest/proxy/v1/service/session/participant.rb
89 def page(page_token: :unset, page_number: :unset, page_size: :unset)
90   params = Twilio::Values.of({
91       'PageToken' => page_token,
92       'Page' => page_number,
93       'PageSize' => page_size,
94   })
95 
96   response = @version.page('GET', @uri, params: params)
97 
98   ParticipantPage.new(@version, response, @solution)
99 end
stream(limit: nil, page_size: nil) click to toggle source

Streams ParticipantInstance records from the API as an Enumerable. This operation lazily loads records as efficiently as possible until the limit is reached. @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 [Enumerable] Enumerable that will yield up to limit results

   # File lib/twilio-ruby/rest/proxy/v1/service/session/participant.rb
60 def stream(limit: nil, page_size: nil)
61   limits = @version.read_limits(limit, page_size)
62 
63   page = self.page(page_size: limits[:page_size], )
64 
65   @version.stream(page, limit: limits[:limit], page_limit: limits[:page_limit])
66 end
to_s() click to toggle source

Provide a user friendly representation

    # File lib/twilio-ruby/rest/proxy/v1/service/session/participant.rb
158 def to_s
159   '#<Twilio.Proxy.V1.ParticipantList>'
160 end