modoboa 2.6.5__py3-none-any.whl → 2.7.0__py3-none-any.whl

modoboa/webmail/lib/sendmail.py

@@ -1,118 +1,16 @@
-from email.header import Header
-from email.mime.image import MIMEImage
-from importlib.metadata import version
-import os
-
 import smtplib
-from urllib.parse import unquote, urlparse
-
-import lxml
 
 from django.conf import settings
 from django.core import mail
-from django.core.mail import EmailMessage, EmailMultiAlternatives
 
-from modoboa.core import models as core_models
 from modoboa.parameters import tools as param_tools
-from modoboa.webmail.lib.attachments import create_mail_attachment
-from modoboa.webmail.lib.utils import html2plaintext
+from modoboa.webmail import constants, models
+from modoboa.webmail.exceptions import WebmailInternalError
+from modoboa.webmail.lib.utils import create_message
 
 from . import get_imapconnector
 
 
-def make_body_images_inline(body: str) -> tuple[str, list]:
-    """Look for images inside the body and make them inline.
-
-    Before sending a message in HTML format, it is necessary to find
-    all img tags contained in the body in order to rewrite them. For
-    example, icons provided by CKeditor are stored on the server
-    filesystem and not accessible from the outside. We must embark
-    them as parts of the MIME message if we want recipients to
-    display them correctly.
-
-    :param body: the HTML body to parse
-    """
-    html = lxml.html.fromstring(body)
-    parts = []
-    for tag in html.iter("img"):
-        src = tag.get("src")
-        if src is None:
-            continue
-        o = urlparse(src)
-        path = unquote(os.path.join(settings.BASE_DIR, o.path[1:]))
-        if not os.path.exists(path):
-            continue
-        fname = os.path.basename(path)
-        cid = f"{os.path.splitext(fname)[0]}@modoboa"
-        tag.set("src", f"cid:{cid}")
-        with open(path, "rb") as fp:
-            part = MIMEImage(fp.read())
-        part["Content-ID"] = f"<{cid}>"
-        part.replace_header("Content-Type", f'{part["Content-Type"]}; name="{fname}"')
-        part["Content-Disposition"] = "inline"
-        parts.append(part)
-    return lxml.html.tostring(html, encoding="unicode"), parts
-
-
-def html_msg(attributes: dict) -> EmailMultiAlternatives:
-    """Create a multipart message.
-
-    We attach two alternatives:
-    * text/html
-    * text/plain
-    """
-    body = attributes.get("body")
-    if body:
-        tbody = html2plaintext(body)
-        body, images = make_body_images_inline(body)
-    else:
-        tbody = ""
-        images = []
-    msg = EmailMultiAlternatives()
-    msg.body = tbody
-    msg.attach_alternative(body, "text/html")
-    for img in images:
-        msg.attach(img)
-    return msg
-
-
-def plain_msg(attributes: dict) -> EmailMessage:
-    """Create a simple text message."""
-    msg = EmailMessage()
-    msg.body = attributes.get("body", "")
-    return msg
-
-
-def format_sender_address(user: core_models.User, address: str) -> str:
-    """Format address before message is sent."""
-    if user.first_name != "" or user.last_name != "":
-        return f'"{Header(user.fullname, "utf8")}" <{address}>'
-    return address
-
-
-def create_message(user: core_models.User, attributes: dict, attachments: list):
-    headers = {"User-Agent": "Modoboa {}".format(version("modoboa"))}
-    origmsgid = attributes.get("in_reply_to")
-    if origmsgid:
-        headers.update({"References": origmsgid, "In-Reply-To": origmsgid})
-    mode = user.parameters.get_value("editor")
-    sender = format_sender_address(user, attributes["sender"])
-    if mode == "html":
-        msg = html_msg(attributes)
-    else:
-        msg = plain_msg(attributes)
-    msg.from_email = sender
-    msg.to = attributes["to"]
-    msg.headers = headers
-    for hdr in ["subject", "cc", "bcc"]:
-        if hdr in attributes:
-            setattr(msg, hdr, attributes[hdr])
-
-    for attachment in attachments:
-        msg.attach(create_mail_attachment(attachment))
-    return msg
-
-
 def send_mail(request, attributes: dict, attachments: list) -> tuple[bool, str | None]:
     """
     Send a new email.
@@ -161,3 +59,88 @@ def send_mail(request, attributes: dict, attachments: list) -> tuple[bool, str |
     with get_imapconnector(request) as imapc:
         imapc.push_mail(sentfolder, msg.message())
     return True, None
+
+
+def schedule_email(
+    request, attributes: dict, attachments: list
+) -> models.ScheduledMessage:
+    """Schedule a new email sending."""
+    scheduled_datetime = attributes["scheduled_datetime"].replace(
+        second=0, microsecond=0
+    )
+    sched_msg = models.ScheduledMessage(
+        account=request.user,
+        sender=attributes["sender"],
+        scheduled_datetime=scheduled_datetime,
+        to=",".join(attributes["to"]),
+        subject=attributes.get("subject", ""),
+        body=attributes.get("body", ""),
+        in_reply_to=attributes.get("in_reply_to", ""),
+    )
+    for attr in ["cc", "bcc"]:
+        if attr in attributes:
+            setattr(sched_msg, attr, ",".join(attributes[attr]))
+    sched_msg.save()
+
+    # Save a copy of this message into an IMAP mailbox
+    msg = sched_msg.to_email_message()
+    with get_imapconnector(request) as imapc:
+        try:
+            imapc.create_folder(constants.MAILBOX_NAME_SCHEDULED)
+        except WebmailInternalError:
+            pass
+        # TODO: deal with UID Validity
+        sched_msg.imap_uid = imapc.push_mail(
+            constants.MAILBOX_NAME_SCHEDULED, msg.message()
+        )
+        sched_msg.save()
+
+    for attachment in attachments:
+        mattachment = models.MessageAttachment(
+            message=sched_msg,
+        )
+        for header in ["content-type", "Content-Type"]:
+            if header in attachment:
+                mattachment.content_type = attachment[header]
+                break
+        if not mattachment.content_type:
+            continue
+
+        mattachment.file.name = attachment["tmpname"]
+        if "fname" in attachment:
+            mattachment.filename = attachment["fname"]
+        mattachment.save()
+
+    return sched_msg
+
+
+def send_scheduled_message(sched_msg: models.ScheduledMessage) -> bool:
+    """Send a scheduled message using configured SMTP server."""
+    msg = sched_msg.to_email_message()
+    conf = dict(param_tools.get_global_parameters("webmail"))
+    options = {
+        "host": conf["scheduling_smtp_server"],
+        "port": conf["scheduling_smtp_port"],
+    }
+    if conf["scheduling_smtp_secured_mode"] == "ssl":
+        options.update({"use_ssl": True})
+    elif conf["scheduling_smtp_secured_mode"] == "starttls":
+        options.update({"use_tls": True})
+
+    try:
+        with mail.get_connection(**options) as connection:
+            msg.connection = connection
+            msg.send()
+    except (smtplib.SMTPResponseException, smtplib.SMTPRecipientsRefused) as inst:
+        if isinstance(inst, smtplib.SMTPRecipientsRefused):
+            error = ", ".join(
+                [f"{rcpt}: {error}" for rcpt, error in inst.recipients.items()]
+            )
+        else:
+            error = str(inst.smtp_error)
+        sched_msg.status = constants.SchedulingState.SEND_ERROR.value
+        sched_msg.error = error
+        sched_msg.save()
+        return False
+
+    return sched_msg.delete_imap_copy()

modoboa/webmail/lib/utils.py

@@ -1,7 +1,19 @@
 """Misc. utilities."""
 
+from email.header import Header
+from email.mime.image import MIMEImage
+from importlib.metadata import version
+import os
+from urllib.parse import unquote, urlparse
+
 import lxml
 
+from django.conf import settings
+from django.core.mail import EmailMessage, EmailMultiAlternatives
+
+from modoboa.core import models as core_models
+from modoboa.webmail.lib.attachments import create_mail_attachment
+
 
 def html2plaintext(content: str) -> str:
     """HTML to plain text translation.
