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

modoboa/admin/api/v1/serializers.py

@@ -68,12 +68,18 @@ class DomainSerializer(serializers.ModelSerializer):
             "message_limit",
             "creation",
             "last_modification",
+            "allocated_quota_in_percent",
+            "mailbox_count",
+            "mbalias_count",
+            "domainalias_count",
+            "enable_dns_checks",
         )
         read_only_fields = (
             "pk",
             "dkim_public_key",
             "dns_global_status",
-            "allocated_quota_in_percent" "mailbox_count",
+            "allocated_quota_in_percent",
+            "mailbox_count",
             "mbalias_count",
             "domainalias_count",
             "enable_dns_checks",
@@ -202,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

@@ -61,6 +61,8 @@ class DomainSerializer(v1_serializers.DomainSerializer):
             "domain_admin",
             "transport",
             "opened_alarms_count",
+            "sent_messages",
+            "sent_messages_in_percent",
         )
 
     def __init__(self, *args, **kwargs):
@@ -221,9 +223,9 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
     enable_dkim_checks = serializers.BooleanField(default=True)
     enable_dmarc_checks = serializers.BooleanField(default=True)
     enable_autoconfig_checks = serializers.BooleanField(default=True)
-    custom_dns_server = serializers.IPAddressField(allow_blank=True)
+    custom_dns_server = serializers.IPAddressField(allow_blank=True, allow_null=True)
     enable_dnsbl_checks = serializers.BooleanField(default=True)
-    dkim_keys_storage_dir = serializers.CharField(allow_blank=True)
+    dkim_keys_storage_dir = serializers.CharField(allow_blank=True, allow_null=True)
     dkim_default_key_length = serializers.ChoiceField(
         default=2048, choices=constants.DKIM_KEY_LENGTHS
     )
@@ -729,7 +731,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/core/api/v2/serializers.py

@@ -76,8 +76,12 @@ class CoreGlobalParametersSerializer(serializers.Serializer):
     default_password = serializers.CharField(default="ChangeMe1!")
     random_password_length = serializers.IntegerField(min_value=8, default=8)
     allow_special_characters = serializers.BooleanField(default=False)
-    update_password_url = serializers.URLField(required=False, allow_blank=True)
-    password_recovery_msg = serializers.CharField(required=False, allow_blank=True)
+    update_password_url = serializers.URLField(
+        required=False, allow_blank=True, allow_null=True
+    )
+    password_recovery_msg = serializers.CharField(
+        required=False, allow_blank=True, allow_null=True
+    )
     sms_password_recovery = serializers.BooleanField(default=False)
     sms_provider = serializers.ChoiceField(
         choices=constants.SMS_BACKENDS, required=False, allow_null=True
@@ -87,7 +91,9 @@ class CoreGlobalParametersSerializer(serializers.Serializer):
     ldap_server_address = serializers.CharField(default="localhost")
     ldap_server_port = serializers.IntegerField(default=389)
     ldap_enable_secondary_server = serializers.BooleanField(default=False)
-    ldap_secondary_server_address = serializers.CharField(required=False)
+    ldap_secondary_server_address = serializers.CharField(
+        required=False, allow_blank=True, allow_null=True
+    )
     ldap_secondary_server_port = serializers.IntegerField(default=389, required=False)
     ldap_secured = serializers.ChoiceField(
         choices=constants.LDAP_SECURE_MODES, default="none"
@@ -109,9 +115,11 @@ class CoreGlobalParametersSerializer(serializers.Serializer):
         choices=constants.LDAP_AUTH_METHODS,
         default="searchbind",
     )
-    ldap_bind_dn = serializers.CharField(default="", required=False, allow_blank=True)
+    ldap_bind_dn = serializers.CharField(
+        default="", required=False, allow_blank=True, allow_null=True
+    )
     ldap_bind_password = serializers.CharField(
-        default="", required=False, allow_blank=True
+        default="", required=False, allow_blank=True, allow_null=True
     )
     ldap_search_base = serializers.CharField(
         default="", required=False, allow_blank=True
@@ -124,15 +132,21 @@ class CoreGlobalParametersSerializer(serializers.Serializer):
     )
 
     # LDAP sync settings
-    ldap_sync_bind_dn = serializers.CharField(required=False, allow_blank=True)
-    ldap_sync_bind_password = serializers.CharField(required=False, allow_blank=True)
+    ldap_sync_bind_dn = serializers.CharField(
+        required=False, allow_blank=True, allow_null=True
+    )
+    ldap_sync_bind_password = serializers.CharField(
+        required=False, allow_blank=True, allow_null=True
+    )
     ldap_enable_sync = serializers.BooleanField(default=False)
     ldap_sync_delete_remote_account = serializers.BooleanField(default=False)
     ldap_sync_account_dn_template = serializers.CharField(
-        required=False, allow_blank=True
+        required=False, allow_blank=True, allow_null=True
     )
     ldap_enable_import = serializers.BooleanField(default=False)
-    ldap_import_search_base = serializers.CharField(required=False, allow_blank=True)
+    ldap_import_search_base = serializers.CharField(
+        required=False, allow_blank=True, allow_null=True
+    )
     ldap_import_search_filter = serializers.CharField(default="(cn=*)", required=False)
     ldap_import_username_attr = serializers.CharField(default="cn")
     ldap_dovecot_sync = serializers.BooleanField(default=False)
@@ -141,7 +155,9 @@ class CoreGlobalParametersSerializer(serializers.Serializer):
     )
 
     # Dashboard settings
