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

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

@@ -5,6 +5,9 @@ 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
@@ -53,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)
 
@@ -228,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)
         )
@@ -315,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]
@@ -339,6 +352,7 @@ class Application(DirectoryObject):
                 "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/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/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/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_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/update_allowed_combinations_result.py

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

office365/directory/security/alerts/evidence.py

@@ -3,7 +3,8 @@ from office365.runtime.types.collections import StringCollection
 
 
 class AlertEvidence(ClientValue):
-    """Evidence related to an alert."""
+    """The alertEvidence base type and its derived evidence types provide a means to organize and track rich data
+    about each artifact involved in an alert."""
 
     def __init__(self, created_datetime=None, detailed_roles=None):
         """

office365/directory/security/alerts/malware_evidence.py

@@ -0,0 +1,5 @@
+from office365.directory.security.alerts.evidence import AlertEvidence
+
+
+class MalwareEvidence(AlertEvidence):
+    """"""

office365/directory/security/alerts/process_evidence.py

@@ -0,0 +1,5 @@
+from office365.directory.security.alerts.evidence import AlertEvidence
+
+
+class ProcessEvidence(AlertEvidence):
+    """Represents a process that is reported in the alert as evidence."""

office365/directory/security/attacksimulations/user.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class AttackSimulationUser(ClientValue):
+    """Represents a user in an attack simulation and training campaign."""

office365/directory/security/attacksimulations/user_coverage.py

@@ -3,3 +3,6 @@ from office365.runtime.client_value import ClientValue
 
 class AttackSimulationSimulationUserCoverage(ClientValue):
     """Represents cumulative simulation data and results for a user in attack simulation and training."""
+
+    def __init__(self):
+        pass

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

@@ -1,12 +1,17 @@
+from office365.directory.security.attacksimulations.user import AttackSimulationUser
 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):
+    def __init__(
+        self, assigned_trainings_count=None, simulation_user=AttackSimulationUser()
+    ):
         """
         :param int assigned_trainings_count: Number of trainings assigned to a user in an attack simulation
             and training campaign.
+        :param AttackSimulationUser simulation_user:
         """
         self.assignedTrainingsCount = assigned_trainings_count
+        self.simulationUser = simulation_user

office365/directory/serviceprincipals/service_principal.py

@@ -114,55 +114,63 @@ 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"""
+    def get_delegated_permissions(self, app, principal=None):
+        # type: (Application|str, User|str) -> ClientResult[StringCollection]
+        """Gets a delegated API permission"""
 
-        return_type = DeltaCollection(self.context, OAuth2PermissionGrant)
+        return_type = ClientResult(self.context, StringCollection())
 
-        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 _get_delegated_permissions(client_id, principal_id=None):
+            # type: (str, str) -> None
 
-        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
+            if principal_id is None:
+                query_text = (
+                    "clientId eq '{0}'  and consentType eq 'AllPrincipals'".format(
+                        client_id
+                    )
+                )
+            else:
+                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)
+            def _loaded(col):
+                scope_val = next(
+                    iter([g.scope for g in col if g.resource_id == self.id]), None
                 )
+                if scope_val is not None:
+                    [return_type.value.add(name) for name in scope_val.split(" ")]
 
