Class: OCI::IdentityDomains::Models::PasswordPolicy

Inherits:
Object
  • Object
show all
Defined in:
lib/oci/identity_domains/models/password_policy.rb

Overview

PasswordPolicy resource.

Constant Summary collapse

IDCS_PREVENTED_OPERATIONS_ENUM = 
[
  IDCS_PREVENTED_OPERATIONS_REPLACE = 'replace'.freeze,
  IDCS_PREVENTED_OPERATIONS_UPDATE = 'update'.freeze,
  IDCS_PREVENTED_OPERATIONS_DELETE = 'delete'.freeze,
  IDCS_PREVENTED_OPERATIONS_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE'.freeze
].freeze
PASSWORD_STRENGTH_ENUM = 
[
  PASSWORD_STRENGTH_SIMPLE = 'Simple'.freeze,
  PASSWORD_STRENGTH_STANDARD = 'Standard'.freeze,
  PASSWORD_STRENGTH_CUSTOM = 'Custom'.freeze,
  PASSWORD_STRENGTH_UNKNOWN_ENUM_VALUE = 'UNKNOWN_ENUM_VALUE'.freeze
].freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(attributes = {}) ⇒ PasswordPolicy

Initializes the object

Parameters:

  • attributes (Hash) (defaults to: {}) —

    Model attributes in the form of hash

Options Hash (attributes):



