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

office365/directory/permissions/grants/condition_set.py

@@ -19,6 +19,23 @@ class PermissionGrantConditionSet(Entity):
         """
         return self.properties.get("clientApplicationIds", StringCollection())
 
+    @property
+    def client_application_publisher_ids(self):
+        """
+        A list of Microsoft Partner Network (MPN) IDs for verified publishers of the client application,  or a list
+        with the single value all to match with client apps from any publisher. Default is the single value all.
+        """
+        return self.properties.get("clientApplicationPublisherIds", StringCollection())
+
+    @property
+    def client_applications_from_verified_publisher_only(self):
+        """
+        Set to true to only match on client applications with a verified publisher. Set to false to match on any client
+        app, even if it does not have a verified publisher. Default is false.
+        :rtype: bool
+        """
+        return self.properties.get("clientApplicationsFromVerifiedPublisherOnly", None)
+
     @property
     def permissions(self):
         """
@@ -30,3 +47,12 @@ class PermissionGrantConditionSet(Entity):
         Default is the single value all.
         """
         return self.properties.get("permissions", StringCollection())
+
+    @property
+    def resource_application(self):
+        """
+        The appId of the resource application (e.g. the API) for which a permission is being granted, or any to match
+        with any resource application or API. Default is any.
+        :rtype: str
+        """
+        return self.properties.get("resourceApplication", None)

office365/directory/permissions/grants/resource_specific.py

@@ -17,3 +17,24 @@ class ResourceSpecificPermissionGrant(DirectoryObject):
         """ID of the service principal of the Azure AD app that has been granted access."""
         return self.properties.get("clientAppId", None)
 
+    @property
+    def permission(self):
+        """The name of the resource-specific permission.
+        :rtype: str
+        """
+        return self.properties.get("permission", None)
+
+    @property
+    def permission_type(self):
+        """The type of permission. Possible values are: Application, Delegated. Read-only.
+        :rtype: str
+        """
+        return self.properties.get("permissionType", None)
+
+    @property
+    def resource_app_id(self):
+        """ID of the Azure AD app that is hosting the resource. Read-only.
+        :rtype: str
+        """
+        return self.properties.get("resourceAppId", None)
+

office365/directory/policies/authentication_flows.py

@@ -0,0 +1,9 @@
+from office365.entity import Entity
+
+
+class AuthenticationFlowsPolicy(Entity):
+    """
+    Represents the policy configuration of self-service sign-up experience at a tenant level that lets external
+    users request to sign up for approval. It contains information, such as the identifier, display name, and
+    description, and indicates whether self-service sign-up is enabled for the policy.
+    """

office365/directory/policies/authentication_strength.py

@@ -0,0 +1,10 @@
+from office365.entity import Entity
+
+
+class AuthenticationStrengthPolicy(Entity):
+    """
+    A collection of settings that define specific combinations of authentication methods and metadata.
+    The authentication strength policy, when applied to a given scenario using Azure AD Conditional Access,
+    defines which authentication methods must be used to authenticate in that scenario. An authentication strength
+    may be built-in or custom (defined by the tenant) and may or may not fulfill the requirements to grant an MFA claim.
+    """

office365/directory/policies/authorization.py

@@ -4,3 +4,11 @@ from office365.directory.policies.base import PolicyBase
 class AuthorizationPolicy(PolicyBase):
     """Represents a policy that can control Azure Active Directory authorization settings.
     It's a singleton that inherits from base policy type, and always exists for the tenant."""
+
+    @property
+    def allowed_to_sign_up_email_based_subscriptions(self):
+        """
+        Indicates whether a user can join the tenant by email validation.
+        :rtype: bool
+        """
+        return self.properties.get("allowedToSignUpEmailBasedSubscriptions", None)

office365/directory/policies/cross_tenant_access.py

@@ -0,0 +1,5 @@
+from office365.directory.policies.base import PolicyBase
+
+
+class CrossTenantAccessPolicy(PolicyBase):
+    """Represents the base policy in the directory for cross-tenant access settings."""

office365/directory/policies/root.py

@@ -1,4 +1,8 @@
+from office365.directory.policies.app_management import AppManagementPolicy
+from office365.directory.policies.authentication_flows import AuthenticationFlowsPolicy
 from office365.directory.policies.authentication_methods import AuthenticationMethodsPolicy
+from office365.directory.policies.authentication_strength import AuthenticationStrengthPolicy
+from office365.directory.policies.cross_tenant_access import CrossTenantAccessPolicy
 from office365.directory.policies.permission_grant import PermissionGrantPolicy
 from office365.directory.policies.authorization import AuthorizationPolicy
 from office365.directory.policies.conditional_access import ConditionalAccessPolicy
