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

office365/outlook/mail/messages/collection.py

@@ -10,6 +10,13 @@ class MessageCollection(DeltaCollection):
     def __init__(self, context, resource_path=None):
         super(MessageCollection, self).__init__(context, Message, resource_path)
 
+    def __getitem__(self, key):
+        """
+        :param int or str key: Message identifier oo index
+        :rtype: Message
+        """
+        return super(MessageCollection, self).__getitem__(key)
+
     def add(self, subject=None, body=None, to_recipients=None, **kwargs):
         """
         Create a draft of a new message in either JSON or MIME format.

office365/outlook/mail/messages/followup_flag.py

@@ -0,0 +1,21 @@
+from office365.outlook.calendar.dateTimeTimeZone import DateTimeTimeZone
+from office365.runtime.client_value import ClientValue
+
+
+class FollowupFlag(ClientValue):
+    """Allows setting a flag in an item for the user to follow up on later."""
+
+    def __init__(self, completed_datetime=DateTimeTimeZone(), due_datetime=DateTimeTimeZone(),
+                 flag_status=None, start_datetime=DateTimeTimeZone()):
+        """
+        :param DateTimeTimeZone completed_datetime: The date and time that the follow-up was finished.
+        :param DateTimeTimeZone due_datetime: The date and time that the follow up is to be finished.
+             Note: To set the due date, you must also specify the startDateTime; otherwise, you will
+             get a 400 Bad Request response.
+        :param str flag_status: The status for follow-up for an item.
+        :param DateTimeTimeZone start_datetime: The date and time that the follow-up is to begin.
+        """
+        self.completedDateTime = completed_datetime
+        self.dueDateTime = due_datetime
+        self.flagStatus = flag_status
+        self.startDateTime = start_datetime

office365/outlook/mail/messages/internet_header.py

@@ -0,0 +1,16 @@
+from office365.runtime.client_value import ClientValue
+
+
+class InternetMessageHeader(ClientValue):
+    """
+    A key-value pair that represents an Internet message header, as defined by RFC5322, that provides details of the
+    network path taken by a message from the sender to the recipient.
+    """
+
+    def __init__(self, name=None, value=None):
+        """
+        :param str name: Represents the key in a key-value pair.
+        :param str value:The value in a key-value pair.
+        """
+        self.name = name
+        self.value = value

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.
@@ -57,8 +80,7 @@ class Message(OutlookItem):
         return return_type
 
     def add_file_attachment(
-        self, name, content=None, content_type=None, base64_content=None
-    ):
+        self, name, content=None, content_type=None, base64_content=None):
         """
         Attach a file to message
 
@@ -221,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)
@@ -267,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

@@ -0,0 +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/messages/rules/predicates.py

@@ -0,0 +1,5 @@
+from office365.runtime.client_value import ClientValue
+
+
+class MessageRulePredicates(ClientValue):
+    """Represents the set of conditions and exceptions that are available for a rule."""

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

@@ -0,0 +1,32 @@
+from office365.entity import Entity
+from office365.outlook.mail.messages.rules.actions import MessageRuleActions
+from office365.outlook.mail.messages.rules.predicates import MessageRulePredicates
+
+
+class MessageRule(Entity):
+    """A rule that applies to messages in the Inbox of a user.
+
+    In Outlook, you can set up rules for incoming messages in the Inbox to carry out specific internal
+    upon certain conditions."""
+
+    @property
+    def actions(self):
+        """Actions to be taken on a message when the corresponding conditions are fulfilled."""
+        return self.properties.get("actions", MessageRuleActions())
+
+    @property
+    def conditions(self):
+        """Conditions that when fulfilled, will trigger the corresponding actions for that rule."""
+        return self.properties.get("conditions", MessageRulePredicates())
+
+    @property
+    def exceptions(self):
+        """Exception conditions for the rule."""
+        return self.properties.get("exceptions", MessageRulePredicates())
+
+    @property
+    def is_read_only(self):
+        """
+        Indicates if the rule is read-only and cannot be modified or deleted by the rules REST API.
+        """
+        return self.properties.get("isReadOnly", None)

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/outlook/timezone_information.py

@@ -12,3 +12,6 @@ class TimeZoneInformation(ClientValue):
         """
         self.alias = alias
         self.displayName = display_name
+
+    def __repr__(self):
+        return self.displayName

office365/reports/root.py

@@ -1,11 +1,24 @@
+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
 
 
 class ReportRoot(Entity):
-    """The resource that represents an instance of History Reports."""
+    """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):
         """
@@ -174,3 +187,17 @@ class ReportRoot(Entity):
         qry = create_report_query(self, "getSharePointActivityUserDetail", period)
         self.context.add_query(qry)
         return qry.return_type
+
+    @property
+    def authentication_methods(self):
+        """Container for navigation properties for Azure AD authentication methods resources."""
+        return self.properties.get('authenticationMethods',
+                                   AuthenticationMethodsRoot(self.context,
+                                                             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