@@ -43,3 +55,100 @@ def decode_payload(encoding, payload):
 
         return quopri.decodestring(payload)
     return payload
+
+
+def make_body_images_inline(body: str) -> tuple[str, list]:
+    """Look for images inside the body and make them inline.
+
+    Before sending a message in HTML format, it is necessary to find
+    all img tags contained in the body in order to rewrite them. For
+    example, icons provided by CKeditor are stored on the server
+    filesystem and not accessible from the outside. We must embark
+    them as parts of the MIME message if we want recipients to
+    display them correctly.
+
+    :param body: the HTML body to parse
+    """
+    html = lxml.html.fromstring(body)
+    parts = []
+    for tag in html.iter("img"):
+        src = tag.get("src")
+        if src is None:
+            continue
+        o = urlparse(src)
+        path = unquote(os.path.join(settings.BASE_DIR, o.path[1:]))
+        if not os.path.exists(path):
+            continue
+        fname = os.path.basename(path)
+        cid = f"{os.path.splitext(fname)[0]}@modoboa"
+        tag.set("src", f"cid:{cid}")
+        with open(path, "rb") as fp:
+            part = MIMEImage(fp.read())
+        part["Content-ID"] = f"<{cid}>"
+        part.replace_header("Content-Type", f'{part["Content-Type"]}; name="{fname}"')
+        part["Content-Disposition"] = "inline"
+        parts.append(part)
+    return lxml.html.tostring(html, encoding="unicode"), parts
+
+
+def html_msg(body: str) -> EmailMultiAlternatives:
+    """Create a multipart message.
+
+    We attach two alternatives:
+    * text/html
+    * text/plain
+    """
+    if body:
+        tbody = html2plaintext(body)
+        body, images = make_body_images_inline(body)
+    else:
+        tbody = ""
+        images = []
+    msg = EmailMultiAlternatives()
+    msg.body = tbody
+    msg.attach_alternative(body, "text/html")
+    for img in images:
+        msg.attach(img)
+    return msg
+
+
+def plain_msg(body: str) -> EmailMessage:
+    """Create a simple text message."""
+    msg = EmailMessage()
+    msg.body = body
+    return msg
+
+
+def format_sender_address(user: core_models.User, address: str) -> str:
+    """Format address before message is sent."""
+    if user.first_name != "" or user.last_name != "":
+        return f'"{Header(user.fullname, "utf8")}" <{address}>'
+    return address
+
+
+def create_message(
+    user: core_models.User, attributes: dict, attachments: list
+) -> EmailMessage:
+    """Create an EmailMessage instance ready to be sent."""
+    extra_headers = {"User-Agent": "Modoboa {}".format(version("modoboa"))}
+    headers = {}
+    origmsgid = attributes.get("in_reply_to")
+    if origmsgid:
+        headers.update({"References": origmsgid, "In-Reply-To": origmsgid})
+    mode = user.parameters.get_value("editor")
+    sender = format_sender_address(user, attributes["sender"])
+    if mode == "html":
+        msg = html_msg(attributes.get("body", ""))
+    else:
+        msg = plain_msg(attributes.get("body", ""))
+    msg.from_email = sender
+    msg.to = attributes["to"]
+    msg.headers = headers
+    msg.extra_headers = extra_headers
+    for hdr in ["subject", "cc", "bcc"]:
+        if hdr in attributes:
+            setattr(msg, hdr, attributes[hdr])
+
+    for attachment in attachments:
+        msg.attach(create_mail_attachment(attachment))
+    return msg

