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

office365/outlook/mail/messages/message.py

@@ -1,10 +1,16 @@
 import os
+import uuid
+from datetime import datetime
 
+from office365.directory.extensions.extended_property import SingleValueLegacyExtendedProperty, \
+    MultiValueLegacyExtendedProperty
 from office365.directory.extensions.extension import Extension
 from office365.entity_collection import EntityCollection
 from office365.outlook.item import OutlookItem
 from office365.outlook.mail.attachments.collection import AttachmentCollection
 from office365.outlook.mail.item_body import ItemBody
+from office365.outlook.mail.messages.followup_flag import FollowupFlag
+from office365.outlook.mail.messages.internet_header import InternetMessageHeader
 from office365.outlook.mail.recipient import Recipient
 from office365.runtime.client_result import ClientResult
 from office365.runtime.client_value_collection import ClientValueCollection
@@ -16,6 +22,23 @@ from office365.runtime.queries.service_operation import ServiceOperationQuery
 class Message(OutlookItem):
     """A message in a mailbox folder."""
 
+    def add_extended_property(self, name, value):
+        """
+        Create a single-value extended property for a message
+        :param str name: A property name
+        :param str value:
+        """
+        prop_id = str(uuid.uuid4())
+        prop_type = "String"
+        prop_value = [
+            {
+                "id":"{0} {{{1}}} Name {2}".format(prop_type, prop_id, name),
+                "value": value
+            }
+        ]
+        self.set_property("singleValueExtendedProperties", prop_value)
+        return self
+
     def create_forward(self, to_recipients=None, message=None, comment=None):
         """
         Create a draft to forward an existing message, in either JSON or MIME format.
@@ -220,15 +243,134 @@ class Message(OutlookItem):
             value = ItemBody(value)
         self.set_property("body", value)
 
+    @property
+    def body_preview(self):
+        """
+        The first 255 characters of the message body. It is in text format.
+        :rtype: str or None
+        """
+        return self.properties.get("bodyPreview", None)
+
+    @property
+    def conversation_id(self):
+        """
+        The ID of the conversation the email belongs to.
+        :rtype: str or None
+        """
+        return self.properties.get("conversationId", None)
+
+    @property
+    def conversation_index(self):
+        """
+        Indicates the position of the message within the conversation.
+        :rtype: str or None
+        """
+        return self.properties.get("conversationIndex", None)
+
+    @property
+    def flag(self):
+        """
+        The flag value that indicates the status, start date, due date, or completion date for the message.
+        """
+        return self.properties.get("flag", FollowupFlag())
+
+    @property
+    def sent_from(self):
+        """
+        The owner of the mailbox from which the message is sent. In most cases, this value is the same as the sender
+        property, except for sharing or delegation scenarios. The value must correspond to the actual mailbox used.
+        Find out more about setting the from and sender properties of a message.
+        """
+        return self.properties.get("from", Recipient())
+
+    @property
+    def importance(self):
+        """
+        The importance of the message.
+        :rtype: str
+        """
+        return self.properties.get("importance", None)
+
+    @property
+    def inference_classification(self):
+        """
+        The classification of the message for the user, based on inferred relevance or importance,
+        or on an explicit override. The possible values are: focused or other.
+        :rtype: str
+        """
+        return self.properties.get("inferenceClassification", None)
+
+    @property
+    def internet_message_headers(self):
+        """
+        A collection of message headers defined by RFC5322. The set includes message headers indicating the network
+        path taken by a message from the sender to the recipient. It can also contain custom message headers that
+        hold app data for the message.
+        """
+        return self.properties.get("internetMessageHeaders", ClientValueCollection(InternetMessageHeader))
+
+    @property
+    def internet_message_id(self):
+        """
+        The message ID in the format specified by RFC2822
+        :rtype: str
+        """
+        return self.properties.get("internetMessageId", None)
+
+    @property
+    def is_delivery_receipt_requested(self):
+        """
+        Indicates whether a read receipt is requested for the message.
+        :rtype: bool
+        """
+        return self.properties.get("isDeliveryReceiptRequested", None)
+
+    @property
+    def is_draft(self):
+        """
+        Indicates whether the message is a draft. A message is a draft if it hasn't been sent yet.
+        :rtype: bool
+        """
+        return self.properties.get("isDraft", None)
+
+    @property
+    def is_read(self):
+        """
+        Indicates whether the message has been read.
+        :rtype: bool
+        """
+        return self.properties.get("isRead", None)
+
+    @property
+    def is_read_receipt_requested(self):
+        """
+        Indicates whether a read receipt is requested for the message.
+        :rtype: bool
+        """
+        return self.properties.get("isReadReceiptRequested", None)
+
+    @property
+    def received_datetime(self):
+        """The date and time the message was received."""
+        return self.properties.get("receivedDateTime", datetime.min)
+
+    @property
+    def sent_datetime(self):
+        """The date and time the message was sent."""
+        return self.properties.get("sentDateTime", datetime.min)
+
     @property
     def subject(self):
-        """The subject of the message."""
+        """
+        The subject of the message.
+        :rtype: str
+        """
         return self.properties.get("subject", None)
 
     @subject.setter
     def subject(self, value):
-        """The subject of the message.
-
+        """
+        The subject of the message.
         :type value: str
         """
         self.set_property("subject", value)
