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

office365/outlook/calendar/events/event.py

@@ -86,8 +86,6 @@ class Event(OutlookItem):
     def start(self):
         """
         The date, time, and time zone that the event starts. By default, the start time is in UTC.
-
-        :rtype: DateTimeTimeZone
         """
         return self.properties.get("start", DateTimeTimeZone())
 
@@ -104,8 +102,6 @@ class Event(OutlookItem):
     def end(self):
         """
         The date, time, and time zone that the event starts. By default, the start time is in UTC.
-
-        :rtype: DateTimeTimeZone
         """
         return self.properties.get("end", DateTimeTimeZone())
 

office365/outlook/calendar/events/reminder.py

@@ -1,15 +1,34 @@
+from office365.outlook.calendar.dateTimeTimeZone import DateTimeTimeZone
+from office365.outlook.mail.location import Location
 from office365.runtime.client_value import ClientValue
 
 
 class Reminder(ClientValue):
     """A reminder for an event in a user calendar."""
 
-    def __init__(self, event_id=None, event_location=None):
+    def __init__(self, change_key=None, event_end_time=DateTimeTimeZone(), event_id=None, event_location=Location(),
+                 event_start_time=DateTimeTimeZone(), event_subject=None, event_web_link=None,
+                 reminder_fire_time=DateTimeTimeZone()):
         """
-
+        :param str change_key: Identifies the version of the reminder. Every time the reminder is changed, changeKey
+            changes as well. This allows Exchange to apply changes to the correct version of the object.
+        :param DateTimeTimeZone event_end_time: The date, time and time zone that the event ends.
         :param str event_id: The unique ID of the event. Read only.
-        :param str event_location:
+        :param Location event_location: The location of the event.
+        :param DateTimeTimeZone event_start_time: The date, time, and time zone that the event starts.
+        :param str event_subject: The text of the event's subject line.
+        :param str event_web_link: The URL to open the event in Outlook on the web.
+             The event 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.
+        :param DateTimeTimeZone reminder_fire_time: The date, time, and time zone that the reminder is set to occur.
         """
         super(Reminder, self).__init__()
+        self.changeKey = change_key
+        self.eventStartTime = event_start_time
+        self.eventEndTime = event_end_time
         self.eventId = event_id
         self.eventLocation = event_location
+        self.eventSubject = event_subject
+        self.eventWebLink = event_web_link
+        self.reminderFireTime = reminder_fire_time

office365/outlook/calendar/group.py

@@ -13,7 +13,6 @@ class CalendarGroup(Entity):
     def name(self):
         """
         The group name.
-
         :rtype: str
         """
         return self.properties.get("name", None)
@@ -22,7 +21,6 @@ class CalendarGroup(Entity):
     def class_id(self):
         """
         The class identifier
-
         :rtype: str
         """
         return self.properties.get("classId", None)

office365/outlook/calendar/location_constraint.py

@@ -1,6 +1,21 @@
+from office365.outlook.mail.location_constraint_item import LocationConstraintItem
 from office365.runtime.client_value import ClientValue
+from office365.runtime.client_value_collection import ClientValueCollection
 
 
 class LocationConstraint(ClientValue):
     """The conditions stated by a client for the location of a meeting."""
-    pass
+
+    def __init__(self, is_required=None, locations=None, suggest_location=None):
+        """
+        :param bool is_required: 	The client requests the service to include in the response a meeting location
+            for the meeting. If this is true and all the resources are busy, findMeetingTimes will not return any
+            meeting time suggestions. If this is false and all the resources are busy, findMeetingTimes would still
+            look for meeting times without locations.
+        :param list[LocationConstraintItem] locations: Constraint information for one or more locations that the client
+            requests for the meeting
+        :param bool suggest_location: The client requests the service to suggest one or more meeting locations.
+        """
+        self.isRequired = is_required
+        self.locations = ClientValueCollection(LocationConstraintItem, locations)
+        self.suggestLocation = suggest_location

office365/outlook/calendar/permissions/collection.py

