modoboa 2.4.11__py3-none-any.whl → 2.5.0__py3-none-any.whl

modoboa/admin/api/v2/serializers.py

@@ -398,6 +398,20 @@ class AccountMeSerializer(v1_serializers.AccountSerializer):
         return [f"{p.content_type.app_label}.{p.codename}" for p in permissions]
 
 
+class AccountMeUpdateSerializer(serializers.ModelSerializer):
+    """Update serializer for connected user."""
+
+    class Meta:
+        model = core_models.User
+        fields = (
+            "first_name",
+            "last_name",
+            "language",
+            "phone_number",
+            "secondary_email",
+        )
+
+
 class AccountSerializer(v1_serializers.AccountSerializer):
     """Add support for user resources."""
 

modoboa/amavis/__init__.py

@@ -0,0 +1,3 @@
+"""The amavis frontend of Modoboa."""
+
+default_app_config = "modoboa.amavis.apps.AmavisConfig"

modoboa/amavis/app_settings.py

@@ -0,0 +1,276 @@
+import collections
+
+from django.utils.translation import gettext_lazy
+
+
+GLOBAL_PARAMETERS_STRUCT = collections.OrderedDict(
+    [
+        (
+            "amavis",
+            {
+                "label": gettext_lazy("Amavis settings"),
+                "params": collections.OrderedDict(
+                    [
+                        (
+                            "localpart_is_case_sensitive",
+                            {
+                                "label": gettext_lazy("Localpart is case sensitive"),
+                                "help_text": gettext_lazy(
+                                    "Value should match amavisd.conf variable "
+                                    "$localpart_is_case_sensitive"
+                                ),
+                            },
+                        ),
+                        (
+                            "recipient_delimiter",
+                            {
+                                "label": gettext_lazy("Recipient delimiter"),
+                                "help_text": gettext_lazy(
+                                    "Value should match amavisd.conf variable "
+                                    "$recipient_delimiter"
+                                ),
+                            },
+                        ),
+                    ]
+                ),
+            },
+        ),
+        (
+            "quarantine",
+            {
+                "label": gettext_lazy("Quarantine settings"),
+                "params": collections.OrderedDict(
+                    [
+                        (
+                            "max_messages_age",
+                            {
+                                "label": gettext_lazy("Maximum message age"),
+                                "help_text": gettext_lazy(
+                                    "Quarantine messages maximum age (in days) before deletion"
+                                ),
+                            },
+                        )
+                    ]
+                ),
+            },
+        ),
+        (
+            "releasing",
+            {
+                "label": gettext_lazy("Message releasing"),
+                "params": collections.OrderedDict(
+                    [
+                        (
+                            "released_msgs_cleanup",
+                            {
+                                "label": gettext_lazy("Remove released messages"),
+                                "help_text": gettext_lazy(
+                                    "Remove messages marked as released while cleaning up "
+                                    "the database"
+                                ),
+                            },
+                        ),
+                        (
+                            "am_pdp_mode",
+                            {
+                                "label": gettext_lazy("Amavis connection mode"),
+                                "help_text": gettext_lazy(
+                                    "Mode used to access the PDP server"
+                                ),
+                            },
+                        ),
+                        (
+                            "am_pdp_host",
+                            {
+                                "label": gettext_lazy("PDP server address"),
+                                "help_text": gettext_lazy(
+                                    "PDP server address (if inet mode)"
+                                ),
+                                "display": "am_pdp_mode=inet",
+                            },
+                        ),
+                        (
+                            "am_pdp_port",
+                            {
+                                "label": gettext_lazy("PDP server port"),
+                                "help_text": gettext_lazy(
+                                    "PDP server port (if inet mode)"
+                                ),
+                                "display": "am_pdp_mode=inet",
+                            },
+                        ),
+                        (
+                            "am_pdp_socket",
+                            {
+                                "label": gettext_lazy("PDP server socket"),
+                                "help_text": gettext_lazy(
+                                    "Path to the PDP server socket (if unix mode)"
+                                ),
+                                "display": "am_pdp_mode=unix",
+                            },
+                        ),
+                        (
+                            "user_can_release",
+                            {
+                                "label": gettext_lazy("Allow direct release"),
+                                "help_text": gettext_lazy(
+                                    "Allow users to directly release their messages"
+                                ),
+                            },
+                        ),
+                        (
+                            "self_service",
+                            {
+                                "label": gettext_lazy("Enable self-service mode"),
+                                "help_text": gettext_lazy(
+                                    "Activate the 'self-service' mode"
+                                ),
+                            },
+                        ),
+                        (
+                            "notifications_sender",
+                            {
+                                "label": gettext_lazy("Notifications sender"),
+                                "help_text": gettext_lazy(
+                                    "The e-mail address used to send notitications"
+                                ),
+                            },
+                        ),
+                    ]
+                ),
+            },
+        ),
+        (
+            "learning",
+            {
+                "label": gettext_lazy("Manual learning"),
+                "params": collections.OrderedDict(
+                    [
+                        (
+                            "manual_learning",
+                            {
+                                "label": gettext_lazy("Enable manual learning"),
+                                "help_text": gettext_lazy(
+                                    "Allow super administrators to manually train Spamassassin"
+                                ),
+                            },
+                        ),
+                        (
+                            "sa_is_local",
+                            {
+                                "label": gettext_lazy("Is Spamassassin local?"),
+                                "help_text": gettext_lazy(
+                                    "Tell if Spamassassin is running on the same server than modoboa"
+                                ),
+                                "display": "manual_learning=true",
+                            },
+                        ),
+                        (
+                            "default_user",
+                            {
+                                "label": gettext_lazy("Default user"),
+                                "help_text": gettext_lazy(
+                                    "Name of the user owning the default bayesian database"
+                                ),
+                                "display": "manual_learning=true",
+                            },
+                        ),
+                        (
+                            "spamd_address",
+                            {
+                                "label": gettext_lazy("Spamd address"),
+                                "help_text": gettext_lazy(
+                                    "The IP address where spamd can be reached"
+                                ),
+                                "display": "sa_is_local=false",
+                            },
+                        ),
+                        (
+                            "spamd_port",
+                            {
+                                "label": gettext_lazy("Spamd port"),
+                                "help_text": gettext_lazy(
+                                    "The TCP port spamd is listening on"
+                                ),
+                                "display": "sa_is_local=false",
+                            },
+                        ),
+                        (
+                            "domain_level_learning",
+                            {
+                                "label": gettext_lazy(
+                                    "Enable per-domain manual learning"
+                                ),
+                                "help_text": gettext_lazy(
+                                    "Allow domain administrators to train Spamassassin "
+                                    "(within dedicated per-domain databases)"
+                                ),
+                                "display": "manual_learning=true",
+                            },
+                        ),
+                        (
+                            "user_level_learning",
+                            {
+                                "label": gettext_lazy(
+                                    "Enable per-user manual learning"
+                                ),
+                                "help_text": gettext_lazy(
+                                    "Allow simple users to personally train Spamassassin "
+                                    "(within a dedicated database)"
+                                ),
+                                "display": "manual_learning=true",
+                            },
+                        ),
+                    ]
+                ),
+            },
+        ),
+    ]
+)
+
+USER_PREFERENCES_STRUCT = collections.OrderedDict(
+    [
+        (
+            "display",
+            {
+                "label": gettext_lazy("Display"),
+                "params": collections.OrderedDict(
+                    [
+                        (
+                            "messages_per_page",
+                            {
+                                "label": gettext_lazy(
+                                    "Number of displayed emails per page"
+                                ),
+                                "help_text": gettext_lazy(
+                                    "Set the maximum number of messages displayed in a page"
+                                ),
+                            },
+                        )
+                    ]
+                ),
+            },
+        )
+    ]
+)
+
+
+def load_settings():
+    """Load amavis settings."""
+    from modoboa.parameters import tools as param_tools
+    from modoboa.amavis import serializers
+
+    param_tools.registry.add(
+        "global",
+        "amavis",
+        gettext_lazy("Amavis"),
+        GLOBAL_PARAMETERS_STRUCT,
+        serializers.GlobalParametersSerializer,
+    )
+    param_tools.registry.add(
+        "user",
+        "amavis",
+        gettext_lazy("Amavis"),
+        USER_PREFERENCES_STRUCT,
+        serializers.UserPreferencesSerializer,
+    )

