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

office365/outlook/calendar/meetingtimes/activity_domain.py

@@ -0,0 +1,10 @@
+class ActivityDomain:
+    """"""
+
+    unknown = "0"
+
+    work = "1"
+
+    personal = "2"
+
+    unrestricted = "3"

office365/outlook/calendar/meetingtimes/suggestion.py

@@ -1,5 +1,5 @@
 from office365.outlook.calendar.attendees.availability import AttendeeAvailability
-from office365.outlook.calendar.time_slot import TimeSlot
+from office365.outlook.calendar.meetingtimes.time_slot import TimeSlot
 from office365.outlook.mail.location import Location
 from office365.runtime.client_value import ClientValue
 from office365.runtime.client_value_collection import ClientValueCollection

office365/outlook/calendar/meetingtimes/time_constraint.py

@@ -0,0 +1,18 @@
+from office365.outlook.calendar.meetingtimes.time_slot import TimeSlot
+from office365.runtime.client_value import ClientValue
+from office365.runtime.client_value_collection import ClientValueCollection
+
+
+class TimeConstraint(ClientValue):
+    """Restricts meeting time suggestions to certain hours and days of the week according to the specified nature of
+    activity and open time slots."""
+
+    def __init__(self, activity_domain=None, time_slots=None):
+        """
+        :param str activity_domain: The nature of the activity, optional
+        :param list[TimeSlot] time_slots: An array of time periods
+        """
+        self.activityDomain = activity_domain
+        self.timeSlots = ClientValueCollection(TimeSlot, time_slots)
+
+

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/place.py

@@ -6,6 +6,13 @@ class Place(Entity):
     """Represents basic location attributes such as name, physical address, and geographic coordinates.
     This is the base type for richer location types such as room and roomList."""
 
+    @property
+    def display_name(self):
+        """The name associated with the place.
+        :rtype: str or None
+        """
+        return self.properties.get("displayName", None)
+
     @property
     def address(self):
         """The street address of the place."""

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/schedule/information.py

@@ -8,7 +8,8 @@ class ScheduleInformation(ClientValue):
     """Represents the availability of a user, distribution list, or resource (room or equipment)
     for a specified time period."""
 
-    def __init__(self, schedule_id=None, schedule_items=None, availability_view=None, error=None, working_hours=None):
+    def __init__(self, schedule_id=None, schedule_items=None, availability_view=None, error=None,
+                 working_hours=WorkingHours()):
         """
 
         :param WorkingHours working_hours: The days of the week and hours in a specific time zone that the user works.
@@ -18,14 +19,14 @@ class ScheduleInformation(ClientValue):
         :param str availability_view: Represents a merged view of availability of all the items in scheduleItems.
              The view consists of time slots. Availability during each time slot is indicated with:
              0= free, 1= tentative, 2= busy, 3= out of office, 4= working elsewhere.
-        :param ClientValueCollection(ScheduleItem) schedule_items: Contains the items that describe the availability
+        :param list[ScheduleItem] schedule_items: Contains the items that describe the availability
             of the user or resource.
         :param str schedule_id: An SMTP address of the user, distribution list, or resource, identifying an instance
             of scheduleInformation.
         """
         super(ScheduleInformation, self).__init__()
-        self.scheduleItems = ClientValueCollection(ScheduleItem) if schedule_items is None else schedule_items
+        self.scheduleItems = ClientValueCollection(ScheduleItem, schedule_items)
         self.scheduleId = schedule_id
         self.availabilityView = availability_view
         self.error = error
-        self.workingHours = WorkingHours() if working_hours is None else working_hours
+        self.workingHours = working_hours

office365/outlook/calendar/schedule/item.py

@@ -1,3 +1,4 @@
+from office365.outlook.calendar.dateTimeTimeZone import DateTimeTimeZone
 from office365.runtime.client_value import ClientValue
 
 
