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

office365/directory/serviceprincipals/service_principal.py

@@ -1,4 +1,3 @@
-from collections.abc import Callable
 from typing import Optional
 
 from typing_extensions import Self
@@ -103,74 +102,73 @@ class ServicePrincipal(DirectoryObject):
         self.context.add_query(qry)
         return return_type
 
-    def _get_service_principal_by_app(self, app, action):
-        # type: (Application|str, Callable[[Application], None]) -> None
-        if isinstance(app, Application):
+    def get_delegated_permissions(self, app, principal=None):
+        # type: (Application|str, User|str) -> ClientResult[StringCollection]
+        """Gets a delegated API permission"""
 
-            def _after():
-                action(app)
+        consent_type = "Principal" if principal else "AllPrincipals"
 
-            app.ensure_property("id", _after)
-        else:
-            self.context.service_principals.get_by_app(app).get().after_execute(action)
+        return_type = ClientResult(self.context, StringCollection())
 
-    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_permissions(client_id, principal_id=None):
+            # type: (str, str) -> None
 
-        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]
+            if principal_id is None:
+                query_text = "clientId eq '{0}'  and consentType eq '{1}'".format(
+                    client_id, consent_type
+                )
             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
+                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):
-        # type: (Application|str, User|str, AppRole|str) -> Self
+    def grant_delegated_permissions(self, app, principal, scope):
+        # type: (Application|str, User|str|None, AppRole|str) -> Self
         """Grants a delegated permission to the client service principal on behalf of a user"""
 
+        consent_type = "Principal" if principal else "AllPrincipals"
+
         def _grant_delegated(principal_id, client_id):
             # type: (str, str) -> None
             self.context.oauth2_permission_grants.add(
                 clientId=client_id,
-                consentType="Principal",
+                consentType=consent_type,
                 resourceId=self.id,
                 principalId=principal_id,
                 scope=scope,
@@ -198,37 +196,79 @@ 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=None, scope=None):
         # type: (Application|str, User|str, AppRole|str) -> Self
         """"""
 
-        def _revoke_delegated(app_id, principal_id):
+        def _revoke_delegated_permissions(principal_id, client_id):
             # type: (str, str) -> None
 
             def _after(return_type):
-                pass
+                if len(return_type) > 0:
+                    return_type[0].delete_object()
+
+            if principal:
+                query_text = "clientId eq '{0}' and principalId eq '{1}' and resourceId eq '{2}'".format(
+                    client_id, principal_id, self.id
+                )
+            else:
+                query_text = "clientId eq '{0}' and consentType eq 'AllPrincipals' and resourceId eq '{1}'".format(
+                    client_id, self.id
+                )
 
-            query_text = "clientId eq '{0}' and principalId eq '{1}'".format(
-                app_id, principal_id
-            )
             self.context.oauth2_permission_grants.filter(
                 query_text
             ).get().after_execute(_after)
 
-        def _ensure_principal(return_type):
+        def _principal_resolved(principal_id):
+            # type: (str) -> None
+            def _client_loaded(return_type):
+                # type: (ServicePrincipal) -> None
+                _revoke_delegated_permissions(principal_id, return_type.id)
+
+            self.context.service_principals.get_by_app(app).get().after_execute(
+                _client_loaded
+            )
+
+        def _resource_resolved():
             if isinstance(principal, User):
 
                 def _after():
-                    _revoke_delegated(principal.id, return_type.id)
+                    _principal_resolved(principal.id)
 
                 principal.ensure_property("id", _after)
             else:
-                _revoke_delegated(principal, return_type.id)
+                _principal_resolved(principal)
 
-        self._get_service_principal_by_app(app, _ensure_principal)
+        self.ensure_property("id", _resource_resolved)
         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):
+            # type: (str) -> None
+            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 +294,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 +366,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 +384,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 +559,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/directory/tenantinformation/multi_organization.py

@@ -0,0 +1,11 @@
+from office365.entity import Entity
+
+
+class MultiTenantOrganization(Entity):
+    """
+    Defines an organization with more than one instance of Microsoft Entra ID. A multitenant organization enables
+    multiple tenants to collaborate like a single entity.
+
+    There can only be one multitenant organization per active tenant. It is not possible to be part of multiple
+    multitenant organizations.
+    """