857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 857

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 }

  self.id = attributes[:'id'] if attributes[:'id']

  self.ocid = attributes[:'ocid'] if attributes[:'ocid']

  self.schemas = attributes[:'schemas'] if attributes[:'schemas']

  self.meta = attributes[:'meta'] if attributes[:'meta']

  self.idcs_created_by = attributes[:'idcsCreatedBy'] if attributes[:'idcsCreatedBy']

  raise 'You cannot provide both :idcsCreatedBy and :idcs_created_by' if attributes.key?(:'idcsCreatedBy') && attributes.key?(:'idcs_created_by')

  self.idcs_created_by = attributes[:'idcs_created_by'] if attributes[:'idcs_created_by']

  self.idcs_last_modified_by = attributes[:'idcsLastModifiedBy'] if attributes[:'idcsLastModifiedBy']

  raise 'You cannot provide both :idcsLastModifiedBy and :idcs_last_modified_by' if attributes.key?(:'idcsLastModifiedBy') && attributes.key?(:'idcs_last_modified_by')

  self.idcs_last_modified_by = attributes[:'idcs_last_modified_by'] if attributes[:'idcs_last_modified_by']

  self.idcs_prevented_operations = attributes[:'idcsPreventedOperations'] if attributes[:'idcsPreventedOperations']

  raise 'You cannot provide both :idcsPreventedOperations and :idcs_prevented_operations' if attributes.key?(:'idcsPreventedOperations') && attributes.key?(:'idcs_prevented_operations')

  self.idcs_prevented_operations = attributes[:'idcs_prevented_operations'] if attributes[:'idcs_prevented_operations']

  self.tags = attributes[:'tags'] if attributes[:'tags']

  self.delete_in_progress = attributes[:'deleteInProgress'] unless attributes[:'deleteInProgress'].nil?

  raise 'You cannot provide both :deleteInProgress and :delete_in_progress' if attributes.key?(:'deleteInProgress') && attributes.key?(:'delete_in_progress')

  self.delete_in_progress = attributes[:'delete_in_progress'] unless attributes[:'delete_in_progress'].nil?

  self.idcs_last_upgraded_in_release = attributes[:'idcsLastUpgradedInRelease'] if attributes[:'idcsLastUpgradedInRelease']

  raise 'You cannot provide both :idcsLastUpgradedInRelease and :idcs_last_upgraded_in_release' if attributes.key?(:'idcsLastUpgradedInRelease') && attributes.key?(:'idcs_last_upgraded_in_release')

  self.idcs_last_upgraded_in_release = attributes[:'idcs_last_upgraded_in_release'] if attributes[:'idcs_last_upgraded_in_release']

  self.domain_ocid = attributes[:'domainOcid'] if attributes[:'domainOcid']

  raise 'You cannot provide both :domainOcid and :domain_ocid' if attributes.key?(:'domainOcid') && attributes.key?(:'domain_ocid')

  self.domain_ocid = attributes[:'domain_ocid'] if attributes[:'domain_ocid']

  self.compartment_ocid = attributes[:'compartmentOcid'] if attributes[:'compartmentOcid']

  raise 'You cannot provide both :compartmentOcid and :compartment_ocid' if attributes.key?(:'compartmentOcid') && attributes.key?(:'compartment_ocid')

  self.compartment_ocid = attributes[:'compartment_ocid'] if attributes[:'compartment_ocid']

  self.tenancy_ocid = attributes[:'tenancyOcid'] if attributes[:'tenancyOcid']

  raise 'You cannot provide both :tenancyOcid and :tenancy_ocid' if attributes.key?(:'tenancyOcid') && attributes.key?(:'tenancy_ocid')

  self.tenancy_ocid = attributes[:'tenancy_ocid'] if attributes[:'tenancy_ocid']

  self.external_id = attributes[:'externalId'] if attributes[:'externalId']

  raise 'You cannot provide both :externalId and :external_id' if attributes.key?(:'externalId') && attributes.key?(:'external_id')

  self.external_id = attributes[:'external_id'] if attributes[:'external_id']

  self.name = attributes[:'name'] if attributes[:'name']

  self.description = attributes[:'description'] if attributes[:'description']

  self.max_length = attributes[:'maxLength'] if attributes[:'maxLength']

  raise 'You cannot provide both :maxLength and :max_length' if attributes.key?(:'maxLength') && attributes.key?(:'max_length')

  self.max_length = attributes[:'max_length'] if attributes[:'max_length']

  self.min_length = attributes[:'minLength'] if attributes[:'minLength']

  raise 'You cannot provide both :minLength and :min_length' if attributes.key?(:'minLength') && attributes.key?(:'min_length')

  self.min_length = attributes[:'min_length'] if attributes[:'min_length']

  self.min_alphas = attributes[:'minAlphas'] if attributes[:'minAlphas']

  raise 'You cannot provide both :minAlphas and :min_alphas' if attributes.key?(:'minAlphas') && attributes.key?(:'min_alphas')

  self.min_alphas = attributes[:'min_alphas'] if attributes[:'min_alphas']

  self.min_numerals = attributes[:'minNumerals'] if attributes[:'minNumerals']

  raise 'You cannot provide both :minNumerals and :min_numerals' if attributes.key?(:'minNumerals') && attributes.key?(:'min_numerals')

  self.min_numerals = attributes[:'min_numerals'] if attributes[:'min_numerals']

  self.min_alpha_numerals = attributes[:'minAlphaNumerals'] if attributes[:'minAlphaNumerals']

  raise 'You cannot provide both :minAlphaNumerals and :min_alpha_numerals' if attributes.key?(:'minAlphaNumerals') && attributes.key?(:'min_alpha_numerals')

  self.min_alpha_numerals = attributes[:'min_alpha_numerals'] if attributes[:'min_alpha_numerals']

  self.min_special_chars = attributes[:'minSpecialChars'] if attributes[:'minSpecialChars']

  raise 'You cannot provide both :minSpecialChars and :min_special_chars' if attributes.key?(:'minSpecialChars') && attributes.key?(:'min_special_chars')

  self.min_special_chars = attributes[:'min_special_chars'] if attributes[:'min_special_chars']

  self.max_special_chars = attributes[:'maxSpecialChars'] if attributes[:'maxSpecialChars']

  raise 'You cannot provide both :maxSpecialChars and :max_special_chars' if attributes.key?(:'maxSpecialChars') && attributes.key?(:'max_special_chars')

  self.max_special_chars = attributes[:'max_special_chars'] if attributes[:'max_special_chars']

  self.min_lower_case = attributes[:'minLowerCase'] if attributes[:'minLowerCase']

  raise 'You cannot provide both :minLowerCase and :min_lower_case' if attributes.key?(:'minLowerCase') && attributes.key?(:'min_lower_case')

  self.min_lower_case = attributes[:'min_lower_case'] if attributes[:'min_lower_case']

  self.min_upper_case = attributes[:'minUpperCase'] if attributes[:'minUpperCase']

  raise 'You cannot provide both :minUpperCase and :min_upper_case' if attributes.key?(:'minUpperCase') && attributes.key?(:'min_upper_case')

  self.min_upper_case = attributes[:'min_upper_case'] if attributes[:'min_upper_case']

  self.min_unique_chars = attributes[:'minUniqueChars'] if attributes[:'minUniqueChars']

  raise 'You cannot provide both :minUniqueChars and :min_unique_chars' if attributes.key?(:'minUniqueChars') && attributes.key?(:'min_unique_chars')

  self.min_unique_chars = attributes[:'min_unique_chars'] if attributes[:'min_unique_chars']

  self.max_repeated_chars = attributes[:'maxRepeatedChars'] if attributes[:'maxRepeatedChars']

  raise 'You cannot provide both :maxRepeatedChars and :max_repeated_chars' if attributes.key?(:'maxRepeatedChars') && attributes.key?(:'max_repeated_chars')

  self.max_repeated_chars = attributes[:'max_repeated_chars'] if attributes[:'max_repeated_chars']

  self.starts_with_alphabet = attributes[:'startsWithAlphabet'] unless attributes[:'startsWithAlphabet'].nil?

  raise 'You cannot provide both :startsWithAlphabet and :starts_with_alphabet' if attributes.key?(:'startsWithAlphabet') && attributes.key?(:'starts_with_alphabet')

  self.starts_with_alphabet = attributes[:'starts_with_alphabet'] unless attributes[:'starts_with_alphabet'].nil?

  self.first_name_disallowed = attributes[:'firstNameDisallowed'] unless attributes[:'firstNameDisallowed'].nil?

  raise 'You cannot provide both :firstNameDisallowed and :first_name_disallowed' if attributes.key?(:'firstNameDisallowed') && attributes.key?(:'first_name_disallowed')

  self.first_name_disallowed = attributes[:'first_name_disallowed'] unless attributes[:'first_name_disallowed'].nil?

  self.last_name_disallowed = attributes[:'lastNameDisallowed'] unless attributes[:'lastNameDisallowed'].nil?

  raise 'You cannot provide both :lastNameDisallowed and :last_name_disallowed' if attributes.key?(:'lastNameDisallowed') && attributes.key?(:'last_name_disallowed')

  self.last_name_disallowed = attributes[:'last_name_disallowed'] unless attributes[:'last_name_disallowed'].nil?

  self.user_name_disallowed = attributes[:'userNameDisallowed'] unless attributes[:'userNameDisallowed'].nil?

  raise 'You cannot provide both :userNameDisallowed and :user_name_disallowed' if attributes.key?(:'userNameDisallowed') && attributes.key?(:'user_name_disallowed')

  self.user_name_disallowed = attributes[:'user_name_disallowed'] unless attributes[:'user_name_disallowed'].nil?

  self.disallowed_user_attribute_values = attributes[:'disallowedUserAttributeValues'] if attributes[:'disallowedUserAttributeValues']

  raise 'You cannot provide both :disallowedUserAttributeValues and :disallowed_user_attribute_values' if attributes.key?(:'disallowedUserAttributeValues') && attributes.key?(:'disallowed_user_attribute_values')

  self.disallowed_user_attribute_values = attributes[:'disallowed_user_attribute_values'] if attributes[:'disallowed_user_attribute_values']

  self.min_password_age = attributes[:'minPasswordAge'] if attributes[:'minPasswordAge']

  raise 'You cannot provide both :minPasswordAge and :min_password_age' if attributes.key?(:'minPasswordAge') && attributes.key?(:'min_password_age')

  self.min_password_age = attributes[:'min_password_age'] if attributes[:'min_password_age']

  self.password_expires_after = attributes[:'passwordExpiresAfter'] if attributes[:'passwordExpiresAfter']

  raise 'You cannot provide both :passwordExpiresAfter and :password_expires_after' if attributes.key?(:'passwordExpiresAfter') && attributes.key?(:'password_expires_after')

  self.password_expires_after = attributes[:'password_expires_after'] if attributes[:'password_expires_after']

  self.password_expire_warning = attributes[:'passwordExpireWarning'] if attributes[:'passwordExpireWarning']

  raise 'You cannot provide both :passwordExpireWarning and :password_expire_warning' if attributes.key?(:'passwordExpireWarning') && attributes.key?(:'password_expire_warning')

  self.password_expire_warning = attributes[:'password_expire_warning'] if attributes[:'password_expire_warning']

  self.required_chars = attributes[:'requiredChars'] if attributes[:'requiredChars']

  raise 'You cannot provide both :requiredChars and :required_chars' if attributes.key?(:'requiredChars') && attributes.key?(:'required_chars')

  self.required_chars = attributes[:'required_chars'] if attributes[:'required_chars']

  self.disallowed_chars = attributes[:'disallowedChars'] if attributes[:'disallowedChars']

  raise 'You cannot provide both :disallowedChars and :disallowed_chars' if attributes.key?(:'disallowedChars') && attributes.key?(:'disallowed_chars')

  self.disallowed_chars = attributes[:'disallowed_chars'] if attributes[:'disallowed_chars']

  self.allowed_chars = attributes[:'allowedChars'] if attributes[:'allowedChars']

  raise 'You cannot provide both :allowedChars and :allowed_chars' if attributes.key?(:'allowedChars') && attributes.key?(:'allowed_chars')

  self.allowed_chars = attributes[:'allowed_chars'] if attributes[:'allowed_chars']

  self.disallowed_substrings = attributes[:'disallowedSubstrings'] if attributes[:'disallowedSubstrings']

  raise 'You cannot provide both :disallowedSubstrings and :disallowed_substrings' if attributes.key?(:'disallowedSubstrings') && attributes.key?(:'disallowed_substrings')

  self.disallowed_substrings = attributes[:'disallowed_substrings'] if attributes[:'disallowed_substrings']

  self.dictionary_word_disallowed = attributes[:'dictionaryWordDisallowed'] unless attributes[:'dictionaryWordDisallowed'].nil?

  raise 'You cannot provide both :dictionaryWordDisallowed and :dictionary_word_disallowed' if attributes.key?(:'dictionaryWordDisallowed') && attributes.key?(:'dictionary_word_disallowed')

  self.dictionary_word_disallowed = attributes[:'dictionary_word_disallowed'] unless attributes[:'dictionary_word_disallowed'].nil?

  self.dictionary_location = attributes[:'dictionaryLocation'] if attributes[:'dictionaryLocation']

  raise 'You cannot provide both :dictionaryLocation and :dictionary_location' if attributes.key?(:'dictionaryLocation') && attributes.key?(:'dictionary_location')

  self.dictionary_location = attributes[:'dictionary_location'] if attributes[:'dictionary_location']

  self.dictionary_delimiter = attributes[:'dictionaryDelimiter'] if attributes[:'dictionaryDelimiter']

  raise 'You cannot provide both :dictionaryDelimiter and :dictionary_delimiter' if attributes.key?(:'dictionaryDelimiter') && attributes.key?(:'dictionary_delimiter')

  self.dictionary_delimiter = attributes[:'dictionary_delimiter'] if attributes[:'dictionary_delimiter']

  self.max_incorrect_attempts = attributes[:'maxIncorrectAttempts'] if attributes[:'maxIncorrectAttempts']

  raise 'You cannot provide both :maxIncorrectAttempts and :max_incorrect_attempts' if attributes.key?(:'maxIncorrectAttempts') && attributes.key?(:'max_incorrect_attempts')

  self.max_incorrect_attempts = attributes[:'max_incorrect_attempts'] if attributes[:'max_incorrect_attempts']

  self.lockout_duration = attributes[:'lockoutDuration'] if attributes[:'lockoutDuration']

  raise 'You cannot provide both :lockoutDuration and :lockout_duration' if attributes.key?(:'lockoutDuration') && attributes.key?(:'lockout_duration')

  self.lockout_duration = attributes[:'lockout_duration'] if attributes[:'lockout_duration']

  self.num_passwords_in_history = attributes[:'numPasswordsInHistory'] if attributes[:'numPasswordsInHistory']

  raise 'You cannot provide both :numPasswordsInHistory and :num_passwords_in_history' if attributes.key?(:'numPasswordsInHistory') && attributes.key?(:'num_passwords_in_history')

  self.num_passwords_in_history = attributes[:'num_passwords_in_history'] if attributes[:'num_passwords_in_history']

  self.password_strength = attributes[:'passwordStrength'] if attributes[:'passwordStrength']

  raise 'You cannot provide both :passwordStrength and :password_strength' if attributes.key?(:'passwordStrength') && attributes.key?(:'password_strength')

  self.password_strength = attributes[:'password_strength'] if attributes[:'password_strength']

  self.force_password_reset = attributes[:'forcePasswordReset'] unless attributes[:'forcePasswordReset'].nil?

  raise 'You cannot provide both :forcePasswordReset and :force_password_reset' if attributes.key?(:'forcePasswordReset') && attributes.key?(:'force_password_reset')

  self.force_password_reset = attributes[:'force_password_reset'] unless attributes[:'force_password_reset'].nil?

  self.distinct_characters = attributes[:'distinctCharacters'] if attributes[:'distinctCharacters']

  raise 'You cannot provide both :distinctCharacters and :distinct_characters' if attributes.key?(:'distinctCharacters') && attributes.key?(:'distinct_characters')

  self.distinct_characters = attributes[:'distinct_characters'] if attributes[:'distinct_characters']

  self.priority = attributes[:'priority'] if attributes[:'priority']

  self.groups = attributes[:'groups'] if attributes[:'groups']

  self.configured_password_policy_rules = attributes[:'configuredPasswordPolicyRules'] if attributes[:'configuredPasswordPolicyRules']

  raise 'You cannot provide both :configuredPasswordPolicyRules and :configured_password_policy_rules' if attributes.key?(:'configuredPasswordPolicyRules') && attributes.key?(:'configured_password_policy_rules')

  self.configured_password_policy_rules = attributes[:'configured_password_policy_rules'] if attributes[:'configured_password_policy_rules']
