Office365-REST-Python-Client 2.5.11__py3-none-any.whl → 2.5.13__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/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/directory/applications/application.py

@@ -3,6 +3,7 @@ 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.roles.role import AppRole
 from office365.directory.applications.spa import SpaApplication
@@ -250,6 +251,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."""
@@ -321,6 +336,8 @@ 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,
                 "tokenIssuancePolicies": self.token_issuance_policies,
             }

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/authentication/conditions/application.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class AuthenticationConditionApplication(Entity):
+    """An object representing the application that will be triggered for an authenticationEventListener."""

office365/directory/authentication/conditions/applications.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class AuthenticationConditionsApplications(ClientValue):
+    """The applications on which an authenticationEventListener should trigger."""

office365/directory/authentication/conditions/conditions.py

@@ -0,0 +1,11 @@
+from office365.directory.authentication.conditions.applications import (
+    AuthenticationConditionsApplications,
+)
+from office365.runtime.client_value import ClientValue
+
+
+class AuthenticationConditions(ClientValue):
+    """"""
+
+    def __init__(self, applications=AuthenticationConditionsApplications()):
+        self.applications = applications

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/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/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/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/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)

office365/directory/protection/policy/one_drive_for_business.py

@@ -0,0 +1,10 @@
+from office365.directory.protection.policy.base import ProtectionPolicyBase
+
+
+class OneDriveForBusinessProtectionPolicy(ProtectionPolicyBase):
+    """
+    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.
+    """

office365/directory/security/attacksimulations/users/details.py

@@ -3,3 +3,10 @@ from office365.runtime.client_value import ClientValue
 
 class UserSimulationDetails(ClientValue):
     """Represents a user of a tenant and their online actions in an attack simulation and training campaign."""
+
+    def __init__(self, assigned_trainings_count=None):
+        """
+        :param int assigned_trainings_count: Number of trainings assigned to a user in an attack simulation
+            and training campaign.
+        """
+        self.assignedTrainingsCount = assigned_trainings_count

office365/directory/serviceprincipals/service_principal.py

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from typing import Optional
 
 from typing_extensions import Self
@@ -102,7 +103,8 @@ class ServicePrincipal(DirectoryObject):
         self.context.add_query(qry)
         return return_type
 
-    def _ensure_client_service_principal(self, app, action):
+    def _get_service_principal_by_app(self, app, action):
+        # type: (Application|str, Callable[[Application], None]) -> None
         if isinstance(app, Application):
 
             def _after():
@@ -112,6 +114,54 @@ class ServicePrincipal(DirectoryObject):
         else:
             self.context.service_principals.get_by_app(app).get().after_execute(action)
 
+    def get_delegated(self, app, principal, scope=None):
+        # type: (Application|str, User|str, AppRole|str) -> DeltaCollection[OAuth2PermissionGrant]
+        """Gets a delegated permission to the client service principal on behalf of a user"""
+
+        return_type = DeltaCollection(self.context, OAuth2PermissionGrant)
+
+        def _get_delegated(col):
+            # type: (DeltaCollection[OAuth2PermissionGrant]) -> None
+            if scope is None:
+                [return_type.add_child(g) for g in col if g.resource_id == self.id]
+            else:
+                [
+                    return_type.add_child(g)
+                    for g in col
+                    if g.scope == scope and g.resource_id == self.id
+                ]
+
+        def _principal_resolved(principal_id):
+            # type: (str) -> None
+            def _client_loaded(client):
+                # type: (ServicePrincipal) -> None
+                query_text = ("principalId eq '{0}' and clientId eq '{1}'").format(
+                    principal_id, client.id
+                )
+
+                (
+                    self.context.oauth2_permission_grants.get()
+                    .filter(query_text)
+                    .after_execute(_get_delegated)
+                )
+
+            self.context.service_principals.get_by_app(app).get().after_execute(
+                _client_loaded
+            )
+
+        def _resource_resolved():
+            if isinstance(principal, User):
+
+                def _after():
+                    _principal_resolved(principal.id)
+
+                principal.ensure_property("id", _after)
+            else:
+                _principal_resolved(principal)
+
+        self.ensure_property("id", _resource_resolved)
+        return return_type
+
     def grant_delegated(self, app, principal, scope):
         # type: (Application|str, User|str, AppRole|str) -> Self
         """Grants a delegated permission to the client service principal on behalf of a user"""
@@ -126,30 +176,33 @@ class ServicePrincipal(DirectoryObject):
                 scope=scope,
             )
 
-        def _ensure_app(principal_id):
-            def _after(return_type):
+        def _principal_resolved(principal_id):
+            # type: (str) -> None
+            def _client_loaded(return_type):
                 _grant_delegated(principal_id, return_type.id)
 
-            self._ensure_client_service_principal(app, _after)
+            self.context.service_principals.get_by_app(app).get().after_execute(
+                _client_loaded
+            )
 
-        def _ensure_principal():
+        def _resource_resolved():
             if isinstance(principal, User):
 
                 def _after():
-                    _ensure_app(principal.id)
+                    _principal_resolved(principal.id)
 
                 principal.ensure_property("id", _after)
             else:
-                _ensure_app(principal)
+                _principal_resolved(principal)
 
-        self.ensure_property("id", _ensure_principal)
+        self.ensure_property("id", _resource_resolved)
         return self
 
     def revoke_delegated(self, app, principal, scope):
         # type: (Application|str, User|str, AppRole|str) -> Self
         """"""
 
-        def _revoke(app_id, principal_id):
+        def _revoke_delegated(app_id, principal_id):
             # type: (str, str) -> None
 
             def _after(return_type):
@@ -158,7 +211,6 @@ class ServicePrincipal(DirectoryObject):
             query_text = "clientId eq '{0}' and principalId eq '{1}'".format(
                 app_id, principal_id
             )
-            # query_text = "clientId eq '{0}'".format(app_id)
             self.context.oauth2_permission_grants.filter(
                 query_text
             ).get().after_execute(_after)
@@ -167,14 +219,13 @@ class ServicePrincipal(DirectoryObject):
             if isinstance(principal, User):
 
                 def _after():
-                    _revoke(principal.id, return_type.id)
+                    _revoke_delegated(principal.id, return_type.id)
 
                 principal.ensure_property("id", _after)
             else:
-                _revoke(principal, return_type.id)
+                _revoke_delegated(principal, return_type.id)
 
-        self._ensure_client_service_principal(app, _ensure_principal)
-        # self.ensure_property("id", _ensure_principal)
+        self._get_service_principal_by_app(app, _ensure_principal)
         return self
 
     def grant_application(self, app, app_role):

office365/directory/users/user.py

@@ -193,6 +193,16 @@ class User(DirectoryObject):
         self.context.add_query(qry)
         return return_type
 
+    def get_my_site(self):
+        """Gets user's site"""
+        return_type = Site(self.context)
+
+        def _loaded():
+            return_type.set_property("webUrl", self.my_site)
+
+        self.ensure_property("mySite", _loaded)
+        return return_type
+
     def send_mail(
         self,
         subject,
@@ -535,11 +545,21 @@ class User(DirectoryObject):
     @property
     def given_name(self):
         # type: () -> Optional[str]
-        """
-        The given name (first name) of the user. Maximum length is 64 characters.
-        """
+        """The given name (first name) of the user. Maximum length is 64 characters"""
         return self.properties.get("givenName", None)
 
+    @property
+    def my_site(self):
+        # type: () -> Optional[str]
+        """The URL for the user's site."""
+        return self.properties.get("mySite", None)
+
+    @property
+    def office_location(self):
+        # type: () -> Optional[str]
+        """The office location in the user's place of business."""
+        return self.properties.get("officeLocation", None)
+
     @property
     def user_principal_name(self):
         # type: () -> Optional[str]

office365/graph_client.py

@@ -229,16 +229,21 @@ class GraphClient(ClientRuntimeContext):
 
         return GraphClient(_acquire_token)
 
-    def execute_batch(self, items_per_batch=100):
+    def execute_batch(self, items_per_batch=20, success_callback=None):
         """Constructs and submit a batch request
 
+        Per Batch size limitations: JSON batch requests are currently limited to 20 individual requests.
+
         :param int items_per_batch: Maximum to be selected for bulk operation
+        :param (List[ClientObject|ClientResult])-> None success_callback: A success callback
         """
         batch_request = ODataV4BatchRequest(V4JsonFormat())
         batch_request.beforeExecute += self._authenticate_request
         while self.has_pending_request:
             qry = self._get_next_query(items_per_batch)
             batch_request.execute_query(qry)
+            if callable(success_callback):
+                success_callback(qry.return_type)
         return self
 
     def pending_request(self):

office365/intune/devices/management/management.py

@@ -9,6 +9,8 @@ from office365.intune.devices.enrollment.configuration import (
 )
 from office365.intune.devices.managed import ManagedDevice
 from office365.intune.devices.management.reports.reports import DeviceManagementReports
+from office365.intune.devices.management.terms_and_conditions import TermsAndConditions
+from office365.intune.devices.management.virtual_endpoint import VirtualEndpoint
 from office365.runtime.client_result import ClientResult
 from office365.runtime.client_value_collection import ClientValueCollection
 from office365.runtime.paths.resource_path import ResourcePath
@@ -40,6 +42,28 @@ class DeviceManagement(Entity):
             ),
         )
 