-    custom_welcome_message = serializers.CharField(required=False, allow_blank=True)
+    custom_welcome_message = serializers.CharField(
+        required=False, allow_blank=True, allow_null=True
+    )
     rss_feed_url = serializers.URLField(
         allow_blank=True, required=False, allow_null=True
     )
@@ -162,7 +178,9 @@ class CoreGlobalParametersSerializer(serializers.Serializer):
     enable_api_communication = serializers.BooleanField(default=True)
     check_new_versions = serializers.BooleanField(default=True)
     send_new_versions_email = serializers.BooleanField(default=False)
-    new_versions_email_rcpt = lib_fields.DRFEmailFieldUTF8(required=False)
+    new_versions_email_rcpt = lib_fields.DRFEmailFieldUTF8(
+        required=False, allow_null=True
+    )
     send_statistics = serializers.BooleanField(default=True)
 
     # Misc settings
@@ -170,6 +188,7 @@ class CoreGlobalParametersSerializer(serializers.Serializer):
     inactive_account_threshold = serializers.IntegerField(default=30)
     top_notifications_check_interval = serializers.IntegerField(default=30)
     log_maximum_age = serializers.IntegerField(default=365)
+    message_history_maximum_age = serializers.IntegerField(default=180)
     items_per_page = serializers.IntegerField(default=30)
     default_top_redirection = serializers.ChoiceField(
         default="user", choices=[("user", _("User profile"))], required=False
@@ -195,10 +214,11 @@ class CoreGlobalParametersSerializer(serializers.Serializer):
         return value
 
     def validate_ldap_sync_account_dn_template(self, value):
-        try:
-            value % {"user": "toto"}
-        except (KeyError, ValueError):
-            raise serializers.ValidationError(_("Invalid syntax")) from None
+        if value:
+            try:
+                value % {"user": "toto"}
+            except (KeyError, ValueError):
+                raise serializers.ValidationError(_("Invalid syntax")) from None
         return value
 
     def validate_ldap_search_filter(self, value):
@@ -672,3 +692,11 @@ class ThemeSerializer(serializers.Serializer):
     theme_primary_color_light = serializers.CharField(default="#3688F9")
     theme_secondary_color = serializers.CharField(default="#F18429")
     theme_label_color = serializers.CharField(default="#616161")
+
+
+class StatisticsSerializer(serializers.Serializer):
+
+    domain_count = serializers.IntegerField()
+    domain_alias_count = serializers.IntegerField()
+    account_count = serializers.IntegerField()
+    alias_count = serializers.IntegerField()

modoboa/core/api/v2/tests.py

@@ -658,3 +658,21 @@ class NewsFeedAPIViewTestCase(ModoAPITestCase):
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
         self.assertIn("modoboa", response.json()[0]["link"])
+
+
+class StatisticsAPIViewTestCase(ModoAPITestCase):
+
+    @classmethod
+    def setUpTestData(cls):
+        """Create test data."""
+        super().setUpTestData()
+        factories.populate_database()
+
+    def test_get_statistics(self):
+        url = reverse("v2:statistics")
+        response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+        stats = response.json()
+        self.assertEqual(stats["domain_count"], 2)
+        self.assertEqual(stats["account_count"], 5)
+        self.assertEqual(stats["alias_count"], 3)

modoboa/core/api/v2/urls.py

@@ -42,6 +42,11 @@ urlpatterns += [
         views.NewsFeedAPIView.as_view(),
         name="news-feed",
     ),
+    path(
+        "admin/statistics/",
+        views.StatisticsAPIView.as_view(),
+        name="statistics",
+    ),
     path("capabilities/", views.CapabilitiesAPIView.as_view(), name="capabilities"),
     path("theme/", views.ThemeAPIView.as_view(), name="theme"),
 ]

