class ZoomUs::Models::UsersuserIdmeetingsSettings

Meeting settings.

Attributes

alternative_hosts[RW]

Alternative host's emails or IDs: multiple values separated by a comma.

approval_type[RW]

`0` - Automatically approve.
`1` - Manually approve.
`2` - No registration required.

audio[RW]

Determine how participants can join the audio portion of the meeting.
`both` - Both Telephony and VoIP.
`telephony` - Telephony only.
`voip` - VoIP only.

authentication_domains[RW]

Meeting authentication domains. This option, allows you to specify the rule so that Zoom users, whose email address contains a certain domain, can join the meeting. You can either provide multiple domains, using a comma in between and/or use a wildcard for listing domains.

authentication_option[RW]

Specify the authentication type for users to join a meeting with`meeting_authentication` setting set to `true`. The value of this field can be retrieved from the `id` field within `authentication_options` array in the response of [Get User Settings API](marketplace.zoom.us/docs/api-reference/zoom-api/users/usersettings).

auto_recording[RW]

Automatic recording:
`local` - Record on local.
`cloud` - Record on cloud.
`none` - Disabled.

close_registration[RW]

Close registration after event date

cn_meeting[RW]

Host meeting in China.

contact_email[RW]

Contact email for registration

contact_name[RW]

Contact name for registration

enforce_login[RW]

Only signed in users can join this meeting.

enforce_login_domains[RW]

Only signed in users with specified domains can join meetings.

global_dial_in_countries[RW]

List of global dial-in countries

host_video[RW]

Start video when the host joins the meeting.

in_meeting[RW]

Host meeting in India.

join_before_host[RW]

Allow participants to join the meeting before the host starts the meeting. Only used for scheduled or recurring meetings.

meeting_authentication[RW]

Only [authenticated](support.zoom.us/hc/en-us/articles/360037117472-Authentication-Profiles-for-Meetings-and-Webinars) users can join meeting if the value of this field is set to `true`.

mute_upon_entry[RW]

Mute participants upon entry.

participant_video[RW]

Start video when participants join the meeting.

registrants_email_notification[RW]

registrants email notification

registration_type[RW]

Registration type. Used for recurring meeting with fixed time only.
`1` Attendees register once and can attend any of the occurrences.
`2` Attendees need to register for each occurrence to attend.
`3` Attendees register once and can choose one or more occurrences to attend.

use_pmi[RW]

Use Personal Meeting ID instead of an automatically generated meeting ID. It can only be used for scheduled meetings, instant meetings and recurring meetings with no fixed time.

waiting_room[RW]

Enable waiting room

watermark[RW]

Add watermark when viewing a shared screen.

Public Class Methods

attribute_map() click to toggle source

Attribute mapping from ruby-style variable name to JSON key.

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 114
def self.attribute_map
  {
    :'host_video' => :'host_video',
    :'participant_video' => :'participant_video',
    :'cn_meeting' => :'cn_meeting',
    :'in_meeting' => :'in_meeting',
    :'join_before_host' => :'join_before_host',
    :'mute_upon_entry' => :'mute_upon_entry',
    :'watermark' => :'watermark',
    :'use_pmi' => :'use_pmi',
    :'approval_type' => :'approval_type',
    :'registration_type' => :'registration_type',
    :'audio' => :'audio',
    :'auto_recording' => :'auto_recording',
    :'enforce_login' => :'enforce_login',
    :'enforce_login_domains' => :'enforce_login_domains',
    :'alternative_hosts' => :'alternative_hosts',
    :'close_registration' => :'close_registration',
    :'waiting_room' => :'waiting_room',
    :'global_dial_in_countries' => :'global_dial_in_countries',
    :'contact_name' => :'contact_name',
    :'contact_email' => :'contact_email',
    :'registrants_email_notification' => :'registrants_email_notification',
    :'meeting_authentication' => :'meeting_authentication',
    :'authentication_option' => :'authentication_option',
    :'authentication_domains' => :'authentication_domains'
  }
end
new(attributes = {}) click to toggle source

