Office365-REST-Python-Client 2.5.12__py3-none-any.whl → 2.5.14__py3-none-any.whl

office365/backuprestore/root.py

@@ -0,0 +1,39 @@
+from office365.backuprestore.service_status import ServiceStatus
+from office365.directory.protection.policy.one_drive_for_business import (
+    OneDriveForBusinessProtectionPolicy,
+)
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class BackupRestoreRoot(Entity):
+    """Represents the Microsoft 365 Backup Storage service in a tenant."""
+
+    @property
+    def service_status(self):
+        """Represents the tenant-level status of the Backup Storage service."""
+        return self.properties.get("serviceStatus", ServiceStatus())
+
+    @property
+    def one_drive_for_business_protection_policies(self):
+        """The list of OneDrive for Business restore sessions available in the tenant."""
+        return self.properties.get(
+            "oneDriveForBusinessProtectionPolicies",
+            EntityCollection(
+                self.context,
+                OneDriveForBusinessProtectionPolicy,
+                ResourcePath(
+                    "oneDriveForBusinessProtectionPolicies", self.resource_path
+                ),
+            ),
+        )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "serviceStatus": self.service_status,
+                "oneDriveForBusinessProtectionPolicies": self.one_drive_for_business_protection_policies,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(BackupRestoreRoot, self).get_property(name, default_value)

office365/backuprestore/service_status.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class ServiceStatus(ClientValue):
+    """Represents the tenant-level service status of the backup service."""

office365/booking/business/business.py

@@ -46,6 +46,19 @@ class BookingBusiness(Entity):
         self.context.add_query(qry)
         return return_type
 
+    def publish(self):
+        """
+        Make the scheduling page of a business available to external customers.
+
+        Set the isPublished property to true, and the publicUrl property to the URL of the scheduling page.
+        """
+        qry = ServiceOperationQuery(
+            self,
+            "publish",
+        )
+        self.context.add_query(qry)
+        return self
+
     @property
     def address(self):
         """

office365/booking/business/collection.py

@@ -1,5 +1,8 @@
+from typing import Optional
+
 from office365.booking.business.business import BookingBusiness
 from office365.entity_collection import EntityCollection
+from office365.outlook.mail.physical_address import PhysicalAddress
 
 
 class BookingBusinessCollection(EntityCollection[BookingBusiness]):
@@ -10,12 +13,13 @@ class BookingBusinessCollection(EntityCollection[BookingBusiness]):
             context, BookingBusiness, resource_path
         )
 
-    def add(self, display_name):
+    def add(self, display_name, address=None, email=None):
+        # type: (str, Optional[PhysicalAddress], Optional[str]) -> BookingBusiness
         """
         Create a new Microsoft Bookings business in a tenant.
         :param str display_name: The business display name.