modoboa/core/api/v2/views.py

@@ -14,7 +14,8 @@ from drf_spectacular.utils import extend_schema
 from rest_framework import permissions, response
 from rest_framework.views import APIView
 
-from modoboa.core import signals
+from modoboa.admin import models as admin_models
+from modoboa.core import models, signals
 from modoboa.core.utils import check_for_updates, get_capabilities
 from modoboa.lib.permissions import IsSuperUser, IsPrivilegedUser
 from modoboa.lib.throttle import (
@@ -226,3 +227,21 @@ class NewsFeedAPIView(APIView):
 
         serializer = serializers.NewsFeedEntrySerializer(entries, many=True)
         return response.Response(serializer.data)
+
+
+class StatisticsAPIView(APIView):
+    """Return some statistics about this modoboa instance."""
+
+    permission_classes = [permissions.IsAuthenticated, IsSuperUser]
+    throttle_classes = [UserLesserDdosUser]
+
+    @extend_schema(responses=serializers.StatisticsSerializer())
+    def get(self, request, *args, **kwargs):
+        data = {
+            "domain_count": admin_models.Domain.objects.count(),
+            "domain_alias_count": admin_models.DomainAlias.objects.count(),
+            "account_count": models.User.objects.count(),
+            "alias_count": admin_models.Alias.objects.filter(internal=False).count(),
+        }
+        serializer = serializers.StatisticsSerializer(data)
+        return response.Response(serializer.data)

modoboa/core/app_settings.py

@@ -649,7 +649,7 @@ GLOBAL_PARAMETERS_STRUCT = collections.OrderedDict(
                             "new_versions_email_rcpt",
                             {
                                 "label": gettext_lazy("Recipient"),
-                                "display": "check_new_versions=true",
+                                "display": "send_new_versions_email=true",
                                 "help_text": gettext_lazy(
                                     "Recipient of new versions notification emails."
                                 ),
@@ -720,6 +720,17 @@ GLOBAL_PARAMETERS_STRUCT = collections.OrderedDict(
                                 ),
                             },
                         ),
+                        (
+                            "message_history_maximum_age",
+                            {
+                                "label": gettext_lazy(
+                                    "Retention time in message history"
+                                ),
+                                "help_text": gettext_lazy(
+                                    "Retention time (in days) of a message in the message history section"
+                                ),
+                            },
+                        ),
                         (
                             "items_per_page",
                             {

modoboa/core/fido2_auth.py

@@ -34,10 +34,9 @@ def begin_registration(request):
         ),
         list(get_creds_from_user(request.user.pk).values()),
         user_verification=UserVerificationRequirement.DISCOURAGED,
-        extensions={"credentialProtectionPolicy": "userVerificationOptional"},
     )
     request.session["fido2_state"] = state
-    return options
+    return dict(options)
 
 
 def end_registration(request):

modoboa/core/management/commands/cleanlogs.py

@@ -5,6 +5,7 @@ from django.core.management.base import BaseCommand
 from django.utils import timezone
 
 from modoboa.core.models import Log
+from modoboa.maillog.models import Maillog
 from modoboa.parameters import tools as param_tools
 
 
@@ -41,4 +42,12 @@ class Command(BaseCommand):
         self.__vprint(f"Deleting logs older than {log_maximum_age} days...")
         limit = timezone.now() - datetime.timedelta(log_maximum_age)
         Log.objects.filter(date_created__lt=limit).delete()
+        message_history_maximum_age = param_tools.get_global_parameter(
+            "message_history_maximum_age"
+        )
+        self.__vprint(
+            f"Deleting messages in history older than {message_history_maximum_age} days..."
+        )
+        limit = timezone.now() - datetime.timedelta(message_history_maximum_age)
+        Maillog.objects.filter(date__lt=limit).delete()
         self.__vprint("Done.")

modoboa/core/management/commands/load_initial_data.py

@@ -159,12 +159,6 @@ class Command(BaseCommand):
             os.path.dirname(__file__), "../../../frontend_dist/"
         )
         frontend_target_dir = f"{settings.BASE_DIR}/frontend"
