Code reformatted using black

This commit is contained in:
Antoine Nguyen
2024-02-20 21:45:07 +01:00
parent 0000e4f4a7
commit 89cc0cf2a3
347 changed files with 9678 additions and 7970 deletions
+146 -91
View File
@@ -15,12 +15,18 @@ from rest_framework import serializers
from modoboa.admin import models as admin_models
from modoboa.core import (
constants as core_constants, models as core_models, signals as core_signals
constants as core_constants,
models as core_models,
signals as core_signals,
)
from modoboa.lib.exceptions import AliasExists
from modoboa.lib import (
email_utils, exceptions as lib_exceptions, fields as lib_fields,
permissions, validators, web_utils
email_utils,
exceptions as lib_exceptions,
fields as lib_fields,
permissions,
validators,
web_utils,
)
from modoboa.parameters import tools as param_tools
@@ -35,43 +41,61 @@ class DomainSerializer(serializers.ModelSerializer):
help_text=gettext_lazy(
"Quota shared between mailboxes. Can be expressed in KB, "
"MB (default) or GB. A value of 0 means no quota."
)
),
)
default_mailbox_quota = serializers.CharField(
required=False,
help_text=gettext_lazy(
"Default quota in MB applied to mailboxes. A value of 0 means "
"no quota."
)
"Default quota in MB applied to mailboxes. A value of 0 means " "no quota."
),
)
class Meta:
model = models.Domain
fields = (
"pk", "name", "quota", "default_mailbox_quota", "enabled", "type",
"enable_dkim", "dkim_key_selector", "dkim_key_length",
"dkim_public_key", "dkim_private_key_path",
"mailbox_count", "mbalias_count", "domainalias_count",
"dns_global_status", "message_limit", "creation",
"last_modification"
"pk",
"name",
"quota",
"default_mailbox_quota",
"enabled",
"type",
"enable_dkim",
"dkim_key_selector",
"dkim_key_length",
"dkim_public_key",
"dkim_private_key_path",
"mailbox_count",
"mbalias_count",
"domainalias_count",
"dns_global_status",
"message_limit",
"creation",
"last_modification",
)
read_only_fields = (
"pk", "dkim_public_key", "dns_global_status", "allocated_quota_in_percent"
"mailbox_count", "mbalias_count", "domainalias_count",
"enable_dns_checks", "creation", "last_modification"
"pk",
"dkim_public_key",
"dns_global_status",
"allocated_quota_in_percent" "mailbox_count",
"mbalias_count",
"domainalias_count",
"enable_dns_checks",
"creation",
"last_modification",
)
def validate_name(self, value):
"""Check name constraints."""
domains_must_have_authorized_mx = (
param_tools.get_global_parameter("domains_must_have_authorized_mx")
domains_must_have_authorized_mx = param_tools.get_global_parameter(
"domains_must_have_authorized_mx"
)
user = self.context["request"].user
value = value.lower()
if domains_must_have_authorized_mx and not user.is_superuser:
if not lib.domain_has_authorized_mx(value):
raise serializers.ValidationError(
_("No authorized MX record found for this domain"))
_("No authorized MX record found for this domain")
)
return value
def validate_quota(self, value):
@@ -87,10 +111,9 @@ class DomainSerializer(serializers.ModelSerializer):
quota = data.get("quota", 0)
default_mailbox_quota = data.get("default_mailbox_quota", 0)
if quota != 0 and default_mailbox_quota > quota:
raise serializers.ValidationError({
"default_mailbox_quota":
_("Cannot be greater than domain quota")
})
raise serializers.ValidationError(
{"default_mailbox_quota": _("Cannot be greater than domain quota")}
)
return data
def create(self, validated_data):
@@ -98,15 +121,15 @@ class DomainSerializer(serializers.ModelSerializer):
params = dict(param_tools.get_global_parameters("admin"))
domain = models.Domain(**validated_data)
condition = (
params["default_domain_message_limit"] is not None and
"message_limit" not in validated_data
params["default_domain_message_limit"] is not None
and "message_limit" not in validated_data
)
if condition:
domain.message_limit = params["default_domain_message_limit"]
creator = self.context["request"].user
core_signals.can_create_object.send(
sender=self.__class__, context=creator,
klass=models.Domain, instance=domain)
sender=self.__class__, context=creator, klass=models.Domain, instance=domain
)
domain.save(creator=creator)
return domain
@@ -125,7 +148,12 @@ class DomainAliasSerializer(serializers.ModelSerializer):
class Meta:
model = admin_models.DomainAlias
fields = ("pk", "name", "target", "enabled", )
fields = (
"pk",
"name",
"target",
"enabled",
)
def validate_target(self, value):
"""Check target domain."""
@@ -143,14 +171,15 @@ class DomainAliasSerializer(serializers.ModelSerializer):
creator = self.context["request"].user
try:
core_signals.can_create_object.send(
sender=self.__class__, context=creator,
klass=models.DomainAlias)
sender=self.__class__, context=creator, klass=models.DomainAlias
)
core_signals.can_create_object.send(
sender=self.__class__, context=domain_alias.target,
object_type="domain_aliases")
sender=self.__class__,
context=domain_alias.target,
object_type="domain_aliases",
)
except lib_exceptions.ModoboaException as inst:
raise serializers.ValidationError({
"domain": force_str(inst)})
raise serializers.ValidationError({"domain": force_str(inst)})
domain_alias.save(creator=creator)
return domain_alias
@@ -165,8 +194,13 @@ class MailboxSerializer(serializers.ModelSerializer):
class Meta:
model = models.Mailbox
fields = (
"pk", "full_address", "use_domain_quota", "quota", "message_limit",
"quota_usage", "is_send_only"
"pk",
"full_address",
"use_domain_quota",
"quota",
"message_limit",
"quota_usage",
"is_send_only",
)
def get_quota_usage(self, mb) -> int:
@@ -185,9 +219,9 @@ class MailboxSerializer(serializers.ModelSerializer):
method = self.context["request"].method
if not data.get("use_domain_quota", False):
if "quota" not in data and method != "PATCH":
raise serializers.ValidationError({
"quota": _("This field is required")
})
raise serializers.ValidationError(
{"quota": _("This field is required")}
)
return data
@@ -199,15 +233,28 @@ class AccountSerializer(serializers.ModelSerializer):
domains = serializers.SerializerMethodField(
help_text=_(
"List of administered domains (resellers and domain "
"administrators only)."))
"administrators only)."
)
)
class Meta:
model = core_models.User
fields = (
"pk", "username", "first_name", "last_name", "is_active",
"master_user", "mailbox", "role", "language", "phone_number",
"secondary_email", "domains", "tfa_enabled", "date_joined",
"last_login"
"pk",
"username",
"first_name",
"last_name",
"is_active",
"master_user",
"mailbox",
"role",
"language",
"phone_number",
"secondary_email",
"domains",
"tfa_enabled",
"date_joined",
"last_login",
)
def __init__(self, *args, **kwargs):
@@ -230,7 +277,8 @@ class AccountSerializer(serializers.ModelSerializer):
if account.role not in ["DomainAdmins", "Resellers"]:
return []
return admin_models.Domain.objects.get_for_admin(account).values_list(
"name", flat=True)
"name", flat=True
)
class AccountExistsSerializer(serializers.Serializer):
@@ -240,7 +288,6 @@ class AccountExistsSerializer(serializers.Serializer):
class AccountPasswordSerializer(serializers.ModelSerializer):
"""A serializer used to change a user password."""
new_password = serializers.CharField()
@@ -248,7 +295,9 @@ class AccountPasswordSerializer(serializers.ModelSerializer):
class Meta:
model = core_models.User
fields = (
"password", "new_password", )
"password",
"new_password",
)
def validate_password(self, value):
"""Check password."""
@@ -279,8 +328,7 @@ class WritableAccountSerializer(AccountSerializer):
password = serializers.CharField(required=False)
class Meta(AccountSerializer.Meta):
fields = AccountSerializer.Meta.fields + (
"password", "random_password")
fields = AccountSerializer.Meta.fields + ("password", "random_password")
def __init__(self, *args, **kwargs):
"""Adapt fields to current user."""
@@ -290,9 +338,11 @@ class WritableAccountSerializer(AccountSerializer):
return
user = self.context["request"].user
self.fields["role"] = serializers.ChoiceField(
choices=permissions.get_account_roles(user))
choices=permissions.get_account_roles(user)
)
self.fields["domains"] = serializers.ListField(
child=serializers.CharField(), allow_empty=False, required=False)
child=serializers.CharField(), allow_empty=False, required=False
)
def validate_username(self, value):
"""Lower case username."""
@@ -303,9 +353,9 @@ class WritableAccountSerializer(AccountSerializer):
master_user = data.get("master_user", False)
role = data.get("role")
if master_user and role != "SuperAdmins":
raise serializers.ValidationError({
"master_user": _("Not allowed for this role.")
})
raise serializers.ValidationError(
{"master_user": _("Not allowed for this role.")}
)
if role == "SimpleUsers":
username = data.get("username")
if username:
@@ -318,49 +368,50 @@ class WritableAccountSerializer(AccountSerializer):
if not self.instance:
data["mailbox"] = {
"full_address": username,
"use_domain_quota": True
"use_domain_quota": True,
}
elif "full_address" in mailbox and mailbox["full_address"] != username:
raise serializers.ValidationError({
"username": _("Must be equal to mailbox full_address")
})
raise serializers.ValidationError(
{"username": _("Must be equal to mailbox full_address")}
)
if "mailbox" in data:
self.address, domain_name = email_utils.split_mailbox(data["mailbox"]["full_address"])
self.domain = get_object_or_404(
admin_models.Domain, name=domain_name)
self.address, domain_name = email_utils.split_mailbox(
data["mailbox"]["full_address"]
)
self.domain = get_object_or_404(admin_models.Domain, name=domain_name)
creator = self.context["request"].user
if not creator.can_access(self.domain):
raise serializers.ValidationError({"mailbox": _("Permission denied.")})
if not self.instance:
try:
core_signals.can_create_object.send(
sender=self.__class__, context=creator,
klass=admin_models.Mailbox)
sender=self.__class__,
context=creator,
klass=admin_models.Mailbox,
)
core_signals.can_create_object.send(
sender=self.__class__, context=self.domain,
object_type="mailboxes")
sender=self.__class__,
context=self.domain,
object_type="mailboxes",
)
except lib_exceptions.ModoboaException as inst:
raise serializers.ValidationError({
"mailbox": force_str(inst)})
condition = (
not data.get("random_password") and (
data.get("password") or
not self.partial
)
raise serializers.ValidationError({"mailbox": force_str(inst)})
condition = not data.get("random_password") and (
data.get("password") or not self.partial
)
if condition:
password = data.get("password")
if password:
try:
password_validation.validate_password(
data["password"], self.instance)
data["password"], self.instance
)
except ValidationError as exc:
raise serializers.ValidationError({
"password": exc.messages[0]})
raise serializers.ValidationError({"password": exc.messages[0]})
elif not self.instance:
raise serializers.ValidationError({
"password": _("This field is required.")
})
raise serializers.ValidationError(
{"password": _("This field is required.")}
)
domain_names = data.get("domains")
if not domain_names:
return data
@@ -370,9 +421,9 @@ class WritableAccountSerializer(AccountSerializer):
if domain:
domains.append(domain)
continue
raise serializers.ValidationError({
"domains": _("Local domain {} does not exist").format(name)
})
raise serializers.ValidationError(
{"domains": _("Local domain {} does not exist").format(name)}
)
data["domains"] = domains
return data
@@ -381,10 +432,12 @@ class WritableAccountSerializer(AccountSerializer):
full_address = data.pop("full_address")
quota = data.pop("quota", None)
mb = admin_models.Mailbox(
user=account, address=self.address, domain=self.domain, **data)
user=account, address=self.address, domain=self.domain, **data
)
mb.set_quota(quota, creator.has_perm("admin.add_domain"))
default_msg_limit = param_tools.get_global_parameter(
"default_mailbox_message_limit")
"default_mailbox_message_limit"
)
if default_msg_limit is not None:
mb.message_limit = default_msg_limit
mb.save(creator=creator)
@@ -457,20 +510,19 @@ class AliasSerializer(serializers.ModelSerializer):
recipients = serializers.ListField(
child=lib_fields.DRFEmailFieldUTF8AndEmptyUser(),
allow_empty=False,
help_text=gettext_lazy("A list of recipient")
help_text=gettext_lazy("A list of recipient"),
)
class Meta:
model = admin_models.Alias
fields = (
"pk", "address", "enabled", "internal", "recipients"
)
fields = ("pk", "address", "enabled", "internal", "recipients")
def validate_address(self, value):
"""Check domain."""
try:
local_part, self.domain = admin_models.validate_alias_address(
value, self.context["request"].user, instance=self.instance)
value, self.context["request"].user, instance=self.instance
)
except ValidationError as err:
raise serializers.ValidationError(err)
except AliasExists:
@@ -481,7 +533,8 @@ class AliasSerializer(serializers.ModelSerializer):
"""Create appropriate objects."""
creator = self.context["request"].user
return admin_models.Alias.objects.create(
creator=creator, domain=self.domain, **validated_data)
creator=creator, domain=self.domain, **validated_data
)
def update(self, instance, validated_data):
"""Update objects."""
@@ -509,7 +562,8 @@ class SenderAddressSerializer(serializers.ModelSerializer):
user = self.context["request"].user
if domain and not user.can_access(domain):
raise serializers.ValidationError(
_("You don't have access to this domain."))
_("You don't have access to this domain.")
)
return value.lower()
def validate_mailbox(self, value):
@@ -517,7 +571,8 @@ class SenderAddressSerializer(serializers.ModelSerializer):
user = self.context["request"].user
if not user.can_access(value):
raise serializers.ValidationError(
_("You don't have access to this mailbox."))
_("You don't have access to this mailbox.")
)
return value
+117 -140
View File
@@ -28,7 +28,8 @@ class DomainAPITestCase(ModoAPITestCase):
super(DomainAPITestCase, cls).setUpTestData()
factories.populate_database()
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_get_domains(self):
"""Retrieve a list of domains."""
@@ -37,8 +38,7 @@ class DomainAPITestCase(ModoAPITestCase):
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
domain = response.data[0]
url = reverse(
"v1:domain-detail", args=[domain["pk"]])
url = reverse("v1:domain-detail", args=[domain["pk"]])
response = self.client.get(url)
data = response.json()
self.assertEqual(response.status_code, 200)
@@ -65,10 +65,10 @@ class DomainAPITestCase(ModoAPITestCase):
self.assertEqual(response.status_code, 400)
self.assertIn("default_mailbox_quota", response.data)
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
response = self.client.post(
url, {"name": "test4.com", "default_mailbox_quota": 10})
url, {"name": "test4.com", "default_mailbox_quota": 10}
)
self.assertEqual(response.status_code, 403)
@mock.patch.object(dns.resolver.Resolver, "resolve")
@@ -81,19 +81,19 @@ class DomainAPITestCase(ModoAPITestCase):
self.set_global_parameter("valid_mxs", "192.0.2.1 2001:db8::1")
self.set_global_parameter("domains_must_have_authorized_mx", True)
reseller = core_factories.UserFactory(
username="reseller", groups=("Resellers", ))
username="reseller", groups=("Resellers",)
)
token = Token.objects.create(user=reseller)
self.client.credentials(HTTP_AUTHORIZATION="Token " + token.key)
url = reverse("v1:domain-list")
response = self.client.post(
url, {"name": "no-mx.example.com", "quota": 0,
"default_mailbox_quota": 10}
url, {"name": "no-mx.example.com", "quota": 0, "default_mailbox_quota": 10}
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json()["name"][0],
"No authorized MX record found for this domain")
response.json()["name"][0], "No authorized MX record found for this domain"
)
mock_getaddrinfo.side_effect = utils.mock_ip_query_result
response = self.client.post(
@@ -104,25 +104,28 @@ class DomainAPITestCase(ModoAPITestCase):
def test_update_domain(self):
"""Check domain update."""
domain = models.Domain.objects.get(name="test.com")
models.Mailbox.objects.filter(
domain__name="test.com", address="user").update(
use_domain_quota=True)
models.Mailbox.objects.filter(domain__name="test.com", address="user").update(
use_domain_quota=True
)
url = reverse("v1:domain-detail", args=[domain.pk])
response = self.client.put(
url, {"name": "test.com", "default_mailbox_quota": 1000})
url, {"name": "test.com", "default_mailbox_quota": 1000}
)
self.assertEqual(response.status_code, 200)
domain.refresh_from_db()
self.assertEqual(domain.default_mailbox_quota, 1000)
mb = models.Mailbox.objects.get(
domain__name="test.com", address="user")
mb = models.Mailbox.objects.get(domain__name="test.com", address="user")
self.assertEqual(mb.quota, 1000)
response = self.client.put(
url, {"name": "test42.com", "default_mailbox_quota": 1000})
url, {"name": "test42.com", "default_mailbox_quota": 1000}
)
self.assertEqual(response.status_code, 200)
self.assertTrue(
models.Mailbox.objects.filter(
address="user", domain__name="test42.com").exists())
address="user", domain__name="test42.com"
).exists()
)
def test_patch_domain(self):
"""Check domain partial update."""
@@ -137,8 +140,7 @@ class DomainAPITestCase(ModoAPITestCase):
"""Try to remove DKIM from a domain."""
domain = models.Domain.objects.get(name="test.com")
url = reverse("v1:domain-detail", args=[domain.pk])
response = self.client.put(
url, {"name": "test.com", "enable_dkim": False})
response = self.client.put(url, {"name": "test.com", "enable_dkim": False})
self.assertEqual(response.status_code, 200)
domain.refresh_from_db()
self.assertEqual(domain.dkim_private_key_path, "")
@@ -161,11 +163,14 @@ class DomainAliasAPITestCase(ModoAPITestCase):
super(DomainAliasAPITestCase, cls).setUpTestData()
factories.populate_database()
cls.dom_alias1 = factories.DomainAliasFactory(
name="dalias1.com", target__name="test.com")
name="dalias1.com", target__name="test.com"
)
cls.dom_alias2 = factories.DomainAliasFactory(
name="dalias2.com", target__name="test2.com")
name="dalias2.com", target__name="test2.com"
)
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_get(self):
"""Retrieve a list of domain aliases."""
@@ -173,8 +178,7 @@ class DomainAliasAPITestCase(ModoAPITestCase):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
url = reverse(
"v1:domain_alias-detail", args=[response.data[0]["pk"]])
url = reverse("v1:domain_alias-detail", args=[response.data[0]["pk"]])
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["name"], "dalias1.com")
@@ -184,8 +188,7 @@ class DomainAliasAPITestCase(ModoAPITestCase):
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
response = self.client.get(reverse("v1:domain_alias-list"))
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
@@ -194,31 +197,25 @@ class DomainAliasAPITestCase(ModoAPITestCase):
"""Try to create a new domain alias."""
url = reverse("v1:domain_alias-list")
target = models.Domain.objects.get(name="test.com")
data = {
"name": "dalias3.com",
"target": target.pk
}
data = {"name": "dalias3.com", "target": target.pk}
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, 201)
dalias = response.json()
dalias = models.DomainAlias.objects.filter(
pk=dalias["pk"]).first()
dalias = models.DomainAlias.objects.filter(pk=dalias["pk"]).first()
self.assertEqual(dalias.target, target)
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
response = self.client.post(
url, {"name": "dalias4.com", "target": target.pk}, format="json")
url, {"name": "dalias4.com", "target": target.pk}, format="json"
)
self.assertEqual(response.status_code, 403)
def test_put(self):
"""Try to update a domain alias."""
dalias = models.DomainAlias.objects.get(name="dalias1.com")
url = reverse("v1:domain_alias-detail", args=[dalias.pk])
data = {
"name": "dalias3.com", "target": dalias.target.pk
}
data = {"name": "dalias3.com", "target": dalias.target.pk}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
@@ -232,8 +229,7 @@ class DomainAliasAPITestCase(ModoAPITestCase):
url = reverse("v1:domain_alias-detail", args=[dalias.pk])
response = self.client.delete(url)
self.assertEqual(response.status_code, 204)
self.assertFalse(
models.DomainAlias.objects.filter(pk=dalias.pk).exists())
self.assertFalse(models.DomainAlias.objects.filter(pk=dalias.pk).exists())
class AccountAPITestCase(ModoAPITestCase):
@@ -243,10 +239,7 @@ class AccountAPITestCase(ModoAPITestCase):
"username": "fromapi@test.com",
"role": "SimpleUsers",
"password": "Toto1234",
"mailbox": {
"full_address": "fromapi@test.com",
"quota": 10
}
"mailbox": {"full_address": "fromapi@test.com", "quota": 10},
}
@classmethod
@@ -255,15 +248,15 @@ class AccountAPITestCase(ModoAPITestCase):
super(AccountAPITestCase, cls).setUpTestData()
factories.populate_database()
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def setUp(self):
"""Test setup."""
super().setUp()
self.set_global_parameters({
"enable_admin_limits": False,
"enable_domain_limits": False
}, app="limits")
self.set_global_parameters(
{"enable_admin_limits": False, "enable_domain_limits": False}, app="limits"
)
def test_get_accounts(self):
"""Retrieve a list of accounts."""
@@ -351,12 +344,10 @@ class AccountAPITestCase(ModoAPITestCase):
response = self.client.post(url, data, format="json")
self.assertEqual(response.status_code, 201)
domain = models.Domain.objects.get(name="test.com")
admin = core_models.User.objects.get(
pk=response.json()["pk"])
admin = core_models.User.objects.get(pk=response.json()["pk"])
self.assertIn(admin, domain.admins)
response = self.client.get(
reverse("v1:account-detail", args=[admin.pk]))
response = self.client.get(reverse("v1:account-detail", args=[admin.pk]))
self.assertEqual(response.status_code, 200)
self.assertIn("domains", response.json())
@@ -376,8 +367,7 @@ class AccountAPITestCase(ModoAPITestCase):
user = core_models.User.objects.filter(pk=account["pk"]).first()
self.assertIsNot(user, None)
self.assertIsNot(user.mailbox, None)
self.assertEqual(
user.mailbox.quota, user.mailbox.domain.default_mailbox_quota)
self.assertEqual(user.mailbox.quota, user.mailbox.domain.default_mailbox_quota)
def test_create_existing_account(self):
"""Check if unicity is respected."""
@@ -404,8 +394,7 @@ class AccountAPITestCase(ModoAPITestCase):
def test_create_account_as_domadmin(self):
"""As DomainAdmin, try to create a new account."""
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
data = copy.deepcopy(self.ACCOUNT_DATA)
data["mailbox"]["quota"] = 1000
url = reverse("v1:account-list")
@@ -414,8 +403,7 @@ class AccountAPITestCase(ModoAPITestCase):
self.assertEqual(response.status_code, 400)
data["username"] = "fromapi@test2.com"
data["mailbox"].update({"full_address": "fromapi@test2.com",
"quota": 10})
data["mailbox"].update({"full_address": "fromapi@test2.com", "quota": 10})
response = self.client.post(url, data, format="json")
# Should fail because admin has no access to @test2.com domain
self.assertEqual(response.status_code, 400)
@@ -442,8 +430,8 @@ class AccountAPITestCase(ModoAPITestCase):
"password": "Toto1234",
"mailbox": {
"full_address": "fromapi@test.com",
"quota": account.mailbox.quota
}
"quota": account.mailbox.quota,
},
}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
@@ -460,14 +448,9 @@ class AccountAPITestCase(ModoAPITestCase):
def test_update_account_with_no_mailbox(self):
"""Try to disable an account."""
account = core_factories.UserFactory(
username="reseller", groups=("Resellers", ))
account = core_factories.UserFactory(username="reseller", groups=("Resellers",))
url = reverse("v1:account-detail", args=[account.pk])
data = {
"username": "reseller",
"role": account.role,
"is_active": False
}
data = {"username": "reseller", "role": account.role, "is_active": False}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
@@ -480,7 +463,7 @@ class AccountAPITestCase(ModoAPITestCase):
"username": "fromapi@test.com",
"mailbox": {
"full_address": "fromapi@test.com",
}
},
}
response = self.client.patch(url, data, format="json")
self.assertEqual(response.status_code, 200)
@@ -498,9 +481,9 @@ class AccountAPITestCase(ModoAPITestCase):
"password": "Toto1234",
"mailbox": {
"full_address": account.mailbox.full_address,
"quota": account.mailbox.quota
"quota": account.mailbox.quota,
},
"domains": ["test.com", "test2.com"]
"domains": ["test.com", "test2.com"],
}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
@@ -525,8 +508,8 @@ class AccountAPITestCase(ModoAPITestCase):
"password": "Toto1234",
"mailbox": {
"full_address": "fromapi@test3.com",
"quota": account.mailbox.quota
}
"quota": account.mailbox.quota,
},
}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 404)
@@ -539,20 +522,17 @@ class AccountAPITestCase(ModoAPITestCase):
url = reverse("v1:account-detail", args=[account.pk])
response = self.client.delete(url)
self.assertEqual(response.status_code, 204)
self.assertFalse(
core_models.User.objects.filter(pk=account.pk).exists())
self.assertFalse(core_models.User.objects.filter(pk=account.pk).exists())
self.assertFalse(domadmin.can_access(account))
def test_account_exists(self):
"""Validate /exists/ service."""
url = reverse("v1:account-exists")
response = self.client.get(
"{}?email={}".format(url, "user@test.com"))
response = self.client.get("{}?email={}".format(url, "user@test.com"))
self.assertEqual(response.status_code, 200)
content = response.json()
self.assertTrue(content["exists"])
response = self.client.get(
"{}?email={}".format(url, "pipo@test.com"))
response = self.client.get("{}?email={}".format(url, "pipo@test.com"))
self.assertEqual(response.status_code, 200)
content = response.json()
self.assertFalse(content["exists"])
@@ -562,17 +542,16 @@ class AccountAPITestCase(ModoAPITestCase):
def test_change_password(self):
"""Check the change password service."""
account = core_models.User.objects.get(username="user@test.com")
url = reverse(
"v1:account-password", args=[account.pk])
url = reverse("v1:account-password", args=[account.pk])
response = self.client.put(
url, {"password": "toto", "new_password": "pass"},
format="json")
url, {"password": "toto", "new_password": "pass"}, format="json"
)
# must fail because password is too weak
self.assertEqual(response.status_code, 400)
response = self.client.put(
url, {"password": "toto", "new_password": "Toto1234"},
format="json")
url, {"password": "toto", "new_password": "Toto1234"}, format="json"
)
self.assertEqual(response.status_code, 200)
account.refresh_from_db()
self.assertTrue(account.check_password("Toto1234"))
@@ -585,13 +564,16 @@ class AccountAPITestCase(ModoAPITestCase):
response = self.client.post(url)
self.assertEqual(response.status_code, 404)
self.set_global_parameters({
"sms_password_recovery": True,
"sms_provider": "ovh",
"sms_ovh_application_key": "key",
"sms_ovh_application_secret": "secret",
"sms_ovh_consumer_key": "consumer"
}, app="core")
self.set_global_parameters(
{
"sms_password_recovery": True,
"sms_provider": "ovh",
"sms_ovh_application_key": "key",
"sms_ovh_application_secret": "secret",
"sms_ovh_consumer_key": "consumer",
},
app="core",
)
# No email provided
response = self.client.post(url)
self.assertEqual(response.status_code, 400)
@@ -615,21 +597,19 @@ class AliasAPITestCase(ModoAPITestCase):
ALIAS_DATA = {
"address": "alias_fromapi@test.com",
"recipients": [
"user@test.com", "postmaster@test.com", "user_éé@nonlocal.com"
]
"recipients": ["user@test.com", "postmaster@test.com", "user_éé@nonlocal.com"],
}
@classmethod
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(AliasAPITestCase, cls).setUpTestData()
cls.localconfig.parameters.set_value(
"enable_admin_limits", False, app="limits")
cls.localconfig.parameters.set_value("enable_admin_limits", False, app="limits")
cls.localconfig.save()
factories.populate_database()
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_get_aliases(self):
"""Retrieve a list of aliases."""
@@ -664,13 +644,23 @@ class AliasAPITestCase(ModoAPITestCase):
domadmin = core_models.User.objects.get(username="admin@test.com")
self.assertTrue(domadmin.can_access(alias))
self.assertEqual(alias.aliasrecipient_set.count(), 3)
self.assertTrue(alias.aliasrecipient_set.filter(
address="user@test.com", r_mailbox__isnull=False).exists())
self.assertTrue(alias.aliasrecipient_set.filter(
address="postmaster@test.com", r_alias__isnull=False).exists())
self.assertTrue(alias.aliasrecipient_set.filter(
address="user_éé@nonlocal.com",
r_mailbox__isnull=True, r_alias__isnull=True).exists())
self.assertTrue(
alias.aliasrecipient_set.filter(
address="user@test.com", r_mailbox__isnull=False
).exists()
)
self.assertTrue(
alias.aliasrecipient_set.filter(
address="postmaster@test.com", r_alias__isnull=False
).exists()
)
self.assertTrue(
alias.aliasrecipient_set.filter(
address="user_éé@nonlocal.com",
r_mailbox__isnull=True,
r_alias__isnull=True,
).exists()
)
# Create catchall alias
data = copy.deepcopy(self.ALIAS_DATA)
@@ -691,8 +681,7 @@ class AliasAPITestCase(ModoAPITestCase):
def test_create_alias_as_domadmin(self):
"""As DomainAdmin, try to create a new alias."""
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
url = reverse("v1:alias-list")
response = self.client.post(url, self.ALIAS_DATA, format="json")
self.assertEqual(response.status_code, 201)
@@ -710,26 +699,20 @@ class AliasAPITestCase(ModoAPITestCase):
url = reverse("v1:alias-detail", args=[alias.pk])
data = {
"address": "alias@test.com",
"recipients": ["user@test.com", "user@nonlocal.com"]
"recipients": ["user@test.com", "user@nonlocal.com"],
}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
alias.refresh_from_db()
self.assertEqual(alias.aliasrecipient_set.count(), 2)
data = {
"address": "alias@test.com",
"recipients": ["user@nonlocal.com"]
}
data = {"address": "alias@test.com", "recipients": ["user@nonlocal.com"]}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 200)
alias.refresh_from_db()
self.assertEqual(alias.aliasrecipient_set.count(), 1)
data = {
"address": "alias@test.com",
"recipients": []
}
data = {"address": "alias@test.com", "recipients": []}
response = self.client.put(url, data, format="json")
self.assertEqual(response.status_code, 400)
@@ -741,13 +724,12 @@ class AliasAPITestCase(ModoAPITestCase):
url = reverse("v1:alias-detail", args=[alias.pk])
response = self.client.delete(url)
self.assertEqual(response.status_code, 204)
self.assertFalse(
models.Alias.objects.filter(pk=alias.pk).exists())
self.assertFalse(models.Alias.objects.filter(pk=alias.pk).exists())
self.assertFalse(domadmin.can_access(alias))
self.assertFalse(
models.AliasRecipient.objects.filter(
address="user@test.com", alias__address="alias@test.com")
.exists()
address="user@test.com", alias__address="alias@test.com"
).exists()
)
@@ -758,18 +740,18 @@ class SenderAddressAPITestCase(ModoAPITestCase):
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(SenderAddressAPITestCase, cls).setUpTestData()
cls.localconfig.parameters.set_value(
"enable_admin_limits", False, app="limits")
cls.localconfig.parameters.set_value("enable_admin_limits", False, app="limits")
cls.localconfig.save()
factories.populate_database()
cls.sa1 = factories.SenderAddressFactory(
address="test@domain.ext",
mailbox__user__username="user@test.com",
mailbox__address="user",
mailbox__domain__name="test.com"
mailbox__domain__name="test.com",
)
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_list(self):
"""Retrieve a list of sender addresses."""
@@ -782,35 +764,31 @@ class SenderAddressAPITestCase(ModoAPITestCase):
def test_create(self):
"""Create a new sender addresses."""
url = reverse("v1:sender_address-list")
mbox = models.Mailbox.objects.get(
address="admin", domain__name="test.com")
mbox = models.Mailbox.objects.get(address="admin", domain__name="test.com")
data = {"address": "@extdomain.test", "mailbox": mbox.pk}
response = self.client.post(url, data)
self.assertEqual(response.status_code, 201)
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
data = {"address": "user@test2.com", "mailbox": mbox.pk}
response = self.client.post(url, data)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json()["address"][0],
"You don't have access to this domain.")
response.json()["address"][0], "You don't have access to this domain."
)
mbox = models.Mailbox.objects.get(
address="admin", domain__name="test2.com")
mbox = models.Mailbox.objects.get(address="admin", domain__name="test2.com")
data = {"address": "toto@titi.com", "mailbox": mbox.pk}
response = self.client.post(url, data)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.json()["mailbox"][0],
"You don't have access to this mailbox.")
response.json()["mailbox"][0], "You don't have access to this mailbox."
)
def test_patch(self):
"""Patch an existing sender address."""
url = reverse("v1:sender_address-detail", args=[self.sa1.pk])
mbox = models.Mailbox.objects.get(
address="user", domain__name="test.com")
mbox = models.Mailbox.objects.get(address="user", domain__name="test.com")
data = {"address": "@extdomain.test"}
response = self.client.patch(url, data)
self.assertEqual(response.status_code, 200)
@@ -821,8 +799,7 @@ class SenderAddressAPITestCase(ModoAPITestCase):
def test_update(self):
"""Update an existing sender address."""
url = reverse("v1:sender_address-detail", args=[self.sa1.pk])
mbox = models.Mailbox.objects.get(
address="user", domain__name="test.com")
mbox = models.Mailbox.objects.get(address="user", domain__name="test.com")
data = {"address": "@extdomain.test", "mailbox": mbox.pk}
response = self.client.put(url, data)
self.assertEqual(response.status_code, 200)
+3 -3
View File
@@ -6,11 +6,11 @@ from . import viewsets
router = routers.SimpleRouter()
router.register(r"domains", viewsets.DomainViewSet, basename="domain")
router.register(
r"domainaliases", viewsets.DomainAliasViewSet, basename="domain_alias")
router.register(r"domainaliases", viewsets.DomainAliasViewSet, basename="domain_alias")
router.register(r"accounts", viewsets.AccountViewSet, basename="account")
router.register(r"aliases", viewsets.AliasViewSet, basename="alias")
router.register(
r"senderaddresses", viewsets.SenderAddressViewSet, basename="sender_address")
r"senderaddresses", viewsets.SenderAddressViewSet, basename="sender_address"
)
urlpatterns = router.urls
+59 -48
View File
@@ -25,23 +25,24 @@ from . import serializers
@extend_schema_view(
retrieve=extend_schema(
description="Retrieve a particular domain",
summary="Retrieve a particular domain"
summary="Retrieve a particular domain",
),
list=extend_schema(
description="Retrieve a list of domains",
summary="Retrieve a list of domains"
description="Retrieve a list of domains", summary="Retrieve a list of domains"
),
create=extend_schema(
description="Create a new domain",
summary="Create a new domain"
)
description="Create a new domain", summary="Create a new domain"
),
)
class DomainViewSet(GetThrottleViewsetMixin,
lib_viewsets.RevisionModelMixin,
viewsets.ModelViewSet):
class DomainViewSet(
GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet
):
"""Domain viewset."""
permission_classes = [IsAuthenticated, DjangoModelPermissions, ]
permission_classes = [
IsAuthenticated,
DjangoModelPermissions,
]
serializer_class = serializers.DomainSerializer
def get_queryset(self):
@@ -63,13 +64,17 @@ class DomainAliasFilterSet(dj_filters.FilterSet):
fields = ["domain"]
class DomainAliasViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin,
viewsets.ModelViewSet):
class DomainAliasViewSet(
GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet
):
"""ViewSet for DomainAlias."""
filter_backends = (dj_filters.DjangoFilterBackend, )
filter_backends = (dj_filters.DjangoFilterBackend,)
filterset_class = DomainAliasFilterSet
permission_classes = [IsAuthenticated, DjangoModelPermissions, ]
permission_classes = [
IsAuthenticated,
DjangoModelPermissions,
]
renderer_classes = (renderers.JSONRenderer, lib_renderers.CSVRenderer)
serializer_class = serializers.DomainAliasSerializer
@@ -83,11 +88,16 @@ class DomainAliasViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixi
return context
class AccountViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet):
class AccountViewSet(
GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet
):
"""ViewSet for User/Mailbox."""
filter_backends = (filters.SearchFilter, )
permission_classes = [IsAuthenticated, DjangoModelPermissions, ]
filter_backends = (filters.SearchFilter,)
permission_classes = [
IsAuthenticated,
DjangoModelPermissions,
]
search_fields = ("^first_name", "^last_name", "^email")
def get_throttles(self):
@@ -105,15 +115,14 @@ class AccountViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, v
"password": serializers.AccountPasswordSerializer,
"reset_password": serializers.ResetPasswordSerializer,
}
return action_dict.get(
self.action, serializers.WritableAccountSerializer)
return action_dict.get(self.action, serializers.WritableAccountSerializer)
def get_queryset(self):
"""Filter queryset based on current user."""
user = self.request.user
ids = user.objectaccess_set \
.filter(content_type=ContentType.objects.get_for_model(user)) \
.values_list("object_id", flat=True)
ids = user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(user)
).values_list("object_id", flat=True)
queryset = core_models.User.objects.filter(pk__in=ids)
domain = self.request.query_params.get("domain")
if domain:
@@ -131,8 +140,7 @@ class AccountViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, v
if serializer.is_valid():
serializer.save()
return Response()
return Response(
serializer.errors, status=status.HTTP_400_BAD_REQUEST)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@action(detail=False)
def exists(self, request):
@@ -156,25 +164,23 @@ class AccountViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, v
@action(methods=["post"], detail=False)
def reset_password(self, request):
"""Reset account password and send a new one by SMS."""
sms_password_recovery = (
request.localconfig.parameters
.get_value("sms_password_recovery", app="core")
sms_password_recovery = request.localconfig.parameters.get_value(
"sms_password_recovery", app="core"
)
if not sms_password_recovery:
return Response(status=404)
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = core_models.User.objects.filter(
email=serializer.validated_data["email"]).first()
email=serializer.validated_data["email"]
).first()
if not user or not user.phone_number:
return Response(status=404)
backend = sms_backends.get_active_backend(
request.localconfig.parameters)
backend = sms_backends.get_active_backend(request.localconfig.parameters)
if not backend:
return Response(status=404)
password = lib.make_password()
content = _("Here is your new Modoboa password: {}").format(
password)
content = _("Here is your new Modoboa password: {}").format(password)
if not backend.send(content, [str(user.phone_number)]):
body = {"status": "ko"}
else:
@@ -185,23 +191,26 @@ class AccountViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, v
return Response(body)
class AliasViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet):
class AliasViewSet(
GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet
):
"""
create:
Create a new alias instance.
"""
permission_classes = [IsAuthenticated, DjangoModelPermissions, ]
permission_classes = [
IsAuthenticated,
DjangoModelPermissions,
]
serializer_class = serializers.AliasSerializer
def get_queryset(self):
"""Filter queryset based on current user."""
user = self.request.user
ids = (
user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(models.Alias))
.values_list("object_id", flat=True)
)
ids = user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(models.Alias)
).values_list("object_id", flat=True)
queryset = models.Alias.objects.filter(pk__in=ids)
domain = self.request.query_params.get("domain")
if domain:
@@ -217,21 +226,23 @@ class SenderAddressFilterSet(dj_filters.FilterSet):
fields = ["mailbox"]
class SenderAddressViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin,
viewsets.ModelViewSet):
class SenderAddressViewSet(
GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin, viewsets.ModelViewSet
):
"""View set for SenderAddress model."""
filter_backends = (dj_filters.DjangoFilterBackend, )
filter_backends = (dj_filters.DjangoFilterBackend,)
filterset_class = SenderAddressFilterSet
permission_classes = [IsAuthenticated, DjangoModelPermissions, ]
permission_classes = [
IsAuthenticated,
DjangoModelPermissions,
]
serializer_class = serializers.SenderAddressSerializer
def get_queryset(self):
"""Filter queryset based on current user."""
user = self.request.user
mb_ids = (
user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(models.Mailbox))
.values_list("object_id", flat=True)
)
mb_ids = user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(models.Mailbox)
).values_list("object_id", flat=True)
return models.SenderAddress.objects.filter(mailbox__pk__in=mb_ids)
+97 -99
View File
@@ -56,7 +56,9 @@ class DomainSerializer(v1_serializers.DomainSerializer):
class Meta(v1_serializers.DomainSerializer.Meta):
fields = v1_serializers.DomainSerializer.Meta.fields + (
"domain_admin", "transport", "opened_alarms_count"
"domain_admin",
"transport",
"opened_alarms_count",
)
def __init__(self, *args, **kwargs):
@@ -71,7 +73,9 @@ class DomainSerializer(v1_serializers.DomainSerializer):
result = super().validate(data)
dtype = data.get("type", "domain")
if dtype == "relaydomain" and not data.get("transport"):
raise serializers.ValidationError({"transport": _("This field is required")})
raise serializers.ValidationError(
{"transport": _("This field is required")}
)
return result
def create(self, validated_data):
@@ -96,16 +100,15 @@ class DomainSerializer(v1_serializers.DomainSerializer):
except core_models.User.DoesNotExist:
pass
else:
raise lib_exceptions.Conflict(
_("User '%s' already exists") % username)
raise lib_exceptions.Conflict(_("User '%s' already exists") % username)
user = self.context["request"].user
core_signals.can_create_object.send(
self.__class__, context=user, klass=models.Mailbox)
self.__class__, context=user, klass=models.Mailbox
)
da = core_models.User(username=username, email=username, is_active=True)
password = domain_admin.get("password")
if password is None:
password = param_tools.get_global_parameter(
"default_password", app="core")
password = param_tools.get_global_parameter("default_password", app="core")
da.set_password(password)
da.save()
da.role = "DomainAdmins"
@@ -115,25 +118,28 @@ class DomainSerializer(v1_serializers.DomainSerializer):
if domain_admin["with_mailbox"]:
dom_admin_username = domain_admin["username"]
mb = models.Mailbox(
address=dom_admin_username, domain=domain,
user=da, use_domain_quota=True
address=dom_admin_username,
domain=domain,
user=da,
use_domain_quota=True,
)
mb.set_quota(
override_rules=user.has_perm("admin.change_domain"))
mb.set_quota(override_rules=user.has_perm("admin.change_domain"))
mb.save(creator=user)
# 3. Create aliases if needed
condition = (
domain.type == "domain" and
domain_admin["with_aliases"] and
dom_admin_username != "postmaster"
domain.type == "domain"
and domain_admin["with_aliases"]
and dom_admin_username != "postmaster"
)
if condition:
core_signals.can_create_object.send(
self.__class__, context=user, klass=models.Alias)
address = u"postmaster@{}".format(domain.name)
self.__class__, context=user, klass=models.Alias
)
address = "postmaster@{}".format(domain.name)
alias = models.Alias.objects.create(
address=address, domain=domain, enabled=True)
address=address, domain=domain, enabled=True
)
alias.set_recipients([mb.full_address])
alias.post_create(user)
@@ -162,9 +168,9 @@ class DomainSerializer(v1_serializers.DomainSerializer):
instance.save()
if resources:
for resource in resources:
instance.domainobjectlimit_set.filter(
name=resource["name"]
).update(max_value=resource["max_value"])
instance.domainobjectlimit_set.filter(name=resource["name"]).update(
max_value=resource["max_value"]
)
return instance
@@ -190,16 +196,19 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
enable_dnsbl_checks = serializers.BooleanField(default=True)
dkim_keys_storage_dir = serializers.CharField(allow_blank=True)
dkim_default_key_length = serializers.ChoiceField(
default=2048, choices=constants.DKIM_KEY_LENGTHS)
default=2048, choices=constants.DKIM_KEY_LENGTHS
)
default_domain_quota = serializers.IntegerField(default=0)
default_domain_message_limit = serializers.IntegerField(
required=False, allow_null=True)
required=False, allow_null=True
)
# Mailboxes settings
handle_mailboxes = serializers.BooleanField(default=False)
default_mailbox_quota = serializers.IntegerField(default=0)
default_mailbox_message_limit = serializers.IntegerField(
required=False, allow_null=True)
required=False, allow_null=True
)
auto_account_removal = serializers.BooleanField(default=False)
auto_create_domain_and_mailbox = serializers.BooleanField(default=True)
create_alias_on_mbox_rename = serializers.BooleanField(default=False)
@@ -207,30 +216,22 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
def validate_default_domain_quota(self, value):
"""Ensure quota is a positive integer."""
if value < 0:
raise serializers.ValidationError(
_("Must be a positive integer")
)
raise serializers.ValidationError(_("Must be a positive integer"))
return value
def validate_default_mailbox_quota(self, value):
"""Ensure quota is a positive integer."""
if value < 0:
raise serializers.ValidationError(
_("Must be a positive integer")
)
raise serializers.ValidationError(_("Must be a positive integer"))
return value
def validate_dkim_keys_storage_dir(self, value):
"""Check that directory exists."""
if value:
if not os.path.isdir(value):
raise serializers.ValidationError(
_("Directory not found.")
)
raise serializers.ValidationError(_("Directory not found."))
if not os.access(value, os.W_OK):
raise serializers.ValidationError(
_("Directory non-writable")
)
raise serializers.ValidationError(_("Directory non-writable"))
code, output = exec_cmd("which openssl")
if code:
raise serializers.ValidationError(
@@ -244,8 +245,7 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
return value
try:
ip_addresses = [
ipaddress.ip_network(v.strip())
for v in value.split() if v.strip()
ipaddress.ip_network(v.strip()) for v in value.split() if v.strip()
]
except ValueError:
raise serializers.ValidationError(
@@ -255,11 +255,12 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
def validate_auto_create_domain_and_mailbox(self, value):
"""
Make sure the option does not get deactivated
while imap migration is enabled.
Make sure the option does not get deactivated
while imap migration is enabled.
"""
if not value and param_tools.get_global_parameter("enabled_imapmigration",
"imap_migration"):
if not value and param_tools.get_global_parameter(
"enabled_imapmigration", "imap_migration"
):
raise serializers.ValidationError(
_("Please disable imap migration before disabling this option.")
)
@@ -268,13 +269,14 @@ class AdminGlobalParametersSerializer(serializers.Serializer):
def validate(self, data):
"""Check MX options."""
condition = (
data.get("enable_mx_checks") and
data.get("domains_must_have_authorized_mx") and
not data.get("valid_mxs"))
data.get("enable_mx_checks")
and data.get("domains_must_have_authorized_mx")
and not data.get("valid_mxs")
)
if condition:
raise serializers.ValidationError({
"valid_mxs": _("Define at least one authorized network / address")
})
raise serializers.ValidationError(
{"valid_mxs": _("Define at least one authorized network / address")}
)
if not data.get("enable_mx_checks"):
data["enable_ipv6_mx_checks"] = False
return data
@@ -335,7 +337,8 @@ class IdentitySerializer(serializers.Serializer):
# (not used for now)
return []
actions = admin_signals.extra_account_identities_actions.send(
self.__class__, account=identity)
self.__class__, account=identity
)
cleaned_actions = []
for action in actions:
try:
@@ -358,15 +361,11 @@ class AccountSerializer(v1_serializers.AccountSerializer):
"""Add support for user resources."""
aliases = serializers.ListField(
child=lib_fields.DRFEmailFieldUTF8(),
source="mailbox.alias_addresses"
child=lib_fields.DRFEmailFieldUTF8(), source="mailbox.alias_addresses"
)
class Meta(v1_serializers.AccountSerializer.Meta):
fields = (
v1_serializers.AccountSerializer.Meta.fields
+ ("aliases", )
)
fields = v1_serializers.AccountSerializer.Meta.fields + ("aliases",)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
@@ -375,7 +374,7 @@ class AccountSerializer(v1_serializers.AccountSerializer):
self.fields["resources"] = serializers.SerializerMethodField()
def get_resources(self, account) -> List[AccountResourceSerializer]:
if account.role == 'SimpleUsers':
if account.role == "SimpleUsers":
return []
resources = []
for limit in account.userobjectlimit_set.all():
@@ -395,7 +394,10 @@ class MailboxSerializer(serializers.ModelSerializer):
class Meta:
model = models.Mailbox
fields = (
"pk", "use_domain_quota", "quota", "message_limit",
"pk",
"use_domain_quota",
"quota",
"message_limit",
"is_send_only",
)
@@ -408,9 +410,9 @@ class MailboxSerializer(serializers.ModelSerializer):
method = self.context["request"].method
if not data.get("use_domain_quota", False):
if "quota" not in data and method != "PATCH":
raise serializers.ValidationError({
"quota": _("This field is required")
})
raise serializers.ValidationError(
{"quota": _("This field is required")}
)
return data
@@ -426,8 +428,7 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
"""Add support for aliases and sender addresses."""
aliases = serializers.ListField(
child=lib_fields.DRFEmailFieldUTF8(),
required=False
child=lib_fields.DRFEmailFieldUTF8(), required=False
)
mailbox = MailboxSerializer(required=False)
@@ -449,7 +450,8 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
aliases = []
for alias in value:
localpart, domain = models.validate_alias_address(
alias, self.context["request"].user, ignore_existing=True)
alias, self.context["request"].user, ignore_existing=True
)
aliases.append({"localpart": localpart, "domain": domain})
return aliases
@@ -458,9 +460,9 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
master_user = data.get("master_user", False)
role = data.get("role")
if master_user and role != "SuperAdmins":
raise serializers.ValidationError({
"master_user": _("Not allowed for this role.")
})
raise serializers.ValidationError(
{"master_user": _("Not allowed for this role.")}
)
if role == "SimpleUsers":
username = data.get("username")
if username:
@@ -471,46 +473,43 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
mailbox = data.get("mailbox")
if mailbox is None:
if not self.instance:
data["mailbox"] = {
"use_domain_quota": True
}
data["mailbox"] = {"use_domain_quota": True}
if "mailbox" in data and "username" in data:
self.address, domain_name = email_utils.split_mailbox(data["username"])
self.domain = get_object_or_404(
models.Domain, name=domain_name)
self.domain = get_object_or_404(models.Domain, name=domain_name)
creator = self.context["request"].user
if not creator.can_access(self.domain):
raise serializers.ValidationError({"mailbox": _("Permission denied.")})
if not self.instance:
try:
core_signals.can_create_object.send(
sender=self.__class__, context=creator,
klass=models.Mailbox)
sender=self.__class__, context=creator, klass=models.Mailbox
)
core_signals.can_create_object.send(
sender=self.__class__, context=self.domain,
object_type="mailboxes")
sender=self.__class__,
context=self.domain,
object_type="mailboxes",
)
except lib_exceptions.ModoboaException as inst:
raise serializers.ValidationError({
"mailbox": str(inst)
})
raise serializers.ValidationError({"mailbox": str(inst)})
if data.get("password") or not self.partial:
password = data.get("password")
if password:
try:
password_validation.validate_password(
data["password"], self.instance)
data["password"], self.instance
)
except ValidationError as exc:
raise serializers.ValidationError({
"password": exc.messages[0]})
raise serializers.ValidationError({"password": exc.messages[0]})
elif not self.instance:
raise serializers.ValidationError({
"password": _("This field is required.")
})
raise serializers.ValidationError(
{"password": _("This field is required.")}
)
aliases = data.get("aliases")
if aliases and "mailbox" not in data:
raise serializers.ValidationError({
"aliases": _("A mailbox is required to create aliases.")
})
raise serializers.ValidationError(
{"aliases": _("A mailbox is required to create aliases.")}
)
domain_names = data.get("domains")
if not domain_names:
return data
@@ -520,9 +519,9 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
if domain:
domains.append(domain)
continue
raise serializers.ValidationError({
"domains": _("Local domain {} does not exist").format(name)
})
raise serializers.ValidationError(
{"domains": _("Local domain {} does not exist").format(name)}
)
data["domains"] = domains
return data
@@ -550,8 +549,8 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
address="{}@{}".format(alias["localpart"], alias["domain"]),
recipients=[user.username],
creator=creator,
domain=alias["domain"]
)
domain=alias["domain"],
)
return user
def update(self, instance, validated_data):
@@ -584,7 +583,7 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
address=address,
recipients=[validated_data["username"]],
creator=creator,
domain=alias["domain"]
domain=alias["domain"],
)
try:
alias_recipients.remove(address)
@@ -592,18 +591,17 @@ class WritableAccountSerializer(v1_serializers.WritableAccountSerializer):
continue
for alias_address in alias_recipients:
alias = models.Alias.objects.filter(
address=alias_address, internal=False)
address=alias_address, internal=False
)
if alias.exists():
alias.first().remove_recipient_or_delete(
validated_data["username"]
)
alias.first().remove_recipient_or_delete(validated_data["username"])
instance.save()
resources = validated_data.get("resources")
if resources:
for resource in resources:
instance.userobjectlimit_set.filter(
name=resource["name"]
).update(max_value=resource["max_value"])
instance.userobjectlimit_set.filter(name=resource["name"]).update(
max_value=resource["max_value"]
)
self.set_permissions(instance, domains)
return instance
+75 -114
View File
@@ -19,7 +19,8 @@ class DomainViewSetTestCase(ModoAPITestCase):
super().setUpTestData()
factories.populate_database()
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_create(self):
url = reverse("v2:domain-list")
@@ -28,8 +29,8 @@ class DomainViewSetTestCase(ModoAPITestCase):
"domain_admin": {
"username": "admin",
"with_mailbox": True,
"with_aliases": True
}
"with_aliases": True,
},
}
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 201)
@@ -39,8 +40,7 @@ class DomainViewSetTestCase(ModoAPITestCase):
admin = dom.admins.first()
self.assertTrue(hasattr(admin, "mailbox"))
self.assertTrue(
models.Alias.objects.filter(
address="postmaster@domain.tld").exists()
models.Alias.objects.filter(address="postmaster@domain.tld").exists()
)
def test_update(self):
@@ -50,11 +50,8 @@ class DomainViewSetTestCase(ModoAPITestCase):
"type": "relaydomain",
"transport": {
"service": "relay",
"settings": {
"relay_target_port": 25,
"relay_target_host": "localhost"
}
}
"settings": {"relay_target_port": 25, "relay_target_host": "localhost"},
},
}
url = reverse("v2:domain-detail", args=[domain.pk])
resp = self.client.put(url, data, format="json")
@@ -63,7 +60,7 @@ class DomainViewSetTestCase(ModoAPITestCase):
self.assertEqual(domain.transport.service, data["transport"]["service"])
self.assertEqual(
domain.transport._settings["relay_target_host"],
data["transport"]["settings"]["relay_target_host"]
data["transport"]["settings"]["relay_target_host"],
)
data["transport"]["relay_verify_recipients"] = True
@@ -75,9 +72,7 @@ class DomainViewSetTestCase(ModoAPITestCase):
domain = models.Domain.objects.get(name="test2.com")
data = {
"name": "test2.com",
"resources": [
{"name": "domain_aliases", "max_value": 20}
]
"resources": [{"name": "domain_aliases", "max_value": 20}],
}
url = reverse("v2:domain-detail", args=[domain.pk])
resp = self.client.put(url, data, format="json")
@@ -87,8 +82,7 @@ class DomainViewSetTestCase(ModoAPITestCase):
)
def test_delete(self):
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
domain = models.Domain.objects.get(name="test2.com")
url = reverse("v2:domain-delete", args=[domain.pk])
@@ -129,15 +123,14 @@ class DomainViewSetTestCase(ModoAPITestCase):
self.assertEqual(resp.status_code, 200)
def test_domains_import(self):
f = ContentFile(b"""domain; domain1.com; 1000; 100; True
f = ContentFile(
b"""domain; domain1.com; 1000; 100; True
domain; domain2.com; 1000; 200; False
domainalias; domalias1.com; domain1.com; True
""", name="domains.csv")
self.client.post(
reverse("v2:domain-import-from-csv"), {
"sourcefile": f
}
""",
name="domains.csv",
)
self.client.post(reverse("v2:domain-import-from-csv"), {"sourcefile": f})
admin = core_models.User.objects.get(username="admin")
dom = models.Domain.objects.get(name="domain1.com")
self.assertEqual(dom.quota, 1000)
@@ -164,8 +157,7 @@ domainalias; domalias1.com; domain1.com; True
"domain,test2.com,0,0,True",
]
self.assertCountEqual(
expected_response,
force_str(response.content.strip()).split("\r\n")
expected_response, force_str(response.content.strip()).split("\r\n")
)
@@ -182,19 +174,14 @@ class AccountViewSetTestCase(ModoAPITestCase):
data = {
"username": "toto@test.com",
"role": "SimpleUsers",
"mailbox": {
"use_domain_quota": True
},
"mailbox": {"use_domain_quota": True},
"password": "Toto12345",
"language": "fr",
"aliases": ["alias3@test.com"]
"aliases": ["alias3@test.com"],
}
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 201)
self.assertTrue(
models.Alias.objects.filter(
address="alias3@test.com").exists()
)
self.assertTrue(models.Alias.objects.filter(address="alias3@test.com").exists())
def test_create_admin(self):
url = reverse("v2:account-list")
@@ -203,7 +190,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
"role": "SuperAdmins",
"password": "Toto12345",
"language": "fr",
"aliases": ["alias3@test.com"]
"aliases": ["alias3@test.com"],
}
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 400)
@@ -251,12 +238,8 @@ class AccountViewSetTestCase(ModoAPITestCase):
"username": "user@test.com",
"role": "SimpleUsers",
"password": "Toto12345",
"mailbox": {
"quota": 10
},
"aliases": [
"aliasupdate1@test.com"
]
"mailbox": {"quota": 10},
"aliases": ["aliasupdate1@test.com"],
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -271,7 +254,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
"mailbox": {
"message_limit": 10,
"is_send_only": True,
}
},
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -283,9 +266,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
"username": "user@test.com",
"role": "SimpleUsers",
"password": "Toto12345",
"mailbox": {
"quota": 10
}
"mailbox": {"quota": 10},
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -299,7 +280,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
"mailbox": {
"message_limit": None,
"is_send_only": False,
}
},
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -314,29 +295,24 @@ class AccountViewSetTestCase(ModoAPITestCase):
"username": "user@test.com",
"role": "SimpleUsers",
"password": "Toto12345",
"mailbox": {
"quota": 10
},
"aliases": [
"aliasupdate1@test.com"
]
"mailbox": {"quota": 10},
"aliases": ["aliasupdate1@test.com"],
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
self.assertTrue(
models.Alias.objects.filter(address="aliasupdate1@test.com").exists())
models.Alias.objects.filter(address="aliasupdate1@test.com").exists()
)
# Create an alias for another user
url = reverse("v2:account-list")
data = {
"username": "toto@test.com",
"role": "SimpleUsers",
"mailbox": {
"use_domain_quota": True
},
"mailbox": {"use_domain_quota": True},
"password": "Toto12345",
"language": "fr",
"aliases": ["totoalias@test.com"]
"aliases": ["totoalias@test.com"],
}
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 201)
@@ -347,13 +323,11 @@ class AccountViewSetTestCase(ModoAPITestCase):
"username": "user@test.com",
"role": "SimpleUsers",
"password": "Toto12345",
"mailbox": {
"quota": 10
},
"mailbox": {"quota": 10},
"aliases": [
"totoalias@test.com",
"aliasupdate1@test.com",
]
],
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -367,17 +341,16 @@ class AccountViewSetTestCase(ModoAPITestCase):
data = {
"username": "user@test.com",
"role": "SimpleUsers",
"mailbox": {
"quota": 10
},
"aliases": []
"mailbox": {"quota": 10},
"aliases": [],
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
self.assertFalse(
models.Alias.objects.filter(address="aliasupdate1@test.com").exists())
alias_recipients = list(models.Alias.objects.filter(
address="totoalias@test.com").first().recipients
models.Alias.objects.filter(address="aliasupdate1@test.com").exists()
)
alias_recipients = list(
models.Alias.objects.filter(address="totoalias@test.com").first().recipients
)
self.assertEqual(alias_recipients, ["toto@test.com"])
@@ -388,9 +361,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
"username": "superadmin@test.com",
"role": "SuperAdmins",
"password": "Toto12345",
"mailbox": {
"quota": 10
}
"mailbox": {"quota": 10},
}
resp = self.client.patch(url, data, format="json")
self.assertEqual(resp.status_code, 200)
@@ -405,7 +376,7 @@ class AccountViewSetTestCase(ModoAPITestCase):
data = {
"resources": [
{"name": "mailboxes", "max_value": 10},
{"name": "mailbox_aliases", "max_value": 10}
{"name": "mailbox_aliases", "max_value": 10},
]
}
resp = self.client.patch(url, data, format="json")
@@ -436,17 +407,20 @@ class IdentityViewSetTestCase(ModoAPITestCase):
self.assertEqual(len(resp.json()), 8)
def test_import(self):
f = ContentFile("""
f = ContentFile(
"""
account; user1@test.com; toto; User; One; True; SimpleUsers; user1@test.com; 0
account; Truc@test.com; toto; René; Truc; True; DomainAdmins; truc@test.com; 5; test.com
alias; alias1@test.com; True; user1@test.com
forward; alias2@test.com; True; user1+ext@test.com
forward; fwd1@test.com; True; user@extdomain.com
dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
""", name="identities.csv") # NOQA:E501
""",
name="identities.csv",
) # NOQA:E501
self.client.post(
reverse("v2:identities-import-from-csv"),
{"sourcefile": f, "crypt_password": True}
{"sourcefile": f, "crypt_password": True},
)
admin = core_models.User.objects.get(username="admin")
u1 = core_models.User.objects.get(username="user1@test.com")
@@ -461,13 +435,11 @@ dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
self.assertEqual(mb1.quota, 0)
self.assertTrue(admin.is_owner(mb1))
self.assertEqual(mb1.full_address, "user1@test.com")
self.assertTrue(
self.client.login(username="user1@test.com", password="toto")
)
self.assertTrue(self.client.login(username="user1@test.com", password="toto"))
da = core_models.User.objects.get(username="truc@test.com")
damb = da.mailbox
self.assertEqual(da.first_name, u"René")
self.assertEqual(da.first_name, "René")
self.assertEqual(da.role, "DomainAdmins")
self.assertEqual(damb.quota, 5)
self.assertFalse(damb.use_domain_quota)
@@ -478,30 +450,23 @@ dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
self.assertTrue(da.can_access(u))
al = models.Alias.objects.get(address="alias1@test.com")
self.assertTrue(
al.aliasrecipient_set
.filter(r_mailbox=u1.mailbox).exists()
)
self.assertTrue(al.aliasrecipient_set.filter(r_mailbox=u1.mailbox).exists())
self.assertTrue(admin.is_owner(al))
fwd = models.Alias.objects.get(address="fwd1@test.com")
self.assertTrue(
fwd.aliasrecipient_set
.filter(
address="user@extdomain.com", r_mailbox__isnull=True,
r_alias__isnull=True)
.exists()
fwd.aliasrecipient_set.filter(
address="user@extdomain.com",
r_mailbox__isnull=True,
r_alias__isnull=True,
).exists()
)
self.assertTrue(admin.is_owner(fwd))
dlist = models.Alias.objects.get(address="dlist@test.com")
self.assertTrue(dlist.aliasrecipient_set.filter(r_mailbox=u1.mailbox).exists())
self.assertTrue(
dlist.aliasrecipient_set
.filter(r_mailbox=u1.mailbox).exists()
)
self.assertTrue(
dlist.aliasrecipient_set.filter(address="user@extdomain.com")
.exists()
dlist.aliasrecipient_set.filter(address="user@extdomain.com").exists()
)
self.assertTrue(admin.is_owner(dlist))
@@ -513,10 +478,7 @@ dlist; dlist@test.com; True; user1@test.com; user@extdomain.com
admin_row = received_content[0].split(",")
admin_row[2] = ""
received_content[0] = ",".join(admin_row)
self.assertCountEqual(
expected_response.strip().split("\r\n"),
received_content
)
self.assertCountEqual(expected_response.strip().split("\r\n"), received_content)
class AliasViewSetTestCase(ModoAPITestCase):
@@ -536,10 +498,7 @@ class AliasViewSetTestCase(ModoAPITestCase):
data = {"address": "alias@test.com"}
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 400)
self.assertEqual(
resp.json()["address"][0],
"This alias already exists"
)
self.assertEqual(resp.json()["address"][0], "This alias already exists")
data = {"address": "alias2@test.com"}
resp = self.client.post(url, data, format="json")
@@ -563,8 +522,7 @@ class UserAccountViewSetTestCase(ModoAPITestCase):
cls.da_token = Token.objects.create(user=cls.da)
def test_forward(self):
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
url = reverse("v2:account-forward")
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
@@ -580,8 +538,7 @@ class UserAccountViewSetTestCase(ModoAPITestCase):
self.assertEqual(resp.status_code, 200)
self.assertEqual(
models.Alias.objects.filter(address=self.da.username).count(),
2
models.Alias.objects.filter(address=self.da.username).count(), 2
)
resp = self.client.get(url)
@@ -592,8 +549,7 @@ class UserAccountViewSetTestCase(ModoAPITestCase):
resp = self.client.post(url, data, format="json")
self.assertEqual(resp.status_code, 200)
self.assertEqual(
models.Alias.objects.filter(address=self.da.username).count(),
1
models.Alias.objects.filter(address=self.da.username).count(), 1
)
@@ -605,9 +561,11 @@ class AlarmViewSetTestCase(ModoAPITestCase):
super().setUpTestData()
factories.populate_database()
factories.AlarmFactory(
domain__name="test.com", mailbox=None, title="Test alarm")
domain__name="test.com", mailbox=None, title="Test alarm"
)
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="admin@test.com"))
user=core_models.User.objects.get(username="admin@test.com")
)
def test_list(self):
url = reverse("v2:alarm-list")
@@ -621,11 +579,11 @@ class AlarmViewSetTestCase(ModoAPITestCase):
domain = models.Domain.objects.get(name="test.com")
# Try performing action on restricted domains
self.client.credentials(
HTTP_AUTHORIZATION="Token " + self.da_token.key)
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.da_token.key)
domain = models.Domain.objects.get(name="test2.com")
alarm_restricted = models.Alarm.objects.create(
domain=domain, mailbox=None, title="Test alarm 2")
domain=domain, mailbox=None, title="Test alarm 2"
)
alarm_restricted.save()
url = reverse("v2:alarm-switch", args=[alarm_restricted.pk])
resp = self.client.post(url)
@@ -638,7 +596,8 @@ class AlarmViewSetTestCase(ModoAPITestCase):
self.client.credentials(HTTP_AUTHORIZATION="Token " + self.token.key)
alarm = models.Alarm.objects.create(
domain=domain, mailbox=None, title="Test alarm 3")
domain=domain, mailbox=None, title="Test alarm 3"
)
alarm.save()
# Switch status of the alarm to close
@@ -678,9 +637,11 @@ class AlarmViewSetTestCase(ModoAPITestCase):
resp = self.client.delete(f"{url}?ids[]=toto")
self.assertEqual(resp.status_code, 400)
alarm1 = factories.AlarmFactory(
domain__name="test.com", mailbox=None, title="Test alarm")
domain__name="test.com", mailbox=None, title="Test alarm"
)
alarm2 = factories.AlarmFactory(
domain__name="test.com", mailbox=None, title="Test alarm")
domain__name="test.com", mailbox=None, title="Test alarm"
)
resp = self.client.delete(f"{url}?ids[]={alarm1.pk}&ids[]={alarm2.pk}")
self.assertEqual(resp.status_code, 204)
with self.assertRaises(models.Alarm.DoesNotExist):
+7 -9
View File
@@ -9,17 +9,15 @@ from . import viewsets
router = routers.SimpleRouter()
router.register(r"domains", viewsets.DomainViewSet, basename="domain")
router.register(
r"domainaliases", v1_viewsets.DomainAliasViewSet, basename="domain_alias")
r"domainaliases", v1_viewsets.DomainAliasViewSet, basename="domain_alias"
)
router.register(r"accounts", viewsets.AccountViewSet, basename="account")
router.register(r"aliases", viewsets.AliasViewSet, basename="alias")
router.register(
r"senderaddresses", v1_viewsets.SenderAddressViewSet,
basename="sender_address")
router.register(
r"identities", viewsets.IdentityViewSet, basename="identities")
router.register(
r"account", viewsets.UserAccountViewSet, basename="account")
router.register(
r"alarms", viewsets.AlarmViewSet, basename="alarm")
r"senderaddresses", v1_viewsets.SenderAddressViewSet, basename="sender_address"
)
router.register(r"identities", viewsets.IdentityViewSet, basename="identities")
router.register(r"account", viewsets.UserAccountViewSet, basename="account")
router.register(r"alarms", viewsets.AlarmViewSet, basename="alarm")
urlpatterns = router.urls
+88 -88
View File
@@ -7,7 +7,13 @@ from django.contrib.contenttypes.models import ContentType
from django_filters import rest_framework as dj_filters
from drf_spectacular.utils import extend_schema, extend_schema_view
from rest_framework import (
filters, mixins, parsers, permissions, response, status, viewsets
filters,
mixins,
parsers,
permissions,
response,
status,
viewsets,
)
from rest_framework.decorators import action
from rest_framework.exceptions import PermissionDenied
@@ -29,31 +35,32 @@ from . import serializers
@extend_schema_view(
retrieve=extend_schema(
description="Retrieve a particular domain",
summary="Retrieve a particular domain"
summary="Retrieve a particular domain",
),
list=extend_schema(
description="Retrieve a list of domains",
summary="Retrieve a list of domains"
description="Retrieve a list of domains", summary="Retrieve a list of domains"
),
create=extend_schema(
description="Create a new domain",
summary="Create a new domain"
description="Create a new domain", summary="Create a new domain"
),
delete=extend_schema(
description="Delete a particular domain",
summary="Delete a particular domain"
description="Delete a particular domain", summary="Delete a particular domain"
),
)
class DomainViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin,
mixins.ListModelMixin,
mixins.RetrieveModelMixin,
mixins.CreateModelMixin,
mixins.UpdateModelMixin,
viewsets.GenericViewSet):
class DomainViewSet(
GetThrottleViewsetMixin,
lib_viewsets.RevisionModelMixin,
mixins.ListModelMixin,
mixins.RetrieveModelMixin,
mixins.CreateModelMixin,
mixins.UpdateModelMixin,
viewsets.GenericViewSet,
):
"""V2 viewset."""
permission_classes = (
permissions.IsAuthenticated, permissions.DjangoModelPermissions,
permissions.IsAuthenticated,
permissions.DjangoModelPermissions,
)
def get_queryset(self):
@@ -112,8 +119,9 @@ class DomainViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin,
domain.remove_admin(serializer.validated_data["account"])
return response.Response()
@action(methods=["get"], detail=False,
renderer_classes=(lib_renderers.CSVRenderer,))
@action(
methods=["get"], detail=False, renderer_classes=(lib_renderers.CSVRenderer,)
)
def export(self, request, **kwargs):
"""Export domains and aliases to CSV."""
result = []
@@ -121,21 +129,19 @@ class DomainViewSet(GetThrottleViewsetMixin, lib_viewsets.RevisionModelMixin,
result += domain.to_csv_rows()
return response.Response(result)
@extend_schema(
request=serializers.CSVImportSerializer
@extend_schema(request=serializers.CSVImportSerializer)
@action(
methods=["post"],
detail=False,
parser_classes=(parsers.MultiPartParser, parsers.FormParser),
url_path="import",
)
@action(methods=["post"],
detail=False,
parser_classes=(parsers.MultiPartParser, parsers.FormParser),
url_path="import")
def import_from_csv(self, request, **kwargs):
"""Import domains and aliases from CSV file."""
serializer = serializers.CSVImportSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
status, msg = lib.import_data(
request.user,
request.FILES["sourcefile"],
serializer.validated_data
request.user, request.FILES["sourcefile"], serializer.validated_data
)
return response.Response({"status": status, "message": msg})
@@ -144,9 +150,8 @@ class AccountFilterSet(dj_filters.FilterSet):
"""Custom FilterSet for Account."""
domain = dj_filters.ModelChoiceFilter(
queryset=lambda request: models.Domain.objects.get_for_admin(
request.user),
field_name="mailbox__domain"
queryset=lambda request: models.Domain.objects.get_for_admin(request.user),
field_name="mailbox__domain",
)
role = dj_filters.CharFilter(method="filter_role")
@@ -176,23 +181,19 @@ class AccountViewSet(v1_viewsets.AccountViewSet):
def get_queryset(self):
"""Filter queryset based on current user."""
user = self.request.user
ids = (
user.objectaccess_set
.filter(content_type=ContentType.objects.get_for_model(user))
.values_list("object_id", flat=True)
)
return (
core_models.User.objects.filter(pk__in=ids)
.prefetch_related("userobjectlimit_set")
ids = user.objectaccess_set.filter(
content_type=ContentType.objects.get_for_model(user)
).values_list("object_id", flat=True)
return core_models.User.objects.filter(pk__in=ids).prefetch_related(
"userobjectlimit_set"
)
@action(methods=["post"], detail=False)
def validate(self, request, **kwargs):
"""Validate given account without creating it."""
serializer = self.get_serializer(
data=request.data,
context=self.get_serializer_context(),
partial=True)
data=request.data, context=self.get_serializer_context(), partial=True
)
serializer.is_valid(raise_exception=True)
return response.Response(status=204)
@@ -215,17 +216,19 @@ class AccountViewSet(v1_viewsets.AccountViewSet):
class IdentityViewSet(GetThrottleViewsetMixin, viewsets.ViewSet):
"""Viewset for identities."""
permission_classes = (permissions.IsAuthenticated, )
permission_classes = (permissions.IsAuthenticated,)
serializer_class = None
def list(self, request, **kwargs):
"""Return all identities."""
serializer = serializers.IdentitySerializer(
lib.get_identities(request.user), many=True)
lib.get_identities(request.user), many=True
)
return response.Response(serializer.data)
@action(methods=["get"], detail=False,
renderer_classes=(lib_renderers.CSVRenderer,))
@action(
methods=["get"], detail=False, renderer_classes=(lib_renderers.CSVRenderer,)
)
def export(self, request, **kwargs):
"""Export accounts and aliases to CSV."""
result = []
@@ -233,21 +236,19 @@ class IdentityViewSet(GetThrottleViewsetMixin, viewsets.ViewSet):
result.append(idt.to_csv_row())
return response.Response(result)
@extend_schema(
request=serializers.CSVIdentityImportSerializer
@extend_schema(request=serializers.CSVIdentityImportSerializer)
@action(
methods=["post"],
detail=False,
parser_classes=(parsers.MultiPartParser, parsers.FormParser),
url_path="import",
)
@action(methods=["post"],
detail=False,
parser_classes=(parsers.MultiPartParser, parsers.FormParser),
url_path="import")
def import_from_csv(self, request, **kwargs):
"""Import accounts and aliases from CSV file."""
serializer = serializers.CSVIdentityImportSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
status, msg = lib.import_data(
request.user,
request.FILES["sourcefile"],
serializer.validated_data
request.user, request.FILES["sourcefile"], serializer.validated_data
)
return response.Response({"status": status, "message": msg})
@@ -261,23 +262,20 @@ class AliasViewSet(v1_viewsets.AliasViewSet):
def validate(self, request, **kwargs):
"""Validate given alias without creating it."""
serializer = self.get_serializer(
data=request.data,
context=self.get_serializer_context(),
partial=True)
data=request.data, context=self.get_serializer_context(), partial=True
)
try:
serializer.is_valid(raise_exception=True)
except AliasExists as e:
return response.Response(
data={"id": e.alias_id, "status": _("This alias already exists")},
status=409
)
status=409,
)
return response.Response(status=204)
@action(methods=["get"], detail=False)
def random_address(self, request, **kwargs):
return response.Response({
"address": models.Alias.generate_random_address()
})
return response.Response({"address": models.Alias.generate_random_address()})
class UserAccountViewSet(GetThrottleViewsetMixin, viewsets.ViewSet):
@@ -288,7 +286,8 @@ class UserAccountViewSet(GetThrottleViewsetMixin, viewsets.ViewSet):
"""Get or define user forward."""
mb = request.user.mailbox
alias = models.Alias.objects.filter(
address=mb.full_address, internal=False).first()
address=mb.full_address, internal=False
).first()
data = {}
if request.method == "GET":
if alias is not None and alias.recipients:
@@ -304,17 +303,16 @@ class UserAccountViewSet(GetThrottleViewsetMixin, viewsets.ViewSet):
recipients = serializer.validated_data.get("recipients")
if not recipients:
models.Alias.objects.filter(
address=mb.full_address, internal=False).delete()
address=mb.full_address, internal=False
).delete()
# Make sure internal self-alias is enabled
models.Alias.objects.filter(
address=mb.full_address, internal=True
).update(enabled=True)
models.Alias.objects.filter(address=mb.full_address, internal=True).update(
enabled=True
)
else:
if alias is None:
alias = models.Alias.objects.create(
address=mb.full_address,
domain=mb.domain,
enabled=mb.user.is_active
address=mb.full_address, domain=mb.domain, enabled=mb.user.is_active
)
alias.post_create(request.user)
if serializer.validated_data["keepcopies"]:
@@ -346,32 +344,35 @@ class AlarmFilterSet(dj_filters.FilterSet):
return queryset.filter(created__gt=value)
class AlarmViewSet(GetThrottleViewsetMixin,
mixins.DestroyModelMixin,
mixins.ListModelMixin,
mixins.RetrieveModelMixin,
viewsets.GenericViewSet):
class AlarmViewSet(
GetThrottleViewsetMixin,
mixins.DestroyModelMixin,
mixins.ListModelMixin,
mixins.RetrieveModelMixin,
viewsets.GenericViewSet,
):
"""Viewset for Alarm."""
filter_backends = (filters.OrderingFilter,
filters.SearchFilter,
dj_filters.DjangoFilterBackend)
filter_backends = (
filters.OrderingFilter,
filters.SearchFilter,
dj_filters.DjangoFilterBackend,
)
filterset_class = AlarmFilterSet
ordering_fields = ["created", "status", "title"]
pagination_class = pagination.CustomPageNumberPagination
permission_classes = (
permissions.IsAuthenticated,
)
permission_classes = (permissions.IsAuthenticated,)
search_fields = ["domain__name", "title"]
serializer_class = serializers.AlarmSerializer
def get_queryset(self):
return models.Alarm.objects.select_related("domain").filter(
domain__in=models.Domain.objects.get_for_admin(
self.request.user)
).order_by("-created")
return (
models.Alarm.objects.select_related("domain")
.filter(domain__in=models.Domain.objects.get_for_admin(self.request.user))
.order_by("-created")
)
@action(methods=['patch'], detail=True)
@action(methods=["patch"], detail=True)
def switch(self, request, **kwargs):
"""Custom update method that switch status of an alarm."""
alarm = self.get_object()
@@ -383,7 +384,7 @@ class AlarmViewSet(GetThrottleViewsetMixin,
alarm.reopen()
return response.Response(status=status.HTTP_204_NO_CONTENT)
@action(methods=['delete'], detail=False)
@action(methods=["delete"], detail=False)
def bulk_delete(self, request, **kwargs):
"""Delete multiple alarms at the same time."""
ids = request.query_params.getlist("ids[]")
@@ -392,7 +393,6 @@ class AlarmViewSet(GetThrottleViewsetMixin,
try:
ids = [int(alarm_id) for alarm_id in ids]
except ValueError:
return response.Response(
_("Received invalid alarm id(s)"), status=400)
return response.Response(_("Received invalid alarm id(s)"), status=400)
models.Alarm.objects.filter(pk__in=ids).delete()
return response.Response(status=204)