modoboa 2.4.10__py3-none-any.whl → 2.5.0__py3-none-any.whl

modoboa/amavis/models.py

@@ -0,0 +1,226 @@
+# This is an auto-generated Django model module.
+# You'll have to do the following manually to clean this up:
+#     * Rearrange models' order
+#     * Make sure each model has one field with primary_key=True
+# Feel free to rename the models, but don't rename db_table values
+# or field names.
+#
+# Also note: You'll have to insert the output of
+# 'django-admin.py sqlcustom [appname]'into your database.
+#
+# Original Amavis version : 2.6.2
+
+from datetime import datetime
+
+from django.db import models
+from django.utils.translation import gettext_lazy
+
+
+class Maddr(models.Model):
+    partition_tag = models.IntegerField(default=0)
+    id = models.BigIntegerField(primary_key=True)  # NOQA:A003
+    email = models.CharField(max_length=255)
+    domain = models.CharField(max_length=255)
+
+    class Meta:
+        db_table = "maddr"
+        unique_together = [("partition_tag", "email")]
+        managed = False
+
+
+class Mailaddr(models.Model):
+    id = models.IntegerField(primary_key=True)  # NOQA:A003
+    priority = models.IntegerField()
+    email = models.CharField(unique=True, max_length=255)
+
+    class Meta:
+        db_table = "mailaddr"
+        managed = False
+
+
+class Msgs(models.Model):
+    partition_tag = models.IntegerField(default=0)
+    mail_id = models.BinaryField(max_length=16, primary_key=True)
+    secret_id = models.BinaryField()
+    am_id = models.CharField(max_length=60)
+    time_num = models.IntegerField()
+    time_iso = models.CharField(max_length=48)
+    sid = models.ForeignKey(Maddr, db_column="sid", on_delete=models.CASCADE)
+    policy = models.CharField(max_length=765, blank=True)
+    client_addr = models.CharField(max_length=765, blank=True)
+    size = models.IntegerField()
+    originating = models.CharField(max_length=3)
+    content = models.CharField(max_length=1, blank=True)
+    quar_type = models.CharField(max_length=1, blank=True)
+    quar_loc = models.CharField(max_length=255, blank=True)
+    dsn_sent = models.CharField(max_length=3, blank=True)
+    spam_level = models.FloatField(null=True, blank=True)
+    message_id = models.CharField(max_length=765, blank=True)
+    from_addr = models.CharField(max_length=765, blank=True)
+    subject = models.CharField(max_length=765, blank=True)
+    host = models.CharField(max_length=765)
+
+    class Meta:
+        db_table = "msgs"
+        managed = False
+        unique_together = ("partition_tag", "mail_id")
+
+    @property
+    def time_datetime(self) -> datetime:
+        return datetime.fromtimestamp(self.time_num)
+
+
+class Msgrcpt(models.Model):
+    partition_tag = models.IntegerField(default=0)
+    mail = models.ForeignKey(Msgs, primary_key=True, on_delete=models.CASCADE)
+    rid = models.ForeignKey(Maddr, db_column="rid", on_delete=models.CASCADE)
+    rseqnum = models.IntegerField(default=0)
+    is_local = models.CharField(max_length=3)
+    content = models.CharField(max_length=3)
+    ds = models.CharField(max_length=3)
+    rs = models.CharField(max_length=3)
+    bl = models.CharField(max_length=3, blank=True)
+    wl = models.CharField(max_length=3, blank=True)
+    bspam_level = models.FloatField(null=True, blank=True)
+    smtp_resp = models.CharField(max_length=765, blank=True)
+
+    class Meta:
+        db_table = "msgrcpt"
+        managed = False
+        unique_together = ("partition_tag", "mail", "rseqnum")
+
+
+class Policy(models.Model):
+    policy_name = models.CharField(max_length=32, blank=True)
+    virus_lover = models.CharField(max_length=3, blank=True, null=True)
+    spam_lover = models.CharField(max_length=3, blank=True, null=True)
+    unchecked_lover = models.CharField(max_length=3, blank=True, null=True)
+    banned_files_lover = models.CharField(max_length=3, blank=True, null=True)
+    bad_header_lover = models.CharField(max_length=3, blank=True, null=True)
+    bypass_virus_checks = models.CharField(
+        gettext_lazy("Virus filter"),
+        default="",
+        null=True,
+        choices=(
+            ("N", gettext_lazy("yes")),
+            ("Y", gettext_lazy("no")),
+            ("", gettext_lazy("default")),
+        ),
+        max_length=3,
+        help_text=gettext_lazy(
+            "Bypass virus checks or not. Choose 'default' to use global " "settings."
+        ),
+    )
+    bypass_spam_checks = models.CharField(
+        gettext_lazy("Spam filter"),
+        default="",
+        null=True,
+        choices=(
+            ("N", gettext_lazy("yes")),
+            ("Y", gettext_lazy("no")),
+            ("", gettext_lazy("default")),
+        ),
+        max_length=3,
+        help_text=gettext_lazy(
+            "Bypass spam checks or not. Choose 'default' to use global " "settings."
+        ),
+    )
+    bypass_banned_checks = models.CharField(
+        gettext_lazy("Banned filter"),
+        default="",
+        null=True,
+        choices=(
+            ("N", gettext_lazy("yes")),
+            ("Y", gettext_lazy("no")),
+            ("", gettext_lazy("default")),
+        ),
+        max_length=3,
+        help_text=gettext_lazy(
+            "Bypass banned checks or not. Choose 'default' to use global " "settings."
+        ),
+    )
+    bypass_header_checks = models.CharField(max_length=3, blank=True, null=True)
+    virus_quarantine_to = models.CharField(max_length=192, blank=True, null=True)
+    spam_quarantine_to = models.CharField(max_length=192, blank=True, null=True)
+    banned_quarantine_to = models.CharField(max_length=192, blank=True, null=True)
+    unchecked_quarantine_to = models.CharField(max_length=192, blank=True, null=True)
+    bad_header_quarantine_to = models.CharField(max_length=192, blank=True, null=True)
+    clean_quarantine_to = models.CharField(max_length=192, blank=True, null=True)
+    archive_quarantine_to = models.CharField(max_length=192, blank=True, null=True)
+    spam_tag_level = models.FloatField(null=True, blank=True)
+    spam_tag2_level = models.FloatField(null=True, blank=True)
+    spam_tag3_level = models.FloatField(null=True, blank=True)
+    spam_kill_level = models.FloatField(null=True, blank=True)
+    spam_dsn_cutoff_level = models.FloatField(null=True, blank=True)
+    spam_quarantine_cutoff_level = models.FloatField(null=True, blank=True)
+    addr_extension_virus = models.CharField(max_length=192, blank=True, null=True)
+    addr_extension_spam = models.CharField(max_length=192, blank=True, null=True)
+    addr_extension_banned = models.CharField(max_length=192, blank=True, null=True)
+    addr_extension_bad_header = models.CharField(max_length=192, blank=True, null=True)
+    warnvirusrecip = models.CharField(max_length=3, blank=True, null=True)
+    warnbannedrecip = models.CharField(max_length=3, blank=True, null=True)
+    warnbadhrecip = models.CharField(max_length=3, blank=True, null=True)
+    newvirus_admin = models.CharField(max_length=192, blank=True, null=True)
+    virus_admin = models.CharField(max_length=192, blank=True, null=True)
+    banned_admin = models.CharField(max_length=192, blank=True, null=True)
+    bad_header_admin = models.CharField(max_length=192, blank=True, null=True)
+    spam_admin = models.CharField(max_length=192, blank=True, null=True)
+    spam_subject_tag = models.CharField(max_length=192, blank=True, null=True)
+    spam_subject_tag2 = models.CharField(
+        gettext_lazy("Spam marker"),
+        default=None,
+        max_length=192,
+        blank=True,
+        null=True,
+        help_text=gettext_lazy(
+            "Modify spam subject using the specified text. "
+            "Choose 'default' to use global settings."
+        ),
+    )
+    spam_subject_tag3 = models.CharField(max_length=192, blank=True, null=True)
+    message_size_limit = models.IntegerField(null=True, blank=True)
+    banned_rulenames = models.CharField(max_length=192, blank=True, null=True)
+    disclaimer_options = models.CharField(max_length=192, blank=True, null=True)
+    forward_method = models.CharField(max_length=192, blank=True, null=True)
+    sa_userconf = models.CharField(max_length=192, blank=True, null=True)
+    sa_username = models.CharField(max_length=192, blank=True, null=True)
+
+    class Meta:
+        db_table = "policy"
+        managed = False
+
+
+class Quarantine(models.Model):
+    partition_tag = models.IntegerField(default=0)
+    mail = models.ForeignKey(Msgs, primary_key=True, on_delete=models.CASCADE)
+    chunk_ind = models.IntegerField()
+    mail_text = models.BinaryField()
+
+    class Meta:
+        db_table = "quarantine"
+        managed = False
+        ordering = ["-mail__time_num"]
+        unique_together = ("partition_tag", "mail", "chunk_ind")
+
+
+class Users(models.Model):
+    id = models.AutoField(primary_key=True)  # NOQA:A003
+    priority = models.IntegerField()
+    policy = models.ForeignKey(Policy, on_delete=models.CASCADE)
+    email = models.CharField(unique=True, max_length=255)
+    fullname = models.CharField(max_length=765, blank=True)
+
+    class Meta:
+        db_table = "users"
+        managed = False
+
+
+class Wblist(models.Model):
+    rid = models.IntegerField(primary_key=True)
+    sid = models.IntegerField()
+    wb = models.CharField(max_length=30)
+
+    class Meta:
+        db_table = "wblist"
+        managed = False
+        unique_together = [("rid", "sid")]

