@backtomyfuture/exchange-cli-darwin-arm64 0.1.8 → 0.1.10

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

@@ -0,0 +1,17 @@
+from ..util import create_element, set_xml_value
+from .common import EWSAccountService
+
+
+class UpdateUserConfiguration(EWSAccountService):
+    """MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/updateuserconfiguration-operation
+    """
+
+    SERVICE_NAME = "UpdateUserConfiguration"
+    returns_elements = False
+
+    def call(self, user_configuration):
+        return self._get_elements(payload=self.get_payload(user_configuration=user_configuration))
+
+    def get_payload(self, user_configuration):
+        return set_xml_value(create_element(f"m:{self.SERVICE_NAME}"), user_configuration, version=self.account.version)

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

@@ -0,0 +1,47 @@
+from ..properties import ItemId, ParentFolderId
+from ..util import MNS, add_xml_child, create_element, set_xml_value
+from .common import EWSAccountService, to_item_id
+
+
+class UploadItems(EWSAccountService):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/uploaditems-operation"""
+
+    SERVICE_NAME = "UploadItems"
+    element_container_name = f"{{{MNS}}}ItemId"
+
+    def call(self, items):
+        # _pool_requests expects 'items', not 'data'
+        return self._elems_to_objs(self._chunked_get_elements(self.get_payload, items=items))
+
+    def get_payload(self, items):
+        """Upload given items to given account.
+
+        'items' is an iterable of tuples where the first element is a Folder instance representing the ParentFolder
+        that the item will be placed in and the second element is a tuple containing an optional ItemId, an optional
+        Item.is_associated boolean, and a Data string returned from an ExportItems.
+        call.
+
+        :param items:
+        """
+        payload = create_element(f"m:{self.SERVICE_NAME}")
+        items_elem = create_element("m:Items")
+        payload.append(items_elem)
+        for parent_folder, (item_id, is_associated, data_str) in items:
+            # TODO: The full spec also allows the "UpdateOrCreate" create action.
+            attrs = dict(CreateAction="Update" if item_id else "CreateNew")
+            if is_associated is not None:
+                attrs["IsAssociated"] = is_associated
+            item = create_element("t:Item", attrs=attrs)
+            set_xml_value(item, ParentFolderId(parent_folder.id, parent_folder.changekey), version=self.account.version)
+            if item_id:
+                set_xml_value(item, to_item_id(item_id, ItemId), version=self.account.version)
+            add_xml_child(item, "t:Data", data_str)
+            items_elem.append(item)
+        return payload
+
+    def _elem_to_obj(self, elem):
+        return elem.get(ItemId.ID_ATTR), elem.get(ItemId.CHANGEKEY_ATTR)
+
+    @classmethod
+    def _get_elements_in_container(cls, container):
+        return [container]

package/bin/_internal/exchangelib/settings.py

@@ -0,0 +1,88 @@
+import datetime
+
+from .ewsdatetime import UTC
+from .fields import Choice, ChoiceField, DateTimeField, MessageField
+from .properties import EWSElement, OutOfOffice
+from .util import create_element, set_xml_value
+
+
+class OofSettings(EWSElement):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/oofsettings"""
+
+    ELEMENT_NAME = "OofSettings"
+    REQUEST_ELEMENT_NAME = "UserOofSettings"
+
+    ENABLED = "Enabled"
+    SCHEDULED = "Scheduled"
+    DISABLED = "Disabled"
+    STATE_CHOICES = (ENABLED, SCHEDULED, DISABLED)
+
+    state = ChoiceField(field_uri="OofState", is_required=True, choices={Choice(c) for c in STATE_CHOICES})
+    external_audience = ChoiceField(
+        field_uri="ExternalAudience", choices={Choice("None"), Choice("Known"), Choice("All")}, default="All"
+    )
+    start = DateTimeField(field_uri="StartTime")
+    end = DateTimeField(field_uri="EndTime")
+    internal_reply = MessageField(field_uri="InternalReply")
+    external_reply = MessageField(field_uri="ExternalReply")
+
+    def clean(self, version=None):
+        super().clean(version=version)
+        if self.state == self.SCHEDULED:
+            if not self.start or not self.end:
+                raise ValueError(f"'start' and 'end' must be set when state is {self.SCHEDULED!r}")
+            if self.start >= self.end:
+                raise ValueError("'start' must be before 'end'")
+            if self.end < datetime.datetime.now(tz=UTC):
+                raise ValueError("'end' must be in the future")
+            # Some servers only like UTC timestamps
+            self.start = self.start.astimezone(UTC)
+            self.end = self.end.astimezone(UTC)
+        if self.state != self.DISABLED and (not self.internal_reply or not self.external_reply):
+            raise ValueError(f"'internal_reply' and 'external_reply' must be set when state is not {self.DISABLED!r}")
+
+    @classmethod
+    def from_xml(cls, elem, account):
+        kwargs = {}
+        for attr in ("state", "external_audience", "internal_reply", "external_reply"):
+            f = cls.get_field_by_fieldname(attr)
+            kwargs[attr] = f.from_xml(elem=elem, account=account)
+        kwargs.update(OutOfOffice.duration_to_start_end(elem=elem, account=account))
+        cls._clear(elem)
+        return cls(**kwargs)
+
+    def to_xml(self, version):
+        self.clean(version=version)
+        elem = create_element(f"t:{self.REQUEST_ELEMENT_NAME}")
+        for attr in ("state", "external_audience"):
+            value = getattr(self, attr)
+            f = self.get_field_by_fieldname(attr)
+            set_xml_value(elem, f.to_xml(value, version=version))
+        if self.start or self.end:
+            duration = create_element("t:Duration")
+            if self.start:
+                f = self.get_field_by_fieldname("start")
+                set_xml_value(duration, f.to_xml(self.start, version=version))
+            if self.end:
+                f = self.get_field_by_fieldname("end")
+                set_xml_value(duration, f.to_xml(self.end, version=version))
+            elem.append(duration)
+        for attr in ("internal_reply", "external_reply"):
+            value = getattr(self, attr)
+            if value is None:
+                value = ""  # The value can be empty, but the XML element must always be present
+            f = self.get_field_by_fieldname(attr)
+            set_xml_value(elem, f.to_xml(value, version=version))
+        return elem
+
+    def __hash__(self):
+        # Customize comparison
+        if self.state == self.DISABLED:
+            # All values except state are ignored by the server
+            relevant_attrs = ("state",)
+        elif self.state != self.SCHEDULED:
+            # 'start' and 'end' values are ignored by the server, and the server always returns today's date
+            relevant_attrs = tuple(f.name for f in self.FIELDS if f.name not in ("start", "end"))
+        else:
+            relevant_attrs = tuple(f.name for f in self.FIELDS)
+        return hash(tuple(getattr(self, attr) for attr in relevant_attrs))

