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

modoboa/maillog/jobs.py

@@ -0,0 +1,11 @@
+"""Async jobs definition."""
+
+from django.core.management import call_command
+
+
+def logparser():
+    call_command("logparser")
+
+
+def update_statistics():
+    call_command("update_statistics")

modoboa/maillog/tests/test_views.py

@@ -11,6 +11,7 @@ from django.test import override_settings
 
 from modoboa.admin import factories as admin_factories
 from modoboa.lib.tests import SimpleModoTestCase
+from modoboa.maillog import jobs
 
 
 class RunCommandsMixin:
@@ -36,14 +37,14 @@ class RunCommandsMixin:
         with open(path, "w") as fp:
             fp.write(content)
         self.set_global_parameter("logfile", path)
-        call_command("logparser")
+        jobs.logparser()
 
     def run_update_statistics(self, rebuild=False):
         """Run update_statistics command."""
-        args = []
         if rebuild:
-            args.append("--rebuild")
-        call_command("update_statistics", *args)
+            call_command("update_statistics", ["--rebuild"])
+        else:
+            jobs.update_statistics()
 
 
 @override_settings(RRDTOOL_TEST_MODE=True)

modoboa/parameters/api/v2/tests.py

@@ -18,7 +18,7 @@ class GlobalParametersAPITestCase(ModoAPITestCase):
         resp = self.client.get(url)
         self.assertEqual(resp.status_code, 200)
         # core, admin, limits, pdf credentials, ...
-        self.assertEqual(len(resp.json()), 13)
+        self.assertEqual(len(resp.json()), 12)
 
     def test_get_structure(self):
         url = reverse("v2:parameter-global-structure")

modoboa/policyd/management/commands/policy_daemon.py

@@ -31,7 +31,11 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         """Entry point."""
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
         coro = asyncio.start_server(
             core.new_connection, options["host"], options["port"]
         )

modoboa/policyd/tests.py

@@ -3,11 +3,11 @@
 import asyncio
 from aiosmtplib import send
 from unittest.mock import AsyncMock
+import multiprocessing
 from multiprocessing import Process
 import socket
 import time
 
-
 from django import db
 from django.core.management import call_command
 from django.test import TransactionTestCase
@@ -21,6 +21,8 @@ from modoboa.policyd import core as policyd_core
 
 from . import constants
 
+multiprocessing.set_start_method("fork")
+
 
 def start_policy_daemon():
     call_command("policy_daemon")
@@ -56,7 +58,7 @@ class PolicyDaemonTestCase(RedisTestCaseMixin, ParametersMixin, TransactionTestC
         self.process.daemon = True
         self.process.start()
         # Wait a bit for the daemon to start
-        self.process.join(0.1)
+        self.process.join(1.0)
 
     def set_domain_limit(self, name, value):
         """Set daily limit for domain."""

modoboa/rspamd/tests.py

@@ -2,12 +2,18 @@ import os
 import shutil
 
 from django.core import management
+from django.test import modify_settings
 from django.urls import reverse
 
 from modoboa.admin import factories as admin_factories, models as admin_models
 from modoboa.lib.tests import ModoAPITestCase
 
 
+@modify_settings(
+    INSTALLED_APPS={
+        "append": "modoboa.rspamd",
+    }
+)
 class ManagementCommandTestCase(ModoAPITestCase):
 
     @classmethod
@@ -76,3 +82,17 @@ class ParametersAPITestCase(ModoAPITestCase):
         }
         response = self.client.put(url, data, format="json")
         self.assertEqual(response.status_code, 200)
+
+
+@modify_settings(
+    MODOBOA_APPS={
+        "append": "modoboa.rspamd",
+    }
+)
+class CapabilitiesAPITestCase(ModoAPITestCase):
+
+    def test_get(self):
+        url = reverse("v2:capabilities")
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("rspamd", response.json()["capabilities"])

modoboa/templates/registration/twofactor_code_verify.html

@@ -25,7 +25,7 @@
         <input type="hidden" id="id_next" name="next" value="{{ nextlocation }}">
         <div class="input-group{% if form.tfa_code.errors %} error{% endif %}">
           <label>{% translate "One-time password" %}</label>
-          <input id="id_tfa_code" name="tfa_code" required>
+          <input id="id_tfa_code" name="tfa_code" required autofocus>
           <span class="error-message">
             {% for error in form.tfa_code.errors %}
               {{ error }}