@@ -0,0 +1,24 @@
+from office365.entity_collection import EntityCollection
+from office365.outlook.calendar.email_address import EmailAddress
+from office365.outlook.calendar.permissions.permission import CalendarPermission
+
+
+class CalendarPermissionCollection(EntityCollection):
+
+    def __init__(self, context, resource_path=None):
+        super(CalendarPermissionCollection, self).__init__(context, CalendarPermission, resource_path)
+
+    def add(self, email_address, role):
+        """
+        Create a calendarPermission resource to specify the identity and role of the user with whom the specified
+        calendar is being shared or delegated.
+        :param str or EmailAddress email_address: Represents a sharee or delegate who has access to the calendar.
+        :param str role: Permission level of the calendar sharee or delegate
+        """
+        if not isinstance(email_address, EmailAddress):
+            email_address = EmailAddress(email_address)
+        props = {
+            "emailAddress": email_address,
+            "role": str(role)
+        }
+        return super(CalendarPermissionCollection, self).add(**props)

office365/outlook/calendar/{permission.py → permissions/permission.py}

@@ -1,5 +1,6 @@
 from office365.entity import Entity
 from office365.outlook.calendar.email_address import EmailAddress
+from office365.runtime.types.collections import StringCollection
 
 
 class CalendarPermission(Entity):
@@ -15,9 +16,17 @@ class CalendarPermission(Entity):
     the permissions of a sharee or delegate. You cannot update the allowedRoles, emailAddress, isInsideOrganization,
     or isRemovable property. To change these properties, you should delete the corresponding calendarPermission
     object and create another sharee or delegate in an Outlook client.
-
     """
 
+    @property
+    def allowed_roles(self):
+        """
+        List of allowed sharing or delegating permission levels for the calendar.
+        Possible values are: none, freeBusyRead, limitedRead, read, write, delegateWithoutPrivateEventAccess,
+        delegateWithPrivateEventAccess, custom.
+        """
+        return self.properties.get("allowedRoles", StringCollection())
+
     @property
     def email_address(self):
         """
@@ -26,13 +35,37 @@ class CalendarPermission(Entity):
         """
         return self.properties.get("emailAddress", EmailAddress())
 
+    @property
+    def is_inside_organization(self):
+        """
+        True if the user in context (sharee or delegate) is inside the same organization as the calendar owner.
+        :rtype: bool or None
+        """
+        return self.properties.get("isInsideOrganization", None)
+
     @property
     def is_removable(self):
         """
         True if the user can be removed from the list of sharees or delegates for the specified calendar,
         false otherwise. The "My organization" user determines the permissions other people within your organization
         have to the given calendar. You cannot remove "My organization" as a sharee to a calendar.
-
         :rtype: bool or None
         """
         return self.properties.get("isRemovable", None)
+
+    @property
+    def role(self):
+        """
+        Current permission level of the calendar sharee or delegate.
+        :rtype: str or None
+        """
+        return self.properties.get("role", None)
+
+    def get_property(self, name, default_value=None):
+        if default_value is None:
+            property_mapping = {
+                "allowedRoles": self.allowed_roles,
+                "emailAddress": self.email_address
+            }
+            default_value = property_mapping.get(name, None)
+        return super(CalendarPermission, self).get_property(name, default_value)

office365/outlook/calendar/role_type.py

@@ -11,3 +11,20 @@ class CalendarRoleType:
 
     limitedRead = 2
     """User is a sharee who can view free/busy status, and titles and locations of the events on the calendar."""
+
+    read = 3
+    """User is a sharee who can view all the details of the events on the calendar, except for the owner's private
+    events."""
+
+    write = 4
+    """User is a sharee who can view all the details (except for private events) and edit events on the calendar."""
+
+    delegateWithoutPrivateEventAccess = 5
+    """User is a delegate who has write access but cannot view information of the owner's private events on the
+    calendar."""
+
+    delegateWithPrivateEventAccess = 6
+    """User is a delegate who has write access and can view information of the owner's private events on the calendar"""
+
+    custom = 7
+    """User has custom permissions to the calendar."""

office365/outlook/calendar/sharing_message.py

@@ -1,5 +1,5 @@
-from office365.entity import Entity
+from office365.outlook.mail.messages.message import Message
 
 
-class CalendarSharingMessage(Entity):
+class CalendarSharingMessage(Message):
     """"""

office365/outlook/calendar/time_zone_base.py