@@ -21,6 +25,22 @@ class PolicyRoot(Entity):
                                                                ResourcePath("authenticationMethodsPolicy",
                                                                             self.resource_path)))
 
+    def authentication_strength_policies(self):
+        """
+        The authentication method combinations that are to be used in scenarios defined by Azure AD Conditional Access.
+        """
+        return self.properties.get('authenticationStrengthPolicies',
+                                   EntityCollection(self.context, AuthenticationStrengthPolicy,
+                                                    ResourcePath("authenticationStrengthPolicies", self.resource_path)))
+
+    @property
+    def authentication_flows_policy(self):
+        """	The policy configuration of the self-service sign-up experience of external users."""
+        return self.properties.get('authenticationFlowsPolicy',
+                                   AuthenticationFlowsPolicy(self.context,
+                                                             ResourcePath("authenticationFlowsPolicy",
+                                                                          self.resource_path)))
+
     @property
     def authorization_policy(self):
         """The policy that controls Azure AD authorization settings."""
@@ -33,8 +53,18 @@ class PolicyRoot(Entity):
         """The policies that enforce app management restrictions for specific applications and service principals,
         overriding the defaultAppManagementPolicy."""
         return self.properties.get('appManagementPolicies',
-                                   AuthorizationPolicy(self.context,
-                                                       ResourcePath("appManagementPolicies", self.resource_path)))
+                                   EntityCollection(self.context, AppManagementPolicy,
+                                                    ResourcePath("appManagementPolicies", self.resource_path)))
+
+    @property
+    def cross_tenant_access_policy(self):
+        """
+        The custom rules that define an access scenario when interacting with external Azure AD tenants.
+        """
+        return self.properties.get('crossTenantAccessPolicy',
+                                   CrossTenantAccessPolicy(self.context,
+                                                           ResourcePath("crossTenantAccessPolicy",
+                                                                        self.resource_path)))
 
     @property
     def permission_grant_policies(self):
@@ -57,10 +87,13 @@ class PolicyRoot(Entity):
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_mapping = {
+                "authenticationStrengthPolicies": self.authentication_strength_policies,
+                "authenticationFlowsPolicy": self.authentication_flows_policy,
                 "appManagementPolicies": self.app_management_policies,
                 "authenticationMethodsPolicy": self.authentication_methods_policy,
                 "authorizationPolicy": self.authorization_policy,
                 "conditional_access_policies": self.conditional_access_policies,
+                "crossTenantAccessPolicy": self.cross_tenant_access_policy,
                 "permissionGrantPolicies": self.permission_grant_policies,
             }
             default_value = property_mapping.get(name, None)

office365/directory/rolemanagement/template.py

@@ -4,3 +4,11 @@ from office365.directory.object import DirectoryObject
 class DirectoryRoleTemplate(DirectoryObject):
     """Represents a directory role template. A directory role template specifies the property values of a directory
     role (directoryRole). """
+
+    @property
+    def display_name(self):
+        """
+        The display name to set for the directory role
+        :rtype: str
+        """
+        return self.properties.get("displayName", None)

office365/directory/rolemanagement/unified_role_assignment.py

@@ -1,4 +1,6 @@
+from office365.directory.rolemanagement.unified_role_definition import UnifiedRoleDefinition
 from office365.entity import Entity
+from office365.runtime.paths.resource_path import ResourcePath
 
 
 class UnifiedRoleAssignment(Entity):
@@ -6,3 +8,38 @@ class UnifiedRoleAssignment(Entity):
     A role assignment is used to grant access to resources. It represents a role definition assigned to a principal
     (for example, a user or a role-assignable group) at a particular scope.
     """
+
+    @property
+    def app_scope_id(self):
+        """
+        Identifier of the app-specific scope when the assignment scope is app-specific. Either this property or
+        directoryScopeId is required. App scopes are scopes that are defined and understood by this application only.
+        Use / for tenant-wide app scopes. Use directoryScopeId to limit the scope to particular directory objects,
+        for example, administrative units. Supports $filter (eq, in).
+        :rtype: str
+        """
+        return self.properties.get("appScopeId", None)
+
+    @property
+    def condition(self):
+        """
+        :rtype: str
+        """
+        return self.properties.get("condition", None)
+
+    @property
+    def role_definition(self):
+        """
+        The roleDefinition the assignment is for. Supports $expand. roleDefinition.Id will be auto expanded.
+        """
+        return self.properties.get('roleDefinition',
+                                   UnifiedRoleDefinition(self.context,
+                                                         ResourcePath("roleDefinition", self.resource_path)))
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "roleDefinition": self.role_definition,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(UnifiedRoleAssignment, self).get_property(name, default_value)

office365/directory/security/alerts/alert.py

@@ -1,4 +1,5 @@
 from office365.directory.security.alerts.evidence import AlertEvidence
+from office365.directory.security.alerts.history_state import AlertHistoryState
 from office365.entity import Entity
 from office365.runtime.client_value_collection import ClientValueCollection
 
@@ -8,7 +9,27 @@ class Alert(Entity):
     representing potential security issues within a customer's tenant that Microsoft 365 Defender,
     or a security provider integrated with Microsoft 365 Defender, has identified."""
 
