def preferences(request):
if request.method == "POST":
for formdef in parameters.get_user_forms(request.user, request.POST)():
form = formdef["form"]
if form.is_valid():
form.save()
continue
return ajax_simple_response({
"status": "ko",
"prefix": form.app,
"errors": form.errors
})
return ajax_simple_response({
"status": "ok",
"respmsg": _("Preferences saved")
})
return ajax_simple_response({
"status":
"ok",
"content":
_render_to_string(request, "core/user_preferences.html",
{"forms": parameters.get_user_forms(request.user)})
})
def profile(request, tplname='core/user_profile.html'):
update_password = True
if True in events.raiseQueryEvent("PasswordChange", request.user):
update_password = False
if request.method == "POST":
form = ProfileForm(update_password,
request.POST,
instance=request.user)
if form.is_valid():
form.save()
if update_password and form.cleaned_data["confirmation"] != "":
request.session["password"] = encrypt(
form.cleaned_data["confirmation"])
return ajax_simple_response(
dict(status="ok", respmsg=_("Profile updated")))
return ajax_simple_response({"status": "ko", "errors": form.errors})
form = ProfileForm(update_password, instance=request.user)
return ajax_simple_response({
"status":
"ok",
"content":
_render_to_string(request, tplname, {"form": form})
})
def send_virus(request):
status, error = sendmail_fromfile("*****@*****.**", request.user.username,
os.path.join(settings.MODOBOA_DIR,
"tmp/virus.msg"))
if status:
return ajax_simple_response(dict(status="ok", respmsg=_("Message sent")))
return ajax_simple_response(dict(status="ko", respmsg=error))
def profile(request, tplname='core/user_profile.html'):
update_password = True
if True in events.raiseQueryEvent("PasswordChange", request.user):
update_password = False
if request.method == "POST":
form = ProfileForm(
update_password, request.POST, instance=request.user
)
if form.is_valid():
form.save()
if update_password and form.cleaned_data["confirmation"] != "":
request.session["password"] = encrypt(form.cleaned_data["confirmation"])
return ajax_simple_response(dict(
status="ok", respmsg=_("Profile updated")
))
return ajax_simple_response({
"status": "ko",
"errors": form.errors
})
form = ProfileForm(update_password, instance=request.user)
return ajax_simple_response({
"status": "ok",
"content": _render_to_string(request, tplname, {
"form": form
})
})
def saveparameters(request):
for formdef in parameters.get_admin_forms(request.POST):
form = formdef["form"]
if form.is_valid():
form.save()
form.to_django_settings()
continue
return ajax_simple_response({"status": "ko", "prefix": form.app, "errors": form.errors})
return ajax_simple_response(dict(status="ok", respmsg=_("Parameters saved")))
def newaccount(request, tplname='common/wizard_forms.html'):
def create_account(steps):
"""Account creation callback
Called when all creation steps have been validated.
:param steps: the steps data
"""
genform = steps[0]["form"]
genform.is_valid()
account = genform.save()
account.post_create(request.user)
mailform = steps[1]["form"]
mailform.save(request.user, account)
ctx = dict(
title=_("New account"),
action=reverse(newaccount),
formid="newaccount_form",
submit_label=_("Create")
)
cwizard = CreationWizard(create_account)
cwizard.add_step(AccountFormGeneral, _("General"),
[dict(classes="btn-inverse next", label=_("Next"))],
new_args=[request.user])
cwizard.add_step(AccountFormMail, _("Mail"),
[dict(classes="btn-primary submit", label=_("Create")),
dict(classes="btn-inverse prev", label=_("Previous"))],
formtpl="admin/mailform.html")
if request.method == "POST":
retcode, data = cwizard.validate_step(request)
if retcode == -1:
raise AdminError(data)
if retcode == 1:
return ajax_simple_response(dict(
status="ok", title=cwizard.get_title(data + 1), stepid=data
))
if retcode == 2:
return ajax_simple_response(dict(
status="ok", respmsg=_("Account created")
))
from modoboa.lib.templatetags.libextras import render_form
return ajax_simple_response(dict(
status="ko", stepid=data,
form=render_form(cwizard.steps[data]["form"])
))
cwizard.create_forms()
ctx.update(steps=cwizard.steps)
ctx.update(subtitle="1. %s" % cwizard.steps[0]['title'])
return render(request, tplname, ctx)
def newdomain(request, tplname="common/wizard_forms.html"):
events.raiseEvent("CanCreate", request.user, "domains")
def newdomain_cb(steps):
genform = steps[0]["form"]
genform.is_valid()
domain = genform.save(request.user)
domain.post_create(request.user)
steps[1]["form"].save(request.user, domain)
commonctx = {
"title": _("New domain"),
"action_label": _("Create"),
"action_classes": "submit",
"action": reverse(newdomain),
"formid": "domform"
}
cwizard = CreationWizard(newdomain_cb)
cwizard.add_step(DomainFormGeneral,
_("General"),
[dict(classes="btn-inverse next", label=_("Next"))],
formtpl="admin/domain_general_form.html")
cwizard.add_step(DomainFormOptions,
_("Options"), [
dict(classes="btn-primary submit", label=_("Create")),
dict(classes="btn-inverse prev", label=_("Previous"))
],
formtpl="admin/domain_options_form.html")
if request.method == "POST":
retcode, data = cwizard.validate_step(request)
if retcode == -1:
raise AdminError(data)
if retcode == 1:
return ajax_simple_response(
dict(status="ok",
title=cwizard.get_title(data + 1),
stepid=data))
if retcode == 2:
return ajax_simple_response(
dict(status="ok", respmsg=_("Domain created")))
from modoboa.lib.templatetags.libextras import render_form
return ajax_simple_response(
dict(status="ko",
stepid=data,
form=render_form(cwizard.steps[data]["form"])))
cwizard.create_forms()
commonctx.update(steps=cwizard.steps)
commonctx.update(subtitle="1. %s" % cwizard.steps[0]['title'])
return render(request, tplname, commonctx)
def saveparameters(request):
for formdef in parameters.get_admin_forms(request.POST):
form = formdef["form"]
if form.is_valid():
form.save()
form.to_django_settings()
continue
return ajax_simple_response({
"status": "ko",
"prefix": form.app,
"errors": form.errors
})
return ajax_simple_response(
dict(status="ok", respmsg=_("Parameters saved")))
def graphs(request):
gset = request.GET.get("gset", None)
gsets = events.raiseDictEvent("GetGraphSets")
if not gset in gsets:
raise ModoboaException(_("Unknown graphic set"))
searchq = request.GET.get("searchquery", None)
period = request.GET.get("period", "day")
tplvars = dict(graphs=[], period=period)
if searchq in [None, "global"]:
if not request.user.is_superuser:
if not Domain.objects.get_for_admin(request.user).count():
return ajax_simple_response({"status": "ok"})
tplvars.update(
domain=Domain.objects.get_for_admin(request.user)[0].name
)
else:
tplvars.update(domain="global")
else:
domain = Domain.objects.filter(name__contains=searchq)
if domain.count() != 1:
return ajax_simple_response({"status": "ok"})
if not request.user.can_access(domain[0]):
raise PermDeniedException
tplvars.update(domain=domain[0].name)
if period == "custom":
if not "start" in request.GET or not "end" in request.GET:
raise ModoboaException(_("Bad custom period"))
start = request.GET["start"]
end = request.GET["end"]
G = Grapher()
period_name = "%s_%s" % (start.replace('-', ''), end.replace('-', ''))
for tpl in gsets[gset].get_graphs():
tplvars['graphs'].append(tpl.display_name)
G.process(
tplvars["domain"], period_name, str2Time(*start.split('-')),
str2Time(*end.split('-')), tpl
)
tplvars["period_name"] = period_name
tplvars["start"] = start
tplvars["end"] = end
else:
tplvars['graphs'] = gsets[gset].get_graph_names()
return ajax_simple_response(dict(
status="ok",
content=_render_to_string(request, "stats/graphs.html", tplvars)
))
def forward(request, tplname='admin/forward.html'):
try:
mb = request.user.mailbox_set.all()[0]
except IndexError:
raise ModoboaException(
_("You need a mailbox in order to define a forward"))
try:
al = Alias.objects.get(address=mb.address, domain__name=mb.domain.name)
except Alias.DoesNotExist:
al = None
if request.method == "POST":
form = ForwardForm(request.POST)
error = None
if form.is_valid():
try:
if al is None:
al = Alias()
al.address = mb.address
al.domain = mb.domain
al.enabled = mb.user.is_active
intdests = []
if form.cleaned_data["keepcopies"]:
intdests += [mb]
form.parse_dest()
al.save(int_rcpts=intdests, ext_rcpts=form.dests)
if request.user.group != "SimpleUsers":
al.post_create(request.user)
return ajax_response(request, respmsg=_("Forward updated"))
except BadDestination, e:
error = str(e)
return ajax_simple_response(
dict(status="ko", errors=form.errors, respmsg=error))
def newfolder(request, tplname="webmail/folder.html"):
mbc = IMAPconnector(user=request.user.username,
password=request.session["password"])
ctx = {
"title": _("Create a new mailbox"),
"formid": "mboxform",
"action": reverse(newfolder),
"action_label": _("Create"),
"action_classes": "submit",
"withunseen": False,
"selectonly": True,
"mboxes": mbc.getmboxes(request.user),
"hdelimiter": mbc.hdelimiter
}
if request.method == "POST":
form = FolderForm(request.POST)
if form.is_valid():
pf = request.POST.get("parent_folder", None)
mbc.create_folder(form.cleaned_data["name"], pf)
return ajax_simple_response(
dict(status="ok",
respmsg=_("Mailbox created"),
newmb=form.cleaned_data["name"],
parent=pf))
ctx["form"] = form
ctx["selected"] = None
return ajax_response(request, status="ko", template=tplname, **ctx)
ctx["form"] = FolderForm()
ctx["selected"] = None
return render(request, tplname, ctx)
def list_quotas(request, tplname="admin/quotas.html"):
from modoboa.lib.dbutils import db_type
sort_order, sort_dir = get_sort_order(request.GET, "address")
mboxes = Mailbox.objects.get_for_admin(
request.user, request.GET.get("searchquery", None))
mboxes = mboxes.exclude(quota=0)
if sort_order in ["address", "quota", "quota_value__bytes"]:
mboxes = mboxes.order_by("%s%s" % (sort_dir, sort_order))
elif sort_order == "quota_usage":
if db_type() == "postgres":
select = '(admin_quota.bytes::float / (CAST(admin_mailbox.quota AS BIGINT) * 1048576)) * 100'
else:
select = 'admin_quota.bytes / (admin_mailbox.quota * 1048576) * 100'
mboxes = mboxes.extra(select={'quota_usage': select},
where=["admin_quota.mbox_id=admin_mailbox.id"],
tables=["admin_quota"],
order_by=["%s%s" % (sort_dir, sort_order)])
else:
raise AdminError(_("Invalid request"))
page = get_listing_page(mboxes, request.GET.get("page", 1))
return ajax_simple_response({
"status":
"ok",
"page":
page.number,
"paginbar":
pagination_bar(page),
"table":
_render_to_string(request, tplname, {"mboxes": page})
})
def _identities(request):
filters = dict((fname, request.GET.get(fname, None))
for fname in ['searchquery', 'idtfilter', 'grpfilter'])
request.session['identities_filters'] = filters
idents_list = get_identities(request.user, **filters)
sort_order, sort_dir = get_sort_order(request.GET, "identity",
["identity", "name_or_rcpt", "tags"])
if sort_order in ["identity", "name_or_rcpt"]:
objects = sorted(idents_list,
key=lambda o: getattr(o, sort_order),
reverse=sort_dir == '-')
else:
objects = sorted(idents_list,
key=lambda o: o.tags[0],
reverse=sort_dir == '-')
page = get_listing_page(objects, request.GET.get("page", 1))
return ajax_simple_response({
"table":
_render_to_string(request, "admin/identities_table.html", {
"identities": page.object_list,
"tableid": "objects_table"
}),
"handle_mailboxes":
parameters.get_admin("HANDLE_MAILBOXES", raise_error=False),
"page":
page.number,
"paginbar":
pagination_bar(page)
})
def newfolder(request, tplname="webmail/folder.html"):
mbc = IMAPconnector(user=request.user.username,
password=request.session["password"])
ctx = {"title": _("Create a new mailbox"),
"formid": "mboxform",
"action": reverse(newfolder),
"action_label": _("Create"),
"action_classes": "submit",
"withunseen": False,
"selectonly": True,
"mboxes": mbc.getmboxes(request.user),
"hdelimiter": mbc.hdelimiter}
if request.method == "POST":
form = FolderForm(request.POST)
if form.is_valid():
pf = request.POST.get("parent_folder", None)
mbc.create_folder(form.cleaned_data["name"], pf)
return ajax_simple_response(dict(
status="ok", respmsg=_("Mailbox created"), newmb=form.cleaned_data["name"], parent=pf
))
ctx["form"] = form
ctx["selected"] = None
return ajax_response(request, status="ko", template=tplname, **ctx)
ctx["form"] = FolderForm()
ctx["selected"] = None
return _render(request, tplname, ctx)
def delaccount(request, accountid):
keepdir = True if request.POST.get("keepdir", "false") == "true" else False
User.objects.get(pk=accountid).delete(request.user, keep_mb_dir=keepdir)
msg = ungettext("Account deleted", "Accounts deleted", 1)
return ajax_simple_response({"status": "ok", "respmsg": msg})
def delaccount(request, accountid):
keepdir = True if request.POST.get("keepdir", "false") == "true" else False
User.objects.get(pk=accountid).delete(request.user, keepdir)
msg = ungettext("Account deleted", "Accounts deleted", 1)
return ajax_simple_response({"status": "ok", "respmsg": msg})
def list_quotas(request, tplname="admin/quotas.html"):
from modoboa.lib.dbutils import db_type
sort_order, sort_dir = get_sort_order(request.GET, "address")
mboxes = request.user.get_mailboxes(request.GET.get("searchquery", None))
mboxes = mboxes.exclude(quota=0)
if sort_order in ["address", "quota", "quota_value__bytes"]:
mboxes = mboxes.order_by("%s%s" % (sort_dir, sort_order))
elif sort_order == "quota_usage":
if db_type() == "postgres":
select = '(admin_quota.bytes::float / (CAST(admin_mailbox.quota AS BIGINT) * 1048576)) * 100'
else:
select = 'admin_quota.bytes / (admin_mailbox.quota * 1048576) * 100'
mboxes = mboxes.extra(
select={'quota_usage': select},
where=["admin_quota.mbox_id=admin_mailbox.id"],
tables=["admin_quota"],
order_by=["%s%s" % (sort_dir, sort_order)]
)
else:
raise AdminError(_("Invalid request"))
page = get_listing_page(mboxes, request.GET.get("page", 1))
return ajax_simple_response({
"status": "ok",
"page": page.number,
"paginbar": pagination_bar(page),
"table": _render_to_string(request, tplname, {
"mboxes": page
})
})
def empty(request, name):
if name != parameters.get_user(request.user, "TRASH_FOLDER"):
raise WebmailError(_("Invalid request"))
get_imapconnector(request).empty(name)
content = "<div class='alert alert-info'>%s</div>" % _("Empty mailbox")
return ajax_simple_response(
dict(status="ok", listing=content, mailbox=name))
def remove_filters_set(request, name):
sc = SieveClient(user=request.user.username,
password=request.session["password"])
try:
sc.deletescript(name)
except SieveClientError, e:
return ajax_simple_response(dict(status="ko", respmsg=str(e)))
def _validate_alias(request,
form,
successmsg,
tplname,
commonctx,
callback=None):
"""Alias validation
Common function shared between creation and modification actions.
"""
error = None
if form.is_valid():
form.set_recipients()
try:
alias = form.save()
except IntegrityError:
raise AdminError(_("Alias with this name already exists"))
if callback:
callback(request.user, alias)
return ajax_simple_response({"status": "ok", "respmsg": successmsg})
if "targets" in request.POST:
targets = request.POST.getlist("targets")
commonctx["targets"] = targets[:-1]
commonctx["form"] = form
commonctx["error"] = error
return ajax_response(request, status="ko", template=tplname, **commonctx)
def new_filters_set(request, tplname="common/generic_modal_form.html"):
ctx = {"title": _("Create a new filters set"),
"formid": "newfiltersset",
"action_label": _("Create"),
"action_classes": "submit",
"action": reverse(new_filters_set),
"withmenu": False,
"withunseen": False}
if request.method == "POST":
form = FiltersSetForm(request.POST)
error = None
if form.is_valid():
sc = SieveClient(user=request.user.username,
password=request.session["password"])
try:
sc.pushscript(form.cleaned_data["name"], "# Empty script",
form.cleaned_data["active"])
except SieveClientError, e:
error = str(e)
else:
return ajax_simple_response({
"status": "ok",
"url": form.cleaned_data["name"],
"active": form.cleaned_data["active"],
"respmsg": _("Filters set created")
})
ctx["form"] = form
ctx["error"] = error
return ajax_response(request, status="ko", template=tplname, **ctx)
def newdomain(request, tplname="common/wizard_forms.html"):
events.raiseEvent("CanCreate", request.user, "domains")
def newdomain_cb(steps):
genform = steps[0]["form"]
genform.is_valid()
domain = genform.save(request.user)
domain.post_create(request.user)
steps[1]["form"].save(request.user, domain)
commonctx = {"title": _("New domain"),
"action_label": _("Create"),
"action_classes": "submit",
"action": reverse(newdomain),
"formid": "domform"}
cwizard = CreationWizard(newdomain_cb)
cwizard.add_step(DomainFormGeneral, _("General"),
[dict(classes="btn-inverse next", label=_("Next"))],
formtpl="admin/domain_general_form.html")
cwizard.add_step(DomainFormOptions, _("Options"),
[dict(classes="btn-primary submit", label=_("Create")),
dict(classes="btn-inverse prev", label=_("Previous"))],
formtpl="admin/domain_options_form.html")
if request.method == "POST":
retcode, data = cwizard.validate_step(request)
if retcode == -1:
raise AdminError(data)
if retcode == 1:
return ajax_simple_response(dict(
status="ok", title=cwizard.get_title(data + 1), stepid=data
))
if retcode == 2:
return ajax_simple_response(
dict(status="ok", respmsg=_("Domain created"))
)
from modoboa.lib.templatetags.libextras import render_form
return ajax_simple_response(dict(
status="ko", stepid=data,
form=render_form(cwizard.steps[data]["form"])
))
cwizard.create_forms()
commonctx.update(steps=cwizard.steps)
commonctx.update(subtitle="1. %s" % cwizard.steps[0]['title'])
return render(request, tplname, commonctx)
def empty(request, name):
if name != parameters.get_user(request.user, "TRASH_FOLDER"):
raise WebmailError(_("Invalid request"))
get_imapconnector(request).empty(name)
content = "<div class='alert alert-info'>%s</div>" % _("Empty mailbox")
return ajax_simple_response(dict(
status="ok", listing=content, mailbox=name
))
def viewparameters(request, tplname='admin/parameters.html'):
return ajax_simple_response({
"status": "ok",
"left_selection": "parameters",
"content": _render_to_string(request, tplname, {
"forms": parameters.get_admin_forms
})
})
def delaccount(request):
selection = request.GET["selection"].split(",")
keepdir = True if request.GET.get("keepdir", "false") == "true" else False
for account in User.objects.filter(id__in=selection):
account.delete(request.user, keepdir)
msg = ungettext("Account deleted", "Accounts deleted", len(selection))
return ajax_simple_response({"status": "ok", "respmsg": msg})
def move(request):
for arg in ["msgset", "to"]:
if not arg in request.GET:
raise WebmailError(_("Invalid request"))
mbc = get_imapconnector(request)
mbc.move(request.GET["msgset"], request.session["mbox"], request.GET["to"])
resp = listmailbox(request, request.session["mbox"], update_session=False)
resp.update(status="ok")
return ajax_simple_response(resp)
def move(request):
for arg in ["msgset", "to"]:
if not arg in request.GET:
raise WebmailError(_("Invalid request"))
mbc = get_imapconnector(request)
mbc.move(request.GET["msgset"], request.session["mbox"], request.GET["to"])
resp = listmailbox(request, request.session["mbox"], update_session=False)
resp.update(status="ok")
return ajax_simple_response(resp)
def delete(request):
mbox = request.GET.get("mbox", None)
mailid = request.GET.get("mailid", None)
if mbox is None or mailid is None:
raise WebmailError(_("Invalid request"))
mbc = get_imapconnector(request)
mbc.move(mailid, mbox, parameters.get_user(request.user, "TRASH_FOLDER"))
resp = dict(status="ok")
return ajax_simple_response(resp)
def delete(request):
mbox = request.GET.get("mbox", None)
mailid = request.GET.get("mailid", None)
if mbox is None or mailid is None:
raise WebmailError(_("Invalid request"))
mbc = get_imapconnector(request)
mbc.move(mailid, mbox, parameters.get_user(request.user, "TRASH_FOLDER"))
resp = dict(status="ok")
return ajax_simple_response(resp)
def _del_alias(request, msg, msgs):
selection = request.GET["selection"].split(",")
for alid in selection:
alias = Alias.objects.get(pk=alid)
if not request.user.can_access(alias):
raise PermDeniedException
alias.delete()
msg = ungettext(msg, msgs, len(selection))
return ajax_simple_response({"status": "ok", "respmsg": msg})
def _del_alias(request, msg, msgs):
selection = request.GET["selection"].split(",")
for alid in selection:
alias = Alias.objects.get(pk=alid)
if not request.user.can_access(alias):
raise PermDeniedException
alias.delete()
msg = ungettext(msg, msgs, len(selection))
return ajax_simple_response({"status": "ok", "respmsg": msg})
def check_unseen_messages(request):
mboxes = request.GET.get("mboxes", None)
if not mboxes:
raise WebmailError(_("Invalid request"))
mboxes = mboxes.split(",")
counters = dict()
imapc = get_imapconnector(request)
for mb in mboxes:
counters[mb] = imapc.unseen_messages(mb)
return ajax_simple_response(dict(status="ok", counters=counters))
def check_unseen_messages(request):
mboxes = request.GET.get("mboxes", None)
if not mboxes:
raise WebmailError(_("Invalid request"))
mboxes = mboxes.split(",")
counters = dict()
imapc = get_imapconnector(request)
for mb in mboxes:
counters[mb] = imapc.unseen_messages(mb)
return ajax_simple_response(dict(status="ok", counters=counters))
def viewparameters(request, tplname='core/parameters.html'):
return ajax_simple_response({
"status":
"ok",
"left_selection":
"parameters",
"content":
_render_to_string(request, tplname,
{"forms": parameters.get_admin_forms})
})
def delete_selfservice(request, mail_id):
rcpt = request.GET.get("rcpt", None)
if rcpt is None:
raise ModoboaException(_("Invalid request"))
try:
msgrcpt = get_wrapper().get_recipient_message(rcpt, mail_id)
msgrcpt.rs = 'D'
msgrcpt.save()
except Msgrcpt.DoesNotExist:
raise ModoboaException(_("Invalid request"))
return ajax_simple_response(dict(status="ok", respmsg=_("Message deleted")))
def send_spam(request):
status, error = sendmail_simple("*****@*****.**", request.user.username, content="""
This is the GTUBE, the
Generic
Test for
Unsolicited
Bulk
Email
If your spam filter supports it, the GTUBE provides a test by which you
can verify that the filter is installed correctly and is detecting incoming
spam. You can send yourself a test mail containing the following string of
characters (in upper case and with no white spaces and line breaks):
XJS*C4JDBQADN1.NSBN3*2IDNEN*GTUBE-STANDARD-ANTI-UBE-TEST-EMAIL*C.34X
You should send this test mail from an account outside of your network.
""")
if status:
return ajax_simple_response(dict(status="ok", respmsg=_("Message sent")))
return ajax_simple_response(dict(status="ko", respmsg=error))
def preferences(request):
if request.method == "POST":
for formdef in parameters.get_user_forms(request.user, request.POST)():
form = formdef["form"]
if form.is_valid():
form.save()
continue
return ajax_simple_response({
"status": "ko", "prefix": form.app, "errors": form.errors
})
return ajax_simple_response({
"status": "ok", "respmsg": _("Preferences saved")
})
return ajax_simple_response({
"status": "ok",
"content": _render_to_string(request, "core/user_preferences.html", {
"forms": parameters.get_user_forms(request.user)
})
})
def delete_selfservice(request, mail_id):
rcpt = request.GET.get("rcpt", None)
if rcpt is None:
raise ModoboaException(_("Invalid request"))
try:
msgrcpt = get_wrapper().get_recipient_message(rcpt, mail_id)
msgrcpt.rs = 'D'
msgrcpt.save()
except Msgrcpt.DoesNotExist:
raise ModoboaException(_("Invalid request"))
return ajax_simple_response(dict(status="ok",
respmsg=_("Message deleted")))
def autoreply(request, tplname="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(request.POST, instance=arm)
else:
form = ARmessageForm(request.POST)
if form.is_valid():
arm = form.save(commit=False)
arm.untildate = form.cleaned_data["untildate"]
arm.mbox = mb
arm.save()
return ajax_simple_response(
dict(status="ok",
respmsg=_("Auto reply message updated successfully.")))
return ajax_simple_response({
"status": "ko",
"errors": form.errors,
"onload_cb": "autoreply_cb"
})
form = ARmessageForm(instance=arm)
if arm is not None:
form.fields['untildate'].initial = arm.untildate
else:
form.fields['untildate'].initial = date.today()
return ajax_simple_response({
"status":
"ok",
"content":
_render_to_string(request, tplname, {"form": form}),
"onload_cb":
"autoreply_cb"
})
def editdomain(request, dom_id, tplname="admin/editdomainform.html"):
domain = Domain.objects.get(pk=dom_id)
if not request.user.can_access(domain):
raise PermDeniedException
domadmins = filter(
lambda u: request.user.can_access(u) and not u.is_superuser,
domain.admins
)
if not request.user.is_superuser:
domadmins = filter(lambda u: u.group == "DomainAdmins", domadmins)
instances = dict(general=domain)
events.raiseEvent("FillDomainInstances", request.user, domain, instances)
commonctx = {"title": domain.name,
"action_label": _("Update"),
"action_classes": "submit",
"action": reverse(editdomain, args=[dom_id]),
"formid": "domform",
"domain": domain}
if request.method == "POST":
error = None
domain.oldname = domain.name
form = DomainForm(request.user, request.POST, instances=instances)
if form.is_valid():
try:
form.save(request.user)
except AdminError, e:
error = str(e)
else:
events.raiseEvent("DomainModified", domain)
return ajax_simple_response({"status": "ok", "respmsg": _("Domain modified")})
commonctx["tabs"] = form
return ajax_simple_response({
"status": "ko", "respmsg": error,
"content": _render_to_string(request, tplname, commonctx)
})
def delete(request):
mbox = request.GET.get("mbox", None)
selection = request.GET.getlist("selection[]", None)
if mbox is None or selection is None:
raise WebmailError(_("Invalid request"))
selection = [item for item in selection if item.isdigit()]
mbc = get_imapconnector(request)
mbc.move(",".join(selection), mbox, parameters.get_user(request.user, "TRASH_FOLDER"))
count = len(selection)
message = ungettext("%(count)d message deleted",
"%(count)d messages deleted",
count) % {"count": count}
resp = dict(status="ok", respmsg=message)
return ajax_simple_response(resp)
def remove_permission(request):
domid = request.GET.get("domid", None)
daid = request.GET.get("daid", None)
if domid is None or daid is None:
raise AdminError(_("Invalid request"))
try:
account = User.objects.get(pk=daid)
domain = Domain.objects.get(pk=domid)
except (User.DoesNotExist, Domain.DoesNotExist):
raise AdminError(_("Invalid request"))
if not request.user.can_access(account) or not request.user.can_access(domain):
raise PermDeniedException
domain.remove_admin(account)
return ajax_simple_response(dict(status="ok"))
def autoreply(request, tplname="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(request.POST, instance=arm)
else:
form = ARmessageForm(request.POST)
if form.is_valid():
arm = form.save(commit=False)
arm.untildate = form.cleaned_data["untildate"]
arm.mbox = mb
arm.save()
return ajax_simple_response(dict(
status="ok",
respmsg=_("Auto reply message updated successfully.")
))
return ajax_simple_response({
"status": "ko",
"errors": form.errors,
"onload_cb": "autoreply_cb"
})
form = ARmessageForm(instance=arm)
if arm is not None:
form.fields['untildate'].initial = arm.untildate
else:
form.fields['untildate'].initial = date.today()
return ajax_simple_response({
"status": "ok",
"content": _render_to_string(request, tplname, {"form": form}),
"onload_cb": "autoreply_cb"
})
def editfolder(request, tplname="webmail/folder.html"):
mbc = IMAPconnector(user=request.user.username,
password=request.session["password"])
ctx = {
"title": _("Edit mailbox"),
"formid": "mboxform",
"action": reverse(editfolder),
"action_label": _("Update"),
"action_classes": "submit",
"withunseen": False,
"selectonly": True,
"hdelimiter": mbc.hdelimiter
}
if request.method == "POST":
form = FolderForm(request.POST)
if form.is_valid():
pf = request.POST.get("parent_folder", None)
ctx["selected"] = pf
oldname, oldparent = separate_mailbox(request.POST["oldname"],
sep=mbc.hdelimiter)
res = dict(status="ok", respmsg=_("Mailbox updated"))
if form.cleaned_data["name"] != oldname \
or (pf != oldparent):
newname = form.cleaned_data["name"] if pf is None \
else "%s.%s" % (pf, form.cleaned_data["name"])
mbc.rename_folder(request.POST["oldname"], newname)
res["oldmb"] = oldname
res["newmb"] = form.cleaned_data["name"]
res["oldparent"] = oldparent
res["newparent"] = pf
if "mbox" in request.session:
del request.session["mbox"]
return ajax_simple_response(res)
ctx["mboxes"] = mbc.getmboxes(request.user)
ctx["form"] = form
return ajax_response(request, status="ko", template=tplname, **ctx)
name = request.GET.get("name", None)
if name is None:
raise WebmailError(_("Invalid request"))
shortname, parent = separate_mailbox(name, sep=mbc.hdelimiter)
ctx["mboxes"] = mbc.getmboxes(request.user, until_mailbox=parent)
ctx["form"] = FolderForm()
ctx["form"].fields["oldname"].initial = name
ctx["form"].fields["name"].initial = shortname
ctx["selected"] = parent
return render(request, tplname, ctx)
def logs(request, tplname="core/logs.html"):
from modoboa.lib.templatetags.lib_tags import pagination_bar
sort_order, sort_dir = get_sort_order(
request.GET, "date_created", allowed_values=["date_created", "level", "logger", "message"]
)
page = get_listing_page(Log.objects.all().order_by("%s%s" % (sort_dir, sort_order)), request.GET.get("page", 1))
return ajax_simple_response(
{
"status": "ok",
"content": render_to_string(tplname, {"logs": page.object_list}),
"page": page.number,
"paginbar": pagination_bar(page),
}
)
def remove_permission(request):
domid = request.GET.get("domid", None)
daid = request.GET.get("daid", None)
if domid is None or daid is None:
raise AdminError(_("Invalid request"))
try:
account = User.objects.get(pk=daid)
domain = Domain.objects.get(pk=domid)
except (User.DoesNotExist, Domain.DoesNotExist):
raise AdminError(_("Invalid request"))
if not request.user.can_access(account) or not request.user.can_access(
domain):
raise PermDeniedException
domain.remove_admin(account)
return ajax_simple_response({"status": "ok"})
def mark(request, name):
status = request.GET.get("status", None)
ids = request.GET.get("ids", None)
if status is None or ids is None:
raise WebmailError(_("Invalid request"))
imapc = get_imapconnector(request)
try:
getattr(imapc, "mark_messages_%s" % status)(name, ids)
except AttributeError:
raise WebmailError(_("Unknown action"))
return ajax_simple_response(
dict(status="ok", action=status, mbox=name,
unseen=imapc.unseen_messages(name))
)
def saveextensions(request):
actived_exts = Extension.objects.filter(enabled=True)
found = []
for k in request.POST.keys():
if k.startswith("select_"):
parts = k.split("_", 1)
dbext = Extension.objects.get(name=parts[1])
if not dbext in actived_exts:
dbext.on()
else:
found += [dbext]
for ext in actived_exts:
if not ext in found:
ext.off()
return ajax_simple_response(dict(status="ok", respmsg=_("Modifications applied.")))
def mark(request, name):
status = request.GET.get("status", None)
ids = request.GET.get("ids", None)
if status is None or ids is None:
raise WebmailError(_("Invalid request"))
imapc = get_imapconnector(request)
try:
getattr(imapc, "mark_messages_%s" % status)(name, ids)
except AttributeError:
raise WebmailError(_("Unknown action"))
return ajax_simple_response(
dict(status="ok",
action=status,
mbox=name,
unseen=imapc.unseen_messages(name)))
def delete(request):
mbox = request.GET.get("mbox", None)
selection = request.GET.getlist("selection[]", None)
if mbox is None or selection is None:
raise WebmailError(_("Invalid request"))
selection = [item for item in selection if item.isdigit()]
mbc = get_imapconnector(request)
mbc.move(",".join(selection), mbox,
parameters.get_user(request.user, "TRASH_FOLDER"))
count = len(selection)
message = ungettext("%(count)d message deleted",
"%(count)d messages deleted", count) % {
"count": count
}
resp = dict(status="ok", respmsg=message)
return ajax_simple_response(resp)
def deldomain(request, dom_id):
keepdir = True if request.POST.get("keepdir", "false") == "true" else False
try:
mb = Mailbox.objects.get(user__id=request.user.id)
except Mailbox.DoesNotExist:
mb = None
dom = Domain.objects.get(pk=dom_id)
if not request.user.can_access(dom):
raise PermDeniedException
if mb and mb.domain == dom:
raise AdminError(_("You can't delete your own domain"))
dom.delete(request.user, keepdir)
msg = ungettext("Domain deleted", "Domains deleted", 1)
return ajax_simple_response({"status": "ok", "respmsg": msg})
def deldomain(request, dom_id):
keepdir = True if request.POST.get("keepdir", "false") == "true" else False
try:
mb = Mailbox.objects.get(user__id=request.user.id)
except Mailbox.DoesNotExist:
mb = None
dom = Domain.objects.get(pk=dom_id)
if not request.user.can_access(dom):
raise PermDeniedException
if mb and mb.domain == dom:
raise AdminError(_("You can't delete your own domain"))
dom.delete(request.user, keepdir)
msg = ungettext("Domain deleted", "Domains deleted", 1)
return ajax_simple_response({"status": "ok", "respmsg": msg})
def saveextensions(request):
actived_exts = Extension.objects.filter(enabled=True)
found = []
for k in request.POST.keys():
if k.startswith("select_"):
parts = k.split("_", 1)
dbext = Extension.objects.get(name=parts[1])
if not dbext in actived_exts:
dbext.on()
else:
found += [dbext]
for ext in actived_exts:
if not ext in found:
ext.off()
return ajax_simple_response(
dict(status="ok", respmsg=_("Modifications applied.")))
def logs(request, tplname="admin/logs.html"):
sort_order, sort_dir = get_sort_order(
request.GET, "date_created",
allowed_values=['date_created', 'level', 'logger', 'message']
)
page = get_listing_page(
Log.objects.all().order_by("%s%s" % (sort_dir, sort_order)),
request.GET.get("page", 1)
)
return ajax_simple_response({
"status": "ok",
"content": render_to_string(tplname, {
"logs": page.object_list,
}),
"page": page.number,
"paginbar": pagination_bar(page),
})
def editdomain(request, dom_id, tplname="admin/editdomainform.html"):
domain = Domain.objects.get(pk=dom_id)
if not request.user.can_access(domain):
raise PermDeniedException
domadmins = filter(
lambda u: request.user.can_access(u) and not u.is_superuser,
domain.admins)
if not request.user.is_superuser:
domadmins = filter(lambda u: u.group == "DomainAdmins", domadmins)
instances = dict(general=domain)
events.raiseEvent("FillDomainInstances", request.user, domain, instances)
commonctx = {
"title": domain.name,
"action_label": _("Update"),
"action_classes": "submit",
"action": reverse(editdomain, args=[dom_id]),
"formid": "domform",
"domain": domain
}
if request.method == "POST":
error = None
domain.oldname = domain.name
form = DomainForm(request.user, request.POST, instances=instances)
if form.is_valid():
try:
form.save(request.user)
except AdminError, e:
error = str(e)
else:
events.raiseEvent("DomainModified", domain)
return ajax_simple_response({
"status": "ok",
"respmsg": _("Domain modified")
})
commonctx["tabs"] = form
commonctx["error"] = error
return ajax_response(request,
status="ko",
template=tplname,
**commonctx)
def delalias(request):
selection = request.GET["selection"].split(",")
for alid in selection:
alias = Alias.objects.get(pk=alid)
if not request.user.can_access(alias):
raise PermDeniedException
if alias.type == 'dlist':
msg = "Distribution list deleted"
msgs = "Distribution lists deleted"
elif alias.type == 'forward':
msg = "Forward deleted"
msgs = "Forwards deleted"
else:
msg = "Alias deleted"
msgs = "Aliases deleted"
alias.delete()
msg = ungettext(msg, msgs, len(selection))
return ajax_simple_response({"status": "ok", "respmsg": msg})
def logs(request, tplname="admin/logs.html"):
sort_order, sort_dir = get_sort_order(
request.GET,
"date_created",
allowed_values=['date_created', 'level', 'logger', 'message'])
page = get_listing_page(
Log.objects.all().order_by("%s%s" % (sort_dir, sort_order)),
request.GET.get("page", 1))
return ajax_simple_response({
"status":
"ok",
"content":
render_to_string(tplname, {
"logs": page.object_list,
}),
"page":
page.number,
"paginbar":
pagination_bar(page),
})