+        :param PhysicalAddress address: The business display name.
+        :param str email: The email address for the business.
         """
-        props = {
-            "displayName": display_name,
-        }
+        props = {"displayName": display_name, "address": address, "email": email}
         return super(BookingBusinessCollection, self).add(**props)

office365/booking/solutions/root.py

@@ -1,3 +1,4 @@
+from office365.backuprestore.root import BackupRestoreRoot
 from office365.booking.business.collection import BookingBusinessCollection
 from office365.booking.currency import BookingCurrency
 from office365.entity import Entity
@@ -6,7 +7,7 @@ from office365.runtime.paths.resource_path import ResourcePath
 
 
 class SolutionsRoot(Entity):
-    """"""
+    """The entry point for Microsoft Bookings, virtual event, and business scenario APIs."""
 
     @property
     def booking_businesses(self):
@@ -31,11 +32,23 @@ class SolutionsRoot(Entity):
             ),
         )
 
+    @property
+    def backup_restore(self):
+        # type: () -> BackupRestoreRoot
+        """Get a Microsoft 365 Backup Storage service in a tenant"""
+        return self.properties.get(
+            "backupRestore",
+            BackupRestoreRoot(
+                self.context, ResourcePath("backupRestore", self.resource_path)
+            ),
+        )
+
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_mapping = {
                 "bookingBusinesses": self.booking_businesses,
                 "bookingCurrencies": self.booking_currencies,
+                "backupRestore": self.backup_restore,
             }
             default_value = property_mapping.get(name, None)
         return super(SolutionsRoot, self).get_property(name, default_value)

office365/communications/callrecords/collection.py

@@ -0,0 +1,42 @@
+from datetime import datetime, timedelta
+
+from office365.communications.callrecords.call_record import CallRecord
+from office365.communications.callrecords.direct_routing_log_row import (
+    DirectRoutingLogRow,
+)
+from office365.entity_collection import EntityCollection
+from office365.runtime.client_result import ClientResult
+from office365.runtime.client_value_collection import ClientValueCollection
+from office365.runtime.queries.function import FunctionQuery
+
+
+class CallRecordCollection(EntityCollection[CallRecord]):
+    def __init__(self, context, resource_path=None):
+        super(CallRecordCollection, self).__init__(context, CallRecord, resource_path)
+
+    def get_direct_routing_calls(self, from_datetime=None, to_datetime=None):
+        """
+        Get a log of direct routing calls as a collection of directRoutingLogRow entries.
+        :param datetime from_datetime: Start of time range to query.
+        :param datetime to_datetime: End of time range to query
+        """
+        if to_datetime is None:
+            to_datetime = datetime.now()
+
+        if from_datetime is None:
+            from_datetime = to_datetime - timedelta(days=30)
+
+        return_type = ClientResult(
+            self.context, ClientValueCollection(DirectRoutingLogRow)
+        )
+        payload = {
+            "fromDateTime": from_datetime.strftime("%Y-%m-%d"),
+            "toDateTime": to_datetime.strftime("%Y-%m-%d"),
+        }
+        qry = FunctionQuery(self, "getDirectRoutingCalls", payload, return_type)
+
+        def _patch_request(request):
+            request.url = request.url.replace("'", "")
+
+        self.context.add_query(qry).before_query_execute(_patch_request)
+        return return_type

office365/communications/callrecords/direct_routing_log_row.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class DirectRoutingLogRow(ClientValue):
+    """Represents a row of data in the direct routing call log. Each row maps to one call."""

office365/communications/cloud_communications.py

@@ -1,4 +1,4 @@
-from office365.communications.callrecords.call_record import CallRecord
+from office365.communications.callrecords.collection import CallRecordCollection
 from office365.communications.calls.collection import CallCollection
 from office365.communications.onlinemeetings.collection import OnlineMeetingCollection
 from office365.communications.presences.presence import Presence
@@ -37,9 +37,8 @@ class CloudCommunications(Entity):
         """ " """
         return self.properties.get(
             "callRecords",
-            EntityCollection(
+            CallRecordCollection(
                 self.context,
-                CallRecord,
                 ResourcePath("callRecords", self.resource_path),
             ),
         )

office365/directory/applications/application.py

@@ -3,7 +3,11 @@ import datetime
 from typing import Optional
 
 from office365.directory.applications.api import ApiApplication
+from office365.directory.applications.optional_claims import OptionalClaims
 from office365.directory.applications.public_client import PublicClientApplication
+from office365.directory.applications.required_resource_access import (
+    RequiredResourceAccess,
+)
 from office365.directory.applications.roles.role import AppRole
 from office365.directory.applications.spa import SpaApplication
 from office365.directory.certificates.certification import Certification
@@ -52,7 +56,7 @@ class Application(DirectoryObject):
         :param datetime.datetime end_datetime: The date and time at which the credential expires. Default: now + 180days
         """
         if start_datetime is None:
-            start_datetime = datetime.datetime.utcnow()
+            start_datetime = datetime.datetime.now()
         if end_datetime is None:
             end_datetime = start_datetime + datetime.timedelta(days=180)
 
@@ -227,7 +231,7 @@ class Application(DirectoryObject):
     @property
     def key_credentials(self):
         """The collection of key credentials associated with the application. Not nullable."""
-        self._ser_property_names.append("keyCredentials")
+        self._properties_to_persist.append("keyCredentials")
         return self.properties.setdefault(
             "keyCredentials", ClientValueCollection(KeyCredential)
         )
@@ -250,6 +254,20 @@ class Application(DirectoryObject):
         """
         return self.properties.get("identifierUris", StringCollection())
 
+    @property
+    def optional_claims(self):
+        """Application developers can configure optional claims in their Microsoft Entra applications to specify
+        the claims that are sent to their application by the Microsoft security token service.
+        """
+        return self.properties.get("optionalClaims", OptionalClaims())
+
+    @property
+    def password_credentials(self):
+        """The collection of password credentials associated with the application"""
+        return self.properties.get(
+            "passwordCredentials", ClientValueCollection(PasswordCredential)
+        )
+
     @property
     def public_client(self):
         """Specifies settings for installed clients such as desktop or mobile devices."""
@@ -300,6 +318,16 @@ class Application(DirectoryObject):
             ),
         )
 