+    @property
+    def actor_display_name(self):
+        """
+        The adversary or activity group that is associated with this alert.
+        :rtype: str
+        """
+        return self.properties.get("actorDisplayName", None)
+
+    @property
+    def alert_policy_id(self):
+        """
+        :rtype: str
+        """
+        return self.properties.get("alertPolicyId", None)
+
     @property
     def evidence(self):
         """Collection of evidence related to the alert."""
         return self.properties.get("evidence", ClientValueCollection(AlertEvidence))
+
+    @property
+    def history_states(self):
+        """Collection of changes for the alert."""
+        return self.properties.get("historyStates", ClientValueCollection(AlertHistoryState))

office365/directory/security/alerts/history_state.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class AlertHistoryState(ClientValue):
+    """Stores changes made to alerts."""

office365/directory/security/attacksimulations/automation.py

@@ -0,0 +1,21 @@
+from office365.directory.permissions.email_identity import EmailIdentity
+from office365.directory.security.attacksimulations.automation_run import SimulationAutomationRun
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class SimulationAutomation(Entity):
+    """Represents simulation automation created to run on a tenant."""
+
+    @property
+    def created_by(self):
+        """Identity of the user who created the attack simulation automation."""
+        return self.properties.get('createdBy', EmailIdentity())
+
+    @property
+    def runs(self):
+        """A collection of simulation automation runs."""
+        return self.properties.get('runs',
+                                   EntityCollection(self.context, SimulationAutomationRun,
+                                                    ResourcePath("runs", self.resource_path)))

office365/directory/security/attacksimulations/automation_run.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class SimulationAutomationRun(Entity):
+    """Represents a run of an attack simulation automation on a tenant."""

office365/directory/security/attacksimulations/repeat_offender.py

@@ -0,0 +1,6 @@
+from office365.runtime.client_value import ClientValue
+
+
+class AttackSimulationRepeatOffender(ClientValue):
+    """Represents a user in a tenant who has given way to attacks more than once across various attack simulation
+    and training campaigns."""

office365/directory/security/attacksimulations/root.py

@@ -1,6 +1,32 @@
+from office365.directory.security.attacksimulations.automation import SimulationAutomation
+from office365.directory.security.attacksimulations.simulation import Simulation
 from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.runtime.paths.resource_path import ResourcePath
 
 
 class AttackSimulationRoot(Entity):
     """Represents an abstract type that provides the ability to launch a realistic phishing attack that organizations
     can learn from."""
+
+    @property
+    def simulations(self):
+        """Represents an attack simulation training campaign in a tenant."""
+        return self.properties.get('simulations',
+                                   EntityCollection(self.context, Simulation,
+                                                    ResourcePath("simulations", self.resource_path)))
+
+    @property
+    def simulation_automations(self):
+        """Represents simulation automation created to run on a tenant."""
+        return self.properties.get('simulationAutomations',
+                                   EntityCollection(self.context, SimulationAutomation,
+                                                    ResourcePath("simulationAutomations", self.resource_path)))
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "simulationAutomations": self.simulation_automations,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(AttackSimulationRoot, self).get_property(name, default_value)

office365/directory/security/attacksimulations/simulation.py

@@ -0,0 +1,17 @@
+from office365.entity import Entity
+
+
+class Simulation(Entity):
+    """
+    Represents an attack simulation training campaign in a tenant.
+
+    Attack simulation and training is a service available as part of Microsoft Defender for Office 365.
+    This service lets tenant users experience a realistic benign phishing attack and learn from it.
+    The service enables tenant administrators to simulate, assign trainings, and read derived insights into online
+    behaviors of users in the phishing simulations. The service provides attack simulation reports that help tenants
+    identify security knowledge gaps, so that they can further train their users to decrease their susceptibility
+    to attacks.
+
+    The attack simulation and training API enables tenant administrators to list launched simulation exercises
+    and trainings, and get reports on derived insights into online behaviors of users in the phishing simulations.
+    """