@@ -10,3 +10,6 @@ class TimeZoneBase(ClientValue):
             "Hawaii-Aleutian Standard Time", or "Customized Time Zone" for a custom time zone.
         """
         self.name = name
+
+    def __repr__(self):
+        return self.name

office365/outlook/calendar/working_hours.py

@@ -1,14 +1,30 @@
 from office365.outlook.calendar.time_zone_base import TimeZoneBase
 from office365.runtime.client_value import ClientValue
+from office365.runtime.types.collections import StringCollection
 
 
 class WorkingHours(ClientValue):
     """
     Represents the days of the week and hours in a specific time zone that the user works.
+
+    Having access to a user's working hours is useful in scenarios that handle activity or resource planning.
+    You can get and set the working hours of a user as part of the user's mailbox settings.
+
+    You can choose to set a time zone for your working hours differently from the time zone you have set on your
+    Outlook client. This can be useful in cases like when you travel to a different time zone than you usually work in.
+    You can set the Outlook client to the destination time zone so that Outlook time values are displayed in local
+    time while you are there. When other people request work meetings with you in your usual place of work,
+    they can still respect your working hours in the appropriate time zone.
     """
 
-    def __init__(self, timezone=TimeZoneBase()):
+    def __init__(self, days_of_week=None, end_time=None, start_time=None, timezone=TimeZoneBase()):
         """
+        :param list[str] days_of_week: The days of the week on which the user works.
         :param TimeZoneBase timezone: The time zone to which the working hours apply.
+        :param str end_time: The time of the day that the user stops working.
+        :param str start_time: The time of the day that the user starts working.
         """
+        self.daysOfWeek = StringCollection(days_of_week)
         self.timeZone = timezone
+        self.endTime = end_time
+        self.startTime = start_time

office365/outlook/contacts/collection.py

@@ -0,0 +1,39 @@
+from office365.delta_collection import DeltaCollection
+from office365.outlook.calendar.email_address import EmailAddress
+from office365.outlook.contacts.contact import Contact
+from office365.runtime.client_value_collection import ClientValueCollection
+from office365.runtime.types.collections import StringCollection
+
+
+class ContactCollection(DeltaCollection):
+
+    def __init__(self, context, resource_path=None):
+        super(ContactCollection, self).__init__(context, Contact, resource_path)
+
+    def add(self, given_name, surname, email_address=None, business_phone=None, **kwargs):
+        """
+        Add a contact to the root Contacts folder or to the contacts endpoint of another contact folder.
+        :param str given_name: The contact's given name.
+        :param str surname: The contact's surname.
+        :param str email_address: Default email address
+        :param str business_phone: Default contact's business phone number.
+        :rtype: Contact
+        """
+        def _create_email_address(address):
+            return EmailAddress(address, "{0} {1}".format(given_name, surname))
+
+        kwargs["givenName"] = given_name
+        kwargs["surname"] = surname
+        if email_address:
+            kwargs["emailAddresses"] = ClientValueCollection(EmailAddress,
+                                                             [_create_email_address(email_address)])
+        if business_phone:
+            kwargs["businessPhones"] = StringCollection([business_phone])
+        return super(ContactCollection, self).add(**kwargs)
+
+    def __getitem__(self, key):
+        """
+        :param int or str key: Contact identifier or index
+        :rtype: Contact
+        """
+        return super(ContactCollection, self).__getitem__(key)

office365/outlook/contacts/contact.py

@@ -8,16 +8,32 @@ from office365.outlook.item import OutlookItem
 from office365.outlook.mail.physical_address import PhysicalAddress
 from office365.runtime.client_value_collection import ClientValueCollection
 from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.types.collections import StringCollection
 
 
 class Contact(OutlookItem):
     """User's contact."""
 
+    @property
+    def business_phones(self):
+        """The contact's business phone numbers."""
+        return self.properties.setdefault("businessPhones", StringCollection())
+
+    @property
+    def display_name(self):
+        """
+        The contact's display name. You can specify the display name in a create or update operation.
+        Note that later updates to other properties may cause an automatically generated value to overwrite the
+        displayName value you have specified. To preserve a pre-existing value, always include it as displayName
+        in an update operation.
+        :rtype: str or None
+        """
+        return self.properties.get('displayName', None)
+
     @property
     def manager(self):
         """
         The name of the contact's manager.
-
         :rtype: str or None
         """
         return self.properties.get("manager", None)
@@ -26,7 +42,6 @@ class Contact(OutlookItem):
     def manager(self, value):
         """
         Sets name of the contact's manager.
-
         :type value: str
         """
         self.set_property("manager", value)