-        if hasattr(settings, "MODOBOA_CUSTOM_LOGO"):
-            menu_logo_path = settings.MODOBOA_CUSTOM_LOGO
-            form_logo_path = settings.MODOBOA_CUSTOM_LOGO
-        else:
-            menu_logo_path = f"{frontend_target_dir}/assets/Modoboa_RVB-BLANC-SANS.png"
-            form_logo_path = f"{frontend_target_dir}/assets/Modoboa_RVB-BLEU-SANS.png"
         if os.path.isdir(base_frontend_dir):
             shutil.rmtree(frontend_target_dir, ignore_errors=True)
             os.makedirs(frontend_target_dir, exist_ok=True)
@@ -178,13 +172,13 @@ class Command(BaseCommand):
             api_base_url = "/api/v2"
             api_doc_url = "/api/schema-v2/swagger/"
             oauth_authority_url = "/api/o"
-            if options["relative_urls_in_config"]:
-                api_base_url += base_uri
-                api_doc_url += base_uri
-                oauth_authority_url += base_uri
-                oauth_post_logout_redirect_uri = ""
-            else:
+            if not options["relative_urls_in_config"]:
+                api_base_url = f"{base_uri}{api_base_url}"
+                api_doc_url = f"{base_uri}{base_uri}"
+                oauth_authority_url = f"{base_uri}{oauth_authority_url}"
                 oauth_post_logout_redirect_uri = base_uri