office365/directory/security/cases/ediscovery.py

@@ -0,0 +1,6 @@
+from office365.entity import Entity
+
+
+class EdiscoveryCase(Entity):
+    """In the context of eDiscovery, contains custodians, searches, review sets. For details, see Overview of
+    Microsoft Purview eDiscovery (Premium)."""

office365/directory/security/cases/root.py

@@ -0,0 +1,22 @@
+from office365.directory.security.cases.ediscovery import EdiscoveryCase
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class CasesRoot(Entity):
+    """"""
+
+    @property
+    def ediscovery_cases(self):
+        return self.properties.get('ediscoveryCases',
+                                   EntityCollection(self.context, EdiscoveryCase,
+                                                    ResourcePath("ediscoveryCases", self.resource_path)))
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "ediscoveryCases": self.ediscovery_cases
+            }
+            default_value = property_mapping.get(name, None)
+        return super(CasesRoot, self).get_property(name, default_value)

office365/directory/security/incidents/incident.py

@@ -0,0 +1,67 @@
+from datetime import datetime
+
+from office365.directory.security.alerts.alert import Alert
+from office365.directory.security.alerts.comment import AlertComment
+from office365.entity import Entity
+from office365.entity_collection import EntityCollection
+from office365.runtime.client_value_collection import ClientValueCollection
+from office365.runtime.paths.resource_path import ResourcePath
+
+
+class Incident(Entity):
+    """
+    An incident in Microsoft 365 Defender is a collection of correlated alert instances and associated metadata
+    that reflects the story of an attack in a tenant.
+
+    Microsoft 365 services and apps create alerts when they detect a suspicious or malicious event or activity.
+    Individual alerts provide valuable clues about a completed or ongoing attack. However, attacks typically employ
+    various techniques against different types of entities, such as devices, users, and mailboxes. The result is
+    multiple alerts for multiple entities in your tenant. Because piecing the individual alerts together to gain
+    insight into an attack can be challenging and time-consuming, Microsoft 365 Defender automatically aggregates the
+    alerts and their associated information into an incident.
+    """
+
+    @property
+    def assigned_to(self):
+        """
+        Owner of the incident, or null if no owner is assigned. Free editable text.
+        :rtype: str or None
+        """
+        return self.properties.get("assignedTo", None)
+
+    @property
+    def classification(self):
+        """
+        The specification for the incident.
+        Possible values are: unknown, falsePositive, truePositive, informationalExpectedActivity, unknownFutureValue.
+        :rtype: str or None
+        """
+        return self.properties.get("classification", None)
+
+    @property
+    def comments(self):
+        """
+        Array of comments created by the Security Operations (SecOps) team when the incident is managed.
+        """
+        return self.properties.get("comments", ClientValueCollection(AlertComment))
+
+    @property
+    def created_datetime(self):
+        """
+        Time when the incident was first created.
+        """
+        return self.properties("createdDateTime", datetime.min)
+
+    @property
+    def alerts(self):
+        """The list of related alerts. Supports $expand."""
+        return self.properties.get('alerts',
+                                   EntityCollection(self.context, Alert, ResourcePath("alerts", self.resource_path)))
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "createdDateTime": self.created_datetime
+            }
+            default_value = property_mapping.get(name, None)
+        return super(Incident, self).get_property(name, default_value)

office365/directory/security/security.py

@@ -1,6 +1,7 @@
 from office365.directory.security.alerts.alert import Alert
 from office365.directory.security.attacksimulations.root import AttackSimulationRoot
-from office365.directory.security.cases_root import CasesRoot
+from office365.directory.security.cases.root import CasesRoot
+from office365.directory.security.incidents.incident import Incident
 from office365.directory.security.triggers.root import TriggersRoot
 from office365.entity import Entity
 from office365.entity_collection import EntityCollection
@@ -37,6 +38,14 @@ class Security(Entity):
                                    AttackSimulationRoot(self.context,
                                                         ResourcePath("attackSimulation", self.resource_path)))
 
+    @property
+    def incidents(self):
+        """A collection of correlated alert instances and associated metadata that reflects the story of
+        an attack in a tenant"""
+        return self.properties.get('incidents',
+                                   EntityCollection(self.context, Incident,
+                                                    ResourcePath("incidents", self.resource_path)))
+
     @property
     def triggers(self):
         return self.properties.get('triggers',

office365/directory/serviceprincipals/service_principal.py

@@ -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."""