@@ -49,20 +64,13 @@ class Contact(OutlookItem):
 
     @property
     def home_address(self):
+        """The contact's home address."""
         return self.properties.get("homeAddress", PhysicalAddress())
 
     @property
     def email_addresses(self):
         """The contact's email addresses."""
-        return self.properties.get("emailAddresses", ClientValueCollection(EmailAddress))
-
-    @email_addresses.setter
-    def email_addresses(self, value):
-        """Sets contact's email addresses.
-
-        :type value: list[str]
-        """
-        self.set_property("emailAddresses", value)
+        return self.properties.setdefault("emailAddresses", ClientValueCollection(EmailAddress))
 
     @property
     def extensions(self):
@@ -94,7 +102,9 @@ class Contact(OutlookItem):
     def get_property(self, name, default_value=None):
         if default_value is None:
             property_mapping = {
+                "businessPhones": self.business_phones,
                 "emailAddresses": self.email_addresses,
+                "homeAddress": self.home_address,
                 "multiValueExtendedProperties": self.multi_value_extended_properties,
                 "singleValueExtendedProperties": self.single_value_extended_properties
             }

office365/outlook/geo_coordinates.py

@@ -0,0 +1,20 @@
+from office365.runtime.client_value import ClientValue
+
+
+class OutlookGeoCoordinates(ClientValue):
+    """The geographic coordinates, elevation, and their degree of accuracy for a physical location."""
+
+    def __init__(self, accuracy=None, altitude=None, altitude_accuracy=None, latitude=None, longitude = None):
+        """
+        :param float accuracy: The accuracy of the latitude and longitude. As an example, the accuracy can be measured
+            in meters, such as the latitude and longitude are accurate to within 50 meters.
+        :param float altitude: The altitude of the location.
+        :param float altitude_accuracy: The accuracy of the altitude.
+        :param float latitude: The latitude of the location.
+        :param float longitude: The longitude of the location.
+        """
+        self.accuracy = accuracy
+        self.altitude = altitude
+        self.altitudeAccuracy = altitude_accuracy
+        self.latitude = latitude
+        self.longitude = longitude

office365/outlook/item.py

@@ -8,8 +8,11 @@ class OutlookItem(Entity):
 
     @property
     def change_key(self):
-        """Identifies the version of the item. Every time the item is changed, changeKey changes as well.
-        This allows Exchange to apply changes to the correct version of the object. """
+        """
+        Identifies the version of the item. Every time the item is changed, changeKey changes as well.
+        This allows Exchange to apply changes to the correct version of the object.
+        :rtype: str
+        """
         return self.properties.get('ChangeKey', None)
 
     @property

office365/outlook/locale_info.py

@@ -14,3 +14,6 @@ class LocaleInfo(ClientValue):
         """
         self.displayName = display_name
         self.locale = locale
+
+    def __repr__(self):
+        return self.locale

office365/outlook/mail/folders/folder.py

@@ -5,26 +5,74 @@ from office365.entity_collection import EntityCollection
 from office365.outlook.mail.messages.collection import MessageCollection
 from office365.outlook.mail.messages.rules.rule import MessageRule
 from office365.runtime.paths.resource_path import ResourcePath
+from office365.runtime.queries.service_operation import ServiceOperationQuery
 
 
 class MailFolder(Entity):
     """A mail folder in a user's mailbox, such as Inbox and Drafts. Mail folders can contain messages,
     other Outlook items, and child mail folders."""
 
+    def copy(self, destination_id):
+        """
+        Copy a mailfolder and its contents to another mailfolder.
+        :param str destination_id: The folder ID, or a well-known folder name. For a list of supported well-known folder
+            names, see mailFolder resource type.
+        """
+        return_type = MailFolder(self.context)
+        payload = {"DestinationId": destination_id}
+        qry = ServiceOperationQuery(self, "copy", None, payload, None, return_type)
+        self.context.add_query(qry)
+        return return_type
+
+    @property
+    def child_folder_count(self):
+        """
+        The number of immediate child mailFolders in the current mailFolder.
+        :rtype: int or None
+        """
+        return self.properties.get("childFolderCount", None)
+
     @property
     def display_name(self):
         """
         The name of the Mail folder
