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

office365/admin/admin.py

@@ -0,0 +1,69 @@
+from office365.admin.microsoft365_apps import AdminMicrosoft365Apps
+from office365.admin.people_settings import PeopleAdminSettings
+from office365.admin.report_settings import AdminReportSettings
+from office365.admin.sharepoint import Sharepoint
+from office365.entity import Entity
+from office365.intune.servicecommunications.announcement import ServiceAnnouncement
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class Admin(Entity):
+    """Entity that acts as a container for administrator functionality."""
+
+    @property
+    def microsoft365_apps(self):
+        """A container for the Microsoft 365 apps admin functionality."""
+        return self.properties.get(
+            "microsoft365Apps",
+            AdminMicrosoft365Apps(
+                self.context, ResourcePath("microsoft365Apps", self.resource_path)
+            ),
+        )
+
+    @property
+    def sharepoint(self):
+        """A container for administrative resources to manage tenant-level settings for SharePoint and OneDrive."""
+        return self.properties.get(
+            "sharepoint",
+            Sharepoint(self.context, ResourcePath("sharepoint", self.resource_path)),
+        )
+
+    @property
+    def service_announcement(self):
+        """A container for service communications resources. Read-only."""
+        return self.properties.get(
+            "serviceAnnouncement",
+            ServiceAnnouncement(
+                self.context, ResourcePath("serviceAnnouncement", self.resource_path)
+            ),
+        )
+
+    @property
+    def report_settings(self):
+        """A container for administrative resources to manage reports."""
+        return self.properties.get(
+            "reportSettings",
+            AdminReportSettings(
+                self.context, ResourcePath("reportSettings", self.resource_path)
+            ),
+        )
+
+    @property
+    def people(self):
+        """Represents a setting to control people-related admin settings in the tenant."""
+        return self.properties.get(
+            "people",
+            PeopleAdminSettings(
+                self.context, ResourcePath("people", self.resource_path)
+            ),
+        )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "microsoft365Apps": self.microsoft365_apps,
+                "serviceAnnouncement": self.service_announcement,
+                "reportSettings": self.report_settings,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(Admin, self).get_property(name, default_value)

office365/admin/microsoft365_apps.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class AdminMicrosoft365Apps(Entity):
+    """Represents an entity that acts as a container for administrator functionality for Microsoft 365 applications."""

office365/admin/people_settings.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class PeopleAdminSettings(Entity):
+    """Represents a setting to control people-related admin settings in the tenant."""

office365/admin/report_settings.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class AdminReportSettings(Entity):
+    """Represents the tenant-level settings for Microsoft 365 reports."""

office365/{onedrive → admin}/sharepoint.py

@@ -1,5 +1,5 @@
+from office365.admin.sharepoint_settings import SharepointSettings
 from office365.entity import Entity
-from office365.onedrive.sharepoint_settings import SharepointSettings
 from office365.runtime.paths.resource_path import ResourcePath
 
 

office365/azure_env.py

@@ -0,0 +1,60 @@
+class AzureEnvironment(object):
+
+    Global = "Global"
+    """Referred to as Azure or Azure Global."""
+
+    USGovernment = "GCC"
+    """Government Community Cloud"""
+
+    USGovernmentHigh = "GCC High"
+    """Government Community Cloud High."""
+
+    China = "CN"
+    """Operated by 21Vianet under Chinese regulations."""
+
+    Germany = "Azure DE"
+    """Legacy; for data sovereignty in Germany."""
+
+    USGovernmentDoD = "DoD"
+    """Azure for U.S. Department of Defense (DoD)"""
+
+    _authority_endpoints = {
+        Global: {
+            "graph": "https://graph.microsoft.com",
+            "login": "https://login.microsoftonline.com",
+        },
+        USGovernment: {
+            "graph": "https://graph.microsoft.com",
+            "login": "https://login.microsoftonline.com",
+        },
+        USGovernmentHigh: {
+            "graph": "https://graph.microsoft.us",
+            "login": "https://login.microsoftonline.us",
+        },
+        USGovernmentDoD: {
+            "graph": "https://dod-graph.microsoft.us",
+            "login": "https://login.microsoftonline.us",
+        },
+        Germany: {
+            "graph": "https://graph.microsoft.de",
+            "login": "https://login.microsoftonline.de",
+        },
+        China: {
+            "graph": "https://microsoftgraph.chinacloudapi.cn",
+            "login": "https://login.chinacloudapi.cn",
+        },
+    }
+
+    @classmethod
+    def get_graph_authority(cls, env):
+        # type: (str) -> str
+        return cls._authority_endpoints.get(env, cls._authority_endpoints["Global"])[
+            "graph"
+        ]
+
+    @classmethod
+    def get_login_authority(cls, env):
+        # type: (str) -> str
+        return cls._authority_endpoints.get(env, cls._authority_endpoints["Global"])[
+            "login"
+        ]

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/app_ids.py