modoboa/webmail/migrations/0001_initial.py

@@ -0,0 +1,90 @@
+# Generated by Django 5.2.10 on 2026-02-02 13:29
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="ScheduledMessage",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("sender", models.CharField(max_length=255)),
+                ("subject", models.CharField(max_length=255)),
+                ("body", models.TextField()),
+                ("to", models.TextField()),
+                ("cc", models.TextField(blank=True, null=True)),
+                ("bcc", models.TextField(blank=True, null=True)),
+                (
+                    "in_reply_to",
+                    models.CharField(blank=True, max_length=200, null=True),
+                ),
+                ("scheduled_datetime", models.DateTimeField()),
+                ("imap_uid", models.IntegerField(blank=True, null=True)),
+                (
+                    "status",
+                    models.CharField(
+                        choices=[
+                            ("scheduled", "scheduled"),
+                            ("sending", "sending"),
+                            ("send_error", "send_error"),
+                            ("move_error", "move_error"),
+                        ],
+                        db_index=True,
+                        default="scheduled",
+                        max_length=15,
+                    ),
+                ),
+                ("error", models.CharField(blank=True, max_length=255, null=True)),
+                (
+                    "account",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="MessageAttachment",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("file", models.FileField(upload_to="")),
+                ("content_type", models.CharField(max_length=150)),
+                ("filename", models.CharField(max_length=255)),
+                (
+                    "message",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="attachments",
+                        to="webmail.scheduledmessage",
+                    ),
+                ),
+            ],
+        ),
+    ]

modoboa/webmail/mocks.py

@@ -1,5 +1,6 @@
 """Mock objects."""
 
+from modoboa.webmail import constants
 from modoboa.webmail.tests import data as tests_data
 
 
@@ -24,7 +25,7 @@ class IMAP4Mock:
         return "OK", None
 
     def append(self, *args, **kwargs):
-        pass
+        return "OK", [b"[APPENDUID 1234 11] ..."]  # noqa
 
     def create(self, name):
         return "OK", None
@@ -43,7 +44,10 @@ class IMAP4Mock:
             return "OK", [b"19"]
         elif command == "FETCH":
             uid = int(args[0])
-            data = tests_data.BODYSTRUCTURE_SAMPLE_WITH_FLAGS
+            if constants.CUSTOM_HEADER_SCHEDULED_ID.upper() in args[1]:
+                data = tests_data.BODYSTRUCTURE_SAMPLE_SCHEDULED
+            else:
+                data = tests_data.BODYSTRUCTURE_SAMPLE_WITH_FLAGS
             if uid == 46931:
                 if args[1] == "(BODYSTRUCTURE)":
                     data = tests_data.BODYSTRUCTURE_ONLY_4