-
         :rtype: str or None
         """
         return self.properties.get("displayName", None)
 
+    @property
+    def is_hidden(self):
+        """
+        Indicates whether the mailFolder is hidden. This property can be set only when creating the folder.
+        Find more information in Hidden mail folders.
+        :rtype: bool or None
+        """
+        return self.properties.get("isHidden", None)
+
+    @property
+    def parent_folder_id(self):
+        """
+        The unique identifier for the mailFolder's parent mailFolder.
+        :rtype: str or None
+        """
+        return self.properties.get('parentFolderId', None)
+
     @property
     def total_item_count(self):
-        """The number of items in the mailFolder."""
+        """
+        The number of items in the mailFolder.
+        :rtype: int
+        """
         return self.properties.get("totalItemCount", None)
 
+    @property
+    def unread_item_count(self):
+        """
+        The number of items in the mailFolder marked as unread.
+        :rtype: int
+        """
+        return self.properties.get("unreadItemCount", None)
+
     @property
     def child_folders(self):
         """The collection of child folders in the mailFolder. """
@@ -34,6 +82,7 @@ class MailFolder(Entity):
 
     @property
     def message_rules(self):
+        """"""
         return self.properties.get('messageRules',
                                    EntityCollection(self.context, MessageRule,
                                                     ResourcePath("messageRules", self.resource_path)))

office365/outlook/mail/folders/search.py

@@ -0,0 +1,11 @@
+from office365.outlook.mail.folders.folder import MailFolder
+
+
+class MailSearchFolder(MailFolder):
+    """
+    A mailSearchFolder is a virtual folder in the user's mailbox that contains all the email items
+    matching specified search criteria. mailSearchFolder inherits from mailFolder.
+    Search folders can be created in any folder in a user's Exchange Online mailbox. However, for a search folder
+    to appear in Outlook, Outlook for the web, or Outlook Live, the folder must be created in the
+    WellKnownFolderName.SearchFolders folder.
+    """

office365/outlook/mail/importance.py

@@ -1,4 +1,5 @@
 class Importance:
+    """The importance of the message"""
     def __init__(self):
         pass
 

office365/outlook/mail/item_body.py

@@ -13,3 +13,6 @@ class ItemBody(ClientValue):
         super(ItemBody, self).__init__()
         self.content = content
         self.contentType = content_type
+
+    def __repr__(self):
+        return self.content

office365/outlook/mail/location.py

@@ -1,12 +1,37 @@
+from office365.outlook.geo_coordinates import OutlookGeoCoordinates
+from office365.outlook.mail.physical_address import PhysicalAddress
 from office365.runtime.client_value import ClientValue
+from office365.runtime.client_value_collection import ClientValueCollection
 
 
 class Location(ClientValue):
-    """Represents location information of an event."""
+    """
+    Represents location information of an event.
 
-    def __init__(self, display_name=None):
+    There are multiple ways to create events in a calendar, for example, through an app using the create event REST API,
+    or manually using the Outlook user interface. When you create an event using the user interface, you can specify
+    the location as plain text (for example, "Harry's Bar"), or from the rooms list provided by Outlook,
+    Bing Autosuggest, or Bing local search.
+    """
+
+    def __init__(self, address=PhysicalAddress(), coordinates=None, display_name=None, location_email_address=None,
+                 location_type=None, location_uri=None, unique_id=None, unique_id_type=None):
         """
+        :param PhysicalAddress address: The street address of the location.
+        :param list[OutlookGeoCoordinates] coordinates:
         :param str display_name: The name associated with the location.
+        :param str location_email_address: Optional email address of the location.
+        :param str location_type: The type of location.
+        :param str location_uri: Optional URI representing the location.
+        :param str unique_id: For internal use only.
+        :param str unique_id_type: For internal use only.
         """
         super(Location, self).__init__()
+        self.address = address
+        self.coordinates = ClientValueCollection(OutlookGeoCoordinates, coordinates)
         self.displayName = display_name
+        self.locationEmailAddress = location_email_address
+        self.locationType = location_type
+        self.locationUri = location_uri
+        self.uniqueId = unique_id
+        self.uniqueIdType = unique_id_type

office365/outlook/mail/location_constraint_item.py

@@ -0,0 +1,5 @@
+from office365.outlook.mail.location import Location
+
+
+class LocationConstraintItem(Location):
+    """The conditions stated by a client for the location of a meeting."""

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