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

office365/directory/identitygovernance/userconsent/request_collection.py

@@ -2,6 +2,7 @@ from office365.directory.identitygovernance.userconsent.request import (
     UserConsentRequest,
 )
 from office365.entity_collection import EntityCollection
+from office365.runtime.queries.function import FunctionQuery
 
 
 class UserConsentRequestCollection(EntityCollection[UserConsentRequest]):
@@ -11,3 +12,12 @@ class UserConsentRequestCollection(EntityCollection[UserConsentRequest]):
         super(UserConsentRequestCollection, self).__init__(
             context, UserConsentRequest, resource_path
         )
+
+    def filter_by_current_user(self, on):
+        """Retrieve a collection of userConsentRequest objects for accessing a specified app, for which the current
+        user is the reviewer."""
+        return_type = UserConsentRequestCollection(self.context, self.resource_path)
+        params = {"on": on}
+        qry = FunctionQuery(self, "filterByCurrentUser", params, return_type)
+        self.context.add_query(qry)
+        return return_type

office365/directory/identitygovernance/workflow/base.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class WorkflowBase(Entity):
+    """An abstract type that exposes the properties for configuring a custom lifecycle workflow."""

office365/directory/permissions/scope.py

@@ -15,8 +15,13 @@ class PermissionScope(ClientValue):
         self,
         admin_consent_display_name=None,
         admin_consent_description=None,
-        _id=None,
+        id_=None,
         is_enabled=None,
+        origin=None,
+        type_=None,
+        user_consent_description=None,
+        user_consent_display_name=None,
+        value=None,
     ):
         """
         :param str admin_consent_display_name: The permission's title, intended to be read by an administrator granting
@@ -24,13 +29,20 @@ class PermissionScope(ClientValue):
         :param str admin_consent_description: A description of the delegated permissions, intended to be read
             by an administrator granting the permission on behalf of all users. This text appears in tenant-wide
             admin consent experiences.
-        :param str _id: Unique delegated permission identifier inside the collection of delegated permissions defined
+        :param str id_: Unique delegated permission identifier inside the collection of delegated permissions defined
             for a resource application.
         :param str is_enabled: When creating or updating a permission, this property must be set to true
             (which is the default). To delete a permission, this property must first be set to false.
             At that point, in a subsequent call, the permission may be removed.
+
+        :param str value: Specifies the value to include in the scp (scope) claim in access tokens.
         """
         self.adminConsentDescription = admin_consent_description
         self.adminConsentDisplayName = admin_consent_display_name
-        self.id = _id
+        self.id = id_
         self.isEnabled = is_enabled
+        self.origin = origin
+        self.type = type_
+        self.userConsentDescription = user_consent_description
+        self.userConsentDisplayName = user_consent_display_name
+        self.value = value

office365/directory/policies/authentication_strength.py

@@ -1,9 +1,13 @@
 from office365.directory.authentication.strength_usage import (
     AuthenticationStrengthUsage,
 )
+from office365.directory.policies.update_allowed_combinations_result import (
+    UpdateAllowedCombinationsResult,
+)
 from office365.entity import Entity
 from office365.runtime.client_result import ClientResult
 from office365.runtime.queries.function import FunctionQuery
+from office365.runtime.queries.service_operation import ServiceOperationQuery
 
 
 class AuthenticationStrengthPolicy(Entity):
@@ -26,3 +30,20 @@ class AuthenticationStrengthPolicy(Entity):
         qry = FunctionQuery(self, "usage", None, return_type)
         self.context.add_query(qry)
         return return_type
+
+    def update_allowed_combinations(self, allowed_combinations=None):
+        """
+        Update the allowedCombinations property of an authenticationStrengthPolicy object.
+        To update other properties of an authenticationStrengthPolicy object,
+        use the Update authenticationStrengthPolicy method.
+
+        :param list[str] allowed_combinations: The authentication method combinations allowed by this authentication
+             strength policy.
+        """
+        return_type = ClientResult(self.context, UpdateAllowedCombinationsResult())
+        payload = {"allowedCombinations": allowed_combinations}
+        qry = ServiceOperationQuery(
+            self, "updateAllowedCombinations", None, payload, None, return_type
+        )
+        self.context.add_query(qry)
+        return return_type

office365/directory/policies/cross_tenant_access.py

@@ -1,4 +1,6 @@
 from office365.directory.policies.base import PolicyBase
