Code reformatted using black

This commit is contained in:
Antoine Nguyen
2024-02-20 21:45:07 +01:00
parent 0000e4f4a7
commit 89cc0cf2a3
347 changed files with 9678 additions and 7970 deletions
+146 -91
View File
@@ -15,12 +15,18 @@ from rest_framework import serializers
from modoboa.admin import models as admin_models
from modoboa.core import (
constants as core_constants, models as core_models, signals as core_signals
constants as core_constants,
models as core_models,
signals as core_signals,
)
from modoboa.lib.exceptions import AliasExists
from modoboa.lib import (
email_utils, exceptions as lib_exceptions, fields as lib_fields,
permissions, validators, web_utils
email_utils,
exceptions as lib_exceptions,
fields as lib_fields,
permissions,
validators,
web_utils,
)
from modoboa.parameters import tools as param_tools
@@ -35,43 +41,61 @@ class DomainSerializer(serializers.ModelSerializer):
help_text=gettext_lazy(
"Quota shared between mailboxes. Can be expressed in KB, "
"MB (default) or GB. A value of 0 means no quota."
)
),
)
default_mailbox_quota = serializers.CharField(
required=False,
help_text=gettext_lazy(
"Default quota in MB applied to mailboxes. A value of 0 means "
"no quota."
)
"Default quota in MB applied to mailboxes. A value of 0 means " "no quota."
),
)
class Meta:
model = models.Domain
fields = (
"pk", "name", "quota", "default_mailbox_quota", "enabled", "type",
"enable_dkim", "dkim_key_selector", "dkim_key_length",
"dkim_public_key", "dkim_private_key_path",
"mailbox_count", "mbalias_count", "domainalias_count",
"dns_global_status", "message_limit", "creation",
"last_modification"
"pk",
"name",
"quota",
"default_mailbox_quota",
"enabled",
"type",
"enable_dkim",
"dkim_key_selector",
"dkim_key_length",
"dkim_public_key",
"dkim_private_key_path",
"mailbox_count",
"mbalias_count",
"domainalias_count",
"dns_global_status",
"message_limit",
"creation",
"last_modification",
)
read_only_fields = (
"pk", "dkim_public_key", "dns_global_status", "allocated_quota_in_percent"
"mailbox_count", "mbalias_count", "domainalias_count",
"enable_dns_checks", "creation", "last_modification"
"pk",
"dkim_public_key",
"dns_global_status",
"allocated_quota_in_percent" "mailbox_count",
"mbalias_count",
"domainalias_count",
"enable_dns_checks",
"creation",
"last_modification",
)
def validate_name(self, value):
"""Check name constraints."""
domains_must_have_authorized_mx = (
param_tools.get_global_parameter("domains_must_have_authorized_mx")
domains_must_have_authorized_mx = param_tools.get_global_parameter(
"domains_must_have_authorized_mx"
)
user = self.context["request"].user
value = value.lower()
if domains_must_have_authorized_mx and not user.is_superuser:
if not lib.domain_has_authorized_mx(value):
raise serializers.ValidationError(
_("No authorized MX record found for this domain"))
_("No authorized MX record found for this domain")
)
return value
def validate_quota(self, value):
@@ -87,10 +111,9 @@ class DomainSerializer(serializers.ModelSerializer):
quota = data.get("quota", 0)
default_mailbox_quota = data.get("default_mailbox_quota", 0)
if quota != 0 and default_mailbox_quota > quota:
raise serializers.ValidationError({
"default_mailbox_quota":
_("Cannot be greater than domain quota")
})
raise serializers.ValidationError(
{"default_mailbox_quota": _("Cannot be greater than domain quota")}
)
return data
def create(self, validated_data):
@@ -98,15 +121,15 @@ class DomainSerializer(serializers.ModelSerializer):
params = dict(param_tools.get_global_parameters("admin"))
domain = models.Domain(**validated_data)
condition = (
params["default_domain_message_limit"] is not None and
"message_limit" not in validated_data
params["default_domain_message_limit"] is not None
and "message_limit" not in validated_data
)
if condition:
domain.message_limit = params["default_domain_message_limit"]
creator = self.context["request"].user
core_signals.can_create_object.send(
sender=self.__class__, context=creator,
klass=models.Domain, instance=domain)
sender=self.__class__, context=creator, klass=models.Domain, instance=domain
)
domain.save(creator=creator)
return domain
@@ -125,7 +148,12 @@ class DomainAliasSerializer(serializers.ModelSerializer):
class Meta:
model = admin_models.DomainAlias
fields = ("pk", "name", "target", "enabled", )
fields = (
"pk",
"name",
"target",
"enabled",
)
def validate_target(self, value):
"""Check target domain."""
@@ -143,14 +171,15 @@ class DomainAliasSerializer(serializers.ModelSerializer):
creator = self.context["request"].user
try:
core_signals.can_create_object.send(
sender=self.__class__, context=creator,
klass=models.DomainAlias)
sender=self.__class__, context=creator, klass=models.DomainAlias
)
core_signals.can_create_object.send(
sender=self.__class__, context=domain_alias.target,
object_type="domain_aliases")
sender=self.__class__,
context=domain_alias.target,
object_type="domain_aliases",
)
except lib_exceptions.ModoboaException as inst:
raise serializers.ValidationError({
"domain": force_str(inst)})
raise serializers.ValidationError({"domain": force_str(inst)})
domain_alias.save(creator=creator)
return domain_alias
@@ -165,8 +194,13 @@ class MailboxSerializer(serializers.ModelSerializer):
class Meta:
model = models.Mailbox
fields = (
"pk", "full_address", "use_domain_quota", "quota", "message_limit",
"quota_usage", "is_send_only"
"pk",
"full_address",
"use_domain_quota",
"quota",
"message_limit",
"quota_usage",
"is_send_only",
)
def get_quota_usage(self, mb) -> int:
@@ -185,9 +219,9 @@ class MailboxSerializer(serializers.ModelSerializer):
method = self.context["request"].method
if not data.get("use_domain_quota", False):
if "quota" not in data and method != "PATCH":
raise serializers.ValidationError({
"quota": _("This field is required")
})
raise serializers.ValidationError(
{"quota": _("This field is required")}
)
return data
@@ -199,15 +233,28 @@ class AccountSerializer(serializers.ModelSerializer):
domains = serializers.SerializerMethodField(
help_text=_(
"List of administered domains (resellers and domain "
"administrators only)."))
"administrators only)."
)
)
class Meta:
model = core_models.User
fields = (
"pk", "username", "first_name", "last_name", "is_active",
"master_user", "mailbox", "role", "language", "phone_number",
"secondary_email", "domains", "tfa_enabled", "date_joined",
"last_login"
"pk",
"username",
"first_name",
"last_name",
"is_active",
"master_user",
"mailbox",
"role",
"language",
"phone_number",
"secondary_email",
"domains",
"tfa_enabled",
"date_joined",
"last_login",
)
def __init__(self, *args, **kwargs):
@@ -230,7 +277,8 @@ class AccountSerializer(serializers.ModelSerializer):
if account.role not in ["DomainAdmins", "Resellers"]:
return []
return admin_models.Domain.objects.get_for_admin(account).values_list(
"name", flat=True)
"name", flat=True
)
class AccountExistsSerializer(serializers.Serializer):
@@ -240,7 +288,6 @@ class AccountExistsSerializer(serializers.Serializer):
class AccountPasswordSerializer(serializers.ModelSerializer):
"""A serializer used to change a user password."""
new_password = serializers.CharField()
@@ -248,7 +295,9 @@ class AccountPasswordSerializer(serializers.ModelSerializer):
class Meta:
model = core_models.User
fields = (
"password", "new_password", )
"password",
"new_password",
)
def validate_password(self, value):
"""Check password."""
@@ -279,8 +328,7 @@ class WritableAccountSerializer(AccountSerializer):
password = serializers.CharField(required=False)
class Meta(AccountSerializer.Meta):
fields = AccountSerializer.Meta.fields + (
"password", "random_password")
fields = AccountSerializer.Meta.fields + ("password", "random_password")
def __init__(self, *args, **kwargs):
"""Adapt fields to current user."""
@@ -290,9 +338,11 @@ class WritableAccountSerializer(AccountSerializer):
return
user = self.context["request"].user
self.fields["role"] = serializers.ChoiceField(
choices=permissions.get_account_roles(user))
choices=permissions.get_account_roles(user)
)
self.fields["domains"] = serializers.ListField(
child=serializers.CharField(), allow_empty=False, required=False)
child=serializers.CharField(), allow_empty=False, required=False
)
def validate_username(self, value):
"""Lower case username."""
@@ -303,9 +353,9 @@ class WritableAccountSerializer(AccountSerializer):
master_user = data.get("master_user", False)
role = data.get("role")
if master_user and role != "SuperAdmins":
raise serializers.ValidationError({
"master_user": _("Not allowed for this role.")
})
raise serializers.ValidationError(
{"master_user": _("Not allowed for this role.")}
)
if role == "SimpleUsers":
username = data.get("username")
if username:
@@ -318,49 +368,50 @@ class WritableAccountSerializer(AccountSerializer):
if not self.instance:
data["mailbox"] = {
"full_address": username,
"use_domain_quota": True
"use_domain_quota": True,
}
elif "full_address" in mailbox and mailbox["full_address"] != username:
raise serializers.ValidationError({
"username": _("Must be equal to mailbox full_address")
})
raise serializers.ValidationError(
{"username": _("Must be equal to mailbox full_address")}
)
if "mailbox" in data:
self.address, domain_name = email_utils.split_mailbox(data["mailbox"]["full_address"])
self.domain = get_object_or_404(
admin_models.Domain, name=domain_name)
self.address, domain_name = email_utils.split_mailbox(
data["mailbox"]["full_address"]
)
self.domain = get_object_or_404(admin_models.Domain, name=domain_name)
creator = self.context["request"].user
if not creator.can_access(self.domain):
raise serializers.ValidationError({"mailbox": _("Permission denied.")})
if not self.instance:
try:
core_signals.can_create_object.send(
sender=self.__class__, context=creator,
klass=admin_models.Mailbox)
sender=self.__class__,
context=creator,
klass=admin_models.Mailbox,
)
core_signals.can_create_object.send(
sender=self.__class__, context=self.domain,
object_type="mailboxes")
sender=self.__class__,
context=self.domain,
object_type="mailboxes",
)
except lib_exceptions.ModoboaException as inst:
raise serializers.ValidationError({
"mailbox": force_str(inst)})
condition = (
not data.get("random_password") and (
data.get("password") or
not self.partial
)
raise serializers.ValidationError({"mailbox": force_str(inst)})
condition = not data.get("random_password") and (
data.get("password") or not self.partial
)
if condition:
password = data.get("password")
if password:
try:
password_validation.validate_password(
data["password"], self.instance)
data["password"], self.instance
)
except ValidationError as exc:
raise serializers.ValidationError({
"password": exc.messages[0]})
raise serializers.ValidationError({"password": exc.messages[0]})
elif not self.instance:
raise serializers.ValidationError({
"password": _("This field is required.")
})
raise serializers.ValidationError(
{"password": _("This field is required.")}
)
domain_names = data.get("domains")
if not domain_names:
return data
@@ -370,9 +421,9 @@ class WritableAccountSerializer(AccountSerializer):
if domain:
domains.append(domain)
continue
raise serializers.ValidationError({
"domains": _("Local domain {} does not exist").format(name)
})
raise serializers.ValidationError(
{"domains": _("Local domain {} does not exist").format(name)}
)
data["domains"] = domains
return data
@@ -381,10 +432,12 @@ class WritableAccountSerializer(AccountSerializer):
full_address = data.pop("full_address")
quota = data.pop("quota", None)
mb = admin_models.Mailbox(
user=account, address=self.address, domain=self.domain, **data)
user=account, address=self.address, domain=self.domain, **data
)
mb.set_quota(quota, creator.has_perm("admin.add_domain"))
default_msg_limit = param_tools.get_global_parameter(
"default_mailbox_message_limit")
"default_mailbox_message_limit"
)
if default_msg_limit is not None:
mb.message_limit = default_msg_limit
mb.save(creator=creator)
@@ -457,20 +510,19 @@ class AliasSerializer(serializers.ModelSerializer):
recipients = serializers.ListField(
child=lib_fields.DRFEmailFieldUTF8AndEmptyUser(),
allow_empty=False,
help_text=gettext_lazy("A list of recipient")
help_text=gettext_lazy("A list of recipient"),
)
class Meta:
model = admin_models.Alias
fields = (
"pk", "address", "enabled", "internal", "recipients"
)
fields = ("pk", "address", "enabled", "internal", "recipients")
def validate_address(self, value):
"""Check domain."""
try:
local_part, self.domain = admin_models.validate_alias_address(
value, self.context["request"].user, instance=self.instance)
value, self.context["request"].user, instance=self.instance
)
except ValidationError as err:
raise serializers.ValidationError(err)
except AliasExists:
@@ -481,7 +533,8 @@ class AliasSerializer(serializers.ModelSerializer):
"""Create appropriate objects."""
creator = self.context["request"].user
return admin_models.Alias.objects.create(
creator=creator, domain=self.domain, **validated_data)
creator=creator, domain=self.domain, **validated_data
)
def update(self, instance, validated_data):
"""Update objects."""
@@ -509,7 +562,8 @@ class SenderAddressSerializer(serializers.ModelSerializer):
user = self.context["request"].user
if domain and not user.can_access(domain):
raise serializers.ValidationError(
_("You don't have access to this domain."))
_("You don't have access to this domain.")
)
return value.lower()
def validate_mailbox(self, value):
@@ -517,7 +571,8 @@ class SenderAddressSerializer(serializers.ModelSerializer):
user = self.context["request"].user
if not user.can_access(value):
raise serializers.ValidationError(
_("You don't have access to this mailbox."))
_("You don't have access to this mailbox.")
)
return value
+117 -140
View File
@@ -28,7 +28,8 @@ class DomainAPITestCase(ModoAPITestCase):
super(DomainAPITestCase, cls).setUpTestData()
factories.populate_database()
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_get_domains(self):
"""Retrieve a list of domains."""
@@ -37,8 +38,7 @@ class DomainAPITestCase(ModoAPITestCase):
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
domain = response.data[0]
url = reverse(
"v1:domain-detail", args=[domain["pk"]])
url = reverse("v1:domain-detail", args=[domain["pk"]])
response = self.client.get(url)
data = response.json()
self.assertEqual(response.status_code, 200)
@@ -65,10 +65,10 @@ class DomainAPITestCase(ModoAPITestCase):
self.assertEqual(response.status_code, 400)
self.assertIn("default_mailbox_quota", response.data)
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
response = self.client.post(
url, {"name": "test4.com", "default_mailbox_quota": 10})
url, {"name": "test4.com", "default_mailbox_quota": 10}
)
self.assertEqual(response.status_code, 403)
@mock.patch.object(dns.resolver.Resolver, "resolve")
@@ -81,19 +81,19 @@ class DomainAPITestCase(ModoAPITestCase):
self.set_global_parameter("valid_mxs", "192.0.2.1 2001:db8::1")
self.set_global_parameter("domains_must_have_authorized_mx", True)
reseller = core_factories.UserFactory(
username="reseller", groups=("Resellers", ))
username="reseller", groups=("Resellers",)
)
token = Token.objects.create(user=reseller)
self.client.credentials(HTTP_AUTHORIZATION="Token " + token.key)
url = reverse("v1:domain-list")
response = self.client.post(
url, {"name": "no-mx.example.com", "quota": 0,
"default_mailbox_quota": 10}
url, {"name": "no-mx.example.com", "quota": 0, "default_mailbox_quota": 10}
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json()["name"][0],
"No authorized MX record found for this domain")
response.json()["name"][0], "No authorized MX record found for this domain"
)
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
response = self.client.post(
@@ -104,25 +104,28 @@ class DomainAPITestCase(ModoAPITestCase):
def test_update_domain(self):
"""Check domain update."""
domain = models.Domain.objects.get(name="test.com")
models.Mailbox.objects.filter(
domain__name="test.com", address="user").update(
use_domain_quota=True)
models.Mailbox.objects.filter(domain__name="test.com", address="user").update(
use_domain_quota=True
)
url = reverse("v1:domain-detail", args=[domain.pk])
response = self.client.put(
url, {"name": "test.com", "default_mailbox_quota": 1000})
url, {"name": "test.com", "default_mailbox_quota": 1000}
)
self.assertEqual(response.status_code, 200)
domain.refresh_from_db()
self.assertEqual(domain.default_mailbox_quota, 1000)
mb = models.Mailbox.objects.get(
domain__name="test.com", address="user")
mb = models.Mailbox.objects.get(domain__name="test.com", address="user")
self.assertEqual(mb.quota, 1000)
response = self.client.put(
url, {"name": "test42.com", "default_mailbox_quota": 1000})
url, {"name": "test42.com", "default_mailbox_quota": 1000}
)
self.assertEqual(response.status_code, 200)
self.assertTrue(
models.Mailbox.objects.filter(
address="user", domain__name="test42.com").exists())
address="user", domain__name="test42.com"
).exists()
)
def test_patch_domain(self):
"""Check domain partial update."""
@@ -137,8 +140,7 @@ class DomainAPITestCase(ModoAPITestCase):
"""Try to remove DKIM from a domain."""
domain = models.Domain.objects.get(name="test.com")
url = reverse("v1:domain-detail", args=[domain.pk])
response = self.client.put(
url, {"name": "test.com", "enable_dkim": False})
response = self.client.put(url, {"name": "test.com", "enable_dkim": False})
self.assertEqual(response.status_code, 200)
domain.refresh_from_db()
self.assertEqual(domain.dkim_private_key_path, "")
@@ -161,11 +163,14 @@ class DomainAliasAPITestCase(ModoAPITestCase):
super(DomainAliasAPITestCase, cls).setUpTestData()
factories.populate_database()
cls.dom_alias1 = factories.DomainAliasFactory(
name="dalias1.com", target__name="test.com")
name="dalias1.com", target__name="test.com"
)
cls.dom_alias2 = factories.DomainAliasFactory(
name="dalias2.com", target__name="test2.com")
name="dalias2.com", target__name="test2.com"
)
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_get(self):
"""Retrieve a list of domain aliases."""
@@ -173,8 +178,7 @@ class DomainAliasAPITestCase(ModoAPITestCase):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
url = reverse(
"v1:domain_alias-detail", args=[response.data[0]["pk"]])
url = reverse("v1:domain_alias-detail", args=[response.data[0]["pk"]])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["name"], "dalias1.com")
@@ -184,8 +188,7 @@ class DomainAliasAPITestCase(ModoAPITestCase):
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
response = self.client.get(reverse("v1:domain_alias-list"))
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
@@ -194,31 +197,25 @@ class DomainAliasAPITestCase(ModoAPITestCase):
"""Try to create a new domain alias."""
url = reverse("v1:domain_alias-list")
target = models.Domain.objects.get(name="test.com")
data = {
"name": "dalias3.com",
"target": target.pk
}
data = {"name": "dalias3.com", "target": target.pk}
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, 201)
dalias = response.json()
dalias = models.DomainAlias.objects.filter(
pk=dalias["pk"]).first()
dalias = models.DomainAlias.objects.filter(pk=dalias["pk"]).first()
self.assertEqual(dalias.target, target)
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
response = self.client.post(
url, {"name": "dalias4.com", "target": target.pk}, format="json")
url, {"name": "dalias4.com", "target": target.pk}, format="json"
)
self.assertEqual(response.status_code, 403)
def test_put(self):
"""Try to update a domain alias."""
dalias = models.DomainAlias.objects.get(name="dalias1.com")
url = reverse("v1:domain_alias-detail", args=[dalias.pk])
data = {
"name": "dalias3.com", "target": dalias.target.pk
}
data = {"name": "dalias3.com", "target": dalias.target.pk}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
@@ -232,8 +229,7 @@ class DomainAliasAPITestCase(ModoAPITestCase):
url = reverse("v1:domain_alias-detail", args=[dalias.pk])
response = self.client.delete(url)
self.assertEqual(response.status_code, 204)
self.assertFalse(
models.DomainAlias.objects.filter(pk=dalias.pk).exists())
self.assertFalse(models.DomainAlias.objects.filter(pk=dalias.pk).exists())
class AccountAPITestCase(ModoAPITestCase):
@@ -243,10 +239,7 @@ class AccountAPITestCase(ModoAPITestCase):
"username": "fromapi@test.com",
"role": "SimpleUsers",
"password": "Toto1234",
"mailbox": {
"full_address": "fromapi@test.com",
"quota": 10
}
"mailbox": {"full_address": "fromapi@test.com", "quota": 10},
}
@classmethod
@@ -255,15 +248,15 @@ class AccountAPITestCase(ModoAPITestCase):
super(AccountAPITestCase, cls).setUpTestData()
factories.populate_database()
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def setUp(self):
"""Test setup."""
super().setUp()
self.set_global_parameters({
"enable_admin_limits": False,
"enable_domain_limits": False
}, app="limits")
self.set_global_parameters(
{"enable_admin_limits": False, "enable_domain_limits": False}, app="limits"
)
def test_get_accounts(self):
"""Retrieve a list of accounts."""
@@ -351,12 +344,10 @@ class AccountAPITestCase(ModoAPITestCase):
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, 201)
domain = models.Domain.objects.get(name="test.com")
admin = core_models.User.objects.get(
pk=response.json()["pk"])
admin = core_models.User.objects.get(pk=response.json()["pk"])
self.assertIn(admin, domain.admins)
response = self.client.get(
reverse("v1:account-detail", args=[admin.pk]))
response = self.client.get(reverse("v1:account-detail", args=[admin.pk]))
self.assertEqual(response.status_code, 200)
self.assertIn("domains", response.json())
@@ -376,8 +367,7 @@ class AccountAPITestCase(ModoAPITestCase):
user = core_models.User.objects.filter(pk=account["pk"]).first()
self.assertIsNot(user, None)
self.assertIsNot(user.mailbox, None)
self.assertEqual(
user.mailbox.quota, user.mailbox.domain.default_mailbox_quota)
self.assertEqual(user.mailbox.quota, user.mailbox.domain.default_mailbox_quota)
def test_create_existing_account(self):
"""Check if unicity is respected."""
@@ -404,8 +394,7 @@ class AccountAPITestCase(ModoAPITestCase):
def test_create_account_as_domadmin(self):
"""As DomainAdmin, try to create a new account."""
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
data = copy.deepcopy(self.ACCOUNT_DATA)
data["mailbox"]["quota"] = 1000
url = reverse("v1:account-list")
@@ -414,8 +403,7 @@ class AccountAPITestCase(ModoAPITestCase):
self.assertEqual(response.status_code, 400)
data["username"] = "fromapi@test2.com"
data["mailbox"].update({"full_address": "fromapi@test2.com",
"quota": 10})
data["mailbox"].update({"full_address": "fromapi@test2.com", "quota": 10})
response = self.client.post(url, data, format="json")
# Should fail because admin has no access to @test2.com domain
self.assertEqual(response.status_code, 400)
@@ -442,8 +430,8 @@ class AccountAPITestCase(ModoAPITestCase):
"password": "Toto1234",
"mailbox": {
"full_address": "fromapi@test.com",
"quota": account.mailbox.quota
}
"quota": account.mailbox.quota,
},
}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
@@ -460,14 +448,9 @@ class AccountAPITestCase(ModoAPITestCase):
def test_update_account_with_no_mailbox(self):
"""Try to disable an account."""
account = core_factories.UserFactory(
username="reseller", groups=("Resellers", ))
account = core_factories.UserFactory(username="reseller", groups=("Resellers",))
url = reverse("v1:account-detail", args=[account.pk])
data = {
"username": "reseller",
"role": account.role,
"is_active": False
}
data = {"username": "reseller", "role": account.role, "is_active": False}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
@@ -480,7 +463,7 @@ class AccountAPITestCase(ModoAPITestCase):
"username": "fromapi@test.com",
"mailbox": {
"full_address": "fromapi@test.com",
}
},
}
response = self.client.patch(url, data, format="json")
self.assertEqual(response.status_code, 200)
@@ -498,9 +481,9 @@ class AccountAPITestCase(ModoAPITestCase):
"password": "Toto1234",
"mailbox": {
"full_address": account.mailbox.full_address,
"quota": account.mailbox.quota
"quota": account.mailbox.quota,
},
"domains": ["test.com", "test2.com"]
"domains": ["test.com", "test2.com"],
}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
@@ -525,8 +508,8 @@ class AccountAPITestCase(ModoAPITestCase):
"password": "Toto1234",
"mailbox": {
"full_address": "fromapi@test3.com",
"quota": account.mailbox.quota
}
"quota": account.mailbox.quota,
},
}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 404)
@@ -539,20 +522,17 @@ class AccountAPITestCase(ModoAPITestCase):
url = reverse("v1:account-detail", args=[account.pk])
response = self.client.delete(url)
self.assertEqual(response.status_code, 204)
self.assertFalse(
core_models.User.objects.filter(pk=account.pk).exists())
self.assertFalse(core_models.User.objects.filter(pk=account.pk).exists())
self.assertFalse(domadmin.can_access(account))
def test_account_exists(self):
"""Validate /exists/ service."""
url = reverse("v1:account-exists")
response = self.client.get(
"{}?email={}".format(url, "user@test.com"))
response = self.client.get("{}?email={}".format(url, "user@test.com"))
self.assertEqual(response.status_code, 200)
content = response.json()
self.assertTrue(content["exists"])
response = self.client.get(
"{}?email={}".format(url, "pipo@test.com"))
response = self.client.get("{}?email={}".format(url, "pipo@test.com"))
self.assertEqual(response.status_code, 200)
content = response.json()
self.assertFalse(content["exists"])
@@ -562,17 +542,16 @@ class AccountAPITestCase(ModoAPITestCase):
def test_change_password(self):
"""Check the change password service."""
account = core_models.User.objects.get(username="user@test.com")
url = reverse(
"v1:account-password", args=[account.pk])
url = reverse("v1:account-password", args=[account.pk])
response = self.client.put(
url, {"password": "toto", "new_password": "pass"},
format="json")
url, {"password": "toto", "new_password": "pass"}, format="json"
)
# must fail because password is too weak
self.assertEqual(response.status_code, 400)
response = self.client.put(
url, {"password": "toto", "new_password": "Toto1234"},
format="json")
url, {"password": "toto", "new_password": "Toto1234"}, format="json"
)
self.assertEqual(response.status_code, 200)
account.refresh_from_db()
self.assertTrue(account.check_password("Toto1234"))
@@ -585,13 +564,16 @@ class AccountAPITestCase(ModoAPITestCase):
response = self.client.post(url)
self.assertEqual(response.status_code, 404)
self.set_global_parameters({
"sms_password_recovery": True,
"sms_provider": "ovh",
"sms_ovh_application_key": "key",
"sms_ovh_application_secret": "secret",
"sms_ovh_consumer_key": "consumer"
}, app="core")
self.set_global_parameters(
{
"sms_password_recovery": True,
"sms_provider": "ovh",
"sms_ovh_application_key": "key",
"sms_ovh_application_secret": "secret",
"sms_ovh_consumer_key": "consumer",
},
app="core",
)
# No email provided
response = self.client.post(url)
self.assertEqual(response.status_code, 400)
@@ -615,21 +597,19 @@ class AliasAPITestCase(ModoAPITestCase):
ALIAS_DATA = {
"address": "alias_fromapi@test.com",
"recipients": [
"user@test.com", "postmaster@test.com", "user_éé@nonlocal.com"
]
"recipients": ["user@test.com", "postmaster@test.com", "user_éé@nonlocal.com"],
}
@classmethod
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(AliasAPITestCase, cls).setUpTestData()
cls.localconfig.parameters.set_value(
"enable_admin_limits", False, app="limits")
cls.localconfig.parameters.set_value("enable_admin_limits", False, app="limits")
cls.localconfig.save()
factories.populate_database()
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_get_aliases(self):
"""Retrieve a list of aliases."""
@@ -664,13 +644,23 @@ class AliasAPITestCase(ModoAPITestCase):
domadmin = core_models.User.objects.get(username="admin@test.com")
self.assertTrue(domadmin.can_access(alias))
self.assertEqual(alias.aliasrecipient_set.count(), 3)
self.assertTrue(alias.aliasrecipient_set.filter(
address="user@test.com", r_mailbox__isnull=False).exists())
self.assertTrue(alias.aliasrecipient_set.filter(
address="postmaster@test.com", r_alias__isnull=False).exists())
self.assertTrue(alias.aliasrecipient_set.filter(
address="user_éé@nonlocal.com",
r_mailbox__isnull=True, r_alias__isnull=True).exists())
self.assertTrue(
alias.aliasrecipient_set.filter(
address="user@test.com", r_mailbox__isnull=False
).exists()
)
self.assertTrue(
alias.aliasrecipient_set.filter(
address="postmaster@test.com", r_alias__isnull=False
).exists()
)
self.assertTrue(
alias.aliasrecipient_set.filter(
address="user_éé@nonlocal.com",
r_mailbox__isnull=True,
r_alias__isnull=True,
).exists()
)
# Create catchall alias
data = copy.deepcopy(self.ALIAS_DATA)
@@ -691,8 +681,7 @@ class AliasAPITestCase(ModoAPITestCase):
def test_create_alias_as_domadmin(self):
"""As DomainAdmin, try to create a new alias."""
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
url = reverse("v1:alias-list")
response = self.client.post(url, self.ALIAS_DATA, format="json")
self.assertEqual(response.status_code, 201)
@@ -710,26 +699,20 @@ class AliasAPITestCase(ModoAPITestCase):
url = reverse("v1:alias-detail", args=[alias.pk])
data = {
"address": "alias@test.com",
"recipients": ["user@test.com", "user@nonlocal.com"]
"recipients": ["user@test.com", "user@nonlocal.com"],
}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
alias.refresh_from_db()
self.assertEqual(alias.aliasrecipient_set.count(), 2)
data = {
"address": "alias@test.com",
"recipients": ["user@nonlocal.com"]
}
data = {"address": "alias@test.com", "recipients": ["user@nonlocal.com"]}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
alias.refresh_from_db()
self.assertEqual(alias.aliasrecipient_set.count(), 1)
data = {
"address": "alias@test.com",
"recipients": []
}
data = {"address": "alias@test.com", "recipients": []}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 400)
@@ -741,13 +724,12 @@ class AliasAPITestCase(ModoAPITestCase):
url = reverse("v1:alias-detail", args=[alias.pk])
response = self.client.delete(url)
self.assertEqual(response.status_code, 204)
self.assertFalse(
models.Alias.objects.filter(pk=alias.pk).exists())
self.assertFalse(models.Alias.objects.filter(pk=alias.pk).exists())
self.assertFalse(domadmin.can_access(alias))
self.assertFalse(
models.AliasRecipient.objects.filter(
address="user@test.com", alias__address="alias@test.com")
.exists()
address="user@test.com", alias__address="alias@test.com"
).exists()
)
@@ -758,18 +740,18 @@ class SenderAddressAPITestCase(ModoAPITestCase):
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(SenderAddressAPITestCase, cls).setUpTestData()
cls.localconfig.parameters.set_value(
"enable_admin_limits", False, app="limits")
cls.localconfig.parameters.set_value("enable_admin_limits", False, app="limits")
cls.localconfig.save()
factories.populate_database()
cls.sa1 = factories.SenderAddressFactory(
address="test@domain.ext",
mailbox__user__username="user@test.com",
mailbox__address="user",
mailbox__domain__name="test.com"
mailbox__domain__name="test.com",
)
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_list(self):
"""Retrieve a list of sender addresses."""
@@ -782,35 +764,31 @@ class SenderAddressAPITestCase(ModoAPITestCase):
def test_create(self):
"""Create a new sender addresses."""
url = reverse("v1:sender_address-list")
mbox = models.Mailbox.objects.get(
address="admin", domain__name="test.com")
mbox = models.Mailbox.objects.get(address="admin", domain__name="test.com")
data = {"address": "@extdomain.test", "mailbox": mbox.pk}
response = self.client.post(url, data)
self.assertEqual(response.status_code, 201)
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
data = {"address": "user@test2.com", "mailbox": mbox.pk}
response = self.client.post(url, data)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json()["address"][0],
"You don't have access to this domain.")
response.json()["address"][0], "You don't have access to this domain."
)
mbox = models.Mailbox.objects.get(
address="admin", domain__name="test2.com")
mbox = models.Mailbox.objects.get(address="admin", domain__name="test2.com")
data = {"address": "toto@titi.com", "mailbox": mbox.pk}
response = self.client.post(url, data)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json()["mailbox"][0],
"You don't have access to this mailbox.")
response.json()["mailbox"][0], "You don't have access to this mailbox."
)
def test_patch(self):
"""Patch an existing sender address."""
url = reverse("v1:sender_address-detail", args=[self.sa1.pk])
mbox = models.Mailbox.objects.get(
address="user", domain__name="test.com")
mbox = models.Mailbox.objects.get(address="user", domain__name="test.com")
data = {"address": "@extdomain.test"}
response = self.client.patch(url, data)
self.assertEqual(response.status_code, 200)
@@ -821,8 +799,7 @@ class SenderAddressAPITestCase(ModoAPITestCase):
def test_update(self):
"""Update an existing sender address."""
url = reverse("v1:sender_address-detail", args=[self.sa1.pk])
mbox = models.Mailbox.objects.get(
address="user", domain__name="test.com")
mbox = models.Mailbox.objects.get(address="user", domain__name="test.com")
data = {"address": "@extdomain.test", "mailbox": mbox.pk}
response = self.client.put(url, data)
self.assertEqual(response.status_code, 200)
+3 -3
View File
@@ -6,11 +6,11 @@ from . import viewsets
router = routers.SimpleRouter()
router.register(r"domains", viewsets.DomainViewSet, basename="domain")
router.register(
r"domainaliases", viewsets.DomainAliasViewSet, basename="domain_alias")
router.register(r"domainaliases", viewsets.DomainAliasViewSet, basename="domain_alias")
router.register(r"accounts", viewsets.AccountViewSet, basename="account")
router.register(r"aliases", viewsets.AliasViewSet, basename="alias")
router.register(
r"senderaddresses", viewsets.SenderAddressViewSet, basename="sender_address")
r"senderaddresses", viewsets.SenderAddressViewSet, basename="sender_address"
)
urlpatterns = router.urls
+59 -48
View File
@@ -25,23 +25,24 @@ from . import serializers
@extend_schema_view(
retrieve=extend_schema(
description="Retrieve a particular domain",
summary="Retrieve a particular domain"
summary="Retrieve a particular domain",
),
list=extend_schema(
description="Retrieve a list of domains",
summary="Retrieve a list of domains"
description="Retrieve a list of domains", summary="Retrieve a list of domains"
),
create=extend_schema(
description="Create a new domain",
summary="Create a new domain"
)
description="Create a new domain", summary="Create a new domain"
),
)
class DomainViewSet(GetThrottleViewsetMixin,
lib_viewsets.RevisionModelMixin,
viewsets.ModelViewSet):
class DomainViewSet(
GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet
):
"""Domain viewset."""
permission_classes = [IsAuthenticated, DjangoModelPermissions, ]
permission_classes = [
IsAuthenticated,
DjangoModelPermissions,
]
serializer_class = serializers.DomainSerializer
def get_queryset(self):
@@ -63,13 +64,17 @@ class DomainAliasFilterSet(dj_filters.FilterSet):
fields = ["domain"]
class DomainAliasViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin,
viewsets.ModelViewSet):
class DomainAliasViewSet(
GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet
):
"""ViewSet for DomainAlias."""
filter_backends = (dj_filters.DjangoFilterBackend, )
filter_backends = (dj_filters.DjangoFilterBackend,)
filterset_class = DomainAliasFilterSet
permission_classes = [IsAuthenticated, DjangoModelPermissions, ]
permission_classes = [
IsAuthenticated,
DjangoModelPermissions,
]
renderer_classes = (renderers.JSONRenderer, lib_renderers.CSVRenderer)
serializer_class = serializers.DomainAliasSerializer
@@ -83,11 +88,16 @@ class DomainAliasViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixi
return context
class AccountViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet):
class AccountViewSet(
GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet
):
"""ViewSet for User/Mailbox."""
filter_backends = (filters.SearchFilter, )
permission_classes = [IsAuthenticated, DjangoModelPermissions, ]
filter_backends = (filters.SearchFilter,)
permission_classes = [
IsAuthenticated,
DjangoModelPermissions,
]
search_fields = ("^first_name", "^last_name", "^email")
def get_throttles(self):
@@ -105,15 +115,14 @@ class AccountViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, v
"password": serializers.AccountPasswordSerializer,
"reset_password": serializers.ResetPasswordSerializer,
}
return action_dict.get(
self.action, serializers.WritableAccountSerializer)
return action_dict.get(self.action, serializers.WritableAccountSerializer)
def get_queryset(self):
"""Filter queryset based on current user."""
user = self.request.user
ids = user.objectaccess_set \
.filter(content_type=ContentType.objects.get_for_model(user)) \
.values_list("object_id", flat=True)
ids = user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(user)
).values_list("object_id", flat=True)
queryset = core_models.User.objects.filter(pk__in=ids)
domain = self.request.query_params.get("domain")
if domain:
@@ -131,8 +140,7 @@ class AccountViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, v
if serializer.is_valid():
serializer.save()
return Response()
return Response(
serializer.errors, status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@action(detail=False)
def exists(self, request):
@@ -156,25 +164,23 @@ class AccountViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, v
@action(methods=["post"], detail=False)
def reset_password(self, request):
"""Reset account password and send a new one by SMS."""
sms_password_recovery = (
request.localconfig.parameters
.get_value("sms_password_recovery", app="core")
sms_password_recovery = request.localconfig.parameters.get_value(
"sms_password_recovery", app="core"
)
if not sms_password_recovery:
return Response(status=404)
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = core_models.User.objects.filter(
email=serializer.validated_data["email"]).first()
email=serializer.validated_data["email"]
).first()
if not user or not user.phone_number:
return Response(status=404)
backend = sms_backends.get_active_backend(
request.localconfig.parameters)
backend = sms_backends.get_active_backend(request.localconfig.parameters)
if not backend:
return Response(status=404)
password = lib.make_password()
content = _("Here is your new Modoboa password: {}").format(
password)
content = _("Here is your new Modoboa password: {}").format(password)
if not backend.send(content, [str(user.phone_number)]):
body = {"status": "ko"}
else:
@@ -185,23 +191,26 @@ class AccountViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, v
return Response(body)
class AliasViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet):
class AliasViewSet(
GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet
):
"""
create:
Create a new alias instance.
"""
permission_classes = [IsAuthenticated, DjangoModelPermissions, ]
permission_classes = [
IsAuthenticated,
DjangoModelPermissions,
]
serializer_class = serializers.AliasSerializer
def get_queryset(self):
"""Filter queryset based on current user."""
user = self.request.user
ids = (
user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(models.Alias))
.values_list("object_id", flat=True)
)
ids = user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(models.Alias)
).values_list("object_id", flat=True)
queryset = models.Alias.objects.filter(pk__in=ids)
domain = self.request.query_params.get("domain")
if domain:
@@ -217,21 +226,23 @@ class SenderAddressFilterSet(dj_filters.FilterSet):
fields = ["mailbox"]
class SenderAddressViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin,
viewsets.ModelViewSet):
class SenderAddressViewSet(
GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet
):
"""View set for SenderAddress model."""
filter_backends = (dj_filters.DjangoFilterBackend, )
filter_backends = (dj_filters.DjangoFilterBackend,)
filterset_class = SenderAddressFilterSet
permission_classes = [IsAuthenticated, DjangoModelPermissions, ]
permission_classes = [
IsAuthenticated,
DjangoModelPermissions,
]
serializer_class = serializers.SenderAddressSerializer
def get_queryset(self):
"""Filter queryset based on current user."""
user = self.request.user
mb_ids = (
user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(models.Mailbox))
.values_list("object_id", flat=True)
)
mb_ids = user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(models.Mailbox)
).values_list("object_id", flat=True)
return models.SenderAddress.objects.filter(mailbox__pk__in=mb_ids)
+97 -99
View File
@@ -56,7 +56,9 @@ class DomainSerializer(v1_serializers.DomainSerializer):
class Meta(v1_serializers.DomainSerializer.Meta):
fields = v1_serializers.DomainSerializer.Meta.fields + (
"domain_admin", "transport", "opened_alarms_count"
"domain_admin",
"transport",
"opened_alarms_count",
)
def __init__(self, *args, **kwargs):
@@ -71,7 +73,9 @@ class DomainSerializer(v1_serializers.DomainSerializer):
result = super().validate(data)
dtype = data.get("type", "domain")
if dtype == "relaydomain" and not data.get("transport"):
raise serializers.ValidationError({"transport": _("This field is required")})
raise serializers.ValidationError(
{"transport": _("This field is required")}
)
return result
def create(self, validated_data):
@@ -96,16 +100,15 @@ class DomainSerializer(v1_serializers.DomainSerializer):
except core_models.User.DoesNotExist:
pass
else:
raise lib_exceptions.Conflict(
_("User '%s' already exists") % username)
raise lib_exceptions.Conflict(_("User '%s' already exists") % username)
user = self.context["request"].user
core_signals.can_create_object.send(
self.__class__, context=user, klass=models.Mailbox)
self.__class__, context=user, klass=models.Mailbox
)
da = core_models.User(username=username, email=username, is_active=True)
password = domain_admin.get("password")
if password is None:
password = param_tools.get_global_parameter(
"default_password", app="core")
password = param_tools.get_global_parameter("default_password", app="core")
da.set_password(password)
da.save()
da.role = "DomainAdmins"
@@ -115,25 +118,28 @@ class DomainSerializer(v1_serializers.DomainSerializer):
if domain_admin["with_mailbox"]:
dom_admin_username = domain_admin["username"]
mb = models.Mailbox(
address=dom_admin_username, domain=domain,
user=da, use_domain_quota=True
address=dom_admin_username,
domain=domain,
user=da,
use_domain_quota=True,
)
mb.set_quota(
override_rules=user.has_perm("admin.change_domain"))
mb.set_quota(override_rules=user.has_perm("admin.change_domain"))
mb.save(creator=user)
# 3. Create aliases if needed
condition = (
domain.type == "domain" and
domain_admin["with_aliases"] and
dom_admin_username != "postmaster"
domain.type == "domain"
and domain_admin["with_aliases"]
and dom_admin_username != "postmaster"
)
if condition:
core_signals.can_create_object.send(
self.__class__, context=user, klass=models.Alias)
address = u"postmaster@{}".format(domain.name)
self.__class__, context=user, klass=models.Alias
)
address = "postmaster@{}".format(domain.name)
alias = models.Alias.objects.create(
address=address, domain=domain, enabled=True)
address=address, domain=domain, enabled=True
)
alias.set_recipients([mb.full_address])
alias.post_create(user)
@@ -162,9 +168,9 @@ class DomainSerializer(v1_serializers.DomainSerializer):
instance.save()
if resources:
for resource in resources:
instance.domainobjectlimit_set.filter(
name=resource["name"]
).update(max_value=resource["max_value"])
instance.domainobjectlimit_set.filter(name=resource["name"]).update(
max_value=resource["max_value"]
)
return instance
@@ -190,16 +196,19 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
enable_dnsbl_checks = serializers.BooleanField(default=True)
dkim_keys_storage_dir = serializers.CharField(allow_blank=True)
dkim_default_key_length = serializers.ChoiceField(
default=2048, choices=constants.DKIM_KEY_LENGTHS)
default=2048, choices=constants.DKIM_KEY_LENGTHS
)
default_domain_quota = serializers.IntegerField(default=0)
default_domain_message_limit = serializers.IntegerField(
required=False, allow_null=True)
required=False, allow_null=True
)
# Mailboxes settings
handle_mailboxes = serializers.BooleanField(default=False)
default_mailbox_quota = serializers.IntegerField(default=0)
default_mailbox_message_limit = serializers.IntegerField(
required=False, allow_null=True)
required=False, allow_null=True
)
auto_account_removal = serializers.BooleanField(default=False)
auto_create_domain_and_mailbox = serializers.BooleanField(default=True)
create_alias_on_mbox_rename = serializers.BooleanField(default=False)
@@ -207,30 +216,22 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
def validate_default_domain_quota(self, value):
"""Ensure quota is a positive integer."""
if value < 0:
raise serializers.ValidationError(
_("Must be a positive integer")
)
raise serializers.ValidationError(_("Must be a positive integer"))
return value
def validate_default_mailbox_quota(self, value):
"""Ensure quota is a positive integer."""
if value < 0:
raise serializers.ValidationError(
_("Must be a positive integer")
)
raise serializers.ValidationError(_("Must be a positive integer"))
return value
def validate_dkim_keys_storage_dir(self, value):
"""Check that directory exists."""
if value:
if not os.path.isdir(value):
raise serializers.ValidationError(
_("Directory not found.")
)
raise serializers.ValidationError(_("Directory not found."))
if not os.access(value, os.W_OK):
raise serializers.ValidationError(
_("Directory non-writable")
)
raise serializers.ValidationError(_("Directory non-writable"))
code, output = exec_cmd("which openssl")
if code:
raise serializers.ValidationError(
@@ -244,8 +245,7 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
return value
try:
ip_addresses = [
ipaddress.ip_network(v.strip())
for v in value.split() if v.strip()
ipaddress.ip_network(v.strip()) for v in value.split() if v.strip()
]
except ValueError:
raise serializers.ValidationError(
@@ -255,11 +255,12 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
def validate_auto_create_domain_and_mailbox(self, value):
"""
Make sure the option does not get deactivated
while imap migration is enabled.
Make sure the option does not get deactivated
while imap migration is enabled.
"""
if not value and param_tools.get_global_parameter("enabled_imapmigration",
"imap_migration"):
if not value and param_tools.get_global_parameter(
"enabled_imapmigration", "imap_migration"
):
raise serializers.ValidationError(
_("Please disable imap migration before disabling this option.")
)
@@ -268,13 +269,14 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
def validate(self, data):
"""Check MX options."""
condition = (
data.get("enable_mx_checks") and
data.get("domains_must_have_authorized_mx") and
not data.get("valid_mxs"))
data.get("enable_mx_checks")
and data.get("domains_must_have_authorized_mx")
and not data.get("valid_mxs")
)
if condition:
raise serializers.ValidationError({
"valid_mxs": _("Define at least one authorized network / address")
})
raise serializers.ValidationError(
{"valid_mxs": _("Define at least one authorized network / address")}
)
if not data.get("enable_mx_checks"):
data["enable_ipv6_mx_checks"] = False
return data
@@ -335,7 +337,8 @@ class IdentitySerializer(serializers.Serializer):
# (not used for now)
return []
actions = admin_signals.extra_account_identities_actions.send(
self.__class__, account=identity)
self.__class__, account=identity
)
cleaned_actions = []
for action in actions:
try:
@@ -358,15 +361,11 @@ class AccountSerializer(v1_serializers.AccountSerializer):
"""Add support for user resources."""
aliases = serializers.ListField(
child=lib_fields.DRFEmailFieldUTF8(),
source="mailbox.alias_addresses"
child=lib_fields.DRFEmailFieldUTF8(), source="mailbox.alias_addresses"
)
class Meta(v1_serializers.AccountSerializer.Meta):
fields = (
v1_serializers.AccountSerializer.Meta.fields
+ ("aliases", )
)
fields = v1_serializers.AccountSerializer.Meta.fields + ("aliases",)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
@@ -375,7 +374,7 @@ class AccountSerializer(v1_serializers.AccountSerializer):
self.fields["resources"] = serializers.SerializerMethodField()
def get_resources(self, account) -> List[AccountResourceSerializer]:
if account.role == 'SimpleUsers':
if account.role == "SimpleUsers":
return []
resources = []
for limit in account.userobjectlimit_set.all():
@@ -395,7 +394,10 @@ class MailboxSerializer(serializers.ModelSerializer):
class Meta:
model = models.Mailbox
fields = (
"pk", "use_domain_quota", "quota", "message_limit",
"pk",
"use_domain_quota",
"quota",
"message_limit",
"is_send_only",
)
@@ -408,9 +410,9 @@ class MailboxSerializer(serializers.ModelSerializer):
method = self.context["request"].method
if not data.get("use_domain_quota", False):
if "quota" not in data and method != "PATCH":
raise serializers.ValidationError({
"quota": _("This field is required")
})
raise serializers.ValidationError(
{"quota": _("This field is required")}
)
return data
@@ -426,8 +428,7 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
"""Add support for aliases and sender addresses."""
aliases = serializers.ListField(
child=lib_fields.DRFEmailFieldUTF8(),
required=False
child=lib_fields.DRFEmailFieldUTF8(), required=False
)
mailbox = MailboxSerializer(required=False)
@@ -449,7 +450,8 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
aliases = []
for alias in value:
localpart, domain = models.validate_alias_address(
alias, self.context["request"].user, ignore_existing=True)
alias, self.context["request"].user, ignore_existing=True
)
aliases.append({"localpart": localpart, "domain": domain})
return aliases
@@ -458,9 +460,9 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
master_user = data.get("master_user", False)
role = data.get("role")
if master_user and role != "SuperAdmins":
raise serializers.ValidationError({
"master_user": _("Not allowed for this role.")
})
raise serializers.ValidationError(
{"master_user": _("Not allowed for this role.")}
)
if role == "SimpleUsers":
username = data.get("username")
if username:
@@ -471,46 +473,43 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
mailbox = data.get("mailbox")
if mailbox is None:
if not self.instance:
data["mailbox"] = {
"use_domain_quota": True
}
data["mailbox"] = {"use_domain_quota": True}
if "mailbox" in data and "username" in data:
self.address, domain_name = email_utils.split_mailbox(data["username"])
self.domain = get_object_or_404(
models.Domain, name=domain_name)
self.domain = get_object_or_404(models.Domain, name=domain_name)
creator = self.context["request"].user
if not creator.can_access(self.domain):
raise serializers.ValidationError({"mailbox": _("Permission denied.")})
if not self.instance:
try:
core_signals.can_create_object.send(
sender=self.__class__, context=creator,
klass=models.Mailbox)
sender=self.__class__, context=creator, klass=models.Mailbox
)
core_signals.can_create_object.send(
sender=self.__class__, context=self.domain,
object_type="mailboxes")
sender=self.__class__,
context=self.domain,
object_type="mailboxes",
)
except lib_exceptions.ModoboaException as inst:
raise serializers.ValidationError({
"mailbox": str(inst)
})
raise serializers.ValidationError({"mailbox": str(inst)})
if data.get("password") or not self.partial:
password = data.get("password")
if password:
try:
password_validation.validate_password(
data["password"], self.instance)
data["password"], self.instance
)
except ValidationError as exc:
raise serializers.ValidationError({
"password": exc.messages[0]})
raise serializers.ValidationError({"password": exc.messages[0]})
elif not self.instance:
raise serializers.ValidationError({
"password": _("This field is required.")
})
raise serializers.ValidationError(
{"password": _("This field is required.")}
)
aliases = data.get("aliases")
if aliases and "mailbox" not in data:
raise serializers.ValidationError({
"aliases": _("A mailbox is required to create aliases.")
})
raise serializers.ValidationError(
{"aliases": _("A mailbox is required to create aliases.")}
)
domain_names = data.get("domains")
if not domain_names:
return data
@@ -520,9 +519,9 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
if domain:
domains.append(domain)
continue
raise serializers.ValidationError({
"domains": _("Local domain {} does not exist").format(name)
})
raise serializers.ValidationError(
{"domains": _("Local domain {} does not exist").format(name)}
)
data["domains"] = domains
return data
@@ -550,8 +549,8 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
address="{}@{}".format(alias["localpart"], alias["domain"]),
recipients=[user.username],
creator=creator,
domain=alias["domain"]
)
domain=alias["domain"],
)
return user
def update(self, instance, validated_data):
@@ -584,7 +583,7 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
address=address,
recipients=[validated_data["username"]],
creator=creator,
domain=alias["domain"]
domain=alias["domain"],
)
try:
alias_recipients.remove(address)
@@ -592,18 +591,17 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
continue
for alias_address in alias_recipients:
alias = models.Alias.objects.filter(
address=alias_address, internal=False)
address=alias_address, internal=False
)
if alias.exists():
alias.first().remove_recipient_or_delete(
validated_data["username"]
)
alias.first().remove_recipient_or_delete(validated_data["username"])
instance.save()
resources = validated_data.get("resources")
if resources:
for resource in resources:
instance.userobjectlimit_set.filter(
name=resource["name"]
).update(max_value=resource["max_value"])
instance.userobjectlimit_set.filter(name=resource["name"]).update(
max_value=resource["max_value"]
)
self.set_permissions(instance, domains)
return instance
+75 -114
View File
@@ -19,7 +19,8 @@ class DomainViewSetTestCase(ModoAPITestCase):
super().setUpTestData()
factories.populate_database()
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_create(self):
url = reverse("v2:domain-list")
@@ -28,8 +29,8 @@ class DomainViewSetTestCase(ModoAPITestCase):
"domain_admin": {
"username": "admin",
"with_mailbox": True,
"with_aliases": True
}
"with_aliases": True,
},
}
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 201)
@@ -39,8 +40,7 @@ class DomainViewSetTestCase(ModoAPITestCase):
admin = dom.admins.first()
self.assertTrue(hasattr(admin, "mailbox"))
self.assertTrue(
models.Alias.objects.filter(
address="postmaster@domain.tld").exists()
models.Alias.objects.filter(address="postmaster@domain.tld").exists()
)
def test_update(self):
@@ -50,11 +50,8 @@ class DomainViewSetTestCase(ModoAPITestCase):
"type": "relaydomain",
"transport": {
"service": "relay",
"settings": {
"relay_target_port": 25,
"relay_target_host": "localhost"
}
}
"settings": {"relay_target_port": 25, "relay_target_host": "localhost"},
},
}
url = reverse("v2:domain-detail", args=[domain.pk])
resp = self.client.put(url, data, format="json")
@@ -63,7 +60,7 @@ class DomainViewSetTestCase(ModoAPITestCase):
self.assertEqual(domain.transport.service, data["transport"]["service"])
self.assertEqual(
domain.transport._settings["relay_target_host"],
data["transport"]["settings"]["relay_target_host"]
data["transport"]["settings"]["relay_target_host"],
)
data["transport"]["relay_verify_recipients"] = True
@@ -75,9 +72,7 @@ class DomainViewSetTestCase(ModoAPITestCase):
domain = models.Domain.objects.get(name="test2.com")
data = {
"name": "test2.com",
"resources": [
{"name": "domain_aliases", "max_value": 20}
]
"resources": [{"name": "domain_aliases", "max_value": 20}],
}
url = reverse("v2:domain-detail", args=[domain.pk])
resp = self.client.put(url, data, format="json")
@@ -87,8 +82,7 @@ class DomainViewSetTestCase(ModoAPITestCase):
)
def test_delete(self):
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
domain = models.Domain.objects.get(name="test2.com")
url = reverse("v2:domain-delete", args=[domain.pk])
@@ -129,15 +123,14 @@ class DomainViewSetTestCase(ModoAPITestCase):
self.assertEqual(resp.status_code, 200)
def test_domains_import(self):
f = ContentFile(b"""domain; domain1.com; 1000; 100; True
f = ContentFile(
b"""domain; domain1.com; 1000; 100; True
domain; domain2.com; 1000; 200; False
domainalias; domalias1.com; domain1.com; True
""", name="domains.csv")
self.client.post(
reverse("v2:domain-import-from-csv"), {
"sourcefile": f
}
""",
name="domains.csv",
)
self.client.post(reverse("v2:domain-import-from-csv"), {"sourcefile": f})
admin = core_models.User.objects.get(username="admin")
dom = models.Domain.objects.get(name="domain1.com")
self.assertEqual(dom.quota, 1000)
@@ -164,8 +157,7 @@ domainalias; domalias1.com; domain1.com; True
"domain,test2.com,0,0,True",
]
self.assertCountEqual(
expected_response,
force_str(response.content.strip()).split("\r\n")
expected_response, force_str(response.content.strip()).split("\r\n")
)
@@ -182,19 +174,14 @@ class AccountViewSetTestCase(ModoAPITestCase):
data = {
"username": "toto@test.com",
"role": "SimpleUsers",
"mailbox": {
"use_domain_quota": True
},
"mailbox": {"use_domain_quota": True},
"password": "Toto12345",
"language": "fr",
"aliases": ["alias3@test.com"]
"aliases": ["alias3@test.com"],
}
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 201)
self.assertTrue(
models.Alias.objects.filter(
address="alias3@test.com").exists()
)
self.assertTrue(models.Alias.objects.filter(address="alias3@test.com").exists())
def test_create_admin(self):
url = reverse("v2:account-list")
@@ -203,7 +190,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
"role": "SuperAdmins",
"password": "Toto12345",
"language": "fr",
"aliases": ["alias3@test.com"]
"aliases": ["alias3@test.com"],
}
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 400)
@@ -251,12 +238,8 @@ class AccountViewSetTestCase(ModoAPITestCase):
"username": "user@test.com",
"role": "SimpleUsers",
"password": "Toto12345",
"mailbox": {
"quota": 10
},
"aliases": [
"aliasupdate1@test.com"
]
"mailbox": {"quota": 10},
"aliases": ["aliasupdate1@test.com"],
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -271,7 +254,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
"mailbox": {
"message_limit": 10,
"is_send_only": True,
}
},
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -283,9 +266,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
"username": "user@test.com",
"role": "SimpleUsers",
"password": "Toto12345",
"mailbox": {
"quota": 10
}
"mailbox": {"quota": 10},
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -299,7 +280,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
"mailbox": {
"message_limit": None,
"is_send_only": False,
}
},
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -314,29 +295,24 @@ class AccountViewSetTestCase(ModoAPITestCase):
"username": "user@test.com",
"role": "SimpleUsers",
"password": "Toto12345",
"mailbox": {
"quota": 10
},
"aliases": [
"aliasupdate1@test.com"
]
"mailbox": {"quota": 10},
"aliases": ["aliasupdate1@test.com"],
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
self.assertTrue(
models.Alias.objects.filter(address="aliasupdate1@test.com").exists())
models.Alias.objects.filter(address="aliasupdate1@test.com").exists()
)
# Create an alias for another user
url = reverse("v2:account-list")
data = {
"username": "toto@test.com",
"role": "SimpleUsers",
"mailbox": {
"use_domain_quota": True
},
"mailbox": {"use_domain_quota": True},
"password": "Toto12345",
"language": "fr",
"aliases": ["totoalias@test.com"]
"aliases": ["totoalias@test.com"],
}
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 201)
@@ -347,13 +323,11 @@ class AccountViewSetTestCase(ModoAPITestCase):
"username": "user@test.com",
"role": "SimpleUsers",
"password": "Toto12345",
"mailbox": {
"quota": 10
},
"mailbox": {"quota": 10},
"aliases": [
"totoalias@test.com",
"aliasupdate1@test.com",
]
],
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -367,17 +341,16 @@ class AccountViewSetTestCase(ModoAPITestCase):
data = {
"username": "user@test.com",
"role": "SimpleUsers",
"mailbox": {
"quota": 10
},
"aliases": []
"mailbox": {"quota": 10},
"aliases": [],
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
self.assertFalse(
models.Alias.objects.filter(address="aliasupdate1@test.com").exists())
alias_recipients = list(models.Alias.objects.filter(
address="totoalias@test.com").first().recipients
models.Alias.objects.filter(address="aliasupdate1@test.com").exists()
)
alias_recipients = list(
models.Alias.objects.filter(address="totoalias@test.com").first().recipients
)
self.assertEqual(alias_recipients, ["toto@test.com"])
@@ -388,9 +361,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
"username": "superadmin@test.com",
"role": "SuperAdmins",
"password": "Toto12345",
"mailbox": {
"quota": 10
}
"mailbox": {"quota": 10},
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -405,7 +376,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
data = {
"resources": [
{"name": "mailboxes", "max_value": 10},
{"name": "mailbox_aliases", "max_value": 10}
{"name": "mailbox_aliases", "max_value": 10},
]
}
resp = self.client.patch(url, data, format="json")
@@ -436,17 +407,20 @@ class IdentityViewSetTestCase(ModoAPITestCase):
self.assertEqual(len(resp.json()), 8)
def test_import(self):
f = ContentFile("""
f = ContentFile(
"""
account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com; 0
account; Truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; 5; test.com
alias; alias1@test.com; True; user1@test.com
forward; alias2@test.com; True; user1+ext@test.com
forward; fwd1@test.com; True; user@extdomain.com
dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
""", name="identities.csv") # NOQA:E501
""",
name="identities.csv",
) # NOQA:E501
self.client.post(
reverse("v2:identities-import-from-csv"),
{"sourcefile": f, "crypt_password": True}
{"sourcefile": f, "crypt_password": True},
)
admin = core_models.User.objects.get(username="admin")
u1 = core_models.User.objects.get(username="user1@test.com")
@@ -461,13 +435,11 @@ dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
self.assertEqual(mb1.quota, 0)
self.assertTrue(admin.is_owner(mb1))
self.assertEqual(mb1.full_address, "user1@test.com")
self.assertTrue(
self.client.login(username="user1@test.com", password="toto")
)
self.assertTrue(self.client.login(username="user1@test.com", password="toto"))
da = core_models.User.objects.get(username="truc@test.com")
damb = da.mailbox
self.assertEqual(da.first_name, u"René")
self.assertEqual(da.first_name, "René")
self.assertEqual(da.role, "DomainAdmins")
self.assertEqual(damb.quota, 5)
self.assertFalse(damb.use_domain_quota)
@@ -478,30 +450,23 @@ dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
self.assertTrue(da.can_access(u))
al = models.Alias.objects.get(address="alias1@test.com")
self.assertTrue(
al.aliasrecipient_set
.filter(r_mailbox=u1.mailbox).exists()
)
self.assertTrue(al.aliasrecipient_set.filter(r_mailbox=u1.mailbox).exists())
self.assertTrue(admin.is_owner(al))
fwd = models.Alias.objects.get(address="fwd1@test.com")
self.assertTrue(
fwd.aliasrecipient_set
.filter(
address="user@extdomain.com", r_mailbox__isnull=True,
r_alias__isnull=True)
.exists()
fwd.aliasrecipient_set.filter(
address="user@extdomain.com",
r_mailbox__isnull=True,
r_alias__isnull=True,
).exists()
)
self.assertTrue(admin.is_owner(fwd))
dlist = models.Alias.objects.get(address="dlist@test.com")
self.assertTrue(dlist.aliasrecipient_set.filter(r_mailbox=u1.mailbox).exists())
self.assertTrue(
dlist.aliasrecipient_set
.filter(r_mailbox=u1.mailbox).exists()
)
self.assertTrue(
dlist.aliasrecipient_set.filter(address="user@extdomain.com")
.exists()
dlist.aliasrecipient_set.filter(address="user@extdomain.com").exists()
)
self.assertTrue(admin.is_owner(dlist))
@@ -513,10 +478,7 @@ dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
admin_row = received_content[0].split(",")
admin_row[2] = ""
received_content[0] = ",".join(admin_row)
self.assertCountEqual(
expected_response.strip().split("\r\n"),
received_content
)
self.assertCountEqual(expected_response.strip().split("\r\n"), received_content)
class AliasViewSetTestCase(ModoAPITestCase):
@@ -536,10 +498,7 @@ class AliasViewSetTestCase(ModoAPITestCase):
data = {"address": "alias@test.com"}
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 400)
self.assertEqual(
resp.json()["address"][0],
"This alias already exists"
)
self.assertEqual(resp.json()["address"][0], "This alias already exists")
data = {"address": "alias2@test.com"}
resp = self.client.post(url, data, format="json")
@@ -563,8 +522,7 @@ class UserAccountViewSetTestCase(ModoAPITestCase):
cls.da_token = Token.objects.create(user=cls.da)
def test_forward(self):
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
url = reverse("v2:account-forward")
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
@@ -580,8 +538,7 @@ class UserAccountViewSetTestCase(ModoAPITestCase):
self.assertEqual(resp.status_code, 200)
self.assertEqual(
models.Alias.objects.filter(address=self.da.username).count(),
2
models.Alias.objects.filter(address=self.da.username).count(), 2
)
resp = self.client.get(url)
@@ -592,8 +549,7 @@ class UserAccountViewSetTestCase(ModoAPITestCase):
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 200)
self.assertEqual(
models.Alias.objects.filter(address=self.da.username).count(),
1
models.Alias.objects.filter(address=self.da.username).count(), 1
)
@@ -605,9 +561,11 @@ class AlarmViewSetTestCase(ModoAPITestCase):
super().setUpTestData()
factories.populate_database()
factories.AlarmFactory(
domain__name="test.com", mailbox=None, title="Test alarm")
domain__name="test.com", mailbox=None, title="Test alarm"
)
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_list(self):
url = reverse("v2:alarm-list")
@@ -621,11 +579,11 @@ class AlarmViewSetTestCase(ModoAPITestCase):
domain = models.Domain.objects.get(name="test.com")
# Try performing action on restricted domains
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
domain = models.Domain.objects.get(name="test2.com")
alarm_restricted = models.Alarm.objects.create(
domain=domain, mailbox=None, title="Test alarm 2")
domain=domain, mailbox=None, title="Test alarm 2"
)
alarm_restricted.save()
url = reverse("v2:alarm-switch", args=[alarm_restricted.pk])
resp = self.client.post(url)
@@ -638,7 +596,8 @@ class AlarmViewSetTestCase(ModoAPITestCase):
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.token.key)
alarm = models.Alarm.objects.create(
domain=domain, mailbox=None, title="Test alarm 3")
domain=domain, mailbox=None, title="Test alarm 3"
)
alarm.save()
# Switch status of the alarm to close
@@ -678,9 +637,11 @@ class AlarmViewSetTestCase(ModoAPITestCase):
resp = self.client.delete(f"{url}?ids[]=toto")
self.assertEqual(resp.status_code, 400)
alarm1 = factories.AlarmFactory(
domain__name="test.com", mailbox=None, title="Test alarm")
domain__name="test.com", mailbox=None, title="Test alarm"
)
alarm2 = factories.AlarmFactory(
domain__name="test.com", mailbox=None, title="Test alarm")
domain__name="test.com", mailbox=None, title="Test alarm"
)
resp = self.client.delete(f"{url}?ids[]={alarm1.pk}&ids[]={alarm2.pk}")
self.assertEqual(resp.status_code, 204)
with self.assertRaises(models.Alarm.DoesNotExist):
+7 -9
View File
@@ -9,17 +9,15 @@ from . import viewsets
router = routers.SimpleRouter()
router.register(r"domains", viewsets.DomainViewSet, basename="domain")
router.register(
r"domainaliases", v1_viewsets.DomainAliasViewSet, basename="domain_alias")
r"domainaliases", v1_viewsets.DomainAliasViewSet, basename="domain_alias"
)
router.register(r"accounts", viewsets.AccountViewSet, basename="account")
router.register(r"aliases", viewsets.AliasViewSet, basename="alias")
router.register(
r"senderaddresses", v1_viewsets.SenderAddressViewSet,
basename="sender_address")
router.register(
r"identities", viewsets.IdentityViewSet, basename="identities")
router.register(
r"account", viewsets.UserAccountViewSet, basename="account")
router.register(
r"alarms", viewsets.AlarmViewSet, basename="alarm")
r"senderaddresses", v1_viewsets.SenderAddressViewSet, basename="sender_address"
)
router.register(r"identities", viewsets.IdentityViewSet, basename="identities")
router.register(r"account", viewsets.UserAccountViewSet, basename="account")
router.register(r"alarms", viewsets.AlarmViewSet, basename="alarm")
urlpatterns = router.urls
+88 -88
View File
@@ -7,7 +7,13 @@ from django.contrib.contenttypes.models import ContentType
from django_filters import rest_framework as dj_filters
from drf_spectacular.utils import extend_schema, extend_schema_view
from rest_framework import (
filters, mixins, parsers, permissions, response, status, viewsets
filters,
mixins,
parsers,
permissions,
response,
status,
viewsets,
)
from rest_framework.decorators import action
from rest_framework.exceptions import PermissionDenied
@@ -29,31 +35,32 @@ from . import serializers
@extend_schema_view(
retrieve=extend_schema(
description="Retrieve a particular domain",
summary="Retrieve a particular domain"
summary="Retrieve a particular domain",
),
list=extend_schema(
description="Retrieve a list of domains",
summary="Retrieve a list of domains"
description="Retrieve a list of domains", summary="Retrieve a list of domains"
),
create=extend_schema(
description="Create a new domain",
summary="Create a new domain"
description="Create a new domain", summary="Create a new domain"
),
delete=extend_schema(
description="Delete a particular domain",
summary="Delete a particular domain"
description="Delete a particular domain", summary="Delete a particular domain"
),
)
class DomainViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin,
mixins.ListModelMixin,
mixins.RetrieveModelMixin,
mixins.CreateModelMixin,
mixins.UpdateModelMixin,
viewsets.GenericViewSet):
class DomainViewSet(
GetThrottleViewsetMixin,
lib_viewsets.RevisionModelMixin,
mixins.ListModelMixin,
mixins.RetrieveModelMixin,
mixins.CreateModelMixin,
mixins.UpdateModelMixin,
viewsets.GenericViewSet,
):
"""V2 viewset."""
permission_classes = (
permissions.IsAuthenticated, permissions.DjangoModelPermissions,
permissions.IsAuthenticated,
permissions.DjangoModelPermissions,
)
def get_queryset(self):
@@ -112,8 +119,9 @@ class DomainViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin,
domain.remove_admin(serializer.validated_data["account"])
return response.Response()
@action(methods=["get"], detail=False,
renderer_classes=(lib_renderers.CSVRenderer,))
@action(
methods=["get"], detail=False, renderer_classes=(lib_renderers.CSVRenderer,)
)
def export(self, request, **kwargs):
"""Export domains and aliases to CSV."""
result = []
@@ -121,21 +129,19 @@ class DomainViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin,
result += domain.to_csv_rows()
return response.Response(result)
@extend_schema(
request=serializers.CSVImportSerializer
@extend_schema(request=serializers.CSVImportSerializer)
@action(
methods=["post"],
detail=False,
parser_classes=(parsers.MultiPartParser, parsers.FormParser),
url_path="import",
)
@action(methods=["post"],
detail=False,
parser_classes=(parsers.MultiPartParser, parsers.FormParser),
url_path="import")
def import_from_csv(self, request, **kwargs):
"""Import domains and aliases from CSV file."""
serializer = serializers.CSVImportSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
status, msg = lib.import_data(
request.user,
request.FILES["sourcefile"],
serializer.validated_data
request.user, request.FILES["sourcefile"], serializer.validated_data
)
return response.Response({"status": status, "message": msg})
@@ -144,9 +150,8 @@ class AccountFilterSet(dj_filters.FilterSet):
"""Custom FilterSet for Account."""
domain = dj_filters.ModelChoiceFilter(
queryset=lambda request: models.Domain.objects.get_for_admin(
request.user),
field_name="mailbox__domain"
queryset=lambda request: models.Domain.objects.get_for_admin(request.user),
field_name="mailbox__domain",
)
role = dj_filters.CharFilter(method="filter_role")
@@ -176,23 +181,19 @@ class AccountViewSet(v1_viewsets.AccountViewSet):
def get_queryset(self):
"""Filter queryset based on current user."""
user = self.request.user
ids = (
user.objectaccess_set
.filter(content_type=ContentType.objects.get_for_model(user))
.values_list("object_id", flat=True)
)
return (
core_models.User.objects.filter(pk__in=ids)
.prefetch_related("userobjectlimit_set")
ids = user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(user)
).values_list("object_id", flat=True)
return core_models.User.objects.filter(pk__in=ids).prefetch_related(
"userobjectlimit_set"
)
@action(methods=["post"], detail=False)
def validate(self, request, **kwargs):
"""Validate given account without creating it."""
serializer = self.get_serializer(
data=request.data,
context=self.get_serializer_context(),
partial=True)
data=request.data, context=self.get_serializer_context(), partial=True
)
serializer.is_valid(raise_exception=True)
return response.Response(status=204)
@@ -215,17 +216,19 @@ class AccountViewSet(v1_viewsets.AccountViewSet):
class IdentityViewSet(GetThrottleViewsetMixin, viewsets.ViewSet):
"""Viewset for identities."""
permission_classes = (permissions.IsAuthenticated, )
permission_classes = (permissions.IsAuthenticated,)
serializer_class = None
def list(self, request, **kwargs):
"""Return all identities."""
serializer = serializers.IdentitySerializer(
lib.get_identities(request.user), many=True)
lib.get_identities(request.user), many=True
)
return response.Response(serializer.data)
@action(methods=["get"], detail=False,
renderer_classes=(lib_renderers.CSVRenderer,))
@action(
methods=["get"], detail=False, renderer_classes=(lib_renderers.CSVRenderer,)
)
def export(self, request, **kwargs):
"""Export accounts and aliases to CSV."""
result = []
@@ -233,21 +236,19 @@ class IdentityViewSet(GetThrottleViewsetMixin, viewsets.ViewSet):
result.append(idt.to_csv_row())
return response.Response(result)
@extend_schema(
request=serializers.CSVIdentityImportSerializer
@extend_schema(request=serializers.CSVIdentityImportSerializer)
@action(
methods=["post"],
detail=False,
parser_classes=(parsers.MultiPartParser, parsers.FormParser),
url_path="import",
)
@action(methods=["post"],
detail=False,
parser_classes=(parsers.MultiPartParser, parsers.FormParser),
url_path="import")
def import_from_csv(self, request, **kwargs):
"""Import accounts and aliases from CSV file."""
serializer = serializers.CSVIdentityImportSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
status, msg = lib.import_data(
request.user,
request.FILES["sourcefile"],
serializer.validated_data
request.user, request.FILES["sourcefile"], serializer.validated_data
)
return response.Response({"status": status, "message": msg})
@@ -261,23 +262,20 @@ class AliasViewSet(v1_viewsets.AliasViewSet):
def validate(self, request, **kwargs):
"""Validate given alias without creating it."""
serializer = self.get_serializer(
data=request.data,
context=self.get_serializer_context(),
partial=True)
data=request.data, context=self.get_serializer_context(), partial=True
)
try:
serializer.is_valid(raise_exception=True)
except AliasExists as e:
return response.Response(
data={"id": e.alias_id, "status": _("This alias already exists")},
status=409
)
status=409,
)
return response.Response(status=204)
@action(methods=["get"], detail=False)
def random_address(self, request, **kwargs):
return response.Response({
"address": models.Alias.generate_random_address()
})
return response.Response({"address": models.Alias.generate_random_address()})
class UserAccountViewSet(GetThrottleViewsetMixin, viewsets.ViewSet):
@@ -288,7 +286,8 @@ class UserAccountViewSet(GetThrottleViewsetMixin, viewsets.ViewSet):
"""Get or define user forward."""
mb = request.user.mailbox
alias = models.Alias.objects.filter(
address=mb.full_address, internal=False).first()
address=mb.full_address, internal=False
).first()
data = {}
if request.method == "GET":
if alias is not None and alias.recipients:
@@ -304,17 +303,16 @@ class UserAccountViewSet(GetThrottleViewsetMixin, viewsets.ViewSet):
recipients = serializer.validated_data.get("recipients")
if not recipients:
models.Alias.objects.filter(
address=mb.full_address, internal=False).delete()
address=mb.full_address, internal=False
).delete()
# Make sure internal self-alias is enabled
models.Alias.objects.filter(
address=mb.full_address, internal=True
).update(enabled=True)
models.Alias.objects.filter(address=mb.full_address, internal=True).update(
enabled=True
)
else:
if alias is None:
alias = models.Alias.objects.create(
address=mb.full_address,
domain=mb.domain,
enabled=mb.user.is_active
address=mb.full_address, domain=mb.domain, enabled=mb.user.is_active
)
alias.post_create(request.user)
if serializer.validated_data["keepcopies"]:
@@ -346,32 +344,35 @@ class AlarmFilterSet(dj_filters.FilterSet):
return queryset.filter(created__gt=value)
class AlarmViewSet(GetThrottleViewsetMixin,
mixins.DestroyModelMixin,
mixins.ListModelMixin,
mixins.RetrieveModelMixin,
viewsets.GenericViewSet):
class AlarmViewSet(
GetThrottleViewsetMixin,
mixins.DestroyModelMixin,
mixins.ListModelMixin,
mixins.RetrieveModelMixin,
viewsets.GenericViewSet,
):
"""Viewset for Alarm."""
filter_backends = (filters.OrderingFilter,
filters.SearchFilter,
dj_filters.DjangoFilterBackend)
filter_backends = (
filters.OrderingFilter,
filters.SearchFilter,
dj_filters.DjangoFilterBackend,
)
filterset_class = AlarmFilterSet
ordering_fields = ["created", "status", "title"]
pagination_class = pagination.CustomPageNumberPagination
permission_classes = (
permissions.IsAuthenticated,
)
permission_classes = (permissions.IsAuthenticated,)
search_fields = ["domain__name", "title"]
serializer_class = serializers.AlarmSerializer
def get_queryset(self):
return models.Alarm.objects.select_related("domain").filter(
domain__in=models.Domain.objects.get_for_admin(
self.request.user)
).order_by("-created")
return (
models.Alarm.objects.select_related("domain")
.filter(domain__in=models.Domain.objects.get_for_admin(self.request.user))
.order_by("-created")
)
@action(methods=['patch'], detail=True)
@action(methods=["patch"], detail=True)
def switch(self, request, **kwargs):
"""Custom update method that switch status of an alarm."""
alarm = self.get_object()
@@ -383,7 +384,7 @@ class AlarmViewSet(GetThrottleViewsetMixin,
alarm.reopen()
return response.Response(status=status.HTTP_204_NO_CONTENT)
@action(methods=['delete'], detail=False)
@action(methods=["delete"], detail=False)
def bulk_delete(self, request, **kwargs):
"""Delete multiple alarms at the same time."""
ids = request.query_params.getlist("ids[]")
@@ -392,7 +393,6 @@ class AlarmViewSet(GetThrottleViewsetMixin,
try:
ids = [int(alarm_id) for alarm_id in ids]
except ValueError:
return response.Response(
_("Received invalid alarm id(s)"), status=400)
return response.Response(_("Received invalid alarm id(s)"), status=400)
models.Alarm.objects.filter(pk__in=ids).delete()
return response.Response(status=204)
+274 -217
View File
@@ -25,9 +25,7 @@ class AdminParametersForm(param_forms.AdminParametersForm):
enable_mx_checks = YesNoField(
label=gettext_lazy("Enable MX checks"),
initial=True,
help_text=gettext_lazy(
"Check that every domain has a valid MX record"
)
help_text=gettext_lazy("Check that every domain has a valid MX record"),
)
valid_mxs = forms.CharField(
@@ -38,7 +36,7 @@ class AdminParametersForm(param_forms.AdminParametersForm):
" A warning will be sent if a record does not respect it."
),
widget=forms.Textarea,
required=False
required=False,
)
domains_must_have_authorized_mx = YesNoField(
@@ -47,40 +45,33 @@ class AdminParametersForm(param_forms.AdminParametersForm):
help_text=gettext_lazy(
"Prevent the creation of a new domain if its MX record does "
"not use one of the defined addresses."
)
),
)
enable_ipv6_mx_checks = YesNoField(
label=gettext_lazy("Enable IPV6 checks"),
initial=True,
help_text=gettext_lazy(
"Check if MX setup for ipv6 is valid"
)
help_text=gettext_lazy("Check if MX setup for ipv6 is valid"),
)
enable_spf_checks = YesNoField(
label=gettext_lazy("Enable SPF checks"),
initial=True,
help_text=gettext_lazy(
"Check if every domain has a valid SPF record"
)
help_text=gettext_lazy("Check if every domain has a valid SPF record"),
)
enable_dkim_checks = YesNoField(
label=gettext_lazy("Enable DKIM checks"),
initial=True,
help_text=gettext_lazy(
"Check if every domain with DKIM signin enabled has a valid DNS "
"record"
)
"Check if every domain with DKIM signin enabled has a valid DNS " "record"
),
)
enable_dmarc_checks = YesNoField(
label=gettext_lazy("Enable DMARC checks"),
initial=True,
help_text=gettext_lazy(
"Check if every domain has a valid DMARC record"
)
help_text=gettext_lazy("Check if every domain has a valid DMARC record"),
)
enable_autoconfig_checks = YesNoField(
@@ -88,15 +79,13 @@ class AdminParametersForm(param_forms.AdminParametersForm):
initial=True,
help_text=gettext_lazy(
"Check if every domain has a valid records for autoconfiguration"
)
),
)
enable_dnsbl_checks = YesNoField(
label=gettext_lazy("Enable DNSBL checks"),
initial=True,
help_text=gettext_lazy(
"Check every domain against major DNSBL providers"
)
help_text=gettext_lazy("Check every domain against major DNSBL providers"),
)
custom_dns_server = GenericIPAddressField(
@@ -105,7 +94,7 @@ class AdminParametersForm(param_forms.AdminParametersForm):
initial="",
help_text=gettext_lazy(
"Use a custom DNS server instead of local server configuration"
)
),
)
dkim_keys_storage_dir = forms.CharField(
@@ -116,16 +105,14 @@ class AdminParametersForm(param_forms.AdminParametersForm):
"be stored. Make sure this directory belongs to root user "
"and is not readable by the outside world."
),
required=False
required=False,
)
dkim_default_key_length = forms.ChoiceField(
label=gettext_lazy("Default DKIM key length"),
initial=2048,
choices=constants.DKIM_KEY_LENGTHS,
help_text=gettext_lazy(
"Default length in bits for newly generated DKIM keys."
)
help_text=gettext_lazy("Default length in bits for newly generated DKIM keys."),
)
default_domain_quota = forms.IntegerField(
@@ -134,7 +121,7 @@ class AdminParametersForm(param_forms.AdminParametersForm):
help_text=gettext_lazy(
"Default quota (in MB) applied to freshly created domains with no "
"value specified. A value of 0 means no quota."
)
),
)
default_domain_message_limit = forms.IntegerField(
@@ -143,7 +130,7 @@ class AdminParametersForm(param_forms.AdminParametersForm):
help_text=gettext_lazy(
"Number of messages freshly created domains will be "
"allowed to send per day. Leave empty for no limit."
)
),
)
mbsep = SeparatorField(label=gettext_lazy("Mailboxes"))
@@ -154,7 +141,7 @@ class AdminParametersForm(param_forms.AdminParametersForm):
help_text=gettext_lazy(
"Rename or remove mailboxes on the filesystem when they get"
" renamed or removed within Modoboa"
)
),
)
default_mailbox_quota = forms.IntegerField(
@@ -163,7 +150,7 @@ class AdminParametersForm(param_forms.AdminParametersForm):
help_text=gettext_lazy(
"Default mailbox quota (in MB) applied to freshly created "
"mailboxes with no value specified. A value of 0 means no quota."
)
),
)
default_mailbox_message_limit = forms.IntegerField(
@@ -172,23 +159,23 @@ class AdminParametersForm(param_forms.AdminParametersForm):
help_text=gettext_lazy(
"Number of messages freshly created mailboxes will be "
"allowed to send per day. Leave empty for no limit."
)
),
)
auto_account_removal = YesNoField(
label=gettext_lazy("Automatic account removal"),
initial=False,
help_text=gettext_lazy(
"When a mailbox is removed, also remove the associated account")
"When a mailbox is removed, also remove the associated account"
),
)
auto_create_domain_and_mailbox = YesNoField(
label=gettext_lazy("Automatic domain/mailbox creation"),
initial=True,
help_text=gettext_lazy(
"Create a domain and a mailbox when an account is automatically "
"created."
)
"Create a domain and a mailbox when an account is automatically " "created."
),
)
create_alias_on_mbox_rename = YesNoField(
@@ -196,22 +183,19 @@ class AdminParametersForm(param_forms.AdminParametersForm):
initial=False,
help_text=gettext_lazy(
"Create an alias using the old address when a mailbox is renamed."
)
),
)
# Visibility rules
visibility_rules = {
"valid_mxs": "enable_mx_checks=True",
"domains_must_have_authorized_mx": "enable_mx_checks=True",
"enable_ipv6_mx_checks": "enable_mx_checks=True"
"enable_ipv6_mx_checks": "enable_mx_checks=True",
}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.field_widths = {
"default_domain_quota": 2,
"default_mailbox_quota": 2
}
self.field_widths = {"default_domain_quota": 2, "default_mailbox_quota": 2}
hide_fields = False
dpath = None
code, output = exec_cmd("which dovecot")
@@ -219,8 +203,9 @@ class AdminParametersForm(param_forms.AdminParametersForm):
dpath = force_str(output).strip()
else:
known_paths = getattr(
settings, "DOVECOT_LOOKUP_PATH",
("/usr/sbin/dovecot", "/usr/local/sbin/dovecot")
settings,
"DOVECOT_LOOKUP_PATH",
("/usr/sbin/dovecot", "/usr/local/sbin/dovecot"),
)
for fpath in known_paths:
if os.path.isfile(fpath) and os.access(fpath, os.X_OK):
@@ -242,17 +227,13 @@ class AdminParametersForm(param_forms.AdminParametersForm):
def clean_default_domain_quota(self):
"""Ensure quota is a positive integer."""
if self.cleaned_data["default_domain_quota"] < 0:
raise forms.ValidationError(
gettext_lazy("Must be a positive integer")
)
raise forms.ValidationError(gettext_lazy("Must be a positive integer"))
return self.cleaned_data["default_domain_quota"]
def clean_default_mailbox_quota(self):
"""Ensure quota is a positive integer."""
if self.cleaned_data["default_mailbox_quota"] < 0:
raise forms.ValidationError(
gettext_lazy("Must be a positive integer")
)
raise forms.ValidationError(gettext_lazy("Must be a positive integer"))
return self.cleaned_data["default_mailbox_quota"]
def clean_dkim_keys_storage_dir(self):
@@ -260,14 +241,11 @@ class AdminParametersForm(param_forms.AdminParametersForm):
storage_dir = self.cleaned_data.get("dkim_keys_storage_dir", "")
if storage_dir:
if not os.path.isdir(storage_dir):
raise forms.ValidationError(
gettext_lazy("Directory not found.")
)
raise forms.ValidationError(gettext_lazy("Directory not found."))
code, output = exec_cmd("which openssl")
if code:
raise forms.ValidationError(
gettext_lazy(
"openssl not found, please make sure it is installed.")
gettext_lazy("openssl not found, please make sure it is installed.")
)
return storage_dir
@@ -278,14 +256,11 @@ class AdminParametersForm(param_forms.AdminParametersForm):
return value
try:
ip_addresses = [
ipaddress.ip_network(v.strip())
for v in value.split() if v.strip()
ipaddress.ip_network(v.strip()) for v in value.split() if v.strip()
]
except ValueError:
raise forms.ValidationError(
gettext_lazy(
"This field only allows valid IP addresses (or networks)"
)
gettext_lazy("This field only allows valid IP addresses (or networks)")
)
return value
@@ -293,171 +268,249 @@ class AdminParametersForm(param_forms.AdminParametersForm):
"""Check MX options."""
cleaned_data = super(AdminParametersForm, self).clean()
condition = (
cleaned_data.get("enable_mx_checks") and
cleaned_data.get("domains_must_have_authorized_mx") and
not cleaned_data.get("valid_mxs"))
cleaned_data.get("enable_mx_checks")
and cleaned_data.get("domains_must_have_authorized_mx")
and not cleaned_data.get("valid_mxs")
)
if condition:
self.add_error(
"valid_mxs",
_("Define at least one authorized network / address")
"valid_mxs", _("Define at least one authorized network / address")
)
if not cleaned_data.get("enable_mx_checks"):
cleaned_data["enable_ipv6_mx_checks"] = False
return cleaned_data
GLOBAL_PARAMETERS_STRUCT = collections.OrderedDict([
("domains", {
"label": gettext_lazy("Domains"),
"params": collections.OrderedDict([
("enable_mx_checks", {
"label": gettext_lazy("Enable MX checks"),
"help_text": gettext_lazy(
"Check that every domain has a valid MX record"
)
}),
("valid_mxs", {
"label": gettext_lazy("Valid MXs"),
"display": "enable_mx_checks=true",
"help_text": gettext_lazy(
"A list of IP or network address every MX record should "
"match. A warning will be sent if a record does not "
"respect it."
GLOBAL_PARAMETERS_STRUCT = collections.OrderedDict(
[
(
"domains",
{
"label": gettext_lazy("Domains"),
"params": collections.OrderedDict(
[
(
"enable_mx_checks",
{
"label": gettext_lazy("Enable MX checks"),
"help_text": gettext_lazy(
"Check that every domain has a valid MX record"
),
},
),
(
"valid_mxs",
{
"label": gettext_lazy("Valid MXs"),
"display": "enable_mx_checks=true",
"help_text": gettext_lazy(
"A list of IP or network address every MX record should "
"match. A warning will be sent if a record does not "
"respect it."
),
},
),
(
"domains_must_have_authorized_mx",
{
"label": gettext_lazy(
"New domains must use authorized MX(s)"
),
"display": "enable_mx_checks=true",
"help_text": gettext_lazy(
"Prevent the creation of a new domain if its MX record "
"does not use one of the defined addresses."
),
},
),
(
"enable_ipv6_mx_checks",
{
"label": gettext_lazy("Enable IPV6 checks"),
"display": "enable_mx_checks=true",
"help_text": gettext_lazy(
"Check if MX setup for ipv6 is valid"
),
},
),
(
"enable_spf_checks",
{
"label": gettext_lazy("Enable SPF checks"),
"help_text": gettext_lazy(
"Check if every domain has a valid SPF record"
),
},
),
(
"enable_dkim_checks",
{
"label": gettext_lazy("Enable DKIM checks"),
"help_text": gettext_lazy(
"Check if every domain with DKIM signin enabled "
"has a valid DNS record"
),
},
),
(
"enable_dmarc_checks",
{
"label": gettext_lazy("Enable DMARC checks"),
"help_text": gettext_lazy(
"Check if every domain has a valid DMARC record"
),
},
),
(
"enable_autoconfig_checks",
{
"label": gettext_lazy("Enable autoconfig checks"),
"help_text": gettext_lazy(
"Check if every domain has a valid records for "
"autoconfiguration"
),
},
),
(
"enable_dnsbl_checks",
{
"label": gettext_lazy("Enable DNSBL checks"),
"help_text": gettext_lazy(
"Check every domain against major DNSBL providers"
),
},
),
(
"custom_dns_server",
{
"label": gettext_lazy("Custom DNS server"),
"help_text": gettext_lazy(
"Use a custom DNS server instead of local server "
"configuration"
),
},
),
(
"dkim_keys_storage_dir",
{
"label": gettext_lazy("DKIM keys storage directory"),
"help_text": gettext_lazy(
"Absolute path of the directory where DKIM private keys "
"will be stored. Make sure this directory belongs to root "
"user and is not readable by the outside world."
),
},
),
(
"dkim_default_key_length",
{
"label": gettext_lazy("Default DKIM key length"),
"help_text": gettext_lazy(
"Default length in bits for newly generated DKIM keys."
),
},
),
(
"default_domain_quota",
{
"label": gettext_lazy("Default domain quota"),
"help_text": gettext_lazy(
"Default quota (in MB) applied to freshly created domains "
"with no value specified. A value of 0 means no quota."
),
},
),
(
"default_domain_message_limit",
{
"label": gettext_lazy("Default domain sending limit"),
"help_text": gettext_lazy(
"Number of messages freshly created domains will be "
"allowed to send per day. Leave empty for no limit."
),
},
),
]
),
}),
("domains_must_have_authorized_mx", {
"label": gettext_lazy("New domains must use authorized MX(s)"),
"display": "enable_mx_checks=true",
"help_text": gettext_lazy(
"Prevent the creation of a new domain if its MX record "
"does not use one of the defined addresses."
)
}),
("enable_ipv6_mx_checks", {
"label": gettext_lazy("Enable IPV6 checks"),
"display": "enable_mx_checks=true",
"help_text": gettext_lazy(
"Check if MX setup for ipv6 is valid"
)
}),
("enable_spf_checks", {
"label": gettext_lazy("Enable SPF checks"),
"help_text": gettext_lazy(
"Check if every domain has a valid SPF record"
)
}),
("enable_dkim_checks", {
"label": gettext_lazy("Enable DKIM checks"),
"help_text": gettext_lazy(
"Check if every domain with DKIM signin enabled "
"has a valid DNS record"
)
}),
("enable_dmarc_checks", {
"label": gettext_lazy("Enable DMARC checks"),
"help_text": gettext_lazy(
"Check if every domain has a valid DMARC record"
)
}),
("enable_autoconfig_checks", {
"label": gettext_lazy("Enable autoconfig checks"),
"help_text": gettext_lazy(
"Check if every domain has a valid records for "
"autoconfiguration"
)
}),
("enable_dnsbl_checks", {
"label": gettext_lazy("Enable DNSBL checks"),
"help_text": gettext_lazy(
"Check every domain against major DNSBL providers"
)
}),
("custom_dns_server", {
"label": gettext_lazy("Custom DNS server"),
"help_text": gettext_lazy(
"Use a custom DNS server instead of local server "
"configuration"
)
}),
("dkim_keys_storage_dir", {
"label": gettext_lazy("DKIM keys storage directory"),
"help_text": gettext_lazy(
"Absolute path of the directory where DKIM private keys "
"will be stored. Make sure this directory belongs to root "
"user and is not readable by the outside world."
},
),
(
"mailboxes",
{
"label": gettext_lazy("Mailboxes"),
"params": collections.OrderedDict(
[
(
"handle_mailboxes",
{
"label": gettext_lazy("Handle mailboxes on filesystem"),
"help_text": gettext_lazy(
"Rename or remove mailboxes on the filesystem when they get"
" renamed or removed within Modoboa"
),
},
),
(
"default_mailbox_quota",
{
"label": gettext_lazy("Default mailbox quota"),
"help_text": gettext_lazy(
"Default mailbox quota (in MB) applied to freshly created "
"domains with no value specified. A value of 0 means no "
"quota."
),
},
),
(
"default_mailbox_message_limit",
{
"label": gettext_lazy("Default mailbox sending limit"),
"help_text": gettext_lazy(
"Number of messages freshly created mailboxes will be "
"allowed to send per day. Leave empty for no limit."
),
},
),
(
"auto_account_removal",
{
"label": gettext_lazy("Automatic account removal"),
"help_text": gettext_lazy(
"When a mailbox is removed, also remove the associated "
"account"
),
},
),
(
"auto_create_domain_and_mailbox",
{
"label": gettext_lazy(
"Automatic domain/mailbox creation"
),
"help_text": gettext_lazy(
"Create a domain and a mailbox when an account is "
"automatically created."
),
},
),
(
"create_alias_on_mbox_rename",
{
"label": gettext_lazy(
"Create an alias when a mailbox is renamed"
),
"help_text": gettext_lazy(
"Create an alias using the old address when a mailbox is "
"renamed."
),
},
),
]
),
}),
("dkim_default_key_length", {
"label": gettext_lazy("Default DKIM key length"),
"help_text": gettext_lazy(
"Default length in bits for newly generated DKIM keys."
)
}),
("default_domain_quota", {
"label": gettext_lazy("Default domain quota"),
"help_text": gettext_lazy(
"Default quota (in MB) applied to freshly created domains "
"with no value specified. A value of 0 means no quota."
)
}),
("default_domain_message_limit", {
"label": gettext_lazy("Default domain sending limit"),
"help_text": gettext_lazy(
"Number of messages freshly created domains will be "
"allowed to send per day. Leave empty for no limit."
)
}),
])
}),
("mailboxes", {
"label": gettext_lazy("Mailboxes"),
"params": collections.OrderedDict([
("handle_mailboxes", {
"label": gettext_lazy("Handle mailboxes on filesystem"),
"help_text": gettext_lazy(
"Rename or remove mailboxes on the filesystem when they get"
" renamed or removed within Modoboa"
)
}),
("default_mailbox_quota", {
"label": gettext_lazy("Default mailbox quota"),
"help_text": gettext_lazy(
"Default mailbox quota (in MB) applied to freshly created "
"domains with no value specified. A value of 0 means no "
"quota."
)
}),
("default_mailbox_message_limit", {
"label": gettext_lazy("Default mailbox sending limit"),
"help_text": gettext_lazy(
"Number of messages freshly created mailboxes will be "
"allowed to send per day. Leave empty for no limit."
)
}),
("auto_account_removal", {
"label": gettext_lazy("Automatic account removal"),
"help_text": gettext_lazy(
"When a mailbox is removed, also remove the associated "
"account")
}),
("auto_create_domain_and_mailbox", {
"label": gettext_lazy("Automatic domain/mailbox creation"),
"help_text": gettext_lazy(
"Create a domain and a mailbox when an account is "
"automatically created."
)
}),
("create_alias_on_mbox_rename", {
"label": gettext_lazy(
"Create an alias when a mailbox is renamed"),
"help_text": gettext_lazy(
"Create an alias using the old address when a mailbox is "
"renamed."
)
})
])
}),
])
},
),
]
)
def load_admin_settings():
@@ -466,8 +519,12 @@ def load_admin_settings():
from .api.v2 import serializers
param_tools.registry.add(
"global", AdminParametersForm, gettext_lazy("Administration"))
"global", AdminParametersForm, gettext_lazy("Administration")
)
param_tools.registry.add2(
"global", "admin", gettext_lazy("Administration"),
"global",
"admin",
gettext_lazy("Administration"),
GLOBAL_PARAMETERS_STRUCT,
serializers.AdminGlobalParametersSerializer)
serializers.AdminGlobalParametersSerializer,
)
+1 -6
View File
@@ -17,12 +17,7 @@ DNSBL_PROVIDERS = [
# Do not run tests for these domains.
# https://en.wikipedia.org/wiki/Top-level_domain#Reserved_domains
RESERVED_TLD = [
"example",
"invalid",
"localhost",
"test"
]
RESERVED_TLD = ["example", "invalid", "localhost", "test"]
DOMAIN_TYPES = [
("domain", _("Domain")),
+12 -26
View File
@@ -9,12 +9,11 @@ from . import models
class DomainFactory(PermissionFactory):
"""Factory to create Domains."""
class Meta:
model = models.Domain
django_get_or_create = ("name", )
django_get_or_create = ("name",)
name = factory.Sequence(lambda n: "domain{}.test".format(n))
type = "domain" # NOQA:A003
@@ -24,19 +23,17 @@ class DomainFactory(PermissionFactory):
class DomainAliasFactory(PermissionFactory):
"""Factory to create DomainAlias objects."""
class Meta:
model = models.DomainAlias
django_get_or_create = ("name", )
django_get_or_create = ("name",)
target = factory.SubFactory(DomainFactory)
enabled = True
class MailboxFactory(PermissionFactory):
"""A factory to create Mailbox instances."""
class Meta:
@@ -98,31 +95,23 @@ def populate_database():
"""
dom = DomainFactory(name="test.com", quota=50)
admin = UserFactory(
username="admin@test.com", groups=("DomainAdmins", ),
password="{PLAIN}toto"
username="admin@test.com", groups=("DomainAdmins",), password="{PLAIN}toto"
)
MailboxFactory(address="admin", domain=dom, user=admin)
account = UserFactory.create(
username="user@test.com", groups=("SimpleUsers",),
username="user@test.com",
groups=("SimpleUsers",),
)
MailboxFactory.create(address="user", domain=dom, user=account)
al = AliasFactory.create(
address="forward@test.com", domain=dom
)
AliasRecipientFactory.create(
address="user@external.com", alias=al)
al = AliasFactory.create(address="forward@test.com", domain=dom)
AliasRecipientFactory.create(address="user@external.com", alias=al)
al = AliasFactory.create(
address="alias@test.com", domain=dom
)
al = AliasFactory.create(address="alias@test.com", domain=dom)
mb = account.mailbox
AliasRecipientFactory.create(
address=mb.full_address, alias=al, r_mailbox=mb)
AliasRecipientFactory.create(address=mb.full_address, alias=al, r_mailbox=mb)
al = AliasFactory.create(
address="postmaster@test.com", domain=dom
)
al = AliasFactory.create(address="postmaster@test.com", domain=dom)
for address in ["toto@titi.com", "test@truc.fr"]:
AliasRecipientFactory.create(address=address, alias=al)
@@ -130,12 +119,9 @@ def populate_database():
dom2 = DomainFactory.create(name="test2.com", default_mailbox_quota=0)
admin = UserFactory.create(
username="admin@test2.com", groups=("DomainAdmins",),
password="{PLAIN}toto"
username="admin@test2.com", groups=("DomainAdmins",), password="{PLAIN}toto"
)
MailboxFactory.create(address="admin", domain=dom2, user=admin)
u = UserFactory.create(
username="user@test2.com", groups=("SimpleUsers",)
)
u = UserFactory.create(username="user@test2.com", groups=("SimpleUsers",))
MailboxFactory.create(address="user", domain=dom2, user=u)
dom2.add_admin(admin)
+19 -9
View File
@@ -1,19 +1,29 @@
from .account import (
AccountForm, AccountFormGeneral, AccountFormMail, AccountPermissionsForm,
AccountWizard
AccountForm,
AccountFormGeneral,
AccountFormMail,
AccountPermissionsForm,
AccountWizard,
)
from .alias import AliasForm
from .domain import (
DomainForm, DomainFormGeneral, DomainFormOptions, DomainWizard
)
from .domain import DomainForm, DomainFormGeneral, DomainFormOptions, DomainWizard
from .export import ExportDataForm
from .forward import ForwardForm
from .import_ import ImportDataForm, ImportIdentitiesForm
__all__ = [
"DomainFormGeneral", "DomainFormOptions", "DomainForm",
"AccountFormGeneral", "AccountFormMail", "AccountPermissionsForm",
"AccountForm", "AliasForm", "ImportDataForm", "ImportIdentitiesForm",
"DomainFormGeneral",
"DomainFormOptions",
"DomainForm",
"AccountFormGeneral",
"AccountFormMail",
"AccountPermissionsForm",
"AccountForm",
"AliasForm",
"ImportDataForm",
"ImportIdentitiesForm",
"ExportDataForm",
"ForwardForm", "DomainWizard", "AccountWizard"
"ForwardForm",
"DomainWizard",
"AccountWizard",
]
+162 -134
View File
@@ -14,9 +14,7 @@ from modoboa.core import signals as core_signals
from modoboa.core.models import User
from modoboa.lib import exceptions as lib_exceptions, fields as lib_fields
from modoboa.lib.email_utils import split_mailbox
from modoboa.lib.form_utils import (
DynamicForm, TabForms, WizardForm, WizardStep
)
from modoboa.lib.form_utils import DynamicForm, TabForms, WizardForm, WizardStep
from modoboa.lib.permissions import get_account_roles
from modoboa.lib.validators import validate_utf8_email
from modoboa.lib.web_utils import render_to_json_response, size2integer
@@ -25,7 +23,6 @@ from .. import lib, models, signals
class AccountFormGeneral(forms.ModelForm):
"""General account form."""
username = forms.CharField(
@@ -33,12 +30,12 @@ class AccountFormGeneral(forms.ModelForm):
help_text=gettext_lazy(
"The user's name. Must be a valid e-mail address for simple users "
"or administrators with a mailbox."
)
),
)
role = forms.ChoiceField(
label=gettext_lazy("Role"),
choices=[("", gettext_lazy("Choose"))],
help_text=gettext_lazy("What level of permission this user will have")
help_text=gettext_lazy("What level of permission this user will have"),
)
random_password = forms.BooleanField(
label=gettext_lazy("Random password"),
@@ -46,55 +43,66 @@ class AccountFormGeneral(forms.ModelForm):
"Generate a random password. If you're updating this account and "
"check this box, a new password will be generated."
),
required=False
required=False,
)
password1 = forms.CharField(
label=gettext_lazy("Password"), widget=forms.widgets.PasswordInput,
required=False
label=gettext_lazy("Password"),
widget=forms.widgets.PasswordInput,
required=False,
)
password2 = forms.CharField(
label=gettext_lazy("Confirmation"),
widget=forms.widgets.PasswordInput,
help_text=gettext_lazy(
"Enter the same password as above, for verification."
),
required=False
help_text=gettext_lazy("Enter the same password as above, for verification."),
required=False,
)
class Meta:
model = User
fields = (
"username", "first_name", "last_name", "role", "is_active",
"username",
"first_name",
"last_name",
"role",
"is_active",
"master_user",
)
labels = {
"is_active": gettext_lazy("Enabled")
}
labels = {"is_active": gettext_lazy("Enabled")}
def __init__(self, user, *args, **kwargs):
super(AccountFormGeneral, self).__init__(*args, **kwargs)
self.fields = OrderedDict(
(key, self.fields[key]) for key in
["role", "username", "first_name", "last_name",
"random_password", "password1", "password2",
"master_user", "is_active"]
(key, self.fields[key])
for key in [
"role",
"username",
"first_name",
"last_name",
"random_password",
"password1",
"password2",
"master_user",
"is_active",
]
)
self.user = user
condition = (
user.role == "DomainAdmins" or
user.role == "Resellers" and self.instance == user
user.role == "DomainAdmins"
or user.role == "Resellers"
and self.instance == user
)
if condition:
self.fields["role"] = forms.CharField(
label="",
widget=forms.HiddenInput(attrs={"class": "form-control"}),
required=False
required=False,
)
else:
self.fields["role"].choices += (
get_account_roles(user, self.instance)
if self.instance.pk else get_account_roles(user)
if self.instance.pk
else get_account_roles(user)
)
if not user.is_superuser:
@@ -104,8 +112,8 @@ class AccountFormGeneral(forms.ModelForm):
return
domain_disabled = (
hasattr(self.instance, "mailbox") and
not self.instance.mailbox.domain.enabled
hasattr(self.instance, "mailbox")
and not self.instance.mailbox.domain.enabled
)
if domain_disabled:
self.fields["is_active"].widget.attrs["disabled"] = "disabled"
@@ -113,9 +121,10 @@ class AccountFormGeneral(forms.ModelForm):
del self.fields["is_active"]
self.fields["role"].initial = self.instance.role
condition = (
not self.instance.is_local and
param_tools.get_global_parameter(
"ldap_auth_method", app="core") == "directbind")
not self.instance.is_local
and param_tools.get_global_parameter("ldap_auth_method", app="core")
== "directbind"
)
if condition:
del self.fields["random_password"]
del self.fields["password1"]
@@ -158,13 +167,12 @@ class AccountFormGeneral(forms.ModelForm):
if self.errors:
return self.cleaned_data
condition = (
self.cleaned_data.get("master_user") and
self.cleaned_data["role"] != "SuperAdmins"
self.cleaned_data.get("master_user")
and self.cleaned_data["role"] != "SuperAdmins"
)
if condition:
self.add_error(
"master_user",
_("Only super administrators are allowed for this mode")
"master_user", _("Only super administrators are allowed for this mode")
)
random_password = self.cleaned_data.get("random_password")
if random_password:
@@ -182,12 +190,11 @@ class AccountFormGeneral(forms.ModelForm):
return self.cleaned_data
if password1 != password2:
self.add_error(
"password2",
_("The two password fields didn't match."))
"password2", _("The two password fields didn't match.")
)
return self.cleaned_data
try:
password_validation.validate_password(
password2, self.instance)
password_validation.validate_password(password2, self.instance)
except forms.ValidationError as ve:
self.add_error("password2", ve.messages)
return self.cleaned_data
@@ -196,7 +203,8 @@ class AccountFormGeneral(forms.ModelForm):
account = super(AccountFormGeneral, self).save(commit=False)
if self.user == account and not self.cleaned_data["is_active"]:
raise lib_exceptions.PermDeniedException(
_("You can't disable your own account"))
_("You can't disable your own account")
)
if not account.pk:
account.language = settings.LANGUAGE_CODE
if commit:
@@ -207,7 +215,8 @@ class AccountFormGeneral(forms.ModelForm):
if hasattr(account, "mailbox"):
# Update forward status according to account status
models.Alias.objects.filter(address=account.email).update(
enabled=account.is_active)
enabled=account.is_active
)
return account
@@ -222,12 +231,11 @@ class AccountProfileForm(forms.ModelForm):
class AccountFormMail(forms.Form, DynamicForm):
"""Form to handle mail part."""
email = lib_fields.UTF8EmailField(
label=gettext_lazy("E-mail"), required=False)
email = lib_fields.UTF8EmailField(label=gettext_lazy("E-mail"), required=False)
create_alias_with_old_address = forms.BooleanField(
label=gettext_lazy("Create an alias using the old address"),
required=False,
initial=False
initial=False,
)
quota = forms.CharField(
label=gettext_lazy("Quota"),
@@ -239,20 +247,20 @@ class AccountFormMail(forms.Form, DynamicForm):
"unlimited value (not allowed for domain "
"administrators)."
),
widget=forms.widgets.TextInput(attrs={"class": "form-control"})
widget=forms.widgets.TextInput(attrs={"class": "form-control"}),
)
quota_act = forms.BooleanField(required=False)
message_limit = forms.IntegerField(
label=gettext_lazy("Message sending limit"),
required=False,
min_value=0,
help_text=gettext_lazy(
"Number of messages this mailbox can send per day")
help_text=gettext_lazy("Number of messages this mailbox can send per day"),
)
is_send_only = forms.BooleanField(
required=False,
help_text=gettext_lazy(
"Block IMAP connection and incoming mails for this mailbox")
"Block IMAP connection and incoming mails for this mailbox"
),
)
aliases = lib_fields.UTF8AndEmptyUserEmailField(
label=gettext_lazy("Alias(es)"),
@@ -261,7 +269,7 @@ class AccountFormMail(forms.Form, DynamicForm):
"Alias(es) of this mailbox. Indicate only one address per input, "
"press ENTER to add a new input. To create a catchall alias, just "
"enter the domain name (@domain.tld)."
)
),
)
senderaddress = lib_fields.UTF8AndEmptyUserEmailField(
label=gettext_lazy("Sender addresses"),
@@ -271,16 +279,14 @@ class AccountFormMail(forms.Form, DynamicForm):
"allowed to send emails using this address, even if it "
"does not exist locally. Indicate one address per input. Press "
"ENTER to add a new input."
)
),
)
def __init__(self, user, *args, **kwargs):
self.mb = kwargs.pop("instance", None)
self.user = user
super().__init__(*args, **kwargs)
self.field_widths = {
"quota": 3
}
self.field_widths = {"quota": 3}
params = dict(param_tools.get_global_parameters("admin"))
if self.mb is not None:
self.fields["email"].required = True
@@ -288,13 +294,13 @@ class AccountFormMail(forms.Form, DynamicForm):
for cpt, ralias in enumerate(qset):
name = "aliases_{}".format(cpt + 1)
self._create_field(
lib_fields.UTF8AndEmptyUserEmailField, name,
ralias.alias.address)
lib_fields.UTF8AndEmptyUserEmailField, name, ralias.alias.address
)
for cpt, saddress in enumerate(self.mb.senderaddress_set.all()):
name = "senderaddress_{}".format(cpt + 1)
self._create_field(
lib_fields.UTF8AndEmptyUserEmailField, name,
saddress.address)
lib_fields.UTF8AndEmptyUserEmailField, name, saddress.address
)
self.fields["email"].initial = self.mb.full_address
self.fields["quota_act"].initial = self.mb.use_domain_quota
if not self.mb.use_domain_quota and self.mb.quota:
@@ -302,22 +308,24 @@ class AccountFormMail(forms.Form, DynamicForm):
if self.mb.message_limit:
self.fields["message_limit"].initial = self.mb.message_limit
self.fields["is_send_only"].initial = self.mb.is_send_only
self.fields["create_alias_with_old_address"].initial = (
params["create_alias_on_mbox_rename"]
)
self.fields["create_alias_with_old_address"].initial = params[
"create_alias_on_mbox_rename"
]
else:
del self.fields["create_alias_with_old_address"]
self.fields["quota_act"].initial = True
if params["default_mailbox_message_limit"] is not None:
self.fields["message_limit"].initial = (
params["default_mailbox_message_limit"])
self.fields["message_limit"].initial = params[
"default_mailbox_message_limit"
]
if len(args) and isinstance(args[0], QueryDict):
self._load_from_qdict(
args[0], "aliases", lib_fields.UTF8AndEmptyUserEmailField)
args[0], "aliases", lib_fields.UTF8AndEmptyUserEmailField
)
self._load_from_qdict(
args[0], "senderaddress",
lib_fields.UTF8AndEmptyUserEmailField)
args[0], "senderaddress", lib_fields.UTF8AndEmptyUserEmailField
)
def clean_email(self):
"""Ensure lower case emails"""
@@ -332,8 +340,8 @@ class AccountFormMail(forms.Form, DynamicForm):
if not self.mb:
try:
core_signals.can_create_object.send(
sender=self.__class__, context=self.domain,
object_type="mailboxes")
sender=self.__class__, context=self.domain, object_type="mailboxes"
)
except lib_exceptions.ModoboaException as inst:
raise forms.ValidationError(inst)
return email
@@ -350,9 +358,10 @@ class AccountFormMail(forms.Form, DynamicForm):
cleaned_data = super(AccountFormMail, self).clean()
use_default_domain_quota = cleaned_data["quota_act"]
condition = (
not use_default_domain_quota and
cleaned_data["quota"] is not None and
cleaned_data["quota"] < 0)
not use_default_domain_quota
and cleaned_data["quota"] is not None
and cleaned_data["quota"] < 0
)
if condition:
self.add_error("quota", _("Must be a positive integer"))
self.aliases = []
@@ -367,16 +376,14 @@ class AccountFormMail(forms.Form, DynamicForm):
self.add_error(name, _("Local domain does not exist"))
continue
if not self.user.can_access(domain):
self.add_error(
name, _("You don't have access to this domain"))
self.add_error(name, _("You don't have access to this domain"))
continue
self.aliases.append(value.lower())
elif name.startswith("senderaddress"):
local_part, domname = split_mailbox(value)
domain = models.Domain.objects.filter(name=domname).first()
if domain and not self.user.can_access(domain):
self.add_error(
name, _("You don't have access to this domain"))
self.add_error(name, _("You don't have access to this domain"))
continue
self.sender_addresses.append(value.lower())
return cleaned_data
@@ -386,17 +393,20 @@ class AccountFormMail(forms.Form, DynamicForm):
if not user.can_access(self.domain):
raise lib_exceptions.PermDeniedException
core_signals.can_create_object.send(
self.__class__, context=user, klass=models.Mailbox)
self.__class__, context=user, klass=models.Mailbox
)
self.mb = models.Mailbox(
address=self.locpart, domain=self.domain, user=account,
address=self.locpart,
domain=self.domain,
user=account,
use_domain_quota=self.cleaned_data["quota_act"],
message_limit=self.cleaned_data.get("message_limit"),
is_send_only=self.cleaned_data.get("is_send_only", False)
is_send_only=self.cleaned_data.get("is_send_only", False),
)
override_rules = (
user.is_superuser or
user.has_perm("admin.add_domain") and
not user.userobjectlimit_set.get(name="quota").max_value
user.is_superuser
or user.has_perm("admin.add_domain")
and not user.userobjectlimit_set.get(name="quota").max_value
)
self.mb.set_quota(self.cleaned_data["quota"], override_rules)
self.mb.save(creator=user)
@@ -405,7 +415,8 @@ class AccountFormMail(forms.Form, DynamicForm):
"""Update mailbox aliases."""
# 1. We check if existing aliases were removed...
qset = self.mb.aliasrecipient_set.select_related("alias").filter(
alias__internal=False)
alias__internal=False
)
for ralias in qset:
if ralias.alias.address not in self.aliases:
alias = ralias.alias
@@ -420,22 +431,28 @@ class AccountFormMail(forms.Form, DynamicForm):
return
# 3. Check limits at all levels
core_signals.can_create_object.send(
self.__class__, context=user, klass=models.Alias,
count=len(self.aliases))
self.__class__, context=user, klass=models.Alias, count=len(self.aliases)
)
core_signals.can_create_object.send(
self.__class__, context=self.mb.domain,
object_type="mailbox_aliases", count=len(self.aliases))
self.__class__,
context=self.mb.domain,
object_type="mailbox_aliases",
count=len(self.aliases),
)
# 4. Create / update aliases
for alias in self.aliases:
if self.mb.aliasrecipient_set.select_related("alias").filter(
alias__address=alias, alias__internal=False).exists():
if (
self.mb.aliasrecipient_set.select_related("alias")
.filter(alias__address=alias, alias__internal=False)
.exists()
):
continue
local_part, domname = split_mailbox(alias)
al, _ = models.Alias.objects.get_or_create(
address=alias,
domain=models.Domain.objects.get(name=domname),
internal=False,
defaults={'enabled': account.is_active},
defaults={"enabled": account.is_active},
)
al.add_recipients([self.mb.full_address])
al.post_create(user)
@@ -451,8 +468,7 @@ class AccountFormMail(forms.Form, DynamicForm):
return
to_create = []
for saddress in self.sender_addresses:
to_create.append(
models.SenderAddress(address=saddress, mailbox=self.mb))
to_create.append(models.SenderAddress(address=saddress, mailbox=self.mb))
models.SenderAddress.objects.bulk_create(to_create)
def save(self, user, account):
@@ -466,8 +482,7 @@ class AccountFormMail(forms.Form, DynamicForm):
if not hasattr(self, "mb") or self.mb is None:
self.create_mailbox(user, account)
else:
self.cleaned_data["use_domain_quota"] = (
self.cleaned_data["quota_act"])
self.cleaned_data["use_domain_quota"] = self.cleaned_data["quota_act"]
if self.cleaned_data.get("create_alias_with_old_address", False):
self.aliases.append(self.mb.full_address)
self.mb.update_from_dict(user, self.cleaned_data)
@@ -487,7 +502,7 @@ class AccountPermissionsForm(forms.Form, DynamicForm):
domains = lib_fields.DomainNameField(
label=gettext_lazy("Domain(s)"),
required=False,
help_text=gettext_lazy("Domain(s) that user administrates")
help_text=gettext_lazy("Domain(s) that user administrates"),
)
def __init__(self, *args, **kwargs):
@@ -504,15 +519,13 @@ class AccountPermissionsForm(forms.Form, DynamicForm):
name = "domains_%d" % (pos + 1)
self._create_field(lib_fields.DomainNameField, name, dom.name)
if len(args) and isinstance(args[0], QueryDict):
self._load_from_qdict(
args[0], "domains", lib_fields.DomainNameField)
self._load_from_qdict(args[0], "domains", lib_fields.DomainNameField)
def save(self):
if self.account.role == "SimpleUsers":
return
current_domains = [
dom.name for dom in
models.Domain.objects.get_for_admin(self.account)
dom.name for dom in models.Domain.objects.get_for_admin(self.account)
]
for name, value in self.cleaned_data.items():
if not name.startswith("domains"):
@@ -534,45 +547,57 @@ class AccountForm(TabForms):
def __init__(self, request, *args, **kwargs):
self.user = request.user
self.forms = [
{"id": "general", "title": _("General"),
"formtpl": "admin/account_general_form.html",
"cls": AccountFormGeneral,
"new_args": [self.user], "mandatory": True},
{"id": "profile", "title": _("Profile"),
"formtpl": "admin/account_profile_form.html",
"cls": AccountProfileForm},
{"id": "mail",
"title": _("Mail"), "formtpl": "admin/mailform.html",
"cls": AccountFormMail,
"new_args": [self.user]},
{"id": "perms", "title": _("Permissions"),
"formtpl": "admin/permsform.html",
"cls": AccountPermissionsForm}
{
"id": "general",
"title": _("General"),
"formtpl": "admin/account_general_form.html",
"cls": AccountFormGeneral,
"new_args": [self.user],
"mandatory": True,
},
{
"id": "profile",
"title": _("Profile"),
"formtpl": "admin/account_profile_form.html",
"cls": AccountProfileForm,
},
{
"id": "mail",
"title": _("Mail"),
"formtpl": "admin/mailform.html",
"cls": AccountFormMail,
"new_args": [self.user],
},
{
"id": "perms",
"title": _("Permissions"),
"formtpl": "admin/permsform.html",
"cls": AccountPermissionsForm,
},
]
cbargs = {"user": self.user}
if "instances" in kwargs:
cbargs["account"] = kwargs["instances"]["general"]
results = signals.extra_account_forms.send(
sender=self.__class__, **cbargs)
self.forms += reduce(
lambda a, b: a + b, [result[1] for result in results])
results = signals.extra_account_forms.send(sender=self.__class__, **cbargs)
self.forms += reduce(lambda a, b: a + b, [result[1] for result in results])
super(AccountForm, self).__init__(request, *args, **kwargs)
def extra_context(self, context):
account = self.instances["general"]
context.update({
"title": account.username,
"formid": "accountform",
"action": reverse("admin:account_change",
args=[account.id]),
})
context.update(
{
"title": account.username,
"formid": "accountform",
"action": reverse("admin:account_change", args=[account.id]),
}
)
def check_perms(self, account):
"""Check if perms form must displayed or not."""
return (
self.user.is_superuser and
not account.is_superuser and
account.has_perm("core.add_user")
self.user.is_superuser
and not account.is_superuser
and account.has_perm("core.add_user")
)
def _before_is_valid(self, form):
@@ -585,7 +610,8 @@ class AccountForm(TabForms):
return True
results = signals.check_extra_account_form.send(
sender=self.__class__, account=self.account, form=form)
sender=self.__class__, account=self.account, form=form
)
results = [result[1] for result in results]
if False in results:
return False
@@ -617,31 +643,33 @@ class AccountForm(TabForms):
class AccountWizard(WizardForm):
"""Account creation wizard."""
def __init__(self, request):
super(AccountWizard, self).__init__(request)
self.add_step(
WizardStep(
"general", AccountFormGeneral, _("General"),
new_args=[request.user]
"general", AccountFormGeneral, _("General"), new_args=[request.user]
)
)
self.add_step(
WizardStep(
"mail", AccountFormMail, _("Mail"),
"mail",
AccountFormMail,
_("Mail"),
"admin/mailform.html",
new_args=[request.user]
new_args=[request.user],
)
)
def extra_context(self, context):
context.update({
"title": _("New account"),
"action": reverse("admin:account_add"),
"formid": "newaccount_form"
})
context.update(
{
"title": _("New account"),
"action": reverse("admin:account_add"),
"formid": "newaccount_form",
}
)
def done(self):
account = self.first_step.form.save()
+26 -19
View File
@@ -17,43 +17,50 @@ class AliasForm(forms.ModelForm, DynamicForm):
"""A form to create/modify an alias."""
random_address = forms.BooleanField(
label=gettext_lazy("Random address"),
required=False)
label=gettext_lazy("Random address"), required=False
)
address = lib_fields.UTF8AndEmptyUserEmailField(
label=gettext_lazy("Email address"),
help_text=gettext_lazy(
"The alias address. To create a catchall alias, just enter the "
"domain name (@domain.tld)."
),
widget=forms.TextInput(attrs={"class": "form-control"})
widget=forms.TextInput(attrs={"class": "form-control"}),
)
recipients = lib_fields.UTF8AndEmptyUserEmailField(
label=gettext_lazy("Recipients"), required=False,
label=gettext_lazy("Recipients"),
required=False,
help_text=gettext_lazy(
"Addresses this alias will point to. Indicate only one address "
"per input, press ENTER to add a new input."
),
widget=forms.TextInput(attrs={"class": "form-control"})
widget=forms.TextInput(attrs={"class": "form-control"}),
)
class Meta:
model = Alias
fields = ("address", "domain", "enabled", "expire_at", "description")
labels = {
"domain": gettext_lazy("Domain")
}
labels = {"domain": gettext_lazy("Domain")}
widgets = {
"domain": forms.widgets.Select(
attrs={"class": "selectpicker", "data-live-search": "true"})
attrs={"class": "selectpicker", "data-live-search": "true"}
)
}
def __init__(self, user, *args, **kwargs):
self.user = user
super(AliasForm, self).__init__(*args, **kwargs)
self.fields = OrderedDict(
(key, self.fields[key]) for key in
["random_address", "address", "domain", "recipients", "enabled",
"expire_at", "description"]
(key, self.fields[key])
for key in [
"random_address",
"address",
"domain",
"recipients",
"enabled",
"expire_at",
"description",
]
)
if self.instance.pk:
del self.fields["random_address"]
@@ -87,14 +94,12 @@ class AliasForm(forms.ModelForm, DynamicForm):
except Domain.DoesNotExist:
raise forms.ValidationError(_("Domain does not exist"))
if not self.user.can_access(domain):
raise forms.ValidationError(
_("You don't have access to this domain")
)
raise forms.ValidationError(_("You don't have access to this domain"))
if not self.instance.pk:
try:
core_signals.can_create_object.send(
sender=self.__class__, context=domain,
object_type="mailbox_aliases")
sender=self.__class__, context=domain, object_type="mailbox_aliases"
)
except lib_exceptions.ModoboaException as inst:
raise forms.ValidationError(inst)
return self.cleaned_data["address"].lower()
@@ -119,14 +124,16 @@ class AliasForm(forms.ModelForm, DynamicForm):
alias = super(AliasForm, self).save(commit=False)
if self.cleaned_data.get("random_address"):
alias.address = "{}@{}".format(
Alias.generate_random_address(), alias.domain)
Alias.generate_random_address(), alias.domain
)
else:
local_part, domname = split_mailbox(self.cleaned_data["address"])
alias.domain = Domain.objects.get(name=domname)
if commit:
alias.save()
address_list = [
value for field, value in self.cleaned_data.items()
value
for field, value in self.cleaned_data.items()
if field.startswith("recipients") and value
]
alias.set_recipients(address_list)
+123 -113
View File
@@ -13,7 +13,11 @@ from modoboa.core.models import User
from modoboa.lib.exceptions import Conflict
from modoboa.lib.fields import DomainNameField
from modoboa.lib.form_utils import (
DynamicForm, TabForms, WizardForm, WizardStep, YesNoField
DynamicForm,
TabForms,
WizardForm,
WizardStep,
YesNoField,
)
from modoboa.lib.web_utils import render_to_json_response, size2integer
from modoboa.parameters import tools as param_tools
@@ -33,17 +37,18 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
help_text=gettext_lazy(
"Alias(es) of this domain. Indicate only one name per input, "
"press ENTER to add a new input."
)
),
)
dkim_key_selector = forms.CharField(
label=gettext_lazy("Key selector"), initial="modoboa", required=False)
label=gettext_lazy("Key selector"), initial="modoboa", required=False
)
quota = forms.CharField(
label=gettext_lazy("Quota"),
initial=0,
help_text=gettext_lazy(
"Quota shared between mailboxes. Can be expressed in KB, "
"MB (default) or GB. A value of 0 means no quota."
)
),
)
default_mailbox_quota = forms.CharField(
label=gettext_lazy("Default mailbox quota"),
@@ -51,15 +56,23 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
help_text=gettext_lazy(
"Default quota applied to mailboxes. Can be expressed in KB, MB "
"(default) or GB. A value of 0 means no quota."
)
),
)
class Meta:
model = Domain
fields = (
"name", "type", "quota", "default_mailbox_quota", "message_limit",
"aliases", "enabled", "enable_dns_checks", "enable_dkim",
"dkim_key_selector", "dkim_key_length"
"name",
"type",
"quota",
"default_mailbox_quota",
"message_limit",
"aliases",
"enabled",
"enable_dns_checks",
"enable_dkim",
"dkim_key_selector",
"dkim_key_length",
)
def __init__(self, user, *args, **kwargs):
@@ -71,15 +84,12 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
params = dict(param_tools.get_global_parameters("admin"))
self.fields["quota"].initial = params["default_domain_quota"]
if params["default_domain_message_limit"] is not None:
self.fields["message_limit"].initial = (
params["default_domain_message_limit"])
self.fields["default_mailbox_quota"].initial = (
params["default_mailbox_quota"])
self.fields["message_limit"].initial = params[
"default_domain_message_limit"
]
self.fields["default_mailbox_quota"].initial = params["default_mailbox_quota"]
self.fields["type"].choices = constants.DOMAIN_TYPES
self.field_widths = {
"quota": 3,
"default_mailbox_quota": 3
}
self.field_widths = {"quota": 3, "default_mailbox_quota": 3}
self.user = user
if len(args) and isinstance(args[0], QueryDict):
@@ -93,19 +103,20 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
def clean_name(self):
"""Check unicity and more."""
name = self.cleaned_data["name"].lower()
label = lib.check_if_domain_exists(
name, [(DomainAlias, _("domain alias"))])
label = lib.check_if_domain_exists(name, [(DomainAlias, _("domain alias"))])
if label is not None:
raise forms.ValidationError(
_("A %s with this name already exists") % force_str(label))
_("A %s with this name already exists") % force_str(label)
)
domains_must_have_authorized_mx = (
param_tools.get_global_parameter("domains_must_have_authorized_mx")
domains_must_have_authorized_mx = param_tools.get_global_parameter(
"domains_must_have_authorized_mx"
)
if domains_must_have_authorized_mx and not self.user.is_superuser:
if not lib.domain_has_authorized_mx(name):
raise forms.ValidationError(
_("No authorized MX record found for this domain"))
_("No authorized MX record found for this domain")
)
return name
@@ -116,8 +127,7 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
return enabled
storage_dir = param_tools.get_global_parameter("dkim_keys_storage_dir")
if not storage_dir:
raise forms.ValidationError(
_("DKIM keys storage directory not configured"))
raise forms.ValidationError(_("DKIM keys storage directory not configured"))
return enabled
def clean_quota(self):
@@ -127,7 +137,8 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
def clean_default_mailbox_quota(self):
"""Return proper quota value."""
return size2integer(
self.cleaned_data["default_mailbox_quota"], output_unit="MB")
self.cleaned_data["default_mailbox_quota"], output_unit="MB"
)
def clean(self):
"""Custom fields validation.
@@ -141,13 +152,13 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
if self._errors:
return cleaned_data
condition = (
self.cleaned_data["quota"] != 0 and
self.cleaned_data["default_mailbox_quota"] >
self.cleaned_data["quota"])
self.cleaned_data["quota"] != 0
and self.cleaned_data["default_mailbox_quota"] > self.cleaned_data["quota"]
)
if condition:
self.add_error(
"default_mailbox_quota",
_("Cannot be greater than domain quota"))
"default_mailbox_quota", _("Cannot be greater than domain quota")
)
elif self.user.role == "Resellers":
limit = self.user.userobjectlimit_set.get(name="quota")
if limit.max_value != 0:
@@ -155,14 +166,12 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
msg = _("You can't define an unlimited quota.")
if quota == 0:
self.add_error("quota", msg)
default_mailbox_quota = self.cleaned_data[
"default_mailbox_quota"]
default_mailbox_quota = self.cleaned_data["default_mailbox_quota"]
if default_mailbox_quota == 0:
self.add_error("default_mailbox_quota", msg)
if self.cleaned_data["enable_dkim"]:
if not self.cleaned_data.get("dkim_key_selector"):
self.add_error(
"dkim_key_selector", _("This field is required."))
self.add_error("dkim_key_selector", _("This field is required."))
self.aliases = []
copied_data = cleaned_data.copy()
for k in copied_data.keys():
@@ -177,12 +186,10 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
)
del cleaned_data[k]
continue
label = lib.check_if_domain_exists(
cleaned_data[k], [(Domain, _("domain"))])
label = lib.check_if_domain_exists(cleaned_data[k], [(Domain, _("domain"))])
if label is not None:
self.add_error(
k, _("A %s with this name already exists")
% force_str(label)
k, _("A %s with this name already exists") % force_str(label)
)
else:
self.aliases.append(cleaned_data[k])
@@ -198,7 +205,8 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
"""
d = super(DomainFormGeneral, self).save(commit=False)
core_signals.can_create_object.send(
sender=self.__class__, context=user, klass=Domain, instance=d)
sender=self.__class__, context=user, klass=Domain, instance=d
)
if not commit:
return d
d.save()
@@ -209,18 +217,23 @@ class DomainFormGeneral(forms.ModelForm, DynamicForm):
self.aliases.remove(dalias.name)
if self.aliases:
core_signals.can_create_object.send(
self.__class__, context=user, klass=DomainAlias,
count=len(self.aliases))
self.__class__, context=user, klass=DomainAlias, count=len(self.aliases)
)
core_signals.can_create_object.send(
self.__class__, context=d, object_type="domain_aliases",
count=len(self.aliases))
self.__class__,
context=d,
object_type="domain_aliases",
count=len(self.aliases),
)
for alias in self.aliases:
if d.domainalias_set.filter(name=alias).exists():
continue
options = {"creator": user} if domalias_post_create else {}
DomainAlias(name=alias, target=d, enabled=d.enabled).save(
**options)
if self.cleaned_data.get("enable_dkim") is False and d.dkim_private_key_path != "":
DomainAlias(name=alias, target=d, enabled=d.enabled).save(**options)
if (
self.cleaned_data.get("enable_dkim") is False
and d.dkim_private_key_path != ""
):
d.dkim_private_key_path = ""
d.save()
return d
@@ -232,9 +245,7 @@ class DomainFormOptions(forms.Form):
create_dom_admin = YesNoField(
label=gettext_lazy("Create a domain administrator"),
initial=False,
help_text=gettext_lazy(
"Automatically create an administrator for this domain"
)
help_text=gettext_lazy("Automatically create an administrator for this domain"),
)
dom_admin_username = forms.CharField(
@@ -244,40 +255,35 @@ class DomainFormOptions(forms.Form):
"The administrator's name. Don't include the domain's name here, "
"it will be automatically appended."
),
required=False
required=False,
)
random_password = YesNoField(
label=gettext_lazy("Random password"),
initial=False,
help_text=gettext_lazy(
"Generate a random password for the administrator."
),
required=False
help_text=gettext_lazy("Generate a random password for the administrator."),
required=False,
)
with_mailbox = YesNoField(
label=gettext_lazy("With a mailbox"),
initial=True,
help_text=gettext_lazy(
"Create a mailbox for the administrator."
),
required=False
help_text=gettext_lazy("Create a mailbox for the administrator."),
required=False,
)
create_aliases = YesNoField(
label=gettext_lazy("Create aliases"),
initial=True,
help_text=gettext_lazy(
"Automatically create standard aliases for this domain"
),
required=False
help_text=gettext_lazy("Automatically create standard aliases for this domain"),
required=False,
)
def __init__(self, user, *args, **kwargs):
super(DomainFormOptions, self).__init__(*args, **kwargs)
results = core_signals.user_can_set_role.send(
sender=self.__class__, user=user, role="DomainAdmins")
sender=self.__class__, user=user, role="DomainAdmins"
)
if False in [result[1] for result in results]:
self.fields = {}
return
@@ -293,11 +299,9 @@ class DomainFormOptions(forms.Form):
cleaned_data = super(DomainFormOptions, self).clean()
if cleaned_data.get("create_dom_admin"):
if not cleaned_data.get("dom_admin_username"):
self.add_error(
"dom_admin_username", _("This field is required."))
self.add_error("dom_admin_username", _("This field is required."))
if "create_aliases" not in cleaned_data:
self.add_error(
"create_aliases", _("This field is required."))
self.add_error("create_aliases", _("This field is required."))
return cleaned_data
def save(self, *args, **kwargs):
@@ -307,22 +311,19 @@ class DomainFormOptions(forms.Form):
return
user = kwargs.pop("user")
domain = kwargs.pop("domain")
username = "%s@%s" % (
self.cleaned_data["dom_admin_username"], domain.name)
username = "%s@%s" % (self.cleaned_data["dom_admin_username"], domain.name)
try:
da = User.objects.get(username=username)
except User.DoesNotExist:
pass
else:
raise Conflict(_("User '%s' already exists") % username)
core_signals.can_create_object.send(
self.__class__, context=user, klass=Mailbox)
core_signals.can_create_object.send(self.__class__, context=user, klass=Mailbox)
da = User(username=username, email=username, is_active=True)
if self.cleaned_data["random_password"]:
password = lib.make_password()
else:
password = param_tools.get_global_parameter(
"default_password", app="core")
password = param_tools.get_global_parameter("default_password", app="core")
da.set_password(password)
da.save()
da.role = "DomainAdmins"
@@ -331,24 +332,27 @@ class DomainFormOptions(forms.Form):
if self.cleaned_data["with_mailbox"]:
dom_admin_username = self.cleaned_data["dom_admin_username"]
mb = Mailbox(
address=dom_admin_username, domain=domain,
user=da, use_domain_quota=True
address=dom_admin_username,
domain=domain,
user=da,
use_domain_quota=True,
)
mb.set_quota(
override_rules=user.has_perm("admin.change_domain"))
mb.set_quota(override_rules=user.has_perm("admin.change_domain"))
mb.save(creator=user)
condition = (
domain.type == "domain" and
self.cleaned_data["create_aliases"] and
dom_admin_username != "postmaster"
domain.type == "domain"
and self.cleaned_data["create_aliases"]
and dom_admin_username != "postmaster"
)
if condition:
core_signals.can_create_object.send(
self.__class__, context=user, klass=Alias)
address = u"postmaster@{}".format(domain.name)
self.__class__, context=user, klass=Alias
)
address = "postmaster@{}".format(domain.name)
alias = Alias.objects.create(
address=address, domain=domain, enabled=True)
address=address, domain=domain, enabled=True
)
alias.set_recipients([mb.full_address])
alias.post_create(user)
@@ -363,36 +367,37 @@ class DomainForm(TabForms):
self.forms = []
self.domain = None
if self.user.has_perm("admin.change_domain"):
self.forms.append({
"id": "general",
"title": _("General"),
"formtpl": "admin/domain_general_form.html",
"cls": DomainFormGeneral,
"mandatory": True,
"new_args": [request.user]
})
self.forms.append(
{
"id": "general",
"title": _("General"),
"formtpl": "admin/domain_general_form.html",
"cls": DomainFormGeneral,
"mandatory": True,
"new_args": [request.user],
}
)
cbargs = {"user": self.user}
if "instances" in kwargs:
self.domain = kwargs["instances"]["general"]
cbargs["domain"] = self.domain
results = signals.extra_domain_forms.send(
sender=self.__class__, **cbargs)
self.forms += reduce(
lambda a, b: a + b, [result[1] for result in results])
results = signals.extra_domain_forms.send(sender=self.__class__, **cbargs)
self.forms += reduce(lambda a, b: a + b, [result[1] for result in results])
if not self.forms:
self.active_id = "admins"
super(DomainForm, self).__init__(request, *args, **kwargs)
def extra_context(self, context):
"""Add information to template context."""
context.update({
"title": self.domain.name,
"action": reverse(
"admin:domain_change", args=[self.domain.pk]),
"formid": "domform",
"domain": self.domain
})
context.update(
{
"title": self.domain.name,
"action": reverse("admin:domain_change", args=[self.domain.pk]),
"formid": "domform",
"domain": self.domain,
}
)
def is_valid(self):
"""Custom validation.
@@ -417,8 +422,7 @@ class DomainForm(TabForms):
first_form = self.forms[0]["instance"]
options = {}
if isinstance(first_form, DomainFormGeneral):
domain = first_form.save(
self.request.user, domalias_post_create=True)
domain = first_form.save(self.request.user, domalias_post_create=True)
options.update({"domain": domain})
else:
first_form.save(self.request.user)
@@ -436,9 +440,11 @@ class DomainWizard(WizardForm):
super(DomainWizard, self).__init__(request)
self.add_step(
WizardStep(
"general", DomainFormGeneral, _("General"),
"general",
DomainFormGeneral,
_("General"),
"admin/domain_general_form.html",
[request.user]
[request.user],
)
)
results = signals.extra_domain_wizard_steps.send(sender=self.__class__)
@@ -447,18 +453,22 @@ class DomainWizard(WizardForm):
self.add_step(step)
self.add_step(
WizardStep(
"options", DomainFormOptions, _("Options"),
"options",
DomainFormOptions,
_("Options"),
"admin/domain_options_form.html",
[self.request.user]
[self.request.user],
)
)
def extra_context(self, context):
context.update({
"title": _("New domain"),
"action": reverse("admin:domain_add"),
"formid": "domform"
})
context.update(
{
"title": _("New domain"),
"action": reverse("admin:domain_add"),
"formid": "domform",
}
)
def done(self):
genform = self.first_step.form
+1 -1
View File
@@ -9,7 +9,7 @@ class ExportDataForm(forms.Form):
label=gettext_lazy("Separator"),
max_length=1,
required=False,
widget=forms.TextInput(attrs={"class": "form-control"})
widget=forms.TextInput(attrs={"class": "form-control"}),
)
def __init__(self, *args, **kwargs):
+3 -3
View File
@@ -12,14 +12,14 @@ class ForwardForm(forms.Form):
label=gettext_lazy("Recipient(s)"),
widget=forms.Textarea(attrs={"class": "form-control"}),
required=False,
help_text=gettext_lazy(
"Indicate one or more recipients separated by a ','")
help_text=gettext_lazy("Indicate one or more recipients separated by a ','"),
)
keepcopies = forms.BooleanField(
label=gettext_lazy("Keep local copies"),
required=False,
help_text=gettext_lazy(
"Forward messages and store copies into your local mailbox")
"Forward messages and store copies into your local mailbox"
),
)
def clean_dest(self):
+8 -9
View File
@@ -5,7 +5,6 @@ from django.utils.translation import gettext_lazy
class ImportDataForm(forms.Form):
"""Base form to import objects."""
sourcefile = forms.FileField(label=gettext_lazy("Select a file"))
@@ -13,11 +12,12 @@ class ImportDataForm(forms.Form):
label=gettext_lazy("Separator"),
max_length=1,
required=False,
widget=forms.TextInput(attrs={"class": "form-control"})
widget=forms.TextInput(attrs={"class": "form-control"}),
)
continue_if_exists = forms.BooleanField(
label=gettext_lazy("Continue on error"), required=False,
help_text=gettext_lazy("Don't treat duplicated objects as error")
label=gettext_lazy("Continue on error"),
required=False,
help_text=gettext_lazy("Don't treat duplicated objects as error"),
)
def __init__(self, *args, **kwargs):
@@ -31,13 +31,12 @@ class ImportDataForm(forms.Form):
class ImportIdentitiesForm(ImportDataForm):
"""A form to import identities."""
crypt_password = forms.BooleanField(
label=gettext_lazy("Crypt passwords"), required=False,
label=gettext_lazy("Crypt passwords"),
required=False,
help_text=gettext_lazy(
"Check this option if passwords contained in your file "
"are not crypted"
)
"Check this option if passwords contained in your file " "are not crypted"
),
)
+81 -71
View File
@@ -23,18 +23,20 @@ def update_domain_mxs_and_mailboxes(sender, instance, **kwargs):
if kwargs.get("created"):
return
instance.mailbox_set.filter(use_domain_quota=True).update(
quota=instance.default_mailbox_quota)
quota=instance.default_mailbox_quota
)
if instance.old_mail_homes is None:
return
qset = (
models.Quota.objects.filter(
username__contains="@{}".format(instance.oldname))
qset = models.Quota.objects.filter(
username__contains="@{}".format(instance.oldname)
)
for q in qset:
username = q.username.replace(
"@{}".format(instance.oldname), "@{}".format(instance.name))
"@{}".format(instance.oldname), "@{}".format(instance.name)
)
models.Quota.objects.create(
username=username, bytes=q.bytes, messages=q.messages)
username=username, bytes=q.bytes, messages=q.messages
)
q.delete()
for mb in instance.mailbox_set.all():
mb.rename_dir(instance.old_mail_homes[mb.pk])
@@ -42,8 +44,7 @@ def update_domain_mxs_and_mailboxes(sender, instance, **kwargs):
# .update(address=Concat("local_part", Value(instance.name)))
# if the local_part was stored aside the address...
for alias in instance.alias_set.all():
alias.address = "{}@{}".format(
alias.address.split("@", 1)[0], instance.name)
alias.address = "{}@{}".format(alias.address.split("@", 1)[0], instance.name)
alias.save(update_fields=["address"])
@@ -51,11 +52,8 @@ def update_domain_mxs_and_mailboxes(sender, instance, **kwargs):
def create_dkim_key(sender, instance, **kwargs):
if not instance.enable_dkim:
return
queue = django_rq.get_queue('dkim')
queue.enqueue(call_command,
"modo",
"manage_dkim_keys",
f"--domain={instance.name}")
queue = django_rq.get_queue("dkim")
queue.enqueue(call_command, "modo", "manage_dkim_keys", f"--domain={instance.name}")
@receiver(signals.post_save, sender=models.DomainAlias)
@@ -64,16 +62,17 @@ def create_alias_for_domainalias(sender, instance, **kwargs):
if not kwargs.get("created"):
return
alias = models.Alias.objects.create(
address=u"@{}".format(instance.name), enabled=True, internal=True)
address="@{}".format(instance.name), enabled=True, internal=True
)
models.AliasRecipient.objects.create(
address=u"@{}".format(instance.target.name), alias=alias)
address="@{}".format(instance.target.name), alias=alias
)
@receiver(signals.post_delete, sender=models.DomainAlias)
def remove_alias_for_domainalias(sender, instance, **kwargs):
"""Remove the alias associated to domain alias."""
models.Alias.objects.filter(
address=u"@{}".format(instance.name)).delete()
models.Alias.objects.filter(address="@{}".format(instance.name)).delete()
@receiver(signals.post_save, sender=models.Mailbox)
@@ -84,20 +83,22 @@ def manage_alias_for_mailbox(sender, instance, **kwargs):
address=instance.full_address,
domain=instance.domain,
internal=True,
defaults={
"enabled": instance.user.enabled
}
defaults={"enabled": instance.user.enabled},
)
models.AliasRecipient.objects.create(
address=instance.full_address, alias=alias, r_mailbox=instance)
address=instance.full_address, alias=alias, r_mailbox=instance
)
return
old_address = getattr(instance, "old_full_address", None)
if old_address is None or old_address == instance.full_address:
return
# Update old self alias
alr = models.AliasRecipient.objects.get(
alias__address=old_address, address=old_address,
r_mailbox=instance, alias__internal=True)
alias__address=old_address,
address=old_address,
r_mailbox=instance,
alias__internal=True,
)
alr.address = instance.full_address
alr.save()
alr.alias.address = instance.full_address
@@ -106,7 +107,8 @@ def manage_alias_for_mailbox(sender, instance, **kwargs):
# Update AliasRecipient instances
instance.aliasrecipient_set.filter(alias__internal=False).update(
address=instance.full_address)
address=instance.full_address
)
@receiver(signals.pre_delete, sender=models.Mailbox)
@@ -132,7 +134,8 @@ def mailbox_deleted_handler(sender, **kwargs):
request = lib_signals.get_request()
if request:
if not request.localconfig.parameters.get_value(
"handle_mailboxes", raise_exception=False):
"handle_mailboxes", raise_exception=False
):
return
keepdir = request.POST.get("keepdir", "false") == "true"
if keepdir:
@@ -142,7 +145,8 @@ def mailbox_deleted_handler(sender, **kwargs):
# Management command context
localconfig = core_models.LocalConfig.objects.first()
if not localconfig.parameters.get_value(
"handle_mailboxes", raise_exception=False):
"handle_mailboxes", raise_exception=False
):
return
mb.delete_dir()
@@ -150,17 +154,18 @@ def mailbox_deleted_handler(sender, **kwargs):
@receiver(signals.post_delete, sender=models.Mailbox)
def remove_alias_for_mailbox(sender, instance, **kwargs):
"""Remove "self alias" for this mailbox."""
models.Alias.objects.filter(
address=instance.full_address).delete()
models.Alias.objects.filter(address=instance.full_address).delete()
@receiver(core_signals.register_postfix_maps)
def register_postfix_maps(sender, **kwargs):
"""Register admin map files."""
return [
postfix_maps.DomainsMap, postfix_maps.DomainsAliasesMap,
postfix_maps.AliasesMap, postfix_maps.MaintainMap,
postfix_maps.SenderLoginMap
postfix_maps.DomainsMap,
postfix_maps.DomainsAliasesMap,
postfix_maps.AliasesMap,
postfix_maps.MaintainMap,
postfix_maps.SenderLoginMap,
]
@@ -177,11 +182,11 @@ def account_auto_created(sender, user, **kwargs):
domain = models.Domain.objects.get(name=domname)
except models.Domain.DoesNotExist:
label = lib.check_if_domain_exists(
domname, [(models.DomainAlias, _("domain alias"))])
domname, [(models.DomainAlias, _("domain alias"))]
)
if label is not None:
return
domain = models.Domain(
name=domname, enabled=True, default_mailbox_quota=0)
domain = models.Domain(name=domname, enabled=True, default_mailbox_quota=0)
domain.save(creator=sadmins[0])
for su in sadmins[1:]:
permissions.grant_access_to_object(su, domain)
@@ -201,11 +206,10 @@ def account_auto_created(sender, user, **kwargs):
@receiver(core_signals.account_exported)
def export_admin_domains(sender, user, **kwargs):
"""Export administered domains too."""
result = [user.mailbox.quota] if hasattr(user, "mailbox") else [u""]
result = [user.mailbox.quota] if hasattr(user, "mailbox") else [""]
if user.role != "DomainAdmins":
return result
return result + [
dom.name for dom in models.Domain.objects.get_for_admin(user)]
return result + [dom.name for dom in models.Domain.objects.get_for_admin(user)]
@receiver(core_signals.account_imported)
@@ -232,14 +236,17 @@ def import_account_mailbox(sender, user, account, row, **kwargs):
if not user.can_access(domain):
raise exceptions.PermDeniedException
core_signals.can_create_object.send(
sender="import", context=user, klass=models.Mailbox)
sender="import", context=user, klass=models.Mailbox
)
core_signals.can_create_object.send(
sender="import", context=domain, object_type="mailboxes")
sender="import", context=domain, object_type="mailboxes"
)
account.save()
qset = models.Mailbox.objects.filter(address=mailbox, domain=domain)
if qset.exists():
raise exceptions.Conflict(
_("Mailbox {} already exists").format(account.email))
_("Mailbox {} already exists").format(account.email)
)
if len(row) == 1:
quota = None
else:
@@ -252,11 +259,12 @@ def import_account_mailbox(sender, user, account, row, **kwargs):
)
use_domain_quota = True if not quota else False
mb = models.Mailbox(
address=mailbox, domain=domain,
user=account, use_domain_quota=use_domain_quota)
mb.set_quota(
quota, override_rules=user.has_perm("admin.change_domain")
address=mailbox,
domain=domain,
user=account,
use_domain_quota=use_domain_quota,
)
mb.set_quota(quota, override_rules=user.has_perm("admin.change_domain"))
mb.save(creator=user)
if account.role == "DomainAdmins":
for domname in row[2:]:
@@ -275,19 +283,20 @@ def admin_menu(sender, location, user, **kwargs):
entries = []
if user.has_perm("admin.view_domain"):
entries += [
{"name": "domains",
"url": reverse("admin:domain_list"),
"label": _("Domains")}
{
"name": "domains",
"url": reverse("admin:domain_list"),
"label": _("Domains"),
}
]
conditions = (
user.has_perm("core.add_user"),
user.has_perm("admin.add_alias")
)
conditions = (user.has_perm("core.add_user"), user.has_perm("admin.add_alias"))
if any(conditions):
entries += [
{"name": "identities",
"url": reverse("admin:identity_list"),
"label": _("Identities")},
{
"name": "identities",
"url": reverse("admin:identity_list"),
"label": _("Identities"),
},
]
return entries
@@ -300,10 +309,12 @@ def user_menu(sender, location, user, **kwargs):
if not hasattr(user, "mailbox"):
return []
return [
{"name": "forward",
"class": "ajaxnav",
"url": "forward/",
"label": _("Forward")}
{
"name": "forward",
"class": "ajaxnav",
"url": "forward/",
"label": _("Forward"),
}
]
@@ -321,12 +332,15 @@ def grant_access_to_all_objects(sender, account, role, **kwargs):
if role != "SuperAdmins":
return
perm_models = [
core_models.User, models.Domain, models.DomainAlias, models.Mailbox,
models.Alias]
core_models.User,
models.Domain,
models.DomainAlias,
models.Mailbox,
models.Alias,
]
for model in perm_models:
permissions.grant_access_to_objects(
account, model.objects.all(),
ContentType.objects.get_for_model(model)
account, model.objects.all(), ContentType.objects.get_for_model(model)
)
@@ -338,19 +352,15 @@ def add_widgets_to_admin_dashboard(sender, user, **kwargs):
"domains_counter": models.Domain.objects.count(),
"domain_aliases_counter": models.DomainAlias.objects.count(),
"identities_counter": (
core_models.User.objects.count() +
models.Alias.objects.filter(internal=False).count()),
core_models.User.objects.count()
+ models.Alias.objects.filter(internal=False).count()
),
}
template = "admin/_global_statistics_widget.html"
else:
context = {
"domains": models.Domain.objects.get_for_admin(user)}
context = {"domains": models.Domain.objects.get_for_admin(user)}
template = "admin/_per_domain_statistics_widget.html"
return [{
"column": "left",
"template": template,
"context": context
}]
return [{"column": "left", "template": template, "context": context}]
@receiver(admin_signals.import_object)
+48 -41
View File
@@ -25,9 +25,7 @@ from reversion import revisions as reversion
from modoboa.core import signals as core_signals
from modoboa.core.models import User
from modoboa.lib.exceptions import (
Conflict, ModoboaException, PermDeniedException
)
from modoboa.lib.exceptions import Conflict, ModoboaException, PermDeniedException
from modoboa.parameters import tools as param_tools
from . import signals
@@ -40,13 +38,16 @@ def needs_mailbox():
Some applications (the webmail for example) need a mailbox to
work.
"""
def decorator(f):
@wraps(f)
def wrapped_f(request, *args, **kwargs):
if hasattr(request.user, "mailbox"):
return f(request, *args, **kwargs)
raise PermDeniedException(_("A mailbox is required"))
return wrapped_f
return decorator
@@ -61,13 +62,12 @@ def get_identities(user, searchquery=None, idtfilter=None, grpfilter=None):
"""
accounts = []
if idtfilter is None or not idtfilter or idtfilter == "account":
ids = user.objectaccess_set \
.filter(content_type=ContentType.objects.get_for_model(user)) \
.values_list("object_id", flat=True)
ids = user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(user)
).values_list("object_id", flat=True)
q = Q(pk__in=ids)
if searchquery is not None:
q &= Q(username__icontains=searchquery) \
| Q(email__icontains=searchquery)
q &= Q(username__icontains=searchquery) | Q(email__icontains=searchquery)
if grpfilter is not None and grpfilter:
if grpfilter == "SuperAdmins":
q &= Q(is_superuser=True)
@@ -76,16 +76,19 @@ def get_identities(user, searchquery=None, idtfilter=None, grpfilter=None):
accounts = User.objects.filter(q).prefetch_related("groups")
aliases = []
if idtfilter is None or not idtfilter \
or (idtfilter in ["alias", "forward", "dlist"]):
if (
idtfilter is None
or not idtfilter
or (idtfilter in ["alias", "forward", "dlist"])
):
alct = ContentType.objects.get_for_model(Alias)
ids = user.objectaccess_set.filter(content_type=alct) \
.values_list("object_id", flat=True)
ids = user.objectaccess_set.filter(content_type=alct).values_list(
"object_id", flat=True
)
q = Q(pk__in=ids, internal=False)
if searchquery is not None:
q &= (
Q(address__icontains=searchquery) |
Q(domain__name__icontains=searchquery)
q &= Q(address__icontains=searchquery) | Q(
domain__name__icontains=searchquery
)
aliases = Alias.objects.select_related("domain").filter(q)
if idtfilter is not None and idtfilter:
@@ -101,8 +104,7 @@ def get_domains(user, domfilter=None, searchquery=None, **extrafilters):
:rtype: list
:return: a list of domains and/or relay domains
"""
domains = (
Domain.objects.get_for_admin(user).prefetch_related("domainalias_set"))
domains = Domain.objects.get_for_admin(user).prefetch_related("domainalias_set")
if domfilter:
domains = domains.filter(type=domfilter)
if searchquery is not None:
@@ -110,7 +112,8 @@ def get_domains(user, domfilter=None, searchquery=None, **extrafilters):
q |= Q(domainalias__name__contains=searchquery)
domains = domains.filter(q).distinct()
results = signals.extra_domain_qset_filters.send(
sender="get_domains", domfilter=domfilter, extrafilters=extrafilters)
sender="get_domains", domfilter=domfilter, extrafilters=extrafilters
)
if results:
qset_filters = {}
for result in results:
@@ -136,8 +139,7 @@ def import_domain(user, row, formopts):
"""Specific code for domains import"""
if not user.has_perm("admin.add_domain"):
raise PermDeniedException(_("You are not allowed to import domains"))
core_signals.can_create_object.send(
sender="import", context=user, klass=Domain)
core_signals.can_create_object.send(sender="import", context=user, klass=Domain)
dom = Domain()
dom.from_csv(user, row)
@@ -145,10 +147,10 @@ def import_domain(user, row, formopts):
def import_domainalias(user, row, formopts):
"""Specific code for domain aliases import"""
if not user.has_perm("admin.add_domainalias"):
raise PermDeniedException(
_("You are not allowed to import domain aliases."))
raise PermDeniedException(_("You are not allowed to import domain aliases."))
core_signals.can_create_object.send(
sender="import", context=user, klass=DomainAlias)
sender="import", context=user, klass=DomainAlias
)
domalias = DomainAlias()
domalias.from_csv(user, row)
@@ -200,14 +202,15 @@ def get_dns_records(name, typ, resolver=None):
except dns.resolver.NoAnswer as e:
logger.error(
_("No %(type)s record for %(name)s") % {"type": typ, "name": name},
exc_info=e
exc_info=e,
)
except dns.resolver.NoNameservers as e:
logger.error(_("No working name servers found"), exc_info=e)
except dns.resolver.Timeout as e:
logger.warning(
_("DNS resolution timeout, unable to query %s at the moment") %
name, exc_info=e)
_("DNS resolution timeout, unable to query %s at the moment") % name,
exc_info=e,
)
except dns.name.NameTooLong as e:
logger.error(_("DNS name is too long: %s" % name), exc_info=e)
else:
@@ -225,7 +228,8 @@ def get_domain_mx_list(domain):
return result
for dns_answer in dns_answers:
mx_domain = dns_answer.exchange.to_unicode(
omit_final_dot=True, idna_codec=IDNA_2008_UTS_46)
omit_final_dot=True, idna_codec=IDNA_2008_UTS_46
)
rtypes = ["A"]
if param_tools.get_global_parameter("enable_ipv6_mx_checks", app="admin"):
rtypes.append("AAAA")
@@ -239,11 +243,11 @@ def get_domain_mx_list(domain):
mx_ip = ipaddress.ip_address(address_smart)
except ValueError as e:
logger.warning(
_("Invalid IP address format for "
"{domain}; {addr}").format(
domain=mx_domain,
addr=smart_str(ip_answer.address)
), exc_info=e)
_("Invalid IP address format for " "{domain}; {addr}").format(
domain=mx_domain, addr=smart_str(ip_answer.address)
),
exc_info=e,
)
else:
result.append((mx_domain, mx_ip))
return result
@@ -252,8 +256,11 @@ def get_domain_mx_list(domain):
def domain_has_authorized_mx(name):
"""Check if domain has authorized mx record at least."""
valid_mxs = param_tools.get_global_parameter("valid_mxs")
valid_mxs = [ipaddress.ip_network(smart_str(v.strip()))
for v in valid_mxs.split() if v.strip()]
valid_mxs = [
ipaddress.ip_network(smart_str(v.strip()))
for v in valid_mxs.split()
if v.strip()
]
domain_mxs = get_domain_mx_list(name)
for _mx_addr, mx_ip_addr in domain_mxs:
for subnet in valid_mxs:
@@ -264,13 +271,12 @@ def domain_has_authorized_mx(name):
def make_password():
"""Create a random password."""
length = int(
param_tools.get_global_parameter("random_password_length", app="core")
)
length = int(param_tools.get_global_parameter("random_password_length", app="core"))
while True:
password = "".join(
random.SystemRandom().choice(
string.ascii_letters + string.digits) for _ in range(length))
random.SystemRandom().choice(string.ascii_letters + string.digits)
for _ in range(length)
)
try:
password_validation.validate_password(password)
except ValidationError:
@@ -297,7 +303,8 @@ def import_data(user, file_object, options: dict):
if not row:
continue
fct = signals.import_object.send(
sender="importdata", objtype=row[0].strip())
sender="importdata", objtype=row[0].strip()
)
fct = [func for x_, func in fct if func is not None]
if not fct:
continue
@@ -315,6 +322,6 @@ def import_data(user, file_object, options: dict):
cpt += 1
msg = _("%d objects imported successfully") % cpt
return True, msg
except (ModoboaException) as e:
except ModoboaException as e:
error = str(e)
return False, error
@@ -31,8 +31,9 @@ class Command(BaseCommand):
def add_arguments(self, parser):
"""Add extra arguments to command line."""
parser.add_argument(
"--pidfile", default="/tmp/handle_mailbox_operations.pid",
help="Path to the file that will contain the PID of this process"
"--pidfile",
default="/tmp/handle_mailbox_operations.pid",
help="Path to the file that will contain the PID of this process",
)
def rename_mailbox(self, operation):
@@ -45,9 +46,7 @@ class Command(BaseCommand):
os.makedirs(dirname)
except os.error as e:
raise OperationError(str(e))
code, output = exec_cmd(
"mv %s %s" % (operation.argument, new_mail_home)
)
code, output = exec_cmd("mv %s %s" % (operation.argument, new_mail_home))
if code:
raise OperationError(output)
@@ -58,8 +57,7 @@ class Command(BaseCommand):
def onerror(function, path, excinfo):
"""Handle errors."""
self.logger.critical(
"delete failed (reason: {})".format(excinfo))
self.logger.critical("delete failed (reason: {})".format(excinfo))
shutil.rmtree(operation.argument, False, onerror)
@@ -97,7 +95,8 @@ class Command(BaseCommand):
f(ope)
except (OperationError, InternalError) as e:
self.logger.critical(
"%s failed (reason: %s)", ope, str(e).decode("utf-8"))
"%s failed (reason: %s)", ope, str(e).decode("utf-8")
)
else:
self.logger.info("%s succeed", ope)
ope.delete()
+3 -7
View File
@@ -26,9 +26,7 @@ class Command(BaseCommand):
}
def add_arguments(self, parser):
subparsers = parser.add_subparsers(
dest='subcommand', title='subcommands'
)
subparsers = parser.add_subparsers(dest="subcommand", title="subcommands")
# required argument is added in Python 3.7
subparsers.required = True
@@ -36,9 +34,7 @@ class Command(BaseCommand):
command = command_class(self.stdout, self.stderr)
command.style = self.style
subparser = subparsers.add_parser(
command_name, help=command_class.help
)
subparser = subparsers.add_parser(command_name, help=command_class.help)
# This is needed to output console friendly errors
subparser.called_from_command_line = self._called_from_command_line
@@ -47,4 +43,4 @@ class Command(BaseCommand):
subparser.set_defaults(command=command)
def execute(self, *args, **options):
return options.pop('command').execute(*args, **options)
return options.pop("command").execute(*args, **options)
@@ -18,12 +18,18 @@ class ExportCommand(BaseCommand):
def add_arguments(self, parser):
"""Add arguments to command."""
parser.add_argument(
"--sepchar", type=str, dest="sepchar", default=";",
help="Separator used in generated file."
"--sepchar",
type=str,
dest="sepchar",
default=";",
help="Separator used in generated file.",
)
parser.add_argument(
"objtype", type=str, choices=["domains", "identities"],
help="The type of object to export (domains or identities)")
"objtype",
type=str,
choices=["domains", "identities"],
help="The type of object to export (domains or identities)",
)
def export_domains(self):
"""Export all domains."""
@@ -39,7 +45,8 @@ class ExportCommand(BaseCommand):
qset = (
models.Alias.objects.filter(internal=False)
.exclude(alias_recipient_aliases=None)
.distinct().prefetch_related("aliasrecipient_set")
.distinct()
.prefetch_related("aliasrecipient_set")
)
for alias in qset:
alias.to_csv(self.csvwriter)
@@ -56,5 +63,6 @@ class ExportCommand(BaseCommand):
def handle(self, *args, **options):
exts_pool.load_all()
self.csvwriter = csv.writer(
self.stdout, delimiter=smart_str(options["sepchar"]))
self.stdout, delimiter=smart_str(options["sepchar"])
)
getattr(self, "export_{}".format(options["objtype"]))()
@@ -27,33 +27,33 @@ class ImportCommand(BaseCommand):
def add_arguments(self, parser):
"""Add extra arguments to command."""
parser.add_argument(
"--sepchar", type=str, default=";",
help="Separator used in file.")
"--sepchar", type=str, default=";", help="Separator used in file."
)
parser.add_argument(
"--continue-if-exists", action="store_true",
dest="continue_if_exists", default=False,
help="Continue even if an entry already exists.")
"--continue-if-exists",
action="store_true",
dest="continue_if_exists",
default=False,
help="Continue even if an entry already exists.",
)
parser.add_argument(
"--crypt-password", action="store_true",
default=False, help="Encrypt provided passwords.")
parser.add_argument(
"files", type=str, nargs="+", help="CSV files to import.")
"--crypt-password",
action="store_true",
default=False,
help="Encrypt provided passwords.",
)
parser.add_argument("files", type=str, nargs="+", help="CSV files to import.")
def _import(self, filename, options, encoding="utf-8"):
"""Import domains or identities."""
superadmin = (
core_models.User.objects.filter(is_superuser=True).first()
)
superadmin = core_models.User.objects.filter(is_superuser=True).first()
if not os.path.isfile(filename):
raise CommandError("File not found")
num_lines = sum(
1 for line in io.open(filename, encoding=encoding) if line
)
num_lines = sum(1 for line in io.open(filename, encoding=encoding) if line)
pbar = progressbar.ProgressBar(
widgets=[
progressbar.Percentage(), progressbar.Bar(), progressbar.ETA()
], maxval=num_lines
widgets=[progressbar.Percentage(), progressbar.Bar(), progressbar.ETA()],
maxval=num_lines,
).start()
with io.open(filename, encoding=encoding, newline="") as f:
reader = csv.reader(f, delimiter=options["sepchar"])
@@ -62,7 +62,8 @@ class ImportCommand(BaseCommand):
if not row:
continue
fct = signals.import_object.send(
sender=self.__class__, objtype=row[0].strip())
sender=self.__class__, objtype=row[0].strip()
)
fct = [func for x_, func in fct if func is not None]
if not fct:
continue
@@ -74,7 +75,9 @@ class ImportCommand(BaseCommand):
continue
raise CommandError(
"Object already exists at line {}: {}".format(
i+1, options["sepchar"].join(row[:2])))
i + 1, options["sepchar"].join(row[:2])
)
)
i += 1
pbar.update(i)
@@ -90,10 +93,14 @@ class ImportCommand(BaseCommand):
except CommandError as exc:
raise exc
except UnicodeDecodeError:
self.stdout.write(self.style.NOTICE(
_("CSV file is not encoded in UTF-8, attempting to guess "
"encoding")
))
self.stdout.write(
self.style.NOTICE(
_(
"CSV file is not encoded in UTF-8, attempting to guess "
"encoding"
)
)
)
detector = UniversalDetector()
with io.open(filename, "rb") as fp:
for line in fp:
@@ -102,18 +109,19 @@ class ImportCommand(BaseCommand):
break
detector.close()
self.stdout.write(self.style.NOTICE(
_("Reading CSV file using %(encoding)s encoding") %
detector.result
))
self.stdout.write(
self.style.NOTICE(
_("Reading CSV file using %(encoding)s encoding")
% detector.result
)
)
try:
with transaction.atomic():
self._import(
filename, options,
encoding=detector.result["encoding"]
filename, options, encoding=detector.result["encoding"]
)
except UnicodeDecodeError as exc:
raise CommandError(
_("Unable to decode CSV file using %(encoding)s "
"encoding") % detector.result
_("Unable to decode CSV file using %(encoding)s " "encoding")
% detector.result
) from exc
@@ -25,8 +25,8 @@ class ManageDKIMKeys(BaseCommand):
if not os.access(storage_dir, os.W_OK):
if not alarm_qset.exists():
domain.alarms.create(
title=_("DKIM path non-writable"),
internal_name=DKIM_WRITE_ERROR)
title=_("DKIM path non-writable"), internal_name=DKIM_WRITE_ERROR
)
else:
alarm = alarm_qset.first()
if alarm.status != ALARM_OPENED:
@@ -35,19 +35,27 @@ class ManageDKIMKeys(BaseCommand):
elif alarm_qset.exists():
alarm_qset.first().close()
key_size = (
domain.dkim_key_length if domain.dkim_key_length
else self.default_key_length)
domain.dkim_key_length
if domain.dkim_key_length
else self.default_key_length
)
code, output = sysutils.exec_cmd(
"openssl genrsa -out {} {}".format(pkey_path, key_size))
"openssl genrsa -out {} {}".format(pkey_path, key_size)
)
if code:
print("Failed to generate DKIM private key for domain {}: {}"
.format(domain.name, smart_str(output)))
print(
"Failed to generate DKIM private key for domain {}: {}".format(
domain.name, smart_str(output)
)
)
domain.dkim_private_key_path = pkey_path
code, output = sysutils.exec_cmd(
"openssl rsa -in {} -pubout".format(pkey_path))
code, output = sysutils.exec_cmd("openssl rsa -in {} -pubout".format(pkey_path))
if code:
print("Failed to generate DKIM public key for domain {}: {}"
.format(domain.name, smart_str(output)))
print(
"Failed to generate DKIM public key for domain {}: {}".format(
domain.name, smart_str(output)
)
)
public_key = ""
for cpt, line in enumerate(smart_str(output).splitlines()):
if cpt == 0 or line.startswith("-----"):
@@ -59,24 +67,27 @@ class ManageDKIMKeys(BaseCommand):
def add_arguments(self, parser):
"""Add arguments to command."""
parser.add_argument(
"--domain", type=str, dest="domain", default="",
help="Domain target for keys generation."
"--domain",
type=str,
dest="domain",
default="",
help="Domain target for keys generation.",
)
def handle(self, *args, **options):
"""Entry point."""
self.default_key_length = param_tools.get_global_parameter(
"dkim_default_key_length")
"dkim_default_key_length"
)
if options["domain"] != "":
domain = models.Domain.objects.filter(name=options["domain"],
enable_dkim=True,
dkim_private_key_path="")
domain = models.Domain.objects.filter(
name=options["domain"], enable_dkim=True, dkim_private_key_path=""
)
if domain.exists():
self.create_new_dkim_key(domain[0])
return
qset = models.Domain.objects.filter(
enable_dkim=True, dkim_private_key_path="")
qset = models.Domain.objects.filter(enable_dkim=True, dkim_private_key_path="")
for domain in qset:
self.create_new_dkim_key(domain)
@@ -40,30 +40,41 @@ class CheckMXRecords(BaseCommand):
def valid_mxs(self):
"""Return valid MXs set in admin."""
valid_mxs = param_tools.get_global_parameter("valid_mxs")
return [ipaddress.ip_network(smart_str(v.strip()))
for v in valid_mxs.split() if v.strip()]
return [
ipaddress.ip_network(smart_str(v.strip()))
for v in valid_mxs.split()
if v.strip()
]
def add_arguments(self, parser):
"""Add extra arguments to command."""
parser.add_argument(
"--no-dnsbl", action="store_true", default=False,
help="Skip DNSBL queries.")
"--no-dnsbl", action="store_true", default=False, help="Skip DNSBL queries."
)
parser.add_argument(
"--email", type=str, action="append", default=[],
help="One or more email to notify")
"--email",
type=str,
action="append",
default=[],
help="One or more email to notify",
)
parser.add_argument(
"--skip-admin-emails", action="store_true",
"--skip-admin-emails",
action="store_true",
default=False,
help="Skip domain's admins email notification.")
help="Skip domain's admins email notification.",
)
parser.add_argument(
"--domain", type=str, action="append", default=[],
help="Domain name or id to update.")
"--domain",
type=str,
action="append",
default=[],
help="Domain name or id to update.",
)
parser.add_argument(
"--timeout", type=int, default=3,
help="Timeout used for queries.")
parser.add_argument(
"--ttl", type=int, default=7200,
help="TTL for dns query.")
"--timeout", type=int, default=3, help="Timeout used for queries."
)
parser.add_argument("--ttl", type=int, default=7200, help="TTL for dns query.")
def query_dnsbl(self, mx_list, provider):
"""Check given IP against given DNSBL provider."""
@@ -79,10 +90,10 @@ class CheckMXRecords(BaseCommand):
pattern = "{}.{}.".format(reverse, provider)
try:
result = socket.gethostbyname(pattern)
#result from dnsbl is in ipv4 format
# result from dnsbl is in ipv4 format
splited_result = result.split(".")
if int(splited_result[-1]) > 15:
#Typical dnsbl result : 127.0.0.[1-15] (depends on services)
# Typical dnsbl result : 127.0.0.[1-15] (depends on services)
result = False
except socket.gaierror:
result = False
@@ -101,13 +112,14 @@ class CheckMXRecords(BaseCommand):
if not result:
result = ""
dnsbl_result = models.DNSBLResult.objects.filter(
domain=domain, provider=provider, mx=mx).first()
domain=domain, provider=provider, mx=mx
).first()
trigger = False
if dnsbl_result is None:
to_create.append(
models.DNSBLResult(
domain=domain, provider=provider, mx=mx,
status=result)
domain=domain, provider=provider, mx=mx, status=result
)
)
if result:
trigger = True
@@ -118,22 +130,15 @@ class CheckMXRecords(BaseCommand):
trigger = True
alarm_name = "domain_mx_in_dnsbl_{}".format(provider)
if trigger:
title = _("MX {} listed by DNSBL provider {}").format(
mx.name, provider)
title = _("MX {} listed by DNSBL provider {}").format(mx.name, provider)
domain.alarms.create(
internal_name=alarm_name,
status=constants.ALARM_OPENED,
title=title
internal_name=alarm_name, status=constants.ALARM_OPENED, title=title
)
alerts.append((provider, mx.name))
else:
domain.alarms.filter(
internal_name=alarm_name,
status=constants.ALARM_OPENED
).update(
status=constants.ALARM_CLOSED,
closed=timezone.now()
)
internal_name=alarm_name, status=constants.ALARM_OPENED
).update(status=constants.ALARM_CLOSED, closed=timezone.now())
models.DNSBLResult.objects.bulk_create(to_create)
return alerts
@@ -142,8 +147,9 @@ class CheckMXRecords(BaseCommand):
emails = list(options["email"])
if not options["skip_admin_emails"]:
emails.extend(
domain.admins.exclude(mailbox__isnull=True)
.values_list("email", flat=True)
domain.admins.exclude(mailbox__isnull=True).values_list(
"email", flat=True
)
)
if not len(emails):
return
@@ -159,24 +165,21 @@ class CheckMXRecords(BaseCommand):
"""
alerts = []
check = False
mxs = [(mx, ipaddress.ip_address("%s" % mx.address))
for mx in mx_list]
mxs = [(mx, ipaddress.ip_address("%s" % mx.address)) for mx in mx_list]
valid_mxs = self.valid_mxs
if not mxs:
alarm, created = domain.alarms.get_or_create(
internal_name="domain_has_no_mx",
status=constants.ALARM_OPENED,
defaults={"title": _("Domain has no MX record")}
defaults={"title": _("Domain has no MX record")},
)
if created:
alerts.append(
_("Domain {} has no MX record").format(domain.name))
alerts.append(_("Domain {} has no MX record").format(domain.name))
else:
# Close opened alarm
domain.alarms.filter(
internal_name="domain_has_no_mx",
status=constants.ALARM_OPENED).update(
status=constants.ALARM_CLOSED, closed=timezone.now())
internal_name="domain_has_no_mx", status=constants.ALARM_OPENED
).update(status=constants.ALARM_CLOSED, closed=timezone.now())
if valid_mxs:
for subnet in valid_mxs:
for mx, addr in mxs:
@@ -184,67 +187,62 @@ class CheckMXRecords(BaseCommand):
mx.managed = check = True
mx.save()
if check is False:
mx_names = [
"{0.name} ({0.address})".format(mx) for mx in mx_list]
mx_names = ["{0.name} ({0.address})".format(mx) for mx in mx_list]
alarm, created = domain.alarms.get_or_create(
internal_name="domain_invalid_mx",
status=constants.ALARM_OPENED,
defaults={
"title": _("Invalid MX record: {}").format(
", ".join(mx_names))
}
", ".join(mx_names)
)
},
)
if created:
alerts.append(
_("MX record for domain {0} is invalid: {1}")
.format(domain, ", ".join(mx_names))
_("MX record for domain {0} is invalid: {1}").format(
domain, ", ".join(mx_names)
)
)
else:
# Close opened alarm
domain.alarms.filter(
internal_name="domain_invalid_mx",
status=constants.ALARM_OPENED
).update(
status=constants.ALARM_CLOSED,
closed=timezone.now()
)
internal_name="domain_invalid_mx", status=constants.ALARM_OPENED
).update(status=constants.ALARM_CLOSED, closed=timezone.now())
if not alerts:
return
subject = _("[modoboa] MX issue(s) for domain {}").format(
domain.name)
subject = _("[modoboa] MX issue(s) for domain {}").format(domain.name)
tpl = "admin/notifications/domain_invalid_mx.html"
self.send_alert_notifications(domain, alerts, subject, tpl, **options)
def check_domain(self, domain, timeout=3, ttl=7200, **options):
"""Check specified domain."""
mx_list = list(
models.MXRecord.objects.get_or_create_for_domain(domain, ttl))
mx_list = list(models.MXRecord.objects.get_or_create_for_domain(domain, ttl))
if param_tools.get_global_parameter("enable_mx_checks"):
self.check_valid_mx(domain, mx_list, **options)
if param_tools.get_global_parameter("enable_spf_checks"):
dns_models.DNSRecord.objects.get_or_create_for_domain(
domain, "spf", ttl)
dns_models.DNSRecord.objects.get_or_create_for_domain(domain, "spf", ttl)
condition = (
param_tools.get_global_parameter("enable_dkim_checks") and
domain.dkim_public_key
param_tools.get_global_parameter("enable_dkim_checks")
and domain.dkim_public_key
)
if condition:
dns_models.DNSRecord.objects.get_or_create_for_domain(
domain, "dkim", ttl)
dns_models.DNSRecord.objects.get_or_create_for_domain(domain, "dkim", ttl)
if param_tools.get_global_parameter("enable_dmarc_checks"):
dns_models.DNSRecord.objects.get_or_create_for_domain(
domain, "dmarc", ttl)
dns_models.DNSRecord.objects.get_or_create_for_domain(domain, "dmarc", ttl)
if param_tools.get_global_parameter("enable_autoconfig_checks"):
dns_models.DNSRecord.objects.get_or_create_for_domain(
domain, "autoconfig", ttl)
domain, "autoconfig", ttl
)
dns_models.DNSRecord.objects.get_or_create_for_domain(
domain, "autodiscover", ttl)
domain, "autodiscover", ttl
)
condition = (
not param_tools.get_global_parameter("enable_dnsbl_checks") or
options["no_dnsbl"] is True)
not param_tools.get_global_parameter("enable_dnsbl_checks")
or options["no_dnsbl"] is True
)
if condition or not mx_list:
return
@@ -257,27 +255,25 @@ class CheckMXRecords(BaseCommand):
jobs = [
gevent.spawn(self.query_dnsbl, mx_by_ip, provider)
for provider in self.providers]
for provider in self.providers
]
gevent.joinall(jobs, timeout)
alerts = []
for job in jobs:
if not job.successful():
continue
provider, results = job.value
alerts += self.store_dnsbl_result(
domain, provider, results, **options)
alerts += self.store_dnsbl_result(domain, provider, results, **options)
if not alerts:
return
subject = _("[modoboa] DNSBL issue(s) for domain {}").format(
domain.name)
subject = _("[modoboa] DNSBL issue(s) for domain {}").format(domain.name)
tpl = "admin/notifications/domain_in_dnsbl.html"
self.send_alert_notifications(domain, alerts, subject, tpl, **options)
def handle(self, *args, **options):
"""Command entry point."""
# Remove deprecated records first
models.DNSBLResult.objects.exclude(
provider__in=self.providers).delete()
models.DNSBLResult.objects.exclude(provider__in=self.providers).delete()
if options["domain"]:
domains = []
@@ -290,8 +286,7 @@ class CheckMXRecords(BaseCommand):
except models.Domain.DoesNotExist:
pass
else:
domains = models.Domain.objects.filter(
enabled=True, enable_dns_checks=True)
domains = models.Domain.objects.filter(enabled=True, enable_dns_checks=True)
options.pop("domain")
@@ -33,8 +33,7 @@ def fix_owner(qs, dry_run=False, **options):
log(" {cls} {obj} has no owner".format(**kw), **options)
continue
if isinstance(obj, User):
admin = User.objects.filter(
is_superuser=True, is_active=True).first()
admin = User.objects.filter(is_superuser=True, is_active=True).first()
elif isinstance(obj, models.Domain):
admin = obj.admins.first()
elif isinstance(obj, models.DomainAlias):
@@ -43,12 +42,10 @@ def fix_owner(qs, dry_run=False, **options):
admin = obj.domain.admins.first()
if not admin:
# Fallback: use the first superuser found
admin = User.objects.filter(
is_superuser=True, is_active=True).first()
admin = User.objects.filter(is_superuser=True, is_active=True).first()
grant_access_to_object(admin, obj, is_owner=True)
kw["admin"] = admin
log(" {cls} {obj} is now owned by {admin}".format(**kw),
**options)
log(" {cls} {obj} is now owned by {admin}".format(**kw), **options)
@known_problem
@@ -72,22 +69,24 @@ def sometimes_mailbox_have_no_alias(**options):
recipient_created = 0
for instance in models.Mailbox.objects.select_related("domain").all():
alias, created = models.Alias.objects.get_or_create(
address=instance.full_address,
domain=instance.domain,
internal=True)
address=instance.full_address, domain=instance.domain, internal=True
)
if created:
alias_created += 1
log("Alias {0} created".format(alias), **options)
recipient, created = models.AliasRecipient.objects.get_or_create(
alias=alias,
address=instance.full_address,
r_mailbox=instance)
alias=alias, address=instance.full_address, r_mailbox=instance
)
if created:
recipient_created += 1
log("AliasRecipient {0} created".format(recipient), **options)
if alias_created or recipient_created:
log("{0} alias created. {1} alias recipient created".format(
alias_created, recipient_created), **options)
log(
"{0} alias created. {1} alias recipient created".format(
alias_created, recipient_created
),
**options,
)
class Repair(BaseCommand):
@@ -98,21 +97,21 @@ class Repair(BaseCommand):
def add_arguments(self, parser):
"""Add extra arguments to command."""
parser.add_argument(
"--dry-run", action="store_true", default=False,
help="List known problems without fixing them.")
"--dry-run",
action="store_true",
default=False,
help="List known problems without fixing them.",
)
parser.add_argument(
"--quiet", action="store_true", default=False,
help="Quiet mode.")
"--quiet", action="store_true", default=False, help="Quiet mode."
)
def handle(self, *args, **options):
"""Command entry point."""
# Load known problems from extensions.
for ext in settings.MODOBOA_APPS:
try:
__import__(
ext, locals(), globals(),
[smart_str("known_problems")]
)
__import__(ext, locals(), globals(), [smart_str("known_problems")])
except ImportError:
pass
for func in known_problems:
+224 -78
View File
@@ -10,158 +10,304 @@ class Migration(migrations.Migration):
operations = [
migrations.CreateModel(
name='Alias',
name="Alias",
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('address', models.CharField(help_text='The alias address.', max_length=254, verbose_name='address')),
('enabled', models.BooleanField(default=True, help_text='Check to activate this alias', verbose_name='enabled')),
('internal', models.BooleanField(default=False)),
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"address",
models.CharField(
help_text="The alias address.",
max_length=254,
verbose_name="address",
),
),
(
"enabled",
models.BooleanField(
default=True,
help_text="Check to activate this alias",
verbose_name="enabled",
),
),
("internal", models.BooleanField(default=False)),
],
options={
'ordering': ['address'],
"ordering": ["address"],
},
bases=(models.Model,),
),
migrations.CreateModel(
name='AliasRecipient',
name="AliasRecipient",
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('address', models.EmailField(max_length=75)),
('alias', models.ForeignKey(to='admin.Alias', on_delete=models.CASCADE)),
('r_alias', models.ForeignKey(related_name='alias_recipient_aliases', blank=True, to='admin.Alias', null=True, on_delete=models.CASCADE)),
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("address", models.EmailField(max_length=75)),
(
"alias",
models.ForeignKey(to="admin.Alias", on_delete=models.CASCADE),
),
(
"r_alias",
models.ForeignKey(
related_name="alias_recipient_aliases",
blank=True,
to="admin.Alias",
null=True,
on_delete=models.CASCADE,
),
),
],
options={
'db_table': 'modoboa_admin_aliasrecipient',
"db_table": "modoboa_admin_aliasrecipient",
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Domain',
name="Domain",
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('name', models.CharField(help_text='The domain name', unique=True, max_length=100, verbose_name='name')),
('quota', models.IntegerField()),
('enabled', models.BooleanField(default=True, help_text='Check to activate this domain', verbose_name='enabled')),
('type', models.CharField(default=b'domain', max_length=20)),
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"name",
models.CharField(
help_text="The domain name",
unique=True,
max_length=100,
verbose_name="name",
),
),
("quota", models.IntegerField()),
(
"enabled",
models.BooleanField(
default=True,
help_text="Check to activate this domain",
verbose_name="enabled",
),
),
("type", models.CharField(default=b"domain", max_length=20)),
],
options={
'ordering': ['name'],
"ordering": ["name"],
},
bases=(models.Model,),
),
migrations.CreateModel(
name='DomainAlias',
name="DomainAlias",
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('name', models.CharField(help_text='The alias name', unique=True, max_length=100, verbose_name='name')),
('enabled', models.BooleanField(default=True, help_text='Check to activate this alias', verbose_name='enabled')),
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"name",
models.CharField(
help_text="The alias name",
unique=True,
max_length=100,
verbose_name="name",
),
),
(
"enabled",
models.BooleanField(
default=True,
help_text="Check to activate this alias",
verbose_name="enabled",
),
),
],
bases=(models.Model,),
),
migrations.CreateModel(
name='Mailbox',
name="Mailbox",
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('address', models.CharField(help_text='Mailbox address (without the @domain.tld part)', max_length=252, verbose_name='address')),
('quota', models.PositiveIntegerField()),
('use_domain_quota', models.BooleanField(default=False)),
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"address",
models.CharField(
help_text="Mailbox address (without the @domain.tld part)",
max_length=252,
verbose_name="address",
),
),
("quota", models.PositiveIntegerField()),
("use_domain_quota", models.BooleanField(default=False)),
],
bases=(models.Model,),
),
migrations.CreateModel(
name='MailboxOperation',
name="MailboxOperation",
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('type', models.CharField(max_length=20, choices=[(b'rename', b'rename'), (b'delete', b'delete')])),
('argument', models.TextField()),
('mailbox', models.ForeignKey(blank=True, to='admin.Mailbox', null=True, on_delete=models.CASCADE)),
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
(
"type",
models.CharField(
max_length=20,
choices=[(b"rename", b"rename"), (b"delete", b"delete")],
),
),
("argument", models.TextField()),
(
"mailbox",
models.ForeignKey(
blank=True,
to="admin.Mailbox",
null=True,
on_delete=models.CASCADE,
),
),
],
options={
},
options={},
bases=(models.Model,),
),
migrations.CreateModel(
name='ObjectDates',
name="ObjectDates",
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('creation', models.DateTimeField(auto_now_add=True)),
('last_modification', models.DateTimeField(auto_now=True)),
(
"id",
models.AutoField(
verbose_name="ID",
serialize=False,
auto_created=True,
primary_key=True,
),
),
("creation", models.DateTimeField(auto_now_add=True)),
("last_modification", models.DateTimeField(auto_now=True)),
],
options={
},
options={},
bases=(models.Model,),
),
migrations.CreateModel(
name='Quota',
name="Quota",
fields=[
('username', models.EmailField(max_length=254, serialize=False, primary_key=True)),
('bytes', models.BigIntegerField(default=0)),
('messages', models.IntegerField(default=0)),
(
"username",
models.EmailField(
max_length=254, serialize=False, primary_key=True
),
),
("bytes", models.BigIntegerField(default=0)),
("messages", models.IntegerField(default=0)),
],
options={
},
options={},
bases=(models.Model,),
),
migrations.AddField(
model_name='mailbox',
name='dates',
field=models.ForeignKey(to='admin.ObjectDates', on_delete=models.CASCADE),
model_name="mailbox",
name="dates",
field=models.ForeignKey(to="admin.ObjectDates", on_delete=models.CASCADE),
preserve_default=True,
),
migrations.AddField(
model_name='mailbox',
name='domain',
field=models.ForeignKey(to='admin.Domain', on_delete=models.CASCADE),
model_name="mailbox",
name="domain",
field=models.ForeignKey(to="admin.Domain", on_delete=models.CASCADE),
preserve_default=True,
),
migrations.AddField(
model_name='mailbox',
name='user',
field=models.OneToOneField(to=settings.AUTH_USER_MODEL, on_delete=models.CASCADE),
model_name="mailbox",
name="user",
field=models.OneToOneField(
to=settings.AUTH_USER_MODEL, on_delete=models.CASCADE
),
preserve_default=True,
),
migrations.AddField(
model_name='domainalias',
name='dates',
field=models.ForeignKey(to='admin.ObjectDates', on_delete=models.CASCADE),
model_name="domainalias",
name="dates",
field=models.ForeignKey(to="admin.ObjectDates", on_delete=models.CASCADE),
preserve_default=True,
),
migrations.AddField(
model_name='domainalias',
name='target',
field=models.ForeignKey(verbose_name='target', to='admin.Domain', help_text='The domain this alias points to', on_delete=models.CASCADE),
model_name="domainalias",
name="target",
field=models.ForeignKey(
verbose_name="target",
to="admin.Domain",
help_text="The domain this alias points to",
on_delete=models.CASCADE,
),
preserve_default=True,
),
migrations.AddField(
model_name='domain',
name='dates',
field=models.ForeignKey(to='admin.ObjectDates', on_delete=models.CASCADE),
model_name="domain",
name="dates",
field=models.ForeignKey(to="admin.ObjectDates", on_delete=models.CASCADE),
preserve_default=True,
),
migrations.AddField(
model_name='aliasrecipient',
name='r_mailbox',
field=models.ForeignKey(blank=True, to='admin.Mailbox', null=True, on_delete=models.CASCADE),
model_name="aliasrecipient",
name="r_mailbox",
field=models.ForeignKey(
blank=True, to="admin.Mailbox", null=True, on_delete=models.CASCADE
),
preserve_default=True,
),
migrations.AlterUniqueTogether(
name='aliasrecipient',
unique_together=set([('alias', 'r_alias'), ('alias', 'r_mailbox')]),
name="aliasrecipient",
unique_together=set([("alias", "r_alias"), ("alias", "r_mailbox")]),
),
migrations.AddField(
model_name='alias',
name='dates',
field=models.ForeignKey(to='admin.ObjectDates', on_delete=models.CASCADE),
model_name="alias",
name="dates",
field=models.ForeignKey(to="admin.ObjectDates", on_delete=models.CASCADE),
preserve_default=True,
),
migrations.AddField(
model_name='alias',
name='domain',
field=models.ForeignKey(to='admin.Domain', null=True, on_delete=models.CASCADE),
model_name="alias",
name="domain",
field=models.ForeignKey(
to="admin.Domain", null=True, on_delete=models.CASCADE
),
preserve_default=True,
),
migrations.AlterUniqueTogether(
name='alias',
unique_together=set([('address', 'internal')]),
name="alias",
unique_together=set([("address", "internal")]),
),
]
@@ -6,8 +6,7 @@ def rename_and_clean(apps, schema_editor):
ContentType = apps.get_model("contenttypes", "ContentType")
for ct in ContentType.objects.filter(app_label="admin"):
try:
old_ct = ContentType.objects.get(
app_label="modoboa_admin", model=ct.model)
old_ct = ContentType.objects.get(app_label="modoboa_admin", model=ct.model)
except ContentType.DoesNotExist:
continue
old_ct.app_label = "admin"
@@ -29,8 +28,8 @@ def rename_and_clean(apps, schema_editor):
class Migration(migrations.Migration):
dependencies = [
('admin', '0001_initial'),
('contenttypes', '0002_remove_content_type_name'),
("admin", "0001_initial"),
("contenttypes", "0002_remove_content_type_name"),
]
operations = [
@@ -4,13 +4,13 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0002_migrate_from_modoboa_admin'),
("admin", "0002_migrate_from_modoboa_admin"),
]
operations = [
migrations.AlterField(
model_name='aliasrecipient',
name='address',
model_name="aliasrecipient",
name="address",
field=models.EmailField(max_length=254),
),
]
@@ -6,59 +6,100 @@ import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('admin', '0003_auto_20151118_1215'),
("admin", "0003_auto_20151118_1215"),
]
operations = [
migrations.CreateModel(
name='DNSBLResult',
name="DNSBLResult",
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('provider', models.CharField(db_index=True, max_length=254)),
('status', models.CharField(blank=True, db_index=True, max_length=45)),
('domain', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='admin.Domain')),
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("provider", models.CharField(db_index=True, max_length=254)),
("status", models.CharField(blank=True, db_index=True, max_length=45)),
(
"domain",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE, to="admin.Domain"
),
),
],
),
migrations.CreateModel(
name='MXRecord',
name="MXRecord",
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=254)),
('address', models.GenericIPAddressField()),
('managed', models.BooleanField(default=False)),
('updated', models.DateTimeField()),
('domain', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='admin.Domain')),
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("name", models.CharField(max_length=254)),
("address", models.GenericIPAddressField()),
("managed", models.BooleanField(default=False)),
("updated", models.DateTimeField()),
(
"domain",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE, to="admin.Domain"
),
),
],
),
migrations.CreateModel(
name='SenderAddress',
name="SenderAddress",
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('address', models.EmailField(max_length=254)),
('mailbox', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='admin.Mailbox')),
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("address", models.EmailField(max_length=254)),
(
"mailbox",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE, to="admin.Mailbox"
),
),
],
),
migrations.AddField(
model_name='alias',
name='description',
model_name="alias",
name="description",
field=models.TextField(blank=True),
),
migrations.AddField(
model_name='alias',
name='expire_at',
model_name="alias",
name="expire_at",
field=models.DateTimeField(blank=True, null=True),
),
migrations.AddField(
model_name='dnsblresult',
name='mx',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='admin.MXRecord'),
model_name="dnsblresult",
name="mx",
field=models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE, to="admin.MXRecord"
),
),
migrations.AlterUniqueTogether(
name='senderaddress',
unique_together=set([('address', 'mailbox')]),
name="senderaddress",
unique_together=set([("address", "mailbox")]),
),
migrations.AlterUniqueTogether(
name='dnsblresult',
unique_together=set([('domain', 'provider', 'mx')]),
name="dnsblresult",
unique_together=set([("domain", "provider", "mx")]),
),
]
@@ -5,18 +5,18 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0004_auto_20160914_0907'),
("admin", "0004_auto_20160914_0907"),
]
operations = [
migrations.AlterField(
model_name='alias',
name='description',
field=models.TextField(blank=True, verbose_name='Description'),
model_name="alias",
name="description",
field=models.TextField(blank=True, verbose_name="Description"),
),
migrations.AlterField(
model_name='alias',
name='expire_at',
field=models.DateTimeField(blank=True, null=True, verbose_name='Expire at'),
model_name="alias",
name="expire_at",
field=models.DateTimeField(blank=True, null=True, verbose_name="Expire at"),
),
]
@@ -19,49 +19,49 @@ def move_dates(apps, schema_editor):
class Migration(migrations.Migration):
dependencies = [
('admin', '0005_auto_20161026_1003'),
("admin", "0005_auto_20161026_1003"),
]
operations = [
migrations.AddField(
model_name='alias',
name='creation',
model_name="alias",
name="creation",
field=models.DateTimeField(default=django.utils.timezone.now),
),
migrations.AddField(
model_name='alias',
name='last_modification',
model_name="alias",
name="last_modification",
field=models.DateTimeField(null=True),
),
migrations.AddField(
model_name='domain',
name='creation',
model_name="domain",
name="creation",
field=models.DateTimeField(default=django.utils.timezone.now),
),
migrations.AddField(
model_name='domain',
name='last_modification',
model_name="domain",
name="last_modification",
field=models.DateTimeField(null=True),
),
migrations.AddField(
model_name='domainalias',
name='creation',
model_name="domainalias",
name="creation",
field=models.DateTimeField(default=django.utils.timezone.now),
),
migrations.AddField(
model_name='domainalias',
name='last_modification',
model_name="domainalias",
name="last_modification",
field=models.DateTimeField(null=True),
),
migrations.AddField(
model_name='mailbox',
name='creation',
model_name="mailbox",
name="creation",
field=models.DateTimeField(default=django.utils.timezone.now),
),
migrations.AddField(
model_name='mailbox',
name='last_modification',
model_name="mailbox",
name="last_modification",
field=models.DateTimeField(null=True),
),
migrations.RunPython(move_dates)
migrations.RunPython(move_dates),
]
@@ -5,48 +5,48 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0006_auto_20161104_1900'),
('relaydomains', '0005_auto_20161105_1426'),
("admin", "0006_auto_20161104_1900"),
("relaydomains", "0005_auto_20161105_1426"),
]
operations = [
migrations.RemoveField(
model_name='alias',
name='dates',
model_name="alias",
name="dates",
),
migrations.RemoveField(
model_name='domain',
name='dates',
model_name="domain",
name="dates",
),
migrations.RemoveField(
model_name='domainalias',
name='dates',
model_name="domainalias",
name="dates",
),
migrations.RemoveField(
model_name='mailbox',
name='dates',
model_name="mailbox",
name="dates",
),
migrations.AlterField(
model_name='alias',
name='last_modification',
model_name="alias",
name="last_modification",
field=models.DateTimeField(auto_now=True),
),
migrations.AlterField(
model_name='domain',
name='last_modification',
model_name="domain",
name="last_modification",
field=models.DateTimeField(auto_now=True),
),
migrations.AlterField(
model_name='domainalias',
name='last_modification',
model_name="domainalias",
name="last_modification",
field=models.DateTimeField(auto_now=True),
),
migrations.AlterField(
model_name='mailbox',
name='last_modification',
model_name="mailbox",
name="last_modification",
field=models.DateTimeField(auto_now=True),
),
migrations.DeleteModel(
name='ObjectDates',
name="ObjectDates",
),
]
@@ -5,13 +5,17 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0007_auto_20161104_1915'),
("admin", "0007_auto_20161104_1915"),
]
operations = [
migrations.AddField(
model_name='domain',
name='enable_dns_checks',
field=models.BooleanField(default=True, help_text='Check to enable DNS checks for this domain', verbose_name='Enable DNS checks'),
model_name="domain",
name="enable_dns_checks",
field=models.BooleanField(
default=True,
help_text="Check to enable DNS checks for this domain",
verbose_name="Enable DNS checks",
),
),
]
@@ -5,13 +5,13 @@ from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('admin', '0008_domain_enable_dns_checks'),
("admin", "0008_domain_enable_dns_checks"),
]
operations = [
migrations.RenameField(
model_name='domain',
old_name='quota',
new_name='default_mailbox_quota',
model_name="domain",
old_name="quota",
new_name="default_mailbox_quota",
),
]
@@ -5,23 +5,30 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0009_auto_20170215_0948'),
("admin", "0009_auto_20170215_0948"),
]
operations = [
migrations.AddField(
model_name='domain',
name='quota',
field=models.PositiveIntegerField(default=0, help_text='Quota in MB shared between mailboxes. A value of 0 means no quota.'),
model_name="domain",
name="quota",
field=models.PositiveIntegerField(
default=0,
help_text="Quota in MB shared between mailboxes. A value of 0 means no quota.",
),
),
migrations.AlterField(
model_name='domain',
name='default_mailbox_quota',
field=models.PositiveIntegerField(default=0, help_text='Default quota in MB applied to mailboxes. A value of 0 means no quota.', verbose_name='Default mailbox quota'),
model_name="domain",
name="default_mailbox_quota",
field=models.PositiveIntegerField(
default=0,
help_text="Default quota in MB applied to mailboxes. A value of 0 means no quota.",
verbose_name="Default mailbox quota",
),
),
migrations.AlterField(
model_name='mailbox',
name='quota',
model_name="mailbox",
name="quota",
field=models.PositiveIntegerField(default=0),
),
]
@@ -6,14 +6,18 @@ import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('transport', '0001_initial'),
('admin', '0010_auto_20170215_1328'),
("transport", "0001_initial"),
("admin", "0010_auto_20170215_1328"),
]
operations = [
migrations.AddField(
model_name='domain',
name='transport',
field=models.OneToOneField(null=True, on_delete=django.db.models.deletion.SET_NULL, to='transport.Transport'),
model_name="domain",
name="transport",
field=models.OneToOneField(
null=True,
on_delete=django.db.models.deletion.SET_NULL,
to="transport.Transport",
),
),
]
@@ -5,33 +5,44 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0011_domain_transport'),
("admin", "0011_domain_transport"),
]
operations = [
migrations.AddField(
model_name='domain',
name='dkim_key_length',
field=models.PositiveIntegerField(blank=True, choices=[(1024, '1024'), (2048, '2048'), (4096, '4096')], null=True, verbose_name='Key length'),
model_name="domain",
name="dkim_key_length",
field=models.PositiveIntegerField(
blank=True,
choices=[(1024, "1024"), (2048, "2048"), (4096, "4096")],
null=True,
verbose_name="Key length",
),
),
migrations.AddField(
model_name='domain',
name='dkim_key_selector',
field=models.CharField(default='modoboa', max_length=30, verbose_name='Key selector'),
model_name="domain",
name="dkim_key_selector",
field=models.CharField(
default="modoboa", max_length=30, verbose_name="Key selector"
),
),
migrations.AddField(
model_name='domain',
name='dkim_private_key_path',
model_name="domain",
name="dkim_private_key_path",
field=models.CharField(blank=True, max_length=254),
),
migrations.AddField(
model_name='domain',
name='dkim_public_key',
model_name="domain",
name="dkim_public_key",
field=models.TextField(blank=True),
),
migrations.AddField(
model_name='domain',
name='enable_dkim',
field=models.BooleanField(default=False, help_text='If you activate this feature, a DKIM key will be generated for this domain.', verbose_name='Enable DKIM signing'),
model_name="domain",
name="enable_dkim",
field=models.BooleanField(
default=False,
help_text="If you activate this feature, a DKIM key will be generated for this domain.",
verbose_name="Enable DKIM signing",
),
),
]
@@ -5,23 +5,25 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0012_auto_20180112_1658'),
("admin", "0012_auto_20180112_1658"),
]
operations = [
migrations.AlterField(
model_name='domain',
name='dkim_key_selector',
field=models.CharField(default='modoboa', max_length=30),
model_name="domain",
name="dkim_key_selector",
field=models.CharField(default="modoboa", max_length=30),
),
migrations.AlterField(
model_name='domain',
name='type',
field=models.CharField(default='domain', max_length=20),
model_name="domain",
name="type",
field=models.CharField(default="domain", max_length=20),
),
migrations.AlterField(
model_name='mailboxoperation',
name='type',
field=models.CharField(choices=[('rename', 'rename'), ('delete', 'delete')], max_length=20),
model_name="mailboxoperation",
name="type",
field=models.CharField(
choices=[("rename", "rename"), ("delete", "delete")], max_length=20
),
),
]
@@ -5,18 +5,20 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0013_auto_20180124_2311'),
("admin", "0013_auto_20180124_2311"),
]
operations = [
migrations.AlterField(
model_name='domain',
name='default_mailbox_quota',
field=models.PositiveIntegerField(default=0, verbose_name='Default mailbox quota'),
model_name="domain",
name="default_mailbox_quota",
field=models.PositiveIntegerField(
default=0, verbose_name="Default mailbox quota"
),
),
migrations.AlterField(
model_name='domain',
name='quota',
model_name="domain",
name="quota",
field=models.PositiveIntegerField(default=0),
),
]
@@ -5,14 +5,14 @@ import sys
from django.db import IntegrityError, migrations, transaction
VIEW_PERMISSION_CODENAMES = {
'view_aliases': 'view_alias',
'view_domaliases': 'view_domainalias',
'view_mailboxes': 'view_mailbox',
"view_aliases": "view_alias",
"view_domaliases": "view_domainalias",
"view_mailboxes": "view_mailbox",
}
def rename_view_permissions(apps, schema_editor):
Permission = apps.get_model('auth', 'Permission')
Permission = apps.get_model("auth", "Permission")
db_alias = schema_editor.connection.alias
# Iterate over permissions and try to rename the codename
for perm in Permission.objects.using(db_alias).filter(
@@ -36,7 +36,7 @@ def rename_view_permissions(apps, schema_editor):
class Migration(migrations.Migration):
dependencies = [
('admin', '0014_auto_20181017_1628'),
("admin", "0014_auto_20181017_1628"),
]
operations = [
@@ -6,18 +6,28 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0015_rename_view_permissions'),
("admin", "0015_rename_view_permissions"),
]
operations = [
migrations.AddField(
model_name='domain',
name='message_limit',
field=models.PositiveIntegerField(blank=True, help_text='Number of messages this domain can send per day', null=True, verbose_name='Message sending limit'),
model_name="domain",
name="message_limit",
field=models.PositiveIntegerField(
blank=True,
help_text="Number of messages this domain can send per day",
null=True,
verbose_name="Message sending limit",
),
),
migrations.AddField(
model_name='mailbox',
name='message_limit',
field=models.PositiveIntegerField(blank=True, help_text='Number of messages this mailbox can send per day', null=True, verbose_name='Message sending limit'),
model_name="mailbox",
name="message_limit",
field=models.PositiveIntegerField(
blank=True,
help_text="Number of messages this mailbox can send per day",
null=True,
verbose_name="Message sending limit",
),
),
]
+40 -11
View File
@@ -8,24 +8,53 @@ import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [
('admin', '0016_auto_20200602_1201'),
("admin", "0016_auto_20200602_1201"),
]
operations = [
migrations.CreateModel(
name='Alarm',
name="Alarm",
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('created', models.DateTimeField(default=django.utils.timezone.now)),
('closed', models.DateTimeField(blank=True, null=True)),
('status', models.IntegerField(choices=[(1, 'Opened'), (2, 'Closed')], db_index=True, default=1)),
('title', models.CharField(max_length=150)),
('internal_name', models.CharField(max_length=120)),
('domain', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='alarms', to='admin.Domain')),
('mailbox', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='alarms', to='admin.Mailbox')),
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("created", models.DateTimeField(default=django.utils.timezone.now)),
("closed", models.DateTimeField(blank=True, null=True)),
(
"status",
models.IntegerField(
choices=[(1, "Opened"), (2, "Closed")], db_index=True, default=1
),
),
("title", models.CharField(max_length=150)),
("internal_name", models.CharField(max_length=120)),
(
"domain",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
related_name="alarms",
to="admin.Domain",
),
),
(
"mailbox",
models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
related_name="alarms",
to="admin.Mailbox",
),
),
],
options={
'ordering': ['created'],
"ordering": ["created"],
},
),
]
@@ -6,13 +6,13 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0017_alarm'),
("admin", "0017_alarm"),
]
operations = [
migrations.AlterField(
model_name='alarm',
name='title',
model_name="alarm",
name="title",
field=models.TextField(),
),
]
@@ -4,14 +4,13 @@ from django.db import migrations
def update_disabled_accounts_aliases(apps, schema_editor):
User = apps.get_model('core', 'User')
Alias = apps.get_model('admin', 'Alias')
User = apps.get_model("core", "User")
Alias = apps.get_model("admin", "Alias")
disabled_accounts = User.objects.filter(
mailbox__isnull=False, is_active=False)
disabled_accounts = User.objects.filter(mailbox__isnull=False, is_active=False)
Alias.objects.filter(
address__in=list(disabled_accounts.values_list('email', flat=True)),
address__in=list(disabled_accounts.values_list("email", flat=True)),
enabled=True,
).update(enabled=False)
@@ -19,8 +18,8 @@ def update_disabled_accounts_aliases(apps, schema_editor):
class Migration(migrations.Migration):
dependencies = [
('admin', '0018_auto_20201204_0935'),
('core', '0022_user_tfa_enabled'),
("admin", "0018_auto_20201204_0935"),
("core", "0022_user_tfa_enabled"),
]
operations = [
@@ -6,13 +6,18 @@ from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('admin', '0019_update_disabled_accounts_aliases'),
("admin", "0019_update_disabled_accounts_aliases"),
]
operations = [
migrations.AlterField(
model_name='domain',
name='name',
field=models.CharField(help_text='The domain name', max_length=253, unique=True, verbose_name='name'),
model_name="domain",
name="name",
field=models.CharField(
help_text="The domain name",
max_length=253,
unique=True,
verbose_name="name",
),
),
]
+1 -4
View File
@@ -1,10 +1,7 @@
"""Admin models."""
from .alarm import Alarm
from .alias import (
Alias,
AliasRecipient,
validate_alias_address)
from .alias import Alias, AliasRecipient, validate_alias_address
from .base import AdminObject
from .domain import Domain
from .domain_alias import DomainAlias
+14 -8
View File
@@ -20,18 +20,23 @@ class Alarm(models.Model):
"""A simple alarm to attach to a domain and/or mailbox."""
domain = models.ForeignKey(
"admin.Domain", on_delete=models.CASCADE, related_name="alarms",
blank=True, null=True)
mailbox = models.ForeignKey(
"admin.Mailbox", on_delete=models.SET_NULL,
"admin.Domain",
on_delete=models.CASCADE,
related_name="alarms",
null=True, blank=True,
blank=True,
null=True,
)
mailbox = models.ForeignKey(
"admin.Mailbox",
on_delete=models.SET_NULL,
related_name="alarms",
null=True,
blank=True,
)
created = models.DateTimeField(default=timezone.now)
closed = models.DateTimeField(null=True, blank=True)
status = models.IntegerField(
default=constants.ALARM_OPENED, choices=constants.ALARM_STATUSES,
db_index=True
default=constants.ALARM_OPENED, choices=constants.ALARM_STATUSES, db_index=True
)
title = models.TextField()
@@ -44,7 +49,8 @@ class Alarm(models.Model):
def __str__(self):
return "[{}] {} - {}".format(
self.created, self.domain, self.get_status_display())
self.created, self.domain, self.get_status_display()
)
def close(self):
"""Close this alarm."""
+58 -69
View File
@@ -6,9 +6,7 @@ import random
from django.core.exceptions import ValidationError
from django.db import models
from django.urls import reverse
from django.utils.encoding import (
force_bytes, force_str, smart_str
)
from django.utils.encoding import force_bytes, force_str, smart_str
from django.utils.translation import gettext as _, gettext_lazy
from reversion import revisions as reversion
@@ -16,7 +14,11 @@ from reversion import revisions as reversion
from modoboa.core import signals as core_signals
from modoboa.lib.email_utils import split_mailbox
from modoboa.lib.exceptions import (
BadRequest, Conflict, NotFound, ModoboaException, AliasExists
BadRequest,
Conflict,
NotFound,
ModoboaException,
AliasExists,
)
from .. import signals
from .base import AdminObject
@@ -25,8 +27,8 @@ from .mailbox import Mailbox
def validate_alias_address(
address, creator, internal=False, instance=None, ignore_existing=False
):
address, creator, internal=False, instance=None, ignore_existing=False
):
"""Check if the given alias address can be created by creator."""
local_part, domain = split_mailbox(address.lower())
domain = Domain.objects.filter(name=domain).first()
@@ -36,21 +38,21 @@ def validate_alias_address(
raise ValidationError(_("Permission denied."))
if not instance or instance.address != address:
alias = Alias.objects.filter(address=address, internal=internal)
condition = (
alias.exists()
and not ignore_existing
)
condition = alias.exists() and not ignore_existing
if condition:
raise AliasExists(alias.first().pk)
if instance is None:
try:
# Check creator limits
core_signals.can_create_object.send(
sender="validate_alias_address", context=creator, klass=Alias)
sender="validate_alias_address", context=creator, klass=Alias
)
# Check domain limits
core_signals.can_create_object.send(
sender="validate_alias_address", context=domain,
object_type="mailbox_aliases")
sender="validate_alias_address",
context=domain,
object_type="mailbox_aliases",
)
except ModoboaException as inst:
raise ValidationError(str(inst))
return local_part, domain
@@ -78,10 +80,7 @@ class AliasManager(models.Manager):
alias.first().add_recipients(recipients)
return
self.create(
creator=creator,
domain=domain,
address=address,
recipients=recipients
creator=creator, domain=domain, address=address, recipients=recipients
)
@@ -89,29 +88,26 @@ class Alias(AdminObject):
"""Mailbox alias."""
address = models.CharField(
gettext_lazy("address"), max_length=254,
help_text=gettext_lazy(
"The alias address."
)
gettext_lazy("address"),
max_length=254,
help_text=gettext_lazy("The alias address."),
)
domain = models.ForeignKey(Domain, null=True, on_delete=models.CASCADE)
enabled = models.BooleanField(
gettext_lazy("enabled"),
help_text=gettext_lazy("Check to activate this alias"),
default=True
default=True,
)
internal = models.BooleanField(default=False)
description = models.TextField(
gettext_lazy("Description"), blank=True)
expire_at = models.DateTimeField(
gettext_lazy("Expire at"), blank=True, null=True)
description = models.TextField(gettext_lazy("Description"), blank=True)
expire_at = models.DateTimeField(gettext_lazy("Expire at"), blank=True, null=True)
_objectname = "MailboxAlias"
objects = AliasManager()
class Meta:
ordering = ["address"]
unique_together = (("address", "internal"), )
unique_together = (("address", "internal"),)
app_label = "admin"
def __str__(self):
@@ -153,6 +149,7 @@ class Alias(AdminObject):
def post_create(self, creator):
from modoboa.lib.permissions import grant_access_to_object
super(Alias, self).post_create(creator)
if creator.is_superuser:
for admin in self.domain.admins:
@@ -173,33 +170,32 @@ class Alias(AdminObject):
continue
if self.aliasrecipient_set.filter(address=address).exists():
continue
local_part, domname, extension = (
split_mailbox(address, return_extension=True))
local_part, domname, extension = split_mailbox(
address, return_extension=True
)
if domname is None:
raise BadRequest(
u"%s %s" % (_("Invalid address"), address)
)
raise BadRequest("%s %s" % (_("Invalid address"), address))
domain = Domain.objects.filter(name=domname).first()
kwargs = {"address": address, "alias": self}
if (
(domain is not None) and
(
any(
r[1] for r in signals.use_external_recipients.send(
self, recipients=address)
) is False
if (domain is not None) and (
any(
r[1]
for r in signals.use_external_recipients.send(
self, recipients=address
)
)
is False
):
rcpt = Mailbox.objects.filter(
domain=domain, address=local_part).first()
rcpt = Mailbox.objects.filter(domain=domain, address=local_part).first()
if rcpt is None:
rcpt = Alias.objects.filter(
address="%s@%s" % (local_part, domname)
).first()
if rcpt is None:
raise NotFound(
_("Local recipient {}@{} not found")
.format(local_part, domname)
_("Local recipient {}@{} not found").format(
local_part, domname
)
)
if rcpt.address == self.address:
raise Conflict
@@ -229,15 +225,13 @@ class Alias(AdminObject):
self.add_recipients(address_list)
# Remove old recipients
self.aliasrecipient_set.exclude(
address__in=address_list).delete()
self.aliasrecipient_set.exclude(address__in=address_list).delete()
@property
def recipients(self):
"""Return the recipient list."""
return (
self.aliasrecipient_set.order_by("address")
.values_list("address", flat=True)
return self.aliasrecipient_set.order_by("address").values_list(
"address", flat=True
)
@property
@@ -245,12 +239,7 @@ class Alias(AdminObject):
"""Return the number of recipients of this alias."""
return self.aliasrecipient_set.count()
def from_csv(self,
user,
row,
expected_elements=5,
formopts=False,
**kwargs):
def from_csv(self, user, row, expected_elements=5, formopts=False, **kwargs):
"""Create a new alias from a CSV file entry."""
if len(row) < expected_elements:
raise BadRequest(_("Invalid line: {}").format(row))
@@ -264,15 +253,16 @@ class Alias(AdminObject):
if formopts:
continue_if_exists = formopts.get("continue_if_exists", False)
if continue_if_exists:
alias = Alias.objects.filter(address=self.address,
internal=False).first()
alias = Alias.objects.filter(
address=self.address, internal=False
).first()
alias.add_recipients([raddress.strip() for raddress in row[3:]])
alias.save()
return
else:
raise e
self.enabled = (row[2].strip().lower() in ["true", "1", "yes", "y"])
self.enabled = row[2].strip().lower() in ["true", "1", "yes", "y"]
self.save()
self.set_recipients([raddress.strip() for raddress in row[3:]])
self.post_create(user)
@@ -291,30 +281,29 @@ reversion.register(Alias)
class AliasRecipient(models.Model):
"""An alias recipient."""
address = models.EmailField()
alias = models.ForeignKey(Alias, on_delete=models.CASCADE)
# if recipient is a local mailbox
r_mailbox = models.ForeignKey(Mailbox, blank=True, null=True,
on_delete=models.CASCADE)
r_mailbox = models.ForeignKey(
Mailbox, blank=True, null=True, on_delete=models.CASCADE
)
# if recipient is a local alias
r_alias = models.ForeignKey(
Alias, related_name="alias_recipient_aliases", blank=True, null=True,
on_delete=models.CASCADE)
Alias,
related_name="alias_recipient_aliases",
blank=True,
null=True,
on_delete=models.CASCADE,
)
class Meta:
app_label = "admin"
db_table = "modoboa_admin_aliasrecipient"
unique_together = [
("alias", "r_mailbox"),
("alias", "r_alias")
]
unique_together = [("alias", "r_mailbox"), ("alias", "r_alias")]
def __str__(self):
"""Return alias and recipient."""
return smart_str(
"{} -> {}".format(self.alias.address, self.address)
)
return smart_str("{} -> {}".format(self.alias.address, self.address))
+1 -3
View File
@@ -5,9 +5,7 @@ from django.db import models
from django.utils import timezone
from modoboa.core import models as core_models
from modoboa.lib.permissions import (
grant_access_to_object, ungrant_access_to_object
)
from modoboa.lib.permissions import grant_access_to_object, ungrant_access_to_object
class AdminObjectManager(models.Manager):
+60 -52
View File
@@ -23,47 +23,54 @@ from . import mixins
class Domain(mixins.MessageLimitMixin, AdminObject):
"""Mail domain."""
name = models.CharField(gettext_lazy("name"), max_length=253, unique=True,
help_text=gettext_lazy("The domain name"))
name = models.CharField(
gettext_lazy("name"),
max_length=253,
unique=True,
help_text=gettext_lazy("The domain name"),
)
quota = models.PositiveIntegerField(
default=0,
)
default_mailbox_quota = models.PositiveIntegerField(
verbose_name=gettext_lazy("Default mailbox quota"),
default=0
verbose_name=gettext_lazy("Default mailbox quota"), default=0
)
message_limit = models.PositiveIntegerField(
gettext_lazy("Message sending limit"),
null=True, blank=True,
help_text=gettext_lazy(
"Number of messages this domain can send per day"
)
null=True,
blank=True,
help_text=gettext_lazy("Number of messages this domain can send per day"),
)
enabled = models.BooleanField(
gettext_lazy("enabled"),
help_text=gettext_lazy("Check to activate this domain"),
default=True
default=True,
)
type = models.CharField(default="domain", max_length=20) # NOQA:A003
enable_dns_checks = models.BooleanField(
gettext_lazy("Enable DNS checks"), default=True,
help_text=gettext_lazy("Check to enable DNS checks for this domain")
gettext_lazy("Enable DNS checks"),
default=True,
help_text=gettext_lazy("Check to enable DNS checks for this domain"),
)
transport = models.OneToOneField(
"transport.Transport", null=True, on_delete=models.SET_NULL)
"transport.Transport", null=True, on_delete=models.SET_NULL
)
enable_dkim = models.BooleanField(
gettext_lazy("Enable DKIM signing"),
help_text=gettext_lazy(
"If you activate this feature, a DKIM key will be "
"generated for this domain."),
default=False
"generated for this domain."
),
default=False,
)
dkim_key_selector = models.CharField(max_length=30, default="modoboa")
dkim_key_length = models.PositiveIntegerField(
gettext_lazy("Key length"), choices=constants.DKIM_KEY_LENGTHS,
blank=True, null=True
gettext_lazy("Key length"),
choices=constants.DKIM_KEY_LENGTHS,
blank=True,
null=True,
)
dkim_public_key = models.TextField(blank=True)
dkim_private_key_path = models.CharField(max_length=254, blank=True)
@@ -94,9 +101,7 @@ class Domain(mixins.MessageLimitMixin, AdminObject):
@property
def identities_count(self) -> int:
"""Total number of identities in this domain."""
return (
self.mailbox_set.count() +
self.alias_set.filter(internal=False).count())
return self.mailbox_set.count() + self.alias_set.filter(internal=False).count()
@property
def opened_alarms_count(self) -> int:
@@ -111,12 +116,14 @@ class Domain(mixins.MessageLimitMixin, AdminObject):
label = dt[1]
result = [{"name": self.type, "label": label, "type": "dom"}]
if self.transport:
result.append({
"name": self.transport.service,
"label": self.transport.service,
"type": "srv",
"color": "info"
})
result.append(
{
"name": self.transport.service,
"label": self.transport.service,
"type": "srv",
"color": "info",
}
)
return result
@property
@@ -128,7 +135,8 @@ class Domain(mixins.MessageLimitMixin, AdminObject):
return User.objects.filter(
is_superuser=False,
objectaccess__content_type__model="domain",
objectaccess__object_id=self.pk)
objectaccess__object_id=self.pk,
)
@property
def aliases(self):
@@ -165,7 +173,10 @@ class Domain(mixins.MessageLimitMixin, AdminObject):
errors = []
if config["enable_mx_checks"] and not self.mxrecord_set.has_valids():
errors.append("mx")
if config["enable_dnsbl_checks"] and self.dnsblresult_set.blacklisted().exists():
if (
config["enable_dnsbl_checks"]
and self.dnsblresult_set.blacklisted().exists()
):
errors.append("dnsbl")
if config["enable_spf_checks"]:
if self.spf_record is None or not self.spf_record.is_valid:
@@ -225,8 +236,7 @@ class Domain(mixins.MessageLimitMixin, AdminObject):
return 0
if not self.mailbox_set.exists():
return 0
return self.mailbox_set.aggregate(
total=models.Sum("quota"))["total"]
return self.mailbox_set.aggregate(total=models.Sum("quota"))["total"]
@cached_property
def allocated_quota_in_percent(self):
@@ -268,14 +278,15 @@ class Domain(mixins.MessageLimitMixin, AdminObject):
split_record = []
while record:
if len(record) > 74:
split_record.append(" \"%s\"" % record[:74])
split_record.append(' "%s"' % record[:74])
record = record[74:]
else:
split_record.append(" \"%s\"" % record)
split_record.append(' "%s"' % record)
break
record = "\n".join(split_record)
return "{}._domainkey.{}. IN TXT (\n{})".format(
self.dkim_key_selector, self.name, record)
self.dkim_key_selector, self.name, record
)
def add_admin(self, account):
"""Add a new administrator to this domain.
@@ -285,7 +296,8 @@ class Domain(mixins.MessageLimitMixin, AdminObject):
from modoboa.lib.permissions import grant_access_to_object
core_signals.can_create_object.send(
sender=self.__class__, context=self, object_type="domain_admins")
sender=self.__class__, context=self, object_type="domain_admins"
)
grant_access_to_object(account, self)
for mb in self.mailbox_set.all():
if mb.user.has_perm("admin.add_domain"):
@@ -315,9 +327,7 @@ class Domain(mixins.MessageLimitMixin, AdminObject):
"""Store current data if domain is renamed."""
# We check that the instance exists to use m2m relationship
if self.pk and self.oldname != self.name:
self.old_mail_homes = {
mb.id: mb.mail_home for mb in self.mailbox_set.all()
}
self.old_mail_homes = {mb.id: mb.mail_home for mb in self.mailbox_set.all()}
if self.old_dkim_key_length != self.dkim_key_length:
self.dkim_public_key = ""
self.dkim_private_key_path = ""
@@ -359,38 +369,36 @@ class Domain(mixins.MessageLimitMixin, AdminObject):
self.name = row[1].strip().lower()
if Domain.objects.filter(name=self.name).exists():
raise Conflict
domains_must_have_authorized_mx = (
param_tools.get_global_parameter("domains_must_have_authorized_mx")
domains_must_have_authorized_mx = param_tools.get_global_parameter(
"domains_must_have_authorized_mx"
)
if domains_must_have_authorized_mx and not user.is_superuser:
if not lib.domain_has_authorized_mx(self.name):
raise BadRequest(
_("{}: no authorized MX record found for domain")
.format(self.name)
_("{}: no authorized MX record found for domain").format(self.name)
)
try:
self.quota = int(row[2].strip())
except ValueError:
raise BadRequest(
_("{}: invalid quota value for domain")
.format(self.name)
)
raise BadRequest(_("{}: invalid quota value for domain").format(self.name))
try:
self.default_mailbox_quota = int(row[3].strip())
except ValueError:
raise BadRequest(
_("{}: invalid default mailbox quota value for domain")
.format(self.name)
_("{}: invalid default mailbox quota value for domain").format(
self.name
)
)
if self.quota != 0 and self.default_mailbox_quota > self.quota:
raise BadRequest(
_("{}: default mailbox quota cannot be greater than domain "
"quota").format(self.name)
_(
"{}: default mailbox quota cannot be greater than domain " "quota"
).format(self.name)
)
self.enabled = (row[4].strip().lower() in ["true", "1", "yes", "y"])
self.enabled = row[4].strip().lower() in ["true", "1", "yes", "y"]
core_signals.can_create_object.send(
sender=self.__class__, context=user, klass=Domain,
instance=self)
sender=self.__class__, context=user, klass=Domain, instance=self
)
self.save(creator=user)
def to_csv_rows(self):
@@ -401,7 +409,7 @@ class Domain(mixins.MessageLimitMixin, AdminObject):
force_str(self.name),
self.quota,
self.default_mailbox_quota,
self.enabled
self.enabled,
]
]
for dalias in self.domainalias_set.all():
+13 -9
View File
@@ -27,20 +27,24 @@ class DomainAliasManager(models.Manager):
class DomainAlias(AdminObject):
"""Domain aliases."""
name = models.CharField(gettext_lazy("name"), max_length=100, unique=True,
help_text=gettext_lazy("The alias name"))
name = models.CharField(
gettext_lazy("name"),
max_length=100,
unique=True,
help_text=gettext_lazy("The alias name"),
)
target = models.ForeignKey(
Domain, verbose_name=gettext_lazy("target"),
Domain,
verbose_name=gettext_lazy("target"),
help_text=gettext_lazy("The domain this alias points to"),
on_delete=models.CASCADE
on_delete=models.CASCADE,
)
enabled = models.BooleanField(
gettext_lazy("enabled"),
help_text=gettext_lazy("Check to activate this alias"),
default=True
default=True,
)
owners = GenericRelation(core_models.ObjectAccess)
@@ -74,14 +78,14 @@ class DomainAlias(AdminObject):
except Domain.DoesNotExist:
raise BadRequest(_("Unknown domain %s") % domname)
core_signals.can_create_object.send(
sender="import", context=self.target, object_type="domain_aliases")
sender="import", context=self.target, object_type="domain_aliases"
)
self.enabled = row[3].strip().lower() in ["true", "1", "yes", "y"]
self.save(creator=user)
def to_csv_row(self):
"""Export to row that can be included in a CSV file."""
return ["domainalias", self.name,
self.target.name, self.enabled]
return ["domainalias", self.name, self.target.name, self.enabled]
def to_csv(self, csvwriter):
"""Export a domain alias using CSV format
+42 -47
View File
@@ -25,8 +25,7 @@ class QuotaManager(models.Manager):
def get_domain_usage(self, domain):
"""Return current usage for domain."""
qset = self.get_queryset().filter(
username__endswith="@{}".format(domain.name))
qset = self.get_queryset().filter(username__endswith="@{}".format(domain.name))
result = qset.aggregate(usage=models.Sum("bytes")).get("usage", 0)
if result is None:
result = 0
@@ -34,7 +33,6 @@ class QuotaManager(models.Manager):
class Quota(models.Model):
"""Keeps track of Mailbox current quota."""
username = models.EmailField(primary_key=True, max_length=254)
@@ -48,7 +46,6 @@ class Quota(models.Model):
class MailboxManager(Manager):
"""Custom manager for Mailbox."""
def get_for_admin(self, admin, squery=None):
@@ -66,18 +63,14 @@ class MailboxManager(Manager):
parts = squery.split("@")
addrfilter = "@".join(parts[:-1])
domfilter = parts[-1]
qf = (
Q(address__contains=addrfilter) &
Q(domain__name__contains=domfilter)
qf = Q(address__contains=addrfilter) & Q(
domain__name__contains=domfilter
)
else:
qf = (
Q(address__contains=squery) |
Q(domain__name__contains=squery)
)
ids = admin.objectaccess_set \
.filter(content_type=ContentType.objects.get_for_model(Mailbox)) \
.values_list("object_id", flat=True)
qf = Q(address__contains=squery) | Q(domain__name__contains=squery)
ids = admin.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(Mailbox)
).values_list("object_id", flat=True)
if qf is not None:
qf = Q(pk__in=ids) & qf
else:
@@ -89,16 +82,17 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
"""User mailbox."""
address = models.CharField(
gettext_lazy("address"), max_length=252,
help_text=gettext_lazy(
"Mailbox address (without the @domain.tld part)")
gettext_lazy("address"),
max_length=252,
help_text=gettext_lazy("Mailbox address (without the @domain.tld part)"),
)
quota = models.PositiveIntegerField(default=0)
use_domain_quota = models.BooleanField(default=False)
message_limit = models.PositiveIntegerField(
gettext_lazy("Message sending limit"), null=True, blank=True,
help_text=gettext_lazy(
"Number of messages this mailbox can send per day")
gettext_lazy("Message sending limit"),
null=True,
blank=True,
help_text=gettext_lazy("Number of messages this mailbox can send per day"),
)
domain = models.ForeignKey(Domain, on_delete=models.CASCADE)
user = models.OneToOneField(User, on_delete=models.CASCADE)
@@ -134,7 +128,8 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
def alias_count(self):
return (
self.recipientalias_set.select_related("alias")
.filter(alias__internal=False).count()
.filter(alias__internal=False)
.count()
)
@property
@@ -155,7 +150,8 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
code, output = doveadm_cmd("user -f home %s" % self.full_address)
if code:
raise lib_exceptions.InternalError(
_("Failed to retrieve mailbox location (%s)") % output)
_("Failed to retrieve mailbox location (%s)") % output
)
self.__mail_home = force_str(output.strip())
return self.__mail_home
@@ -165,9 +161,8 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
:rtype: list of string
"""
qset = (
self.aliasrecipient_set.select_related("alias")
.filter(alias__internal=False)
qset = self.aliasrecipient_set.select_related("alias").filter(
alias__internal=False
)
aliases = [alr.alias.address for alr in qset]
return aliases
@@ -177,8 +172,7 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
"""Retrieve the ``Quota`` instance associated to this mailbox."""
if not hasattr(self, "_quota_value"):
try:
self._quota_value = Quota.objects.get(
username=self.full_address)
self._quota_value = Quota.objects.get(username=self.full_address)
except Quota.DoesNotExist:
return None
return self._quota_value
@@ -195,8 +189,7 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
def rename_dir(self, old_mail_home):
"""Rename local directory if needed."""
hm = param_tools.get_global_parameter(
"handle_mailboxes", raise_exception=False)
hm = param_tools.get_global_parameter("handle_mailboxes", raise_exception=False)
if not hm:
return
MailboxOperation.objects.create(
@@ -219,15 +212,15 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
self.address = address
self.domain = domain
self.quota_value = Quota.objects.create(
username=self.full_address, bytes=old_qvalue.bytes,
messages=old_qvalue.messages
username=self.full_address,
bytes=old_qvalue.bytes,
messages=old_qvalue.messages,
)
old_qvalue.delete()
self.rename_dir(old_mail_home)
def delete_dir(self):
hm = param_tools.get_global_parameter(
"handle_mailboxes", raise_exception=False)
hm = param_tools.get_global_parameter("handle_mailboxes", raise_exception=False)
if not hm:
return
MailboxOperation.objects.create(type="delete", argument=self.mail_home)
@@ -277,16 +270,15 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
"""
if not self.quota:
return 0
return int(
self.quota_value.bytes / float(self.quota * 1048576) * 100
)
return int(self.quota_value.bytes / float(self.quota * 1048576) * 100)
def post_create(self, creator):
from modoboa.lib.permissions import grant_access_to_object
super().post_create(creator)
conditions = (
creator.has_perm("admin.add_mailbox"),
not self.user.has_perm("admin.add_domain")
not self.user.has_perm("admin.add_domain"),
)
if all(conditions):
# An admin is creating a new mailbox. Give
@@ -305,8 +297,9 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
newaddress = None
if values["email"] != self.full_address:
newaddress = values["email"]
elif (self.user.role == "SimpleUsers" and
self.user.username != self.full_address):
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)
@@ -319,9 +312,10 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
self.use_domain_quota = values["use_domain_quota"]
if "use_domain_quota" in values or "quota" in values:
override_rules = (
not self.quota or user.is_superuser or
user.has_perm("admin.add_domain") and
not user.userobjectlimit_set.get(name="quota").max_value
not self.quota
or user.is_superuser
or user.has_perm("admin.add_domain")
and not user.userobjectlimit_set.get(name="quota").max_value
)
self.set_quota(values["quota"], override_rules)
if "message_limit" in values:
@@ -343,11 +337,11 @@ class Mailbox(mixins.MessageLimitMixin, AdminObject):
if self.pk:
qset = qset.exclude(pk=self.pk)
if qset.exists():
raise lib_exceptions.Conflict(
_("Mailbox {} already exists").format(self))
raise lib_exceptions.Conflict(_("Mailbox {} already exists").format(self))
if self.quota_value is None:
self.quota_value, created = Quota.objects.get_or_create(
username=self.full_address)
username=self.full_address
)
super().save(*args, **kwargs)
@@ -377,8 +371,9 @@ reversion.register(SenderAddress)
class MailboxOperation(models.Model):
"""An operation on a mailbox."""
mailbox = models.ForeignKey(Mailbox, blank=True, null=True,
on_delete=models.CASCADE)
mailbox = models.ForeignKey(
Mailbox, blank=True, null=True, on_delete=models.CASCADE
)
type = models.CharField( # NOQA:A003
max_length=20, choices=(("rename", "rename"), ("delete", "delete"))
)
+1 -3
View File
@@ -15,9 +15,7 @@ class MessageLimitMixin:
"""Return number of sent messages for the current day."""
if self.message_limit is None:
return None
return (
self.message_limit - get_message_counter(self.message_counter_key)
)
return self.message_limit - get_message_counter(self.message_counter_key)
@property
def sent_messages_in_percent(self):
+3 -3
View File
@@ -29,8 +29,7 @@ class MXRecordManager(models.Manager):
from .. import lib
now = timezone.now()
records = self.get_queryset().filter(
domain=domain, updated__gt=now)
records = self.get_queryset().filter(domain=domain, updated__gt=now)
if records.exists():
for record in records:
yield record
@@ -47,7 +46,8 @@ class MXRecordManager(models.Manager):
domain=domain,
name="{}".format(mx_addr.strip(".")),
address="{}".format(mx_ip_addr),
updated=now + delta)
updated=now + delta,
)
yield record
+2 -6
View File
@@ -1,7 +1,7 @@
"""Map file definitions for postfix."""
class DomainsMap(object):
class DomainsMap(object):
"""Map to list all domains."""
filename = "sql-domains.cf"
@@ -10,8 +10,7 @@ class DomainsMap(object):
"WHERE name='%s' AND type='domain' AND enabled=1"
)
postgres = (
"SELECT name FROM admin_domain "
"WHERE name='%s' AND type='domain' AND enabled"
"SELECT name FROM admin_domain " "WHERE name='%s' AND type='domain' AND enabled"
)
sqlite = (
"SELECT name FROM admin_domain "
@@ -20,7 +19,6 @@ class DomainsMap(object):
class DomainsAliasesMap(object):
"""Map to list all domain aliases."""
filename = "sql-domain-aliases.cf"
@@ -42,7 +40,6 @@ class DomainsAliasesMap(object):
class AliasesMap(object):
"""A map to list all mailbox aliases."""
filename = "sql-aliases.cf"
@@ -67,7 +64,6 @@ class AliasesMap(object):
class MaintainMap(object):
"""Map files to list non available mailboxes."""
filename = "sql-maintain.cf"
+14 -14
View File
@@ -2,21 +2,21 @@
import django.dispatch
check_extra_account_form = django.dispatch.Signal() # Provides account, form
extra_account_dashboard_widgets = django.dispatch.Signal() # Provides user, account
extra_account_forms = django.dispatch.Signal() # Provides user, account
extra_admin_content = django.dispatch.Signal() # Provides user, location, currentpage
extra_domain_actions = django.dispatch.Signal() # Provides user, domain
extra_domain_dashboard_widgets = django.dispatch.Signal() # Provides user, domain
check_extra_account_form = django.dispatch.Signal() # Provides account, form
extra_account_dashboard_widgets = django.dispatch.Signal() # Provides user, account
extra_account_forms = django.dispatch.Signal() # Provides user, account
extra_admin_content = django.dispatch.Signal() # Provides user, location, currentpage
extra_domain_actions = django.dispatch.Signal() # Provides user, domain
extra_domain_dashboard_widgets = django.dispatch.Signal() # Provides user, domain
extra_domain_filters = django.dispatch.Signal()
extra_domain_forms = django.dispatch.Signal() # Provides user, domain
extra_domain_menu_entries = django.dispatch.Signal() # Provides user
extra_domain_qset_filters = django.dispatch.Signal() # Provides domfilter, extrafilters
extra_domain_forms = django.dispatch.Signal() # Provides user, domain
extra_domain_menu_entries = django.dispatch.Signal() # Provides user
extra_domain_qset_filters = django.dispatch.Signal() # Provides domfilter, extrafilters
# extra_domain_types = django.dispatch.Signal()
extra_domain_wizard_steps = django.dispatch.Signal()
get_account_form_instances = django.dispatch.Signal() # Provides user, account
get_domain_form_instances = django.dispatch.Signal() # Provides user, domain
get_account_form_instances = django.dispatch.Signal() # Provides user, account
get_domain_form_instances = django.dispatch.Signal() # Provides user, domain
# get_domain_tags = django.dispatch.Signal(providing_args=["domain"])
import_object = django.dispatch.Signal() # Provides objtype
use_external_recipients = django.dispatch.Signal() # Provides recipients
extra_account_identities_actions = django.dispatch.Signal() # Provides account
import_object = django.dispatch.Signal() # Provides objtype
use_external_recipients = django.dispatch.Signal() # Provides recipients
extra_account_identities_actions = django.dispatch.Signal() # Provides account
+156 -125
View File
@@ -15,9 +15,7 @@ from .. import signals
register = template.Library()
genders = {
"Enabled": (gettext_lazy("enabled_m"), gettext_lazy("enabled_f"))
}
genders = {"Enabled": (gettext_lazy("enabled_m"), gettext_lazy("enabled_f"))}
@register.simple_tag
@@ -43,47 +41,57 @@ def domains_menu(selection, user, ajax_mode=True):
quota_list_url = domain_list_url + "#quotas/"
logs_url = domain_list_url + "#logs/"
entries = [
{"name": "domains",
"label": _("List domains"),
"img": "fa fa-user",
"class": "ajaxnav navigation",
"url": domain_list_url},
{"name": "quotas",
"label": _("List quotas"),
"img": "fa fa-hdd-o",
"class": "ajaxnav navigation",
"url": quota_list_url},
{"name": "logs",
"label": _("Message logs"),
"img": "fa fa-list",
"class": "ajaxnav navigation",
"url": logs_url},
{
"name": "domains",
"label": _("List domains"),
"img": "fa fa-user",
"class": "ajaxnav navigation",
"url": domain_list_url,
},
{
"name": "quotas",
"label": _("List quotas"),
"img": "fa fa-hdd-o",
"class": "ajaxnav navigation",
"url": quota_list_url,
},
{
"name": "logs",
"label": _("Message logs"),
"img": "fa fa-list",
"class": "ajaxnav navigation",
"url": logs_url,
},
]
if user.has_perm("admin.add_domain"):
extra_entries = signals.extra_domain_menu_entries.send(
sender="domains_menu", user=user)
sender="domains_menu", user=user
)
for entry in extra_entries:
entries += entry[1]
entries += [
{"name": "import",
"label": _("Import"),
"img": "fa fa-folder-open",
"url": reverse("admin:domain_import"),
"modal": True,
"modalcb": "admin.importform_cb"},
{"name": "export",
"label": _("Export"),
"img": "fa fa-share-alt",
"url": reverse("admin:domain_export"),
"modal": True,
"modalcb": "admin.exportform_cb"}
{
"name": "import",
"label": _("Import"),
"img": "fa fa-folder-open",
"url": reverse("admin:domain_import"),
"modal": True,
"modalcb": "admin.importform_cb",
},
{
"name": "export",
"label": _("Export"),
"img": "fa fa-share-alt",
"url": reverse("admin:domain_export"),
"modal": True,
"modalcb": "admin.exportform_cb",
},
]
return render_to_string("common/menulist.html", {
"entries": entries,
"selection": selection,
"user": user
})
return render_to_string(
"common/menulist.html",
{"entries": entries, "selection": selection, "user": user},
)
@register.simple_tag
@@ -103,71 +111,84 @@ def identities_menu(user, selection=None, ajax_mode=True):
identity_list_url = reverse("admin:identity_list")
quota_list_url = identity_list_url + "#quotas/"
entries = [
{"name": "identities",
"label": _("List identities"),
"img": "fa fa-user",
"class": nav_classes,
"url": identity_list_url},
{"name": "quotas",
"label": _("List quotas"),
"img": "fa fa-hdd-o",
"class": nav_classes,
"url": quota_list_url},
{"name": "import",
"label": _("Import"),
"img": "fa fa-folder-open",
"url": reverse("admin:identity_import"),
"modal": True,
"modalcb": "admin.importform_cb"},
{"name": "export",
"label": _("Export"),
"img": "fa fa-share-alt",
"url": reverse("admin:identity_export"),
"modal": True,
"modalcb": "admin.exportform_cb"}
{
"name": "identities",
"label": _("List identities"),
"img": "fa fa-user",
"class": nav_classes,
"url": identity_list_url,
},
{
"name": "quotas",
"label": _("List quotas"),
"img": "fa fa-hdd-o",
"class": nav_classes,
"url": quota_list_url,
},
{
"name": "import",
"label": _("Import"),
"img": "fa fa-folder-open",
"url": reverse("admin:identity_import"),
"modal": True,
"modalcb": "admin.importform_cb",
},
{
"name": "export",
"label": _("Export"),
"img": "fa fa-share-alt",
"url": reverse("admin:identity_export"),
"modal": True,
"modalcb": "admin.exportform_cb",
},
]
return render_to_string("common/menulist.html", {
"entries": entries,
"user": user
})
return render_to_string("common/menulist.html", {"entries": entries, "user": user})
@register.simple_tag
def domain_actions(user, domain):
actions = [
{"name": "listidentities",
"url": u"{0}#list/?searchquery=@{1}".format(
reverse("admin:identity_list"), domain.name),
"title": _("View the domain's identities"),
"img": "fa fa-user"},
{
"name": "listidentities",
"url": "{0}#list/?searchquery=@{1}".format(
reverse("admin:identity_list"), domain.name
),
"title": _("View the domain's identities"),
"img": "fa fa-user",
},
]
if domain.alarms.opened().exists():
actions.append({
"name": "listalarms",
"url": reverse("admin:domain_alarms", args=[domain.pk]),
"title": _("View domain's alarms"),
"img": "fa fa-bell"
})
actions.append(
{
"name": "listalarms",
"url": reverse("admin:domain_alarms", args=[domain.pk]),
"title": _("View domain's alarms"),
"img": "fa fa-bell",
}
)
if user.has_perm("admin.change_domain"):
actions.append({
"name": "editdomain",
"title": _("Edit {}").format(domain),
"url": reverse("admin:domain_change", args=[domain.pk]),
"modal": True,
"modalcb": "admin.domainform_cb",
"img": "fa fa-edit"
})
actions.append(
{
"name": "editdomain",
"title": _("Edit {}").format(domain),
"url": reverse("admin:domain_change", args=[domain.pk]),
"modal": True,
"modalcb": "admin.domainform_cb",
"img": "fa fa-edit",
}
)
if user.has_perm("admin.delete_domain"):
actions.append({
"name": "deldomain",
"url": reverse("admin:domain_delete", args=[domain.id]),
"title": _("Delete %s?") % domain.name,
"img": "fa fa-trash"
})
actions.append(
{
"name": "deldomain",
"url": reverse("admin:domain_delete", args=[domain.id]),
"title": _("Delete %s?") % domain.name,
"img": "fa fa-trash",
}
)
responses = signals.extra_domain_actions.send(
sender=None, user=user, domain=domain)
responses = signals.extra_domain_actions.send(sender=None, user=user, domain=domain)
for _receiver, response in responses:
if response:
actions += response
@@ -182,38 +203,43 @@ def identity_actions(user, ident):
if name == "User":
actions = []
result = core_signals.extra_account_actions.send(
sender="identity_actions", account=ident)
sender="identity_actions", account=ident
)
for action in result:
actions += action[1]
url = (
reverse("admin:account_change", args=[objid]) +
"?active_tab=default"
)
url = reverse("admin:account_change", args=[objid]) + "?active_tab=default"
actions += [
{"name": "changeaccount",
"url": url,
"img": "fa fa-edit",
"modal": True,
"modalcb": "admin.editaccount_cb",
"title": _("Edit {}").format(ident.username)},
{"name": "delaccount",
"url": reverse("admin:account_delete", args=[objid]),
"img": "fa fa-trash",
"title": _("Delete %s?") % ident.username},
{
"name": "changeaccount",
"url": url,
"img": "fa fa-edit",
"modal": True,
"modalcb": "admin.editaccount_cb",
"title": _("Edit {}").format(ident.username),
},
{
"name": "delaccount",
"url": reverse("admin:account_delete", args=[objid]),
"img": "fa fa-trash",
"title": _("Delete %s?") % ident.username,
},
]
else:
actions = [
{"name": "changealias",
"url": reverse("admin:alias_change", args=[objid]),
"img": "fa fa-edit",
"modal": True,
"modalcb": "admin.aliasform_cb",
"title": _("Edit {}").format(ident)},
{"name": "delalias",
"url": "{}?selection={}".format(
reverse("admin:alias_delete"), objid),
"img": "fa fa-trash",
"title": _("Delete %s?") % ident.address},
{
"name": "changealias",
"url": reverse("admin:alias_change", args=[objid]),
"img": "fa fa-edit",
"modal": True,
"modalcb": "admin.aliasform_cb",
"title": _("Edit {}").format(ident),
},
{
"name": "delalias",
"url": "{}?selection={}".format(reverse("admin:alias_delete"), objid),
"img": "fa fa-trash",
"title": _("Delete %s?") % ident.address,
},
]
return render_actions(actions)
@@ -222,8 +248,7 @@ def identity_actions(user, ident):
def check_identity_status(identity):
"""Check if identity is enabled or not."""
if identity.__class__.__name__ == "User":
if hasattr(identity, "mailbox") \
and not identity.mailbox.domain.enabled:
if hasattr(identity, "mailbox") and not identity.mailbox.domain.enabled:
return False
elif not identity.is_active:
return False
@@ -271,13 +296,16 @@ def identity_modify_link(identity, active_tab="default"):
@register.simple_tag
def domadmin_actions(daid, domid):
actions = [{
"name": "removeperm",
"url": "{0}?domid={1}&daid={2}".format(
reverse("admin:permission_remove"), domid, daid),
"img": "fa fa-trash",
"title": _("Remove this permission")
}]
actions = [
{
"name": "removeperm",
"url": "{0}?domid={1}&daid={2}".format(
reverse("admin:permission_remove"), domid, daid
),
"img": "fa fa-trash",
"title": _("Remove this permission"),
}
]
return render_actions(actions)
@@ -294,7 +322,10 @@ def gender(value, target):
def get_extra_admin_content(user, target, currentpage):
results = signals.extra_admin_content.send(
sender="get_extra_admin_content",
user=user, location=target, currentpage=currentpage)
user=user,
location=target,
currentpage=currentpage,
)
if not results:
return ""
results = reduce(lambda a, b: a + b, [result[1] for result in results])
+269 -239
View File
@@ -19,9 +19,10 @@ class AuthenticationTestCase(ModoTestCase):
"""Create test data."""
super(AuthenticationTestCase, cls).setUpTestData()
cls.mb = factories.MailboxFactory(
domain__name="test.com", address="user",
domain__name="test.com",
address="user",
user__username="user@test.com",
user__groups=("SimpleUsers",)
user__groups=("SimpleUsers",),
)
def test_authentication_unicode(self):
@@ -46,10 +47,16 @@ class AccountTestCase(ModoTestCase):
def test_crud(self):
values = {
"username": "tester@test.com", "first_name": "Tester",
"last_name": "Toto", "password1": "Toto1234",
"password2": "Toto1234", "role": "SimpleUsers", "quota_act": True,
"is_active": True, "email": "tester@test.com", "stepid": "step2"
"username": "tester@test.com",
"first_name": "Tester",
"last_name": "Toto",
"password1": "Toto1234",
"password2": "Toto1234",
"role": "SimpleUsers",
"quota_act": True,
"is_active": True,
"email": "tester@test.com",
"stepid": "step2",
}
self.ajax_post(reverse("admin:account_add"), values)
@@ -66,19 +73,24 @@ class AccountTestCase(ModoTestCase):
self.assertEqual(mb.domain.mailbox_count, 3)
# Check if self alias has been created
self.assertTrue(
models.AliasRecipient.objects.select_related("alias").filter(
alias__address=mb.full_address, address=mb.full_address,
alias__internal=True).exists()
models.AliasRecipient.objects.select_related("alias")
.filter(
alias__address=mb.full_address,
address=mb.full_address,
alias__internal=True,
)
.exists()
)
values.update({
"username": "pouet@test.com", "language": "en",
"secondary_email": "homer@simpson.com",
"phone_number": "+33612345678"
})
self.ajax_post(
reverse("admin:account_change", args=[account.id]), values
values.update(
{
"username": "pouet@test.com",
"language": "en",
"secondary_email": "homer@simpson.com",
"phone_number": "+33612345678",
}
)
self.ajax_post(reverse("admin:account_change", args=[account.id]), values)
account.refresh_from_db()
self.assertEqual(account.secondary_email, values["secondary_email"])
mb = models.Mailbox.objects.get(pk=mb.pk)
@@ -86,18 +98,24 @@ class AccountTestCase(ModoTestCase):
self.assertEqual(mb.quota_value.username, "pouet@test.com")
# Check if self alias has been updated
self.assertTrue(
models.AliasRecipient.objects.select_related("alias").filter(
alias__address=mb.full_address, address=mb.full_address,
alias__internal=True).exists()
)
self.ajax_post(
reverse("admin:account_delete", args=[account.id]), {}
models.AliasRecipient.objects.select_related("alias")
.filter(
alias__address=mb.full_address,
address=mb.full_address,
alias__internal=True,
)
.exists()
)
self.ajax_post(reverse("admin:account_delete", args=[account.id]), {})
# Check if self alias has been deleted
self.assertFalse(
models.AliasRecipient.objects.select_related("alias").filter(
alias__address=mb.full_address, address=mb.full_address,
alias__internal=True).exists()
models.AliasRecipient.objects.select_related("alias")
.filter(
alias__address=mb.full_address,
address=mb.full_address,
alias__internal=True,
)
.exists()
)
@override_settings(LANGUAGE_CODE="fr")
@@ -113,7 +131,7 @@ class AccountTestCase(ModoTestCase):
"quota_act": True,
"is_active": True,
"email": "tester@test.com",
"stepid": "step2"
"stepid": "step2",
}
self.ajax_post(reverse("admin:account_add"), values)
account = User.objects.get(username=values["username"])
@@ -148,11 +166,9 @@ class AccountTestCase(ModoTestCase):
}
self.ajax_post(reverse("admin:account_add"), values)
# Check that internal alias has not been updated
alias = models.Alias.objects.get(
address="user@test.com", internal=True)
alias = models.Alias.objects.get(address="user@test.com", internal=True)
self.assertTrue(alias.aliasrecipient_set.count() == 1)
alias = models.Alias.objects.get(
address="user@test.com", internal=False)
alias = models.Alias.objects.get(address="user@test.com", internal=False)
self.assertTrue(alias.aliasrecipient_set.count() == 1)
def test_create_disabled_account(self):
@@ -167,7 +183,7 @@ class AccountTestCase(ModoTestCase):
"quota_act": True,
"is_active": False,
"email": "tester@test.com",
"stepid": "step2"
"stepid": "step2",
}
self.ajax_post(reverse("admin:account_add"), values)
account = User.objects.get(username=values["username"])
@@ -186,19 +202,15 @@ class AccountTestCase(ModoTestCase):
"quota_act": True,
"is_active": False,
"email": "user@test.com",
"language": "en"
"language": "en",
}
self.ajax_post(
reverse("admin:account_change", args=[account.id]), values
)
self.ajax_post(reverse("admin:account_change", args=[account.id]), values)
internal.refresh_from_db()
self.assertFalse(internal.enabled)
forward.refresh_from_db()
self.assertFalse(forward.enabled)
values["is_active"] = True
self.ajax_post(
reverse("admin:account_change", args=[account.id]), values
)
self.ajax_post(reverse("admin:account_change", args=[account.id]), values)
internal.refresh_from_db()
self.assertTrue(internal.enabled)
forward.refresh_from_db()
@@ -217,7 +229,7 @@ class AccountTestCase(ModoTestCase):
"email": "new_user@test.com",
"language": "en",
"create_alias_with_old_address": False,
"aliases_1": "alias@test.com"
"aliases_1": "alias@test.com",
}
url = reverse("admin:account_change", args=[account.pk])
self.ajax_post(url, values)
@@ -237,42 +249,48 @@ class AccountTestCase(ModoTestCase):
"is_active": account.is_active,
"email": "new_user@test.com",
"language": "en",
"create_alias_with_old_address": False
"create_alias_with_old_address": False,
}
url = reverse("admin:account_change", args=[account.pk])
# Rename while option is set to False -> no alias created
self.ajax_post(url, values)
self.assertFalse(
models.AliasRecipient.objects.filter(
address="new_user@test.com", alias__address="user@test.com",
alias__internal=False
address="new_user@test.com",
alias__address="user@test.com",
alias__internal=False,
).exists()
)
# Now rename while option set to True -> alias created
values.update({
"username": "user@test.com",
"email": "user@test.com",
"create_alias_with_old_address": True}
values.update(
{
"username": "user@test.com",
"email": "user@test.com",
"create_alias_with_old_address": True,
}
)
self.ajax_post(url, values)
self.assertTrue(
models.AliasRecipient.objects.filter(
address="user@test.com", alias__address="new_user@test.com",
alias__internal=False
address="user@test.com",
alias__address="new_user@test.com",
alias__internal=False,
).exists()
)
# Change domain while option set to True -> alias created
values.update({
"username": "new_user@test2.com",
"email": "new_user@test2.com",
})
values.update(
{
"username": "new_user@test2.com",
"email": "new_user@test2.com",
}
)
self.ajax_post(url, values)
self.assertTrue(
models.AliasRecipient.objects.filter(
address="new_user@test2.com",
alias__address="user@test.com",
alias__domain__name="test.com",
alias__internal=False
alias__internal=False,
).exists()
)
@@ -280,38 +298,45 @@ class AccountTestCase(ModoTestCase):
"""Check password constraints."""
values = {
"username": "tester@test.com",
"first_name": "Tester", "last_name": "Toto",
"password1": "", "password2": "",
"first_name": "Tester",
"last_name": "Toto",
"password1": "",
"password2": "",
"role": "SimpleUsers",
"quota_act": True, "is_active": True, "email": "tester@test.com",
"stepid": "step2"
"quota_act": True,
"is_active": True,
"email": "tester@test.com",
"stepid": "step2",
}
resp = self.ajax_post(reverse("admin:account_add"), values, 400)
self.assertEqual(
resp["form_errors"]["password1"][0],
"This field is required.")
self.assertEqual(resp["form_errors"]["password1"][0], "This field is required.")
values["password1"] = "Toto1234"
values["password2"] = "Toto12345"
resp = self.ajax_post(reverse("admin:account_add"), values, 400)
self.assertEqual(
resp["form_errors"]["password2"][0],
"The two password fields didn't match.")
resp["form_errors"]["password2"][0], "The two password fields didn't match."
)
values["password1"] = "toto1234"
values["password2"] = "toto1234"
resp = self.ajax_post(reverse("admin:account_add"), values, 400)
self.assertEqual(
resp["form_errors"]["password2"][0],
"Password must contain at least 1 uppercase letter.")
"Password must contain at least 1 uppercase letter.",
)
def test_random_password(self):
"""Try to create an account with a random password."""
values = {
"username": "tester@test.com",
"first_name": "Tester", "last_name": "Toto",
"random_password": True, "role": "SimpleUsers",
"quota_act": True, "is_active": True, "email": "tester@test.com",
"stepid": "step2"
"first_name": "Tester",
"last_name": "Toto",
"random_password": True,
"role": "SimpleUsers",
"quota_act": True,
"is_active": True,
"email": "tester@test.com",
"stepid": "step2",
}
self.ajax_post(reverse("admin:account_add"), values)
@@ -320,62 +345,56 @@ class AccountTestCase(ModoTestCase):
values["language"] = "en"
# Since 'random_password' is still True, a new password should
# be generated
self.ajax_post(
reverse("admin:account_change", args=[account.pk]), values
)
self.ajax_post(reverse("admin:account_change", args=[account.pk]), values)
account.refresh_from_db()
self.assertNotEqual(password, account.password)
password = account.password
values["random_password"] = False
self.ajax_post(
reverse("admin:account_change", args=[account.pk]), values
)
self.ajax_post(reverse("admin:account_change", args=[account.pk]), values)
account.refresh_from_db()
self.assertEqual(password, account.password)
def test_delete_default_superadmin(self):
"""Delete default superadmin."""
sadmin2 = core_factories.UserFactory(
username="admin2", is_superuser=True)
sadmin2 = core_factories.UserFactory(username="admin2", is_superuser=True)
sadmin = User.objects.get(username="admin")
self.client.force_login(sadmin2)
self.ajax_post(
reverse("admin:account_delete", args=[sadmin.pk]), {}
)
self.ajax_post(reverse("admin:account_delete", args=[sadmin.pk]), {})
values = {
"username": "user@test.com", "role": "DomainAdmins",
"is_active": True, "email": "user@test.com",
"language": "en"
"username": "user@test.com",
"role": "DomainAdmins",
"is_active": True,
"email": "user@test.com",
"language": "en",
}
account = User.objects.get(username="user@test.com")
self.ajax_post(
reverse("admin:account_change", args=[account.pk]), values
)
self.ajax_post(reverse("admin:account_change", args=[account.pk]), values)
def test_sender_address(self):
"""Check if sender addresses are saved."""
account = User.objects.get(username="user@test.com")
values = {
"username": "user@test.com", "first_name": "Tester",
"last_name": "Toto", "role": "SimpleUsers",
"quota_act": True, "is_active": True, "email": "user@test.com",
"senderaddress": "test@titi.com", "senderaddress_1": "toto@go.com",
"language": "en"
"username": "user@test.com",
"first_name": "Tester",
"last_name": "Toto",
"role": "SimpleUsers",
"quota_act": True,
"is_active": True,
"email": "user@test.com",
"senderaddress": "test@titi.com",
"senderaddress_1": "toto@go.com",
"language": "en",
}
self.ajax_post(
reverse("admin:account_change", args=[account.pk]), values)
self.ajax_post(reverse("admin:account_change", args=[account.pk]), values)
self.assertEqual(
models.SenderAddress.objects.filter(
mailbox__address="user").count(),
2)
models.SenderAddress.objects.filter(mailbox__address="user").count(), 2
)
del values["senderaddress_1"]
self.ajax_post(
reverse("admin:account_change", args=[account.pk]), values)
self.ajax_post(reverse("admin:account_change", args=[account.pk]), values)
self.assertEqual(
models.SenderAddress.objects.filter(
mailbox__address="user").count(),
1)
models.SenderAddress.objects.filter(mailbox__address="user").count(), 1
)
def test_sender_address_as_domainadmin(self):
"""Check that restrictions are applied."""
@@ -383,63 +402,83 @@ class AccountTestCase(ModoTestCase):
self.client.force_login(admin)
account = User.objects.get(username="user@test.com")
values = {
"username": "user@test.com", "first_name": "Tester",
"last_name": "Toto", "role": "SimpleUsers",
"quota_act": True, "is_active": True, "email": "user@test.com",
"username": "user@test.com",
"first_name": "Tester",
"last_name": "Toto",
"role": "SimpleUsers",
"quota_act": True,
"is_active": True,
"email": "user@test.com",
"senderaddress": "test@titi.com",
"senderaddress_1": "toto@test2.com"
"senderaddress_1": "toto@test2.com",
}
response = self.ajax_post(
reverse("admin:account_change", args=[account.pk]), values, 400)
reverse("admin:account_change", args=[account.pk]), values, 400
)
self.assertEqual(
response["form_errors"]["senderaddress_1"][0],
"You don't have access to this domain")
"You don't have access to this domain",
)
def test_conflicts(self):
"""Check if unicity constraints are respected."""
values = {
"username": "user@test.com",
"password1": "Toto1234", "password2": "Toto1234",
"role": "SimpleUsers", "quota_act": True,
"is_active": True, "email": "user@test.com",
"stepid": "step2"
"password1": "Toto1234",
"password2": "Toto1234",
"role": "SimpleUsers",
"quota_act": True,
"is_active": True,
"email": "user@test.com",
"stepid": "step2",
}
self.ajax_post(reverse("admin:account_add"), values, status=400)
values.update({"username": "fakeuser@test.com",
"email": "fakeuser@test.com"})
values.update({"username": "fakeuser@test.com", "email": "fakeuser@test.com"})
self.ajax_post(reverse("admin:account_add"), values)
account = User.objects.get(username="fakeuser@test.com")
values = {
"username": "user@test.com",
"role": "SimpleUsers", "quota_act": True,
"is_active": True, "email": "user@test.com",
"role": "SimpleUsers",
"quota_act": True,
"is_active": True,
"email": "user@test.com",
}
self.ajax_post(
reverse("admin:account_change", args=[account.pk]), values,
status=400
reverse("admin:account_change", args=[account.pk]), values, status=400
)
def test_utf8_username(self):
"""Create an account with non-ASCII characters."""
values = {
"username": "téster@test.com", "first_name": "Tester",
"last_name": "Toto", "password1": "Toto1234",
"password2": "Toto1234", "role": "SimpleUsers", "quota_act": True,
"is_active": True, "email": "téster@test.com", "stepid": "step2"
"username": "téster@test.com",
"first_name": "Tester",
"last_name": "Toto",
"password1": "Toto1234",
"password2": "Toto1234",
"role": "SimpleUsers",
"quota_act": True,
"is_active": True,
"email": "téster@test.com",
"stepid": "step2",
}
self.ajax_post(reverse("admin:account_add"), values)
def _set_quota(self, email, value, expected_status=200):
account = User.objects.get(username=email)
values = {
"username": email, "role": "SimpleUsers", "quota_act": False,
"is_active": True, "quota": value, "email": email,
"language": "en"
"username": email,
"role": "SimpleUsers",
"quota_act": False,
"is_active": True,
"quota": value,
"email": email,
"language": "en",
}
self.ajax_post(
reverse("admin:account_change", args=[account.id]),
values, status=expected_status
values,
status=expected_status,
)
def test_set_nul_quota_as_superadmin(self):
@@ -448,15 +487,11 @@ class AccountTestCase(ModoTestCase):
def test_set_nul_quota_as_domainadmin(self):
"""Check cases where a domain admin set unlimited quota."""
self.client.logout()
self.assertTrue(
self.client.login(username="admin@test.com", password="toto")
)
self.assertTrue(self.client.login(username="admin@test.com", password="toto"))
# Fails because domain has a quota
self._set_quota("user@test.com", 0, 400)
self.client.logout()
self.assertTrue(
self.client.login(username="admin@test2.com", password="toto")
)
self.assertTrue(self.client.login(username="admin@test2.com", password="toto"))
# Ok because domain has no quota
self._set_quota("user@test2.com", 0)
@@ -477,25 +512,29 @@ class AccountTestCase(ModoTestCase):
def test_master_user(self):
"""Validate the master user mode."""
values = {
"username": "masteruser", "role": "SuperAdmins",
"username": "masteruser",
"role": "SuperAdmins",
"quota_act": False,
"is_active": True, "master_user": True, "stepid": "step2",
"password1": "Toto1234", "password2": "Toto1234"
"is_active": True,
"master_user": True,
"stepid": "step2",
"password1": "Toto1234",
"password2": "Toto1234",
}
self.ajax_post(
reverse("admin:account_add"), values
)
self.ajax_post(reverse("admin:account_add"), values)
self.assertTrue(User.objects.get(username="masteruser").master_user)
values = {
"username": "testuser", "role": "DomainAdmins",
"username": "testuser",
"role": "DomainAdmins",
"quota_act": False,
"is_active": True, "master_user": True, "stepid": "step2",
"password1": "Toto1234", "password2": "Toto1234"
"is_active": True,
"master_user": True,
"stepid": "step2",
"password1": "Toto1234",
"password2": "Toto1234",
}
self.ajax_post(
reverse("admin:account_add"), values, status=400
)
self.ajax_post(reverse("admin:account_add"), values, status=400)
def test_account_detail_view(self):
"""Test account detail view."""
@@ -513,8 +552,7 @@ class AccountTestCase(ModoTestCase):
def test_quota_list_view(self):
"""Test quota list view."""
models.Quota.objects.filter(username="user@test.com").update(
bytes=5 * 1048576)
models.Quota.objects.filter(username="user@test.com").update(bytes=5 * 1048576)
url = reverse("admin:identity_quota_list")
response = self.ajax_get(url)
self.assertIn("5M", response["rows"])
@@ -522,24 +560,23 @@ class AccountTestCase(ModoTestCase):
self.assertIn("user@test.com", response["rows"])
old_rows = response["rows"]
response = self.ajax_get(
"{}?sort_order=-quota_value__bytes".format(url))
response = self.ajax_get("{}?sort_order=-quota_value__bytes".format(url))
self.assertNotEqual(old_rows, response["rows"])
old_rows = response["rows"]
response = self.ajax_get(
"{}?sort_order=-quota_usage".format(url))
response = self.ajax_get("{}?sort_order=-quota_usage".format(url))
self.assertEqual(old_rows, response["rows"])
response = self.ajax_get(
"{}?sort_order=-unknown".format(url), status=400)
response = self.ajax_get("{}?sort_order=-unknown".format(url), status=400)
@skipIf(NO_LDAP, "No ldap module installed")
@override_settings(AUTHENTICATION_BACKENDS=(
"modoboa.lib.authbackends.LDAPBackend",
"django.contrib.auth.backends.ModelBackend",
))
@override_settings(
AUTHENTICATION_BACKENDS=(
"modoboa.lib.authbackends.LDAPBackend",
"django.contrib.auth.backends.ModelBackend",
)
)
class LDAPAccountTestCase(test_ldap.LDAPTestCaseMixin, ModoTestCase):
"""Check LDAP related code."""
@@ -550,10 +587,8 @@ class LDAPAccountTestCase(test_ldap.LDAPTestCaseMixin, ModoTestCase):
self.set_global_parameter("auto_create_domain_and_mailbox", False)
username = "testuser@example.com"
self.authenticate(username, "test")
self.assertFalse(
models.Domain.objects.filter(name="example.com").exists())
self.assertFalse(
models.Mailbox.objects.filter(address="testuser").exists())
self.assertFalse(models.Domain.objects.filter(name="example.com").exists())
self.assertFalse(models.Mailbox.objects.filter(address="testuser").exists())
class PermissionsTestCase(ModoTestCase):
@@ -576,9 +611,12 @@ class PermissionsTestCase(ModoTestCase):
"""Initiate test context."""
super(PermissionsTestCase, self).setUp()
self.values = {
"username": self.user.username, "role": "DomainAdmins",
"is_active": self.user.is_active, "email": "user@test.com",
"quota_act": True, "language": "en"
"username": self.user.username,
"role": "DomainAdmins",
"is_active": self.user.is_active,
"email": "user@test.com",
"quota_act": True,
"language": "en",
}
def tearDown(self):
@@ -588,8 +626,7 @@ class PermissionsTestCase(ModoTestCase):
factories.DomainFactory(name="test2.com")
self.ajax_post(
reverse("admin:account_change", args=[self.user.id]),
self.values
reverse("admin:account_change", args=[self.user.id]), self.values
)
self.assertEqual(self.user.role, "DomainAdmins")
@@ -599,8 +636,7 @@ class PermissionsTestCase(ModoTestCase):
self.values["domains_1"] = "test.com"
self.values["domains_2"] = "test2.com"
self.ajax_post(
reverse("admin:account_change", args=[self.user.id]),
self.values
reverse("admin:account_change", args=[self.user.id]), self.values
)
self.assertIn(
self.user, models.Domain.objects.get(name="test.com").admins.all()
@@ -611,8 +647,7 @@ class PermissionsTestCase(ModoTestCase):
del self.values["domains_2"]
self.ajax_post(
reverse("admin:account_change", args=[self.user.id]),
self.values
reverse("admin:account_change", args=[self.user.id]), self.values
)
self.assertIn(
self.user, models.Domain.objects.get(name="test.com").admins.all()
@@ -623,12 +658,9 @@ class PermissionsTestCase(ModoTestCase):
self.values["role"] = "SimpleUsers"
self.ajax_post(
reverse("admin:account_change", args=[self.user.id]),
self.values
)
self.assertFalse(
self.user.groups.filter(name="DomainAdmins").exists()
reverse("admin:account_change", args=[self.user.id]), self.values
)
self.assertFalse(self.user.groups.filter(name="DomainAdmins").exists())
self.assertNotIn(
self.user, models.Domain.objects.get(name="test.com").admins.all()
)
@@ -636,46 +668,36 @@ class PermissionsTestCase(ModoTestCase):
def test_superusers(self):
self.values["role"] = "SuperAdmins"
self.ajax_post(
reverse("admin:account_change", args=[self.user.id]),
self.values
)
self.assertEqual(
User.objects.get(username="user@test.com").is_superuser, True
reverse("admin:account_change", args=[self.user.id]), self.values
)
self.assertEqual(User.objects.get(username="user@test.com").is_superuser, True)
self.values["role"] = "SimpleUsers"
self.ajax_post(
reverse("admin:account_change", args=[self.user.id]),
self.values
reverse("admin:account_change", args=[self.user.id]), self.values
)
self.assertEqual(User.objects.get(
username="user@test.com").is_superuser, False)
self.assertEqual(User.objects.get(username="user@test.com").is_superuser, False)
def test_self_modif(self):
self.client.logout()
self.assertTrue(
self.client.login(username="admin@test.com", password="toto")
)
self.assertTrue(self.client.login(username="admin@test.com", password="toto"))
admin = User.objects.get(username="admin@test.com")
values = {
"username": "admin@test.com", "first_name": "Admin",
"password1": "", "password2": "",
"quota": 10, "is_active": True, "email": "admin@test.com",
"language": "en"
"username": "admin@test.com",
"first_name": "Admin",
"password1": "",
"password2": "",
"quota": 10,
"is_active": True,
"email": "admin@test.com",
"language": "en",
}
self.ajax_post(
reverse("admin:account_change", args=[admin.id]),
values
)
self.ajax_post(reverse("admin:account_change", args=[admin.id]), values)
self.assertEqual(admin.role, "DomainAdmins")
self.assertTrue(admin.can_access(
models.Domain.objects.get(name="test.com")))
self.assertTrue(admin.can_access(models.Domain.objects.get(name="test.com")))
values["role"] = "SuperAdmins"
self.ajax_post(
reverse("admin:account_change", args=[admin.id]),
values
)
self.ajax_post(reverse("admin:account_change", args=[admin.id]), values)
admin.refresh_from_db()
self.assertEqual(admin.role, "DomainAdmins")
@@ -683,33 +705,31 @@ class PermissionsTestCase(ModoTestCase):
self.client.login(username=self.reseller.username, password="toto")
self.assertTrue(self.reseller.can_access(self.reseller))
values = {
"username": self.reseller.username, "first_name": "Reseller",
"password1": "", "password2": "",
"is_active": True, "language": "en"
"username": self.reseller.username,
"first_name": "Reseller",
"password1": "",
"password2": "",
"is_active": True,
"language": "en",
}
self.ajax_post(
reverse("admin:account_change", args=[self.reseller.pk]),
values
)
self.ajax_post(reverse("admin:account_change", args=[self.reseller.pk]), values)
self.assertEqual(self.reseller.role, "Resellers")
values["role"] = "SuperAdmins"
self.ajax_post(
reverse("admin:account_change", args=[self.reseller.pk]),
values
)
self.ajax_post(reverse("admin:account_change", args=[self.reseller.pk]), values)
self.assertEqual(self.reseller.role, "Resellers")
def test_domadmin_access(self):
self.client.logout()
self.assertEqual(
self.client.login(username="admin@test.com", password="toto"),
True)
self.client.login(username="admin@test.com", password="toto"), True
)
response = self.client.get(reverse("admin:domain_list"))
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse("admin:account_change", args=[self.user.id]),
HTTP_X_REQUESTED_WITH="XMLHttpRequest")
HTTP_X_REQUESTED_WITH="XMLHttpRequest",
)
self.assertNotEqual(response["Content-Type"], "application/json")
def test_domainadmin_deletes_superadmin(self):
@@ -720,21 +740,21 @@ class PermissionsTestCase(ModoTestCase):
to access the super admin.
"""
values = {
"username": "superadmin2@test.com", "first_name": "Super",
"last_name": "Admin", "password1": "Toto1234",
"password2": "Toto1234", "role": "SuperAdmins", "is_active": True,
"email": "superadmin2@test.com", "stepid": "step2"
"username": "superadmin2@test.com",
"first_name": "Super",
"last_name": "Admin",
"password1": "Toto1234",
"password2": "Toto1234",
"role": "SuperAdmins",
"is_active": True,
"email": "superadmin2@test.com",
"stepid": "step2",
}
self.ajax_post(
reverse("admin:account_add"),
values
)
self.ajax_post(reverse("admin:account_add"), values)
account = User.objects.get(username="superadmin2@test.com")
self.client.logout()
self.client.login(username="admin@test.com", password="toto")
self.ajax_post(
reverse("admin:account_delete", args=[account.id]), {}, 403
)
self.ajax_post(reverse("admin:account_delete", args=[account.id]), {}, 403)
def test_domainadmin_dlist_local_domain_not_owned(self):
"""Check if a domain admin can use a local mailbox he can't
@@ -743,22 +763,25 @@ class PermissionsTestCase(ModoTestCase):
"address": "all@test.com",
"recipients": "user@test.com",
"recipients_1": "user@test2.com",
"enabled": True
"enabled": True,
}
self.ajax_post(reverse("admin:alias_add"), values)
def test_domainadmin_master_user(self):
"""Check domain administrator is not allowed to access this feature."""
values = {
"username": "user10@test.com", "first_name": "Test",
"last_name": "Test", "password1": "Toto1234",
"password2": "Toto1234", "role": "SimpleUsers", "is_active": True,
"master_user": True, "email": "user10@test.com", "stepid": "step2"
"username": "user10@test.com",
"first_name": "Test",
"last_name": "Test",
"password1": "Toto1234",
"password2": "Toto1234",
"role": "SimpleUsers",
"is_active": True,
"master_user": True,
"email": "user10@test.com",
"stepid": "step2",
}
self.ajax_post(
reverse("admin:account_add"),
values, status=400
)
self.ajax_post(reverse("admin:account_add"), values, status=400)
def test_domadmins_permissions(self):
"""
@@ -767,17 +790,24 @@ class PermissionsTestCase(ModoTestCase):
"""
dom = models.Domain.objects.get(name="test.com")
mb = factories.MailboxFactory(
domain=dom, address="admin2",
user__username="admin2@test.com", user__groups=("DomainAdmins", ),
user__password="{PLAIN}toto")
domain=dom,
address="admin2",
user__username="admin2@test.com",
user__groups=("DomainAdmins",),
user__password="{PLAIN}toto",
)
dom.add_admin(mb.user)
self.client.logout()
self.assertTrue(
self.client.login(username="admin@test.com", password="toto"))
self.assertTrue(self.client.login(username="admin@test.com", password="toto"))
values = {
"username": "new@test.com", "password1": "Toto1234",
"password2": "Toto1234", "role": "SimpleUsers", "quota_act": True,
"is_active": True, "email": "new@test.com", "stepid": "step2"
"username": "new@test.com",
"password1": "Toto1234",
"password2": "Toto1234",
"role": "SimpleUsers",
"quota_act": True,
"is_active": True,
"email": "new@test.com",
"stepid": "step2",
}
self.ajax_post(reverse("admin:account_add"), values)
+1 -2
View File
@@ -16,8 +16,7 @@ class AlarmsTestCase(ModoTestCase):
def test_set_forward(self):
domain = Domain.objects.all().first()
alarm = Alarm.objects.create(
domain=domain, mailbox=None, title="Test alarm 3")
alarm = Alarm.objects.create(domain=domain, mailbox=None, title="Test alarm 3")
alarm.save()
self.assertEqual(alarm.status, 1)
alarm.close()
+100 -116
View File
@@ -19,29 +19,28 @@ class AliasTestCase(ModoTestCase):
def test_alias(self):
user = User.objects.get(username="user@test.com")
values = {
"username": "user@test.com", "role": user.role,
"is_active": user.is_active, "email": "user@test.com",
"aliases": "toto@test.com", "aliases_1": "titi@test.com",
"language": "en"
"username": "user@test.com",
"role": user.role,
"is_active": user.is_active,
"email": "user@test.com",
"aliases": "toto@test.com",
"aliases_1": "titi@test.com",
"language": "en",
}
self.ajax_post(
reverse("admin:account_change", args=[user.id]),
values
)
self.assertEqual(
AliasRecipient.objects.filter
(alias__internal=False, r_mailbox=user.mailbox)
.count(), 2
)
del values["aliases_1"]
self.ajax_post(
reverse("admin:account_change", args=[user.id]),
values
)
self.ajax_post(reverse("admin:account_change", args=[user.id]), values)
self.assertEqual(
AliasRecipient.objects.filter(
alias__internal=False, r_mailbox=user.mailbox)
.count(), 1
alias__internal=False, r_mailbox=user.mailbox
).count(),
2,
)
del values["aliases_1"]
self.ajax_post(reverse("admin:account_change", args=[user.id]), values)
self.assertEqual(
AliasRecipient.objects.filter(
alias__internal=False, r_mailbox=user.mailbox
).count(),
1,
)
def test_alias_with_duplicated_recipient(self):
@@ -50,11 +49,9 @@ class AliasTestCase(ModoTestCase):
"address": "badalias@test.com",
"recipients": "user@test.com",
"recipients_1": "user@test.com",
"enabled": True
"enabled": True,
}
self.ajax_post(
reverse("admin:alias_add"), values
)
self.ajax_post(reverse("admin:alias_add"), values)
alias = Alias.objects.get(address="badalias@test.com")
self.assertEqual(alias.recipients_count, 1)
@@ -62,55 +59,59 @@ class AliasTestCase(ModoTestCase):
"""Try to create an upper case alias."""
user = User.objects.get(username="user@test.com")
values = {
"username": "user@test.com", "role": user.role,
"is_active": user.is_active, "email": "user@test.com",
"aliases": "Toto@test.com", "language": "en"
"username": "user@test.com",
"role": user.role,
"is_active": user.is_active,
"email": "user@test.com",
"aliases": "Toto@test.com",
"language": "en",
}
self.ajax_post(
reverse("admin:account_change", args=[user.id]),
values
)
self.ajax_post(reverse("admin:account_change", args=[user.id]), values)
mb = user.mailbox
self.assertEqual(
AliasRecipient.objects
.filter(alias__internal=False, r_mailbox=mb).count(), 1)
AliasRecipient.objects.filter(alias__internal=False, r_mailbox=mb).count(),
1,
)
self.assertEqual(
AliasRecipient.objects.get(
alias__internal=False, r_mailbox=mb).alias.address,
"toto@test.com"
alias__internal=False, r_mailbox=mb
).alias.address,
"toto@test.com",
)
values = {
"address": "Titi@test.com", "recipients": "user@test.com",
"enabled": True
"address": "Titi@test.com",
"recipients": "user@test.com",
"enabled": True,
}
self.ajax_post(reverse("admin:alias_add"), values)
self.assertTrue(
Alias.objects.filter(address="titi@test.com").exists())
self.assertTrue(Alias.objects.filter(address="titi@test.com").exists())
def test_append_alias_with_tag(self):
"""Try to create a alias with tag in recipient address"""
user = User.objects.get(username="user@test.com")
values = {
"username": "user@test.com", "role": user.role,
"is_active": user.is_active, "email": "user@test.com",
"language": "en"
"username": "user@test.com",
"role": user.role,
"is_active": user.is_active,
"email": "user@test.com",
"language": "en",
}
self.ajax_post(
reverse("admin:account_change", args=[user.id]),
values
)
self.ajax_post(reverse("admin:account_change", args=[user.id]), values)
values = {
"address": "foobar@test.com", "recipients": "user+spam@test.com",
"enabled": True
"address": "foobar@test.com",
"recipients": "user+spam@test.com",
"enabled": True,
}
self.ajax_post(reverse("admin:alias_add"), values)
alias = Alias.objects.get(address="foobar@test.com")
self.assertTrue(
alias.aliasrecipient_set.filter(
address="user+spam@test.com", r_mailbox__isnull=False,
r_alias__isnull=True).exists()
address="user+spam@test.com",
r_mailbox__isnull=False,
r_alias__isnull=True,
).exists()
)
def test_utf8_alias(self):
@@ -120,11 +121,9 @@ class AliasTestCase(ModoTestCase):
"recipients": "user@test.com",
"recipients_1": "admin@test.com",
"recipients_2": "ext@titi.com",
"enabled": True
"enabled": True,
}
self.ajax_post(
reverse("admin:alias_add"), values
)
self.ajax_post(reverse("admin:alias_add"), values)
def test_dlist(self):
values = {
@@ -132,89 +131,68 @@ class AliasTestCase(ModoTestCase):
"recipients": "user@test.com",
"recipients_1": "admin@test.com",
"recipients_2": "ext@titi.com",
"enabled": True
"enabled": True,
}
self.ajax_post(
reverse("admin:alias_add"), values
)
self.ajax_post(reverse("admin:alias_add"), values)
user = User.objects.get(username="user@test.com")
mb = user.mailbox
self.assertEqual(
AliasRecipient.objects.filter(
alias__internal=False, r_mailbox=mb).count(), 2)
AliasRecipient.objects.filter(alias__internal=False, r_mailbox=mb).count(),
2,
)
admin = User.objects.get(username="admin@test.com")
mb = admin.mailbox
self.assertEqual(
AliasRecipient.objects.filter(
alias__internal=False, r_mailbox=mb).count(), 1)
AliasRecipient.objects.filter(alias__internal=False, r_mailbox=mb).count(),
1,
)
dlist = Alias.objects.get(address="all@test.com")
self.assertEqual(dlist.recipients_count, 3)
del values["recipients_1"]
self.ajax_post(
reverse("admin:alias_change", args=[dlist.id]),
values
)
self.ajax_post(reverse("admin:alias_change", args=[dlist.id]), values)
self.assertEqual(dlist.recipients_count, 2)
self.ajax_delete(
"{}?selection={}".format(
reverse("admin:alias_delete"), dlist.id)
"{}?selection={}".format(reverse("admin:alias_delete"), dlist.id)
)
self.assertRaises(
Alias.DoesNotExist, Alias.objects.get, address="all@test.com")
self.assertRaises(Alias.DoesNotExist, Alias.objects.get, address="all@test.com")
def test_forward(self):
values = {"address": "forward2@test.com", "recipients": "rcpt@dest.com"}
self.ajax_post(
reverse("admin:alias_add"), values
)
self.ajax_post(reverse("admin:alias_add"), values)
fwd = Alias.objects.get(address="forward2@test.com")
self.assertEqual(fwd.recipients_count, 1)
values["recipients"] = "rcpt2@dest.com"
self.ajax_post(
reverse("admin:alias_change",
args=[fwd.id]),
values
)
self.ajax_post(reverse("admin:alias_change", args=[fwd.id]), values)
self.assertEqual(fwd.recipients_count, 1)
self.ajax_delete(
reverse("admin:alias_delete") + "?selection=%d"
% fwd.id, {}
)
self.ajax_delete(reverse("admin:alias_delete") + "?selection=%d" % fwd.id, {})
self.assertRaises(
Alias.DoesNotExist, Alias.objects.get, address="forward2@test.com")
Alias.DoesNotExist, Alias.objects.get, address="forward2@test.com"
)
def test_forward_and_local_copies(self):
values = {"address": "user@test.com", "recipients": "rcpt@dest.com"}
self.ajax_post(
reverse("admin:alias_add"), values
)
self.ajax_post(reverse("admin:alias_add"), values)
fwd = Alias.objects.get(address="user@test.com", internal=False)
self.assertEqual(fwd.recipients_count, 1)
values["recipients"] = "rcpt@dest.com"
values["recipients_1"] = "user@test.com"
self.ajax_post(
reverse("admin:alias_change", args=[fwd.id]),
values
)
self.ajax_post(reverse("admin:alias_change", args=[fwd.id]), values)
fwd = Alias.objects.get(pk=fwd.pk)
self.assertEqual(fwd.aliasrecipient_set.count(), 2)
self.assertEqual(
fwd.aliasrecipient_set.filter(r_alias__isnull=True).count(), 2)
self.assertEqual(fwd.aliasrecipient_set.filter(r_alias__isnull=True).count(), 2)
def test_wildcard_alias(self):
"""Test creation of a wildcard alias."""
values = {
"address": "@test.com",
"recipients": "user@test.com",
"enabled": True
"enabled": True,
}
self.ajax_post(
reverse("admin:alias_add"), values
)
self.ajax_post(reverse("admin:alias_add"), values)
def test_random_alias(self):
"""Test creation of a random alias."""
@@ -223,7 +201,7 @@ class AliasTestCase(ModoTestCase):
"random_address": True,
"domain": Domain.objects.get(name="test.com").pk,
"recipients": "user@test.com",
"enabled": True
"enabled": True,
}
self.ajax_post(reverse("admin:alias_add"), values)
self.assertEqual(Alias.objects.count(), alias_count + 1)
@@ -234,31 +212,34 @@ class AliasTestCase(ModoTestCase):
def test_distribution_list_deletion_on_user_update_bug(self):
"""This test demonstrates an issue with distribution list being
deleted when one of the users which belong to that list is
changed.
deleted when one of the users which belong to that list is
changed.
"""
values = {
"address": "list@test.com",
"recipients": "user@test.com",
"recipients_1": "admin@test.com",
"enabled": True
"enabled": True,
}
self.ajax_post(
reverse("admin:alias_add"), values
)
self.ajax_post(reverse("admin:alias_add"), values)
user = User.objects.get(username="user@test.com")
values = {
"username": user.username, "first_name": "Tester",
"last_name": "Toto", "password1": "Toto1234",
"password2": "Toto1234", "role": "SimpleUsers", "quota_act": True,
"is_active": True, "email": user.email, "language": "en"
"username": user.username,
"first_name": "Tester",
"last_name": "Toto",
"password1": "Toto1234",
"password2": "Toto1234",
"role": "SimpleUsers",
"quota_act": True,
"is_active": True,
"email": user.email,
"language": "en",
}
self.ajax_post(reverse("admin:account_change", args=[user.id]), values)
self.assertEqual(
Alias.objects.filter(address="list@test.com").count(), 1)
self.assertEqual(Alias.objects.filter(address="list@test.com").count(), 1)
def test_alias_detail_view(self):
"""Test alias detail view."""
@@ -276,15 +257,18 @@ class AliasTestCase(ModoTestCase):
user = User.objects.get(username="user@test.com")
values = {
"username": "user@test.com", "role": user.role,
"is_active": user.is_active, "email": "user@test.com",
"aliases": "toto@test.com", "aliases_1": "titi@test2.com",
"language": "en"
"username": "user@test.com",
"role": user.role,
"is_active": user.is_active,
"email": "user@test.com",
"aliases": "toto@test.com",
"aliases_1": "titi@test2.com",
"language": "en",
}
response = self.ajax_post(
reverse("admin:account_change", args=[user.id]),
values, 400
reverse("admin:account_change", args=[user.id]), values, 400
)
self.assertEqual(
response["form_errors"]["aliases_1"][0],
"You don't have access to this domain")
"You don't have access to this domain",
)
+173 -127
View File
@@ -20,7 +20,7 @@ from modoboa.core.tests.test_views import SETTINGS_SAMPLE
from modoboa.lib.tests import ModoTestCase
from modoboa.maillog import factories as ml_factories
from ..import constants
from .. import constants
from . import utils
from .. import factories
from ..models import Alarm, Alias, Domain
@@ -38,8 +38,12 @@ class DomainTestCase(ModoTestCase):
def test_create(self):
"""Test the creation of a domain."""
values = {
"name": "pouet.com", "quota": 1000, "default_mailbox_quota": 100,
"create_dom_admin": False, "type": "domain", "stepid": "step3"
"name": "pouet.com",
"quota": 1000,
"default_mailbox_quota": 100,
"create_dom_admin": False,
"type": "domain",
"stepid": "step3",
}
self.ajax_post(reverse("admin:domain_add"), values)
dom = Domain.objects.get(name="pouet.com")
@@ -52,12 +56,16 @@ class DomainTestCase(ModoTestCase):
def test_create_utf8(self):
"""Test the creation of a domain with non-ASCII characters."""
values = {
"name": "pouét.com", "quota": 1000, "default_mailbox_quota": 100,
"create_dom_admin": False, "type": "domain", "stepid": "step3"
"name": "pouét.com",
"quota": 1000,
"default_mailbox_quota": 100,
"create_dom_admin": False,
"type": "domain",
"stepid": "step3",
}
self.ajax_post(reverse("admin:domain_add"), values)
dom = Domain.objects.get(name=u"pouét.com")
self.assertEqual(dom.name, u"pouét.com")
dom = Domain.objects.get(name="pouét.com")
self.assertEqual(dom.name, "pouét.com")
self.assertEqual(dom.quota, 1000)
self.assertEqual(dom.default_mailbox_quota, 100)
self.assertEqual(dom.enabled, False)
@@ -66,83 +74,101 @@ class DomainTestCase(ModoTestCase):
def test_create_with_template(self):
"""Test the creation of a domain with a template."""
values = {
"name": "pouet.com", "quota": 1000, "default_mailbox_quota": 100,
"create_dom_admin": True, "dom_admin_username": "toto",
"with_mailbox": True, "create_aliases": True, "type": "domain",
"stepid": "step3"
"name": "pouet.com",
"quota": 1000,
"default_mailbox_quota": 100,
"create_dom_admin": True,
"dom_admin_username": "toto",
"with_mailbox": True,
"create_aliases": True,
"type": "domain",
"stepid": "step3",
}
self.ajax_post(reverse("admin:domain_add"), values)
dom = Domain.objects.get(name="pouet.com")
da = User.objects.get(username="toto@pouet.com")
self.assertIn(da, dom.admins)
al = Alias.objects.get(address="postmaster@pouet.com")
self.assertTrue(
al.aliasrecipient_set.filter(r_mailbox=da.mailbox)
.exists()
)
self.assertTrue(al.aliasrecipient_set.filter(r_mailbox=da.mailbox).exists())
self.assertTrue(da.can_access(al))
values = {
"name": "pouet2.com", "quota": 1000, "default_mailbox_quota": 100,
"create_dom_admin": True, "dom_admin_username": "postmaster",
"create_aliases": True, "type": "domain", "stepid": "step3",
"with_mailbox": True
"name": "pouet2.com",
"quota": 1000,
"default_mailbox_quota": 100,
"create_dom_admin": True,
"dom_admin_username": "postmaster",
"create_aliases": True,
"type": "domain",
"stepid": "step3",
"with_mailbox": True,
}
self.ajax_post(reverse("admin:domain_add"), values)
self.assertTrue(
User.objects.filter(username="postmaster@pouet2.com").exists())
self.assertTrue(User.objects.filter(username="postmaster@pouet2.com").exists())
self.assertFalse(
Alias.objects.filter(
address="postmaster@pouet2.com", internal=False).exists())
address="postmaster@pouet2.com", internal=False
).exists()
)
def test_create_with_template_and_random_password(self):
"""Test domain creation with administrator and random password."""
values = {
"name": "pouet.com", "quota": 1000, "default_mailbox_quota": 100,
"create_dom_admin": True, "dom_admin_username": "toto",
"with_mailbox": True, "create_aliases": True, "type": "domain",
"stepid": "step3", "random_password": True
"name": "pouet.com",
"quota": 1000,
"default_mailbox_quota": 100,
"create_dom_admin": True,
"dom_admin_username": "toto",
"with_mailbox": True,
"create_aliases": True,
"type": "domain",
"stepid": "step3",
"random_password": True,
}
self.ajax_post(reverse("admin:domain_add"), values)
self.assertFalse(
self.client.login(username="admin@pouet.com", password="password"))
self.client.login(username="admin@pouet.com", password="password")
)
def test_create_with_template_and_no_mailbox(self):
"""Test domain creation with administrator but no mailbox."""
values = {
"name": "pouet.com", "quota": 1000, "default_mailbox_quota": 100,
"create_dom_admin": True, "dom_admin_username": "toto",
"with_mailbox": False, "create_aliases": True, "type": "domain",
"stepid": "step3"
"name": "pouet.com",
"quota": 1000,
"default_mailbox_quota": 100,
"create_dom_admin": True,
"dom_admin_username": "toto",
"with_mailbox": False,
"create_aliases": True,
"type": "domain",
"stepid": "step3",
}
self.ajax_post(reverse("admin:domain_add"), values)
dom = Domain.objects.get(name="pouet.com")
da = User.objects.get(username="toto@pouet.com")
self.assertIn(da, dom.admins)
self.assertFalse(hasattr(da, "mailbox"))
self.assertFalse(
Alias.objects.filter(address="postmaster@pouet.com").exists())
self.assertFalse(Alias.objects.filter(address="postmaster@pouet.com").exists())
def test_create_with_template_and_empty_quota(self):
"""Test the creation of a domain with a template and no quota"""
values = {
"name": "pouet.com", "quota": 0, "default_mailbox_quota": 0,
"create_dom_admin": True, "dom_admin_username": "toto",
"create_aliases": True, "type": "domain", "stepid": "step3",
"with_mailbox": True
"name": "pouet.com",
"quota": 0,
"default_mailbox_quota": 0,
"create_dom_admin": True,
"dom_admin_username": "toto",
"create_aliases": True,
"type": "domain",
"stepid": "step3",
"with_mailbox": True,
}
self.ajax_post(
reverse("admin:domain_add"),
values
)
self.ajax_post(reverse("admin:domain_add"), values)
dom = Domain.objects.get(name="pouet.com")
da = User.objects.get(username="toto@pouet.com")
self.assertIn(da, dom.admins)
al = Alias.objects.get(address="postmaster@pouet.com")
self.assertTrue(
al.aliasrecipient_set.filter(r_mailbox=da.mailbox)
.exists()
)
self.assertTrue(al.aliasrecipient_set.filter(r_mailbox=da.mailbox).exists())
self.assertTrue(da.can_access(al))
def test_create_with_template_and_custom_password(self):
@@ -150,61 +176,62 @@ class DomainTestCase(ModoTestCase):
password = "Toto1000"
self.set_global_parameter("default_password", password, app="core")
values = {
"name": "pouet.com", "quota": 0, "default_mailbox_quota": 0,
"create_dom_admin": True, "dom_admin_username": "toto",
"create_aliases": True, "type": "domain", "stepid": "step3",
"with_mailbox": True
"name": "pouet.com",
"quota": 0,
"default_mailbox_quota": 0,
"create_dom_admin": True,
"dom_admin_username": "toto",
"create_aliases": True,
"type": "domain",
"stepid": "step3",
"with_mailbox": True,
}
self.ajax_post(
reverse("admin:domain_add"),
values
)
self.ajax_post(reverse("admin:domain_add"), values)
dom = Domain.objects.get(name="pouet.com")
da = User.objects.get(username="toto@pouet.com")
self.assertIn(da, dom.admins)
al = Alias.objects.get(address="postmaster@pouet.com")
self.assertTrue(
al.aliasrecipient_set.filter(r_mailbox=da.mailbox)
.exists()
)
self.assertTrue(al.aliasrecipient_set.filter(r_mailbox=da.mailbox).exists())
self.assertTrue(da.can_access(al))
self.assertTrue(
self.client.login(username="toto@pouet.com", password=password))
self.assertTrue(self.client.login(username="toto@pouet.com", password=password))
def test_quota_constraints(self):
"""Check quota constraints."""
values = {
"name": "pouet.com", "quota": 10, "default_mailbox_quota": 100,
"create_dom_admin": True, "dom_admin_username": "toto",
"create_aliases": True, "type": "domain", "stepid": "step3"
"name": "pouet.com",
"quota": 10,
"default_mailbox_quota": 100,
"create_dom_admin": True,
"dom_admin_username": "toto",
"create_aliases": True,
"type": "domain",
"stepid": "step3",
}
response = self.ajax_post(
reverse("admin:domain_add"),
values, status=400
)
response = self.ajax_post(reverse("admin:domain_add"), values, status=400)
self.assertEqual(
response["form_errors"]["default_mailbox_quota"][0],
"Cannot be greater than domain quota")
"Cannot be greater than domain quota",
)
dom = Domain.objects.get(name="test.com")
values["name"] = dom.name
values["quota"] = 10
values["default_mailbox_quota"] = 100
response = self.ajax_post(
reverse("admin:domain_change", args=[dom.pk]),
values, status=400
reverse("admin:domain_change", args=[dom.pk]), values, status=400
)
self.assertEqual(
response["form_errors"]["default_mailbox_quota"][0],
"Cannot be greater than domain quota")
"Cannot be greater than domain quota",
)
def test_create_using_default_quota(self):
"""Check that default value is used for creation."""
self.set_global_parameter("default_domain_quota", 500)
self.set_global_parameter("default_mailbox_quota", 50)
response = self.client.get(reverse("admin:domain_add"))
self.assertContains(response, "value=\"500\"")
self.assertContains(response, "value=\"50\"")
self.assertContains(response, 'value="500"')
self.assertContains(response, 'value="50"')
@mock.patch.object(dns.resolver.Resolver, "resolve")
@mock.patch("socket.getaddrinfo")
@@ -214,7 +241,8 @@ class DomainTestCase(ModoTestCase):
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
reseller = core_factories.UserFactory(
username="reseller", groups=("Resellers", ))
username="reseller", groups=("Resellers",)
)
self.client.force_login(reseller)
self.set_global_parameter("enable_admin_limits", False, app="limits")
@@ -222,15 +250,18 @@ class DomainTestCase(ModoTestCase):
self.set_global_parameter("domains_must_have_authorized_mx", True)
values = {
"name": "no-mx.example.com", "quota": 0,
"name": "no-mx.example.com",
"quota": 0,
"default_mailbox_quota": 0,
"create_dom_admin": True, "dom_admin_username": "toto",
"create_aliases": True, "type": "domain", "stepid": "step3",
"with_mailbox": True
"create_dom_admin": True,
"dom_admin_username": "toto",
"create_aliases": True,
"type": "domain",
"stepid": "step3",
"with_mailbox": True,
}
self.ajax_post(reverse("admin:domain_add"), values, 400)
self.assertFalse(
Domain.objects.filter(name=values["name"]).exists())
self.assertFalse(Domain.objects.filter(name=values["name"]).exists())
values["name"] = "pouet.com"
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
@@ -242,21 +273,20 @@ class DomainTestCase(ModoTestCase):
Rename 'test.com' domain to 'pouet.com'
"""
values = {
"name": "pouet.com", "quota": 1000, "default_mailbox_quota": 100,
"type": "domain", "enabled": True
"name": "pouet.com",
"quota": 1000,
"default_mailbox_quota": 100,
"type": "domain",
"enabled": True,
}
dom = Domain.objects.get(name="test.com")
self.ajax_post(
reverse("admin:domain_change", args=[dom.id]),
values
)
self.ajax_post(reverse("admin:domain_change", args=[dom.id]), values)
dom = Domain.objects.get(name="pouet.com")
self.assertEqual(dom.name, "pouet.com")
self.assertTrue(dom.enabled)
# Check if aliases were renamed too
self.assertTrue(
dom.alias_set.filter(address="postmaster@pouet.com").exists())
self.assertTrue(dom.alias_set.filter(address="postmaster@pouet.com").exists())
def test_delete(self):
"""Test the removal of a domain."""
@@ -264,15 +294,13 @@ class DomainTestCase(ModoTestCase):
self.ajax_post(reverse("admin:domain_delete", args=[dom.id]))
with self.assertRaises(Domain.DoesNotExist):
Domain.objects.get(pk=1)
self.assertTrue(
User.objects.filter(username="user@test.com").exists())
self.assertTrue(User.objects.filter(username="user@test.com").exists())
self.set_global_parameter("auto_account_removal", True)
dom = Domain.objects.get(name="test2.com")
self.ajax_post(reverse("admin:domain_delete", args=[dom.id]))
with self.assertRaises(Domain.DoesNotExist):
Domain.objects.get(pk=1)
self.assertFalse(
User.objects.filter(username="admin@test2.com").exists())
self.assertFalse(User.objects.filter(username="admin@test2.com").exists())
def test_domain_counters(self):
"""Check counters at domain level."""
@@ -347,8 +375,10 @@ class DomainTestCase(ModoTestCase):
domain = Domain.objects.get(name="test.com")
ml_factories.MaillogFactory(from_domain=domain)
ml_factories.MaillogFactory(
to_domain=domain, status="received",
date=timezone.now() + relativedelta(days=1))
to_domain=domain,
status="received",
date=timezone.now() + relativedelta(days=1),
)
ml_factories.MaillogFactory(date=timezone.now() + relativedelta(days=2))
ml_factories.MaillogFactory(date=timezone.now() + relativedelta(days=3))
url = reverse("admin:domain_logs_list")
@@ -375,8 +405,7 @@ class DomainTestCase(ModoTestCase):
self.assertEqual(response.status_code, 200)
self.assertIn("Global statistics", response.content.decode("utf-8"))
self.client.force_login(
User.objects.get(username="admin@test.com"))
self.client.force_login(User.objects.get(username="admin@test.com"))
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
content = response.content.decode("utf-8")
@@ -386,7 +415,8 @@ class DomainTestCase(ModoTestCase):
def test_page_loader(self):
"""Test page loader view."""
factories.AlarmFactory(
domain__name="test.com", mailbox=None, title="Test alarm")
domain__name="test.com", mailbox=None, title="Test alarm"
)
url = reverse("admin:domain_page")
response = self.ajax_get(url)
self.assertIn("handle_mailboxes", response)
@@ -418,10 +448,13 @@ class DKIMTestCase(ModoTestCase):
settings["admin-dkim_keys_storage_dir"] = "/wrong"
response = self.client.post(url, settings, format="json")
self.assertEqual(response.status_code, 400)
compare(response.json(), {
"form_errors": {"dkim_keys_storage_dir": ["Directory not found."]},
"prefix": "admin"
})
compare(
response.json(),
{
"form_errors": {"dkim_keys_storage_dir": ["Directory not found."]},
"prefix": "admin",
},
)
settings["admin-dkim_keys_storage_dir"] = self.workdir
response = self.client.post(url, settings, format="json")
self.assertEqual(response.status_code, 200)
@@ -429,20 +462,26 @@ class DKIMTestCase(ModoTestCase):
def test_dkim_key_creation(self):
"""Test DKIM key creation."""
values = {
"name": "pouet.com", "quota": 1000, "default_mailbox_quota": 100,
"create_dom_admin": False, "type": "domain", "stepid": "step3",
"enable_dkim": True, "dkim_key_selector": ""
"name": "pouet.com",
"quota": 1000,
"default_mailbox_quota": 100,
"create_dom_admin": False,
"type": "domain",
"stepid": "step3",
"enable_dkim": True,
"dkim_key_selector": "",
}
response = self.ajax_post(reverse("admin:domain_add"), values, 400)
self.assertEqual(
response["form_errors"]["enable_dkim"][0],
"DKIM keys storage directory not configured")
"DKIM keys storage directory not configured",
)
self.set_global_parameter("dkim_keys_storage_dir", self.workdir)
response = self.ajax_post(reverse("admin:domain_add"), values, 400)
self.assertEqual(
response["form_errors"]["dkim_key_selector"][0],
"This field is required.")
response["form_errors"]["dkim_key_selector"][0], "This field is required."
)
values["dkim_key_selector"] = "default"
self.ajax_post(reverse("admin:domain_add"), values)
@@ -453,30 +492,33 @@ class DKIMTestCase(ModoTestCase):
domain = Domain.objects.get(name=values["name"])
# Closing the alarm and retry generating dkim keys
Alarm.objects.get(domain=domain,
internal_name=constants.DKIM_WRITE_ERROR
).close()
Alarm.objects.get(
domain=domain, internal_name=constants.DKIM_WRITE_ERROR
).close()
call_command("modo", "manage_dkim_keys")
self.assertEqual(
Alarm.objects.get(domain=domain,
internal_name=constants.DKIM_WRITE_ERROR).status,
constants.ALARM_OPENED)
Alarm.objects.get(
domain=domain, internal_name=constants.DKIM_WRITE_ERROR
).status,
constants.ALARM_OPENED,
)
# Generate normally
self.set_global_parameter("dkim_keys_storage_dir", self.workdir)
call_command("modo", "manage_dkim_keys")
self.assertEqual(
Alarm.objects.get(domain=domain,
internal_name=constants.DKIM_WRITE_ERROR).status,
constants.ALARM_CLOSED)
Alarm.objects.get(
domain=domain, internal_name=constants.DKIM_WRITE_ERROR
).status,
constants.ALARM_CLOSED,
)
key_path = os.path.join(self.workdir, "{}.pem".format(values["name"]))
self.assertTrue(os.path.exists(key_path))
domain.refresh_from_db()
url = reverse("admin:domain_detail", args=[domain.pk])
response = self.client.get(url)
self.assertContains(
response, escape(domain.bind_format_dkim_public_key))
self.assertContains(response, escape(domain.bind_format_dkim_public_key))
# Try generating DKIM key for a targetted domain
domain.dkim_private_key_path = ""
@@ -488,14 +530,13 @@ class DKIMTestCase(ModoTestCase):
# Try disabling DKIM and checking that dkim_private_key_path is emptied
values = {
"name": "pouet.com", "enable_dkim": False,
"quota": 1000, "default_mailbox_quota": 100,
"type": "domain"
"name": "pouet.com",
"enable_dkim": False,
"quota": 1000,
"default_mailbox_quota": 100,
"type": "domain",
}
self.ajax_post(
reverse("admin:domain_change", args=[domain.id]),
values
)
self.ajax_post(reverse("admin:domain_change", args=[domain.id]), values)
domain.refresh_from_db()
self.assertEqual(domain.dkim_private_key_path, "")
@@ -503,9 +544,14 @@ class DKIMTestCase(ModoTestCase):
""" """
self.set_global_parameter("dkim_keys_storage_dir", self.workdir)
values = {
"name": "pouet.com", "quota": 1000, "default_mailbox_quota": 100,
"create_dom_admin": False, "type": "domain", "stepid": "step3",
"enable_dkim": True, "dkim_key_selector": "default"
"name": "pouet.com",
"quota": 1000,
"default_mailbox_quota": 100,
"create_dom_admin": False,
"type": "domain",
"stepid": "step3",
"enable_dkim": True,
"dkim_key_selector": "default",
}
self.ajax_post(reverse("admin:domain_add"), values)
call_command("modo", "manage_dkim_keys")
+11 -18
View File
@@ -21,37 +21,30 @@ class DomainAliasTestCase(ModoTestCase):
domal.target = dom
domal.save()
self.assertEqual(dom.domainalias_count, 1)
self.assertTrue(
Alias.objects.filter(
address="@{}".format(domal.name)).exists())
self.assertTrue(Alias.objects.filter(address="@{}".format(domal.name)).exists())
domal.name = "domalias.org"
domal.save()
domal.delete()
self.assertFalse(
Alias.objects.filter(
address="@{}".format(domal.name)).exists())
Alias.objects.filter(address="@{}".format(domal.name)).exists()
)
def test_form(self):
dom = Domain.objects.get(name="test.com")
values = {
"name": dom.name, "quota": dom.quota,
"name": dom.name,
"quota": dom.quota,
"default_mailbox_quota": dom.default_mailbox_quota,
"enabled": dom.enabled, "aliases": "domalias.net",
"aliases_1": "domaliasé.com", "type": "domain"
"enabled": dom.enabled,
"aliases": "domalias.net",
"aliases_1": "domaliasé.com",
"type": "domain",
}
self.ajax_post(
reverse("admin:domain_change",
args=[dom.id]),
values
)
self.ajax_post(reverse("admin:domain_change", args=[dom.id]), values)
self.assertEqual(dom.domainalias_set.count(), 2)
del values["aliases_1"]
self.ajax_post(
reverse("admin:domain_change",
args=[dom.id]),
values
)
self.ajax_post(reverse("admin:domain_change", args=[dom.id]), values)
self.assertEqual(dom.domainalias_set.count(), 1)
+17 -21
View File
@@ -22,20 +22,19 @@ class ExportTestCase(ModoTestCase):
def __export_domains(self, domfilter=""):
self.client.get(
"{}?domfilter={}".format(
reverse("admin:_domain_list"), domfilter))
"{}?domfilter={}".format(reverse("admin:_domain_list"), domfilter)
)
return self.client.post(
reverse("admin:domain_export"), {"filename": "test.csv"}
)
def __export_identities(self, idtfilter="", grpfilter=""):
self.client.get(
reverse("admin:_identity_list") +
"?grpfilter=%s&idtfilter=%s" % (grpfilter, idtfilter)
reverse("admin:_identity_list")
+ "?grpfilter=%s&idtfilter=%s" % (grpfilter, idtfilter)
)
return self.client.post(
reverse("admin:identity_export"),
{"filename": "test.csv"}
reverse("admin:identity_export"), {"filename": "test.csv"}
)
def test_export_domains(self):
@@ -49,8 +48,7 @@ class ExportTestCase(ModoTestCase):
"domain;test2.com;0;0;True",
]
self.assertCountEqual(
expected_response,
force_str(response.content.strip()).split("\r\n")
expected_response, force_str(response.content.strip()).split("\r\n")
)
# Test management command too.
@@ -59,7 +57,8 @@ class ExportTestCase(ModoTestCase):
response = sys.stdout.getvalue()
sys.stdout = stdout_backup
self.assertCountEqual(
expected_response, force_str(response.strip()).split("\r\n"))
expected_response, force_str(response.strip()).split("\r\n")
)
def test_export_identities(self):
response = self.__export_identities()
@@ -69,16 +68,15 @@ class ExportTestCase(ModoTestCase):
admin_row = received_content[0].split(";")
admin_row[2] = ""
received_content[0] = ";".join(admin_row)
self.assertCountEqual(
expected_response.strip().split("\r\n"),
received_content
)
self.assertCountEqual(expected_response.strip().split("\r\n"), received_content)
def test_export_simpleusers(self):
factories.MailboxFactory(
user__username="toto@test.com",
user__first_name="Léon", user__groups=("SimpleUsers", ),
address="toto", domain__name="test.com",
user__first_name="Léon",
user__groups=("SimpleUsers",),
address="toto",
domain__name="test.com",
)
response = self.__export_identities(
idtfilter="account", grpfilter="SimpleUsers"
@@ -86,7 +84,7 @@ class ExportTestCase(ModoTestCase):
expected_response = "account;user@test.com;{PLAIN}toto;;;True;SimpleUsers;user@test.com;10\r\naccount;user@test2.com;{PLAIN}toto;;;True;SimpleUsers;user@test2.com;10\r\naccount;toto@test.com;{PLAIN}toto;Léon;;True;SimpleUsers;toto@test.com;10" # NOQA:E501
self.assertCountEqual(
expected_response.split("\r\n"),
force_str(response.content.strip()).split("\r\n")
force_str(response.content.strip()).split("\r\n"),
)
def test_export_superadmins(self):
@@ -100,9 +98,7 @@ class ExportTestCase(ModoTestCase):
elements = response.content.decode().strip().split(";")
self.assertEqual(len(elements), 9)
elements[2] = ""
self.assertEqual(
";".join(elements), "account;admin;;;;True;SuperAdmins;;"
)
self.assertEqual(";".join(elements), "account;admin;;;;True;SuperAdmins;;")
def test_export_domainadmins(self):
response = self.__export_identities(
@@ -111,12 +107,12 @@ class ExportTestCase(ModoTestCase):
expected_response = "account;admin@test.com;{PLAIN}toto;;;True;DomainAdmins;admin@test.com;10;test.com\r\naccount;admin@test2.com;{PLAIN}toto;;;True;DomainAdmins;admin@test2.com;10;test2.com" # NOQA:E501
self.assertCountEqual(
expected_response.split("\r\n"),
force_str(response.content.strip()).split("\r\n")
force_str(response.content.strip()).split("\r\n"),
)
def test_export_aliases(self):
response = self.__export_identities(idtfilter="alias")
self.assertEqual(
response.content.decode().strip(),
"alias;alias@test.com;True;user@test.com\r\nalias;forward@test.com;True;user@external.com\r\nalias;postmaster@test.com;True;test@truc.fr;toto@titi.com" # NOQA:E501
"alias;alias@test.com;True;user@test.com\r\nalias;forward@test.com;True;user@external.com\r\nalias;postmaster@test.com;True;test@truc.fr;toto@titi.com", # NOQA:E501
)
+130 -144
View File
@@ -22,8 +22,7 @@ class ImportTestCase(ModoTestCase):
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(ImportTestCase, cls).setUpTestData()
cls.localconfig.parameters.set_value(
"enable_admin_limits", False, app="limits")
cls.localconfig.parameters.set_value("enable_admin_limits", False, app="limits")
cls.localconfig.save()
factories.populate_database()
@@ -32,15 +31,14 @@ class ImportTestCase(ModoTestCase):
self.assertEqual(response.status_code, 200)
self.assertIn("Provide a CSV", response.content.decode())
f = ContentFile(b"""domain; domain1.com; 1000; 100; True
f = ContentFile(
b"""domain; domain1.com; 1000; 100; True
domain; domain2.com; 1000; 200; False
domainalias; domalias1.com; domain1.com; True
""", name="domains.csv")
self.client.post(
reverse("admin:domain_import"), {
"sourcefile": f
}
""",
name="domains.csv",
)
self.client.post(reverse("admin:domain_import"), {"sourcefile": f})
admin = User.objects.get(username="admin")
dom = Domain.objects.get(name="domain1.com")
self.assertEqual(dom.quota, 1000)
@@ -59,25 +57,21 @@ domainalias; domalias1.com; domain1.com; True
def test_domain_import_bad_syntax(self):
"""Check errors handling."""
url = reverse("admin:domain_import")
f = ContentFile("domain; domain1.com; 100; True",
name="domains.csv")
f = ContentFile("domain; domain1.com; 100; True", name="domains.csv")
response = self.client.post(url, {"sourcefile": f})
self.assertContains(response, "Invalid line")
f = ContentFile("domain; domain1.com; XX; 100; True",
name="domains.csv")
f = ContentFile("domain; domain1.com; XX; 100; True", name="domains.csv")
response = self.client.post(url, {"sourcefile": f})
self.assertContains(response, "domain1.com: invalid quota value")
f = ContentFile("domain; domain1.com; 100; XX; True",
name="domains.csv")
f = ContentFile("domain; domain1.com; 100; XX; True", name="domains.csv")
response = self.client.post(url, {"sourcefile": f})
self.assertContains(
response, "domain1.com: invalid default mailbox quota")
f = ContentFile("domain; domain1.com; 10; 100; True",
name="domains.csv")
self.assertContains(response, "domain1.com: invalid default mailbox quota")
f = ContentFile("domain; domain1.com; 10; 100; True", name="domains.csv")
response = self.client.post(url, {"sourcefile": f})
self.assertContains(
response,
"domain1.com: default mailbox quota cannot be greater than domain quota")
"domain1.com: default mailbox quota cannot be greater than domain quota",
)
@mock.patch.object(dns.resolver.Resolver, "resolve")
@mock.patch("socket.getaddrinfo")
@@ -86,60 +80,49 @@ domainalias; domalias1.com; domain1.com; True
mock_query.side_effect = utils.mock_dns_query_result
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
reseller = core_factories.UserFactory(
username="reseller", groups=("Resellers", ))
username="reseller", groups=("Resellers",)
)
self.client.force_login(reseller)
self.set_global_parameter("valid_mxs", "192.0.2.1 2001:db8::1")
self.set_global_parameter("domains_must_have_authorized_mx", True)
f = ContentFile(
b"domain; test3.com; 100; 1; True", name="domains.csv")
resp = self.client.post(
reverse("admin:domain_import"), {
"sourcefile": f
}
)
self.assertContains(
resp, "test3.com: no authorized MX record found for domain")
f = ContentFile(b"domain; test3.com; 100; 1; True", name="domains.csv")
resp = self.client.post(reverse("admin:domain_import"), {"sourcefile": f})
self.assertContains(resp, "test3.com: no authorized MX record found for domain")
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
f = ContentFile(
b"domain; domain1.com; 100; 1; True", name="domains.csv")
resp = self.client.post(
reverse("admin:domain_import"), {
"sourcefile": f
}
)
self.assertTrue(
Domain.objects.filter(name="domain1.com").exists())
f = ContentFile(b"domain; domain1.com; 100; 1; True", name="domains.csv")
resp = self.client.post(reverse("admin:domain_import"), {"sourcefile": f})
self.assertTrue(Domain.objects.filter(name="domain1.com").exists())
def test_import_domains_with_conflict(self):
f = ContentFile(b"""domain;test.alias;100;10;True
f = ContentFile(
b"""domain;test.alias;100;10;True
domainalias;test.alias;test.com;True
""", name="domains.csv")
resp = self.client.post(
reverse("admin:domain_import"), {
"sourcefile": f
}
""",
name="domains.csv",
)
self.assertIn(
"Object already exists: domainalias", resp.content.decode())
resp = self.client.post(reverse("admin:domain_import"), {"sourcefile": f})
self.assertIn("Object already exists: domainalias", resp.content.decode())
def test_identities_import(self):
response = self.client.get(reverse("admin:identity_import"))
self.assertEqual(response.status_code, 200)
self.assertIn("Provide a CSV", response.content.decode())
f = ContentFile("""
f = ContentFile(
"""
account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com; 0
account; Truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; 5; test.com
alias; alias1@test.com; True; user1@test.com
forward; alias2@test.com; True; user1+ext@test.com
forward; fwd1@test.com; True; user@extdomain.com
dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
""", name="identities.csv") # NOQA:E501
""",
name="identities.csv",
) # NOQA:E501
self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True}
reverse("admin:identity_import"), {"sourcefile": f, "crypt_password": True}
)
admin = User.objects.get(username="admin")
u1 = User.objects.get(username="user1@test.com")
@@ -154,13 +137,11 @@ dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
self.assertEqual(mb1.quota, 0)
self.assertTrue(admin.is_owner(mb1))
self.assertEqual(mb1.full_address, "user1@test.com")
self.assertTrue(
self.client.login(username="user1@test.com", password="toto")
)
self.assertTrue(self.client.login(username="user1@test.com", password="toto"))
da = User.objects.get(username="truc@test.com")
damb = da.mailbox
self.assertEqual(da.first_name, u"René")
self.assertEqual(da.first_name, "René")
self.assertEqual(da.role, "DomainAdmins")
self.assertEqual(damb.quota, 5)
self.assertFalse(damb.use_domain_quota)
@@ -171,52 +152,48 @@ dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
self.assertTrue(da.can_access(u))
al = Alias.objects.get(address="alias1@test.com")
self.assertTrue(
al.aliasrecipient_set
.filter(r_mailbox=u1.mailbox).exists()
)
self.assertTrue(al.aliasrecipient_set.filter(r_mailbox=u1.mailbox).exists())
self.assertTrue(admin.is_owner(al))
fwd = Alias.objects.get(address="fwd1@test.com")
self.assertTrue(
fwd.aliasrecipient_set
.filter(
address="user@extdomain.com", r_mailbox__isnull=True,
r_alias__isnull=True)
.exists()
fwd.aliasrecipient_set.filter(
address="user@extdomain.com",
r_mailbox__isnull=True,
r_alias__isnull=True,
).exists()
)
self.assertTrue(admin.is_owner(fwd))
dlist = Alias.objects.get(address="dlist@test.com")
self.assertTrue(dlist.aliasrecipient_set.filter(r_mailbox=u1.mailbox).exists())
self.assertTrue(
dlist.aliasrecipient_set
.filter(r_mailbox=u1.mailbox).exists()
)
self.assertTrue(
dlist.aliasrecipient_set.filter(address="user@extdomain.com")
.exists()
dlist.aliasrecipient_set.filter(address="user@extdomain.com").exists()
)
self.assertTrue(admin.is_owner(dlist))
def test_import_for_nonlocal_domain(self):
"""Try to import an account for nonlocal domain."""
f = ContentFile(b"""
f = ContentFile(
b"""
account; user1@nonlocal.com; toto; User; One; True; SimpleUsers; user1@nonlocal.com; 0
""", name="identities.csv") # NOQA:E501
""",
name="identities.csv",
) # NOQA:E501
self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True}
reverse("admin:identity_import"), {"sourcefile": f, "crypt_password": True}
)
self.assertFalse(
User.objects.filter(username="user1@nonlocal.com").exists())
self.assertFalse(User.objects.filter(username="user1@nonlocal.com").exists())
def test_import_invalid_quota(self):
f = ContentFile(b"""
f = ContentFile(
b"""
account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com; ; test.com
""", name="identities.csv") # NOQA:E501
""",
name="identities.csv",
) # NOQA:E501
resp = self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True}
reverse("admin:identity_import"), {"sourcefile": f, "crypt_password": True}
)
self.assertIn("wrong quota value", resp.content.decode())
@@ -224,62 +201,69 @@ account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com; ; t
"""Check if a domain admin is not allowed to import a domain."""
self.client.logout()
self.client.login(username="admin@test.com", password="toto")
f = ContentFile(b"""
f = ContentFile(
b"""
domain; domain2.com; 1000; 200; False
""", name="identities.csv")
resp = self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True}
""",
name="identities.csv",
)
self.assertIn(
"You are not allowed to import domains",
resp.content.decode())
f = ContentFile(b"""
resp = self.client.post(
reverse("admin:identity_import"), {"sourcefile": f, "crypt_password": True}
)
self.assertIn("You are not allowed to import domains", resp.content.decode())
f = ContentFile(
b"""
domainalias; domalias1.com; test.com; True
""", name="identities.csv")
""",
name="identities.csv",
)
resp = self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True}
reverse("admin:identity_import"), {"sourcefile": f, "crypt_password": True}
)
self.assertIn(
"You are not allowed to import domain aliases",
resp.content.decode())
"You are not allowed to import domain aliases", resp.content.decode()
)
def test_import_quota_too_big(self):
self.client.logout()
self.client.login(username="admin@test.com", password="toto")
f = ContentFile(b"""
f = ContentFile(
b"""
account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com; 40
""", name="identities.csv")
""",
name="identities.csv",
)
resp = self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True}
reverse("admin:identity_import"), {"sourcefile": f, "crypt_password": True}
)
self.assertIn("test.com: domain quota exceeded", resp.content.decode())
def test_import_missing_quota(self):
f = ContentFile(b"""
f = ContentFile(
b"""
account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com
""", name="identities.csv")
""",
name="identities.csv",
)
self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True}
reverse("admin:identity_import"), {"sourcefile": f, "crypt_password": True}
)
account = User.objects.get(username="user1@test.com")
self.assertEqual(
account.mailbox.quota,
account.mailbox.domain.default_mailbox_quota
account.mailbox.quota, account.mailbox.domain.default_mailbox_quota
)
def test_import_duplicate(self):
f = ContentFile("""
f = ContentFile(
"""
account; admin@test.com; toto; Admin; ; True; DomainAdmins; admin@test.com; 0; test.com
account; truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; 0; test.com
""", name="identities.csv") # NOQA:E501
""",
name="identities.csv",
) # NOQA:E501
self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True,
"continue_if_exists": True}
{"sourcefile": f, "crypt_password": True, "continue_if_exists": True},
)
admin = User.objects.get(username="admin")
u1 = User.objects.get(username="truc@test.com")
@@ -291,58 +275,63 @@ account; truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; 0;
Expected result: no
"""
self.client.logout()
self.assertTrue(
self.client.login(username="admin@test.com", password="toto")
)
f = ContentFile(b"""
self.assertTrue(self.client.login(username="admin@test.com", password="toto"))
f = ContentFile(
b"""
account; sa@test.com; toto; Super; Admin; True; SuperAdmins; superadmin@test.com; 50
""", name="identities.csv") # NOQA:E501
""",
name="identities.csv",
) # NOQA:E501
self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True,
"continue_if_exists": True}
{"sourcefile": f, "crypt_password": True, "continue_if_exists": True},
)
with self.assertRaises(User.DoesNotExist):
User.objects.get(username="sa@test.com")
def test_import_alias_with_empty_values(self):
f = ContentFile(b"""
f = ContentFile(
b"""
alias;user.alias@test.com;True;user@test.com;;;;;;;;;;;;;;;;
""", name="identities.csv")
""",
name="identities.csv",
)
self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True,
"continue_if_exists": True}
{"sourcefile": f, "crypt_password": True, "continue_if_exists": True},
)
alias = Alias.objects.get(address="user.alias@test.com")
self.assertEqual(alias.type, "alias")
def test_import_account_alias_conflict(self):
"""Specific test for #1144."""
f = ContentFile(b"""
f = ContentFile(
b"""
alias;user@test.com;True;admin@test.com
""", name="identities.csv")
""",
name="identities.csv",
)
self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True}
reverse("admin:identity_import"), {"sourcefile": f, "crypt_password": True}
)
self.assertTrue(
Alias.objects.filter(
address="user@test.com", internal=False).exists())
Alias.objects.filter(address="user@test.com", internal=False).exists()
)
def test_domains_import_utf8(self):
response = self.client.get(reverse("admin:domain_import"))
self.assertEqual(response.status_code, 200)
self.assertIn("Provide a CSV", response.content.decode())
f = ContentFile("""domain; dómªin1.com; 1000; 100; True
f = ContentFile(
"""domain; dómªin1.com; 1000; 100; True
dómain; dómªin2.com; 1000; 100; True
""".encode("utf8"), name="dómains.csv")
self.client.post(
reverse("admin:domain_import"), {
"sourcefile": f
}
""".encode(
"utf8"
),
name="dómains.csv",
)
self.client.post(reverse("admin:domain_import"), {"sourcefile": f})
admin = User.objects.get(username="admin")
dom = Domain.objects.get(name="dómªin1.com")
self.assertEqual(dom.quota, 1000)
@@ -360,8 +349,7 @@ dómain; dómªin2.com; 1000; 100; True
def test_import_command(self):
test_file = os.path.join(
os.path.dirname(__file__),
"test_data/import_domains.csv"
os.path.dirname(__file__), "test_data/import_domains.csv"
)
call_command("modo", "import", test_file)
@@ -381,8 +369,7 @@ dómain; dómªin2.com; 1000; 100; True
def test_import_command_non_utf8(self):
test_file = os.path.join(
os.path.dirname(__file__),
"test_data/import_domains_iso8859.csv"
os.path.dirname(__file__), "test_data/import_domains_iso8859.csv"
)
call_command("modo", "import", test_file)
dom = Domain.objects.get(name="dómain2.com")
@@ -390,8 +377,7 @@ dómain; dómªin2.com; 1000; 100; True
def test_import_command_duplicates(self):
test_file = os.path.join(
os.path.dirname(__file__),
"test_data/import_domains_duplicates.csv"
os.path.dirname(__file__), "test_data/import_domains_duplicates.csv"
)
with self.assertRaises(CommandError) as cm:
call_command("modo", "import", test_file)
@@ -400,8 +386,7 @@ dómain; dómªin2.com; 1000; 100; True
def test_import_command_duplicates_continue(self):
test_file = os.path.join(
os.path.dirname(__file__),
"test_data/import_domains_duplicates.csv"
os.path.dirname(__file__), "test_data/import_domains_duplicates.csv"
)
call_command("modo", "import", "--continue-if-exists", test_file)
@@ -420,20 +405,21 @@ dómain; dómªin2.com; 1000; 100; True
self.assertTrue(admin.is_owner(dom))
def test_import_aliases(self):
f = ContentFile("""
f = ContentFile(
"""
account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com; 0
account; Truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; 5; test.com
alias; alias1@test.com; True; user1@test.com
""", name="identities.csv") # NOQA:E501
""",
name="identities.csv",
) # NOQA:E501
resp = self.client.post(
reverse("admin:identity_import"),
{"sourcefile": f, "crypt_password": True}
reverse("admin:identity_import"), {"sourcefile": f, "crypt_password": True}
)
self.assertEqual(resp.status_code, 200)
test_file = os.path.join(
os.path.dirname(__file__),
"test_data/import_aliases.csv"
os.path.dirname(__file__), "test_data/import_aliases.csv"
)
with self.assertRaises(CommandError) as cm:
call_command("modo", "import", test_file)
+12 -13
View File
@@ -13,8 +13,7 @@ from modoboa.lib.tests import ModoTestCase
from .. import factories, models
@override_settings(
DOVECOT_LOOKUP_PATH=["{}/dovecot".format(os.path.dirname(__file__))])
@override_settings(DOVECOT_LOOKUP_PATH=["{}/dovecot".format(os.path.dirname(__file__))])
class MailboxOperationTestCase(ModoTestCase):
"""Test management command."""
@@ -43,10 +42,9 @@ class MailboxOperationTestCase(ModoTestCase):
path = "{}/test.com/admin".format(self.workdir)
mail_home_mock.__get__ = mock.Mock(return_value=path)
mb = models.Mailbox.objects.select_related("user").get(
address="admin", domain__name="test.com")
self.ajax_post(
reverse("admin:account_delete", args=[mb.user.pk]), {}
address="admin", domain__name="test.com"
)
self.ajax_post(reverse("admin:account_delete", args=[mb.user.pk]), {})
call_command("handle_mailbox_operations")
self.assertFalse(models.MailboxOperation.objects.exists())
self.assertFalse(os.path.exists(mb.mail_home))
@@ -57,15 +55,16 @@ class MailboxOperationTestCase(ModoTestCase):
path = "{}/test.com/admin".format(self.workdir)
mail_home_mock.__get__ = mock.Mock(return_value=path)
mb = models.Mailbox.objects.select_related("user").get(
address="admin", domain__name="test.com")
values = {
"username": "admin2@test.com", "role": "DomainAdmins",
"is_active": True, "email": "admin2@test.com",
"language": "en"
}
self.ajax_post(
reverse("admin:account_change", args=[mb.user.pk]), values
address="admin", domain__name="test.com"
)
values = {
"username": "admin2@test.com",
"role": "DomainAdmins",
"is_active": True,
"email": "admin2@test.com",
"language": "en",
}
self.ajax_post(reverse("admin:account_change", args=[mb.user.pk]), values)
path = "{}/test.com/admin2".format(self.workdir)
mail_home_mock.__get__ = mock.Mock(return_value=path)
call_command("handle_mailbox_operations")
+10 -9
View File
@@ -11,20 +11,22 @@ from modoboa.lib.test_utils import MapFilesTestCaseMixin
class MapFilesTestCase(MapFilesTestCaseMixin, TestCase):
"""Test case for admin."""
MAP_FILES = [
"sql-domains.cf", "sql-domain-aliases.cf", "sql-aliases.cf",
"sql-maintain.cf", "sql-sender-login-map.cf"
"sql-domains.cf",
"sql-domain-aliases.cf",
"sql-aliases.cf",
"sql-maintain.cf",
"sql-sender-login-map.cf",
]
def test_map_upgrade(self):
"""Check that map content is used."""
dburl = "postgres://user:password@localhost/testdb"
call_command(
"generate_postfix_maps",
"--dburl", dburl, "--destdir", self.workdir)
"generate_postfix_maps", "--dburl", dburl, "--destdir", self.workdir
)
# Now upgrade files. Map credentials should be preserved.
call_command("generate_postfix_maps", "--destdir", self.workdir)
@@ -36,8 +38,8 @@ class MapFilesTestCase(MapFilesTestCaseMixin, TestCase):
# Now force overwrite, credentials should be different
call_command(
"generate_postfix_maps", "--destdir", self.workdir,
"--force-overwrite")
"generate_postfix_maps", "--destdir", self.workdir, "--force-overwrite"
)
dbsettings = settings.DATABASES["default"]
for f in self.MAP_FILES:
mapcontent = parse_map_file(os.path.join(self.workdir, f))
@@ -45,8 +47,7 @@ class MapFilesTestCase(MapFilesTestCaseMixin, TestCase):
self.assertEqual(mapcontent["dbpath"], dbsettings["NAME"])
else:
self.assertEqual(mapcontent["user"], dbsettings["USER"])
self.assertEqual(
mapcontent["password"], dbsettings["PASSWORD"])
self.assertEqual(mapcontent["password"], dbsettings["PASSWORD"])
self.assertEqual(mapcontent["dbname"], dbsettings["NAME"])
# Now modify a file manually
+87 -72
View File
@@ -10,8 +10,7 @@ from django.test import override_settings
from django.urls import reverse
from django.utils.translation import gettext as _
from modoboa.core import (
models as core_models, factories as core_factories)
from modoboa.core import models as core_models, factories as core_factories
from modoboa.lib.tests import ModoTestCase
from . import utils
from .. import factories, models
@@ -27,23 +26,22 @@ class MXTestCase(ModoTestCase):
super(MXTestCase, cls).setUpTestData()
cls.domain = factories.DomainFactory(name="modoboa.org")
# should not exist
cls.bad_domain = factories.DomainFactory(
name="does-not-exist.example.com")
cls.bad_domain = factories.DomainFactory(name="does-not-exist.example.com")
# Add domain admin with mailbox
mb = factories.MailboxFactory(
address="admin", domain=cls.bad_domain,
address="admin",
domain=cls.bad_domain,
user__username="admin@does-not-exist.example.com",
user__groups=("DomainAdmins", )
user__groups=("DomainAdmins",),
)
cls.bad_domain.add_admin(mb.user)
# Add domain admin with no mailbox
admin = core_factories.UserFactory(
username="admin2@does-not-exist.example.com",
groups=("DomainAdmins", ))
username="admin2@does-not-exist.example.com", groups=("DomainAdmins",)
)
cls.bad_domain.add_admin(admin)
cls.localconfig.parameters.set_value(
"valid_mxs", "192.0.2.1 2001:db8::1")
cls.localconfig.parameters.set_value("valid_mxs", "192.0.2.1 2001:db8::1")
cls.localconfig.save()
models.MXRecord.objects.all().delete()
@@ -51,15 +49,15 @@ class MXTestCase(ModoTestCase):
@mock.patch("socket.getaddrinfo")
@mock.patch.object(dns.resolver.Resolver, "resolve")
def test_management_command(
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname):
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname
):
"""Check that command works fine."""
mock_query.side_effect = utils.mock_dns_query_result
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
mock_g_gethostbyname.return_value = "1.2.3.4"
self.assertEqual(models.MXRecord.objects.count(), 0)
management.call_command("modo", "check_mx", "--no-dnsbl", "--ttl=0")
self.assertTrue(
models.MXRecord.objects.filter(domain=self.domain).exists())
self.assertTrue(models.MXRecord.objects.filter(domain=self.domain).exists())
# we passed a ttl to 0. this will reset the cache this time
qs = models.MXRecord.objects.filter(domain=self.domain)
@@ -79,32 +77,30 @@ class MXTestCase(ModoTestCase):
@mock.patch("socket.getaddrinfo")
@mock.patch.object(dns.resolver.Resolver, "resolve")
def test_single_domain_update(
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname):
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname
):
"""Update only one domain."""
mock_query.side_effect = utils.mock_dns_query_result
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
mock_g_gethostbyname.return_value = "1.2.3.4"
management.call_command(
"modo", "check_mx", "--domain", self.domain.name)
self.assertTrue(
models.MXRecord.objects.filter(domain=self.domain).exists())
management.call_command("modo", "check_mx", "--domain", self.domain.name)
self.assertTrue(models.MXRecord.objects.filter(domain=self.domain).exists())
self.assertFalse(
models.MXRecord.objects.filter(domain=self.bad_domain).exists())
models.MXRecord.objects.filter(domain=self.bad_domain).exists()
)
management.call_command(
"modo", "check_mx", "--domain", str(self.bad_domain.pk))
management.call_command("modo", "check_mx", "--domain", str(self.bad_domain.pk))
self.assertFalse(
models.MXRecord.objects.filter(domain=self.bad_domain).exists())
models.MXRecord.objects.filter(domain=self.bad_domain).exists()
)
self.assertEqual(len(mail.outbox), 1)
management.call_command(
"modo", "check_mx", "--domain", "toto.com")
management.call_command("modo", "check_mx", "--domain", "toto.com")
@mock.patch("gevent.socket.gethostbyname")
@mock.patch("socket.getaddrinfo")
@mock.patch.object(dns.resolver.Resolver, "resolve")
def test_invalid_mx(
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname):
def test_invalid_mx(self, mock_query, mock_getaddrinfo, mock_g_gethostbyname):
"""Test to check if invalid MX records are detected."""
mock_query.side_effect = utils.mock_dns_query_result
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
@@ -112,16 +108,19 @@ class MXTestCase(ModoTestCase):
domain = factories.DomainFactory(name="invalid-mx.com")
# Add domain admin with mailbox
mb = factories.MailboxFactory(
address="admin", domain=domain,
address="admin",
domain=domain,
user__username="admin@{}".format(domain.name),
user__groups=("DomainAdmins", )
user__groups=("DomainAdmins",),
)
domain.add_admin(mb.user)
management.call_command(
"modo", "check_mx", "--domain", domain.name, "--no-dnsbl")
"modo", "check_mx", "--domain", domain.name, "--no-dnsbl"
)
self.assertEqual(domain.alarms.count(), 1)
management.call_command(
"modo", "check_mx", "--domain", domain.name, "--no-dnsbl")
"modo", "check_mx", "--domain", domain.name, "--no-dnsbl"
)
self.assertEqual(domain.alarms.count(), 1)
self.assertEqual(len(mail.outbox), 1)
@@ -149,27 +148,41 @@ class MXTestCase(ModoTestCase):
get_domain_mx_list("no-answer.example.Com")
get_domain_mx_list("bad-response.example.com")
log.check(
("modoboa.admin", "ERROR",
_("No DNS record found for %s")
% "does-not-exist.example.com"),
("modoboa.admin", "ERROR",
_("No MX record for %s") % "no-mx.example.com"),
(
"modoboa.admin",
"ERROR",
_("No DNS record found for %s") % "does-not-exist.example.com",
),
("modoboa.admin", "ERROR", _("No MX record for %s") % "no-mx.example.com"),
("modoboa.admin", "ERROR", _("No working name servers found")),
("modoboa.admin", "WARNING",
(
"modoboa.admin",
"WARNING",
_("DNS resolution timeout, unable to query %s at the moment")
% "timeout.example.com"),
("modoboa.admin", "ERROR",
_("No DNS record found for %s")
% "does-not-exist.example.com"),
("modoboa.admin", "ERROR",
_("No DNS record found for %s")
% "does-not-exist.example.com"),
("modoboa.admin", "WARNING",
_("Invalid IP address format for %(domain)s; %(addr)s")
% {"domain": "bad-response.example.com", "addr": "000.0.0.0"}),
("modoboa.admin", "WARNING",
_("Invalid IP address format for %(domain)s; %(addr)s")
% {"domain": "bad-response.example.com", "addr": "000.0.0.0"}),
% "timeout.example.com",
),
(
"modoboa.admin",
"ERROR",
_("No DNS record found for %s") % "does-not-exist.example.com",
),
(
"modoboa.admin",
"ERROR",
_("No DNS record found for %s") % "does-not-exist.example.com",
),
(
"modoboa.admin",
"WARNING",
_("Invalid IP address format for %(domain)s; %(addr)s")
% {"domain": "bad-response.example.com", "addr": "000.0.0.0"},
),
(
"modoboa.admin",
"WARNING",
_("Invalid IP address format for %(domain)s; %(addr)s")
% {"domain": "bad-response.example.com", "addr": "000.0.0.0"},
),
)
@mock.patch("ipaddress.ip_address")
@@ -184,9 +197,7 @@ class MXTestCase(ModoTestCase):
with LogCapture("modoboa.admin") as log:
get_domain_mx_list("test3.com")
log.check(
("modoboa.admin", "ERROR",
_("No AAAA record for %s")
% "mx3.example.com")
("modoboa.admin", "ERROR", _("No AAAA record for %s") % "mx3.example.com")
)
localconfig = core_models.LocalConfig.objects.first()
localconfig.parameters.set_value("enable_ipv6_mx_checks", False, "admin")
@@ -207,28 +218,32 @@ class DNSBLTestCase(ModoTestCase):
cls.domain = factories.DomainFactory(name="modoboa.org")
factories.DomainFactory(name="does-not-exist.example.com")
cls.domain2 = factories.DomainFactory(
name="test.localhost") # Should not be checked
name="test.localhost"
) # Should not be checked
cls.domain3 = factories.DomainFactory(
name="modoboa.com", enable_dns_checks=False)
name="modoboa.com", enable_dns_checks=False
)
models.DNSBLResult.objects.all().delete()
@mock.patch("gevent.socket.gethostbyname")
@mock.patch("socket.getaddrinfo")
@mock.patch.object(dns.resolver.Resolver, "resolve")
def test_management_command(
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname):
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname
):
"""Check that command works fine."""
mock_query.side_effect = utils.mock_dns_query_result
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
mock_g_gethostbyname.return_value = "1.2.3.4"
self.assertEqual(models.DNSBLResult.objects.count(), 0)
management.call_command("modo", "check_mx")
self.assertTrue(
models.DNSBLResult.objects.filter(domain=self.domain).exists())
self.assertTrue(models.DNSBLResult.objects.filter(domain=self.domain).exists())
self.assertFalse(
models.DNSBLResult.objects.filter(domain=self.domain3).exists())
models.DNSBLResult.objects.filter(domain=self.domain3).exists()
)
response = self.client.get(
reverse("admin:dnsbl_domain_detail", args=[self.domain.pk]))
reverse("admin:dnsbl_domain_detail", args=[self.domain.pk])
)
self.assertEqual(response.status_code, 200)
self.assertFalse(self.domain.uses_a_reserved_tld)
self.assertTrue(self.domain2.uses_a_reserved_tld)
@@ -236,44 +251,43 @@ class DNSBLTestCase(ModoTestCase):
@mock.patch("gevent.socket.gethostbyname")
@mock.patch("socket.getaddrinfo")
@mock.patch.object(dns.resolver.Resolver, "resolve")
def test_notifications(
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname):
def test_notifications(self, mock_query, mock_getaddrinfo, mock_g_gethostbyname):
"""Check notifications."""
mock_query.side_effect = utils.mock_dns_query_result
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
mock_g_gethostbyname.return_value = "127.0.0.4"
management.call_command(
"modo", "check_mx", "--email", "user@example.test")
management.call_command("modo", "check_mx", "--email", "user@example.test")
self.assertEqual(len(mail.outbox), 2)
@mock.patch("gevent.socket.gethostbyname")
@mock.patch("socket.getaddrinfo")
@mock.patch.object(dns.resolver.Resolver, "resolve")
def test_notifications_wrong_dnsbl_response(
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname):
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname
):
"""Check notifications."""
mock_query.side_effect = utils.mock_dns_query_result
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
mock_g_gethostbyname.return_value = "127.255.255.254" #<--Spamhaus response when querying from an open resolver
management.call_command(
"modo", "check_mx", "--email", "user@example.test")
mock_g_gethostbyname.return_value = "127.255.255.254" # <--Spamhaus response when querying from an open resolver
management.call_command("modo", "check_mx", "--email", "user@example.test")
self.assertEqual(len(mail.outbox), 1)
@mock.patch("gevent.socket.gethostbyname")
@mock.patch("socket.getaddrinfo")
@mock.patch.object(dns.resolver.Resolver, "resolve")
def test_management_command_no_dnsbl(
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname):
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname
):
"""Check that command works fine without dnsbl."""
mock_query.side_effect = utils.mock_dns_query_result
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
mock_g_gethostbyname.return_value = "1.2.3.4"
self.assertEqual(models.DNSBLResult.objects.count(), 0)
management.call_command("modo", "check_mx", "--no-dnsbl")
self.assertFalse(
models.DNSBLResult.objects.filter(domain=self.domain).exists())
self.assertFalse(models.DNSBLResult.objects.filter(domain=self.domain).exists())
response = self.client.get(
reverse("admin:dnsbl_domain_detail", args=[self.domain.pk]))
reverse("admin:dnsbl_domain_detail", args=[self.domain.pk])
)
self.assertEqual(response.status_code, 200)
@@ -290,7 +304,8 @@ class DNSChecksTestCase(ModoTestCase):
@mock.patch("socket.getaddrinfo")
@mock.patch.object(dns.resolver.Resolver, "resolve")
def test_management_command(
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname):
self, mock_query, mock_getaddrinfo, mock_g_gethostbyname
):
"""Check that command works fine."""
mock_query.side_effect = utils.mock_dns_query_result
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
+28 -19
View File
@@ -48,21 +48,24 @@ class NeedDovecotUpdateTestCase(ModoTestCase):
self.assertTrue(self.localconfig.need_dovecot_update)
tmp_file = os.path.join(self.workdir, "test-dovecot-ldap.conf")
self.set_global_parameters({
"authentication_type": "ldap",
"ldap_dovecot_sync": True,
"ldap_dovecot_conf_file": tmp_file,
"ldap_server_address": "localhost",
"ldap_server_port": "636",
"ldap_enable_secondary_server": True,
"ldap_secondary_server_address": "localhost2",
"ldap_secondary_server_port": "636",
"ldap_secured": "ssl",
"ldap_bind_dn": "DC=test,DC=lan",
"ldap_bind_password": "test",
"ldap_search_base": "CN=Users,DC=test,DC=lan",
"ldap_search_filter": "(& (objectClass=user) (|(mail=%(user)s)(sAMAccountName=%(user)s)) )"
}, app="core")
self.set_global_parameters(
{
"authentication_type": "ldap",
"ldap_dovecot_sync": True,
"ldap_dovecot_conf_file": tmp_file,
"ldap_server_address": "localhost",
"ldap_server_port": "636",
"ldap_enable_secondary_server": True,
"ldap_secondary_server_address": "localhost2",
"ldap_secondary_server_port": "636",
"ldap_secured": "ssl",
"ldap_bind_dn": "DC=test,DC=lan",
"ldap_bind_password": "test",
"ldap_search_base": "CN=Users,DC=test,DC=lan",
"ldap_search_filter": "(& (objectClass=user) (|(mail=%(user)s)(sAMAccountName=%(user)s)) )",
},
app="core",
)
# Generated file checks
call_command("update_dovecot_conf")
@@ -71,11 +74,17 @@ class NeedDovecotUpdateTestCase(ModoTestCase):
with open(tmp_file) as tmp:
content = tmp.read()
self.assertIn("uris = ldaps://localhost:636 ldaps://localhost2:636", content)
self.assertIn("dn = \"DC=test,DC=lan\"", content)
self.assertIn("dnpass = \'test\'", content)
self.assertIn('dn = "DC=test,DC=lan"', content)
self.assertIn("dnpass = 'test'", content)
self.assertIn("base = CN=Users,DC=test,DC=lan", content)
self.assertIn("user_filter = (& (objectClass=user) (|(mail=%u)(sAMAccountName=%u)) )", content)
self.assertIn("pass_filter = (& (objectClass=user) (|(mail=%u)(sAMAccountName=%u)) )", content)
self.assertIn(
"user_filter = (& (objectClass=user) (|(mail=%u)(sAMAccountName=%u)) )",
content,
)
self.assertIn(
"pass_filter = (& (objectClass=user) (|(mail=%u)(sAMAccountName=%u)) )",
content,
)
self.localconfig.refresh_from_db()
self.assertFalse(self.localconfig.need_dovecot_update)
+11 -8
View File
@@ -15,15 +15,18 @@ class PasswordSchemesTestCase(ModoTestCase):
def _create_account(self):
values = {
"username": "tester@test.com", "first_name": "Tester",
"last_name": "Toto", "password1": "Toto1234",
"password2": "Toto1234", "role": "SimpleUsers", "quota_act": True,
"is_active": True, "email": "tester@test.com", "stepid": "step2"
"username": "tester@test.com",
"first_name": "Tester",
"last_name": "Toto",
"password1": "Toto1234",
"password2": "Toto1234",
"role": "SimpleUsers",
"quota_act": True,
"is_active": True,
"email": "tester@test.com",
"stepid": "step2",
}
self.ajax_post(
reverse("admin:account_add"),
values
)
self.ajax_post(reverse("admin:account_add"), values)
def _test_scheme(self, name, startpattern):
self.set_global_parameter("password_scheme", name, app="core")
+4 -3
View File
@@ -51,10 +51,11 @@ class RepairTestCase(ModoTestCase):
def test_management_command_with_no_alias(self):
"""Check that problem is fixed."""
count, detail = models.Alias.objects.filter(
address="user@test.com", internal=True).delete()
address="user@test.com", internal=True
).delete()
self.assertEqual(count, 3)
ret = management.call_command("modo", "repair", "--quiet")
assert ret is None
self.assertTrue(
models.Alias.objects.filter(
address="user@test.com", internal=True).exists())
models.Alias.objects.filter(address="user@test.com", internal=True).exists()
)
+2 -8
View File
@@ -19,10 +19,7 @@ class ForwardTestCase(ModoTestCase):
self.client.logout()
self.client.login(username="user@test.com", password="toto")
url = reverse("user_forward")
self.ajax_post(
url,
{"dest": "user@extdomain.com", "keepcopies": True}
)
self.ajax_post(url, {"dest": "user@extdomain.com", "keepcopies": True})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
content = response.json()
@@ -38,10 +35,7 @@ class ForwardTestCase(ModoTestCase):
self.assertTrue(selfalias.enabled)
# Deactivate local copies
self.ajax_post(
url,
{"dest": "user@extdomain.com", "keepcopies": False}
)
self.ajax_post(url, {"dest": "user@extdomain.com", "keepcopies": False})
selfalias.refresh_from_db()
self.assertFalse(selfalias.enabled)
+18 -9
View File
@@ -31,12 +31,17 @@ _SPF_RECORD = TXT("IN", "TXT", ["v=spf1 mx -all"])
_DMARC_RECORD = TXT("IN", "TXT", ["v=DMARC1 p=reject"])
_DKIM_RECORD = TXT("IN", "TXT", ["v=DKIM1 p=XXXXX"])
_BAD_MX_RECORD = MX("IN", "MX", 10, Name("bad-response.example.com".split(".")))
_DNE_MX_RECORD = MX("IN", "MX", 10, Name(
"does-not-exist.example.com".split(".")))
_DNE_MX_RECORD = MX("IN", "MX", 10, Name("does-not-exist.example.com".split(".")))
_MX_RECORDS = [_MX_RECORD_1]
_IP_SET_RECORDS = [RRset()]
_IPV4_RECORD_REDIS = (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("127.0.0.1", int(settings.REDIS_PORT)))
_IPV4_RECORD_REDIS = (
socket.AF_INET,
socket.SOCK_STREAM,
6,
"",
("127.0.0.1", int(settings.REDIS_PORT)),
)
_IPV4_RECORD_1 = (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("192.0.2.1", 25))
_IPV4_RECORD_2 = (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("192.0.2.2", 25))
_IPV6_RECORD = (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("2001:db8::1", 25))
@@ -53,7 +58,7 @@ _POSSIBLE_DNS_RESULTS = {
"no-lookup.example.com": [_DNE_MX_RECORD],
"no-answer.example.com": [_DNE_MX_RECORD],
"dns-checks.com": [_MX_RECORD_2],
"invalid-mx.com": [_MX_RECORD_3]
"invalid-mx.com": [_MX_RECORD_3],
}
_POSSIBLE_DNS_RESULTS_NO_MX = {
@@ -62,12 +67,16 @@ _POSSIBLE_DNS_RESULTS_NO_MX = {
"no-lookup.example.com": NXDOMAIN(),
"no-answer.example.com": NoAnswer(),
"bad-response.example.com": [RRsetInvalid()],
"dns-checks.com": [_SPF_RECORD, ],
"dns-checks.com": [
_SPF_RECORD,
],
"modoboa._domainkey.dns-checks.com": [_DKIM_RECORD],
"_dmarc.dns-checks.com": [_DMARC_RECORD, ],
"_dmarc.dns-checks.com": [
_DMARC_RECORD,
],
"autoconfig.dns-checks.com": [_A_RECORD],
"autodiscover.dns-checks.com": [_A_RECORD],
"mx3.example.com": [_A_RECORD]
"mx3.example.com": [_A_RECORD],
}
_POSSIBLE_IP_RESULTS = {
settings.REDIS_HOST: [_IPV4_RECORD_REDIS],
@@ -82,8 +91,8 @@ _POSSIBLE_IP_RESULTS = {
_POSSIBLE_DNS_IPV6_RESULTS = {
settings.REDIS_HOST: socket.getaddrinfo(settings.REDIS_HOST, settings.REDIS_PORT),
"mx3.example.com": NoAnswer()
}
"mx3.example.com": NoAnswer(),
}
def mock_dns_query_result(qname, *args, **kwargs):
+55 -60
View File
@@ -4,81 +4,76 @@ from django.urls import path
from . import views
from .views import (
alias as alias_views, domain as domain_views, export as export_views,
identity as identity_views, import_ as import_views
alias as alias_views,
domain as domain_views,
export as export_views,
identity as identity_views,
import_ as import_views,
)
app_name = "admin"
urlpatterns = [
path('', domain_views.index, name="index"),
path('domains/', domain_views.domains, name="domain_list"),
path('domains/<int:pk>/', views.DomainDetailView.as_view(),
name="domain_detail"),
path('domains/<int:pk>/alarms/', views.DomainAlarmsView.as_view(),
name="domain_alarms"),
path('domains/<int:pk>/dnsbl/', views.DNSBLDomainDetailView.as_view(),
name="dnsbl_domain_detail"),
path('domains/<int:pk>/mx/', views.MXDomainDetailView.as_view(),
name="mx_domain_detail"),
path('domains/list/', domain_views._domains, name="_domain_list"),
path('domains/quotas/', domain_views.list_quotas,
name="domain_quota_list"),
path('domains/logs/', domain_views.list_logs,
name="domain_logs_list"),
path('domains/flatlist/', domain_views.domains_list,
name="domain_flat_list"),
path('domains/new/', domain_views.newdomain, name="domain_add"),
path('domains/<int:dom_id>/edit/', domain_views.editdomain,
name="domain_change"),
path('domains/<int:dom_id>/delete/', domain_views.deldomain,
name="domain_delete"),
path('domains/page/', domain_views.get_next_page,
name="domain_page"),
path("", domain_views.index, name="index"),
path("domains/", domain_views.domains, name="domain_list"),
path("domains/<int:pk>/", views.DomainDetailView.as_view(), name="domain_detail"),
path(
"domains/<int:pk>/alarms/",
views.DomainAlarmsView.as_view(),
name="domain_alarms",
),
path(
"domains/<int:pk>/dnsbl/",
views.DNSBLDomainDetailView.as_view(),
name="dnsbl_domain_detail",
),
path(
"domains/<int:pk>/mx/",
views.MXDomainDetailView.as_view(),
name="mx_domain_detail",
),
path("domains/list/", domain_views._domains, name="_domain_list"),
path("domains/quotas/", domain_views.list_quotas, name="domain_quota_list"),
path("domains/logs/", domain_views.list_logs, name="domain_logs_list"),
path("domains/flatlist/", domain_views.domains_list, name="domain_flat_list"),
path("domains/new/", domain_views.newdomain, name="domain_add"),
path("domains/<int:dom_id>/edit/", domain_views.editdomain, name="domain_change"),
path("domains/<int:dom_id>/delete/", domain_views.deldomain, name="domain_delete"),
path("domains/page/", domain_views.get_next_page, name="domain_page"),
]
urlpatterns += [
path('permissions/remove/', identity_views.remove_permission,
name="permission_remove"),
path('identities/', identity_views.identities, name="identity_list"),
path('identities/list/', identity_views._identities,
name="_identity_list"),
path('identities/quotas/', identity_views.list_quotas,
name="identity_quota_list"),
path('identities/page/', identity_views.get_next_page,
name="identity_page"),
path('accounts/list/', identity_views.accounts_list,
name="account_list"),
path('accounts/new/', identity_views.newaccount, name="account_add"),
path('accounts/<int:pk>/', views.AccountDetailView.as_view(),
name="account_detail"),
path('accounts/<int:pk>/edit/', identity_views.editaccount,
name="account_change"),
path('accounts/<int:pk>/delete/', identity_views.delaccount,
name="account_delete"),
path(
"permissions/remove/",
identity_views.remove_permission,
name="permission_remove",
),
path("identities/", identity_views.identities, name="identity_list"),
path("identities/list/", identity_views._identities, name="_identity_list"),
path("identities/quotas/", identity_views.list_quotas, name="identity_quota_list"),
path("identities/page/", identity_views.get_next_page, name="identity_page"),
path("accounts/list/", identity_views.accounts_list, name="account_list"),
path("accounts/new/", identity_views.newaccount, name="account_add"),
path(
"accounts/<int:pk>/", views.AccountDetailView.as_view(), name="account_detail"
),
path("accounts/<int:pk>/edit/", identity_views.editaccount, name="account_change"),
path("accounts/<int:pk>/delete/", identity_views.delaccount, name="account_delete"),
]
urlpatterns += [
path('aliases/new/', alias_views.newalias, name="alias_add"),
path('aliases/<int:pk>/', views.AliasDetailView.as_view(),
name="alias_detail"),
path('aliases/<int:alid>/edit/', alias_views.editalias,
name="alias_change"),
path('aliases/delete/', alias_views.delalias, name="alias_delete"),
path("aliases/new/", alias_views.newalias, name="alias_add"),
path("aliases/<int:pk>/", views.AliasDetailView.as_view(), name="alias_detail"),
path("aliases/<int:alid>/edit/", alias_views.editalias, name="alias_change"),
path("aliases/delete/", alias_views.delalias, name="alias_delete"),
]
urlpatterns += [
path('domains/import/', import_views.import_domains,
name="domain_import"),
path('identities/import/', import_views.import_identities,
name="identity_import"),
path("domains/import/", import_views.import_domains, name="domain_import"),
path("identities/import/", import_views.import_identities, name="identity_import"),
]
urlpatterns += [
path('domains/export/', export_views.export_domains,
name="domain_export"),
path('identities/export/', export_views.export_identities,
name="identity_export"),
path("domains/export/", export_views.export_domains, name="domain_export"),
path("identities/export/", export_views.export_identities, name="identity_export"),
]
+8 -13
View File
@@ -35,18 +35,15 @@ def _validate_alias(request, form, successmsg, callback=None):
return render_to_json_response({"form_errors": form.errors}, status=400)
def _new_alias(request, title, action, successmsg,
tplname="admin/aliasform.html"):
core_signals.can_create_object.send(
"new_alias", context=request.user, klass=Alias)
def _new_alias(request, title, action, successmsg, tplname="admin/aliasform.html"):
core_signals.can_create_object.send("new_alias", context=request.user, klass=Alias)
if request.method == "POST":
def callback(user, alias):
alias.post_create(user)
form = AliasForm(request.user, request.POST)
return _validate_alias(
request, form, successmsg, callback
)
return _validate_alias(request, form, successmsg, callback)
ctx = {
"title": title,
@@ -54,7 +51,7 @@ def _new_alias(request, title, action, successmsg,
"formid": "aliasform",
"action_label": _("Create"),
"action_classes": "submit",
"form": AliasForm(request.user)
"form": AliasForm(request.user),
}
return render(request, tplname, ctx)
@@ -64,8 +61,7 @@ def _new_alias(request, title, action, successmsg,
@reversion.create_revision()
def newalias(request):
return _new_alias(
request, _("New alias"), reverse("admin:alias_add"),
_("Alias created")
request, _("New alias"), reverse("admin:alias_add"), _("Alias created")
)
@@ -87,7 +83,7 @@ def editalias(request, alid, tplname="admin/aliasform.html"):
"title": alias.address,
"action_label": _("Update"),
"action_classes": "submit",
"form": AliasForm(request.user, instance=alias)
"form": AliasForm(request.user, instance=alias),
}
return render(request, tplname, ctx)
@@ -106,8 +102,7 @@ def delalias(request):
return render_to_json_response(msg)
class AliasDetailView(
auth_mixins.PermissionRequiredMixin, generic.DetailView):
class AliasDetailView(auth_mixins.PermissionRequiredMixin, generic.DetailView):
"""DetailView for Alias."""
model = Alias
+12 -14
View File
@@ -7,8 +7,7 @@ from django.views import generic
from .. import models
class MXDomainDetailView(
auth_mixins.PermissionRequiredMixin, generic.DetailView):
class MXDomainDetailView(auth_mixins.PermissionRequiredMixin, generic.DetailView):
"""View to display MX records."""
model = models.Domain
@@ -18,20 +17,19 @@ class MXDomainDetailView(
def get_queryset(self):
"""Add some prefetching."""
return (
super(MXDomainDetailView, self).get_queryset()
.prefetch_related("mxrecord_set"))
super(MXDomainDetailView, self)
.get_queryset()
.prefetch_related("mxrecord_set")
)
def get_context_data(self, **kwargs):
"""Add extra variables."""
context = super(MXDomainDetailView, self).get_context_data(**kwargs)
context.update({
"title": _("MX records of {}").format(self.object.name)
})
context.update({"title": _("MX records of {}").format(self.object.name)})
return context
class DNSBLDomainDetailView(
auth_mixins.PermissionRequiredMixin, generic.DetailView):
class DNSBLDomainDetailView(auth_mixins.PermissionRequiredMixin, generic.DetailView):
"""View to display DNSBL summary."""
model = models.Domain
@@ -41,13 +39,13 @@ class DNSBLDomainDetailView(
def get_queryset(self):
"""Add some prefetching."""
return (
super(DNSBLDomainDetailView, self).get_queryset()
.prefetch_related("dnsblresult_set"))
super(DNSBLDomainDetailView, self)
.get_queryset()
.prefetch_related("dnsblresult_set")
)
def get_context_data(self, **kwargs):
"""Add extra variables."""
context = super(DNSBLDomainDetailView, self).get_context_data(**kwargs)
context.update({
"title": _("DNSBL summary for {}").format(self.object.name)
})
context.update({"title": _("DNSBL summary for {}").format(self.object.name)})
return context
+68 -68
View File
@@ -6,7 +6,9 @@ from reversion import revisions as reversion
from django.contrib.auth import mixins as auth_mixins
from django.contrib.auth.decorators import (
login_required, permission_required, user_passes_test
login_required,
permission_required,
user_passes_test,
)
from django.db.models import Q, Sum
from django.http import HttpResponseRedirect
@@ -37,15 +39,15 @@ def index(request):
@login_required
@user_passes_test(
lambda u: u.has_perm("admin.view_domain") or
u.has_perm("admin.view_mailbox")
lambda u: u.has_perm("admin.view_domain") or u.has_perm("admin.view_mailbox")
)
def _domains(request):
sort_order, sort_dir = get_sort_order(request.GET, "name")
extra_filters = signals.extra_domain_filters.send(sender="_domains")
if extra_filters:
extra_filters = reduce(
lambda a, b: a + b, [result[1] for result in extra_filters])
lambda a, b: a + b, [result[1] for result in extra_filters]
)
filters = {
flt: request.GET.get(flt, None)
for flt in ["domfilter", "searchquery"] + extra_filters
@@ -54,17 +56,19 @@ def _domains(request):
domainlist = get_domains(request.user, **filters)
if sort_order == "name":
domainlist = sorted(
domainlist,
key=lambda d: getattr(d, sort_order), reverse=sort_dir == "-"
domainlist, key=lambda d: getattr(d, sort_order), reverse=sort_dir == "-"
)
else:
domainlist = sorted(domainlist, key=lambda d: d.tags[0]["name"],
reverse=sort_dir == "-")
domainlist = sorted(
domainlist, key=lambda d: d.tags[0]["name"], reverse=sort_dir == "-"
)
context = {
"handle_mailboxes": request.localconfig.parameters.get_value(
"handle_mailboxes", raise_exception=False),
"handle_mailboxes", raise_exception=False
),
"auto_account_removal": request.localconfig.parameters.get_value(
"auto_account_removal"),
"auto_account_removal"
),
}
page = get_listing_page(domainlist, request.GET.get("page", 1))
parameters = request.localconfig.parameters
@@ -73,9 +77,8 @@ def _domains(request):
"enable_spf_checks": parameters.get_value("enable_spf_checks"),
"enable_dkim_checks": parameters.get_value("enable_dkim_checks"),
"enable_dmarc_checks": parameters.get_value("enable_dmarc_checks"),
"enable_autoconfig_checks": (
parameters.get_value("enable_autoconfig_checks")),
"enable_dnsbl_checks": parameters.get_value("enable_dnsbl_checks")
"enable_autoconfig_checks": (parameters.get_value("enable_autoconfig_checks")),
"enable_dnsbl_checks": parameters.get_value("enable_dnsbl_checks"),
}
context["headers"] = render_to_string(
"admin/domain_headers.html", dns_checks, request
@@ -97,28 +100,31 @@ def _domains(request):
def domains(request, tplname="admin/domains.html"):
if not request.user.has_perm("admin.view_domain"):
if request.user.has_perm("admin.view_mailbox"):
return HttpResponseRedirect(
reverse("admin:identity_list")
)
return HttpResponseRedirect(reverse("admin:identity_list"))
return HttpResponseRedirect(reverse("core:user_index"))
parameters = request.localconfig.parameters
return render(request, tplname, {
"selection": "domains",
"enable_mx_checks": parameters.get_value("enable_mx_checks"),
"enable_spf_checks": parameters.get_value("enable_spf_checks"),
"enable_dkim_checks": parameters.get_value("enable_dkim_checks"),
"enable_dmarc_checks": parameters.get_value("enable_dmarc_checks"),
"enable_autoconfig_checks": (
parameters.get_value("enable_autoconfig_checks")),
"enable_dnsbl_checks": parameters.get_value("enable_dnsbl_checks")
})
return render(
request,
tplname,
{
"selection": "domains",
"enable_mx_checks": parameters.get_value("enable_mx_checks"),
"enable_spf_checks": parameters.get_value("enable_spf_checks"),
"enable_dkim_checks": parameters.get_value("enable_dkim_checks"),
"enable_dmarc_checks": parameters.get_value("enable_dmarc_checks"),
"enable_autoconfig_checks": (
parameters.get_value("enable_autoconfig_checks")
),
"enable_dnsbl_checks": parameters.get_value("enable_dnsbl_checks"),
},
)
@login_required
@user_passes_test(
lambda u: u.has_perm("admin.view_domain") or
u.has_perm("admin.view_mailbox") or
u.has_perm("admin.add_domain")
lambda u: u.has_perm("admin.view_domain")
or u.has_perm("admin.view_mailbox")
or u.has_perm("admin.add_domain")
)
def get_next_page(request):
"""Return the next page of the domain or quota list."""
@@ -146,15 +152,12 @@ def list_quotas(request):
if sort_order in ["name", "quota"]:
domains = domains.order_by("{}{}".format(sort_dir, sort_order))
elif sort_order == "allocated_quota":
domains = (
domains.annotate(allocated_quota=Sum("mailbox__quota"))
.order_by("{}{}".format(sort_dir, sort_order))
domains = domains.annotate(allocated_quota=Sum("mailbox__quota")).order_by(
"{}{}".format(sort_dir, sort_order)
)
page = get_listing_page(domains, request.GET.get("page", 1))
context = {
"headers": render_to_string(
"admin/domains_quota_headers.html", {}, request
)
"headers": render_to_string("admin/domains_quota_headers.html", {}, request)
}
if page is None:
context["length"] = 0
@@ -182,16 +185,14 @@ def list_logs(request):
logs = logs.order_by("{}{}".format(sort_dir, sort_order))
if search:
logs = logs.filter(
Q(sender__icontains=search) |
Q(rcpt__icontains=search) |
Q(queue_id__icontains=search) |
Q(status__icontains=search)
Q(sender__icontains=search)
| Q(rcpt__icontains=search)
| Q(queue_id__icontains=search)
| Q(status__icontains=search)
)
page = get_listing_page(logs, request.GET.get("page", 1))
context = {
"headers": render_to_string(
"admin/domains_log_headers.html", {}, request
)
"headers": render_to_string("admin/domains_log_headers.html", {}, request)
}
if page is None:
context["length"] = 0
@@ -207,8 +208,7 @@ def list_logs(request):
@permission_required("admin.add_domain")
@reversion.create_revision()
def newdomain(request):
core_signals.can_create_object.send(
"newdomain", context=request.user, klass=Domain)
core_signals.can_create_object.send("newdomain", context=request.user, klass=Domain)
return DomainWizard(request).process()
@@ -224,7 +224,8 @@ def editdomain(request, dom_id):
instances = {"general": domain}
results = signals.get_domain_form_instances.send(
sender="editdomain", user=request.user, domain=domain)
sender="editdomain", user=request.user, domain=domain
)
for result in results:
instances.update(result[1])
return DomainForm(request, instances=instances).process()
@@ -251,8 +252,7 @@ def deldomain(request, dom_id):
return render_to_json_response(msg)
class DomainDetailView(
auth_mixins.PermissionRequiredMixin, generic.DetailView):
class DomainDetailView(auth_mixins.PermissionRequiredMixin, generic.DetailView):
"""DetailView for Domain."""
model = Domain
@@ -260,39 +260,40 @@ class DomainDetailView(
def get_queryset(self):
"""Add some prefetching."""
return (
Domain.objects.get_for_admin(self.request.user)
.prefetch_related("domainalias_set", "mailbox_set", "alias_set")
return Domain.objects.get_for_admin(self.request.user).prefetch_related(
"domainalias_set", "mailbox_set", "alias_set"
)
def get_context_data(self, **kwargs):
"""Include extra widgets."""
context = super(DomainDetailView, self).get_context_data(**kwargs)
result = signals.extra_domain_dashboard_widgets.send(
self.__class__, user=self.request.user, domain=self.object)
self.__class__, user=self.request.user, domain=self.object
)
parameters = self.request.localconfig.parameters
context.update({
"templates": {"left": [], "right": []},
"enable_mx_checks": parameters.get_value("enable_mx_checks"),
"enable_spf_checks": parameters.get_value("enable_spf_checks"),
"enable_dkim_checks": parameters.get_value("enable_dkim_checks"),
"enable_dmarc_checks": parameters.get_value("enable_dmarc_checks"),
"enable_autoconfig_checks": (
parameters.get_value("enable_autoconfig_checks")),
"enable_dnsbl_checks": parameters.get_value("enable_dnsbl_checks"),
})
context.update(
{
"templates": {"left": [], "right": []},
"enable_mx_checks": parameters.get_value("enable_mx_checks"),
"enable_spf_checks": parameters.get_value("enable_spf_checks"),
"enable_dkim_checks": parameters.get_value("enable_dkim_checks"),
"enable_dmarc_checks": parameters.get_value("enable_dmarc_checks"),
"enable_autoconfig_checks": (
parameters.get_value("enable_autoconfig_checks")
),
"enable_dnsbl_checks": parameters.get_value("enable_dnsbl_checks"),
}
)
for _receiver, widgets in result:
for widget in widgets:
context["templates"][widget["column"]].append(
widget["template"])
context["templates"][widget["column"]].append(widget["template"])
# FIXME: can raise conflicts...
context.update(widget["context"])
return context
class DomainAlarmsView(
auth_mixins.PermissionRequiredMixin, generic.DetailView):
class DomainAlarmsView(auth_mixins.PermissionRequiredMixin, generic.DetailView):
"""A view to list domain alarms."""
model = Domain
@@ -301,7 +302,6 @@ class DomainAlarmsView(
def get_queryset(self):
"""Add some prefetching."""
return (
Domain.objects.get_for_admin(self.request.user)
.prefetch_related("alarms")
return Domain.objects.get_for_admin(self.request.user).prefetch_related(
"alarms"
)
+6 -4
View File
@@ -4,7 +4,9 @@ import csv
from io import StringIO
from django.contrib.auth.decorators import (
login_required, permission_required, user_passes_test
login_required,
permission_required,
user_passes_test,
)
from django.http import HttpResponse
from django.shortcuts import render
@@ -48,7 +50,8 @@ def export_identities(request):
fp = StringIO()
csvwriter = csv.writer(fp, delimiter=form.cleaned_data["sepchar"])
identities = get_identities(
request.user, **request.session["identities_filters"])
request.user, **request.session["identities_filters"]
)
for ident in identities:
ident.to_csv(csvwriter)
content = fp.getvalue()
@@ -75,8 +78,7 @@ def export_domains(request):
form.is_valid()
fp = StringIO()
csvwriter = csv.writer(fp, delimiter=form.cleaned_data["sepchar"])
for dom in get_domains(request.user,
**request.session["domains_filters"]):
for dom in get_domains(request.user, **request.session["domains_filters"]):
dom.to_csv(csvwriter)
content = fp.getvalue()
fp.close()
+35 -45
View File
@@ -4,7 +4,9 @@ from reversion import revisions as reversion
from django.contrib.auth import mixins as auth_mixins
from django.contrib.auth.decorators import (
login_required, permission_required, user_passes_test
login_required,
permission_required,
user_passes_test,
)
from django.shortcuts import render
from django.template.loader import render_to_string
@@ -25,8 +27,7 @@ from ..models import Domain, Mailbox
@login_required
@user_passes_test(
lambda u: u.has_perm("core.add_user") or
u.has_perm("admin.add_alias")
lambda u: u.has_perm("core.add_user") or u.has_perm("admin.add_alias")
)
def _identities(request):
filters = {
@@ -35,28 +36,29 @@ def _identities(request):
}
request.session["identities_filters"] = filters
idents_list = get_identities(request.user, **filters)
sort_order, sort_dir = get_sort_order(request.GET, "identity",
["identity", "name_or_rcpt", "tags"])
sort_order, sort_dir = get_sort_order(
request.GET, "identity", ["identity", "name_or_rcpt", "tags"]
)
if sort_order in ["identity", "name_or_rcpt"]:
objects = sorted(idents_list, key=lambda o: getattr(o, sort_order),
reverse=sort_dir == "-")
objects = sorted(
idents_list, key=lambda o: getattr(o, sort_order), reverse=sort_dir == "-"
)
else:
objects = sorted(idents_list, key=lambda o: o.tags[0]["label"],
reverse=sort_dir == "-")
objects = sorted(
idents_list, key=lambda o: o.tags[0]["label"], reverse=sort_dir == "-"
)
context = {
"handle_mailboxes": request.localconfig.parameters.get_value(
"handle_mailboxes", raise_exception=False)
"handle_mailboxes", raise_exception=False
)
}
page = get_listing_page(objects, request.GET.get("page", 1))
context["headers"] = render_to_string(
"admin/identity_headers.html", {}, request)
context["headers"] = render_to_string("admin/identity_headers.html", {}, request)
if page is None:
context["length"] = 0
else:
context["rows"] = render_to_string(
"admin/identities_table.html", {
"identities": page.object_list
}, request
"admin/identities_table.html", {"identities": page.object_list}, request
)
context["pages"] = [page.number]
return render_to_json_response(context)
@@ -85,7 +87,7 @@ def list_quotas(request):
select={"quota_value__bytes": "admin_quota.bytes"},
where=["admin_quota.username=%s" % where],
tables=["admin_quota", "admin_domain"],
order_by=["%s%s" % (sort_dir, sort_order)]
order_by=["%s%s" % (sort_dir, sort_order)],
)
else:
if db_type == "postgres":
@@ -102,15 +104,13 @@ def list_quotas(request):
select={"quota_usage": select},
where=["admin_quota.username=%s" % where],
tables=["admin_quota", "admin_domain"],
order_by=["%s%s" % (sort_dir, sort_order)]
order_by=["%s%s" % (sort_dir, sort_order)],
)
else:
raise BadRequest(_("Invalid request"))
page = get_listing_page(mboxes, request.GET.get("page", 1))
context = {
"headers": render_to_string(
"admin/identities_quota_headers.html", {}, request
)
"headers": render_to_string("admin/identities_quota_headers.html", {}, request)
}
if page is None:
context["length"] = 0
@@ -124,9 +124,9 @@ def list_quotas(request):
@login_required
@user_passes_test(
lambda u: u.has_perm("core.add_user") or
u.has_perm("admin.add_alias") or
u.has_perm("admin.add_mailbox")
lambda u: u.has_perm("core.add_user")
or u.has_perm("admin.add_alias")
or u.has_perm("admin.add_mailbox")
)
def get_next_page(request):
"""Return the next page of the identity list."""
@@ -137,22 +137,17 @@ def get_next_page(request):
@login_required
@user_passes_test(
lambda u: u.has_perm("core.add_user") or
u.has_perm("admin.add_alias")
lambda u: u.has_perm("core.add_user") or u.has_perm("admin.add_alias")
)
@ensure_csrf_cookie
def identities(request, tplname="admin/identities.html"):
return render(request, tplname, {
"selection": "identities",
"deflocation": "list/"
})
return render(request, tplname, {"selection": "identities", "deflocation": "list/"})
@login_required
@permission_required("core.add_user")
def accounts_list(request):
accs = User.objects.filter(is_superuser=False) \
.exclude(groups__name="SimpleUsers")
accs = User.objects.filter(is_superuser=False).exclude(groups__name="SimpleUsers")
res = [a.username for a in accs.all()]
return render_to_json_response(res)
@@ -175,11 +170,10 @@ def editaccount(request, pk):
raise PermDeniedException
mb = account.mailbox if hasattr(account, "mailbox") else None
instances = {
"general": account, "profile": account, "mail": mb, "perms": account
}
instances = {"general": account, "profile": account, "mail": mb, "perms": account}
results = signals.get_account_form_instances.send(
sender="editaccount", user=request.user, account=account)
sender="editaccount", user=request.user, account=account
)
for result in results:
instances.update(result[1])
return AccountForm(request, instances=instances).process()
@@ -190,9 +184,7 @@ def editaccount(request, pk):
@require_http_methods(["POST"])
def delaccount(request, pk):
User.objects.get(pk=pk).delete()
return render_to_json_response(
ngettext("Account deleted", "Accounts deleted", 1)
)
return render_to_json_response(ngettext("Account deleted", "Accounts deleted", 1))
@login_required
@@ -208,15 +200,13 @@ def remove_permission(request):
domain = Domain.objects.get(pk=domid)
except (User.DoesNotExist, Domain.DoesNotExist):
raise BadRequest(_("Invalid request"))
if not request.user.can_access(account) or \
not request.user.can_access(domain):
if not request.user.can_access(account) or not request.user.can_access(domain):
raise PermDeniedException
domain.remove_admin(account)
return render_to_json_response({})
class AccountDetailView(
auth_mixins.PermissionRequiredMixin, generic.DetailView):
class AccountDetailView(auth_mixins.PermissionRequiredMixin, generic.DetailView):
"""DetailView for Account."""
model = User
@@ -235,12 +225,12 @@ class AccountDetailView(
context = super(AccountDetailView, self).get_context_data(**kwargs)
del context["user"]
result = signals.extra_account_dashboard_widgets.send(
self.__class__, user=self.request.user, account=self.object)
self.__class__, user=self.request.user, account=self.object
)
context["templates"] = {"left": [], "right": []}
for _receiver, widgets in result:
for widget in widgets:
context["templates"][widget["column"]].append(
widget["template"])
context["templates"][widget["column"]].append(widget["template"])
context.update(widget["context"])
if self.object.role in ["Resellers", "DomainAdmins"]:
context["domains"] = Domain.objects.get_for_admin(self.object)
+11 -11
View File
@@ -6,7 +6,9 @@ import io
from reversion import revisions as reversion
from django.contrib.auth.decorators import (
login_required, permission_required, user_passes_test
login_required,
permission_required,
user_passes_test,
)
from django.db import transaction
from django.shortcuts import render
@@ -35,14 +37,13 @@ def importdata(request, formclass=ImportDataForm):
form = formclass(request.POST, request.FILES)
if form.is_valid():
status, msg = lib.import_data(
request.user, request.FILES["sourcefile"], form.cleaned_data)
request.user, request.FILES["sourcefile"], form.cleaned_data
)
if status:
return render(request, "admin/import_done.html", {
"status": "ok", "msg": msg
})
return render(request, "admin/import_done.html", {
"status": "ko", "msg": msg
})
return render(
request, "admin/import_done.html", {"status": "ok", "msg": msg}
)
return render(request, "admin/import_done.html", {"status": "ko", "msg": msg})
@login_required
@@ -66,8 +67,7 @@ def import_domains(request):
@login_required
@user_passes_test(
lambda u: u.has_perm("core.add_user") or
u.has_perm("admin.add_alias")
lambda u: u.has_perm("core.add_user") or u.has_perm("admin.add_alias")
)
def import_identities(request):
if request.method == "POST":
@@ -81,6 +81,6 @@ def import_identities(request):
"formid": "importform",
"enctype": "multipart/form-data",
"target": "import_target",
"form": ImportIdentitiesForm()
"form": ImportIdentitiesForm(),
}
return render(request, "admin/import_identities_form.html", ctx)
+15 -18
View File
@@ -23,37 +23,34 @@ def forward(request, tplname="admin/forward.html"):
if form.is_valid():
recipients = form.cleaned_data["dest"]
if not recipients:
Alias.objects.filter(
address=mb.full_address, internal=False).delete()
Alias.objects.filter(address=mb.full_address, internal=False).delete()
# Make sure internal self-alias is enabled
Alias.objects.filter(
address=mb.full_address, internal=True
).update(enabled=True)
Alias.objects.filter(address=mb.full_address, internal=True).update(
enabled=True
)
else:
if al is None:
al = Alias.objects.create(
address=mb.full_address,
domain=mb.domain,
enabled=mb.user.is_active
enabled=mb.user.is_active,
)
al.post_create(request.user)
if form.cleaned_data["keepcopies"]:
# Make sure internal self-alias is enabled
Alias.objects.filter(
address=mb.full_address, internal=True
).update(enabled=True)
Alias.objects.filter(address=mb.full_address, internal=True).update(
enabled=True
)
else:
# Deactivate internal self-alias to avoid storing
# local copies...
Alias.objects.filter(
address=mb.full_address, internal=True
).update(enabled=False)
Alias.objects.filter(address=mb.full_address, internal=True).update(
enabled=False
)
al.set_recipients(recipients)
return render_to_json_response(_("Forward updated"))
return render_to_json_response(
{"form_errors": form.errors}, status=400
)
return render_to_json_response({"form_errors": form.errors}, status=400)
form = ForwardForm()
if al is not None and al.recipients:
@@ -62,6 +59,6 @@ def forward(request, tplname="admin/forward.html"):
form.fields["keepcopies"].initial = True
recipients.remove(mb.full_address)
form.fields["dest"].initial = "\n".join(recipients)
return render_to_json_response({
"content": render_to_string(tplname, {"form": form}, request)
})
return render_to_json_response(
{"content": render_to_string(tplname, {"form": form}, request)}
)