Initializes the object @param [Hash] attributes Model attributes in the form of hash

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 175
def initialize(attributes = {})
  return unless attributes.is_a?(Hash)

  # convert string to symbol for hash key
  attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }

  if attributes.has_key?(:'host_video')
    self.host_video = attributes[:'host_video']
  end

  if attributes.has_key?(:'participant_video')
    self.participant_video = attributes[:'participant_video']
  end

  if attributes.has_key?(:'cn_meeting')
    self.cn_meeting = attributes[:'cn_meeting']
  else
    self.cn_meeting = false
  end

  if attributes.has_key?(:'in_meeting')
    self.in_meeting = attributes[:'in_meeting']
  else
    self.in_meeting = false
  end

  if attributes.has_key?(:'join_before_host')
    self.join_before_host = attributes[:'join_before_host']
  else
    self.join_before_host = false
  end

  if attributes.has_key?(:'mute_upon_entry')
    self.mute_upon_entry = attributes[:'mute_upon_entry']
  else
    self.mute_upon_entry = false
  end

  if attributes.has_key?(:'watermark')
    self.watermark = attributes[:'watermark']
  else
    self.watermark = false
  end

  if attributes.has_key?(:'use_pmi')
    self.use_pmi = attributes[:'use_pmi']
  else
    self.use_pmi = false
  end

  if attributes.has_key?(:'approval_type')
    self.approval_type = attributes[:'approval_type']
  end

  if attributes.has_key?(:'registration_type')
    self.registration_type = attributes[:'registration_type']
  end

  if attributes.has_key?(:'audio')
    self.audio = attributes[:'audio']
  else
    self.audio = 'both'
  end

  if attributes.has_key?(:'auto_recording')
    self.auto_recording = attributes[:'auto_recording']
  else
    self.auto_recording = 'none'
  end

  if attributes.has_key?(:'enforce_login')
    self.enforce_login = attributes[:'enforce_login']
  end

  if attributes.has_key?(:'enforce_login_domains')
    self.enforce_login_domains = attributes[:'enforce_login_domains']
  end

  if attributes.has_key?(:'alternative_hosts')
    self.alternative_hosts = attributes[:'alternative_hosts']
  end

  if attributes.has_key?(:'close_registration')
    self.close_registration = attributes[:'close_registration']
  else
    self.close_registration = false
  end

  if attributes.has_key?(:'waiting_room')
    self.waiting_room = attributes[:'waiting_room']
  else
    self.waiting_room = false
  end

  if attributes.has_key?(:'global_dial_in_countries')
    if (value = attributes[:'global_dial_in_countries']).is_a?(Array)
      self.global_dial_in_countries = value
    end
  end

  if attributes.has_key?(:'contact_name')
    self.contact_name = attributes[:'contact_name']
  end

  if attributes.has_key?(:'contact_email')
    self.contact_email = attributes[:'contact_email']
  end

  if attributes.has_key?(:'registrants_email_notification')
    self.registrants_email_notification = attributes[:'registrants_email_notification']
  end

  if attributes.has_key?(:'meeting_authentication')
    self.meeting_authentication = attributes[:'meeting_authentication']
  end

  if attributes.has_key?(:'authentication_option')
    self.authentication_option = attributes[:'authentication_option']
  end

  if attributes.has_key?(:'authentication_domains')
    self.authentication_domains = attributes[:'authentication_domains']
  end
end
swagger_types() click to toggle source

Attribute type mapping.

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 144
def self.swagger_types
  {
    :'host_video' => :'BOOLEAN',
    :'participant_video' => :'BOOLEAN',
    :'cn_meeting' => :'BOOLEAN',
    :'in_meeting' => :'BOOLEAN',
    :'join_before_host' => :'BOOLEAN',
    :'mute_upon_entry' => :'BOOLEAN',
    :'watermark' => :'BOOLEAN',
    :'use_pmi' => :'BOOLEAN',
    :'approval_type' => :'Integer',
    :'registration_type' => :'Integer',
    :'audio' => :'String',
    :'auto_recording' => :'String',
    :'enforce_login' => :'BOOLEAN',
    :'enforce_login_domains' => :'String',
    :'alternative_hosts' => :'String',
    :'close_registration' => :'BOOLEAN',
    :'waiting_room' => :'BOOLEAN',
    :'global_dial_in_countries' => :'Array<String>',
    :'contact_name' => :'String',
    :'contact_email' => :'String',
    :'registrants_email_notification' => :'BOOLEAN',
    :'meeting_authentication' => :'BOOLEAN',
    :'authentication_option' => :'String',
    :'authentication_domains' => :'String'
  }
end

Public Instance Methods

==(o) click to toggle source

Checks equality by comparing each attribute. @param [Object] Object to be compared

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 339
def ==(o)
  return true if self.equal?(o)
  self.class == o.class &&
    host_video == o.host_video &&
    participant_video == o.participant_video &&
    cn_meeting == o.cn_meeting &&
    in_meeting == o.in_meeting &&
    join_before_host == o.join_before_host &&
    mute_upon_entry == o.mute_upon_entry &&
    watermark == o.watermark &&
    use_pmi == o.use_pmi &&
    approval_type == o.approval_type &&
    registration_type == o.registration_type &&
    audio == o.audio &&
    auto_recording == o.auto_recording &&
    enforce_login == o.enforce_login &&
    enforce_login_domains == o.enforce_login_domains &&
    alternative_hosts == o.alternative_hosts &&
    close_registration == o.close_registration &&
    waiting_room == o.waiting_room &&
    global_dial_in_countries == o.global_dial_in_countries &&
    contact_name == o.contact_name &&
    contact_email == o.contact_email &&
    registrants_email_notification == o.registrants_email_notification &&
    meeting_authentication == o.meeting_authentication &&
    authentication_option == o.authentication_option &&
    authentication_domains == o.authentication_domains
end
_deserialize(type, value) click to toggle source

