class DocuSign_eSign::AccountManagementGranular

Attributes

allow_manage_account_security_settings[RW]

allow_manage_account_security_settings_metadata[RW]

allow_manage_account_settings[RW]

allow_manage_account_settings_metadata[RW]

allow_manage_admins[RW]

allow_manage_admins_metadata[RW]

allow_manage_connect[RW]

allow_manage_connect_metadata[RW]

allow_manage_document_retention[RW]

allow_manage_document_retention_metadata[RW]

allow_manage_envelope_transfer[RW]

allow_manage_envelope_transfer_metadata[RW]

allow_manage_groups_but_not_users[RW]

allow_manage_groups_but_not_users_metadata[RW]

allow_manage_joint_agreements[RW]

allow_manage_joint_agreements_metadata[RW]

allow_manage_reporting[RW]

allow_manage_reporting_metadata[RW]

allow_manage_sharing[RW]

allow_manage_sharing_metadata[RW]

allow_manage_signing_groups[RW]

allow_manage_signing_groups_metadata[RW]

allow_manage_stamps[RW]

allow_manage_stamps_metadata[RW]

allow_manage_users[RW]

allow_manage_users_metadata[RW]

allow_view_users[RW]

Public Class Methods

attribute_map() click to toggle source

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

# File lib/docusign_esign/models/account_management_granular.rb, line 98
def self.attribute_map
  {
    :'allow_manage_account_security_settings' => :'allowManageAccountSecuritySettings',
    :'allow_manage_account_security_settings_metadata' => :'allowManageAccountSecuritySettingsMetadata',
    :'allow_manage_account_settings' => :'allowManageAccountSettings',
    :'allow_manage_account_settings_metadata' => :'allowManageAccountSettingsMetadata',
    :'allow_manage_admins' => :'allowManageAdmins',
    :'allow_manage_admins_metadata' => :'allowManageAdminsMetadata',
    :'allow_manage_connect' => :'allowManageConnect',
    :'allow_manage_connect_metadata' => :'allowManageConnectMetadata',
    :'allow_manage_document_retention' => :'allowManageDocumentRetention',
    :'allow_manage_document_retention_metadata' => :'allowManageDocumentRetentionMetadata',
    :'allow_manage_envelope_transfer' => :'allowManageEnvelopeTransfer',
    :'allow_manage_envelope_transfer_metadata' => :'allowManageEnvelopeTransferMetadata',
    :'allow_manage_groups_but_not_users' => :'allowManageGroupsButNotUsers',
    :'allow_manage_groups_but_not_users_metadata' => :'allowManageGroupsButNotUsersMetadata',
    :'allow_manage_joint_agreements' => :'allowManageJointAgreements',
    :'allow_manage_joint_agreements_metadata' => :'allowManageJointAgreementsMetadata',
    :'allow_manage_reporting' => :'allowManageReporting',
    :'allow_manage_reporting_metadata' => :'allowManageReportingMetadata',
    :'allow_manage_sharing' => :'allowManageSharing',
    :'allow_manage_sharing_metadata' => :'allowManageSharingMetadata',
    :'allow_manage_signing_groups' => :'allowManageSigningGroups',
    :'allow_manage_signing_groups_metadata' => :'allowManageSigningGroupsMetadata',
    :'allow_manage_stamps' => :'allowManageStamps',
    :'allow_manage_stamps_metadata' => :'allowManageStampsMetadata',
    :'allow_manage_users' => :'allowManageUsers',
    :'allow_manage_users_metadata' => :'allowManageUsersMetadata',
    :'allow_view_users' => :'allowViewUsers'
  }
end

new(attributes = {}) click to toggle source

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

# File lib/docusign_esign/models/account_management_granular.rb, line 165
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?(:'allowManageAccountSecuritySettings')
    self.allow_manage_account_security_settings = attributes[:'allowManageAccountSecuritySettings']
  end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

swagger_types() click to toggle source

Attribute type mapping.

# File lib/docusign_esign/models/account_management_granular.rb, line 131
def self.swagger_types
  {
    :'allow_manage_account_security_settings' => :'String',
    :'allow_manage_account_security_settings_metadata' => :'SettingsMetadata',
    :'allow_manage_account_settings' => :'String',
    :'allow_manage_account_settings_metadata' => :'SettingsMetadata',
    :'allow_manage_admins' => :'String',
    :'allow_manage_admins_metadata' => :'SettingsMetadata',
    :'allow_manage_connect' => :'String',
    :'allow_manage_connect_metadata' => :'SettingsMetadata',
    :'allow_manage_document_retention' => :'String',
    :'allow_manage_document_retention_metadata' => :'SettingsMetadata',
    :'allow_manage_envelope_transfer' => :'String',
    :'allow_manage_envelope_transfer_metadata' => :'SettingsMetadata',
    :'allow_manage_groups_but_not_users' => :'String',
    :'allow_manage_groups_but_not_users_metadata' => :'SettingsMetadata',
    :'allow_manage_joint_agreements' => :'String',
    :'allow_manage_joint_agreements_metadata' => :'SettingsMetadata',
    :'allow_manage_reporting' => :'String',
    :'allow_manage_reporting_metadata' => :'SettingsMetadata',
    :'allow_manage_sharing' => :'String',
    :'allow_manage_sharing_metadata' => :'SettingsMetadata',
    :'allow_manage_signing_groups' => :'String',
    :'allow_manage_signing_groups_metadata' => :'SettingsMetadata',
    :'allow_manage_stamps' => :'String',
    :'allow_manage_stamps_metadata' => :'SettingsMetadata',
    :'allow_manage_users' => :'String',
    :'allow_manage_users_metadata' => :'SettingsMetadata',
    :'allow_view_users' => :'String'
  }