modoboa/amavis/apps.py

@@ -0,0 +1,18 @@
+"""AppConfig for amavis."""
+
+from django.apps import AppConfig
+
+
+class AmavisConfig(AppConfig):
+    """App configuration."""
+
+    name = "modoboa.amavis"
+    verbose_name = "Modoboa amavis frontend"
+
+    def ready(self):
+        # Import these to force registration of checks and signals
+        from . import checks  # NOQA:F401
+        from . import handlers  # NOQA:F401
+        from modoboa.amavis.app_settings import load_settings
+
+        load_settings()

modoboa/amavis/checks/__init__.py

@@ -0,0 +1,2 @@
+# Import these to force registration of checks
+from . import settings_checks  # NOQA:F401

modoboa/amavis/checks/settings_checks.py

@@ -0,0 +1,59 @@
+from django.conf import settings
+from django.core.checks import Warning, register
+from django.db import connections
+from django.utils.translation import gettext as _
+
+W001 = Warning(
+    _(
+        "AMAVIS_DEFAULT_DATABASE_ENCODING does not match the character "
+        "encoding used by the Amavis database."
+    ),
+    hint=_(
+        "Check your database character encoding and set/update "
+        "AMAVIS_DEFAULT_DATABASE_ENCODING."
+    ),
+    id="modoboa-amavis.W001",
+)
+
+W002 = Warning(
+    _("Modoboa Amavis has not been tested using the selected database engine."),
+    hint=_("Try using PostgreSQL, MySQL or MariaDB."),
+    id="modoboa-amavis.W002",
+)
+
+
+@register(deploy=True)
+def check_amavis_database_encoding(app_configs, **kwargs):
+    """Ensure AMAVIS_DEFAULT_DATABASE_ENCODING is set to the correct value."""
+    errors = []
+    db_engine = settings.DATABASES["amavis"]["ENGINE"]
+    sql_query = None
+    if "postgresql" in db_engine:
+        sql_query = (
+            "SELECT pg_encoding_to_char(encoding) "
+            "FROM pg_database "
+            "WHERE datname = %s;"
+        )
+    elif "mysql" in db_engine:
+        sql_query = (
+            "SELECT DEFAULT_CHARACTER_SET_NAME "
+            "FROM INFORMATION_SCHEMA.SCHEMATA "
+            "WHERE SCHEMA_NAME = %s;"
+        )
+    elif "sqlite" in db_engine:
+        sql_query = "PRAGMA encoding;"
+    else:
+        errors.append(W002)
+        return errors
+
+    with connections["amavis"].cursor() as cursor:
+        if "sqlite" in db_engine:
+            cursor.execute(sql_query)
+        else:
+            cursor.execute(sql_query, [settings.DATABASES["amavis"]["NAME"]])
+        encoding = cursor.fetchone()[0]
+
+    if encoding.lower() != settings.AMAVIS_DEFAULT_DATABASE_ENCODING.lower():
+        errors.append(W001)
+
+    return errors