modoboa/amavis/serializers.py

@@ -0,0 +1,139 @@
+"""Amavis serializers."""
+
+from django.utils.translation import gettext as _
+
+from rest_framework import serializers
+
+from modoboa.amavis import models
+
+
+class GlobalParametersSerializer(serializers.Serializer):
+
+    localpart_is_case_sensitive = serializers.BooleanField(default=False)
+    recipient_delimiter = serializers.CharField(default="")
+    max_messages_age = serializers.IntegerField(default=14)
+    released_msgs_cleanup = serializers.BooleanField(default=False)
+    am_pdp_mode = serializers.ChoiceField(
+        choices=[("inet", "inet"), ("unix", "unix")],
+        default="unix",
+    )
+    am_pdp_host = serializers.CharField(default="localhost", required=False)
+    am_pdp_port = serializers.IntegerField(default=9998, required=False)
+    am_pdp_socket = serializers.CharField(
+        default="/var/amavis/amavisd.sock", required=False
+    )
+    user_can_release = serializers.BooleanField(default=False)
+    self_service = serializers.BooleanField(default=False)
+    notifications_sender = serializers.EmailField(default="noreply@domain.tld")
+    manual_learning = serializers.BooleanField(default=True)
+    sa_is_local = serializers.BooleanField(default=True)
+    default_user = serializers.CharField(default="amavis", required=False)
+    spamd_address = serializers.CharField(default="127.0.0.1", required=False)
+    spamd_port = serializers.IntegerField(default=783, required=False)
+    domain_level_learning = serializers.BooleanField(default=False)
+    user_level_learning = serializers.BooleanField(default=False)
+
+    def validate(self, data):
+        am_pdp_mode = data.get("am_pdp_mode")
+        errors = {}
+        error = _("This field is required")
+        if am_pdp_mode == "inet":
+            for name in ["am_pdp_host", "am_pdp_port"]:
+                if name not in data:
+                    errors[name] = error
+        else:
+            name = "am_pdp_socket"
+            if name not in data:
+                errors[name] = error
+        manual_learning = data.get("manual_learning")
+        if manual_learning:
+            name = "default_user"
+            if name not in data:
+                errors[name] = error
+            sa_is_local = data.get("sa_is_local")
+            if sa_is_local:
+                for name in ["spamd_address", "spamd_port"]:
+                    if name not in data:
+                        errors[name] = error
+        if errors:
+            raise serializers.ValidationError(errors)
+        return data
+
+
+class UserPreferencesSerializer(serializers.Serializer):
+
+    messages_per_page = serializers.IntegerField(default=40)
+
+
+class HeaderSerializer(serializers.Serializer):
+
+    name = serializers.CharField()
+    value = serializers.CharField()
+
+
+class MessageHeadersSerializer(serializers.Serializer):
+
+    headers = HeaderSerializer(many=True)
+
+
+class MessageSerializer(serializers.Serializer):
+
+    qtype = serializers.CharField()
+    qreason = serializers.CharField()
+    headers = HeaderSerializer(many=True)
+    body = serializers.CharField()
+
+
+class CompactMessageSerializer(serializers.Serializer):
+
+    mailid = serializers.CharField()
+    type = serializers.CharField()
+    status = serializers.CharField()
+    score = serializers.CharField()
+    to_address = serializers.CharField()
+    from_address = serializers.CharField()
+    subject = serializers.CharField()
+    datetime = serializers.DateTimeField()
+    style = serializers.CharField(required=False)
+
+
+class PaginatedMessageListSerializer(serializers.Serializer):
+
+    count = serializers.IntegerField()
+    first_index = serializers.IntegerField()
+    last_index = serializers.IntegerField()
+    prev_page = serializers.IntegerField()
+    next_page = serializers.IntegerField()
+    results = CompactMessageSerializer(many=True)
+
+
+class MessageIdentifierSerializer(serializers.Serializer):
+
+    mailid = serializers.CharField()
+    rcpt = serializers.CharField()
+    secret_id = serializers.CharField(required=False)
+
+
+class MessageSelectionSerializer(serializers.Serializer):
+
+    selection = MessageIdentifierSerializer(many=True)
+
+
+class MarkMessageSelectionSerializer(MessageSelectionSerializer):
+
+    type = serializers.CharField()
+    database = serializers.CharField(required=False)
+
+
+class PolicySerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = models.Policy
+        fields = (
+            "bypass_virus_checks",
+            "bypass_spam_checks",
+            "bypass_banned_checks",
+            "spam_tag2_level",
+            "spam_kill_level",
+            "spam_subject_tag2",
+        )