end

Instance Attribute Details

#allowed_chars ⇒ String

A String value whose contents indicate a set of characters that can appear, in any sequence, in a password value

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


501
502
503
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 501

def allowed_chars
  @allowed_chars
end

#compartment_ocid ⇒ String

OCI Compartment Id (ocid) in which the resource lives.

SCIM++ Properties: - caseExact: false - idcsSearchable: false - multiValued: false - mutability: readOnly - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


158
159
160
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 158

def compartment_ocid
  @compartment_ocid
end

#configured_password_policy_rules ⇒ Array<OCI::IdentityDomains::Models::PasswordPolicyConfiguredPasswordPolicyRules>

List of password policy rules that have values set. This map of stringKey:stringValue pairs can be used to aid users while setting/resetting password

SCIM++ Properties: - caseExact: false - idcsCompositeKey: [key] - multiValued: true - mutability: readOnly - required: false - returned: request - type: complex - uniqueness: none

Returns:



680
681
682
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 680

def configured_password_policy_rules
  @configured_password_policy_rules
end

#delete_in_progress ⇒ BOOLEAN

A boolean flag indicating this resource in the process of being deleted. Usually set to true when synchronous deletion of the resource would take too long.

SCIM++ Properties: - caseExact: false - idcsSearchable: true - multiValued: false - mutability: readOnly - required: false - returned: default - type: boolean - uniqueness: none