modoboa/webmail/app_settings.py

@@ -107,6 +107,43 @@ GLOBAL_PARAMETERS_STRUCT = collections.OrderedDict(
                 ),
             },
         ),
+        (
+            "scheduling",
+            {
+                "label": gettext_lazy("Scheduling settings"),
+                "params": collections.OrderedDict(
+                    [
+                        (
+                            "scheduling_smtp_server",
+                            {
+                                "label": gettext_lazy("Server address"),
+                                "help_text": gettext_lazy(
+                                    "Address of your SMTP server"
+                                ),
+                            },
+                        ),
+                        (
+                            "scheduling_smtp_secured_mode",
+                            {
+                                "label": gettext_lazy("Secured connection mode"),
+                                "help_text": gettext_lazy(
+                                    "Use a secured connection to access SMTP server"
+                                ),
+                            },
+                        ),
+                        (
+                            "scheduling_smtp_port",
+                            {
+                                "label": gettext_lazy("Server port"),
+                                "help_text": gettext_lazy(
+                                    "Listening port of your SMTP server"
+                                ),
+                            },
+                        ),
+                    ]
+                ),
+            },
+        ),
     ]
 )
 

modoboa/webmail/constants.py

@@ -5,7 +5,27 @@ from enum import Enum
 from django.utils.translation import gettext_lazy as _
 
 
-MAILBOX_TYPES = ["inbox", "draft", "sent", "junk", "trash", "normal"]
+MAILBOX_TYPES = ["inbox", "draft", "sent", "scheduled", "junk", "trash", "normal"]
+
+MAILBOX_NAME_SCHEDULED = "Scheduled"
+
+CUSTOM_HEADER_SCHEDULED_ID = "X-Scheduled-ID"
+CUSTOM_HEADER_SCHEDULED_DATETIME = "X-Scheduled-Datetime"
+
+
+class SchedulingState(Enum):
+    SCHEDULED = "scheduled"
+    SENDING = "sending"
+    SEND_ERROR = "send_error"
+    MOVE_ERROR = "move_error"
+
+
+EMAIL_SCHEDULING_STATES = (
+    (SchedulingState.SCHEDULED.value, "scheduled"),
+    (SchedulingState.SENDING.value, "sending"),
+    (SchedulingState.SEND_ERROR.value, "send_error"),
+    (SchedulingState.MOVE_ERROR.value, "move_error"),
+)
 
 
 class SmtpConnectionMode(Enum):

modoboa/webmail/factories.py

@@ -0,0 +1,19 @@
+"""Webmail factories."""
+
+import factory
+
+from modoboa.admin import factories as admin_factories
+
+from modoboa.webmail import models
+
+
+class ScheduledMessageFactory(factory.django.DjangoModelFactory):
+    """Scheduled message factory."""
+
+    class Meta:
+        model = models.ScheduledMessage
+
+    account = factory.SubFactory(admin_factories.UserFactory)
+    sender = "sender@test.com"
+    subject = "Scheduled Message"
+    to = "recipient@domain.test"

modoboa/webmail/jobs.py

@@ -0,0 +1,27 @@
+"""Async (RQ) jobs definition."""
+
+from django.utils import timezone
+
+import django_rq
+
+from modoboa.webmail import constants, models
+from modoboa.webmail.lib import sendmail
+
+
+def send_scheduled_message(message_id: int):
+    message = models.ScheduledMessage.objects.get(id=message_id)
+    if sendmail.send_scheduled_message(message):
+        message.delete()
+
+
+def send_scheduled_messages():
+    now = timezone.now().replace(second=0, microsecond=0)
+    messages = models.ScheduledMessage.objects.filter(
+        scheduled_datetime__lte=now,
+        status=constants.SchedulingState.SCHEDULED.value,
+    )
+    queue = django_rq.get_queue("modoboa")
+    for message in messages:
+        message.status = constants.SchedulingState.SENDING.value
+        message.save()
+        queue.enqueue(send_scheduled_message, message_id=message.id)

modoboa/webmail/lib/__init__.py

@@ -7,7 +7,6 @@ from .imapemail import ImapEmail, ReplyModifier, ForwardModifier
 from .imaputils import BodyStructure, IMAPconnector, get_imapconnector, separate_mailbox
 from .signature import EmailSignature
 from .utils import decode_payload