@@ -0,0 +1,6 @@
+class MsAppIds:
+    """Enum for commonly used Microsoft application IDs."""
+
+    Office_365_SharePoint_Online = "00000003-0000-0ff1-ce00-000000000000"
+
+    Office_365_Exchange_Online = "00000002-0000-0ff1-ce00-000000000000"

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

@@ -42,6 +42,21 @@ class Authentication(Entity):
             ),
         )
 
+    @property
+    def microsoft_authenticator_methods(self):
+        from office365.directory.authentication.methods.microsoft_authenticator import (
+            MicrosoftAuthenticatorAuthenticationMethod,
+        )
+
+        return self.properties.get(
+            "microsoftAuthenticatorMethods",
+            EntityCollection(
+                self.context,
+                MicrosoftAuthenticatorAuthenticationMethod,
+                ResourcePath("microsoftAuthenticatorMethods", self.resource_path),
+            ),
+        )
+
     @property
     def phone_methods(self):
         """The phone numbers registered to a user for authentication."""
@@ -94,6 +109,7 @@ class Authentication(Entity):
             property_mapping = {
                 "emailMethods": self.email_methods,
                 "fido2Methods": self.fido2_methods,
+                "microsoftAuthenticatorMethods": self.microsoft_authenticator_methods,
                 "passwordMethods": self.password_methods,
                 "phoneMethods": self.phone_methods,
             }

office365/directory/authentication/method_target.py

@@ -2,4 +2,5 @@ from office365.entity import Entity
 
 
 class AuthenticationMethodTarget(Entity):
-    """"""
+    """A collection of groups that are enabled to use an authentication method as part of an authentication
+    method policy in Microsoft Entra ID."""

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/microsoft_authenticator.py

@@ -0,0 +1,6 @@
+from office365.directory.authentication.methods.method import AuthenticationMethod
+
+
+class MicrosoftAuthenticatorAuthenticationMethod(AuthenticationMethod):
+    """A representation of the Microsoft Authenticator app registered to a user. Microsoft Authenticator
+    is an authentication method."""

office365/directory/authentication/methods/root.py

@@ -1,6 +1,9 @@
 from office365.directory.authentication.methods.details import UserRegistrationDetails
 from office365.entity import Entity
 from office365.entity_collection import EntityCollection
+from office365.reports.userregistration.feature_summary import (
+    UserRegistrationFeatureSummary,
+)
 from office365.reports.userregistration.method_summary import (
     UserRegistrationMethodSummary,
 )
@@ -12,6 +15,14 @@ from office365.runtime.queries.function import FunctionQuery
 class AuthenticationMethodsRoot(Entity):
     """Container for navigation properties for Azure AD authentication methods resources."""
 