Returns:

  • (BOOLEAN) 


116
117
118
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 116

def delete_in_progress
  @delete_in_progress
end

#description ⇒ String

A String that describes the password policy

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


212
213
214
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 212

def description
  @description
end

#dictionary_delimiter ⇒ String

A delimiter used to separate characters in the dictionary file

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


553
554
555
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 553

def dictionary_delimiter
  @dictionary_delimiter
end

#dictionary_location ⇒ String

A Reference value that contains the URI of a dictionary of words not allowed to appear within a password value

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


540
541
542
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 540

def dictionary_location
  @dictionary_location
end

#dictionary_word_disallowed ⇒ BOOLEAN

Indicates whether the password can match a dictionary word

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: boolean - uniqueness: none

Returns:

  • (BOOLEAN) 


527
528
529
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 527

def dictionary_word_disallowed
  @dictionary_word_disallowed
end

#disallowed_chars ⇒ String

A String value whose contents indicate a set of characters that cannot appear, in any sequence, in a password value

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


488
489
490
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 488

def disallowed_chars
  @disallowed_chars
end

#disallowed_substrings ⇒ Array<String>

A String value whose contents indicate a set of substrings that cannot appear, in any sequence, in a password value

SCIM++ Properties: - caseExact: false - multiValued: true - mutability: readWrite - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (Array<String>) 


514
515
516
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 514

def disallowed_substrings
  @disallowed_substrings
end

#disallowed_user_attribute_values ⇒ Array<String>

List of User attributes whose values are not allowed in the password.

Added In: 2303212224

SCIM++ Properties: - idcsSearchable: false - multiValued: true - mutability: readWrite - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (Array<String>) 


423
424
425
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 423

def disallowed_user_attribute_values
  @disallowed_user_attribute_values
end

#distinct_characters ⇒ Integer

The number of distinct characters between old password and new password

Added In: 2303212224

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


633
634
635
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 633

def distinct_characters
  @distinct_characters
end

#domain_ocid ⇒ String

OCI Domain Id (ocid) in which the resource lives.

SCIM++ Properties: - caseExact: false - idcsSearchable: false - multiValued: false - mutability: readOnly - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


144
145
146
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 144

def domain_ocid
  @domain_ocid