office365/directory/tenantinformation/relationship.py

@@ -0,0 +1,61 @@
+from office365.directory.tenantinformation.information import TenantInformation
+from office365.directory.tenantinformation.multi_organization import (
+    MultiTenantOrganization,
+)
+from office365.entity import Entity
+from office365.runtime.client_result import ClientResult
+from office365.runtime.paths.resource_path import ResourcePath
+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
+
+    def find_tenant_information_by_tenant_id(self, tenant_id):
+        """Given a tenant ID, search for a tenant and read its tenantInformation. You can use this API to validate
+        tenant information and use the tenantId to configure cross-tenant cross-tenant access settings between you
+        and the tenant.
+
+        :param str tenant_id: Unique tenant identifier of a Microsoft Entra tenant.
+        """
+        return_type = ClientResult(self.context, TenantInformation())
+        params = {"tenantId": tenant_id}
+        qry = FunctionQuery(
+            self, "findTenantInformationByTenantId", params, return_type
+        )
+        self.context.add_query(qry)
+        return return_type
+
+    @property
+    def multi_tenant_organization(self):
+        """Represents a setting to control people-related admin settings in the tenant."""
+        return self.properties.get(
+            "multiTenantOrganization",
+            MultiTenantOrganization(
+                self.context,
+                ResourcePath("multiTenantOrganization", self.resource_path),
+            ),
+        )
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "multiTenantOrganization": self.multi_tenant_organization,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(TenantRelationship, self).get_property(name, default_value)

office365/directory/users/insights_settings.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class UserInsightsSettings(Entity):
+    """"""

office365/graph_client.py

@@ -1,5 +1,7 @@
 from typing import Any, Callable, List, Optional
 
+from office365.admin.admin import Admin
+from office365.azure_env import AzureEnvironment
 from office365.booking.solutions.root import SolutionsRoot
 from office365.communications.cloud_communications import CloudCommunications
 from office365.delta_collection import DeltaCollection
@@ -36,7 +38,7 @@ from office365.directory.rolemanagement.management import RoleManagement
 from office365.directory.rolemanagement.role import DirectoryRole
 from office365.directory.security.security import Security
 from office365.directory.serviceprincipals.collection import ServicePrincipalCollection
-from office365.directory.tenant_relationship import TenantRelationship
+from office365.directory.tenantinformation.relationship import TenantRelationship
 from office365.directory.users.collection import UserCollection
 from office365.directory.users.user import User
 from office365.education.root import EducationRoot
@@ -47,15 +49,14 @@ from office365.intune.devices.collection import DeviceCollection
 from office365.intune.devices.management.management import DeviceManagement
 from office365.intune.organizations.contact import OrgContact
 from office365.intune.organizations.organization import Organization
-from office365.onedrive.admin import Admin
 from office365.onedrive.drives.drive import Drive
 from office365.onedrive.shares.collection import SharesCollection
 from office365.onedrive.sites.sites_with_root import SitesWithRoot
+from office365.onedrive.storage.storage import Storage
 from office365.outlook.calendar.place import Place
 from office365.outlook.calendar.rooms.list import RoomList
 from office365.planner.planner import Planner
 from office365.reports.root import ReportRoot
-from office365.runtime.auth.token_response import TokenResponse
 from office365.runtime.client_runtime_context import ClientRuntimeContext
 from office365.runtime.http.http_method import HttpMethod
 from office365.runtime.http.request_options import RequestOptions
@@ -77,157 +78,73 @@ from office365.teams.viva.employee_experience import EmployeeExperience
 class GraphClient(ClientRuntimeContext):
     """Graph Service client"""
 
-    def __init__(self, acquire_token_callback):
-        # type: (Callable[[], dict]) -> None
+    def __init__(
+        self,
+        token_callback=None,
+        tenant=None,
+        scopes=None,
+        token_cache=None,
+        environment=AzureEnvironment.Global,
+    ):
+        # type: (Callable[[], dict], str, list[str], Any, str) -> None
+        """
+        :param list[str] or None scopes: Scopes requested to access an API
+        :param Any token_cache: Default cache is in memory only,
+             Refer https://msal-python.readthedocs.io/en/latest/#msal.SerializableTokenCache
+        """
         super(GraphClient, self).__init__()
         self._pending_request = None
