Office365-REST-Python-Client 2.4.2__py3-none-any.whl → 2.4.4__py3-none-any.whl

office365/directory/serviceprincipals/service_principal.py

@@ -1,5 +1,5 @@
 from office365.delta_collection import DeltaCollection
-from office365.directory.applications.roles.assignment import AppRoleAssignmentCollection
+from office365.directory.applications.roles.assignment_collection import AppRoleAssignmentCollection
 from office365.directory.certificates.self_signed import SelfSignedCertificate
 from office365.directory.key_credential import KeyCredential
 from office365.directory.object_collection import DirectoryObjectCollection
@@ -7,10 +7,12 @@ from office365.directory.object import DirectoryObject
 from office365.directory.password_credential import PasswordCredential
 from office365.directory.permissions.grants.oauth2 import OAuth2PermissionGrant
 from office365.directory.permissions.scope import PermissionScope
+from office365.directory.synchronization.synchronization import Synchronization
 from office365.runtime.client_result import ClientResult
 from office365.runtime.client_value_collection import ClientValueCollection
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.queries.service_operation import ServiceOperationQuery
+from office365.runtime.types.collections import StringCollection
 
 
 class ServicePrincipal(DirectoryObject):
@@ -85,17 +87,44 @@ class ServicePrincipal(DirectoryObject):
         return return_type
 
     def remove_password(self, key_id):
-        """Remove a password from a servicePrincipal object..
-
+        """
+        Remove a password from a servicePrincipal object.
         :param str key_id: The unique identifier for the password.
         """
         qry = ServiceOperationQuery(self, "removePassword", None, {"keyId": key_id})
         self.context.add_query(qry)
         return self
 
+    @property
+    def account_enabled(self):
+        """
+        true if the service principal account is enabled; otherwise, false. If set to false, then no users will be
+        able to sign in to this app, even if they are assigned to it. Supports $filter (eq, ne, not, in).
+        :rtype: bool
+        """
+        return self.properties.get('accountEnabled', None)
+
+    @property
+    def alternative_names(self):
+        """
+        Used to retrieve service principals by subscription, identify resource group and full resource ids for
+        managed identities. Supports $filter (eq, not, ge, le, startsWith).
+        """
+        return self.properties.get('alternativeNames', StringCollection())
+
+    @property
+    def app_description(self):
+        """
+        The description exposed by the associated application.
+        :rtype: str
+        """
+        return self.properties.get('appDescription', None)
+
     @property
     def app_display_name(self):
-        """The collection of key credentials associated with the application. Not nullable.
+        """
+        The display name exposed by the associated application.
+        :rtype: str
         """
         return self.properties.get('appDisplayName', None)
 
@@ -108,6 +137,51 @@ class ServicePrincipal(DirectoryObject):
                                    AppRoleAssignmentCollection(self.context,
                                                                ResourcePath("appRoleAssignedTo", self.resource_path)))
 
+    @property
+    def homepage(self):
+        """
+        Home page or landing page of the application.
+        :rtype: str
+        """
+        return self.properties.get('homepage', None)
+
+    @property
+    def key_credentials(self):
+        """
+        The collection of key credentials associated with the service principal. Not nullable.
+        Supports $filter (eq, not, ge, le).
+        """
+        return self.properties.setdefault('keyCredentials', ClientValueCollection(KeyCredential))
+
+    @property
+    def login_url(self):
+        """
+        Specifies the URL where the service provider redirects the user to Azure AD to authenticate.
+        Azure AD uses the URL to launch the application from Microsoft 365 or the Azure AD My Apps. When blank,
+        Azure AD performs IdP-initiated sign-on for applications configured with SAML-based single sign-on.
+        The user launches the application from Microsoft 365, the Azure AD My Apps, or the Azure AD SSO URL.
+        :rtype: str
+        """
+        return self.properties.get('loginUrl', None)
+
+    @property
+    def logout_url(self):
+        """
+        Specifies the URL that will be used by Microsoft's authorization service to logout an user using
+        OpenId Connect front-channel, back-channel or SAML logout protocols.
+        :rtype: str
+        """
+        return self.properties.get('logoutUrl', None)
+
+    @property
+    def notification_email_addresses(self):
+        """
+        Specifies the list of email addresses where Azure AD sends a notification when the active certificate is near
+        the expiration date. This is only for the certificates used to sign the SAML token issued for Azure
+        AD Gallery applications.
+        """
+        return self.properties.get('notificationEmailAddresses', StringCollection())
+
     @property
     def service_principal_type(self):
         """
@@ -170,6 +244,16 @@ class ServicePrincipal(DirectoryObject):
                                    DirectoryObjectCollection(self.context,
                                                              ResourcePath("ownedObjects", self.resource_path)))
 
+    @property
+    def synchronization(self):
+        """
+        Represents the capability for Azure Active Directory (Azure AD) identity synchronization through
+        the Microsoft Graph API.
+        """
+        return self.properties.get('synchronization',
+                                   Synchronization(self.context,
+                                                   ResourcePath("synchronization", self.resource_path)))
+
     @property
     def token_encryption_key_id(self):
         """