modoboa/amavis/sql_connector.py

@@ -0,0 +1,240 @@
+"""SQL connector module."""
+
+import datetime
+
+from django.db.models import Q
+
+from modoboa.admin.models import Domain
+from modoboa.lib.email_utils import decode
+
+from .lib import cleanup_email_address, make_query_args
+from .models import Maddr, Msgrcpt, Quarantine
+from .utils import ConvertFrom, fix_utf8_encoding, smart_bytes, smart_str
+
+
+def reverse_domain_names(domains):
+    """Return a list of reversed domain names."""
+    return [".".join(reversed(domain.split("."))) for domain in domains]
+
+
+class SQLconnector:
+    """This class handles all database operations."""
+
+    ORDER_TRANSLATION_TABLE = {
+        "type": "content",
+        "score": "bspam_level",
+        "datetime": "mail__time_num",
+        "subject": "mail__subject",
+        "from_address": "mail__from_addr",
+        "to_address": "rid__email",
+    }
+
+    QUARANTINE_FIELDS = [
+        "content",
+        "bspam_level",
+        "rs",
+        "rid__email",
+        "mail__from_addr",
+        "mail__subject",
+        "mail__mail_id",
+        "mail__time_num",
+    ]
+
+    def __init__(self, user=None, ordering: str | None = None) -> None:
+        """Constructor."""
+        self.user = user
+        self.messages = None
+        self.ordering = ordering
+
+        self._messages_count = None
+        self._annotations = {}
+
+    def _exec(self, query, args):
+        """Execute a raw SQL query.
+
+        :param string query: query to execute
+        :param list args: a list of arguments to replace in :kw:`query`
+        """
+        from django.db import connections, transaction
+
+        with transaction.atomic():
+            cursor = connections["amavis"].cursor()
+            cursor.execute(query, args)
+
+    def _apply_msgrcpt_simpleuser_filter(self, flt):
+        """Apply specific filter for simple users."""
+        if "str_email" not in self._annotations:
+            self._annotations["str_email"] = ConvertFrom("rid__email")
+
+        rcpts = [self.user.email]
+        if hasattr(self.user, "mailbox"):
+            rcpts += self.user.mailbox.alias_addresses
+
+        query_rcpts = []
+        for rcpt in rcpts:
+            query_rcpts += make_query_args(rcpt, exact_extension=False, wildcard=".*")
+
+        re = f"({'|'.join(query_rcpts)})"
+        return flt & Q(str_email__regex=re)
+
+    def _apply_msgrcpt_filters(self, flt):
+        """Apply filters based on user's role."""
+        if self.user.role == "SimpleUsers":
+            flt = self._apply_msgrcpt_simpleuser_filter(flt)
+        elif not self.user.is_superuser:
+            doms = Domain.objects.get_for_admin(self.user).values_list(
+                "name", flat=True
+            )
+            flt &= Q(rid__domain__in=reverse_domain_names(doms))
+        return flt
+
+    def _get_quarantine_content(self, request):
+        """Fetch quarantine content.
+
+        Filters: rs, rid, content
+        """
+        flt = (
+            Q(rs__in=[" ", "V", "R", "p", "S", "H"])
+            if request.GET.get("viewrequests", "0") != "1"
+            else Q(rs="p")
+        )
+        flt = self._apply_msgrcpt_filters(flt)
+        search = request.GET.get("search")
+        if search:
+            criteria = request.GET.get("criteria", "both")
+            if criteria == "both":
+                criteria = "from_addr,subject,to"
+            search_flt = None
+            for crit in criteria.split(","):
+                if crit == "from_addr":
+                    nfilter = Q(mail__from_addr__icontains=search)
+                elif crit == "subject":
+                    nfilter = Q(mail__subject__icontains=search)
+                elif crit == "to":
+                    if "str_email" not in self._annotations:
+                        self._annotations["str_email"] = ConvertFrom("rid__email")
+                    nfilter = Q(str_email__icontains=search)
+                else:
+                    continue
+                search_flt = nfilter if search_flt is None else search_flt | nfilter
+            if search_flt:
+                flt &= search_flt
+
+        msgtype = request.GET.get("msgtype")
+        if msgtype is not None:
+            flt &= Q(content=msgtype)
+
+        flt &= Q(mail__in=Quarantine.objects.filter(chunk_ind=1).values("mail_id"))
+
+        return (
+            Msgrcpt.objects.annotate(**self._annotations)
+            .select_related("mail", "rid")
+            .filter(flt)
+        )
+
+    def messages_count(self, request) -> int:
+        """
+        Return the total number of messages living in the quarantine.
+
+        We also store the built queryset for a later use.
+        """
+        if self.user is None:
+            return None
+        if self._messages_count is None:
+            self.messages = self._get_quarantine_content(request)
+            self.messages = self.messages.values(*self.QUARANTINE_FIELDS)
+
+            order = self.ordering
+            if order is not None:
+                sign = ""
+                if order[0] == "-":
+                    sign = "-"
+                    order = order[1:]
+                order = self.ORDER_TRANSLATION_TABLE.get(order)
+                if order:
+                    self.messages = self.messages.order_by(sign + order)
+
+            self._messages_count = len(self.messages)
+
+        return self._messages_count
+
+    def fetch(self, start=None, stop=None):
+        """Fetch a range of messages from the internal cache."""
+        emails = []
+        for qm in self.messages[start - 1 : stop]:
+            if qm["rs"] == "D":
+                continue
+            m = {
+                "from_address": cleanup_email_address(
+                    fix_utf8_encoding(qm["mail__from_addr"])
+                ),
+                "to_address": smart_str(qm["rid__email"]),
+                "subject": fix_utf8_encoding(qm["mail__subject"]),
+                "mailid": smart_str(qm["mail__mail_id"]),
+                "datetime": datetime.datetime.fromtimestamp(qm["mail__time_num"]),
+                "type": qm["content"],
+                "score": qm["bspam_level"],
+                "status": qm["rs"],
+            }
+            if qm["rs"] in ["", " "]:
+                m["style"] = "unseen"
+            elif qm["rs"] == "p":
+                m["style"] = "pending"
+            emails.append(m)
+        return emails
+
+    def get_recipient_message(self, address, mailid):
+        """Retrieve a message for a given recipient."""
+        assert isinstance(address, str), "address should be of type str"
+
+        return Msgrcpt.objects.annotate(str_email=ConvertFrom("rid__email")).get(
+            mail=mailid.encode("ascii"), str_email=address
+        )
+
+    def set_msgrcpt_status(self, address, mailid: str, status):
+        """Change the status (rs field) of a message recipient.
+
+        :param string status: status
+        """
+        assert isinstance(address, str), "address should be of type str"
+        addr = Maddr.objects.annotate(str_email=ConvertFrom("email")).get(
+            str_email=address
+        )
+        self._exec(
+            "UPDATE msgrcpt SET rs=%s WHERE mail_id=%s AND rid=%s",
+            [status, mailid.encode("ascii"), addr.id],
+        )
+
+    def get_domains_pending_requests(self, domains):
+        """Retrieve pending release requests for a list of domains."""
+        return Msgrcpt.objects.filter(
+            rs="p", rid__domain__in=reverse_domain_names(domains)
+        )
+
+    def get_pending_requests(self):
+        """Return the number of requests currently pending."""
+        rq = Q(rs="p")
+        if not self.user.is_superuser:
+            doms = Domain.objects.get_for_admin(self.user)
+            if not doms.exists():
+                return 0
+            doms_q = Q(
+                rid__domain__in=reverse_domain_names(
+                    doms.values_list("name", flat=True)
+                )
+            )
+            rq &= doms_q
+        return Msgrcpt.objects.filter(rq).count()
+
+    def get_mail_content(self, mailid) -> str:
+        """Retrieve the content of a message."""
+        content_bytes = smart_bytes("").join(
+            [
+                smart_bytes(qmail.mail_text)
+                for qmail in Quarantine.objects.filter(mail=mailid)
+            ]
+        )
+        content = decode(
+            content_bytes, "utf-8", append_to_error=f"; mail_id={smart_str(mailid)}"
+        )
+        return content