@@ -266,12 +408,49 @@ class Message(OutlookItem):
         """
         return self.properties.get('parentFolderId', None)
 
+    @property
+    def web_link(self):
+        """
+        The URL to open the message in Outlook on the web.
+
+        You can append an ispopout argument to the end of the URL to change how the message is displayed.
+        If ispopout is not present or if it is set to 1, then the message is shown in a popout window.
+        If ispopout is set to 0, then the browser will show the message in the Outlook on the web review pane.
+
+        The message will open in the browser if you are logged in to your mailbox via Outlook on the web.
+        You will be prompted to login if you are not already logged in with the browser.
+
+        This URL cannot be accessed from within an iFrame.
+        :rtype: str or None
+        """
+        return self.properties.get("webLink", None)
+
+    @property
+    def multi_value_extended_properties(self):
+        """The collection of multi-value extended properties defined for the event."""
+        return self.properties.get('multiValueExtendedProperties',
+                                   EntityCollection(self.context, MultiValueLegacyExtendedProperty,
+                                                    ResourcePath("multiValueExtendedProperties", self.resource_path)))
+
+    @property
+    def single_value_extended_properties(self):
+        """The collection of single-value extended properties defined for the message"""
+        return self.properties.get('singleValueExtendedProperties',
+                                   EntityCollection(self.context, SingleValueLegacyExtendedProperty,
+                                                    ResourcePath("singleValueExtendedProperties", self.resource_path)))
+
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_type_mapping = {
                 "toRecipients": self.to_recipients,
                 "bccRecipients": self.bcc_recipients,
-                "ccRecipients": self.cc_recipients
+                "ccRecipients": self.cc_recipients,
+                "from": self.sent_from,
+                "internetMessageHeaders": self.internet_message_headers,
+                "multiValueExtendedProperties": self.multi_value_extended_properties,
+                "receivedDateTime": self.received_datetime,
+                "sentDateTime": self.sent_datetime,
+                "singleValueExtendedProperties": self.single_value_extended_properties
             }
             default_value = property_type_mapping.get(name, None)
 

office365/outlook/mail/messages/rules/actions.py

@@ -1,5 +1,38 @@
+from office365.outlook.mail.recipient import Recipient
 from office365.runtime.client_value import ClientValue
+from office365.runtime.client_value_collection import ClientValueCollection
+from office365.runtime.types.collections import StringCollection
 
 
 class MessageRuleActions(ClientValue):
     """Represents the set of actions that are available to a rule."""
+
+    def __init__(self, assign_categories=None, copy_to_folder=None, delete=None,
+                 forward_as_attachment_to=None, forward_to=None, mark_as_read=None, mark_importance=None,
+                 move_to_folder=None, permanent_delete=None, redirect_to=None, stop_processing_rules=None):
+        """
+        :param list[str] assign_categories: A list of categories to be assigned to a message.
+        :param str copy_to_folder: The ID of a folder that a message is to be copied to.
+        :param bool delete: Indicates whether a message should be moved to the Deleted Items folder.
+        :param list[Recipient] forward_as_attachment_to: The email addresses of the recipients to which a message
+            should be forwarded as an attachment.
+        :param list[Recipient] forward_to: The email addresses of the recipients to which a message should be forwarded.
+        :param bool mark_as_read: Indicates whether a message should be marked as read.
+        :param str mark_importance: Sets the importance of the message, which can be: low, normal, high.
+        :param str move_to_folder: The ID of the folder that a message will be moved to.
+        :param bool permanent_delete: Indicates whether a message should be permanently deleted and not saved to the
+            Deleted Items folder.
+        :param list[Recipient] redirect_to: The email addresses to which a message should be redirected.
+        :param bool stop_processing_rules: Indicates whether subsequent rules should be evaluated.
+        """
+        self.assignCategories = StringCollection(assign_categories)
+        self.copyToFolder = copy_to_folder
+        self.delete = delete
+        self.forwardAsAttachmentTo = ClientValueCollection(Recipient, forward_as_attachment_to)
+        self.forwardTo = ClientValueCollection(Recipient, forward_to)
+        self.markAsRead = mark_as_read
+        self.markImportance = mark_importance
+        self.moveToFolder = move_to_folder
+        self.permanentDelete = permanent_delete
+        self.redirectTo = ClientValueCollection(Recipient, redirect_to)
+        self.stopProcessingRules = stop_processing_rules

office365/outlook/mail/patterned_recurrence.py

@@ -1,3 +1,5 @@
+from office365.outlook.mail.recurrence_pattern import RecurrencePattern
+from office365.outlook.mail.recurrence_range import RecurrenceRange
 from office365.runtime.client_value import ClientValue
 
 
@@ -10,4 +12,15 @@ class PatternedRecurrence(ClientValue):
         unifiedRoleAssignmentScheduleRequest and unifiedRoleEligibilityScheduleRequest objects in PIM
         accessPackageAssignment objects in Azure AD entitlement management.
     """