modoboa/amavis/dbrouter.py

@@ -0,0 +1,35 @@
+class AmavisRouter:
+    """A router to control all database operations on models in
+    the amavis application"""
+
+    def db_for_read(self, model, **hints):
+        """Point all operations on amavis models to 'amavis'."""
+        if model._meta.app_label == "amavis":
+            return "amavis"
+        return None
+
+    def db_for_write(self, model, **hints):
+        """Point all operations on amavis models to 'amavis'."""
+        if model._meta.app_label == "amavis":
+            return "amavis"
+        return None
+
+    def allow_relation(self, obj1, obj2, **hints):
+        """Allow any relation if a model in amavis is involved."""
+        if obj1._meta.app_label == "amavis" or obj2._meta.app_label == "amavis":
+            return True
+        return None
+
+    def allow_migrate(self, db, app_label, model=None, **hints):
+        """
+        Make sure the auth app only appears in the 'amavis'
+        database.
+        """
+        if app_label == "amavis":
+            # modoboa_amavis migrations should be created in the amavis
+            # database.
+            return db == "amavis"
+        elif db == "amavis":
+            # Don't create non modoboa_amavis migrations in the amavis database.
+            return False
+        return None

modoboa/amavis/factories.py

@@ -0,0 +1,164 @@
+"""Amavis factories."""
+
+import datetime
+import time
+
+import factory
+
+from . import models
+from .utils import smart_bytes
+
+SPAM_BODY = """X-Envelope-To: <{rcpt}>
+X-Envelope-To-Blocked: <{rcpt}>
+X-Quarantine-ID: <nq6ekd4wtXZg>
+X-Spam-Flag: YES
+X-Spam-Score: 1000.985
+X-Spam-Level: ****************************************************************
+X-Spam-Status: Yes, score=1000.985 tag=2 tag2=6.31 kill=6.31
+    tests=[ALL_TRUSTED=-1, GTUBE=1000, PYZOR_CHECK=1.985]
+    autolearn=no autolearn_force=no
+Received: from demo.modoboa.org ([127.0.0.1])
+    by localhost (demo.modoboa.org [127.0.0.1]) (amavisd-new, port 10024)
+    with ESMTP id nq6ekd4wtXZg for <user@demo.local>;
+    Thu,  9 Nov 2017 15:59:52 +0100 (CET)
+Received: from demo.modoboa.org (localhost [127.0.0.1])
+    by demo.modoboa.org (Postfix) with ESMTP
+    for <user@demo.local>; Thu,  9 Nov 2017 15:59:52 +0100 (CET)
+Content-Type: text/plain; charset="utf-8"
+MIME-Version: 1.0
+Content-Transfer-Encoding: quoted-printable
+Subject: Sample message
+From: {sender}
+To: {rcpt}
+Message-ID: <151023959268.5550.5713670714483771838@demo.modoboa.org>
+Date: Thu, 09 Nov 2017 15:59:52 +0100
+
+This is the GTUBE, the
+        Generic
+        Test for
+        Unsolicited
+        Bulk
+        Email
+
+If your spam filter supports it, the GTUBE provides a test by which you
+can verify that the filter is installed correctly and is detecting incoming
+spam. You can send yourself a test mail containing the following string of
+characters (in upper case and with no white spaces and line breaks):
+
+XJS*C4JDBQADN1.NSBN3*2IDNEN*GTUBE-STANDARD-ANTI-UBE-TEST-EMAIL*C.34X
+
+You should send this test mail from an account outside of your network.
+"""
+
+VIRUS_BODY = r"""Subject: Virus Test Message (EICAR)
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="huq684BweRXVnRxX"
+Content-Disposition: inline
+Date: Sun, 06 Nov 2011 10:08:18 -0800
+
+
+--huq684BweRXVnRxX
+Content-Type: text/plain; charset=us-ascii
+Content-Disposition: inline
+
+
+This is a virus test message. It contains an attached file 'eicar.com',
+which contains the EICAR virus <http://eicar.org/86-0-Intended-use.html>
+test pattern.
+
+
+--huq684BweRXVnRxX
+Content-Type: application/x-msdos-program
+Content-Disposition: attachment; filename="eicar.com"
+Content-Transfer-Encoding: quoted-printable
+
+X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*=0A
+--huq684BweRXVnRxX--
+"""
+
+
+class MaddrFactory(factory.django.DjangoModelFactory):
+    """Factory for Maddr."""
+
+    class Meta:
+        model = models.Maddr
+        django_get_or_create = ("email",)
+
+    id = factory.Sequence(lambda n: n)  # NOQA:A003
+    email = factory.Sequence(lambda n: f"user_{n}@domain.test")
+    domain = "test.domain"
+
+
+class MsgsFactory(factory.django.DjangoModelFactory):
+    """Factory for Mailaddr."""
+
+    class Meta:
+        model = models.Msgs
+
+    mail_id = factory.Sequence(lambda n: f"mailid{n}".encode("ascii"))
+    secret_id = factory.Sequence(lambda n: smart_bytes(f"id{n}"))
+    sid = factory.SubFactory(MaddrFactory)
+    client_addr = "127.0.0.1"
+    originating = "Y"
+    dsn_sent = "N"
+    subject = factory.Sequence(lambda n: f"Test message {n}")
+    time_num = factory.LazyAttribute(lambda o: int(time.time()))
+    time_iso = factory.LazyAttribute(
+        lambda o: datetime.datetime.fromtimestamp(o.time_num).isoformat()
+    )
+    size = 100
+
+
+class MsgrcptFactory(factory.django.DjangoModelFactory):
+    """Factory for Msgrcpt."""
+
+    class Meta:
+        model = models.Msgrcpt
+
+    rseqnum = 1
+    is_local = "Y"
+    bl = "N"
+    wl = "N"
+    mail = factory.SubFactory(MsgsFactory)
+    rid = factory.SubFactory(MaddrFactory)
+
+
+class QuarantineFactory(factory.django.DjangoModelFactory):
+    """Factory for Quarantine."""
+
+    class Meta:
+        model = models.Quarantine
+
+    chunk_ind = 1
+    mail = factory.SubFactory(MsgsFactory)
+
+
+def create_quarantined_msg(rcpt, sender, rs, body, **kwargs):
+    """Create a quarantined msg."""
+    msgrcpt = MsgrcptFactory(
+        rs=rs,
+        rid__email=rcpt,
+        rid__domain="com.test",  # FIXME
+        mail__sid__email=smart_bytes(sender),
+        mail__sid__domain="",  # FIXME
+        **kwargs,
+    )
+    QuarantineFactory(
+        mail=msgrcpt.mail,
+        mail_text=smart_bytes(SPAM_BODY.format(rcpt=rcpt, sender=sender)),
+    )
+    return msgrcpt
+
+
+def create_spam(rcpt, sender="spam@evil.corp", rs=" "):
+    """Create a spam."""
+    body = SPAM_BODY.format(rcpt=rcpt, sender=sender)
+    body += "fóó bár"
+    return create_quarantined_msg(
+        rcpt, sender, rs, body, bspam_level=999.0, content="S"
+    )
+
+
+def create_virus(rcpt, sender="virus@evil.corp", rs=" "):
+    """Create a virus."""
+    return create_quarantined_msg(rcpt, sender, rs, VIRUS_BODY, content="V")