end

#external_id ⇒ String

An identifier for the Resource as defined by the Service Consumer. The externalId may simplify identification of the Resource between Service Consumer and Service Provider by allowing the Consumer to refer to the Resource with its own identifier, obviating the need to store a local mapping between the local identifier of the Resource and the identifier used by the Service Provider. Each Resource MAY include a non-empty externalId value. The value of the externalId attribute is always issued by the Service Consumer and can never be specified by the Service Provider. The Service Provider MUST always interpret the externalId as scoped to the Service Consumer's tenant.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


185
186
187
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 185

def external_id
  @external_id
end

#first_name_disallowed ⇒ BOOLEAN

Indicates a sequence of characters that match the user's first name of given name cannot be the password. Password validation against policy will be ignored if length of first name is less than or equal to 3 characters.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: boolean - uniqueness: none

Returns:

  • (BOOLEAN) 


382
383
384
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 382

def first_name_disallowed
  @first_name_disallowed
end

#force_password_reset ⇒ BOOLEAN

Indicates whether all of the users should be forced to reset their password on the next login (to comply with new password policy changes)

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: writeOnly - required: false - returned: never - type: boolean - uniqueness: none

Returns:

  • (BOOLEAN) 


618
619
620
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 618

def force_password_reset
  @force_password_reset
end

#groups ⇒ Array<OCI::IdentityDomains::Models::PasswordPolicyGroups>

A list of groups that the password policy belongs to.

Added In: 20.1.3

SCIM++ Properties: - caseExact: false - idcsCompositeKey: [value] - idcsSearchable: true - multiValued: true - mutability: readWrite - required: false - returned: default - type: complex - uniqueness: none

Returns:



666
667
668
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 666

def groups
  @groups
end

#id ⇒ String

Unique identifier for the SCIM Resource as defined by the Service Provider. Each representation of the Resource MUST include a non-empty id value. This identifier MUST be unique across the Service Provider's entire set of Resources. It MUST be a stable, non-reassignable identifier that does not change when the same Resource is returned in subsequent requests. The value of the id attribute is always issued by the Service Provider and MUST never be specified by the Service Consumer. bulkId: is a reserved keyword and MUST NOT be used in the unique identifier.

SCIM++ Properties: - caseExact: false - idcsSearchable: true - multiValued: false - mutability: readOnly - required: false - returned: always - type: string - uniqueness: global

Returns:

  • (String) 


38
39
40
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 38

def id
  @id
end

#idcs_created_by ⇒ OCI::IdentityDomains::Models::IdcsCreatedBy

Returns:



72
73
74
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 72

def idcs_created_by
  @idcs_created_by
end

#idcs_last_modified_by ⇒ OCI::IdentityDomains::Models::IdcsLastModifiedBy

Returns:



75
76
77
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 75

def idcs_last_modified_by
  @idcs_last_modified_by
end

#idcs_last_upgraded_in_release ⇒ String

The release number when the resource was upgraded.

SCIM++ Properties: - caseExact: false - idcsSearchable: false - multiValued: false - mutability: readOnly - required: false - returned: request - type: string - uniqueness: none

Returns:

  • (String) 


130
131
132
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 130

def idcs_last_upgraded_in_release
  @idcs_last_upgraded_in_release
end

#idcs_prevented_operations ⇒ Array<String>

Each value of this attribute specifies an operation that only an internal client may perform on this particular resource.

SCIM++ Properties: - idcsSearchable: false - multiValued: true - mutability: readOnly - required: false - returned: request - type: string - uniqueness: none

Returns:

  • (Array<String>) 


88
89
90
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 88

def idcs_prevented_operations
  @idcs_prevented_operations
end

#last_name_disallowed ⇒ BOOLEAN

Indicates a sequence of characters that match the user's last name of given name cannot be the password. Password validation against policy will be ignored if length of last name is less than or equal to 3 characters.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: boolean - uniqueness: none

Returns:

  • (BOOLEAN) 


395
396
397
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 395

def last_name_disallowed
  @last_name_disallowed
end

#lockout_duration ⇒ Integer

The time period in minutes to lock out a user account when the threshold of invalid login attempts is reached. The available range is from 5 through 1440 minutes (24 hours).

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


579
580
581
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 579

def lockout_duration
  @lockout_duration
end

#max_incorrect_attempts ⇒ Integer

An integer that represents the maximum number of failed logins before an account is locked

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


566
567
568
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 566

def max_incorrect_attempts
  @max_incorrect_attempts
end

#max_length ⇒ Integer

The maximum password length (in characters). A value of 0 or no value indicates no maximum length restriction.

SCIM++ Properties: - caseExact: false - idcsSearchable: true - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


226
227
228
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 226

def max_length
  @max_length
end

#max_repeated_chars ⇒ Integer

The maximum number of repeated characters allowed in a password. A value of 0 or no value indicates no such restriction.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


356
357
358
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 356

def max_repeated_chars
  @max_repeated_chars
end

#max_special_chars ⇒ Integer

The maximum number of special characters in a password. A value of 0 or no value indicates no maximum special characters restriction.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


304
305
306
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 304

def max_special_chars
  @max_special_chars
end

#meta ⇒ OCI::IdentityDomains::Models::Meta

Returns:



69
70
71
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 69

def meta
  @meta
end

#min_alpha_numerals ⇒ Integer

The minimum number of a combination of alphabetic and numeric characters in a password. A value of 0 or no value indicates no minimum alphanumeric character restriction.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


278
279
280
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 278