+from office365.directory.policies.template import PolicyTemplate
+from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.types.collections import StringCollection
 
 
@@ -13,3 +15,14 @@ class CrossTenantAccessPolicy(PolicyBase):
         and partner.microsoftonline.cn.
         """
         return self.properties.get("allowedCloudEndpoints", StringCollection())
+
+    def templates(self):
+        # type: () -> PolicyTemplate
+        """Represents the base policy in the directory for multitenant organization settings."""
+        return self.properties.get(
+            "templates",
+            PolicyTemplate(
+                self.context,
+                ResourcePath("templates", self.resource_path),
+            ),
+        )

office365/directory/policies/feature_rollout.py

@@ -0,0 +1,16 @@
+from office365.entity import Entity
+
+
+class FeatureRolloutPolicy(Entity):
+    """
+    Represents a feature rollout policy associated with a directory object. Creating a feature rollout policy
+    helps tenant administrators to pilot features of Microsoft Entra ID with a specific group before enabling
+    features for entire organization. This minimizes the impact and helps administrators to test and rollout
+    authentication related features gradually.
+
+    The following are limitations of feature rollout:
+
+     - Each feature supports a maximum of 10 groups.
+     - The appliesTo field only supports groups.
+     - Dynamic groups and nested groups are not supported.
+    """

office365/directory/policies/root.py

@@ -11,6 +11,7 @@ from office365.directory.policies.authorization import AuthorizationPolicy
 from office365.directory.policies.conditional_access import ConditionalAccessPolicy
 from office365.directory.policies.cross_tenant_access import CrossTenantAccessPolicy
 from office365.directory.policies.device_registration import DeviceRegistrationPolicy
+from office365.directory.policies.feature_rollout import FeatureRolloutPolicy
 from office365.directory.policies.permission_grant import PermissionGrantPolicy
 from office365.directory.policies.tenant_app_management import TenantAppManagementPolicy
 from office365.directory.policies.unified_role_management import (
@@ -52,16 +53,6 @@ class PolicyRoot(Entity):
         )
 
     @property
-    def device_registration_policy(self):
-        """ """
-        return self.properties.get(
-            "deviceRegistrationPolicy",
-            DeviceRegistrationPolicy(
-                self.context,
-                ResourcePath("deviceRegistrationPolicy", self.resource_path),
-            ),
-        )
-
     def authentication_strength_policies(self):
         # type: () -> EntityCollection[AuthenticationStrengthPolicy]
         """
@@ -111,6 +102,19 @@ class PolicyRoot(Entity):
             ),
         )
 
+    @property
+    def conditional_access_policies(self):
+        # type: () -> EntityCollection[ConditionalAccessPolicy]
+        """The custom rules that define an access scenario"""
+        return self.properties.get(
+            "conditionalAccessPolicies",
+            EntityCollection(
+                self.context,
+                ConditionalAccessPolicy,
+                ResourcePath("conditionalAccessPolicies", self.resource_path),
+            ),
+        )
+
     @property
     def cross_tenant_access_policy(self):
         """
@@ -124,6 +128,17 @@ class PolicyRoot(Entity):
             ),
         )
 
+    @property
+    def device_registration_policy(self):
+        """ """
+        return self.properties.get(
+            "deviceRegistrationPolicy",
+            DeviceRegistrationPolicy(
+                self.context,
+                ResourcePath("deviceRegistrationPolicy", self.resource_path),
+            ),
+        )
+
     @property
     def default_app_management_policy(self):
         """
@@ -137,6 +152,19 @@ class PolicyRoot(Entity):
             ),
         )
 
+    @property
+    def feature_rollout_policies(self):
+        # type: () -> EntityCollection[FeatureRolloutPolicy]
+        """The feature rollout policy associated with a directory object."""
+        return self.properties.get(
+            "featureRolloutPolicies",
+            EntityCollection(
+                self.context,
+                FeatureRolloutPolicy,
+                ResourcePath("featureRolloutPolicies", self.resource_path),
+            ),
+        )
+
     @property
     def permission_grant_policies(self):
         # type: () -> EntityCollection[PermissionGrantPolicy]
@@ -152,19 +180,6 @@ class PolicyRoot(Entity):
             ),
         )
 
-    @property
-    def conditional_access_policies(self):
-        # type: () -> EntityCollection[ConditionalAccessPolicy]
-        """The custom rules that define an access scenario"""
-        return self.properties.get(
-            "conditionalAccessPolicies",
-            EntityCollection(
-                self.context,
-                ConditionalAccessPolicy,
-                ResourcePath("conditionalAccessPolicies", self.resource_path),
-            ),
-        )
-
     @property
     def role_management_policies(self):
         # type: () -> EntityCollection[UnifiedRoleManagementPolicy]