+    @property
+    def required_resource_access(self):
+        """Specifies the resources that the application needs to access. This property also specifies the set
+        of delegated permissions and application roles that it needs for each of those resources.
+        This configuration of access to the required resources drives the consent experience.
+        """
+        return self.properties.get(
+            "requiredResourceAccess", ClientValueCollection(RequiredResourceAccess)
+        )
+
     @property
     def token_issuance_policies(self):
         # type: () -> EntityCollection[TokenIssuancePolicy]
@@ -321,7 +349,10 @@ class Application(DirectoryObject):
                 "createdOnBehalfOf": self.created_on_behalf_of,
                 "extensionProperties": self.extension_properties,
                 "keyCredentials": self.key_credentials,
+                "optionalClaims": self.optional_claims,
+                "passwordCredentials": self.password_credentials,
                 "publicClient": self.public_client,
+                "requiredResourceAccess": self.required_resource_access,
                 "tokenIssuancePolicies": self.token_issuance_policies,
             }
             default_value = property_mapping.get(name, None)

office365/directory/applications/optional_claim.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class OptionalClaim(ClientValue):
+    """Contains an optional claim associated with an application"""

office365/directory/applications/optional_claims.py

@@ -0,0 +1,16 @@
+from office365.directory.applications.optional_claim import OptionalClaim
+from office365.runtime.client_value import ClientValue
+from office365.runtime.client_value_collection import ClientValueCollection
+
+
+class OptionalClaims(ClientValue):
+    """An application can configure optional claims to be returned in each of three types of tokens
+    (ID token, access token, SAML 2 token) it can receive from the security token service.
+    An application can configure a different set of optional claims to be returned in each token type.
+    The optionalClaims property of the application is an optionalClaims object."""
+
+    def __init__(self, access_token=None, id_token=None, saml2_token=None):
+        """ """
+        self.accessToken = ClientValueCollection(OptionalClaim, access_token)
+        self.idToken = ClientValueCollection(OptionalClaim, id_token)
+        self.saml2Token = ClientValueCollection(OptionalClaim, saml2_token)

office365/directory/applications/required_resource_access.py

@@ -0,0 +1,23 @@
+from office365.directory.applications.resource_access import ResourceAccess
+from office365.runtime.client_value import ClientValue
+from office365.runtime.client_value_collection import ClientValueCollection
+
+
+class RequiredResourceAccess(ClientValue):
+    """Specifies the set of OAuth 2.0 permission scopes and app roles under the specified resource that an
+    application requires access to. The application may request the specified OAuth 2.0 permission scopes or app
+    roles through the requiredResourceAccess property, which is a collection of requiredResourceAccess objects.
+    """
+
+    def __init__(self, resource_access=None, resource_app_id=None):
+        """
+        :param list[ResourceAccess] resource_access: The list of OAuth2.0 permission scopes and app roles that
+             the application requires from the specified resource.
+        :param str resource_app_id: The unique identifier for the resource that the application requires access to.
+             This should be equal to the appId declared on the target resource application.
+        """
+        self.resourceAccess = ClientValueCollection(ResourceAccess, resource_access)
+        self.resourceAppId = resource_app_id
+
+    def __repr__(self):
+        return self.resourceAppId or self.entity_type_name

office365/directory/applications/resource_access.py