Deserializes the data based on type @param string type Data type @param string value Value to be deserialized @return [Object] Deserialized data

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 404
def _deserialize(type, value)
  case type.to_sym
  when :DateTime
    ::DateTime.parse(value)
  when :Date
    ::Date.parse(value)
  when :String
    value.to_s
  when :Integer
    value.to_i
  when :Float
    value.to_f
  when :BOOLEAN
    if value.to_s =~ /\A(true|t|yes|y|1)\z/i
      true
    else
      false
    end
  when :Object
    # generic object (usually a Hash), return directly
    value
  when /\AArray<(?<inner_type>.+)>\z/
    inner_type = Regexp.last_match[:inner_type]
    value.map { |v| _deserialize(inner_type, v) }
  when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
    k_type = Regexp.last_match[:k_type]
    v_type = Regexp.last_match[:v_type]
    {}.tap do |hash|
      value.each do |k, v|
        hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
      end
    end
  else # model
    temp_model = Models.const_get(type).new
    temp_model.build_from_hash(value)
  end
end
_to_hash(value) click to toggle source

Outputs non-array value in the form of hash For object, use to_hash. Otherwise, just return the value @param [Object] value Any valid value @return [Hash] Returns the value in the form of hash

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 470
def _to_hash(value)
  if value.is_a?(Array)
    value.compact.map { |v| _to_hash(v) }
  elsif value.is_a?(Hash)
    {}.tap do |hash|
      value.each { |k, v| hash[k] = _to_hash(v) }
    end
  elsif value.respond_to? :to_hash
    value.to_hash
  else
    value
  end
end
audio=(audio) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] audio Object to be assigned

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 319
def audio=(audio)
  validator = EnumAttributeValidator.new('String', ['both', 'telephony', 'voip'])
  unless validator.valid?(audio)
    fail ArgumentError, 'invalid value for "audio", must be one of #{validator.allowable_values}.'
  end
  @audio = audio
end
auto_recording=(auto_recording) click to toggle source

Custom attribute writer method checking allowed values (enum). @param [Object] auto_recording Object to be assigned

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 329
def auto_recording=(auto_recording)
  validator = EnumAttributeValidator.new('String', ['local', 'cloud', 'none'])
  unless validator.valid?(auto_recording)
    fail ArgumentError, 'invalid value for "auto_recording", must be one of #{validator.allowable_values}.'
  end
  @auto_recording = auto_recording
end
build_from_hash(attributes) click to toggle source

Builds the object from hash @param [Hash] attributes Model attributes in the form of hash @return [Object] Returns the model itself

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 383
def build_from_hash(attributes)
  return nil unless attributes.is_a?(Hash)
  self.class.swagger_types.each_pair do |key, type|
    if type =~ /\AArray<(.*)>/i
      # check to ensure the input is an array given that the the attribute
      # is documented as an array but the input is not
      if attributes[self.class.attribute_map[key]].is_a?(Array)
        self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
      end
    elsif !attributes[self.class.attribute_map[key]].nil?
      self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
    end # or else data not found in attributes(hash), not an issue as the data can be optional
  end

  self
end
eql?(o) click to toggle source

@see the `==` method @param [Object] Object to be compared

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 370
def eql?(o)
  self == o
end
hash() click to toggle source

Calculates hash code according to all attributes. @return [Fixnum] Hash code

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 376
def hash
  [host_video, participant_video, cn_meeting, in_meeting, join_before_host, mute_upon_entry, watermark, use_pmi, approval_type, registration_type, audio, auto_recording, enforce_login, enforce_login_domains, alternative_hosts, close_registration, waiting_room, global_dial_in_countries, contact_name, contact_email, registrants_email_notification, meeting_authentication, authentication_option, authentication_domains].hash
end
list_invalid_properties() click to toggle source

Show invalid properties with the reasons. Usually used together with valid? @return Array for valid properties with the reasons

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 302
def list_invalid_properties
  invalid_properties = Array.new
  invalid_properties
end
to_body() click to toggle source

to_body is an alias to to_hash (backward compatibility) @return [Hash] Returns the object in the form of hash

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 450
def to_body
  to_hash
end
to_hash() click to toggle source

Returns the object in the form of hash @return [Hash] Returns the object in the form of hash

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 456
def to_hash
  hash = {}
  self.class.attribute_map.each_pair do |attr, param|
    value = self.send(attr)
    next if value.nil?
    hash[param] = _to_hash(value)
  end
  hash
end
to_s() click to toggle source

Returns the string representation of the object @return [String] String presentation of the object

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 444
def to_s
  to_hash.to_s
end
valid?() click to toggle source

Check to see if the all the properties in the model are valid @return true if the model is valid

# File lib/zoom_us/models/usersuser_idmeetings_settings.rb, line 309
def valid?
  audio_validator = EnumAttributeValidator.new('String', ['both', 'telephony', 'voip'])
  return false unless audio_validator.valid?(@audio)
  auto_recording_validator = EnumAttributeValidator.new('String', ['local', 'cloud', 'none'])
  return false unless auto_recording_validator.valid?(@auto_recording)
  true
end