@@ -191,6 +206,7 @@ class PolicyRoot(Entity):
                 "crossTenantAccessPolicy": self.cross_tenant_access_policy,
                 "defaultAppManagementPolicy": self.default_app_management_policy,
                 "deviceRegistrationPolicy": self.device_registration_policy,
+                "featureRolloutPolicies": self.feature_rollout_policies,
                 "permissionGrantPolicies": self.permission_grant_policies,
                 "roleManagementPolicies": self.role_management_policies,
             }

office365/directory/policies/template.py

@@ -0,0 +1,5 @@
+from office365.entity import Entity
+
+
+class PolicyTemplate(Entity):
+    """Represents the base policy in the directory for multitenant organization settings."""

office365/directory/policies/update_allowed_combinations_result.py

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

office365/directory/protection/threatassessment/email_file_request.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+from office365.directory.protection.threatassessment.request import (
+    ThreatAssessmentRequest,
+)
+
+
+class EmailFileAssessmentRequest(ThreatAssessmentRequest):
+    """
+    Represents a resource that creates and retrieves an email file threat assessment.
+    The email file can be an .eml file type.
+    """
+
+    @property
+    def content_data(self):
+        # type: () -> Optional[str]
+        """
+        Base64 encoded .eml email file content. The file content can't fetch back because it isn't stored.
+        """
+        return self.properties.get("contentData", None)

office365/directory/protection/threatassessment/request.py

@@ -1,5 +1,30 @@
+from datetime import datetime
+
+from office365.directory.permissions.identity_set import IdentitySet
 from office365.entity import Entity
 
 
 class ThreatAssessmentRequest(Entity):
     """An abstract resource type used to represent a threat assessment request item."""
+
+    @property
+    def created_by(self):
+        """The threat assessment request creator."""
+        return self.properties.get("createdBy", IdentitySet())
+
+    @property
+    def created_datetime(self):
+        """
+        The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time.
+        For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z
+        """
+        return self.properties.get("createdDateTime", datetime.min)
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "createdDateTime": self.created_datetime,
+                "createdBy": self.created_by,
+            }
+            default_value = property_mapping.get(name, None)
+        return super(ThreatAssessmentRequest, self).get_property(name, default_value)

office365/directory/rolemanagement/application.py

@@ -1,3 +1,6 @@
+from office365.directory.identitygovernance.privilegedaccess.unified_role_assignment_schedule_request import (
+    UnifiedRoleAssignmentScheduleRequest,
+)
 from office365.directory.rolemanagement.unified_role_assignment import (
     UnifiedRoleAssignment,
 )
@@ -40,6 +43,18 @@ class RbacApplication(Entity):
             ),
         )
 