+    def users_registered_by_feature(self):
+        """Get the number of users capable of multi-factor authentication, self-service password reset,
+        and passwordless authentication."""
+        return_type = ClientResult(self.context, UserRegistrationFeatureSummary())
+        qry = FunctionQuery(self, "usersRegisteredByFeature", None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
     def users_registered_by_method(self):
         """Get the number of users registered for each authentication method."""
         return_type = ClientResult(self.context, UserRegistrationMethodSummary())
@@ -32,3 +43,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/authentication/methods/sms.py

@@ -0,0 +1,9 @@
+from office365.directory.authentication.method_configuration import (
+    AuthenticationMethodConfiguration,
+)
+
+
+class SmsAuthenticationMethodConfiguration(AuthenticationMethodConfiguration):
+    """Represents a text message authentication methods policy. Authentication methods policies define
+    configuration settings and users or groups that are enabled to use the authentication method.
+    """

office365/directory/certificates/self_signed.py

@@ -4,8 +4,37 @@ from office365.runtime.client_value import ClientValue
 class SelfSignedCertificate(ClientValue):
     """Contains the public part of a signing certificate."""
 
-    def __init__(self, display_name=None):
+    def __init__(
+        self,
+        custom_key_identifier=None,
+        display_name=None,
+        end_datetime=None,
+        key=None,
+        key_id=None,
+        start_datetime=None,
+        thumbprint=None,
+        type_=None,
+        usage=None,
+    ):
         """
-        :param str display_name:
+        :param custom_key_identifier: 	Custom key identifier.
+        :param str display_name: The friendly name for the key.
+        :param end_datetime: The date and time at which the credential expires. The timestamp type represents date
+             and time information using ISO 8601 format and is always in UTC time
+        :param key: The value for the key credential. Should be a Base-64 encoded value.
+        :param key_id: 	The unique identifier (GUID) for the key.
+        :param start_datetime: The date and time at which the credential becomes valid. The timestamp type represents
+             date and time information using ISO 8601 format and is always in UTC time
+        :param thumbprint: 	The thumbprint value for the key.
+        :param type_: 	The type of key credential. AsymmetricX509Cert.
+        :param usage: A string that describes the purpose for which the key can be used. The possible value is Verify.
         """
+        self.customKeyIdentifier = custom_key_identifier
         self.displayName = display_name
+        self.endDateTime = end_datetime
+        self.key = key
+        self.keyId = key_id
+        self.startDateTime = start_datetime
+        self.thumbprint = thumbprint
+        self.type = type_
+        self.usage = usage

office365/directory/identities/conditional_access_root.py

@@ -1,4 +1,6 @@
+from office365.directory.policies.conditional_access import ConditionalAccessPolicy
 from office365.entity import Entity
+from office365.entity_collection import EntityCollection
 from office365.runtime.paths.resource_path import ResourcePath
 
 
@@ -15,3 +17,15 @@ class ConditionalAccessRoot(Entity):
                 self.context, ResourcePath("authenticationStrength", self.resource_path)
             ),
         )
+
+    @property
+    def policies(self):
+        """Returns a collection of the specified Conditional Access (CA) policies."""
+        return self.properties.get(
+            "policies",
+            EntityCollection(
+                self.context,
+                ConditionalAccessPolicy,
+                ResourcePath("policies", self.resource_path),
+            ),
+        )

office365/directory/identitygovernance/privilegedaccess/approval.py

@@ -0,0 +1,8 @@
+from office365.entity import Entity
+
+
+class Approval(Entity):
+    """Represents the approval object for decisions associated with a request.
+
+    In PIM for groups, the approval object for decisions to approve or deny requests to activate
+    group membership or ownership."""

office365/directory/identitygovernance/privilegedaccess/group.py

@@ -1,5 +1,35 @@
+from office365.directory.identitygovernance.privilegedaccess.approval import Approval
+from office365.directory.identitygovernance.privilegedaccess.group_assignment_schedule_instance import (
+    PrivilegedAccessGroupAssignmentScheduleInstance,
+)
 from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.runtime.paths.resource_path import ResourcePath
 
 
 class PrivilegedAccessGroup(Entity):
     """The entry point for all resources related to Privileged Identity Management (PIM) for groups."""
+
+    @property
+    def assignment_approvals(self):
+        """ """
+        return self.properties.get(
+            "assignmentApprovals",
+            EntityCollection(
+                self.context,
+                Approval,
+                ResourcePath("assignmentApprovals", self.resource_path),
+            ),
+        )
+
+    @property
+    def assignment_schedule_instances(self):
+        """The instances of assignment schedules to activate a just-in-time access."""
+        return self.properties.get(
+            "assignmentScheduleInstances",
+            EntityCollection(
+                self.context,
+                PrivilegedAccessGroupAssignmentScheduleInstance,
+                ResourcePath("assignmentScheduleInstances", self.resource_path),
+            ),
+        )

office365/directory/identitygovernance/privilegedaccess/group_assignment_schedule_instance.py

@@ -0,0 +1,7 @@
+from office365.directory.identitygovernance.privilegedaccess.schedule_instance import (
+    PrivilegedAccessScheduleInstance,
+)
+
+
+class PrivilegedAccessGroupAssignmentScheduleInstance(PrivilegedAccessScheduleInstance):
+    """Represents an instance of a provisioned membership or ownership assignment in PIM for groups."""

office365/directory/identitygovernance/privilegedaccess/unified_role_assignment_schedule_request.py

@@ -0,0 +1,7 @@
+from office365.entity import Entity
+
+
+class UnifiedRoleAssignmentScheduleRequest(Entity):
+    """In PIM, represents a request for an active role assignment to a principal. The role assignment can be
+    permanently active with or without an expiry date, or temporarily active after activation of an eligible
+    assignment. Inherits from request."""