Initial import

admin/forms.py

@@ -0,0 +1,34 @@
+from django import forms
+from mailng.admin.models import Domain, Mailbox, Alias
+
+class DomainForm(forms.ModelForm):
+    class Meta:
+        model = Domain
+
+class MailboxForm(forms.ModelForm):
+    password1 = forms.CharField(label="Password", widget=forms.PasswordInput)
+    password2 = forms.CharField(label="Confirmation", widget=forms.PasswordInput)
+    enabled = forms.BooleanField(label="Enabled", required=False)
+
+    class Meta:
+        model = Mailbox
+        fields = ('name', 'address', 'quota')
+
+    def clean_password2(self):
+        if self.cleaned_data["password1"] != self.cleaned_data["password2"]:
+            raise forms.ValidationError("Passwords mismatch")
+        return self.cleaned_data["password2"]
+
+class AliasForm(forms.ModelForm):
+    def __init__(self, *args, **kwargs):
+        domain = None
+        if kwargs.has_key("domain"):
+            domain = kwargs["domain"]
+            del kwargs["domain"]
+        super(AliasForm, self).__init__(*args, **kwargs)
+        if domain:
+            self.fields['mbox'].queryset = Mailbox.objects.filter(domain=domain.id)
+
+    class Meta:
+        model = Alias
+

admin/models.py

@@ -0,0 +1,30 @@
+from django.db import models
+from django.contrib.auth.models import User
+
+# Create your models here.
+
+class Domain(models.Model):
+    name = models.CharField(max_length=100)
+    quota = models.IntegerField()
+    enabled = models.BooleanField()
+
+class Mailbox(models.Model):
+    name = models.CharField(max_length=100)
+    address = models.CharField(max_length=100)
+#    password = models.CharField(max_length=100)
+    quota = models.IntegerField()
+#    enabled = models.BooleanField()
+    uid = models.IntegerField()
+    gid = models.IntegerField()
+    path = models.CharField(max_length=200)
+    domain = models.ForeignKey(Domain)
+    user = models.ForeignKey(User)
+
+    def __str__(self):
+        return "%s" % (self.address)
+
+
+class Alias(models.Model):
+    address = models.CharField(max_length=100)
+    mbox = models.ForeignKey(Mailbox)
+    enabled = models.BooleanField()

admin/templatetags/admin_extras.py

@@ -0,0 +1,36 @@
+from django import template
+from django.template.loader import render_to_string
+
+register = template.Library()
+
+@register.simple_tag
+def domain_menu(domain_id, selection):
+    return render_to_string('admin/domain_menu.html', 
+                            {"selection" : selection,
+                             "domain_id" : domain_id})
+
+
+# class MyVar(template.Node):
+#     def __init__(self, value, var_name):
+#         self.var_name = var_name
+#         self.value = value
+
+#     def render(self, context):
+#         context[self.var_name] = self.value
+#         return ""
+
+# import re
+
+# @register.tag(name="var")
+# def do_my_var(parser, token):
+#     try:
+#         tag_name, arg = token.contents.split(None, 1)
+#     except ValueError:
+#         raise template.TemplateSyntaxError, '%r tag requires arguments' \
+#             % token.contents.split()[0]
+#     m = re.search('(.*?) as (\w+)', arg)
+#     if not m:
+#         raise template.TemplateSyntaxError, "%r tag had invalid arguments" \
+#             % tag_name
+#     value, var_name = m.groups()
+#     return MyVar(value, var_name)

admin/urls.py

@@ -0,0 +1,18 @@
+from django.conf.urls.defaults import *
+
+urlpatterns = patterns('mailng.admin.views',
+                       (r'^$', 'domains'),
+                       (r'^domains/$', 'domains'),
+                       (r'^domains/new/', 'newdomain'),
+                       (r'^domains/(?P<dom_id>\d+)/edit/$', 'editdomain'),
+                       (r'^domains/(?P<dom_id>\d+)/delete/$', 'deldomain'),
+                       (r'^domains/(?P<dom_id>\d+)/newmailbox/$', 'newmailbox'),
+                       (r'^domains/(?P<dom_id>\d+)/editmailbox/(?P<mbox_id>\d+)/$', 'editmailbox'),
+                       (r'^domains/(?P<dom_id>\d+)/deletemailbox/(?P<mbox_id>\d+)/$', 'delmailbox'),
+                       (r'^domains/(?P<dom_id>\d+)/newalias/(?P<mbox_id>\d+)/$', 'newalias'),
+                       (r'^domains/(?P<dom_id>\d+)/editalias/(?P<alias_id>\d+)/$', 'editalias'),
+                       (r'^domains/(?P<dom_id>\d+)/$', 'mailboxes'),
+                       url(r'^domains/(?P<dom_id>\d+)/aliases/$', "aliases", name="full-aliases"),
+                       url(r'^domains/(?P<dom_id>\d+)/aliases/(?P<mbox_id>\d+)/$', "aliases", name="mbox-aliases"),
+                       (r'^domains/(?P<dom_id>\d+)/delalias/(?P<alias_id>\d+)/$', 'delalias'),
+                       )