-from .sendmail import send_mail
 
 
 __all__ = [
@@ -22,6 +21,5 @@ __all__ = [
     "decode_payload",
     "get_imapconnector",
     "save_attachment",
-    "send_mail",
     "separate_mailbox",
 ]

modoboa/webmail/lib/imapemail.py

@@ -18,6 +18,7 @@ from django.utils.translation import gettext as _
 from modoboa.contacts import models as contacts_models
 from modoboa.lib import u2u_decode
 from modoboa.lib.email_utils import Email
+from modoboa.webmail import constants
 
 from . import imapheader
 from .attachments import get_storage_path
@@ -45,19 +46,24 @@ class ImapEmail(Email):
         self.imapc = self.imapc.__enter__()
         self.mbox, self.mailid = self.mailid.split(":")
         self.attachments: dict[str, str] = {}
+        self.To: list = []
 
     def __del__(self):
         self.imapc.__exit__()
 
     def fetch_headers(self, raw_addresses: bool = False) -> None:
         """Fetch message headers from server."""
+        requested_headers = self.headernames
+        if self.mbox == constants.MAILBOX_NAME_SCHEDULED:
+            requested_headers += [(constants.CUSTOM_HEADER_SCHEDULED_DATETIME, True)]
+        header_names = [header[0].upper() for header in requested_headers]
         msg = self.imapc.fetchmail(
-            self.mbox, self.mailid, readonly=False, what=" ".join(self.headers_as_list)
+            self.mbox, self.mailid, readonly=False, what=" ".join(header_names)
         )
-        headers = msg[f"BODY[HEADER.FIELDS ({self.headers_as_text})]"]
+        headers = msg[f"BODY[HEADER.FIELDS ({' '.join(header_names)})]"]
         self.fetch_body_structure(msg)
         msg = email.message_from_string(headers)
-        for hdr in self.headernames:
+        for hdr in requested_headers:
             label = hdr[0]
             hdrvalue = self.get_header(msg, label, raw=raw_addresses)
             if not hdrvalue:
@@ -110,14 +116,6 @@ class ImapEmail(Email):
             self.dformat if self.dformat in self.bs.contents else fallback_fmt
         )
 
-    @property
-    def headers_as_list(self):
-        return [hdr[0].upper() for hdr in self.headernames]
-
-    @property
-    def headers_as_text(self):
-        return " ".join(self.headers_as_list)
-
     @property
     def subject(self):
         """Just a shortcut to return a subject in any case."""

modoboa/webmail/lib/imapheader.py

@@ -27,19 +27,19 @@ __all__ = [
 # according to https://en.wikipedia.org/wiki/Date_format_by_country
 # and https://en.wikipedia.org/wiki/Date_and_time_representation_by_country
 DATETIME_FORMATS = {
-    "cs": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
-    "de": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
-    "en": {"SHORT": "l, P", "LONG": "N j, Y P"},
-    "es": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
-    "fr": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
-    "it": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
-    "ja_JP": {"SHORT": "l, P", "LONG": "N j, Y P"},
-    "nl": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
-    "pl_PL": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
-    "pt_PT": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
-    "pt_BR": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
-    "ru": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
-    "sv": {"SHORT": "l, H:i", "LONG": "d. N Y H:i"},
+    "cs": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
+    "de": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
+    "en": {"SHORT": "l, P", "LONG": "N j, Y P", "TIME": "H:i"},
+    "es": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
+    "fr": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
+    "it": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
+    "ja_JP": {"SHORT": "l, P", "LONG": "N j, Y P", "TIME": "H:i"},
+    "nl": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
+    "pl_PL": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
+    "pt_PT": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
+    "pt_BR": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
+    "ru": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
+    "sv": {"SHORT": "l, H:i", "LONG": "d. N Y H:i", "TIME": "H:i"},
 }
 
 
@@ -123,6 +123,18 @@ def parse_date(value, **kwargs):
     )
 
 
+def parse_scheduled_datetime(value: str, **kwargs) -> str:
+    result = datetime.datetime.fromisoformat(value)
+    current_language = get_request().user.language
+    if timezone.now().date().day != result.date().day:
+        fmt = "LONG"
+    else:
+        fmt = "TIME"
+    return date_format(
+        result, DATETIME_FORMATS.get(current_language, DATETIME_FORMATS.get("en"))[fmt]
+    )
+
+
 def parse_message_id(value, **kwargs):
     """Parse a Message-ID: header."""
     return value.strip("\n")