+    def role_assignment_schedule_requests(self):
+        # type: () -> EntityCollection[UnifiedRoleAssignmentScheduleRequest]
+        """Resource representing the roles allowed by RBAC providers and the permissions assigned to the roles."""
+        return self.properties.get(
+            "roleAssignmentScheduleRequests",
+            EntityCollection(
+                self.context,
+                UnifiedRoleAssignmentScheduleRequest,
+                ResourcePath("roleAssignmentScheduleRequests", self.resource_path),
+            ),
+        )
+
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_mapping = {

office365/directory/rolemanagement/resource_action.py

@@ -3,8 +3,12 @@ from office365.runtime.types.collections import StringCollection
 
 
 class ResourceAction(ClientValue):
-    """ """
+    """Set of allowed and not allowed actions for a resource."""
 
-    def __init__(self):
-        self.allowedResourceActions = StringCollection()
-        self.notAllowedResourceActions = StringCollection()
+    def __init__(self, allowed=None, not_allowed=None):
+        """
+        :param list[str] allowed: Allowed Actions
+        :param list[str] not_allowed: Not Allowed Actions.
+        """
+        self.allowedResourceActions = StringCollection(allowed)
+        self.notAllowedResourceActions = StringCollection(not_allowed)

office365/directory/rolemanagement/role_permission.py

@@ -4,7 +4,7 @@ from office365.runtime.client_value_collection import ClientValueCollection
 
 
 class RolePermission(ClientValue):
-    """ """
+    """Contains the set of ResourceActions determining the allowed and not allowed permissions for each role."""
 
-    def __init__(self, resourceActions=None):
-        self.resourceActions = ClientValueCollection(ResourceAction, resourceActions)
+    def __init__(self, resource_actions=None):
+        self.resourceActions = ClientValueCollection(ResourceAction, resource_actions)

office365/directory/security/alerts/collection.py

@@ -0,0 +1,49 @@
+from office365.directory.security.alerts.alert import Alert
+from office365.entity_collection import EntityCollection
+from office365.runtime.http.request_options import RequestOptions
+
+
+class AlertCollection(EntityCollection[Alert]):
+    """Service Principal's collection"""
+
+    def __init__(self, context, resource_path=None):
+        super(AlertCollection, self).__init__(context, Alert, resource_path)
+
+    def add(
+        self,
+        title,
+        description=None,
+        severity=None,
+        category=None,
+        status=None,
+        source=None,
+        vendor_information=None,
+    ):
+        """
+        Creates an alert object.
+        :param str title:
+        :param str description:
+        :param str severity:
+        :param str category:
+        :param str status:
+        :param str source:
+        :param str vendor_information:
+        """
+
+        def _construct_request(request):
+            # type: (RequestOptions) -> None
+            request.set_header("Content-Type", "application/json")
+
+        return (
+            super(AlertCollection, self)
+            .add(
+                title=title,
+                description=description,
+                severity=severity,
+                category=category,
+                status=status,
+                source=source,
+                vendorInformation=vendor_information,
+            )
+            .before_execute(_construct_request)
+        )

office365/directory/security/alerts/evidence.py

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

office365/directory/security/alerts/malware_evidence.py

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

office365/directory/security/alerts/process_evidence.py

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

office365/directory/security/attacksimulations/user.py

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

office365/directory/security/attacksimulations/user_coverage.py

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

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

@@ -1,12 +1,17 @@
+from office365.directory.security.attacksimulations.user import AttackSimulationUser
 from office365.runtime.client_value import ClientValue
 
 
 class UserSimulationDetails(ClientValue):
     """Represents a user of a tenant and their online actions in an attack simulation and training campaign."""
 
-    def __init__(self, assigned_trainings_count=None):
+    def __init__(
+        self, assigned_trainings_count=None, simulation_user=AttackSimulationUser()
+    ):
         """
         :param int assigned_trainings_count: Number of trainings assigned to a user in an attack simulation
             and training campaign.
+        :param AttackSimulationUser simulation_user:
         """
         self.assignedTrainingsCount = assigned_trainings_count
+        self.simulationUser = simulation_user

office365/directory/security/scorecontrol/profile.py

@@ -0,0 +1,6 @@
+from office365.entity import Entity
+
+
+class SecureScoreControlProfile(Entity):
+    """Represents a tenant's secure score per control data. By default, it returns all controls
+    for a tenant and can explicitly pull individual controls."""

office365/directory/security/security.py

@@ -1,8 +1,10 @@
 from office365.directory.security.alerts.alert import Alert
+from office365.directory.security.alerts.collection import AlertCollection
 from office365.directory.security.attacksimulations.root import AttackSimulationRoot
 from office365.directory.security.cases.root import CasesRoot
 from office365.directory.security.hunting_query_results import HuntingQueryResults
 from office365.directory.security.incidents.incident import Incident
+from office365.directory.security.scorecontrol.profile import SecureScoreControlProfile
 from office365.directory.security.threatintelligence.threat_intelligence import (
     ThreatIntelligence,
 )
@@ -35,12 +37,10 @@ class Security(Entity):
 
     @property
     def alerts(self):
-        # type: () -> EntityCollection[Alert]
+        # type: () -> AlertCollection
         return self.properties.get(
             "alerts",
-            EntityCollection(
-                self.context, Alert, ResourcePath("alerts", self.resource_path)
-            ),
+            AlertCollection(self.context, ResourcePath("alerts", self.resource_path)),
         )
 
     @property
@@ -83,6 +83,18 @@ class Security(Entity):
             ),
         )
 
+    @property
+    def secure_score_control_profiles(self):
+        """"""
+        return self.properties.get(
+            "secureScoreControlProfiles",
+            EntityCollection(
+                self.context,
+                SecureScoreControlProfile,
+                ResourcePath("secureScoreControlProfiles", self.resource_path),
+            ),
+        )
+
     @property
     def triggers(self):
         """"""
@@ -106,6 +118,7 @@ class Security(Entity):
             property_mapping = {
                 "alerts_v2": self.alerts_v2,
                 "attackSimulation": self.attack_simulation,
+                "secureScoreControlProfiles": self.secure_score_control_profiles,
                 "threatIntelligence": self.threat_intelligence,
             }
             default_value = property_mapping.get(name, None)