-    pass
+
+    def __init__(self, pattern=RecurrencePattern(), recurrence_range=RecurrenceRange()):
+        """
+        :param RecurrencePattern pattern: The frequency of an event.
+             For access reviews:
+                 - Do not specify this property for a one-time access review.
+                 - Only interval, dayOfMonth, and type (weekly, absoluteMonthly) properties of recurrencePattern
+                   are supported.
+        :param RecurrenceRange recurrence_range: The duration of an event.
+        """
+        self.pattern = pattern
+        self.range = recurrence_range

office365/outlook/mail/physical_address.py

@@ -4,13 +4,17 @@ from office365.runtime.client_value import ClientValue
 class PhysicalAddress(ClientValue):
     """The physical address of a contact."""
 
-    def __init__(self, city=None, country_or_region=None, postal_code=None):
+    def __init__(self, city=None, country_or_region=None, postal_code=None, state=None, street=None):
         """
         :param str city: The city.
         :param str country_or_region: The country or region. It's a free-format string value, for example, "United States".
         :param str postal_code: The postal code.
+        :param str state:
+        :param str street:
         """
         super(PhysicalAddress, self).__init__()
         self.city = city
         self.countryOrRegion = country_or_region
         self.postalCode = postal_code
+        self.state = state
+        self.street = street

office365/outlook/mail/recipient.py

@@ -12,6 +12,9 @@ class Recipient(ClientValue):
         super(Recipient, self).__init__()
         self.emailAddress = email_address
 
+    def __repr__(self):
+        return repr(self.emailAddress)
+
     @staticmethod
     def from_email(value):
         """

office365/outlook/mail/recurrence_pattern.py

@@ -1,13 +1,30 @@
 from office365.runtime.client_value import ClientValue
+from office365.runtime.types.collections import StringCollection
 
 
 class RecurrencePattern(ClientValue):
     """Describes the frequency by which a recurring event repeats."""
 
-    def __init__(self, day_of_month=None):
+    def __init__(self, day_of_month=None, days_of_week=None, first_day_of_week=None,
+                 index=None, interval=None, month=None, pattern_type=None):
         """
         :param int day_of_month: The day of the month on which the event occurs. Required if type is absoluteMonthly
             or absoluteYearly.