-        self._acquire_token_callback = acquire_token_callback
+        self._token_callback = token_callback
+        self._tenant = tenant
+        self._token_cache = token_cache
+        self._environment = environment
+        self._scopes = scopes
 
-    @staticmethod
-    def with_certificate(
-        tenant, client_id, thumbprint, private_key, scopes=None, token_cache=None
-    ):
+    def with_certificate(self, client_id, thumbprint, private_key):
         """
         Initializes the confidential client with client certificate
 
-        :param str tenant: Tenant name, for example: contoso.onmicrosoft.com
         :param str client_id: The OAuth client id of the calling application.
         :param str thumbprint: Thumbprint
         :param str private_key: Private key
-        :param list[str] or None scopes: Scopes requested to access an API
-        :param Any token_cache: Default cache is in memory only,
-        Refer https://msal-python.readthedocs.io/en/latest/#msal.SerializableTokenCache
         """
-        if scopes is None:
-            scopes = ["https://graph.microsoft.com/.default"]
-        authority_url = "https://login.microsoftonline.com/{0}".format(tenant)
-        import msal
-
-        app = msal.ConfidentialClientApplication(
-            client_id,
-            authority=authority_url,
-            client_credential={
-                "thumbprint": thumbprint,
-                "private_key": private_key,
-            },
-            token_cache=token_cache,  # Default cache is in memory only.
-            # You can learn how to use SerializableTokenCache from
-            # https://msal-python.readthedocs.io/en/latest/#msal.SerializableTokenCache
-        )
-
-        def _acquire_token():
-            return app.acquire_token_for_client(scopes=scopes)
-
-        return GraphClient(_acquire_token)
+        self.pending_request().with_certificate(client_id, thumbprint, private_key)
+        return self
 
-    @staticmethod
-    def with_client_secret(
-        tenant, client_id, client_secret, scopes=None, token_cache=None
-    ):
-        # type: (str, str, str, List[str], Any) -> "GraphClient"
+    def with_client_secret(self, client_id, client_secret):
+        # type: (str, str) -> "GraphClient"
         """
         Initializes the confidential client with client secret
 
-        :param str tenant: Tenant name, for example: contoso.onmicrosoft.com
         :param str client_id: The OAuth client id of the calling application.
         :param str client_secret: Client secret
-        :param list[str] or None scopes: Scopes requested to access an API
-        :param Any token_cache: Default cache is in memory only,
-             Refer https://msal-python.readthedocs.io/en/latest/#msal.SerializableTokenCache
         """
-        if scopes is None:
-            scopes = ["https://graph.microsoft.com/.default"]
-        authority_url = "https://login.microsoftonline.com/{0}".format(tenant)
-        import msal
-
-        app = msal.ConfidentialClientApplication(
-            client_id,
-            authority=authority_url,
-            client_credential=client_secret,
-            token_cache=token_cache,
-        )
-
-        def _acquire_token():
-            return app.acquire_token_for_client(scopes=scopes)
-
-        return GraphClient(_acquire_token)
+        self.pending_request().with_client_secret(client_id, client_secret)
+        return self
 
-    @staticmethod
-    def with_token_interactive(tenant, client_id, username=None, scopes=None):
-        # type: (str, str, Optional[str], List[str]) -> "GraphClient"
+    def with_token_interactive(self, client_id, username=None):
+        # type: (str, Optional[str]) -> "GraphClient"
         """
         Initializes the client via user credentials
         Note: only works if your app is registered with redirect_uri as http://localhost
 
-        :param str tenant: Tenant name, for example: contoso.onmicrosoft.com
         :param str client_id: The OAuth client id of the calling application.
         :param str username: Typically a UPN in the form of an email address.
-        :param list[str] or None scopes: Scopes requested to access an API
         """