def min_alpha_numerals
  @min_alpha_numerals
end

#min_alphas ⇒ Integer

The minimum number of alphabetic characters in a password. A value of 0 or no value indicates no minimum alphas restriction.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


252
253
254
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 252

def min_alphas
  @min_alphas
end

#min_length ⇒ Integer

The minimum password length (in characters). A value of 0 or no value indicates no minimum length restriction.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


239
240
241
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 239

def min_length
  @min_length
end

#min_lower_case ⇒ Integer

The minimum number of lowercase alphabetic characters in a password. A value of 0 or no value indicates no minimum lowercase restriction.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


317
318
319
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 317

def min_lower_case
  @min_lower_case
end

#min_numerals ⇒ Integer

The minimum number of numeric characters in a password. A value of 0 or no value indicates no minimum numeric character restriction.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


265
266
267
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 265

def min_numerals
  @min_numerals
end

#min_password_age ⇒ Integer

Minimum time after which the user can resubmit the reset password request

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


436
437
438
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 436

def min_password_age
  @min_password_age
end

#min_special_chars ⇒ Integer

The minimum number of special characters in a password. A value of 0 or no value indicates no minimum special characters restriction.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


291
292
293
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 291

def min_special_chars
  @min_special_chars
end

#min_unique_chars ⇒ Integer

The minimum number of unique characters in a password. A value of 0 or no value indicates no minimum unique characters restriction.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


343
344
345
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 343

def min_unique_chars
  @min_unique_chars
end

#min_upper_case ⇒ Integer

The minimum number of uppercase alphabetic characters in a password. A value of 0 or no value indicates no minimum uppercase restriction.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


330
331
332
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 330

def min_upper_case
  @min_upper_case
end

#name ⇒ String

[Required] A String that is the name of the policy to display to the user. This is the only mandatory attribute for a password policy.

SCIM++ Properties: - caseExact: false - idcsSearchable: true - multiValued: false - mutability: immutable - required: true - returned: always - type: string - uniqueness: server

Returns:

  • (String) 


199
200
201
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 199

def name
  @name
end

#num_passwords_in_history ⇒ Integer

The number of passwords that will be kept in history that may not be used as a password

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


592
593
594
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 592

def num_passwords_in_history
  @num_passwords_in_history
end

#ocid ⇒ String

Unique OCI identifier for the SCIM Resource.

SCIM++ Properties: - caseExact: true - idcsSearchable: true - multiValued: false - mutability: immutable - required: false - returned: default - type: string - uniqueness: global

Returns:

  • (String) 


52
53
54
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 52

def ocid
  @ocid
end

#password_expire_warning ⇒ Integer

An integer indicating the number of days before which the user should be warned about password expiry.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


462
463
464
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 462

def password_expire_warning
  @password_expire_warning
end

#password_expires_after ⇒ Integer

The number of days after which the password expires automatically

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - uniqueness: none

Returns:

  • (Integer) 


449
450
451
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 449

def password_expires_after
  @password_expires_after
end

#password_strength ⇒ String

Indicates whether the password policy is configured as Simple, Standard, or Custom.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


605
606
607
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 605

def password_strength
  @password_strength
end

#priority ⇒ Integer

Password policy priority

Added In: 20.1.3

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: integer - idcsMinValue: 1 - uniqueness: server

Returns:

  • (Integer) 


649
650
651
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 649

def priority
  @priority
end

#required_chars ⇒ String

A String value whose contents indicate a set of characters that must appear, in any sequence, in a password value

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


475
476
477
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 475

def required_chars
  @required_chars
end

#schemas ⇒ Array<String>

[Required] REQUIRED. The schemas attribute is an array of Strings which allows introspection of the supported schema version for a SCIM representation as well any schema extensions supported by that representation. Each String value must be a unique URI. This specification defines URIs for User, Group, and a standard \“enterprise\” extension. All representations of SCIM schema MUST include a non-zero value array with value(s) of the URIs supported by that representation. Duplicate values MUST NOT be included. Value order is not specified and MUST not impact behavior.

SCIM++ Properties: - caseExact: false - idcsSearchable: false - multiValued: true - mutability: readWrite - required: true - returned: default - type: string - uniqueness: none

Returns:

  • (Array<String>) 


66
67
68
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 66

def schemas
  @schemas
end

#starts_with_alphabet ⇒ BOOLEAN

Indicates that the password must begin with an alphabetic character

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: boolean - uniqueness: none

Returns:

  • (BOOLEAN) 


369
370
371
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 369

def starts_with_alphabet
  @starts_with_alphabet
end

#tags ⇒ Array<OCI::IdentityDomains::Models::Tags>

A list of tags on this resource.

SCIM++ Properties: - idcsCompositeKey: [key, value] - idcsSearchable: true - multiValued: true - mutability: readWrite - required: false - returned: request - type: complex - uniqueness: none

Returns:



102
103
104
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 102

def tags
  @tags
end

#tenancy_ocid ⇒ String

OCI Tenant Id (ocid) in which the resource lives.

SCIM++ Properties: - caseExact: false - idcsSearchable: false - multiValued: false - mutability: readOnly - required: false - returned: default - type: string - uniqueness: none

Returns:

  • (String) 


172
173
174
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 172

def tenancy_ocid
  @tenancy_ocid
end

#user_name_disallowed ⇒ BOOLEAN

Indicates a sequence of characters that match the username cannot be the password. Password validation against policy will be ignored if length of user name is less than or equal to 3 characters.

SCIM++ Properties: - caseExact: false - multiValued: false - mutability: readWrite - required: false - returned: default - type: boolean - uniqueness: none

