@backtomyfuture/exchange-cli-darwin-x64 0.1.10

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

@@ -0,0 +1,43 @@
+from ..errors import InvalidEnumValue
+from ..properties import Notification
+from ..util import MNS, create_element
+from .common import EWSService, add_xml_child
+
+
+class SendNotification(EWSService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/sendnotification
+
+    This service is implemented backwards compared to other services. We use it to parse the XML body of push
+    notifications we receive on the callback URL defined in a push subscription, and to create responses to these
+    push notifications.
+    """
+
+    SERVICE_NAME = "SendNotification"
+    OK = "OK"
+    UNSUBSCRIBE = "Unsubscribe"
+    STATUS_CHOICES = (OK, UNSUBSCRIBE)
+
+    def ok_payload(self):
+        return self.wrap(content=self.get_payload(status=self.OK))
+
+    def unsubscribe_payload(self):
+        return self.wrap(content=self.get_payload(status=self.UNSUBSCRIBE))
+
+    def _elem_to_obj(self, elem):
+        return Notification.from_xml(elem=elem, account=None)
+
+    @classmethod
+    def _response_tag(cls):
+        """Return the name of the element containing the service response."""
+        return f"{{{MNS}}}{cls.SERVICE_NAME}"
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        return container.findall(Notification.response_tag())
+
+    def get_payload(self, status):
+        if status not in self.STATUS_CHOICES:
+            raise InvalidEnumValue("status", status, self.STATUS_CHOICES)
+        payload = create_element(f"m:{self.SERVICE_NAME}Result")
+        add_xml_child(payload, "m:SubscriptionStatus", status)
+        return payload

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

@@ -0,0 +1,34 @@
+from ..errors import InvalidTypeError
+from ..properties import AvailabilityMailbox, Mailbox
+from ..settings import OofSettings
+from ..util import MNS, create_element, set_xml_value
+from .common import EWSAccountService
+
+
+class SetUserOofSettings(EWSAccountService):
+    """Set automatic replies for the specified mailbox.
+    MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/setuseroofsettings-operation
+    """
+
+    SERVICE_NAME = "SetUserOofSettings"
+    returns_elements = False
+
+    def call(self, oof_settings, mailbox):
+        if not isinstance(oof_settings, OofSettings):
+            raise InvalidTypeError("oof_settings", oof_settings, OofSettings)
+        if not isinstance(mailbox, Mailbox):
+            raise InvalidTypeError("mailbox", mailbox, Mailbox)
+        return self._get_elements(payload=self.get_payload(oof_settings=oof_settings, mailbox=mailbox))
+
+    def get_payload(self, oof_settings, mailbox):
+        payload = create_element(f"m:{self.SERVICE_NAME}Request")
+        set_xml_value(payload, AvailabilityMailbox.from_mailbox(mailbox), version=self.account.version)
+        return set_xml_value(payload, oof_settings, version=self.account.version)
+
+    def _get_element_container(self, message, name=None):
+        message = message.find(self._response_message_tag())
+        return super()._get_element_container(message=message, name=name)
+
+    @classmethod
+    def _response_message_tag(cls):
+        return f"{{{MNS}}}ResponseMessage"

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

@@ -0,0 +1,125 @@
+"""The 'Subscribe' service has three different modes - pull, push and streaming - with different signatures. Implement
+as three distinct classes.
+"""
+
+import abc
+
+from ..util import MNS, create_element
+from .common import EWSAccountService, add_xml_child, folder_ids_element
+
+
+class Subscribe(EWSAccountService, metaclass=abc.ABCMeta):
+    """Base class for subscription classes.
+
+    MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/subscribe-operation"""
+
+    SERVICE_NAME = "Subscribe"
+    EVENT_TYPES = (
+        "CopiedEvent",
+        "CreatedEvent",
+        "DeletedEvent",
+        "ModifiedEvent",
+        "MovedEvent",
+        "NewMailEvent",
+        "FreeBusyChangedEvent",
+    )
+    subscription_request_elem_tag = None
+
+    def _partial_call(self, payload_func, folders, event_types, **kwargs):
+        if set(event_types) - set(self.EVENT_TYPES):
+            raise ValueError(f"'event_types' values must consist of values in {self.EVENT_TYPES}")
+        return self._elems_to_objs(
+            self._get_elements(payload=payload_func(folders=folders, event_types=event_types, **kwargs))
+        )
+
+    def _elem_to_obj(self, elem):
+        subscription_elem, watermark_elem = elem
+        return subscription_elem.text, watermark_elem.text
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        return [(container.find(f"{{{MNS}}}SubscriptionId"), container.find(f"{{{MNS}}}Watermark"))]
+
+    def _partial_payload(self, folders, event_types):
+        if folders is None:
+            # Interpret this as "all folders"
+            request_elem = create_element(self.subscription_request_elem_tag, attrs=dict(SubscribeToAllFolders=True))
+        else:
+            request_elem = create_element(self.subscription_request_elem_tag)
+            folder_ids = folder_ids_element(folders=folders, version=self.account.version, tag="t:FolderIds")
+            request_elem.append(folder_ids)
+        event_types_elem = create_element("t:EventTypes")
+        for event_type in event_types:
+            add_xml_child(event_types_elem, "t:EventType", event_type)
+        request_elem.append(event_types_elem)
+        return request_elem
+
+
+class SubscribeToPull(Subscribe):
+    # https://learn.microsoft.com/en-us/exchange/client-developer/web-service-reference/pullsubscriptionrequest
+    subscription_request_elem_tag = "m:PullSubscriptionRequest"
+    prefer_affinity = True
+
+    def call(self, folders, event_types, watermark, timeout):
+        yield from self._partial_call(
+            payload_func=self.get_payload,
+            folders=folders,
+            event_types=event_types,
+            timeout=timeout,
+            watermark=watermark,
+        )
+
+    def get_payload(self, folders, event_types, watermark, timeout):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        request_elem = self._partial_payload(folders=folders, event_types=event_types)
+        if watermark:
+            add_xml_child(request_elem, "m:Watermark", watermark)
+        add_xml_child(request_elem, "t:Timeout", timeout)  # In minutes
+        payload.append(request_elem)
+        return payload
+
+
+class SubscribeToPush(Subscribe):
+    # https://learn.microsoft.com/en-us/exchange/client-developer/web-service-reference/pushsubscriptionrequest
+    subscription_request_elem_tag = "m:PushSubscriptionRequest"
+
+    def call(self, folders, event_types, watermark, status_frequency, url):
+        yield from self._partial_call(
+            payload_func=self.get_payload,
+            folders=folders,
+            event_types=event_types,
+            status_frequency=status_frequency,
+            url=url,
+            watermark=watermark,
+        )
+
+    def get_payload(self, folders, event_types, watermark, status_frequency, url):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        request_elem = self._partial_payload(folders=folders, event_types=event_types)
+        if watermark:
+            add_xml_child(request_elem, "m:Watermark", watermark)
+        add_xml_child(request_elem, "t:StatusFrequency", status_frequency)  # In minutes
+        add_xml_child(request_elem, "t:URL", url)
+        payload.append(request_elem)
+        return payload
+
+
+class SubscribeToStreaming(Subscribe):
+    # https://learn.microsoft.com/en-us/exchange/client-developer/web-service-reference/streamingsubscriptionrequest
+    subscription_request_elem_tag = "m:StreamingSubscriptionRequest"
+    prefer_affinity = True
+
+    def call(self, folders, event_types):
+        yield from self._partial_call(payload_func=self.get_payload, folders=folders, event_types=event_types)
+
+    def _elem_to_obj(self, elem):
+        return elem.text
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        return [container.find(f"{{{MNS}}}SubscriptionId")]
+
+    def get_payload(self, folders, event_types):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        payload.append(self._partial_payload(folders=folders, event_types=event_types))
+        return payload

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

@@ -0,0 +1,95 @@
+import abc
+import logging
+
+from ..properties import FolderId
+from ..util import MNS, TNS, create_element, xml_text_to_value
+from .common import EWSAccountService, add_xml_child, folder_ids_element, parse_folder_elem, shape_element
+
+log = logging.getLogger(__name__)
+
+
+class SyncFolder(EWSAccountService, metaclass=abc.ABCMeta):
+    """Base class for SyncFolderHierarchy and SyncFolderItems."""
+
+    element_container_name = f"{{{MNS}}}Changes"
+    # Change types
+    CREATE = "create"
+    UPDATE = "update"
+    DELETE = "delete"
+    CHANGE_TYPES = (CREATE, UPDATE, DELETE)
+    shape_tag = None
+    last_in_range_name = None
+    change_types_map = {
+        f"{{{TNS}}}Create": CREATE,
+        f"{{{TNS}}}Update": UPDATE,
+        f"{{{TNS}}}Delete": DELETE,
+    }
+
+    def __init__(self, *args, **kwargs):
+        # These values are reset and set each time call() is consumed
+        self.sync_state = None
+        self.includes_last_item_in_range = None
+        super().__init__(*args, **kwargs)
+
+    def _get_element_container(self, message, name=None):
+        self.sync_state = message.find(f"{{{MNS}}}SyncState").text
+        log.debug("Sync state is: %s", self.sync_state)
+        self.includes_last_item_in_range = xml_text_to_value(message.find(self.last_in_range_name).text, bool)
+        log.debug("Includes last item in range: %s", self.includes_last_item_in_range)
+        return super()._get_element_container(message=message, name=name)
+
+    def _partial_get_payload(self, folder, shape, additional_fields, sync_state):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        payload.append(
+            shape_element(
+                tag=self.shape_tag, shape=shape, additional_fields=additional_fields, version=self.account.version
+            )
+        )
+        payload.append(folder_ids_element(folders=[folder], version=self.account.version, tag="m:SyncFolderId"))
+        if sync_state:
+            add_xml_child(payload, "m:SyncState", sync_state)
+        return payload
+
+
+class SyncFolderHierarchy(SyncFolder):
+    """MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/syncfolderhierarchy-operation
+    """
+
+    SERVICE_NAME = "SyncFolderHierarchy"
+    shape_tag = "m:FolderShape"
+    last_in_range_name = f"{{{MNS}}}IncludesLastFolderInRange"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.folder = None  # A hack to communicate parsing args to _elems_to_objs()
+
+    def call(self, folder, shape, additional_fields, sync_state):
+        self.sync_state = sync_state
+        self.folder = folder
+        return self._elems_to_objs(
+            self._get_elements(
+                payload=self.get_payload(
+                    folder=folder,
+                    shape=shape,
+                    additional_fields=additional_fields,
+                    sync_state=sync_state,
+                )
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        change_type = self.change_types_map[elem.tag]
+        if change_type == self.DELETE:
+            folder = FolderId.from_xml(elem=elem.find(FolderId.response_tag()), account=self.account)
+        else:
+            # We can't find() the element because we don't know which tag to look for. The change element can
+            # contain multiple folder types, each with their own tag.
+            folder_elem = elem[0]
+            folder = parse_folder_elem(elem=folder_elem, folder=self.folder)
+        return change_type, folder
+
+    def get_payload(self, folder, shape, additional_fields, sync_state):
+        return self._partial_get_payload(
+            folder=folder, shape=shape, additional_fields=additional_fields, sync_state=sync_state
+        )

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

@@ -0,0 +1,77 @@
+from ..errors import InvalidEnumValue, InvalidTypeError
+from ..folders import BaseFolder
+from ..properties import ItemId
+from ..util import MNS, TNS, peek, xml_text_to_value
+from .common import add_xml_child, item_ids_element
+from .sync_folder_hierarchy import SyncFolder
+
+
+class SyncFolderItems(SyncFolder):
+    """MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/syncfolderitems-operation
+    """
+
+    SERVICE_NAME = "SyncFolderItems"
+    SYNC_SCOPES = (
+        "NormalItems",
+        "NormalAndAssociatedItems",
+    )
+    # Extra change type
+    READ_FLAG_CHANGE = "read_flag_change"
+    CHANGE_TYPES = SyncFolder.CHANGE_TYPES + (READ_FLAG_CHANGE,)
+    shape_tag = "m:ItemShape"
+    last_in_range_name = f"{{{MNS}}}IncludesLastItemInRange"
+    change_types_map = SyncFolder.change_types_map
+    change_types_map[f"{{{TNS}}}ReadFlagChange"] = READ_FLAG_CHANGE
+
+    def call(self, folder, shape, additional_fields, sync_state, ignore, max_changes_returned, sync_scope):
+        self.sync_state = sync_state
+        if max_changes_returned is None:
+            max_changes_returned = 100
+        if not isinstance(max_changes_returned, int):
+            raise InvalidTypeError("max_changes_returned", max_changes_returned, int)
+        if max_changes_returned <= 0:
+            raise ValueError(f"'max_changes_returned' {max_changes_returned} must be a positive integer")
+        if sync_scope is not None and sync_scope not in self.SYNC_SCOPES:
+            raise InvalidEnumValue("sync_scope", sync_scope, self.SYNC_SCOPES)
+        return self._elems_to_objs(
+            self._get_elements(
+                payload=self.get_payload(
+                    folder=folder,
+                    shape=shape,
+                    additional_fields=additional_fields,
+                    sync_state=sync_state,
+                    ignore=ignore,
+                    max_changes_returned=max_changes_returned,
+                    sync_scope=sync_scope,
+                )
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        change_type = self.change_types_map[elem.tag]
+        if change_type == self.READ_FLAG_CHANGE:
+            item = (
+                ItemId.from_xml(elem=elem.find(ItemId.response_tag()), account=self.account),
+                xml_text_to_value(elem.find(f"{{{TNS}}}IsRead").text, bool),
+            )
+        elif change_type == self.DELETE:
+            item = ItemId.from_xml(elem=elem.find(ItemId.response_tag()), account=self.account)
+        else:
+            # We can't find() the element because we don't know which tag to look for. The change element can
+            # contain multiple item types, each with their own tag.
+            item_elem = elem[0]
+            item = BaseFolder.item_model_from_tag(item_elem.tag).from_xml(elem=item_elem, account=self.account)
+        return change_type, item
+
+    def get_payload(self, folder, shape, additional_fields, sync_state, ignore, max_changes_returned, sync_scope):
+        sync_folder_items = self._partial_get_payload(
+            folder=folder, shape=shape, additional_fields=additional_fields, sync_state=sync_state
+        )
+        is_empty, ignore = (True, None) if ignore is None else peek(ignore)
+        if not is_empty:
+            sync_folder_items.append(item_ids_element(items=ignore, version=self.account.version, tag="m:Ignore"))
+        add_xml_child(sync_folder_items, "m:MaxChangesReturned", max_changes_returned)
+        if sync_scope:
+            add_xml_child(sync_folder_items, "m:SyncScope", sync_scope)
+        return sync_folder_items

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

@@ -0,0 +1,21 @@
+from ..util import create_element
+from .common import EWSAccountService, add_xml_child
+
+
+class Unsubscribe(EWSAccountService):
+    """Unsubscribing is only valid for pull and streaming notifications.
+
+    MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/unsubscribe-operation
+    """
+
+    SERVICE_NAME = "Unsubscribe"
+    returns_elements = False
+    prefer_affinity = True
+
+    def call(self, subscription_id):
+        return self._get_elements(payload=self.get_payload(subscription_id=subscription_id))
+
+    def get_payload(self, subscription_id):
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        add_xml_child(payload, "m:SubscriptionId", subscription_id)
+        return payload

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

@@ -0,0 +1,158 @@
+import abc
+
+from ..fields import FieldPath, IndexedField
+from ..properties import FolderId
+from ..util import MNS, create_element, set_xml_value
+from .common import EWSAccountService, parse_folder_elem, to_item_id
+
+
+class BaseUpdateService(EWSAccountService, metaclass=abc.ABCMeta):
+    """Base class for UpdateFolder and UpdateItem"""
+
+    SET_FIELD_ELEMENT_NAME = None
+    DELETE_FIELD_ELEMENT_NAME = None
+    CHANGE_ELEMENT_NAME = None
+    CHANGES_ELEMENT_NAME = None
+
+    @staticmethod
+    def _sorted_fields(target_model, fieldnames):
+        # Take a list of fieldnames and return the fields in the order they are mentioned in target_model.FIELDS.
+        # Checks that all fieldnames are valid.
+        fieldnames_copy = list(fieldnames)
+        # Loop over FIELDS and not supported_fields(). Upstream should make sure not to update a non-supported field.
+        for f in target_model.FIELDS:
+            if f.name in fieldnames_copy:
+                fieldnames_copy.remove(f.name)
+                yield f
+        if fieldnames_copy:
+            raise ValueError(f"Field name(s) {fieldnames_copy} are not valid {target_model.__name__!r} fields")
+
+    def _get_value(self, target, field):
+        return field.clean(getattr(target, field.name), version=self.account.version)  # Make sure the value is OK
+
+    def _set_field_elems(self, target_model, field, value):
+        if isinstance(field, IndexedField):
+            # Generate either set or delete elements for all combinations of labels and subfields
+            supported_labels = field.value_cls.get_field_by_fieldname("label").supported_choices(
+                version=self.account.version
+            )
+            seen_labels = set()
+            subfields = field.value_cls.supported_fields(version=self.account.version)
+            for v in value:
+                seen_labels.add(v.label)
+                for subfield in subfields:
+                    field_path = FieldPath(field=field, label=v.label, subfield=subfield)
+                    subfield_value = getattr(v, subfield.name)
+                    if not subfield_value:
+                        # Generate delete elements for blank subfield values
+                        yield self._delete_field_elem(field_path=field_path)
+                    else:
+                        # Generate set elements for non-null subfield values
+                        yield self._set_field_elem(
+                            target_model=target_model,
+                            field_path=field_path,
+                            value=field.value_cls(**{"label": v.label, subfield.name: subfield_value}),
+                        )
+                # Generate delete elements for all subfields of all labels not mentioned in the list of values
+                for label in (label for label in supported_labels if label not in seen_labels):
+                    for subfield in subfields:
+                        yield self._delete_field_elem(field_path=FieldPath(field=field, label=label, subfield=subfield))
+        else:
+            yield self._set_field_elem(target_model=target_model, field_path=FieldPath(field=field), value=value)
+
+    def _set_field_elem(self, target_model, field_path, value):
+        set_field = create_element(self.SET_FIELD_ELEMENT_NAME)
+        set_xml_value(set_field, field_path, version=self.account.version)
+        folder = create_element(target_model.request_tag())
+        field_elem = field_path.field.to_xml(value, version=self.account.version)
+        set_xml_value(folder, field_elem, version=self.account.version)
+        set_field.append(folder)
+        return set_field
+
+    def _delete_field_elems(self, field):
+        for field_path in FieldPath(field=field).expand(version=self.account.version):
+            yield self._delete_field_elem(field_path=field_path)
+
+    def _delete_field_elem(self, field_path):
+        delete_folder_field = create_element(self.DELETE_FIELD_ELEMENT_NAME)
+        return set_xml_value(delete_folder_field, field_path, version=self.account.version)
+
+    def _update_elems(self, target, fieldnames):
+        target_model = target.__class__
+
+        for field in self._sorted_fields(target_model=target_model, fieldnames=fieldnames):
+            if field.is_read_only:
+                raise ValueError(f"{field.name!r} is a read-only field")
+            value = self._get_value(target, field)
+
+            if value is None or (field.is_list and not value):
+                # A value of None or [] means we want to remove this field from the item
+                if field.is_required or field.is_required_after_save:
+                    raise ValueError(f"{field.name!r} is a required field and may not be deleted")
+                yield from self._delete_field_elems(field)
+                continue
+
+            yield from self._set_field_elems(target_model=target_model, field=field, value=value)
+
+    def _change_elem(self, target, fieldnames):
+        if not fieldnames:
+            raise ValueError("'fieldnames' must not be empty")
+        change = create_element(self.CHANGE_ELEMENT_NAME)
+        set_xml_value(change, self._target_elem(target), version=self.account.version)
+        updates = create_element("t:Updates")
+        for elem in self._update_elems(target=target, fieldnames=fieldnames):
+            updates.append(elem)
+        change.append(updates)
+        return change
+
+    @staticmethod
+    @abc.abstractmethod
+    def _target_elem(target):
+        """Convert the object to update to an XML element"""
+
+    def _changes_elem(self, target_changes):
+        changes = create_element(self.CHANGES_ELEMENT_NAME)
+        for target, fieldnames in target_changes:
+            if not target.account:
+                target.account = self.account
+            changes.append(self._change_elem(target=target, fieldnames=fieldnames))
+        return changes
+
+
+class UpdateFolder(BaseUpdateService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/updatefolder-operation"""
+
+    SERVICE_NAME = "UpdateFolder"
+    SET_FIELD_ELEMENT_NAME = "t:SetFolderField"
+    DELETE_FIELD_ELEMENT_NAME = "t:DeleteFolderField"
+    CHANGE_ELEMENT_NAME = "t:FolderChange"
+    CHANGES_ELEMENT_NAME = "m:FolderChanges"
+    element_container_name = f"{{{MNS}}}Folders"
+
+    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):
+        # 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))
+
+    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)
+
+    @staticmethod
+    def _target_elem(target):
+        return to_item_id(target, FolderId)
+
+    def get_payload(self, folders):
+        # Takes a list of (Folder, fieldnames) tuples where 'Folder' is an instance of a subclass of Folder and
+        # 'fieldnames' are the attribute names that were updated.
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        payload.append(self._changes_elem(target_changes=folders))
+        return payload

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