+        :param list[str] days_of_week: A collection of the days of the week on which the event occurs
+        :param str first_day_of_week: The first day of the week
+        :param str index: Specifies on which instance of the allowed days specified in daysOfWeek the event occurs,
+             counted from the first instance in the month.
+        :param int interval: The number of units between occurrences, where units can be in days, weeks, months,
+             or years, depending on the type. Required.
+        :param int month: The month in which the event occurs. This is a number from 1 to 12.
+        :param str pattern_type: The recurrence pattern type: daily, weekly, absoluteMonthly, relativeMonthly,
+             absoluteYearly, relativeYearly
         """
         self.dayOfMonth = day_of_month
+        self.daysOfWeek = StringCollection(days_of_week)
+        self.firstDayOfWeek = first_day_of_week
+        self.index = index
+        self.interval = interval
+        self.month = month
+        self.type = pattern_type
 

office365/outlook/mail/recurrence_range.py

@@ -7,8 +7,22 @@ class RecurrenceRange(ClientValue):
     of access reviews, calendar events, and access package assignments in Azure AD.
     """
 
-    def __init__(self, end_date=None):
+    def __init__(self, start_date=None, end_date=None, number_of_occurrences=None, recurrence_timezone=None,
+                 range_type=None):
         """
-        :param str end_date:
+        :param datetime.date start_date: The date to start applying the recurrence pattern. The first occurrence of
+            the meeting may be this date or later, depending on the recurrence pattern of the event. Must be the
+            same value as the start property of the recurring event. Required.
+        :param datetime.date end_date: The date to stop applying the recurrence pattern. Depending on the recurrence pattern of
+            the event, the last occurrence of the meeting may not be this date. Required if type is endDate.
+        :param int number_of_occurrences: The number of times to repeat the event. Required and must be positive
+            if type is numbered.
+        :param str recurrence_timezone: Time zone for the startDate and endDate properties. Optional. If not specified,
+            the time zone of the event is used.
+        :param str range_type: The recurrence range. The possible values are: endDate, noEnd, numbered. Required.
         """
         self.endDate = end_date
+        self.numberOfOccurrences = number_of_occurrences
+        self.recurrenceTimeZone = recurrence_timezone
+        self.startDate = start_date
+        self.type = range_type

office365/reports/root.py

@@ -1,6 +1,8 @@
 from office365.directory.authentication.methods.root import AuthenticationMethodsRoot
 from office365.entity import Entity
 from office365.reports.internal.queries.create_report_query import create_report_query
+from office365.reports.report import Report
+from office365.reports.security.root import SecurityReportsRoot
 from office365.runtime.client_result import ClientResult
 from office365.runtime.paths.resource_path import ResourcePath
 from office365.runtime.queries.function import FunctionQuery
@@ -9,6 +11,15 @@ from office365.runtime.queries.function import FunctionQuery
 class ReportRoot(Entity):
     """Represents a container for Azure Active Directory (Azure AD) reporting resources."""
 
