@backtomyfuture/exchange-cli-linux-arm64 0.1.10

package/bin/_internal/exchangelib/services/find_people.py

@@ -0,0 +1,106 @@
+import logging
+
+from ..errors import InvalidEnumValue
+from ..items import ID_ONLY, ITEM_TRAVERSAL_CHOICES, SHAPE_CHOICES, Persona
+from ..util import MNS, create_element, set_xml_value
+from ..version import EXCHANGE_2013
+from .common import EWSPagingService, folder_ids_element, shape_element
+
+log = logging.getLogger(__name__)
+
+
+class FindPeople(EWSPagingService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/findpeople-operation"""
+
+    SERVICE_NAME = "FindPeople"
+    element_container_name = f"{{{MNS}}}People"
+    supported_from = EXCHANGE_2013
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # A hack to communicate parsing args to _elems_to_objs()
+        self.additional_fields = None
+        self.shape = None
+
+    def call(self, folder, additional_fields, restriction, order_fields, shape, query_string, depth, max_items, offset):
+        """Find items in an account. This service can only be called on a single folder.
+
+        :param folder: the Folder object to query
+        :param additional_fields: the extra fields that should be returned with the item, as FieldPath objects
+        :param restriction: a Restriction object for
+        :param order_fields: the fields to sort the results by
+        :param shape: The set of attributes to return
+        :param query_string: a QueryString object
+        :param depth: How deep in the folder structure to search for items
+        :param max_items: the max number of items to return
+        :param offset: the offset relative to the first item in the item collection. Usually 0.
+
+        :return: XML elements for the matching items
+        """
+        if shape not in SHAPE_CHOICES:
+            raise InvalidEnumValue("shape", shape, SHAPE_CHOICES)
+        if depth not in ITEM_TRAVERSAL_CHOICES:
+            raise InvalidEnumValue("depth", depth, ITEM_TRAVERSAL_CHOICES)
+        self.additional_fields = additional_fields
+        self.shape = shape
+        return self._elems_to_objs(
+            self._paged_call(
+                payload_func=self.get_payload,
+                max_items=max_items,
+                folders=[folder],  # We just need the list to satisfy self._paged_call()
+                **dict(
+                    additional_fields=additional_fields,
+                    restriction=restriction,
+                    order_fields=order_fields,
+                    query_string=query_string,
+                    shape=shape,
+                    depth=depth,
+                    page_size=self.page_size,
+                    offset=offset,
+                ),
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        if self.shape == ID_ONLY and self.additional_fields is None:
+            return Persona.id_from_xml(elem)
+        return Persona.from_xml(elem, account=self.account)
+
+    def get_payload(
+        self, folders, additional_fields, restriction, order_fields, query_string, shape, depth, page_size, offset=0
+    ):
+        # We actually only support a single folder, but self._paged_call() sends us a list
+        payload = create_element(f"m:{self.SERVICE_NAME}", attrs=dict(Traversal=depth))
+        payload.append(
+            shape_element(
+                tag="m:PersonaShape", shape=shape, additional_fields=additional_fields, version=self.account.version
+            )
+        )
+        payload.append(
+            create_element(
+                "m:IndexedPageItemView", attrs=dict(MaxEntriesReturned=page_size, Offset=offset, BasePoint="Beginning")
+            )
+        )
+        if restriction:
+            payload.append(restriction.to_xml(version=self.account.version))
+        if order_fields:
+            payload.append(set_xml_value(create_element("m:SortOrder"), order_fields, version=self.account.version))
+        payload.append(folder_ids_element(folders=folders, version=self.account.version, tag="m:ParentFolderId"))
+        if query_string:
+            payload.append(query_string.to_xml(version=self.account.version))
+        return payload
+
+    @staticmethod
+    def _get_paging_values(elem):
+        """Find paging values. The paging element from FindPeople is different from other paging containers."""
+        item_count = int(elem.find(f"{{{MNS}}}TotalNumberOfPeopleInView").text)
+        first_matching = int(elem.find(f"{{{MNS}}}FirstMatchingRowIndex").text)
+        first_loaded = int(elem.find(f"{{{MNS}}}FirstLoadedRowIndex").text)
+        log.debug(
+            "Got page with total items %s, first matching %s, first loaded %s ",
+            item_count,
+            first_matching,
+            first_loaded,
+        )
+        next_offset = None  # GetPersona does not support fetching more pages
+        return item_count, next_offset

package/bin/_internal/exchangelib/services/get_attachment.py

@@ -0,0 +1,117 @@
+from itertools import chain
+
+from ..attachments import FileAttachment, ItemAttachment
+from ..errors import InvalidEnumValue
+from ..util import (
+    MNS,
+    DummyResponse,
+    ElementNotFound,
+    StreamingBase64Parser,
+    StreamingContentHandler,
+    add_xml_child,
+    create_element,
+    set_xml_value,
+)
+from .common import EWSAccountService, attachment_ids_element
+
+# https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/bodytype
+BODY_TYPE_CHOICES = ("Best", "HTML", "Text")
+
+
+class GetAttachment(EWSAccountService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getattachment-operation"""
+
+    SERVICE_NAME = "GetAttachment"
+    element_container_name = f"{{{MNS}}}Attachments"
+    cls_map = {cls.response_tag(): cls for cls in (FileAttachment, ItemAttachment)}
+
+    def call(self, items, include_mime_content, body_type, filter_html_content, additional_fields):
+        if body_type and body_type not in BODY_TYPE_CHOICES:
+            raise InvalidEnumValue("body_type", body_type, BODY_TYPE_CHOICES)
+        return self._elems_to_objs(
+            self._chunked_get_elements(
+                self.get_payload,
+                items=items,
+                include_mime_content=include_mime_content,
+                body_type=body_type,
+                filter_html_content=filter_html_content,
+                additional_fields=additional_fields,
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        return self.cls_map[elem.tag].from_xml(elem=elem, account=self.account)
+
+    def get_payload(self, items, include_mime_content, body_type, filter_html_content, additional_fields):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        shape_elem = create_element("m:AttachmentShape")
+        if include_mime_content:
+            add_xml_child(shape_elem, "t:IncludeMimeContent", "true")
+        if body_type:
+            add_xml_child(shape_elem, "t:BodyType", body_type)
+        if filter_html_content is not None:
+            add_xml_child(shape_elem, "t:FilterHtmlContent", "true" if filter_html_content else "false")
+        if additional_fields:
+            additional_properties = create_element("t:AdditionalProperties")
+            expanded_fields = chain(*(f.expand(version=self.account.version) for f in additional_fields))
+            set_xml_value(
+                additional_properties,
+                sorted(expanded_fields, key=lambda f: (getattr(f.field, "field_uri", ""), f.path)),
+                version=self.account.version,
+            )
+            shape_elem.append(additional_properties)
+        if len(shape_elem):
+            payload.append(shape_elem)
+        payload.append(attachment_ids_element(items=items, version=self.account.version))
+        return payload
+
+    def _update_api_version(self, api_version, header):
+        if not self.streaming:
+            super()._update_api_version(api_version, header)
+        # TODO: We're skipping this part in streaming mode because StreamingBase64Parser cannot parse the SOAP header
+
+    def _get_soap_parts(self, response):
+        if not self.streaming:
+            return super()._get_soap_parts(response)
+        # Pass the response unaltered. We want to use our custom streaming parser
+        return None, response
+
+    def _get_soap_messages(self, body):
+        if not self.streaming:
+            return super()._get_soap_messages(body)
+        # 'body' is actually the raw response passed on by '_get_soap_parts'
+        r = body
+        parser = StreamingBase64Parser()
+        field = FileAttachment.get_field_by_fieldname("_content")
+        handler = StreamingContentHandler(parser=parser, ns=field.namespace, element_name=field.field_uri)
+        parser.setContentHandler(handler)
+        return parser.parse(r)
+
+    def stream_file_content(self, attachment_id):
+        # The streaming XML parser can only stream content of one attachment
+        payload = self.get_payload(
+            items=[attachment_id],
+            include_mime_content=False,
+            body_type=None,
+            filter_html_content=None,
+            additional_fields=None,
+        )
+        self.streaming = True
+        try:
+            yield from self._get_response_xml(payload=payload)
+        except ElementNotFound as enf:
+            # When the returned XML does not contain a Content element, ElementNotFound is thrown by parser.parse().
+            # Let the non-streaming SOAP parser parse the response and hook into the normal exception handling.
+            # Wrap in DummyResponse because _get_soap_parts() expects an iter_content() method.
+            response = DummyResponse(content=enf.data)
+            _, body = super()._get_soap_parts(response=response)
+            # TODO: We're skipping ._update_api_version() here because we don't have access to the 'api_version' used.
+            res = super()._get_soap_messages(body=body)
+            for e in self._get_elements_in_response(response=res):
+                if isinstance(e, Exception):
+                    raise e
+            # The returned content did not contain any EWS exceptions. Give up and re-raise the original exception.
+            raise enf
+        finally:
+            self.stop_streaming()
+            self.streaming = False

package/bin/_internal/exchangelib/services/get_delegate.py

@@ -0,0 +1,45 @@
+from ..properties import DelegateUser, DLMailbox, UserId  # The service expects a Mailbox element in the MNS namespace
+from ..util import MNS, create_element, set_xml_value
+from ..version import EXCHANGE_2007_SP1
+from .common import EWSAccountService
+
+
+class GetDelegate(EWSAccountService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getdelegate-operation"""
+
+    SERVICE_NAME = "GetDelegate"
+    ERRORS_TO_CATCH_IN_RESPONSE = ()
+    supported_from = EXCHANGE_2007_SP1
+
+    def call(self, user_ids, include_permissions):
+        return self._elems_to_objs(
+            self._chunked_get_elements(
+                self.get_payload,
+                items=user_ids or [None],
+                mailbox=DLMailbox(email_address=self.account.primary_smtp_address),
+                include_permissions=include_permissions,
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        return DelegateUser.from_xml(elem=elem, account=self.account)
+
+    def get_payload(self, user_ids, mailbox, include_permissions):
+        payload = create_element(f"m:{self.SERVICE_NAME}", attrs=dict(IncludePermissions=include_permissions))
+        set_xml_value(payload, mailbox, version=self.protocol.version)
+        if user_ids != [None]:
+            user_ids_elem = create_element("m:UserIds")
+            for user_id in user_ids:
+                if isinstance(user_id, str):
+                    user_id = UserId(primary_smtp_address=user_id)
+                set_xml_value(user_ids_elem, user_id, version=self.protocol.version)
+            set_xml_value(payload, user_ids_elem, version=self.protocol.version)
+        return payload
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        return container.findall(DelegateUser.response_tag())
+
+    @classmethod
+    def _response_message_tag(cls):
+        return f"{{{MNS}}}DelegateUserResponseMessageType"

package/bin/_internal/exchangelib/services/get_events.py

@@ -0,0 +1,39 @@
+import logging
+
+from ..properties import Notification
+from ..util import create_element
+from .common import EWSAccountService, add_xml_child
+
+log = logging.getLogger(__name__)
+
+
+class GetEvents(EWSAccountService):
+    """MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getevents-operation
+    """
+
+    SERVICE_NAME = "GetEvents"
+    prefer_affinity = True
+
+    def call(self, subscription_id, watermark):
+        return self._elems_to_objs(
+            self._get_elements(
+                payload=self.get_payload(
+                    subscription_id=subscription_id,
+                    watermark=watermark,
+                )
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        return Notification.from_xml(elem=elem, account=None)
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        return container.findall(Notification.response_tag())
+
+    def get_payload(self, subscription_id, watermark):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        add_xml_child(payload, "m:SubscriptionId", subscription_id)
+        add_xml_child(payload, "m:Watermark", watermark)
+        return payload

package/bin/_internal/exchangelib/services/get_folder.py

@@ -0,0 +1,65 @@
+from ..errors import (
+    ErrorAccessDenied,
+    ErrorFolderNotFound,
+    ErrorInvalidOperation,
+    ErrorItemNotFound,
+    ErrorNoPublicFolderReplicaAvailable,
+)
+from ..util import MNS, create_element
+from .common import EWSAccountService, folder_ids_element, parse_folder_elem, shape_element
+
+
+class GetFolder(EWSAccountService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getfolder-operation"""
+
+    SERVICE_NAME = "GetFolder"
+    element_container_name = f"{{{MNS}}}Folders"
+    ERRORS_TO_CATCH_IN_RESPONSE = EWSAccountService.ERRORS_TO_CATCH_IN_RESPONSE + (
+        ErrorAccessDenied,
+        ErrorFolderNotFound,
+        ErrorNoPublicFolderReplicaAvailable,
+        ErrorInvalidOperation,
+        ErrorItemNotFound,
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.folders = []  # A hack to communicate parsing args to _elems_to_objs()
+
+    def call(self, folders, additional_fields, shape):
+        """Take a folder ID and returns the full information for that folder.
+
+        :param folders: a list of Folder objects
+        :param additional_fields: the extra fields that should be returned with the folder, as FieldPath objects
+        :param shape: The set of attributes to return
+
+        :return: XML elements for the folders, in stable order
+        """
+        # We can't easily find the correct folder class from the returned XML. Instead, return objects with the same
+        # class as the folder instance it was requested with.
+        self.folders = list(folders)  # Convert to a list, in case 'folders' is a generator. We're iterating twice.
+        return self._elems_to_objs(
+            self._chunked_get_elements(
+                self.get_payload,
+                items=self.folders,
+                additional_fields=additional_fields,
+                shape=shape,
+            )
+        )
+
+    def _elems_to_objs(self, elems):
+        for folder, elem in zip(self.folders, elems):
+            if isinstance(elem, Exception):
+                yield elem
+                continue
+            yield parse_folder_elem(elem=elem, folder=folder)
+
+    def get_payload(self, folders, additional_fields, shape):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        payload.append(
+            shape_element(
+                tag="m:FolderShape", shape=shape, additional_fields=additional_fields, version=self.account.version
+            )
+        )
+        payload.append(folder_ids_element(folders=folders, version=self.account.version))
+        return payload

package/bin/_internal/exchangelib/services/get_item.py

@@ -0,0 +1,41 @@
+from ..folders.base import BaseFolder
+from ..util import MNS, create_element
+from .common import EWSAccountService, item_ids_element, shape_element
+
+
+class GetItem(EWSAccountService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getitem-operation"""
+
+    SERVICE_NAME = "GetItem"
+    element_container_name = f"{{{MNS}}}Items"
+
+    def call(self, items, additional_fields, shape):
+        """Return all items in an account that correspond to a list of ID's, in stable order.
+
+        :param items: a list of (id, changekey) tuples or Item objects
+        :param additional_fields: the extra fields that should be returned with the item, as FieldPath objects
+        :param shape: The shape of returned objects
+
+        :return: XML elements for the items, in stable order
+        """
+        return self._elems_to_objs(
+            self._chunked_get_elements(
+                self.get_payload,
+                items=items,
+                additional_fields=additional_fields,
+                shape=shape,
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        return BaseFolder.item_model_from_tag(elem.tag).from_xml(elem=elem, account=self.account)
+
+    def get_payload(self, items, additional_fields, shape):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        payload.append(
+            shape_element(
+                tag="m:ItemShape", shape=shape, additional_fields=additional_fields, version=self.account.version
+            )
+        )
+        payload.append(item_ids_element(items=items, version=self.account.version))
+        return payload

package/bin/_internal/exchangelib/services/get_mail_tips.py

@@ -0,0 +1,43 @@
+from ..properties import MailTips
+from ..util import MNS, create_element, set_xml_value
+from .common import EWSService
+
+
+class GetMailTips(EWSService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getmailtips-operation"""
+
+    SERVICE_NAME = "GetMailTips"
+
+    def call(self, sending_as, recipients, mail_tips_requested):
+        return self._elems_to_objs(
+            self._chunked_get_elements(
+                self.get_payload,
+                items=recipients,
+                sending_as=sending_as,
+                mail_tips_requested=mail_tips_requested,
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        return MailTips.from_xml(elem=elem, account=None)
+
+    def get_payload(self, recipients, sending_as, mail_tips_requested):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        set_xml_value(payload, sending_as, version=self.protocol.version)
+
+        recipients_elem = create_element("m:Recipients")
+        for recipient in recipients:
+            set_xml_value(recipients_elem, recipient, version=self.protocol.version)
+        payload.append(recipients_elem)
+
+        if mail_tips_requested:
+            set_xml_value(payload, mail_tips_requested, version=self.protocol.version)
+        return payload
+
+    def _get_elements_in_response(self, response):
+        for msg in response:
+            yield self._get_element_container(message=msg, name=MailTips.response_tag())
+
+    @classmethod
+    def _response_message_tag(cls):
+        return f"{{{MNS}}}MailTipsResponseMessageType"

package/bin/_internal/exchangelib/services/get_persona.py

@@ -0,0 +1,31 @@
+from ..items import Persona
+from ..properties import PersonaId
+from ..util import MNS, create_element, set_xml_value
+from .common import EWSAccountService, to_item_id
+
+
+class GetPersona(EWSAccountService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getpersona-operation"""
+
+    SERVICE_NAME = "GetPersona"
+
+    def call(self, personas):
+        # GetPersona only accepts one persona ID per request. Crazy.
+        for persona in personas:
+            yield from self._elems_to_objs(self._get_elements(payload=self.get_payload(persona=persona)))
+
+    def _elem_to_obj(self, elem):
+        return Persona.from_xml(elem=elem, account=None)
+
+    def get_payload(self, persona):
+        return set_xml_value(
+            create_element(f"m:{self.SERVICE_NAME}"), to_item_id(persona, PersonaId), version=self.protocol.version
+        )
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        return container.findall(f"{{{MNS}}}{Persona.ELEMENT_NAME}")
+
+    @classmethod
+    def _response_tag(cls):
+        return f"{{{MNS}}}{cls.SERVICE_NAME}ResponseMessage"

package/bin/_internal/exchangelib/services/get_room_lists.py

@@ -0,0 +1,21 @@
+from ..properties import RoomList
+from ..util import MNS, create_element
+from ..version import EXCHANGE_2010
+from .common import EWSService
+
+
+class GetRoomLists(EWSService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getroomlists-operation"""
+
+    SERVICE_NAME = "GetRoomLists"
+    element_container_name = f"{{{MNS}}}RoomLists"
+    supported_from = EXCHANGE_2010
+
+    def call(self):
+        return self._elems_to_objs(self._get_elements(payload=self.get_payload()))
+
+    def _elem_to_obj(self, elem):
+        return RoomList.from_xml(elem=elem, account=None)
+
+    def get_payload(self):
+        return create_element(f"m:{self.SERVICE_NAME}")

package/bin/_internal/exchangelib/services/get_rooms.py

@@ -0,0 +1,21 @@
+from ..properties import Room
+from ..util import MNS, create_element, set_xml_value
+from ..version import EXCHANGE_2010
+from .common import EWSService
+
+
+class GetRooms(EWSService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getrooms-operation"""
+
+    SERVICE_NAME = "GetRooms"
+    element_container_name = f"{{{MNS}}}Rooms"
+    supported_from = EXCHANGE_2010
+
+    def call(self, room_list):
+        return self._elems_to_objs(self._get_elements(payload=self.get_payload(room_list=room_list)))
+
+    def _elem_to_obj(self, elem):
+        return Room.from_xml(elem=elem, account=None)
+
+    def get_payload(self, room_list):
+        return set_xml_value(create_element(f"m:{self.SERVICE_NAME}"), room_list, version=self.protocol.version)

package/bin/_internal/exchangelib/services/get_searchable_mailboxes.py

@@ -0,0 +1,48 @@
+from ..errors import MalformedResponseError
+from ..properties import FailedMailbox, SearchableMailbox
+from ..util import MNS, add_xml_child, create_element
+from ..version import EXCHANGE_2013
+from .common import EWSService
+
+
+class GetSearchableMailboxes(EWSService):
+    """MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getsearchablemailboxes-operation
+    """
+
+    SERVICE_NAME = "GetSearchableMailboxes"
+    element_container_name = f"{{{MNS}}}SearchableMailboxes"
+    failed_mailboxes_container_name = f"{{{MNS}}}FailedMailboxes"
+    supported_from = EXCHANGE_2013
+    cls_map = {cls.response_tag(): cls for cls in (SearchableMailbox, FailedMailbox)}
+
+    def call(self, search_filter, expand_group_membership):
+        return self._elems_to_objs(
+            self._get_elements(
+                payload=self.get_payload(
+                    search_filter=search_filter,
+                    expand_group_membership=expand_group_membership,
+                )
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        return self.cls_map[elem.tag].from_xml(elem=elem, account=None)
+
+    def get_payload(self, search_filter, expand_group_membership):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        if search_filter:
+            add_xml_child(payload, "m:SearchFilter", search_filter)
+        if expand_group_membership is not None:
+            add_xml_child(payload, "m:ExpandGroupMembership", "true" if expand_group_membership else "false")
+        return payload
+
+    def _get_elements_in_response(self, response):
+        for msg in response:
+            for container_name in (self.element_container_name, self.failed_mailboxes_container_name):
+                try:
+                    container = self._get_element_container(message=msg, name=container_name)
+                except MalformedResponseError:
+                    # Responses may contain no mailboxes of either kind. _get_element_container() does not accept this.
+                    continue
+                yield from self._get_elements_in_container(container=container)

package/bin/_internal/exchangelib/services/get_server_time_zones.py

@@ -0,0 +1,39 @@
+from ..properties import TimeZoneDefinition
+from ..util import MNS, create_element, peek, set_xml_value
+from ..version import EXCHANGE_2010
+from .common import EWSService
+
+
+class GetServerTimeZones(EWSService):
+    """MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/getservertimezones-operation
+    """
+
+    SERVICE_NAME = "GetServerTimeZones"
+    element_container_name = f"{{{MNS}}}TimeZoneDefinitions"
+    supported_from = EXCHANGE_2010
+
+    def call(self, timezones=None, return_full_timezone_data=False):
+        return self._elems_to_objs(
+            self._get_elements(
+                payload=self.get_payload(timezones=timezones, return_full_timezone_data=return_full_timezone_data)
+            )
+        )
+
+    def get_payload(self, timezones, return_full_timezone_data):
+        payload = create_element(
+            f"m:{self.SERVICE_NAME}",
+            attrs=dict(ReturnFullTimeZoneData=return_full_timezone_data),
+        )
+        if timezones is not None:
+            is_empty, timezones = peek(timezones)
+            if not is_empty:
+                tz_ids = create_element("m:Ids")
+                for timezone in timezones:
+                    tz_id = set_xml_value(create_element("t:Id"), timezone.ms_id)
+                    tz_ids.append(tz_id)
+                payload.append(tz_ids)
+        return payload
+
+    def _elem_to_obj(self, elem):
+        return TimeZoneDefinition.from_xml(elem=elem, account=None)