Returns:

  • (BOOLEAN) 


408
409
410
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 408

def user_name_disallowed
  @user_name_disallowed
end

Class Method Details

.attribute_map ⇒ Object

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



683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 683

def self.attribute_map
  {
    # rubocop:disable Style/SymbolLiteral
    'id': :'id',
    'ocid': :'ocid',
    'schemas': :'schemas',
    'meta': :'meta',
    'idcs_created_by': :'idcsCreatedBy',
    'idcs_last_modified_by': :'idcsLastModifiedBy',
    'idcs_prevented_operations': :'idcsPreventedOperations',
    'tags': :'tags',
    'delete_in_progress': :'deleteInProgress',
    'idcs_last_upgraded_in_release': :'idcsLastUpgradedInRelease',
    'domain_ocid': :'domainOcid',
    'compartment_ocid': :'compartmentOcid',
    'tenancy_ocid': :'tenancyOcid',
    'external_id': :'externalId',
    'name': :'name',
    'description': :'description',
    'max_length': :'maxLength',
    'min_length': :'minLength',
    'min_alphas': :'minAlphas',
    'min_numerals': :'minNumerals',
    'min_alpha_numerals': :'minAlphaNumerals',
    'min_special_chars': :'minSpecialChars',
    'max_special_chars': :'maxSpecialChars',
    'min_lower_case': :'minLowerCase',
    'min_upper_case': :'minUpperCase',
    'min_unique_chars': :'minUniqueChars',
    'max_repeated_chars': :'maxRepeatedChars',
    'starts_with_alphabet': :'startsWithAlphabet',
    'first_name_disallowed': :'firstNameDisallowed',
    'last_name_disallowed': :'lastNameDisallowed',
    'user_name_disallowed': :'userNameDisallowed',
    'disallowed_user_attribute_values': :'disallowedUserAttributeValues',
    'min_password_age': :'minPasswordAge',
    'password_expires_after': :'passwordExpiresAfter',
    'password_expire_warning': :'passwordExpireWarning',
    'required_chars': :'requiredChars',
    'disallowed_chars': :'disallowedChars',
    'allowed_chars': :'allowedChars',
    'disallowed_substrings': :'disallowedSubstrings',
    'dictionary_word_disallowed': :'dictionaryWordDisallowed',
    'dictionary_location': :'dictionaryLocation',
    'dictionary_delimiter': :'dictionaryDelimiter',
    'max_incorrect_attempts': :'maxIncorrectAttempts',
    'lockout_duration': :'lockoutDuration',
    'num_passwords_in_history': :'numPasswordsInHistory',
    'password_strength': :'passwordStrength',
    'force_password_reset': :'forcePasswordReset',
    'distinct_characters': :'distinctCharacters',
    'priority': :'priority',
    'groups': :'groups',
    'configured_password_policy_rules': :'configuredPasswordPolicyRules'
    # rubocop:enable Style/SymbolLiteral
  }
end

.swagger_types ⇒ Object

Attribute type mapping.



742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 742

def self.swagger_types
  {
    # rubocop:disable Style/SymbolLiteral
    'id': :'String',
    'ocid': :'String',
    'schemas': :'Array<String>',
    'meta': :'OCI::IdentityDomains::Models::Meta',
    'idcs_created_by': :'OCI::IdentityDomains::Models::IdcsCreatedBy',
    'idcs_last_modified_by': :'OCI::IdentityDomains::Models::IdcsLastModifiedBy',
    'idcs_prevented_operations': :'Array<String>',
    'tags': :'Array<OCI::IdentityDomains::Models::Tags>',
    'delete_in_progress': :'BOOLEAN',
    'idcs_last_upgraded_in_release': :'String',
    'domain_ocid': :'String',
    'compartment_ocid': :'String',
    'tenancy_ocid': :'String',
    'external_id': :'String',
    'name': :'String',
    'description': :'String',
    'max_length': :'Integer',
    'min_length': :'Integer',
    'min_alphas': :'Integer',
    'min_numerals': :'Integer',
    'min_alpha_numerals': :'Integer',
    'min_special_chars': :'Integer',
    'max_special_chars': :'Integer',
    'min_lower_case': :'Integer',
    'min_upper_case': :'Integer',
    'min_unique_chars': :'Integer',
    'max_repeated_chars': :'Integer',
    'starts_with_alphabet': :'BOOLEAN',
    'first_name_disallowed': :'BOOLEAN',
    'last_name_disallowed': :'BOOLEAN',
    'user_name_disallowed': :'BOOLEAN',
    'disallowed_user_attribute_values': :'Array<String>',
    'min_password_age': :'Integer',
    'password_expires_after': :'Integer',
    'password_expire_warning': :'Integer',
    'required_chars': :'String',
    'disallowed_chars': :'String',
    'allowed_chars': :'String',
    'disallowed_substrings': :'Array<String>',
    'dictionary_word_disallowed': :'BOOLEAN',
    'dictionary_location': :'String',
    'dictionary_delimiter': :'String',
    'max_incorrect_attempts': :'Integer',
    'lockout_duration': :'Integer',
    'num_passwords_in_history': :'Integer',
    'password_strength': :'String',
    'force_password_reset': :'BOOLEAN',
    'distinct_characters': :'Integer',
    'priority': :'Integer',
    'groups': :'Array<OCI::IdentityDomains::Models::PasswordPolicyGroups>',
    'configured_password_policy_rules': :'Array<OCI::IdentityDomains::Models::PasswordPolicyConfiguredPasswordPolicyRules>'
    # rubocop:enable Style/SymbolLiteral
  }
