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)
|
||||
|
||||
Reference in New Issue
Block a user