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

modoboa/admin/api/v1/serializers.py

@@ -208,6 +208,7 @@ class MailboxSerializer(serializers.ModelSerializer):
             "message_limit",
             "quota_usage",
             "is_send_only",
+            "sent_messages_in_percent",
         )
 
     def get_quota_usage(self, mb) -> int:

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."""
 
@@ -731,7 +745,7 @@ class CSVImportSerializer(serializers.Serializer):
 class CSVIdentityImportSerializer(CSVImportSerializer):
     """Custom serializer for identity import."""
 
-    crypt_password = serializers.BooleanField()
+    crypt_passwords = serializers.BooleanField()
 
 
 class AlarmSerializer(serializers.ModelSerializer):

modoboa/admin/api/v2/tests.py

@@ -331,6 +331,16 @@ class AccountViewSetTestCase(ModoAPITestCase):
         resp = self.client.patch(url, data, format="json")
         self.assertEqual(resp.status_code, 200)
 
+    def test_update_quota(self):
+        account = core_models.User.objects.get(username="user@test.com")
+        url = reverse("v2:account-detail", args=[account.pk])
+        data = {
+            "mailbox": {"quota": 1},
+        }
+        resp = self.client.patch(url, data, format="json")
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(account.mailbox.quota, data["mailbox"]["quota"])
+
     def test_user_updates_password(self):
         account = core_models.User.objects.get(username="user@test.com")
         self.authenticate_user(account)
@@ -583,7 +593,7 @@ dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
         )  # NOQA:E501
         self.client.post(
             reverse("v2:identities-import-from-csv"),
-            {"sourcefile": f, "crypt_password": True},
+            {"sourcefile": f, "crypt_passwords": True},
         )
         admin = core_models.User.objects.get(username="admin")
         u1 = core_models.User.objects.get(username="user1@test.com")

modoboa/admin/lib.py

@@ -138,7 +138,7 @@ def import_domainalias(user, row, formopts):
 def import_account(user, row, formopts):
     """Specific code for accounts import"""
     account = User()
-    account.from_csv(user, row, formopts["crypt_password"])
+    account.from_csv(user, row, formopts["crypt_passwords"])
 
 
 def _import_alias(user, row, **kwargs):

modoboa/admin/models/mailbox.py

@@ -295,19 +295,21 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
     def update_from_dict(self, user, values):
         """Update mailbox from a dictionary."""
         newaddress = None
-        if values["email"] != self.full_address:
-            newaddress = values["email"]
-        elif (
-            self.user.role == "SimpleUsers" and self.user.username != self.full_address
-        ):
-            newaddress = self.user.username
-        if newaddress is not None:
-            local_part, domname = split_mailbox(newaddress)
-            domain = Domain.objects.filter(name=domname).first()
-            if domain is None:
-                raise lib_exceptions.NotFound(_("Domain does not exist"))
-            if not user.can_access(domain):
-                raise lib_exceptions.PermDeniedException
+        if "email" in values:
+            if values["email"] != self.full_address:
+                newaddress = values["email"]
+            elif (
+                self.user.role == "SimpleUsers"
+                and self.user.username != self.full_address
+            ):
+                newaddress = self.user.username
+            if newaddress is not None:
+                local_part, domname = split_mailbox(newaddress)
+                domain = Domain.objects.filter(name=domname).first()
+                if domain is None:
+                    raise lib_exceptions.NotFound(_("Domain does not exist"))
+                if not user.can_access(domain):
+                    raise lib_exceptions.PermDeniedException
         if "use_domain_quota" in values:
             self.use_domain_quota = values["use_domain_quota"]
         if "use_domain_quota" in values or "quota" in values:

modoboa/admin/models/mxrecord.py

@@ -71,6 +71,10 @@ class MXRecord(models.Model):
     def __str__(self):
         return f"{self.name} ({self.address}) for {self.domain} "
 
+    @property
+    def active_dnsbl_results(self):
+        return self.dnsblresult_set.exclude(status="")
+
 
 class DNSBLQuerySet(models.QuerySet):
     """Custom manager for DNSBLResultManager."""

modoboa/admin/tests/test_import_.py

@@ -88,7 +88,7 @@ account; user1@nonlocal.com; toto; User; One; True; SimpleUsers; user1@nonlocal.
             name="identities.csv",
         )  # NOQA:E501
         url = reverse("v2:identities-import-from-csv")
-        self.client.post(url, {"sourcefile": f, "crypt_password": True})
+        self.client.post(url, {"sourcefile": f, "crypt_passwords": True})
         self.assertFalse(User.objects.filter(username="user1@nonlocal.com").exists())
 
     def test_import_invalid_quota(self):
@@ -99,7 +99,7 @@ account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com; ; t
             name="identities.csv",
         )  # NOQA:E501
         url = reverse("v2:identities-import-from-csv")
-        resp = self.client.post(url, {"sourcefile": f, "crypt_password": True})
+        resp = self.client.post(url, {"sourcefile": f, "crypt_passwords": True})
         self.assertIn("wrong quota value", resp.content.decode())
 
     def test_import_domain_by_domainadmin(self):
@@ -114,7 +114,7 @@ domain; domain2.com; 1000; 200; False
             name="identities.csv",
         )
         url = reverse("v2:identities-import-from-csv")
-        resp = self.client.post(url, {"sourcefile": f, "crypt_password": True})
+        resp = self.client.post(url, {"sourcefile": f, "crypt_passwords": True})
         self.assertIn("You are not allowed to import domains", resp.content.decode())
         f = ContentFile(
             b"""