modoboa/webmail/lib/imaputils.py

@@ -13,6 +13,7 @@ from modoboa.lib import imap_utf7  # noqa
 from modoboa.lib import oauth2
 from modoboa.lib.exceptions import InternalError
 from modoboa.parameters import tools as param_tools
+from modoboa.webmail import constants
 
 from ..exceptions import ImapError, WebmailInternalError
 from .fetch_parser import FetchResponseParser
@@ -292,16 +293,21 @@ class IMAPconnector:
             return f"OR {old} {c}"
 
         if criterion == "both":
-            criterion = "from_addr, subject"
-        criterions = ""
-        for c in criterion.split(","):
-            if c == "from_addr":
-                key = "FROM"
-            elif c == "subject":
-                key = "SUBJECT"
-            else:
-                continue
-            criterions = or_criterion(criterions, f'({key} "{pattern}")')
+            criterion = "from_addr,subject"
+
+        if not pattern:
+            criterions = "ALL"
+        else:
+            criterions = ""
+            for c in criterion.split(","):
+                if c == "from_addr":
+                    key = "FROM"
+                elif c == "subject":
+                    key = "SUBJECT"
+                else:
+                    continue
+                criterions = or_criterion(criterions, f'({key} "{pattern}")')
+
         self.criterions = [bytearray(criterions, "utf8")]
 
     def messages_count(self, **kwargs) -> int:
@@ -485,6 +491,16 @@ class IMAPconnector:
                     "type": "sent",
                     "label": _("Sent"),
                 },
+            ]
+            if user.scheduledmessage_set.exists():
+                md_mailboxes += [
+                    {
+                        "name": constants.MAILBOX_NAME_SCHEDULED,
+                        "type": "scheduled",
+                        "label": _("Scheduled"),
+                    },
+                ]
+            md_mailboxes += [
                 {
                     "name": user.parameters.get_value("trash_folder"),
                     "type": "trash",
@@ -576,10 +592,30 @@ class IMAPconnector:
         self._cmd("COPY", msgset, self._encode_mbox_name(newmailbox))
         self._cmd("STORE", msgset, "+FLAGS", r"(\Deleted \Seen)")
 
-    def push_mail(self, mbox: str, msg):
+    def push_mail(self, mbox: str, msg) -> int:
+        """
+        Append a new message to a mailbox.
+
+        Return the UID of the created message.
+        """
         now = imaplib.Time2Internaldate(time.time())
         msg = bytes(msg)
-        return self.m.append(self._encode_mbox_name(mbox), r"(\Seen)", now, msg)
+        typ, data = self.m.append(self._encode_mbox_name(mbox), r"(\Seen)", now, msg)
+        response = data[0].decode()
+        m = re.match(r"\[APPENDUID \d+ (\d+)\].+", response)
+        if m:
+            return int(m.group(1))
+        raise WebmailInternalError("Failed to retrieve message UID")
+
+    def delete_mail(self, mbox: str, uid: int) -> None:
+        """
+        Delete given message (set \Deleted flag) and expunge mailbox.
+
+        Do not use directly.
+        """
+        self.select_mailbox(mbox, False)
+        self._cmd("STORE", f"{uid}".encode(), "+FLAGS", r"(\Deleted)")
+        self._cmd("EXPUNGE")
 
     def empty(self, mbox: str):
         self.select_mailbox(mbox, False)
@@ -605,7 +641,7 @@ class IMAPconnector:
             name = f"{parent}{self.hdelimiter}{name}"
         typ, data = self.m.create(self._encode_mbox_name(name))
         if typ == "NO":
-            raise WebmailInternalError(data[0])
+            raise WebmailInternalError(str(data[0]))
         return True
 
     def rename_folder(self, oldname: str, newname: str) -> bool:
@@ -694,6 +730,8 @@ class IMAPconnector:
             submessages = [start]
             mrange = str(start)
         headers = "DATE FROM TO CC SUBJECT"
+        if mbox == constants.MAILBOX_NAME_SCHEDULED:
+            headers += " X-SCHEDULED-ID X-SCHEDULED-DATETIME"
         query = (
             f"(FLAGS BODYSTRUCTURE RFC822.SIZE BODY.PEEK[HEADER.FIELDS ({headers})])"
         )