@@ -185,6 +269,7 @@ class ServicePrincipal(DirectoryObject):
             property_mapping = {
                 "appRoleAssignedTo": self.app_role_assigned_to,
                 "created_objects": self.created_objects,
+                "keyCredentials": self.key_credentials,
                 "oauth2PermissionScopes": self.oauth2_permission_scopes,
                 "ownedObjects": self.owned_objects,
                 "oauth2PermissionGrants": self.oauth2_permission_grants

office365/directory/synchronization/job.py

@@ -0,0 +1,16 @@
+from office365.directory.synchronization.status import SynchronizationStatus
+from office365.entity import Entity
+
+
+class SynchronizationJob(Entity):
+    """
+    Performs synchronization by periodically running in the background, polling for changes in one directory,
+    and pushing them to another directory. The synchronization job is always specific to a particular instance
+    of an application in your tenant. As part of the synchronization job setup, you need to give authorization
+    to read and write objects in your target directory, and customize the job's synchronization schema.
+    """
+
+    @property
+    def status(self):
+        """Status of the job, which includes when the job was last run, current job state, and errors."""
+        return self.properties.get("status", SynchronizationStatus())

office365/directory/synchronization/progress.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class SynchronizationProgress(ClientValue):
+    """Represents the progress of a synchronizationJob toward completion."""

office365/directory/synchronization/status.py

@@ -0,0 +1,13 @@
+from office365.directory.synchronization.progress import SynchronizationProgress
+from office365.runtime.client_value import ClientValue
+from office365.runtime.client_value_collection import ClientValueCollection
+
+
+class SynchronizationStatus(ClientValue):
+    """Represents the current status of the synchronizationJob."""
+
+    def __init__(self, progress=None):
+        """
+        :param list[SynchronizationProgress] progress: Details of the progress of a job toward completion.
+        """
+        self.progress = ClientValueCollection(SynchronizationProgress, progress)

office365/directory/synchronization/synchronization.py

@@ -0,0 +1,24 @@
+from office365.directory.synchronization.job import SynchronizationJob
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class Synchronization(Entity):
+    """
+    Represents the capability for Azure Active Directory (Azure AD) identity synchronization through
+    the Microsoft Graph API. Identity synchronization (also called provisioning) allows you to automate
+    the provisioning (creation, maintenance) and de-provisioning (removal) of user identities and roles from
+    Azure AD to supported cloud applications. For more information, see How Application Provisioning works
+    in Azure Active Directory
+    """
+
+    @property
+    def jobs(self):
+        """
+        Performs synchronization by periodically running in the background, polling for changes in one directory,
+        and pushing them to another directory.
+        """
+        return self.properties.get('jobs',
+                                   EntityCollection(self.context, SynchronizationJob,
+                                                    ResourcePath("jobs", self.resource_path)))

office365/directory/tenant_information.py

@@ -0,0 +1,17 @@
+from office365.runtime.client_value import ClientValue
+
+
+class TenantInformation(ClientValue):
+    """Information about your Azure AD tenant that is publicly displayed to users in other Azure AD tenants."""
+
+    def __str__(self, default_domain_name=None, display_name=None, federation_brand_name=None, tenant_id=None):
+        """
+        :param str default_domain_name: Primary domain name of an Azure AD tenant.
+        :param str display_name: Display name of an Azure AD tenant.
+        :param str federation_brand_name: Name shown to users that sign in to an Azure AD tenant.
+        :param str tenant_id: Unique identifier of an Azure AD tenant.
+        """
+        self.defaultDomainName = default_domain_name
+        self.displayName = display_name
+        self.federationBrandName = federation_brand_name
+        self.tenantId = tenant_id

office365/directory/tenant_relationship.py

@@ -0,0 +1,21 @@
+from office365.directory.tenant_information import TenantInformation
+from office365.entity import Entity
+from office365.runtime.client_result import ClientResult
+from office365.runtime.queries.function import FunctionQuery
+
+
+class TenantRelationship(Entity):
+    """Represent the various type of tenant relationships."""
+
+    def find_tenant_information_by_domain_name(self, domain_name):
+        """Given a domain name, search for a tenant and read its tenantInformation. You can use this API to
+        validate tenant information and use their tenantId to configure cross-tenant access settings between you
+        and the tenant.
+
+        :param str domain_name: Primary domain name of an Azure AD tenant.
+        """
+        return_type = ClientResult(self.context, TenantInformation())
+        params = {"domainName": domain_name}
+        qry = FunctionQuery(self, "findTenantInformationByDomainName", params, return_type)
+        self.context.add_query(qry)
+        return return_type

office365/directory/users/activities/activity.py

@@ -1,10 +1,54 @@
+from datetime import datetime
+
 from office365.entity import Entity
 from office365.entity_collection import EntityCollection
 from office365.runtime.paths.resource_path import ResourcePath
 
 
 class UserActivity(Entity):
-    """"""
+    """
+    Represents a single activity within an app - for example, a TV show, a document, or a current campaign
+    in a video game. When a user engages with that activity, the engagement is captured as a history item
+    that indicates the start and end time for that activity. As the user re-engages with that activity over time,
+    multiple history items are recorded for a single user activity.
+    """
+
+    @property
+    def activation_url(self):
+        """URL used to launch the activity in the best native experience represented by the appId.
+        Might launch a web-based app if no native app exists"""
+        return self.properties.get("activationUrl", None)
+
+    @property
+    def activity_source_host(self):
+        """Required. URL for the domain representing the cross-platform identity mapping for the app.
+        Mapping is stored either as a JSON file hosted on the domain or configurable via Windows Dev Center.
+        The JSON file is named cross-platform-app-identifiers and is hosted at root of your HTTPS domain,
+        either at the top level domain or include a sub domain.
+        For example: https://contoso.com or https://myapp.contoso.com but NOT https://myapp.contoso.com/somepath.
+        You must have a unique file and domain (or sub domain) per cross-platform app identity.
+        For example, a separate file and domain is needed for Word vs. PowerPoint."""
+        return self.properties.get("activitySourceHost", None)
+
+    @property
+    def app_activity_id(self):
+        """The unique activity ID in the context of the app - supplied by caller and immutable thereafter.
+        :rtype: str
+        """
+        return self.properties.get("appActivityId", None)
+
+    @property
+    def app_display_name(self):
+        """Short text description of the app used to generate the activity for use in cases when the app is
+        not installed on the user’s local device.
+        :rtype: str
+        """
+        return self.properties.get("appDisplayName", None)
+
+    @property
+    def created_datetime(self):
+        """Set by the server. DateTime in UTC when the object was created on the server."""
+        return self.properties.get('createdDateTime', datetime.min)
 
     @property
     def history_items(self):

office365/directory/users/collection.py

@@ -1,5 +1,6 @@
 from office365.delta_collection import DeltaCollection
 from office365.directory.users.user import User
+from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.queries.create_entity import CreateEntityQuery
 
 
@@ -15,6 +16,13 @@ class UserCollection(DeltaCollection):
         """
         return super(UserCollection, self).__getitem__(id_or_principal_name)
 
+    def get_by_principal_name(self, name):
+        """
+        Retrieves User by principal name
+        :param str name: User principal name
+        """
+        return User(self.context, ResourcePath(name, self.resource_path))
+
     def add(self, user_properties):
         """Create a new user.
 

office365/directory/users/password_profile.py

@@ -4,7 +4,23 @@ from office365.runtime.client_value import ClientValue
 class PasswordProfile(ClientValue):
     """Contains the password profile associated with a user. The passwordProfile property of the user entity is a
     passwordProfile object. """
-    def __init__(self, password):
+
+    def __init__(self, password=None, force_change_password_next_sign_in=None,
+                 force_change_password_next_sign_in_with_mfa=None):
+        """
+        :param str password: The password for the user. This property is required when a user is created.
+             It can be updated, but the user will be required to change the password on the next login.
+             The password must satisfy minimum requirements as specified by the user's passwordPolicies property.
+             By default, a strong password is required.
+        :param bool force_change_password_next_sign_in: true if the user must change her password on the next login;
+             otherwise false.
+        :param bool force_change_password_next_sign_in_with_mfa: f true, at next sign-in, the user must perform a
+             multi-factor authentication (MFA) before being forced to change their password. The behavior is identical
+             to forceChangePasswordNextSignIn except that the user is required to first perform a multi-factor
+             authentication before password change. After a password change, this property will be automatically
+             reset to false. If not set, default is false.
+        """
         super(PasswordProfile, self).__init__()
         self.password = password
-        self.forceChangePasswordNextSignIn = True
+        self.forceChangePasswordNextSignIn = force_change_password_next_sign_in
+        self.forceChangePasswordNextSignInWithMfa = force_change_password_next_sign_in_with_mfa