@@ -6,4 +7,22 @@ class ScheduleItem(ClientValue):
     An item that describes the availability of a user corresponding to an actual event on the user's default calendar.
     This item applies to a resource (room or equipment) as well.
     """
-    pass
+
+    def __init__(self, start=DateTimeTimeZone(), end=DateTimeTimeZone(),
+                 location=None, is_private=None, subject=None, status=None):
+        """
+        :param DateTimeTimeZone start: The date, time, and time zone that the corresponding event starts.
+        :param DateTimeTimeZone end: The date, time, and time zone that the corresponding event ends.
+        :param str location: The location where the corresponding event is held or attended from. Optional.
+        :param bool is_private: The sensitivity of the corresponding event. True if the event is marked private,
+             false otherwise. Optional.
+        :param str subject: The corresponding event's subject line. Optional.
+        :param str status: The availability status of the user or resource during the corresponding event.
+              The possible values are: free, tentative, busy, oof, workingElsewhere, unknown.
+        """
+        self.start = start
+        self.end = end
+        self.location = location
+        self.isPrivate = is_private
+        self.subject = subject
+        self.status = status

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
@@ -43,5 +46,3 @@ class OutlookItem(Entity):
             }
             default_value = property_mapping.get(name, None)
         return super(OutlookItem, self).get_property(name, default_value)
-
-

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/automatic_replies_setting.py

@@ -6,3 +6,17 @@ class AutomaticRepliesSetting(ClientValue):
     Configuration settings to automatically notify the sender of an incoming email with a message from the signed-in
     user. For example, an automatic reply to notify that the signed-in user is unavailable to respond to emails.
     """
+
+    def __init__(self, external_audience=None, external_reply_message=None, internal_reply_message=None):
+        """
+        :param str external_audience: The set of audience external to the signed-in user's organization who will
+           receive the ExternalReplyMessage, if Status is AlwaysEnabled or Scheduled.
+           The possible values are: none, contactsOnly, all.
+        :param str external_reply_message: The automatic reply to send to the specified external audience, if Status
+           is AlwaysEnabled or Scheduled.
+        :param str internal_reply_message: The automatic reply to send to the audience internal
+            to the signed-in user's organization, if Status is AlwaysEnabled or Scheduled.
+        """
+        self.externalAudience = external_audience
+        self.externalReplyMessage = external_reply_message
+        self.internalReplyMessage = internal_reply_message

office365/outlook/mail/folders/folder.py

@@ -3,28 +3,76 @@ from office365.directory.extensions.extended_property import SingleValueLegacyEx
 from office365.entity import Entity
 from office365.entity_collection import EntityCollection
 from office365.outlook.mail.messages.collection import MessageCollection
-from office365.outlook.mail.messages.message_rule import MessageRule
+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/mailbox_settings.py

@@ -1,3 +1,5 @@
+from office365.outlook.calendar.working_hours import WorkingHours
+from office365.outlook.locale_info import LocaleInfo
 from office365.outlook.mail.automatic_replies_setting import AutomaticRepliesSetting
 from office365.runtime.client_value import ClientValue
 
@@ -5,14 +7,24 @@ from office365.runtime.client_value import ClientValue
 class MailboxSettings(ClientValue):
     """Settings for the primary mailbox of a user."""
 
-    def __init__(self, time_format=None, time_zone=None, automatic_replies_setting=AutomaticRepliesSetting()):
+    def __init__(self, time_format=None, time_zone=None, automatic_replies_setting=AutomaticRepliesSetting(),
+                 archive_folder=None, date_format=None, language=LocaleInfo(), working_hours=WorkingHours()):
         """
         :param str time_format: The time format for the user's mailbox.
         :param str time_zone: The default time zone for the user's mailbox.
         :param AutomaticRepliesSetting automatic_replies_setting: 	Configuration settings to automatically notify
             the sender of an incoming email with a message from the signed-in user.
+        :param str archive_folder: Folder ID of an archive folder for the user.
+        :param str date_format: The date format for the user's mailbox.
+        :param LocaleInfo language: The locale information for the user, including the preferred language
+            and country/region.
+        :param WorkingHours working_hours: The days of the week and hours in a specific time zone that the user works.
         """
         super(MailboxSettings, self).__init__()
         self.timeFormat = time_format
         self.timeZone = time_zone
         self.automaticRepliesSetting = automatic_replies_setting
+        self.archiveFolder = archive_folder
+        self.dateFormat = date_format
+        self.language = language
+        self.workingHours = working_hours