package/bin/_internal/exchangelib/transport.py

@@ -0,0 +1,214 @@
+import logging
+from contextlib import suppress
+
+import requests.auth
+import requests_ntlm
+import requests_oauthlib
+
+from .errors import RateLimitError, TransportError, UnauthorizedError
+from .util import CONNECTION_ERRORS, TLS_ERRORS, _back_off_if_needed
+
+log = logging.getLogger(__name__)
+
+# Authentication method enums
+NOAUTH = "no authentication"
+NTLM = "NTLM"
+BASIC = "basic"
+DIGEST = "digest"
+GSSAPI = "gssapi"
+SSPI = "sspi"
+OAUTH2 = "OAuth 2.0"
+CBA = "CBA"  # Certificate Based Authentication
+
+# The auth types that must be accompanied by a credentials object
+CREDENTIALS_REQUIRED = (NTLM, BASIC, DIGEST, OAUTH2)
+
+AUTH_TYPE_MAP = {
+    NTLM: requests_ntlm.HttpNtlmAuth,
+    BASIC: requests.auth.HTTPBasicAuth,
+    DIGEST: requests.auth.HTTPDigestAuth,
+    OAUTH2: requests_oauthlib.OAuth2,
+    CBA: None,
+    NOAUTH: None,
+}
+with suppress(ImportError):
+    # Kerberos auth is optional
+    import requests_gssapi
+
+    AUTH_TYPE_MAP[GSSAPI] = requests_gssapi.HTTPSPNEGOAuth
+with suppress(ImportError):
+    # SSPI auth is optional
+    import requests_negotiate_sspi
+
+    AUTH_TYPE_MAP[SSPI] = requests_negotiate_sspi.HttpNegotiateAuth
+
+DEFAULT_ENCODING = "utf-8"
+DEFAULT_HEADERS = {"Content-Type": f"text/xml; charset={DEFAULT_ENCODING}", "Accept-Encoding": "gzip, deflate"}
+
+
+def get_auth_instance(auth_type, **kwargs):
+    """Return an *Auth instance suitable for the requests package.
+
+    :param auth_type:
+    :param kwargs:
+    """
+    model = AUTH_TYPE_MAP[auth_type]
+    if model is None:
+        return None
+    if auth_type == GSSAPI:
+        # Kerberos auth relies on credentials supplied via a ticket available externally to this library
+        return model()
+    if auth_type == SSPI:
+        # SSPI auth does not require credentials, but can have it
+        return model(**kwargs)
+    return model(**kwargs)
+
+
+def get_service_authtype(protocol):
+    # Get auth type by tasting headers from the server. Only do POST requests. HEAD is too error-prone, and some servers
+    # are set up to redirect to OWA on all requests except POST to /EWS/Exchange.asmx
+    #
+    # We don't know the API version yet, but we need it to create a valid request because some Exchange servers only
+    # respond when given a valid request. Try all known versions. Gross.
+    from .services import ConvertId
+
+    service_endpoint = protocol.service_endpoint
+    retry_policy = protocol.retry_policy
+    wait = protocol.RETRY_WAIT
+    for api_version in ConvertId.supported_api_versions():
+        protocol.api_version_hint = api_version
+        data = protocol.dummy_xml()
+        log.debug("Requesting %s from %s", data, service_endpoint)
+        while True:
+            _back_off_if_needed(retry_policy.back_off_until)
+            log.debug("Trying to get service auth type for %s", service_endpoint)
+            with protocol.raw_session(service_endpoint) as s:
+                try:
+                    r = s.post(
+                        url=service_endpoint,
+                        data=data,
+                        allow_redirects=False,
+                        timeout=protocol.TIMEOUT,
+                    )
+                    r.close()  # Release memory
+                    break
+                except TLS_ERRORS as e:
+                    # Don't retry on TLS errors. They will most likely be persistent.
+                    raise TransportError(str(e))
+                except CONNECTION_ERRORS as e:
+                    log.info("Connection error on URL %s.", service_endpoint)
+                    if not retry_policy.fail_fast:
+                        retry_policy.back_off(wait)
+                        continue
+                    raise TransportError(str(e)) from e
+                finally:
+                    wait *= 2
+        if r.status_code not in (200, 401):
+            log.debug("Unexpected response: %s %s", r.status_code, r.reason)
+            continue
+        try:
+            auth_type = get_auth_method_from_response(response=r)
+            log.debug("Auth type is %s", auth_type)
+            return auth_type
+        except UnauthorizedError:
+            continue
+    raise TransportError("Failed to get auth type from service")
+
+
+def get_autodiscover_authtype(protocol):
+    data = protocol.dummy_xml()
+    headers = {"X-AnchorMailbox": "DUMMY@example.com"}  # Required in case of OAuth
+    r = get_unauthenticated_autodiscover_response(protocol=protocol, method="post", headers=headers, data=data)
+    try:
+        auth_type = get_auth_method_from_response(response=r)
+        log.debug("Auth type is %s", auth_type)
+        return auth_type
+    except UnauthorizedError:
+        raise TransportError("Failed to get autodiscover auth type from service")
+
+
+def get_unauthenticated_autodiscover_response(protocol, method, headers=None, data=None):
+    service_endpoint = protocol.service_endpoint
+    retry_policy = protocol.retry_policy
+    wait = protocol.RETRY_WAIT
+    while True:
+        _back_off_if_needed(retry_policy.back_off_until)
+        log.debug("Trying to get response from %s", service_endpoint)
+        with protocol.raw_session(service_endpoint) as s:
+            try:
+                r = getattr(s, method)(
+                    url=service_endpoint,
+                    headers=headers,
+                    data=data,
+                    allow_redirects=False,
+                    timeout=protocol.TIMEOUT,
+                )
+                r.close()  # Release memory
+                break
+            except TLS_ERRORS as e:
+                # Don't retry on TLS errors. But wrap, so we can catch later and continue with the next endpoint.
+                raise TransportError(str(e))
+            except CONNECTION_ERRORS as e:
+                log.debug("Connection error on URL %s: %s", service_endpoint, e)
+                if not retry_policy.fail_fast:
+                    try:
+                        retry_policy.back_off(wait)
+                        continue
+                    except RateLimitError:
+                        pass
+                raise TransportError(str(e)) from e
+            finally:
+                wait *= 2
+    return r
+
+
+def get_auth_method_from_response(response):
+    # First, get the auth method from headers. Then, test credentials. Don't handle redirects - burden is on caller.
+    log.debug("Request headers: %s", response.request.headers)
+    log.debug("Response headers: %s", response.headers)
+    if response.status_code == 200:
+        return NOAUTH
+    # Get auth type from headers
+    for key, val in response.headers.items():
+        if key.lower() == "www-authenticate":
+            # Requests will combine multiple HTTP headers into one in 'request.headers'
+            vals = _tokenize(val.lower())
+            for v in vals:
+                if v.startswith("realm"):
+                    realm = v.split("=")[1].strip('"')
+                    log.debug("realm: %s", realm)
+            # Prefer most secure auth method if more than one is offered. See discussion at
+            # http://docs.oracle.com/javase/7/docs/technotes/guides/net/http-auth.html
+            if "digest" in vals:
+                return DIGEST
+            if "ntlm" in vals:
+                return NTLM
+            if "basic" in vals:
+                return BASIC
+        elif key.lower() == "ms-diagnostics-public" and "Modern Auth" in val:
+            return OAUTH2
+    raise UnauthorizedError("No compatible auth type was reported by server")
+
+
+def _tokenize(val):
+    # Splits cookie auth values
+    auth_methods = []
+    auth_method = ""
+    quote = False
+    for c in val:
+        if c in (" ", ",") and not quote:
+            if auth_method not in ("", ","):
+                auth_methods.append(auth_method)
+            auth_method = ""
+            continue
+        if c == '"':
+            auth_method += c
+            if quote:
+                auth_methods.append(auth_method)
+                auth_method = ""
+            quote = not quote
+            continue
+        auth_method += c
+    if auth_method:
+        auth_methods.append(auth_method)
+    return auth_methods