+            else:
+                oauth_post_logout_redirect_uri = ""
 
             with open(f"{frontend_target_dir}/config.json", "w") as fp:
                 fp.write(
@@ -194,9 +188,7 @@ class Command(BaseCommand):
   "OAUTH_AUTHORITY_URL": "{oauth_authority_url}",
   "OAUTH_CLIENT_ID": "{client_id}",
   "OAUTH_REDIRECT_URI": "{redirect_uri}",
-  "OAUTH_POST_REDIRECT_URI": "{oauth_post_logout_redirect_uri}",
-  "MENU_LOGO_PATH": "{menu_logo_path}",
-  "CREATION_FORM_LOGO_PATH": "{form_logo_path}"
+  "OAUTH_POST_REDIRECT_URI": "{oauth_post_logout_redirect_uri}"
 }}
 """
                 )

modoboa/core/migrations/0025_rename_user_email_is_active_core_user_email_c0c03f_idx.py

@@ -9,9 +9,9 @@ class Migration(migrations.Migration):
     ]
 
     operations = [
-        migrations.RenameIndex(
-            model_name="user",
-            new_name="core_user_email_c0c03f_idx",
-            old_fields=("email", "is_active"),
-        ),
+        # migrations.RenameIndex(
+        #     model_name="user",
+        #     new_name="core_user_email_c0c03f_idx",
+        #     old_fields=("email", "is_active"),
+        # ),
     ]

modoboa/core/tests/test_core.py

@@ -16,6 +16,7 @@ from django.urls import reverse
 from django.utils import timezone
 
 from modoboa.lib.tests import ModoTestCase, SimpleModoTestCase
+from modoboa.maillog import factories as maillog_factories, models as maillog_models
 from .. import factories, mocks, models
 
 
@@ -60,12 +61,16 @@ class ManagementCommandsTestCase(SimpleModoTestCase):
 
     def test_clean_logs(self):
         """Run cleanlogs command."""
+        management.call_command("load_initial_data", "--no-frontend")
         log1 = factories.LogFactory()
         factories.LogFactory()
         log1.date_created -= relativedelta(years=2)
         log1.save(update_fields=["date_created"])
+        maillog_factories.MaillogFactory(date=timezone.now() - relativedelta(days=190))
+        maillog_factories.MaillogFactory()
         management.call_command("cleanlogs")
         self.assertEqual(models.Log.objects.count(), 1)
+        self.assertEqual(maillog_models.Maillog.objects.count(), 1)
 
     def test_init_data_non_duplicate_client_creation(self):
         """Test that the load_initial_data command does not create duplicates

modoboa/core/utils.py

@@ -111,4 +111,7 @@ def get_capabilities():
     if is_rspamd_installed:
         rspamd_options = get_rspamd_options()
         capabilities.update({"rspamd": rspamd_options})
+    # IMAP migration
+    if "modoboa.imap_migration" in settings.MODOBOA_APPS:
+        capabilities.update({"imap_migration": {}})
     return capabilities

modoboa/dnstools/api/v2/serializers.py

@@ -7,22 +7,22 @@ from modoboa.admin import models as admin_models
 from ... import models
 
 
-class MXRecordSerializer(serializers.ModelSerializer):
-    """Serializer for MXRecord."""
+class DNSBLResultSerializer(serializers.ModelSerializer):
+    """Serializer for DNSBLResult."""
 
     class Meta:
-        model = admin_models.MXRecord
-        fields = ("name", "address", "updated")
+        model = admin_models.DNSBLResult
+        fields = ("provider", "status")
 
 
-class DNSBLResultSerializer(serializers.ModelSerializer):
-    """Serializer for DNSBLResult."""
+class MXRecordSerializer(serializers.ModelSerializer):
+    """Serializer for MXRecord."""
 
-    mx = MXRecordSerializer()
+    dnsbl_results = DNSBLResultSerializer(many=True, source="active_dnsbl_results")
 
     class Meta:
-        model = admin_models.DNSBLResult
-        fields = ("provider", "mx", "status")
+        model = admin_models.MXRecord
+        fields = ("name", "address", "dnsbl_results", "updated")
 
 
 class DNSRecordSerializer(serializers.ModelSerializer):
@@ -41,13 +41,11 @@ class DNSDetailSerializer(serializers.ModelSerializer):
     spf_record = DNSRecordSerializer()
     dkim_record = DNSRecordSerializer()
     dmarc_record = DNSRecordSerializer()
-    dnsbl_results = DNSBLResultSerializer(many=True, source="dnsblresult_set")
 
     class Meta:
         model = admin_models.Domain
         fields = (
             "mx_records",
-            "dnsbl_results",
             "autoconfig_record",
             "autodiscover_record",
             "spf_record",