Merge develop branch. Release v2.0.0

Merge develop branch. Release SDK v2.0.0

CHANGELOG.md

@@ -1,5 +1,46 @@
 # Okta Python SDK Changelog
 
+## v2.0.0
+- Regenerate code using the [open API spec v2.5.0](https://github.com/okta/okta-management-openapi-spec/releases/tag/openapi-2.5.0).
+- Make sign_on_mode of all apps instance of enum, issue #198 (this change might be not compatible with custom clients code, although probability is low)
+- Add response headers to OktaAPIResponse object, issue #218
+
+_New resources:_
+* Domain
+* UserSchema
+
+_New models:_
+* DnsRecord
+* DnsRecordType
+* Domain
+* DomainCertificate
+* DomainCertificateMetadata
+* DomainCertificateSourceType
+* DomainCertificateType
+* DomainListResponse
+* DomainValidationStatus
+* UserSchemaAttributeEnum
+* UserSchemaAttributeItems
+* UserSchemaAttributeMasterPriority
+* UserSchemaAttributeMasterType
+* UserSchemaAttributeScope
+* UserSchemaAttributeType
+* UserSchemaAttributeUnion
+* UserSchemaProperties
+* UserSchemaPropertiesProfile
+* UserSchemaPropertiesProfileItem
+
+### Breaking changes
+Previously, the type of `sign_on_mode` attribute was inconsistent among different applications. While some applications, including the generic application, defined this attribute as string, others defined it as `ApplicationSignOnMode`.
+
+We have now standardized the sign_on_mode attribute making its type an ApplicationSignOnMode. Thus, code like the following, which was working previously, won't provide desired result:
+
+```py
+# if sign_on_mode is not an ApplicationSignOnMode type, then it should be string; but now all sign_on_modes are of type ApplicationSignOnMode
+if not isinstance(app.sign_on_mode, ApplicationSignOnMode):
+    do_some_stuff()
+```
+
 ## v1.7.0
 - Regenerate code using the [open API spec v2.4.0](https://github.com/okta/okta-management-openapi-spec/releases/tag/openapi-2.4.0).
 - Fix case issue with user custom attributes, issue #202.

okta/__init__.py

@@ -1 +1 @@
-__version__ = '1.7.0'
+__version__ = '2.0.0'

okta/models/__init__.py

@@ -150,6 +150,8 @@
 CustomHotpUserFactorProfile = custom_hotp_user_factor_profile.CustomHotpUserFactorProfile
 from okta.models import dns_record as dns_record
 DnsRecord = dns_record.DnsRecord
+from okta.models import dns_record_type as dns_record_type
+DnsRecordType = dns_record_type.DnsRecordType
 from okta.models import device_policy_rule_condition as device_policy_rule_condition
 DevicePolicyRuleCondition = device_policy_rule_condition.DevicePolicyRuleCondition
 from okta.models import device_policy_rule_condition_platform as device_policy_rule_condition_platform
@@ -160,12 +162,14 @@
 DomainCertificate = domain_certificate.DomainCertificate
 from okta.models import domain_certificate_metadata as domain_certificate_metadata
 DomainCertificateMetadata = domain_certificate_metadata.DomainCertificateMetadata
-from okta.models import domain_links as domain_links
-DomainLinks = domain_links.DomainLinks
+from okta.models import domain_certificate_source_type as domain_certificate_source_type
+DomainCertificateSourceType = domain_certificate_source_type.DomainCertificateSourceType
+from okta.models import domain_certificate_type as domain_certificate_type
+DomainCertificateType = domain_certificate_type.DomainCertificateType
 from okta.models import domain_list_response as domain_list_response
 DomainListResponse = domain_list_response.DomainListResponse
-from okta.models import domain_response as domain_response
-DomainResponse = domain_response.DomainResponse
+from okta.models import domain_validation_status as domain_validation_status
+DomainValidationStatus = domain_validation_status.DomainValidationStatus
 from okta.models import duration as duration
 Duration = duration.Duration
 from okta.models import email_user_factor as email_user_factor
@@ -690,16 +694,36 @@
 UserSchema = user_schema.UserSchema
 from okta.models import user_schema_attribute as user_schema_attribute
 UserSchemaAttribute = user_schema_attribute.UserSchemaAttribute
+from okta.models import user_schema_attribute_enum as user_schema_attribute_enum
+UserSchemaAttributeEnum = user_schema_attribute_enum.UserSchemaAttributeEnum
+from okta.models import user_schema_attribute_items as user_schema_attribute_items
+UserSchemaAttributeItems = user_schema_attribute_items.UserSchemaAttributeItems
 from okta.models import user_schema_attribute_master as user_schema_attribute_master
 UserSchemaAttributeMaster = user_schema_attribute_master.UserSchemaAttributeMaster
+from okta.models import user_schema_attribute_master_priority as user_schema_attribute_master_priority
+UserSchemaAttributeMasterPriority = user_schema_attribute_master_priority.UserSchemaAttributeMasterPriority
+from okta.models import user_schema_attribute_master_type as user_schema_attribute_master_type
+UserSchemaAttributeMasterType = user_schema_attribute_master_type.UserSchemaAttributeMasterType
 from okta.models import user_schema_attribute_permission as user_schema_attribute_permission
 UserSchemaAttributePermission = user_schema_attribute_permission.UserSchemaAttributePermission
+from okta.models import user_schema_attribute_scope as user_schema_attribute_scope
+UserSchemaAttributeScope = user_schema_attribute_scope.UserSchemaAttributeScope
+from okta.models import user_schema_attribute_type as user_schema_attribute_type
+UserSchemaAttributeType = user_schema_attribute_type.UserSchemaAttributeType
+from okta.models import user_schema_attribute_union as user_schema_attribute_union
+UserSchemaAttributeUnion = user_schema_attribute_union.UserSchemaAttributeUnion
 from okta.models import user_schema_base as user_schema_base
 UserSchemaBase = user_schema_base.UserSchemaBase
 from okta.models import user_schema_base_properties as user_schema_base_properties
 UserSchemaBaseProperties = user_schema_base_properties.UserSchemaBaseProperties
 from okta.models import user_schema_definitions as user_schema_definitions
 UserSchemaDefinitions = user_schema_definitions.UserSchemaDefinitions
+from okta.models import user_schema_properties as user_schema_properties
+UserSchemaProperties = user_schema_properties.UserSchemaProperties
+from okta.models import user_schema_properties_profile as user_schema_properties_profile
+UserSchemaPropertiesProfile = user_schema_properties_profile.UserSchemaPropertiesProfile
+from okta.models import user_schema_properties_profile_item as user_schema_properties_profile_item
+UserSchemaPropertiesProfileItem = user_schema_properties_profile_item.UserSchemaPropertiesProfileItem
 from okta.models import user_schema_public as user_schema_public
 UserSchemaPublic = user_schema_public.UserSchemaPublic
 from okta.models import user_status as user_status

okta/models/dns_record.py

@@ -20,6 +20,8 @@
 
 from okta.okta_object import OktaObject
 from okta.okta_collection import OktaCollection
+from okta.models import dns_record_type\
+    as dns_record_type
 
 
 class DnsRecord(
@@ -32,23 +34,37 @@ class DnsRecord(
     def __init__(self, config=None):
         super().__init__(config)
         if config:
+            self.expiration = config["expiration"]\
+                if "expiration" in config else None
             self.fqdn = config["fqdn"]\
                 if "fqdn" in config else None
-            self.record_type = config["recordType"]\
-                if "recordType" in config else None
+            if "recordType" in config:
+                if isinstance(config["recordType"],
+                              dns_record_type.DnsRecordType):
+                    self.record_type = config["recordType"]
+                elif config["recordType"] is not None:
+                    self.record_type = dns_record_type.DnsRecordType(
+                        config["recordType"].upper()
+                    )
+                else:
+                    self.record_type = None
+            else:
+                self.record_type = None
             self.values = OktaCollection.form_list(
                 config["values"] if "values"\
                     in config else [],
                 str
             )
         else:
+            self.expiration = None
             self.fqdn = None
             self.record_type = None
             self.values = []
 
     def request_format(self):
         parent_req_format = super().request_format()
         current_obj_format = {
+            "expiration": self.expiration,
             "fqdn": self.fqdn,
             "recordType": self.record_type,
             "values": self.values

okta/models/dns_record_type.py

@@ -0,0 +1,33 @@
+# flake8: noqa
+"""
+Copyright 2020 - Present Okta, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+# AUTO-GENERATED! DO NOT EDIT FILE DIRECTLY
+# SEE CONTRIBUTOR DOCUMENTATION
+
+from aenum import MultiValueEnum
+
+
+class DnsRecordType(
+    str,
+    MultiValueEnum
+):
+    """
+    An enumeration class for DnsRecordType.
+    """
+
+    TXT = "TXT", "txt"
+    CNAME = "CNAME", "cname"

okta/models/domain.py

@@ -19,6 +19,15 @@
 # SEE CONTRIBUTOR DOCUMENTATION
 
 from okta.okta_object import OktaObject
+from okta.okta_collection import OktaCollection
+from okta.models import domain_certificate_source_type\
+    as domain_certificate_source_type
+from okta.models import dns_record\
+    as dns_record
+from okta.models import domain_certificate_metadata\
+    as domain_certificate_metadata
+from okta.models import domain_validation_status\
+    as domain_validation_status
 
 
 class Domain(
@@ -31,19 +40,68 @@ class Domain(
     def __init__(self, config=None):
         super().__init__(config)
         if config:
-            self.certificate_sourcetype = config["certificateSourcetype"]\
-                if "certificateSourcetype" in config else None
+            if "certificateSourcetype" in config:
+                if isinstance(config["certificateSourcetype"],
+                              domain_certificate_source_type.DomainCertificateSourceType):
+                    self.certificate_sourcetype = config["certificateSourcetype"]
+                elif config["certificateSourcetype"] is not None:
+                    self.certificate_sourcetype = domain_certificate_source_type.DomainCertificateSourceType(
+                        config["certificateSourcetype"].upper()
+                    )
+                else:
+                    self.certificate_sourcetype = None
+            else:
+                self.certificate_sourcetype = None
+            self.dns_records = OktaCollection.form_list(
+                config["dnsRecords"] if "dnsRecords"\
+                    in config else [],
+                dns_record.DnsRecord
+            )
             self.domain = config["domain"]\
                 if "domain" in config else None
+            self.id = config["id"]\
+                if "id" in config else None
+            if "publicCertificate" in config:
+                if isinstance(config["publicCertificate"],
+                              domain_certificate_metadata.DomainCertificateMetadata):
+                    self.public_certificate = config["publicCertificate"]
+                elif config["publicCertificate"] is not None:
+                    self.public_certificate = domain_certificate_metadata.DomainCertificateMetadata(
+                        config["publicCertificate"]
+                    )
+                else:
+                    self.public_certificate = None
+            else:
+                self.public_certificate = None
+            if "validationStatus" in config:
+                if isinstance(config["validationStatus"],
+                              domain_validation_status.DomainValidationStatus):
+                    self.validation_status = config["validationStatus"]
+                elif config["validationStatus"] is not None:
+                    self.validation_status = domain_validation_status.DomainValidationStatus(
+                        config["validationStatus"].upper()
+                    )
+                else:
+                    self.validation_status = None
+            else:
+                self.validation_status = None
         else:
             self.certificate_sourcetype = None
+            self.dns_records = []
             self.domain = None
+            self.id = None
+            self.public_certificate = None
+            self.validation_status = None
 
     def request_format(self):
         parent_req_format = super().request_format()
         current_obj_format = {
             "certificateSourcetype": self.certificate_sourcetype,
-            "domain": self.domain
+            "dnsRecords": self.dns_records,
+            "domain": self.domain,
+            "id": self.id,
+            "publicCertificate": self.public_certificate,
+            "validationStatus": self.validation_status
         }
         parent_req_format.update(current_obj_format)
         return parent_req_format

okta/models/domain_certificate.py

@@ -19,6 +19,8 @@
 # SEE CONTRIBUTOR DOCUMENTATION
 
 from okta.okta_object import OktaObject
+from okta.models import domain_certificate_type\
+    as domain_certificate_type
 
 
 class DomainCertificate(
@@ -37,8 +39,18 @@ def __init__(self, config=None):
                 if "certificateChain" in config else None
             self.private_key = config["privateKey"]\
                 if "privateKey" in config else None
-            self.type = config["type"]\
-                if "type" in config else None
+            if "type" in config:
+                if isinstance(config["type"],
+                              domain_certificate_type.DomainCertificateType):
+                    self.type = config["type"]
+                elif config["type"] is not None:
+                    self.type = domain_certificate_type.DomainCertificateType(
+                        config["type"].upper()
+                    )
+                else:
+                    self.type = None
+            else:
+                self.type = None
         else:
             self.certificate = None
             self.certificate_chain = None

okta/models/domain_certificate_source_type.py

@@ -0,0 +1,32 @@
+# flake8: noqa
+"""
+Copyright 2020 - Present Okta, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+# AUTO-GENERATED! DO NOT EDIT FILE DIRECTLY
+# SEE CONTRIBUTOR DOCUMENTATION
+
+from aenum import MultiValueEnum
+
+
+class DomainCertificateSourceType(
+    str,
+    MultiValueEnum
+):
+    """
+    An enumeration class for DomainCertificateSourceType.
+    """
+
+    MANUAL = "MANUAL", "manual"

okta/models/domain_certificate_type.py

@@ -0,0 +1,32 @@
+# flake8: noqa
+"""
+Copyright 2020 - Present Okta, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+# AUTO-GENERATED! DO NOT EDIT FILE DIRECTLY
+# SEE CONTRIBUTOR DOCUMENTATION
+
+from aenum import MultiValueEnum
+
+
+class DomainCertificateType(
+    str,
+    MultiValueEnum
+):
+    """
+    An enumeration class for DomainCertificateType.
+    """
+
+    PEM = "PEM", "pem"