end

Instance Method Details

#==(other) ⇒ Object

Checks equality by comparing each attribute.

Parameters:

  • other (Object) —

    the other object to be compared



1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 1174

def ==(other)
  return true if equal?(other)

  self.class == other.class &&
    id == other.id &&
    ocid == other.ocid &&
    schemas == other.schemas &&
    meta == other.meta &&
    idcs_created_by == other.idcs_created_by &&
    idcs_last_modified_by == other.idcs_last_modified_by &&
    idcs_prevented_operations == other.idcs_prevented_operations &&
    tags == other.tags &&
    delete_in_progress == other.delete_in_progress &&
    idcs_last_upgraded_in_release == other.idcs_last_upgraded_in_release &&
    domain_ocid == other.domain_ocid &&
    compartment_ocid == other.compartment_ocid &&
    tenancy_ocid == other.tenancy_ocid &&
    external_id == other.external_id &&
    name == other.name &&
    description == other.description &&
    max_length == other.max_length &&
    min_length == other.min_length &&
    min_alphas == other.min_alphas &&
    min_numerals == other.min_numerals &&
    min_alpha_numerals == other.min_alpha_numerals &&
    min_special_chars == other.min_special_chars &&
    max_special_chars == other.max_special_chars &&
    min_lower_case == other.min_lower_case &&
    min_upper_case == other.min_upper_case &&
    min_unique_chars == other.min_unique_chars &&
    max_repeated_chars == other.max_repeated_chars &&
    starts_with_alphabet == other.starts_with_alphabet &&
    first_name_disallowed == other.first_name_disallowed &&
    last_name_disallowed == other.last_name_disallowed &&
    user_name_disallowed == other.user_name_disallowed &&
    disallowed_user_attribute_values == other.disallowed_user_attribute_values &&
    min_password_age == other.min_password_age &&
    password_expires_after == other.password_expires_after &&
    password_expire_warning == other.password_expire_warning &&
    required_chars == other.required_chars &&
    disallowed_chars == other.disallowed_chars &&
    allowed_chars == other.allowed_chars &&
    disallowed_substrings == other.disallowed_substrings &&
    dictionary_word_disallowed == other.dictionary_word_disallowed &&
    dictionary_location == other.dictionary_location &&
    dictionary_delimiter == other.dictionary_delimiter &&
    max_incorrect_attempts == other.max_incorrect_attempts &&
    lockout_duration == other.lockout_duration &&
    num_passwords_in_history == other.num_passwords_in_history &&
    password_strength == other.password_strength &&
    force_password_reset == other.force_password_reset &&
    distinct_characters == other.distinct_characters &&
    priority == other.priority &&
    groups == other.groups &&
    configured_password_policy_rules == other.configured_password_policy_rules
end

#build_from_hash(attributes) ⇒ Object

Builds the object from hash

Parameters:

  • attributes (Hash) —

    Model attributes in the form of hash

Returns:

  • (Object) —

    Returns the model itself



1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 1254

def build_from_hash(attributes)
  return nil unless attributes.is_a?(Hash)

  self.class.swagger_types.each_pair do |key, type|
    if type =~ /^Array<(.*)>/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)
        public_method("#{key}=").call(
          attributes[self.class.attribute_map[key]]
            .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
        )
      end
    elsif !attributes[self.class.attribute_map[key]].nil?
      public_method("#{key}=").call(
        OCI::Internal::Util.convert_to_type(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?(other) ⇒ Boolean

Parameters:

  • other (Object) —

    the other object to be compared

Returns:

  • (Boolean)

See Also:

  • `==` method


1234
1235
1236
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 1234

def eql?(other)
  self == other
end

#hash ⇒ Fixnum

Calculates hash code according to all attributes.

Returns:

  • (Fixnum) —

    Hash code



1243
1244
1245
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 1243

def hash
  [id, ocid, schemas, meta, idcs_created_by, idcs_last_modified_by, idcs_prevented_operations, tags, delete_in_progress, idcs_last_upgraded_in_release, domain_ocid, compartment_ocid, tenancy_ocid, external_id, name, description, max_length, min_length, min_alphas, min_numerals, min_alpha_numerals, min_special_chars, max_special_chars, min_lower_case, min_upper_case, min_unique_chars, max_repeated_chars, starts_with_alphabet, first_name_disallowed, last_name_disallowed, user_name_disallowed, disallowed_user_attribute_values, min_password_age, password_expires_after, password_expire_warning, required_chars, disallowed_chars, allowed_chars, disallowed_substrings, dictionary_word_disallowed, dictionary_location, dictionary_delimiter, max_incorrect_attempts, lockout_duration, num_passwords_in_history, password_strength, force_password_reset, distinct_characters, priority, groups, configured_password_policy_rules].hash
end

#to_hash ⇒ Hash

Returns the object in the form of hash

Returns:

  • (Hash) —

    Returns the object in the form of hash



1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 1287

def to_hash
  hash = {}
  self.class.attribute_map.each_pair do |attr, param|
    value = public_method(attr).call
    next if value.nil? && !instance_variable_defined?("@#{attr}")

    hash[param] = _to_hash(value)
  end
  hash
end

#to_s ⇒ String

Returns the string representation of the object

Returns:

  • (String) —

    String presentation of the object



1281
1282
1283
 
# File 'lib/oci/identity_domains/models/password_policy.rb', line 1281

def to_s
  to_hash.to_s
end