@@ -0,0 +1,26 @@
+from office365.runtime.client_value import ClientValue
+
+
+class ResourceAccess(ClientValue):
+    """Object used to specify an OAuth 2.0 permission scope or an app role that an application requires,
+    through the resourceAccess property of the requiredResourceAccess resource type."""
+
+    def __init__(self, id_=None, type_=None):
+        """
+        :param str id_: The unique identifier of an app role or delegated permission exposed by the resource
+            application. For delegated permissions, this should match the id property of one of the delegated
+            permissions in the oauth2PermissionScopes collection of the resource application's service principal.
+            For app roles (application permissions), this should match the id property of an app role in the appRoles
+            collection of the resource application's service principal.
+        :param str type_: Specifies whether the id property references a delegated permission or an app role
+            (application permission). The possible values are: Scope (for delegated permissions) or Role (for app roles).
+        """
+        self.id = id_
+        self.type = type_
+
+    def __repr__(self):
+        return "ResourceAccess(id={!r}, type={!r})".format(self.id, self.type)
+
+    @property
+    def type_name(self):
+        return "Delegated" if self.type == "Scope" else "Application"

office365/directory/authentication/conditions/event_listener.py

@@ -0,0 +1,9 @@
+from office365.entity import Entity
+
+
+class AuthenticationEventListener(Entity):
+    """
+    Defines a listener to evaluate when an authentication event happens in an authentication experience.
+    An authenticationListener is abstract and is the base class of the various types of listeners you can evaluate
+    during an authentication event.
+    """

office365/directory/authentication/methods/details.py

@@ -54,6 +54,32 @@ class UserRegistrationDetails(Entity):
         """
         return self.properties.get("isSsprEnabled", None)
 
+    @property
+    def user_display_name(self):
+        # type: () -> Optional[str]
+        """
+        The user display name, such as Adele Vance. Supports $filter (eq, startsWith) and $orderby.
+        """
+        return self.properties.get("userDisplayName", None)
+
+    @property
+    def user_preferred_method_for_secondary_authentication(self):
+        # type: () -> Optional[str]
+        """
+        The method the user selected as the default second-factor for performing multifactor authentication.
+        """
+        return self.properties.get(
+            "userPreferredMethodForSecondaryAuthentication", None
+        )
+
+    @property
+    def user_principal_name(self):
+        # type: () -> Optional[str]
+        """
+        The user principal name, such as AdeleV@contoso.com. Supports $filter (eq, startsWith) and $orderby.
+        """
+        return self.properties.get("userPrincipalName", None)
+
     @property
     def user_type(self):
         # type: () -> Optional[str]
@@ -62,3 +88,6 @@ class UserRegistrationDetails(Entity):
         The possible values are: member, guest, unknownFutureValue.
         """
         return self.properties.get("userType", None)
+
+    def __repr__(self):
+        return self.user_principal_name or self.id or self.entity_type_name

office365/directory/authentication/methods/root.py

@@ -32,3 +32,11 @@ class AuthenticationMethodsRoot(Entity):
                 ResourcePath("userRegistrationDetails", self.resource_path),
             ),
         )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "userRegistrationDetails": self.user_registration_details
+            }
+            default_value = property_mapping.get(name, None)
+        return super(AuthenticationMethodsRoot, self).get_property(name, default_value)

office365/directory/device_local_credential_info.py

@@ -1,6 +1,27 @@
+from datetime import datetime
+from typing import Optional
+
 from office365.entity import Entity
 
 
 class DeviceLocalCredentialInfo(Entity):
     """Represents local administrator credential information for all device objects in Azure Active Directory
     that are enabled with Local Admin Password Solution (LAPS)."""
+
+    @property
+    def device_name(self):
+        # type: () -> Optional[str]
+        """
+        Display name of the device that the local credentials are associated with.
+        """
+        return self.properties.get("deviceName", None)
+
+    @property
+    def last_backup_datetime(self):
+        """When the local administrator account credential was backed up to Azure Active Directory."""
+        return self.properties.get("lastBackupDateTime", datetime.min)
+
+    @property
+    def refresh_datetime(self):
+        """When the local administrator account credential will be refreshed and backed up to Azure Active Directory."""
+        return self.properties.get("refreshDateTime", datetime.min)