modoboa/amavis/sql_email.py

@@ -0,0 +1,66 @@
+"""An email representation based on a database record."""
+
+from html2text import HTML2Text
+
+from django.template.loader import render_to_string
+
+from modoboa.lib.email_utils import Email
+from .sql_connector import SQLconnector
+from .utils import fix_utf8_encoding, smart_str
+
+
+class SQLemail(Email):
+    """The SQL version of the Email class."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.qtype = ""
+        self.qreason = ""
+
+        qreason = self.msg["X-Amavis-Alert"]
+        if qreason:
+            if "," in qreason:
+                self.qtype, qreason = qreason.split(",", 1)
+            elif qreason.startswith("BAD HEADER SECTION "):
+                # Workaround for amavis <= 2.8.0 :p
+                self.qtype = "BAD HEADER SECTION"
+                qreason = qreason[19:]
+
+            qreason = " ".join([x.strip() for x in qreason.splitlines()])
+            self.qreason = qreason
+
+    def _fetch_message(self) -> str:
+        return SQLconnector().get_mail_content(self.mailid)
+
+    @property
+    def body(self):
+        if self._body is None:
+            super().body  # noqa
+            self._body = fix_utf8_encoding(self._body)
+
+        # if there's no plain text version available attempt to make one by
+        # sanitising the html version. The output isn't always pretty but it
+        # is readable, better than a blank screen and helps the user decide
+        # if the message is spam or ham.
+        if (
+            self.dformat == "plain"
+            and not self.contents["plain"]
+            and self.contents["html"]
+        ):
+            h = HTML2Text()
+            h.ignore_tables = True
+            h.images_to_alt = True
+            mail_text = h.handle(self.contents["html"])
+            self.contents["plain"] = self._post_process_plain(smart_str(mail_text))
+            self._body = self.viewmail_plain()
+            self._body = fix_utf8_encoding(self._body)
+
+        return self._body
+
+    def render_headers(self, **kwargs):
+        context = {
+            "qtype": self.qtype,
+            "qreason": self.qreason,
+            "headers": self.headers,
+        }
+        return render_to_string("modoboa_amavis/mailheaders.html", context)