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

package/bin/_internal/exchangelib/items/message.py

@@ -0,0 +1,201 @@
+import logging
+
+from ..fields import Base64Field, BooleanField, CharField, EWSElementField, MailboxField, MailboxListField, TextField
+from ..properties import ReferenceItemId, ReminderMessageData
+from ..util import require_account, require_id
+from ..version import EXCHANGE_2013, EXCHANGE_2013_SP1
+from .base import AUTO_RESOLVE, SEND_AND_SAVE_COPY, SEND_ONLY, SEND_TO_NONE, BaseReplyItem
+from .item import Item
+
+log = logging.getLogger(__name__)
+
+
+class Message(Item):
+    """MSDN:
+    https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/message-ex15websvcsotherref
+    """
+
+    ELEMENT_NAME = "Message"
+
+    sender = MailboxField(field_uri="message:Sender", is_read_only=True, is_read_only_after_send=True)
+    to_recipients = MailboxListField(
+        field_uri="message:ToRecipients", is_read_only_after_send=True, is_searchable=False
+    )
+    cc_recipients = MailboxListField(
+        field_uri="message:CcRecipients", is_read_only_after_send=True, is_searchable=False
+    )
+    bcc_recipients = MailboxListField(
+        field_uri="message:BccRecipients", is_read_only_after_send=True, is_searchable=False
+    )
+    is_read_receipt_requested = BooleanField(
+        field_uri="message:IsReadReceiptRequested", is_required=True, default=False, is_read_only_after_send=True
+    )
+    is_delivery_receipt_requested = BooleanField(
+        field_uri="message:IsDeliveryReceiptRequested", is_required=True, default=False, is_read_only_after_send=True
+    )
+    conversation_index = Base64Field(field_uri="message:ConversationIndex", is_read_only=True)
+    conversation_topic = CharField(field_uri="message:ConversationTopic", is_read_only=True)
+    # Rename 'From' to 'author'. We can't use field name 'from' since it's a Python keyword.
+    author = MailboxField(field_uri="message:From", is_read_only_after_send=True)
+    message_id = TextField(field_uri="message:InternetMessageId", is_read_only_after_send=True)
+    is_read = BooleanField(field_uri="message:IsRead", is_required=True, default=False)
+    is_response_requested = BooleanField(field_uri="message:IsResponseRequested", default=False, is_required=True)
+    references = TextField(field_uri="message:References")
+    reply_to = MailboxListField(field_uri="message:ReplyTo", is_read_only_after_send=True, is_searchable=False)
+    received_by = MailboxField(field_uri="message:ReceivedBy", is_read_only=True)
+    received_representing = MailboxField(field_uri="message:ReceivedRepresenting", is_read_only=True)
+    reminder_message_data = EWSElementField(
+        field_uri="message:ReminderMessageData",
+        value_cls=ReminderMessageData,
+        supported_from=EXCHANGE_2013_SP1,
+        is_read_only=True,
+    )
+
+    @require_account
+    def send(
+        self,
+        save_copy=True,
+        copy_to_folder=None,
+        conflict_resolution=AUTO_RESOLVE,
+        send_meeting_invitations=SEND_TO_NONE,
+    ):
+        from ..services import SendItem
+
+        # Only sends a message. The message can either be an existing draft stored in EWS or a new message that does
+        # not yet exist in EWS.
+        if copy_to_folder and not save_copy:
+            raise AttributeError("'save_copy' must be True when 'copy_to_folder' is set")
+        if save_copy and not copy_to_folder:
+            copy_to_folder = self.account.sent  # 'Sent' is default EWS behaviour
+        if self.id:
+            SendItem(account=self.account).get(items=[self], saved_item_folder=copy_to_folder)
+            # The item will be deleted from the original folder
+            self._id = None
+            self.folder = copy_to_folder
+            return None
+
+        # New message
+        if copy_to_folder:
+            # This would better be done via send_and_save() but let's just support it here
+            self.folder = copy_to_folder
+            return self.send_and_save(
+                conflict_resolution=conflict_resolution, send_meeting_invitations=send_meeting_invitations
+            )
+
+        if self.account.version.build < EXCHANGE_2013 and self.attachments:
+            # At least some versions prior to Exchange 2013 can't send attachments immediately. You need to first save,
+            # then attach, then send. This is done in send_and_save(). send() will delete the item again.
+            self.send_and_save(
+                conflict_resolution=conflict_resolution, send_meeting_invitations=send_meeting_invitations
+            )
+            return None
+
+        self._create(message_disposition=SEND_ONLY, send_meeting_invitations=send_meeting_invitations)
+        return None
+
+    def send_and_save(
+        self, update_fields=None, conflict_resolution=AUTO_RESOLVE, send_meeting_invitations=SEND_TO_NONE
+    ):
+        # Sends Message and saves a copy in the parent folder. Does not return an ItemId.
+        if self.id:
+            return self._update(
+                update_fieldnames=update_fields,
+                message_disposition=SEND_AND_SAVE_COPY,
+                conflict_resolution=conflict_resolution,
+                send_meeting_invitations=send_meeting_invitations,
+            )
+        if self.account.version.build < EXCHANGE_2013 and self.attachments:
+            # At least some versions prior to Exchange 2013 can't send-and-save attachments immediately. You need
+            # to first save, then attach, then send. This is done in save().
+            self.save(
+                update_fields=update_fields,
+                conflict_resolution=conflict_resolution,
+                send_meeting_invitations=send_meeting_invitations,
+            )
+            return self.send(
+                save_copy=False,
+                conflict_resolution=conflict_resolution,
+                send_meeting_invitations=send_meeting_invitations,
+            )
+        return self._create(message_disposition=SEND_AND_SAVE_COPY, send_meeting_invitations=send_meeting_invitations)
+
+    @require_id
+    def create_reply(self, subject, body, to_recipients=None, cc_recipients=None, bcc_recipients=None, author=None):
+        if not to_recipients:
+            if not self.author:
+                raise ValueError("'to_recipients' must be set when message has no 'author'")
+            to_recipients = [self.author]
+        return ReplyToItem(
+            account=self.account,
+            reference_item_id=ReferenceItemId(id=self.id, changekey=self.changekey),
+            subject=subject,
+            new_body=body,
+            to_recipients=to_recipients,
+            cc_recipients=cc_recipients,
+            bcc_recipients=bcc_recipients,
+            author=author,
+        )
+
+    def reply(self, subject, body, to_recipients=None, cc_recipients=None, bcc_recipients=None, author=None):
+        return self.create_reply(subject, body, to_recipients, cc_recipients, bcc_recipients, author).send()
+
+    @require_id
+    def create_reply_all(self, subject, body, author=None):
+        me = MailboxField().clean(self.account.primary_smtp_address.lower())
+        to_recipients = set(self.to_recipients or [])
+        to_recipients.discard(me)
+        cc_recipients = set(self.cc_recipients or [])
+        cc_recipients.discard(me)
+        bcc_recipients = set(self.bcc_recipients or [])
+        bcc_recipients.discard(me)
+        if self.author:
+            to_recipients.add(self.author)
+        return ReplyAllToItem(
+            account=self.account,
+            reference_item_id=ReferenceItemId(id=self.id, changekey=self.changekey),
+            subject=subject,
+            new_body=body,
+            to_recipients=list(to_recipients),
+            cc_recipients=list(cc_recipients),
+            bcc_recipients=list(bcc_recipients),
+            author=author,
+        )
+
+    def reply_all(self, subject, body, author=None):
+        return self.create_reply_all(subject, body, author).send()
+
+    def mark_as_junk(self, is_junk=True, move_item=True):
+        """Mark or un-marks items as junk email.
+
+        :param is_junk: If True, the sender will be added from the blocked sender list. Otherwise, the sender will be
+        removed.
+        :param move_item: If true, the item will be moved to the junk folder.
+        :return:
+        """
+        from ..services import MarkAsJunk
+
+        res = MarkAsJunk(account=self.account).get(
+            items=[self], is_junk=is_junk, move_item=move_item, expect_result=None
+        )
+        if res is None:
+            return
+        self.folder = self.account.junk if is_junk else self.account.inbox
+        self.id, self.changekey = res
+
+
+class ReplyToItem(BaseReplyItem):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/replytoitem"""
+
+    ELEMENT_NAME = "ReplyToItem"
+
+
+class ReplyAllToItem(BaseReplyItem):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/replyalltoitem"""
+
+    ELEMENT_NAME = "ReplyAllToItem"
+
+
+class ForwardItem(BaseReplyItem):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/forwarditem"""
+
+    ELEMENT_NAME = "ForwardItem"

package/bin/_internal/exchangelib/items/post.py

@@ -0,0 +1,38 @@
+import logging
+
+from ..fields import BodyField, DateTimeField, MailboxField, TextField
+from .item import Item
+from .message import Message
+
+log = logging.getLogger(__name__)
+
+
+class PostItem(Item):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/postitem"""
+
+    ELEMENT_NAME = "PostItem"
+
+    conversation_index = Message.FIELDS["conversation_index"]
+    conversation_topic = Message.FIELDS["conversation_topic"]
+
+    author = Message.FIELDS["author"]
+    message_id = Message.FIELDS["message_id"]
+    is_read = Message.FIELDS["is_read"]
+
+    posted_time = DateTimeField(field_uri="postitem:PostedTime", is_read_only=True)
+    references = TextField(field_uri="message:References")
+    sender = MailboxField(field_uri="message:Sender", is_read_only=True, is_read_only_after_send=True)
+
+
+class PostReplyItem(Item):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/postreplyitem"""
+
+    ELEMENT_NAME = "PostReplyItem"
+
+    # This element only has Item fields up to, and including, 'culture'
+    # TDO: Plus all message fields
+    new_body = BodyField(field_uri="NewBodyContent")  # Accepts and returns Body or HTMLBody instances
+
+    culture_idx = Item.FIELDS.index_by_name("culture")
+    sender_idx = Message.FIELDS.index_by_name("sender")
+    FIELDS = Item.FIELDS[: culture_idx + 1] + Message.FIELDS[sender_idx:]

package/bin/_internal/exchangelib/items/task.py

@@ -0,0 +1,139 @@
+import datetime
+import logging
+from decimal import Decimal
+
+from ..ewsdatetime import UTC, EWSDateTime
+from ..fields import (
+    BooleanField,
+    CharField,
+    Choice,
+    ChoiceField,
+    DateTimeBackedDateField,
+    DateTimeField,
+    DecimalField,
+    IntegerField,
+    TaskRecurrenceField,
+    TextField,
+    TextListField,
+)
+from .item import Item
+
+log = logging.getLogger(__name__)
+
+
+class Task(Item):
+    """MSDN: https://docs.microsoft.com/en-us/exchange/client-developer/web-service-reference/task"""
+
+    ELEMENT_NAME = "Task"
+    NOT_STARTED = "NotStarted"
+    COMPLETED = "Completed"
+
+    actual_work = IntegerField(field_uri="task:ActualWork", min=0)
+    assigned_time = DateTimeField(field_uri="task:AssignedTime", is_read_only=True)
+    billing_information = TextField(field_uri="task:BillingInformation")
+    change_count = IntegerField(field_uri="task:ChangeCount", is_read_only=True, min=0)
+    companies = TextListField(field_uri="task:Companies")
+    # 'complete_date' can be set, but is ignored by the server, which sets it to now()
+    complete_date = DateTimeField(field_uri="task:CompleteDate", is_read_only=True)
+    contacts = TextListField(field_uri="task:Contacts")
+    delegation_state = ChoiceField(
+        field_uri="task:DelegationState",
+        choices={
+            Choice("NoMatch"),
+            Choice("OwnNew"),
+            Choice("Owned"),
+            Choice("Accepted"),
+            Choice("Declined"),
+            Choice("Max"),
+        },
+        is_read_only=True,
+    )
+    delegator = CharField(field_uri="task:Delegator", is_read_only=True)
+    due_date = DateTimeBackedDateField(field_uri="task:DueDate")
+    is_editable = BooleanField(field_uri="task:IsAssignmentEditable", is_read_only=True)
+    is_complete = BooleanField(field_uri="task:IsComplete", is_read_only=True)
+    is_recurring = BooleanField(field_uri="task:IsRecurring", is_read_only=True)
+    is_team_task = BooleanField(field_uri="task:IsTeamTask", is_read_only=True)
+    mileage = TextField(field_uri="task:Mileage")
+    owner = CharField(field_uri="task:Owner", is_read_only=True)
+    percent_complete = DecimalField(
+        field_uri="task:PercentComplete",
+        is_required=True,
+        default=Decimal(0.0),
+        min=Decimal(0),
+        max=Decimal(100),
+        is_searchable=False,
+    )
+    recurrence = TaskRecurrenceField(field_uri="task:Recurrence", is_searchable=False)
+    start_date = DateTimeBackedDateField(field_uri="task:StartDate")
+    status = ChoiceField(
+        field_uri="task:Status",
+        choices={
+            Choice(NOT_STARTED),
+            Choice("InProgress"),
+            Choice(COMPLETED),
+            Choice("WaitingOnOthers"),
+            Choice("Deferred"),
+        },
+        is_required=True,
+        is_searchable=False,
+        default=NOT_STARTED,
+    )
+    status_description = CharField(field_uri="task:StatusDescription", is_read_only=True)
+    total_work = IntegerField(field_uri="task:TotalWork", min=0)
+
+    # O365 throws ErrorInternalServerError "[0x004f0102] MapiReplyToBlob" if UniqueBody is requested
+    unique_body_idx = Item.FIELDS.index_by_name("unique_body")
+    FIELDS = Item.FIELDS[:unique_body_idx] + Item.FIELDS[unique_body_idx + 1 :]
+
+    def clean(self, version=None):
+        super().clean(version=version)
+        if self.due_date and self.start_date and self.due_date < self.start_date:
+            log.warning(
+                "'due_date' must be greater than 'start_date' (%s vs %s). Resetting 'due_date'",
+                self.due_date,
+                self.start_date,
+            )
+            self.due_date = self.start_date
+        if self.complete_date:
+            if self.status != self.COMPLETED:
+                log.warning(
+                    "'status' must be '%s' when 'complete_date' is set (%s). Resetting", self.COMPLETED, self.status
+                )
+                self.status = self.COMPLETED
+            now = datetime.datetime.now(tz=UTC)
+            if (self.complete_date - now).total_seconds() > 120:
+                # Reset complete_date values that are in the future
+                # 'complete_date' can be set automatically by the server. Allow some grace between local and server time
+                log.warning("'complete_date' must be in the past (%s vs %s). Resetting", self.complete_date, now)
+                self.complete_date = now
+            if self.start_date and self.complete_date.date() < self.start_date:
+                log.warning(
+                    "'complete_date' must be greater than 'start_date' (%s vs %s). Resetting",
+                    self.complete_date,
+                    self.start_date,
+                )
+                self.complete_date = EWSDateTime.combine(self.start_date, datetime.time(0, 0)).replace(tzinfo=UTC)
+        if self.percent_complete is not None:
+            if self.status == self.COMPLETED and self.percent_complete != Decimal(100):
+                # percent_complete must be 100% if task is complete
+                log.warning(
+                    "'percent_complete' must be 100 when 'status' is '%s' (%s). Resetting",
+                    self.COMPLETED,
+                    self.percent_complete,
+                )
+                self.percent_complete = Decimal(100)
+            elif self.status == self.NOT_STARTED and self.percent_complete != Decimal(0):
+                # percent_complete must be 0% if task is not started
+                log.warning(
+                    "'percent_complete' must be 0 when 'status' is '%s' (%s). Resetting",
+                    self.NOT_STARTED,
+                    self.percent_complete,
+                )
+                self.percent_complete = Decimal(0)
+
+    def complete(self):
+        # A helper method to mark a task as complete on the server
+        self.status = Task.COMPLETED
+        self.percent_complete = Decimal(100)
+        self.save()