@@ -0,0 +1,113 @@
+from ..errors import InvalidEnumValue
+from ..ewsdatetime import EWSDate
+from ..items import (
+    CONFLICT_RESOLUTION_CHOICES,
+    MESSAGE_DISPOSITION_CHOICES,
+    SEND_MEETING_INVITATIONS_AND_CANCELLATIONS_CHOICES,
+    SEND_ONLY,
+    CalendarItem,
+    Item,
+)
+from ..properties import ItemId
+from ..util import MNS, create_element
+from ..version import EXCHANGE_2013_SP1
+from .common import to_item_id
+from .update_folder import BaseUpdateService
+
+
+class UpdateItem(BaseUpdateService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/updateitem-operation"""
+
+    SERVICE_NAME = "UpdateItem"
+    SET_FIELD_ELEMENT_NAME = "t:SetItemField"
+    DELETE_FIELD_ELEMENT_NAME = "t:DeleteItemField"
+    CHANGE_ELEMENT_NAME = "t:ItemChange"
+    CHANGES_ELEMENT_NAME = "m:ItemChanges"
+    element_container_name = f"{{{MNS}}}Items"
+
+    def call(
+        self,
+        items,
+        conflict_resolution,
+        message_disposition,
+        send_meeting_invitations_or_cancellations,
+        suppress_read_receipts,
+    ):
+        if conflict_resolution not in CONFLICT_RESOLUTION_CHOICES:
+            raise InvalidEnumValue("conflict_resolution", conflict_resolution, CONFLICT_RESOLUTION_CHOICES)
+        if message_disposition not in MESSAGE_DISPOSITION_CHOICES:
+            raise InvalidEnumValue("message_disposition", message_disposition, MESSAGE_DISPOSITION_CHOICES)
+        if send_meeting_invitations_or_cancellations not in SEND_MEETING_INVITATIONS_AND_CANCELLATIONS_CHOICES:
+            raise InvalidEnumValue(
+                "send_meeting_invitations_or_cancellations",
+                send_meeting_invitations_or_cancellations,
+                SEND_MEETING_INVITATIONS_AND_CANCELLATIONS_CHOICES,
+            )
+        if message_disposition == SEND_ONLY:
+            raise ValueError("Cannot send-only existing objects. Use SendItem service instead")
+        return self._elems_to_objs(
+            self._chunked_get_elements(
+                self.get_payload,
+                items=items,
+                conflict_resolution=conflict_resolution,
+                message_disposition=message_disposition,
+                send_meeting_invitations_or_cancellations=send_meeting_invitations_or_cancellations,
+                suppress_read_receipts=suppress_read_receipts,
+            )
+        )
+
+    def _elem_to_obj(self, elem):
+        return Item.id_from_xml(elem)
+
+    def _update_elems(self, target, fieldnames):
+        fieldnames_copy = list(fieldnames)
+
+        if target.__class__ == CalendarItem:
+            # For CalendarItem items where we update 'start' or 'end', we want to update internal timezone fields
+            target.clean_timezone_fields(version=self.account.version)  # Possibly also sets timezone values
+            for field_name in ("start", "end"):
+                if field_name in fieldnames_copy:
+                    tz_field_name = target.tz_field_for_field_name(field_name).name
+                    if tz_field_name not in fieldnames_copy:
+                        fieldnames_copy.append(tz_field_name)
+
+        yield from super()._update_elems(target=target, fieldnames=fieldnames_copy)
+
+    def _get_value(self, target, field):
+        value = super()._get_value(target, field)
+
+        if target.__class__ == CalendarItem:
+            # For CalendarItem items where we update 'start' or 'end', we want to send values in the local timezone
+            if field.name in ("start", "end"):
+                if type(value) is EWSDate:
+                    # EWS always expects a datetime
+                    return target.date_to_datetime(field_name=field.name)
+                tz_field_name = target.tz_field_for_field_name(field.name).name
+                return value.astimezone(getattr(target, tz_field_name))
+
+        return value
+
+    @staticmethod
+    def _target_elem(target):
+        return to_item_id(target, ItemId)
+
+    def get_payload(
+        self,
+        items,
+        conflict_resolution,
+        message_disposition,
+        send_meeting_invitations_or_cancellations,
+        suppress_read_receipts,
+    ):
+        # Takes a list of (Item, fieldnames) tuples where 'Item' is an instance of a subclass of Item and 'fieldnames'
+        # are the attribute names that were updated.
+        attrs = dict(
+            ConflictResolution=conflict_resolution,
+            MessageDisposition=message_disposition,
+            SendMeetingInvitationsOrCancellations=send_meeting_invitations_or_cancellations,
+        )
+        if self.account.version.build >= EXCHANGE_2013_SP1:
+            attrs["SuppressReadReceipts"] = suppress_read_receipts
+        payload = create_element(f"m:{self.SERVICE_NAME}", attrs=attrs)
+        payload.append(self._changes_elem(target_changes=items))
+        return payload