office365/directory/identities/container.py

@@ -1,3 +1,6 @@
+from office365.directory.authentication.conditions.event_listener import (
+    AuthenticationEventListener,
+)
 from office365.directory.identities.api_connector import IdentityApiConnector
 from office365.directory.identities.conditional_access_root import ConditionalAccessRoot
 from office365.directory.identities.providers.base_collection import (
@@ -18,6 +21,7 @@ class IdentityContainer(Entity):
 
     @property
     def api_connectors(self):
+        # type: () -> EntityCollection[IdentityApiConnector]
         """Represents entry point for API connectors."""
         return self.properties.get(
             "apiConnectors",
@@ -28,6 +32,19 @@ class IdentityContainer(Entity):
             ),
         )
 
+    @property
+    def authentication_event_listeners(self):
+        # type: () -> EntityCollection[AuthenticationEventListener]
+        """Get the collection of authenticationListener resources supported by the onSignupStart event."""
+        return self.properties.get(
+            "authenticationEventListeners",
+            EntityCollection(
+                self.context,
+                AuthenticationEventListener,
+                ResourcePath("authenticationEventListeners", self.resource_path),
+            ),
+        )
+
     @property
     def conditional_access(self):
         """The entry point for the Conditional Access (CA) object model."""
@@ -76,6 +93,7 @@ class IdentityContainer(Entity):
         if default_value is None:
             property_mapping = {
                 "apiConnectors": self.api_connectors,
+                "authenticationEventListeners": self.authentication_event_listeners,
                 "b2xUserFlows": self.b2x_user_flows,
                 "conditionalAccess": self.conditional_access,
                 "identityProviders": self.identity_providers,

office365/directory/permissions/scope.py

@@ -15,8 +15,13 @@ class PermissionScope(ClientValue):
         self,
         admin_consent_display_name=None,
         admin_consent_description=None,
-        _id=None,
+        id_=None,
         is_enabled=None,
+        origin=None,
+        type_=None,
+        user_consent_description=None,
+        user_consent_display_name=None,
+        value=None,
     ):
         """
         :param str admin_consent_display_name: The permission's title, intended to be read by an administrator granting
@@ -24,13 +29,20 @@ class PermissionScope(ClientValue):
         :param str admin_consent_description: A description of the delegated permissions, intended to be read
             by an administrator granting the permission on behalf of all users. This text appears in tenant-wide
             admin consent experiences.
-        :param str _id: Unique delegated permission identifier inside the collection of delegated permissions defined
+        :param str id_: Unique delegated permission identifier inside the collection of delegated permissions defined
             for a resource application.
         :param str is_enabled: When creating or updating a permission, this property must be set to true
             (which is the default). To delete a permission, this property must first be set to false.
             At that point, in a subsequent call, the permission may be removed.
+
+        :param str value: Specifies the value to include in the scp (scope) claim in access tokens.
         """
         self.adminConsentDescription = admin_consent_description
         self.adminConsentDisplayName = admin_consent_display_name
-        self.id = _id
+        self.id = id_
         self.isEnabled = is_enabled
+        self.origin = origin
+        self.type = type_
+        self.userConsentDescription = user_consent_description
+        self.userConsentDisplayName = user_consent_display_name
+        self.value = value

