mirror of
https://github.com/jwinterm/modoboa.git
synced 2026-11-16 09:34:03 +01:00
Code reformatted using black
This commit is contained in:
@@ -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
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
@@ -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):
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -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,
|
||||
)
|
||||
|
||||
@@ -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
@@ -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)
|
||||
|
||||
@@ -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
@@ -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()
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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
@@ -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
@@ -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()
|
||||
|
||||
@@ -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:
|
||||
|
||||
@@ -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",
|
||||
),
|
||||
),
|
||||
]
|
||||
|
||||
@@ -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,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
|
||||
|
||||
@@ -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."""
|
||||
|
||||
@@ -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))
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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():
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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"))
|
||||
)
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
@@ -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
@@ -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)
|
||||
|
||||
|
||||
@@ -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
@@ -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
@@ -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")
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
@@ -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)
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -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()
|
||||
)
|
||||
|
||||
@@ -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)
|
||||
|
||||
|
||||
@@ -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
@@ -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"),
|
||||
]
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
@@ -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"
|
||||
)
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
@@ -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)}
|
||||
)
|
||||
|
||||
Reference in New Issue
Block a user