-        if scopes is None:
-            scopes = ["https://graph.microsoft.com/.default"]
-        authority_url = "https://login.microsoftonline.com/{0}".format(tenant)
-        import msal
-
-        app = msal.PublicClientApplication(client_id, authority=authority_url)
-
-        def _acquire_token():
-            # The pattern to acquire a token looks like this.
-            result = None
-
-            # Firstly, check the cache to see if this end user has signed in before
-            accounts = app.get_accounts(username=username)
-            if accounts:
-                chosen = accounts[0]  # Assuming the end user chose this one to proceed
-                # Now let's try to find a token in cache for this account
-                result = app.acquire_token_silent(scopes, account=chosen)
-
-            if not result:
-                result = app.acquire_token_interactive(
-                    scopes,
-                    login_hint=username,
-                )
-            return result
-
-        return GraphClient(_acquire_token)
-
-    @staticmethod
-    def with_username_and_password(tenant, client_id, username, password, scopes=None):
-        # type: (str, str, str, str, List[str]) -> "GraphClient"
+        self.pending_request().with_token_interactive(client_id, username)
+        return self
+
+    def with_username_and_password(self, client_id, username, password):
+        # type: (str, str, str) -> "GraphClient"
         """
         Initializes the client via user credentials
 
-        :param str tenant: Tenant name, for example: contoso.onmicrosoft.com
         :param str client_id: The OAuth client id of the calling application.
         :param str username: Typically a UPN in the form of an email address.
         :param str password: The password.
-        :param list[str] or None scopes: Scopes requested to access an API
         """
-        if scopes is None:
-            scopes = ["https://graph.microsoft.com/.default"]
-        authority_url = "https://login.microsoftonline.com/{0}".format(tenant)
-        import msal
-
-        app = msal.PublicClientApplication(
-            authority=authority_url,
-            client_id=client_id,
-        )
-
-        def _acquire_token():
-            result = None
-            accounts = app.get_accounts(username=username)
-            if accounts:
-                result = app.acquire_token_silent(scopes, account=accounts[0])
-
-            if not result:
-                result = app.acquire_token_by_username_password(
-                    username=username,
-                    password=password,
-                    scopes=scopes,
-                )
-            return result
-
-        return GraphClient(_acquire_token)
+        self.pending_request().with_username_and_password(client_id, username, password)
+        return self
 
     def execute_batch(self, items_per_batch=20, success_callback=None):
         """Constructs and submit a batch request
@@ -238,7 +155,7 @@ class GraphClient(ClientRuntimeContext):
         :param (List[ClientObject|ClientResult])-> None success_callback: A success callback
         """
         batch_request = ODataV4BatchRequest(V4JsonFormat())
-        batch_request.beforeExecute += self._authenticate_request
+        batch_request.beforeExecute += self.pending_request().authenticate_request
         while self.has_pending_request:
             qry = self._get_next_query(items_per_batch)
             batch_request.execute_query(qry)
@@ -249,8 +166,11 @@ class GraphClient(ClientRuntimeContext):
     def pending_request(self):
         # type: () -> GraphRequest
         if self._pending_request is None:
-            self._pending_request = GraphRequest()
-            self._pending_request.beforeExecute += self._authenticate_request
+            self._pending_request = GraphRequest(
+                tenant=self._tenant, environment=self._environment
+            )
+            if callable(self._token_callback):
+                self._pending_request.with_access_token(self._token_callback)
             self._pending_request.beforeExecute += self._build_specific_query
         return self._pending_request
 
@@ -266,13 +186,6 @@ class GraphClient(ClientRuntimeContext):
         elif isinstance(self.current_query, DeleteEntityQuery):
             request.method = HttpMethod.Delete
 
-    def _authenticate_request(self, request):
-        # type: (RequestOptions) -> None
-        """Authenticate request."""
-        token_json = self._acquire_token_callback()
-        token = TokenResponse.from_json(token_json)
-        request.ensure_header("Authorization", "Bearer {0}".format(token.accessToken))
-
     @property
     def admin(self):
         """A container for administrator functionality for SharePoint and OneDrive."""
@@ -475,6 +388,13 @@ class GraphClient(ClientRuntimeContext):
         """
         return InformationProtection(self, ResourcePath("informationProtection"))
 
+    @property
+    def storage(self):
+        """
+        Facilitates the structures of fileStorageContainers.
+        """
+        return Storage(self, ResourcePath("storage"))
+
     @property
     def subscriptions(self):
         """