office365/directory/policies/authentication_flows.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from office365.entity import Entity
 
 
@@ -7,3 +9,9 @@ class AuthenticationFlowsPolicy(Entity):
     users request to sign up for approval. It contains information, such as the identifier, display name, and
     description, and indicates whether self-service sign-up is enabled for the policy.
     """
+
+    @property
+    def display_name(self):
+        # type: () -> Optional[str]
+        """The human-readable name of the policy."""
+        return self.properties.get("displayName", None)

office365/directory/policies/authentication_strength.py

@@ -1,9 +1,13 @@
 from office365.directory.authentication.strength_usage import (
     AuthenticationStrengthUsage,
 )
+from office365.directory.policies.update_allowed_combinations_result import (
+    UpdateAllowedCombinationsResult,
+)
 from office365.entity import Entity
 from office365.runtime.client_result import ClientResult
 from office365.runtime.queries.function import FunctionQuery
+from office365.runtime.queries.service_operation import ServiceOperationQuery
 
 
 class AuthenticationStrengthPolicy(Entity):
@@ -26,3 +30,20 @@ class AuthenticationStrengthPolicy(Entity):
         qry = FunctionQuery(self, "usage", None, return_type)
         self.context.add_query(qry)
         return return_type
+
+    def update_allowed_combinations(self, allowed_combinations=None):
+        """
+        Update the allowedCombinations property of an authenticationStrengthPolicy object.
+        To update other properties of an authenticationStrengthPolicy object,
+        use the Update authenticationStrengthPolicy method.
+
+        :param list[str] allowed_combinations: The authentication method combinations allowed by this authentication
+             strength policy.
+        """
+        return_type = ClientResult(self.context, UpdateAllowedCombinationsResult())
+        payload = {"allowedCombinations": allowed_combinations}
+        qry = ServiceOperationQuery(
+            self, "updateAllowedCombinations", None, payload, None, return_type
+        )
+        self.context.add_query(qry)
+        return return_type

office365/directory/policies/root.py

@@ -13,6 +13,9 @@ from office365.directory.policies.cross_tenant_access import CrossTenantAccessPo
 from office365.directory.policies.device_registration import DeviceRegistrationPolicy
 from office365.directory.policies.permission_grant import PermissionGrantPolicy
 from office365.directory.policies.tenant_app_management import TenantAppManagementPolicy
+from office365.directory.policies.unified_role_management import (
+    UnifiedRoleManagementPolicy,
+)
 from office365.entity import Entity
 from office365.entity_collection import EntityCollection
 from office365.runtime.paths.resource_path import ResourcePath
@@ -162,6 +165,19 @@ class PolicyRoot(Entity):
             ),
         )
 
+    @property
+    def role_management_policies(self):
+        # type: () -> EntityCollection[UnifiedRoleManagementPolicy]
+        """Specifies the various policies associated with scopes and roles."""
+        return self.properties.get(
+            "roleManagementPolicies",
+            EntityCollection(
+                self.context,
+                UnifiedRoleManagementPolicy,
+                ResourcePath("roleManagementPolicies", self.resource_path),
+            ),
+        )
+
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_mapping = {
@@ -176,6 +192,7 @@ class PolicyRoot(Entity):
                 "defaultAppManagementPolicy": self.default_app_management_policy,
                 "deviceRegistrationPolicy": self.device_registration_policy,
                 "permissionGrantPolicies": self.permission_grant_policies,
+                "roleManagementPolicies": self.role_management_policies,
             }
             default_value = property_mapping.get(name, None)
         return super(PolicyRoot, self).get_property(name, default_value)

office365/directory/policies/unified_role_management.py

@@ -0,0 +1,7 @@
+from office365.entity import Entity
+
+
+class UnifiedRoleManagementPolicy(Entity):
+    """Specifies the various policies associated with scopes and roles.
+    For policies that apply to Azure RBAC, use the Azure REST PIM API for role management policies.
+    """

office365/directory/policies/update_allowed_combinations_result.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class UpdateAllowedCombinationsResult(ClientValue):
+    """ """

office365/directory/protection/policy/base.py

@@ -0,0 +1,24 @@
+from office365.directory.permissions.identity_set import IdentitySet
+from office365.entity import Entity
+
+
+class ProtectionPolicyBase(Entity):
+    """
+    Contains details about protection policies applied to Microsoft 365 data in an organization.
+    Protection policies are defined by the Global Admin (or the SharePoint Online Admin or Exchange Online Admin)
+    and include what data to protect, when to protect it, and for what time period to retain the protected data
+    for a single Microsoft 365 service.
+    """
+
+    @property
+    def created_by(self):
+        """Identity of the user, device, or application which created the item."""
+        return self.properties.get("createdBy", IdentitySet())
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "createdBy": self.created_by,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(ProtectionPolicyBase, self).get_property(name, default_value)