+    @property
+    def virtual_endpoint(self):
+        """"""
+        return self.properties.get(
+            "virtualEndpoint",
+            VirtualEndpoint(
+                self.context, ResourcePath("virtualEndpoint", self.resource_path)
+            ),
+        )
+
+    @property
+    def terms_and_conditions(self):
+        """"""
+        return self.properties.get(
+            "termsAndConditions",
+            EntityCollection(
+                self.context,
+                TermsAndConditions,
+                ResourcePath("termsAndConditions", self.resource_path),
+            ),
+        )
+
     @property
     def device_categories(self):
         """"""
@@ -98,6 +122,8 @@ class DeviceManagement(Entity):
                 "deviceEnrollmentConfigurations": self.device_enrollment_configurations,
                 "intuneBrand": self.intune_brand,
                 "managedDevices": self.managed_devices,
+                "termsAndConditions": self.terms_and_conditions,
+                "virtualEndpoint": self.virtual_endpoint,
             }
             default_value = property_mapping.get(name, None)
         return super(DeviceManagement, self).get_property(name, default_value)

office365/intune/devices/management/terms_and_conditions.py

@@ -0,0 +1,10 @@
+from office365.entity import Entity
+
+
+class TermsAndConditions(Entity):
+    """
+    A termsAndConditions entity represents the metadata and contents of a given Terms and Conditions (T&C) policy.
+    T&C policies’ contents are presented to users upon their first attempt to enroll into Intune and subsequently
+    upon edits where an administrator has required re-acceptance. They enable administrators to communicate
+    the provisions to which a user must agree in order to have devices enrolled into Intune.
+    """

office365/intune/devices/management/virtual_endpoint.py

@@ -0,0 +1,8 @@
+from office365.entity import Entity
+
+
+class VirtualEndpoint(Entity):
+    """
+    Use the Cloud PC API to provision and manage virtual desktops for employees in an organization,
+    or along with the Intune API to manage physical and virtual endpoints.
+    """

office365/onedrive/idle_session_signout.py

@@ -0,0 +1,15 @@
+from office365.runtime.client_value import ClientValue
+
+
+class IdleSessionSignOut(ClientValue):
+    """Represents the idle session sign-out policy settings for SharePoint."""
+
+    def __init__(
+        self,
+        is_enabled=None,
+        sign_out_after_in_seconds=None,
+        warn_after_in_seconds=None,
+    ):
+        self.isEnabled = is_enabled
+        self.signOutAfterInSeconds = sign_out_after_in_seconds
+        self.warnAfterInSeconds = warn_after_in_seconds