-            self.context.service_principals.get_by_app(app).get().after_execute(
-                _client_loaded
+            (
+                self.context.oauth2_permission_grants.get()
+                .filter(query_text)
+                .after_execute(_loaded)
             )
 
-        def _resource_resolved():
+        def _resolve_application():
+            # type: () -> None
+            def _after(service_principal):
+                if principal is None:
+                    _get_delegated_permissions(service_principal.id)
+                else:
+                    _resolve_principal(service_principal.id)
+
+            self.context.service_principals.get_by_app(app).get().after_execute(_after)
+
+        def _resolve_principal(app_id):
             if isinstance(principal, User):
 
                 def _after():
-                    _principal_resolved(principal.id)
+                    _get_delegated_permissions(app_id, principal.id)
 
                 principal.ensure_property("id", _after)
             else:
-                _principal_resolved(principal)
+                _get_delegated_permissions(app_id, principal)
 
-        self.ensure_property("id", _resource_resolved)
+        self.ensure_property("id", _resolve_application)
         return return_type
 
-    def grant_delegated(self, app, principal, scope):
+    def grant_delegated_permissions(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"""
 
@@ -198,11 +206,11 @@ class ServicePrincipal(DirectoryObject):
         self.ensure_property("id", _resource_resolved)
         return self
 
-    def revoke_delegated(self, app, principal, scope):
+    def revoke_delegated_permissions(self, app, principal, scope):
         # type: (Application|str, User|str, AppRole|str) -> Self
         """"""
 
-        def _revoke_delegated(app_id, principal_id):
+        def _revoke_delegated_permissions(app_id, principal_id):
             # type: (str, str) -> None
 
             def _after(return_type):
@@ -219,16 +227,40 @@ class ServicePrincipal(DirectoryObject):
             if isinstance(principal, User):
 
                 def _after():
-                    _revoke_delegated(principal.id, return_type.id)
+                    _revoke_delegated_permissions(principal.id, return_type.id)
 
                 principal.ensure_property("id", _after)
             else:
-                _revoke_delegated(principal, return_type.id)
+                _revoke_delegated_permissions(principal, return_type.id)
 
         self._get_service_principal_by_app(app, _ensure_principal)
         return self
 
-    def grant_application(self, app, app_role):
+    def get_application_permissions(self, app):
+        # type: (Application|str) -> ClientResult[AppRoleCollection]
+        return_type = ClientResult(self.context, AppRoleCollection())
+
+        def _get_application_permissions(app_id):
+            app_role_ids = [
+                app_role.app_role_id
+                for app_role in self.app_role_assigned_to
+                if app_role.principal_id == app_id
+            ]
+            for app_role in self.app_roles:
+                if app_role.id in app_role_ids:
+                    return_type.value.add(app_role)
+
+        def _resolve_app():
+
+            def _after(service_principal):
+                _get_application_permissions(service_principal.id)
+
+            self.context.service_principals.get_by_app(app).get().after_execute(_after)
+
+        self.ensure_properties(["id", "appRoles", "appRoleAssignedTo"], _resolve_app)
+        return return_type
+
+    def grant_application_permissions(self, app, app_role):
         # type: (Application|str, AppRole|str) -> Self
         """
         Grants an app role assignment to a client service principal
@@ -254,7 +286,7 @@ class ServicePrincipal(DirectoryObject):
         self.ensure_properties(["id", "appRoles"], _ensure_resource)
         return self
 
-    def revoke_application(self, app, app_role):
+    def revoke_application_permissions(self, app, app_role):
         # type: (Application|str, AppRole|str) -> Self
         """Revokes an app role assignment from a client service principal"""
 
@@ -326,6 +358,12 @@ class ServicePrincipal(DirectoryObject):
         """The display name exposed by the associated application."""
         return self.properties.get("appDisplayName", None)
 
+    @property
+    def app_id(self):
+        # type: () -> Optional[str]
+        """The unique identifier for the associated application (its appId property)."""
+        return self.properties.get("appId", None)
+
     @property
     def app_role_assigned_to(self):
         """
@@ -338,6 +376,16 @@ class ServicePrincipal(DirectoryObject):
             ),
         )
 
+    @property
+    def app_role_assignments(self):
+        """Get an event collection or an appRoleAssignments."""
+        return self.properties.get(
+            "appRoleAssignments",
+            AppRoleAssignmentCollection(
+                self.context, ResourcePath("appRoleAssignments", self.resource_path)
+            ),
+        )
+
     @property
     def app_roles(self):
         """The roles exposed by the application which this service principal represents."""
@@ -503,6 +551,7 @@ class ServicePrincipal(DirectoryObject):
             property_mapping = {
                 "appRoles": self.app_roles,
                 "appRoleAssignedTo": self.app_role_assigned_to,
+                "appRoleAssignments": self.app_role_assignments,
                 "created_objects": self.created_objects,
                 "keyCredentials": self.key_credentials,
                 "oauth2PermissionScopes": self.oauth2_permission_scopes,

office365/onedrive/driveitems/driveItem.py

@@ -366,7 +366,7 @@ class DriveItem(BaseItem):
     def download_folder(
         self, download_file, after_file_downloaded=None, recursive=True
     ):
-        # type: (IO, Callable[[File], None], bool) -> "DriveItem"
+        # type: (IO, Callable[["DriveItem"], None], bool) -> "DriveItem"
         """
         Download the folder content
         """