+    def managed_device_enrollment_top_failures(self, period=None):
+        """
+        Note: The Microsoft Graph API for Intune requires an active Intune license for the tenant.
+        """
+        return_type = ClientResult(self.context, Report())
+        qry = FunctionQuery(self, "managedDeviceEnrollmentTopFailures", {"period": period}, return_type)
+        self.context.add_query(qry)
+        return return_type
+
     def get_email_activity_counts(self, period):
         """
         Enables you to understand the trends of email activity (like how many were sent, read, and received)
@@ -182,4 +193,11 @@ class ReportRoot(Entity):
         """Container for navigation properties for Azure AD authentication methods resources."""
         return self.properties.get('authenticationMethods',
                                    AuthenticationMethodsRoot(self.context,
-                                                             ResourcePath("authenticationMethods", self.resource_path)))
+                                                             ResourcePath("authenticationMethods",
+                                                                          self.resource_path)))
+
+    @property
+    def security(self):
+        """Container for navigation properties for Azure AD authentication methods resources."""
+        return self.properties.get('security',
+                                   SecurityReportsRoot(self.context, ResourcePath("security", self.resource_path)))

office365/reports/security/root.py

@@ -0,0 +1,21 @@
+from office365.directory.security.attacksimulations.repeat_offender import AttackSimulationRepeatOffender
+from office365.entity import Entity
+from office365.runtime.client_result import ClientResult
+from office365.runtime.client_value_collection import ClientValueCollection
+from office365.runtime.queries.function import FunctionQuery
+
+
+class SecurityReportsRoot(Entity):
+    """
+    Represents an abstract type that contains resources for attack simulation and training reports. This resource
+    provides the ability to launch a realistic simulated phishing attack that organizations can learn from.
+    """
+
+    def get_attack_simulation_repeat_offenders(self):
+        """
+        List the tenant users who have yielded to attacks more than once in attack simulation and training campaigns.
+        """
+        return_type = ClientResult(self.context, ClientValueCollection(AttackSimulationRepeatOffender))
+        qry = FunctionQuery(self, "getAttackSimulationRepeatOffenders", None, return_type)
+        self.context.add_query(qry)
+        return return_type

office365/reports/userregistration/method_count.py

@@ -0,0 +1,17 @@
+from office365.runtime.client_value import ClientValue
+
+
+class UserRegistrationMethodCount(ClientValue):
+    """Represents the number of users registered for an authentication method."""
+
+    def __init__(self, authentication_method=None, user_count=None):
+        """
+        :param str authentication_method: Name of the authentication method.
+        :param str user_count: Number of users registered.
+        """
+        self.authenticationMethod = authentication_method
+        self.userCount = user_count
+
+    def __repr__(self):
+        return "{0}: {1}".format(self.authenticationMethod, self.userCount)
+

office365/reports/userregistration/method_summary.py

@@ -0,0 +1,21 @@
+from office365.reports.userregistration.method_count import UserRegistrationMethodCount
+from office365.runtime.client_value import ClientValue
+from office365.runtime.client_value_collection import ClientValueCollection
+
+
+class UserRegistrationMethodSummary(ClientValue):
+    """Represents the summary of number of users registered for each authentication method."""
+
+    def __init__(self, total_user_count=None, method_counts=None, user_roles=None, user_types=None):
+        """
+        :param int total_user_count: Total number of users in the tenant.
+        :param list[UserRegistrationMethodCount] method_counts: Number of users registered for each authentication
+           method.
+        :param str user_roles: The role type of the user.
+             Possible values are: all, privilegedAdmin, admin, user, unknownFutureValue.
+        :param str user_types: User type. Possible values are: all, member, guest, unknownFutureValue.
+        """
+        self.totalUserCount = total_user_count
+        self.userRegistrationMethodCounts = ClientValueCollection(UserRegistrationMethodCount, method_counts)
+        self.userRoles = user_roles
+        self.userTypes = user_types

office365/sharepoint/activities/logger.py

@@ -1,8 +1,33 @@
+from office365.runtime.queries.service_operation import ServiceOperationQuery
 from office365.sharepoint.base_entity import BaseEntity
 
 
 class ActivityLogger(BaseEntity):
 
+    def log_activity(self, operation, list_id, list_item_unique_id, affected_resource_url, item_type,
+                     audit_creation_time, is_offline):
+        """
+        :param str operation:
+        :param str list_id:
+        :param str list_item_unique_id:
+        :param str affected_resource_url:
+        :param str item_type:
+        :param str audit_creation_time:
+        :param bool is_offline:
+        """
+        payload = {
+            "Operation": operation,
+            "ListId": list_id,
+            "ListItemUniqueId": list_item_unique_id,
+            "AffectedResourceUrl": affected_resource_url,
+            "ItemType": item_type,
+            "AuditCreationTime": audit_creation_time,
+            "IsOffline": is_offline
+        }
+        qry = ServiceOperationQuery(self, "LogActivity", None, payload)
+        self.context.add_query(qry)
+        return self
+
     @property
     def entity_type_name(self):
         return "Microsoft.SharePoint.Internal.ActivityLogger"

office365/sharepoint/addtoonedrive/mount_point.py

@@ -0,0 +1,25 @@
+from office365.runtime.queries.service_operation import ServiceOperationQuery
+from office365.sharepoint.addtoonedrive.mounted_folder_info import MountedFolderInfo
+from office365.sharepoint.base_entity import BaseEntity
+
+
+class MountPoint(BaseEntity):
+    """"""
+
+    @staticmethod
+    def get_mounted_folder_info(context, target_site_id, target_web_id, target_unique_id):
+        """
+        :type context: office365.sharepoint.client_context.ClientContext
+        :param str target_site_id:
+        :param str target_web_id:
+        :param str target_unique_id:
+        """
+        return_type = MountedFolderInfo(context)
+        payload = {
+            "targetSiteId": target_site_id,
+            "targetWebId": target_web_id,
+            "targetUniqueId": target_unique_id
+        }
+        qry = ServiceOperationQuery(context.web, "GetMountedFolderInfo", None, payload, None, return_type, True)
+        context.add_query(qry)
+        return return_type

office365/sharepoint/addtoonedrive/mounted_folder_info.py

@@ -0,0 +1,5 @@
+from office365.sharepoint.base_entity import BaseEntity
+
+
+class MountedFolderInfo(BaseEntity):
+    """"""

office365/sharepoint/alerts/alert.py

@@ -12,6 +12,37 @@ class Alert(BaseEntity):
     set for this type.
     """
 