admin/views.py

@@ -0,0 +1,222 @@
+from django.shortcuts import get_object_or_404, render_to_response
+from django.template.loader import render_to_string
+from django.template import RequestContext
+from django.http import HttpResponse, HttpResponseRedirect
+from django.utils import simplejson
+from django.core import serializers
+from django.core.urlresolvers import reverse
+from django.contrib.auth.decorators import login_required
+from django.contrib.auth.models import User
+from mailng import admin
+from mailng.admin.models import Domain, Mailbox, Alias
+from forms import MailboxForm, DomainForm, AliasForm
+
+def _ctx_ok(url):
+    return {"status" : "ok", "url" : url}
+
+def _ctx_ko(tpl, ctx):
+    return {"status" : "ko", "content" : render_to_string(tpl, ctx)}
+
+def _render(request, tpl, user_context):
+    return render_to_response(tpl, user_context, 
+                              context_instance=RequestContext(request))
+
+@login_required
+def domains(request):
+    domains = Domain.objects.all()
+    counters = {}
+    for dom in domains:
+        dom.mboxcounter = len(dom.mailbox_set.all())
+    return _render(request, 'admin/domains.html', {
+            "domains" : domains, "counters" : counters
+            })
+
+@login_required
+def newdomain(request):
+    if request.method == "POST":
+        form = DomainForm(request.POST)
+        error = None
+        if form.is_valid():
+            if Domain.objects.filter(name=request.POST["name"]):
+                error = "Domain with this name already defined"
+            else:
+                form.save()
+                ctx = _ctx_ok(reverse(admin.views.domains))
+                return HttpResponse(simplejson.dumps(ctx), mimetype="application/json")
+        ctx = _ctx_ko("admin/newdomain.html", {
+                "form" : form, "error" : error
+                })
+        return HttpResponse(simplejson.dumps(ctx), mimetype="application/json")
+
+    form = DomainForm()
+    return render_to_response('admin/newdomain.html', {
+            "form" : form
+            })
+@login_required   
+def editdomain(request, dom_id):
+    domain = Domain.objects.get(pk=dom_id)
+    if request.method == "POST":
+        form = DomainForm(request.POST, instance=domain)
+        if form.is_valid():
+            form.save()
+            ctx = _ctx_ok(reverse(admin.views.domains))
+            return HttpResponse(simplejson.dumps(ctx), mimetype="application/json")
+        ctx = _ctx_ko("admin/editdomain.html", {
+                "domain" : domain, "form" : form
+                })
+        return HttpResponse(simplejson.dumps(ctx), mimetype="application/json")
+
+    form = DomainForm(instance=domain) 
+    return render_to_response('admin/editdomain.html', {
+            "domain" : domain, "form" : form
+            })
+
+@login_required
+def deldomain(request, dom_id):
+    domain = Domain.objects.get(pk=dom_id)
+    domain.delete()
+    return HttpResponseRedirect('/mailng/admin/')
+
+@login_required
+def mailboxes(request, dom_id=None):
+    domain = Domain.objects.get(pk=dom_id)
+    mailboxes = Mailbox.objects.filter(domain=dom_id)
+    return _render(request, 'admin/mailboxes.html', {
+            "mailboxes" : mailboxes, "domain" : domain
+            })
+
+@login_required
+def newmailbox(request, dom_id=None):
+    domain = Domain.objects.get(pk=dom_id)
+    if request.method == "POST":
+        form = MailboxForm(request.POST)
+        error = None
+        if form.is_valid():
+            if Mailbox.objects.filter(address=request.POST["address"],
+                                      domain=dom_id):
+                error = "Mailbox with this address already exists"
+            else:
+                mb = form.save(commit=False)
+                user = User()
+                user.username = user.email = "%s@%s" % (mb.address, domain.name)
+                user.set_password(request.POST["password1"])
+                user.is_active = request.POST.has_key("enabled") \
+                    and True or False
+                fname, lname = mb.name.split()
+                user.first_name = fname
+
+                user.last_name = lname
+                user.save()
+                mb.user = user
+
+                mb.uid = mb.gid = 500
+                mb.domain = domain
+                mb.save()
+                ctx = _ctx_ok(reverse(admin.views.mailboxes, args=[domain.id]))
+                return HttpResponse(simplejson.dumps(ctx), 
+                                    mimetype="application/json")
+        ctx = _ctx_ko("admin/newmailbox.html", {
+                "form" : form, "domain" : domain, "error" : error
+                })
+        return HttpResponse(simplejson.dumps(ctx), mimetype="application/json")
+
+    form = MailboxForm()
+    return render_to_response('admin/newmailbox.html', {
+            "domain" : domain, "form" : form
+            })
+
+@login_required
+def editmailbox(request, dom_id, mbox_id=None):
+    mb = Mailbox.objects.get(pk=mbox_id)
+    if request.method == "POST":
+        form = MailboxForm(request.POST, instance=mb)
+        if form.is_valid():
+            if request.POST["enabled"] != mb.user.is_active \
+                    or request.POST["password1"] != mb.user.password:
+                mb.user.is_active = request.POST["enabled"]
+                mb.user.password = request.POST["password1"]
+                mb.user.save()
+            form.save()
+            ctx = _ctx_ok(reverse(admin.views.mailboxes, args=[dom_id]))
+        else:
+            ctx = _ctx_ko("admin/editmailbox.html", {
+                    "mbox" : mb, "form" : form
+                    })
+        json = simplejson.dumps(ctx)
+        return HttpResponse(json, mimetype="application/json")
+
+    form = MailboxForm(instance=mb)
+    form.fields['enabled'].initial = mb.user.is_active
+    form.fields['password1'].initial = mb.user.password
+    form.fields['password2'].initial = mb.user.password
+    return _render(request, 'admin/editmailbox.html', {
+            "form" : form, "mbox" : mb
+            })
+
+@login_required
+def delmailbox(request, dom_id, mbox_id=None):
+    mb = Mailbox.objects.get(pk=mbox_id)
+    mb.delete()
+    return HttpResponseRedirect(reverse(admin.views.mailboxes, 
+                                        args=[dom_id]))
+
+@login_required
+def aliases(request, dom_id=None, mbox_id=None):
+    domain = Domain.objects.get(pk=dom_id)
+    if not mbox_id:
+        mboxes = Mailbox.objects.filter(domain=dom_id)
+        aliases = []
+        for mb in mboxes:
+            aliases += Alias.objects.filter(mbox=mb.id)
+    else:
+        aliases = Alias.objects.filter(mbox=mbox_id)
+    return _render(request, 'admin/aliases.html', {
+            "aliases" : aliases, "domain" : domain
+            })
+
+@login_required
+def newalias(request, dom_id, mbox_id):
+    mbox = Mailbox.objects.get(pk=mbox_id)
+    if request.method == "POST":
+        form = AliasForm(request.POST)
+        if form.is_valid():
+            form.save()
+            ctx = _ctx_ok(reverse(admin.views.aliases, args=[mbox.domain.id]))
+        else:
+            ctx = _ctx_ko("admin/newalias.html", {
+                    "mbox" : mbox, "form" : form
+                    })
+        json = simplejson.dumps(ctx)
+        return HttpResponse(json, mimetype="application/json")
+
+    form = AliasForm({"mbox" : mbox_id}, domain=mbox.domain)
+    return render_to_response('admin/newalias.html', {
+            "mbox" : mbox, "form" : form, "noerrors" : True
+            })
+
+@login_required
+def editalias(request, dom_id, alias_id):
+    alias = Alias.objects.get(pk=alias_id)
+    if request.method == "POST":
+        form = AliasForm(request.POST, instance=alias)
+        if form.is_valid():
+            form.save()
+            ctx = _ctx_ok(reverse(admin.views.aliases, args=[dom_id]))
+        else:
+            ctx = _ctx_ko("admin/editalias.html", {
+                    "alias" : alias, "form" : form
+                    })
+        json = simplejson.dumps(ctx)
+        return HttpResponse(json, mimetype="application/json")
+    form = AliasForm(instance=alias)
+    return _render(request, 'admin/editalias.html', {
+            "form" : form, "alias" : alias
+            })
+
+@login_required
+def delalias(request, dom_id, alias_id):
+    alias = Alias.objects.get(pk=alias_id)
+    alias.delete()
+    return HttpResponseRedirect(reverse(admin.views.aliases, 
+                                        args=[dom_id]))
+