Removed useless files

modoboa/pdfcredentials/urls.py

@@ -1,13 +0,0 @@
-from django.urls import path
-
-from . import views
-
-app_name = "pdfcredentials"
-
-urlpatterns = [
-    path(
-        "credentials/<int:accountid>/",
-        views.get_account_credentials,
-        name="account_credentials",
-    ),
-]

modoboa/postfix_autoreply/views.py

@@ -1,39 +0,0 @@
-from django.contrib.auth.decorators import login_required
-from django.template.loader import render_to_string
-from django.utils.translation import gettext as _
-
-from modoboa.admin.lib import needs_mailbox
-from modoboa.admin.models import Mailbox
-from modoboa.lib.web_utils import render_to_json_response
-from .forms import ARmessageForm
-from .models import ARmessage
-
-
-@login_required
-@needs_mailbox()
-def autoreply(request, tplname="modoboa_postfix_autoreply/autoreply.html"):
-    mb = Mailbox.objects.get(user=request.user.id)
-    try:
-        arm = ARmessage.objects.get(mbox=mb.id)
-    except ARmessage.DoesNotExist:
-        arm = None
-    if request.method == "POST":
-        if arm:
-            form = ARmessageForm(mb, request.POST, instance=arm)
-        else:
-            form = ARmessageForm(mb, request.POST)
-        if form.is_valid():
-            form.save()
-            return render_to_json_response(
-                _("Auto reply message updated successfully.")
-            )
-
-        return render_to_json_response({"form_errors": form.errors}, status=400)
-
-    form = ARmessageForm(mb, instance=arm)
-    return render_to_json_response(
-        {
-            "content": render_to_string(tplname, {"form": form}, request),
-            "onload_cb": "autoreply_cb",
-        }
-    )

modoboa/relaydomains/forms.py

@@ -1,62 +0,0 @@
-"""Postfix relay domains extension forms."""
-
-from django.db.models.signals import pre_save, post_save
-
-from modoboa.lib.form_utils import WizardStep
-from modoboa.transport import forms as tr_forms, models as tr_models
-
-
-class DisableSignals:
-    """Context manager to disable signals."""
-
-    def __init__(self):
-        self.stashed_signals = {}
-        self.disabled_signals = [pre_save, post_save]
-
-    def __enter__(self):
-        for signal in self.disabled_signals:
-            self.disconnect(signal)
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        for signal in list(self.stashed_signals.keys()):
-            self.reconnect(signal)
-
-    def disconnect(self, signal):
-        self.stashed_signals[signal] = signal.receivers
-        signal.receivers = []
-
-    def reconnect(self, signal):
-        signal.receivers = self.stashed_signals.get(signal, [])
-        del self.stashed_signals[signal]
-
-
-class RelayDomainWizardStep(WizardStep):
-    """A custom wizard step."""
-
-    def check_access(self, wizard):
-        """Check if domain is a relay domain."""
-        return wizard.steps[0].form.cleaned_data["type"] == "relaydomain"
-
-
-class RelayDomainFormGeneral(tr_forms.TransportForm):
-    """A form to display transport."""
-
-    class Meta:
-        model = tr_models.Transport
-        exclude = ["creation", "pattern", "next_hop", "enabled", "_settings"]
-
-    def save(self, *args, **kwargs):
-        """Custom save method."""
-        domain = kwargs.pop("domain", None)
-        if domain.type != "relaydomain":
-            # We don't want to recreate the transport we just deleted it
-            # (post_save signal).
-            return None
-        instance = super().save()
-        instance.pattern = domain.name
-        instance.save()
-        if not domain.transport:
-            domain.transport = instance
-            with DisableSignals():
-                domain.save(update_fields=["transport"])
-        return instance

modoboa/transport/forms.py

@@ -1,97 +0,0 @@
-"""Transport forms."""
-
-from django import forms
-
-from . import backends, models
-
-TYPE_TO_FIELD_MAP = {
-    "int": forms.IntegerField,
-    "boolean": forms.BooleanField,
-    "string": forms.CharField,
-}
-
-
-class BackendSettingsMixin:
-    """A mixin to deal with backend settings in a model form."""
-
-    def __init__(self, *args, **kwargs):
-        """Constructor."""
-        super().__init__(*args, **kwargs)
-        self.setting_field_names = []
-
-    def inject_backend_settings(self, name, settings):
-        """Inject backend settings to form."""
-        for setting in settings:
-            fullname = "{}_{}".format(name, setting["name"])
-            options = {}
-            ftype = setting.get("type", "string")
-            if self.instance.pk:
-                options["initial"] = self.instance._settings.get(fullname)
-            elif "default" in setting:
-                options["initial"] = setting["default"]
-            if "widget" in setting:
-                options["widget"] = setting["widget"]
-            self.fields[fullname] = TYPE_TO_FIELD_MAP[ftype](
-                label=setting["label"], required=False, **options
-            )
-            self.setting_field_names.append(fullname)
-
-    def clean_backend_fields(self, name):
-        """Clean backend fields."""
-        self.backend = backends.manager.get_backend(name)
-        for field, error in self.backend.clean_fields(self.cleaned_data):
-            self.add_error(field, error)
-
-    def save(self, commit=True):
-        """Set settings to JSON field."""
-        transport = super().save(commit=False)
-        transport._settings = {
-            name: self.cleaned_data[name] for name in self.setting_field_names
-        }
-        if commit:
-            transport.save()
-        return transport
-
-
-class TransportForm(BackendSettingsMixin, forms.ModelForm):
-    """Transport model form."""
-
-    service = forms.ChoiceField(choices=[])
-
-    class Meta:
-        fields = ("pattern", "service")
-        model = models.Transport
-
-    def __init__(self, *args, **kwargs):
-        """Set backend list."""
-        super().__init__(*args, **kwargs)
-        self.fields["service"].choices = backends.manager.get_backend_list()
-        settings = backends.manager.get_all_backend_settings()
-        for name, backend_settings in settings.items():
-            self.inject_backend_settings(name, backend_settings)
-
-    @property
-    def setting_fields(self):
-        return [self[name] for name in self.setting_field_names]
-
-    def _clean_fields(self):
-        """Make backend settings required."""
-        backend_name = self.data.get("service")
-        backend_settings = backends.manager.get_backend_settings(backend_name)
-        for name, field in self.fields.items():
-            if name.startswith(f"{backend_name}_"):
-                name = name.replace(f"{backend_name}_", "")
-                for setting in backend_settings:
-                    if setting["name"] == name:
-                        break
-                if setting.get("required", True):
-                    field.required = True
-        return super()._clean_fields()
-
-    def clean(self):
-        """Check values."""
-        cleaned_data = super().clean()
-        if self.errors:
-            return cleaned_data
-        self.clean_backend_fields(cleaned_data["service"])
-        return cleaned_data