@@ -122,7 +122,7 @@ domainalias; domalias1.com; test.com; True
 """,
             name="identities.csv",
         )
-        resp = self.client.post(url, {"sourcefile": f, "crypt_password": True})
+        resp = self.client.post(url, {"sourcefile": f, "crypt_passwords": True})
         self.assertIn(
             "You are not allowed to import domain aliases", resp.content.decode()
         )
@@ -138,7 +138,7 @@ account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com; 40
         )
         resp = self.client.post(
             reverse("v2:identities-import-from-csv"),
-            {"sourcefile": f, "crypt_password": True},
+            {"sourcefile": f, "crypt_passwords": True},
         )
         self.assertIn("test.com: domain quota exceeded", resp.content.decode())
 
@@ -151,7 +151,7 @@ account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com
         )
         self.client.post(
             reverse("v2:identities-import-from-csv"),
-            {"sourcefile": f, "crypt_password": True},
+            {"sourcefile": f, "crypt_passwords": True},
         )
         account = User.objects.get(username="user1@test.com")
         self.assertEqual(
@@ -168,7 +168,7 @@ account; truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; 0;
         )  # NOQA:E501
         self.client.post(
             reverse("v2:identities-import-from-csv"),
-            {"sourcefile": f, "crypt_password": True, "continue_if_exists": True},
+            {"sourcefile": f, "crypt_passwords": True, "continue_if_exists": True},
         )
         admin = User.objects.get(username="admin")
         u1 = User.objects.get(username="truc@test.com")
@@ -189,7 +189,7 @@ account; sa@test.com; toto; Super; Admin; True; SuperAdmins; superadmin@test.com
         )  # NOQA:E501
         self.client.post(
             reverse("v2:identities-import-from-csv"),
-            {"sourcefile": f, "crypt_password": True, "continue_if_exists": True},
+            {"sourcefile": f, "crypt_passwords": True, "continue_if_exists": True},
         )
         with self.assertRaises(User.DoesNotExist):
             User.objects.get(username="sa@test.com")
@@ -203,7 +203,7 @@ alias;user.alias@test.com;True;user@test.com;;;;;;;;;;;;;;;;
         )
         self.client.post(
             reverse("v2:identities-import-from-csv"),
-            {"sourcefile": f, "crypt_password": True, "continue_if_exists": True},
+            {"sourcefile": f, "crypt_passwords": True, "continue_if_exists": True},
         )
         alias = Alias.objects.get(address="user.alias@test.com")
         self.assertEqual(alias.type, "alias")
@@ -218,7 +218,7 @@ alias;user@test.com;True;admin@test.com
         )
         self.client.post(
             reverse("v2:identities-import-from-csv"),
-            {"sourcefile": f, "crypt_password": True},
+            {"sourcefile": f, "crypt_passwords": True},
         )
         self.assertTrue(
             Alias.objects.filter(address="user@test.com", internal=False).exists()
@@ -315,7 +315,7 @@ alias; alias1@test.com; True; user1@test.com
         )  # NOQA:E501
         resp = self.client.post(
             reverse("v2:identities-import-from-csv"),
-            {"sourcefile": f, "crypt_password": True},
+            {"sourcefile": f, "crypt_passwords": True},
         )
         self.assertEqual(resp.status_code, 200)
 

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