@@ -62,7 +66,12 @@ class IMAP4Mock:
                 if args[1] == "(BODYSTRUCTURE)":
                     data = tests_data.BODYSTRUCTURE_EMPTY_MAIL
                 elif "HEADER.FIELDS" in args[1]:
-                    data = tests_data.BODYSTRUCTURE_EMPTY_MAIL_WITH_HEADERS
+                    if constants.CUSTOM_HEADER_SCHEDULED_DATETIME.upper() in args[1]:
+                        data = (
+                            tests_data.BODYSTRUCTURE_EMPTY_MAIL_WITH_HEADERS_SCHEDULED
+                        )
+                    else:
+                        data = tests_data.BODYSTRUCTURE_EMPTY_MAIL_WITH_HEADERS
                 else:
                     data = tests_data.EMPTY_BODY
             elif uid == 3444:

modoboa/webmail/models.py

@@ -0,0 +1,102 @@
+"""
+Webmail related models.
+"""
+
+from django.core.mail import EmailMessage
+from django.db import models
+
+from modoboa.lib.sysutils import doveadm_cmd
+from modoboa.webmail import constants
+from modoboa.webmail.lib.utils import create_message
+
+
+class ScheduledMessage(models.Model):
+    account = models.ForeignKey("core.User", on_delete=models.CASCADE)
+    sender = models.CharField(max_length=255)
+    subject = models.CharField(max_length=255)
+    body = models.TextField()
+    to = models.TextField()
+    cc = models.TextField(blank=True, null=True)
+    bcc = models.TextField(blank=True, null=True)
+    in_reply_to = models.CharField(max_length=200, blank=True, null=True)
+    scheduled_datetime = models.DateTimeField()
+    imap_uid = models.IntegerField(blank=True, null=True)
+    status = models.CharField(
+        choices=constants.EMAIL_SCHEDULING_STATES,
+        default=constants.SchedulingState.SCHEDULED.value,
+        max_length=15,
+        db_index=True,
+    )
+    error = models.CharField(max_length=255, null=True, blank=True)
+
+    def __str__(self):
+        return f"{self.subject} - {self.sender.username} - {self.scheduled_datetime}"
+
+    def to_dict(self) -> dict:
+        result = {
+            "in_reply_to": self.in_reply_to,
+            "sender": self.sender,
+            "to": self.to.split(","),
+        }
+        if self.subject:
+            result["subject"] = self.subject
+        if self.body:
+            result["body"] = self.body
+        for hdr in ["cc", "bcc"]:
+            if getattr(self, hdr):
+                result[hdr] = getattr(self, hdr).split(",")
+        return result
+
+    def delete_imap_copy(self) -> bool:
+        """Move IMAP message to Sent folder using doveadm."""
+        # TODO: use doveadm HTTP API when dovecot is not local
+        sent_folder = self.account.parameters.get_value("sent_folder")
+        code, output = doveadm_cmd(
+            f"move -u {self.account.email} {sent_folder} "
+            f"mailbox {constants.MAILBOX_NAME_SCHEDULED} "
+            f"header {constants.CUSTOM_HEADER_SCHEDULED_ID} {self.id}"
+        )
+        if code:
+            self.status = constants.SchedulingState.MOVE_ERROR.value
+            self.error = output
+            self.save()
+            return False
+
+        # Try to delete mailbox when empty
+        doveadm_cmd(
+            f"mailbox delete -u {self.account.email} -s -e "
+            f"{constants.MAILBOX_NAME_SCHEDULED}"
+        )
+
+        return True
+
+    def to_email_message(self) -> EmailMessage:
+        """Convert this scheduled message to an EmailMessage instance."""
+        attachments = [attachment.to_dict() for attachment in self.attachments.all()]
+        result = create_message(self.account, self.to_dict(), attachments)
+        result.extra_headers.update(
+            {
+                constants.CUSTOM_HEADER_SCHEDULED_ID: self.id,
+                constants.CUSTOM_HEADER_SCHEDULED_DATETIME: self.scheduled_datetime.isoformat(),
+            }
+        )
+        return result
+
+
+class MessageAttachment(models.Model):
+    message = models.ForeignKey(
+        ScheduledMessage, on_delete=models.CASCADE, related_name="attachments"
+    )
+    file = models.FileField()
+    content_type = models.CharField(max_length=150)
+    filename = models.CharField(max_length=255)
+
+    def __str__(self):
+        return f"Attachment for {self.message.subject}"
+
+    def to_dict(self) -> dict:
+        return {
+            "content-type": self.content_type,
+            "tmpname": self.file.name,
+            "fname": self.filename,
+        }