end

Public Instance Methods

==(o) click to toggle source

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

# File lib/docusign_esign/models/account_management_granular.rb, line 295
def ==(o)
  return true if self.equal?(o)
  self.class == o.class &&
      allow_manage_account_security_settings == o.allow_manage_account_security_settings &&
      allow_manage_account_security_settings_metadata == o.allow_manage_account_security_settings_metadata &&
      allow_manage_account_settings == o.allow_manage_account_settings &&
      allow_manage_account_settings_metadata == o.allow_manage_account_settings_metadata &&
      allow_manage_admins == o.allow_manage_admins &&
      allow_manage_admins_metadata == o.allow_manage_admins_metadata &&
      allow_manage_connect == o.allow_manage_connect &&
      allow_manage_connect_metadata == o.allow_manage_connect_metadata &&
      allow_manage_document_retention == o.allow_manage_document_retention &&
      allow_manage_document_retention_metadata == o.allow_manage_document_retention_metadata &&
      allow_manage_envelope_transfer == o.allow_manage_envelope_transfer &&
      allow_manage_envelope_transfer_metadata == o.allow_manage_envelope_transfer_metadata &&
      allow_manage_groups_but_not_users == o.allow_manage_groups_but_not_users &&
      allow_manage_groups_but_not_users_metadata == o.allow_manage_groups_but_not_users_metadata &&
      allow_manage_joint_agreements == o.allow_manage_joint_agreements &&
      allow_manage_joint_agreements_metadata == o.allow_manage_joint_agreements_metadata &&
      allow_manage_reporting == o.allow_manage_reporting &&
      allow_manage_reporting_metadata == o.allow_manage_reporting_metadata &&
      allow_manage_sharing == o.allow_manage_sharing &&
      allow_manage_sharing_metadata == o.allow_manage_sharing_metadata &&
      allow_manage_signing_groups == o.allow_manage_signing_groups &&
      allow_manage_signing_groups_metadata == o.allow_manage_signing_groups_metadata &&
      allow_manage_stamps == o.allow_manage_stamps &&
      allow_manage_stamps_metadata == o.allow_manage_stamps_metadata &&
      allow_manage_users == o.allow_manage_users &&
      allow_manage_users_metadata == o.allow_manage_users_metadata &&
      allow_view_users == o.allow_view_users
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/docusign_esign/models/account_management_granular.rb, line 363
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 = DocuSign_eSign.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/docusign_esign/models/account_management_granular.rb, line 429
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

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/docusign_esign/models/account_management_granular.rb, line 342
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 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/docusign_esign/models/account_management_granular.rb, line 329
def eql?(o)
  self == o
end

hash() click to toggle source

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

# File lib/docusign_esign/models/account_management_granular.rb, line 335
def hash
  [allow_manage_account_security_settings, allow_manage_account_security_settings_metadata, allow_manage_account_settings, allow_manage_account_settings_metadata, allow_manage_admins, allow_manage_admins_metadata, allow_manage_connect, allow_manage_connect_metadata, allow_manage_document_retention, allow_manage_document_retention_metadata, allow_manage_envelope_transfer, allow_manage_envelope_transfer_metadata, allow_manage_groups_but_not_users, allow_manage_groups_but_not_users_metadata, allow_manage_joint_agreements, allow_manage_joint_agreements_metadata, allow_manage_reporting, allow_manage_reporting_metadata, allow_manage_sharing, allow_manage_sharing_metadata, allow_manage_signing_groups, allow_manage_signing_groups_metadata, allow_manage_stamps, allow_manage_stamps_metadata, allow_manage_users, allow_manage_users_metadata, allow_view_users].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/docusign_esign/models/account_management_granular.rb, line 282
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/docusign_esign/models/account_management_granular.rb, line 409
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/docusign_esign/models/account_management_granular.rb, line 415
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/docusign_esign/models/account_management_granular.rb, line 403
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/docusign_esign/models/account_management_granular.rb, line 289
def valid?
  true
end