+    @property
+    def alert_frequency(self):
+        """
+        Gets the time interval for sending the alert.
+        :rtype: int
+        """
+        return self.properties.get("AlertFrequency", None)
+
+    @property
+    def alert_template_name(self):
+        """
+        Gets the string representing the alert template name.
+        :rtype: int
+        """
+        return self.properties.get("AlertTemplateName", None)
+
+    @property
+    def always_notify(self):
+        """
+        Gets a Boolean value that causes daily and weekly alerts to trigger, even if there is no matching event.
+        :rtype: bool
+        """
+        return self.properties.get("AlwaysNotify", None)
+
+    @property
+    def item(self):
+        """Gets the list item or document to which the alert applies."""
+        from office365.sharepoint.listitems.listitem import ListItem
+        return self.properties.get('Item',
+                                   ListItem(self.context, ResourcePath("item", self.resource_path)))
+
     @property
     def user(self):
         """Gets user object that represents User for the alert."""

office365/sharepoint/changes/item.py

@@ -6,6 +6,20 @@ from office365.sharepoint.sharing.shared_with_user import SharedWithUser
 class ChangeItem(Change):
     """A change on an item."""
 
+    @property
+    def activity_type(self):
+        """
+        Returns activity type defined in ChangeActivityType
+        """
+        return self.properties.get("ActivityType", None)
+
+    @property
+    def content_type_id(self):
+        """
+        Specifies an identifier for the content type
+        """
+        return self.properties.get("ContentTypeId", None)
+
     @property
     def shared_by_user(self):
         """Return the sharedBy User Information in sharing action for change log."""

office365/sharepoint/client_context.py

@@ -395,6 +395,12 @@ class ClientContext(ClientRuntimeContext):
         from office365.sharepoint.contentcenter.machinelearning.models.collection import SPMachineLearningModelCollection
         return SPMachineLearningModelCollection(self, ResourcePath("models"))
 
+    @property
+    def folder_coloring(self):
+        """Alias to FolderColoring"""
+        from office365.sharepoint.folders.coloring import FolderColoring
+        return FolderColoring(self, ResourcePath("foldercoloring"))
+
     @property
     def group_site_manager(self):
         """Alias to GroupSiteManager"""

office365/sharepoint/clientsidecomponent/component_context_info.py

@@ -4,6 +4,13 @@ from office365.sharepoint.base_entity import BaseEntity
 class ComponentContextInfo(BaseEntity):
     """This class functions as a wrapper of the ContextInfo object. Reserved for internal use only."""
 
+    @property
+    def serialized_data(self):
+        """
+        :rtype: str
+        """
+        return self.properties.get("SerializedData", None)
+
     @property
     def entity_type_name(self):
         return "Microsoft.SharePoint.Internal.ClientSideComponent.ComponentContextInfo"

office365/sharepoint/clientsidecomponent/identifier.py

@@ -8,6 +8,9 @@ class SPClientSideComponentIdentifier(ClientValue):
         self.id = _id
         self.version = version
 
+    def __repr__(self):
+        return self.id
+
     @property
     def entity_type_name(self):
         return "Microsoft.SharePoint.ClientSideComponent.SPClientSideComponentIdentifier"