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 == '-')
context = {
"handle_mailboxes": parameters.get_admin(
"HANDLE_MAILBOXES", raise_error=False)
}
page = get_listing_page(objects, request.GET.get("page", 1))
if page is None:
context["length"] = 0
else:
context["headers"] = _render_to_string(
request, "admin/identity_headers.html", {})
context["rows"] = _render_to_string(
request, "admin/identities_table.html", {
"identities": page.object_list
}
)
context["pages"] = [page.number]
return render_to_json_response(context)
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 == '-')
context = {
"handle_mailboxes":
parameters.get_admin("HANDLE_MAILBOXES", raise_error=False)
}
page = get_listing_page(objects, request.GET.get("page", 1))
if page is None:
context["length"] = 0
else:
context["headers"] = _render_to_string(request,
"admin/identity_headers.html",
{})
context["rows"] = _render_to_string(request,
"admin/identities_table.html",
{"identities": page.object_list})
context["pages"] = [page.number]
return render_to_json_response(context)
def list_quotas(request):
from modoboa.lib.db_utils 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"]:
mboxes = mboxes.order_by("%s%s" % (sort_dir, sort_order))
elif sort_order == "quota_value__bytes":
where = "admin_mailbox.address||'@'||admin_domain.name"
mboxes = mboxes.extra(
select={"quota_value__bytes": "admin_quota.bytes"},
where=["admin_quota.username=%s" % where],
tables=["admin_quota", "admin_domain"],
order_by=["%s%s" % (sort_dir, sort_order)]
)
elif sort_order == "quota_usage":
where = "admin_mailbox.address||'@'||admin_domain.name"
db_type = db_type()
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"
)
if db_type == "mysql":
where = "CONCAT(admin_mailbox.address,'@',admin_domain.name)"
mboxes = mboxes.extra(
select={'quota_usage': select},
where=["admin_quota.username=%s" % where],
tables=["admin_quota", "admin_domain"],
order_by=["%s%s" % (sort_dir, sort_order)]
)
else:
raise BadRequest(_("Invalid request"))
page = get_listing_page(mboxes, request.GET.get("page", 1))
context = {
"headers": _render_to_string(
request, "admin/quota_headers.html", {}
)
}
if page is None:
context["length"] = 0
else:
context["rows"] = _render_to_string(
request, "admin/quotas.html", {
"mboxes": page
}
)
context["pages"] = [page.number]
return render_to_json_response(context)
def list_quotas(request):
from modoboa.lib.db_utils 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"]:
mboxes = mboxes.order_by("%s%s" % (sort_dir, sort_order))
elif sort_order == "quota_value__bytes":
where = "admin_mailbox.address||'@'||admin_domain.name"
mboxes = mboxes.extra(
select={"quota_value__bytes": "admin_quota.bytes"},
where=["admin_quota.username=%s" % where],
tables=["admin_quota", "admin_domain"],
order_by=["%s%s" % (sort_dir, sort_order)]
)
elif sort_order == "quota_usage":
where = "admin_mailbox.address||'@'||admin_domain.name"
db_type = db_type()
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"
)
if db_type == "mysql":
where = "CONCAT(admin_mailbox.address,'@',admin_domain.name)"
mboxes = mboxes.extra(
select={'quota_usage': select},
where=["admin_quota.username=%s" % where],
tables=["admin_quota", "admin_domain"],
order_by=["%s%s" % (sort_dir, sort_order)]
)
else:
raise BadRequest(_("Invalid request"))
page = get_listing_page(mboxes, request.GET.get("page", 1))
context = {
"headers": _render_to_string(
request, "admin/quota_headers.html", {}
)
}
if page is None:
context["length"] = 0
else:
context["rows"] = _render_to_string(
request, "admin/quotas.html", {
"mboxes": page
}
)
context["pages"] = [page.number]
return render_to_json_response(context)
def forward(request, tplname="admin/forward.html"):
mb = request.user.mailbox
al = Alias.objects.filter(address=mb.full_address, internal=False).first()
if request.method == "POST":
form = ForwardForm(request.POST)
if form.is_valid():
if al is None:
al = Alias.objects.create(
address=mb.full_address, domain=mb.domain,
enabled=mb.user.is_active)
recipients = form.get_recipients()
if form.cleaned_data["keepcopies"]:
recipients.append(mb.full_address)
al.set_recipients(recipients)
al.post_create(request.user)
return render_to_json_response(_("Forward updated"))
return render_to_json_response(
{'form_errors': form.errors}, status=400
)
form = ForwardForm()
if al is not None and al.recipients:
form.fields["dest"].initial = al.recipients
if al.aliasrecipient_set.filter(r_mailbox=mb.pk).exists():
form.fields["keepcopies"].initial = True
return render_to_json_response({
"content": _render_to_string(request, tplname, {
"form": form
})
})
def _listing(request):
"""Listing initial view.
Called the first time the listing page is displayed.
"""
if not request.user.is_superuser and request.user.role != 'SimpleUsers':
if not Domain.objects.get_for_admin(request.user).count():
return empty_quarantine()
navparams = QuarantineNavigationParameters(request)
navparams.store()
connector = get_connector(user=request.user, navparams=navparams)
context = get_listing_pages(request, connector)
if context is None:
return empty_quarantine()
context["listing"] = _render_to_string(
request, "modoboa_amavis/email_list.html", {
"email_list": context["rows"]}
)
del context["rows"]
if request.session.get('location', 'listing') != 'listing':
context["menu"] = quar_menu(request.user)
request.session["location"] = "listingx"
return render_to_json_response(context)
def forward(request, tplname="admin/forward.html"):
mb = request.user.mailbox
al = Alias.objects.filter(address=mb.full_address, internal=False).first()
if request.method == "POST":
form = ForwardForm(request.POST)
if form.is_valid():
if al is None:
al = Alias.objects.create(address=mb.full_address,
domain=mb.domain,
enabled=mb.user.is_active)
recipients = form.get_recipients()
if form.cleaned_data["keepcopies"]:
recipients.append(mb.full_address)
al.set_recipients(recipients)
al.post_create(request.user)
return render_to_json_response(_("Forward updated"))
return render_to_json_response({'form_errors': form.errors},
status=400)
form = ForwardForm()
if al is not None and al.recipients:
form.fields["dest"].initial = al.recipients
if al.aliasrecipient_set.filter(r_mailbox=mb.pk).exists():
form.fields["keepcopies"].initial = True
return render_to_json_response(
{"content": _render_to_string(request, tplname, {"form": form})})
def _domains(request):
sort_order, sort_dir = get_sort_order(request.GET, "name")
filters = dict((flt, request.GET.get(flt, None))
for flt in ['domfilter', 'searchquery'] +
events.raiseQueryEvent('ExtraDomainFilters'))
request.session['domains_filters'] = filters
domainlist = get_domains(request.user, **filters)
if sort_order == 'name':
domainlist = sorted(domainlist,
key=lambda d: getattr(d, sort_order),
reverse=sort_dir == '-')
else:
domainlist = sorted(domainlist,
key=lambda d: d.tags[0],
reverse=sort_dir == '-')
context = {
"handle_mailboxes":
parameters.get_admin("HANDLE_MAILBOXES", raise_error=False),
"auto_account_removal":
parameters.get_admin("AUTO_ACCOUNT_REMOVAL")
}
page = get_listing_page(domainlist, request.GET.get("page", 1))
if page is None:
context["length"] = 0
else:
context["rows"] = _render_to_string(request,
"admin/domains_table.html", {
'domains': page.object_list,
})
context["pages"] = [page.number]
return render_to_json_response(context)
def viewparameters(request, tplname='core/parameters.html'):
return render_to_json_response({
"left_selection": "parameters",
"content": _render_to_string(request, tplname, {
"forms": parameters.get_admin_forms
})
})
def preferences(request):
if request.method == "POST":
forms = param_tools.registry.get_forms("user",
request.POST,
user=request.user)
for formdef in forms:
form = formdef["form"]
if form.is_valid():
form.save()
continue
return render_to_json_response(
{
"prefix": form.app,
"form_errors": form.errors
}, status=400)
request.user.save()
return render_to_json_response(_("Preferences saved"))
return render_to_json_response({
"content":
_render_to_string(
request, "core/user_preferences.html", {
"forms":
param_tools.registry.get_forms(
"user", user=request.user, first_app="general")
})
})
def profile(request, tplname='core/user_profile.html'):
"""Profile detail/update view."""
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"])
translation.activate(request.user.language)
request.session[translation.LANGUAGE_SESSION_KEY] = (
request.user.language)
return render_to_json_response(_("Profile updated"))
return render_to_json_response(
{'form_errors': form.errors}, status=400)
form = ProfileForm(update_password, instance=request.user)
return render_to_json_response({
"content": _render_to_string(request, tplname, {
"form": form
})
})
def profile(request, tplname='core/user_profile.html'):
"""Profile detail/update view."""
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"])
translation.activate(request.user.language)
request.session[translation.LANGUAGE_SESSION_KEY] = (
request.user.language)
return render_to_json_response(_("Profile updated"))
return render_to_json_response(
{'form_errors': form.errors}, status=400)
form = ProfileForm(update_password, instance=request.user)
return render_to_json_response({
"content": _render_to_string(request, tplname, {
"form": form
})
})
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.fromdate = form.cleaned_data["fromdate"]
arm.untildate = form.cleaned_data["untildate"]
arm.mbox = mb
arm.save()
return render_to_json_response(
_("Auto reply message updated successfully.")
)
return render_to_json_response(
{"form_errors": form.errors}, status=400
)
form = ARmessageForm(instance=arm)
return render_to_json_response({
"content": _render_to_string(request, tplname, {"form": form}),
"onload_cb": "autoreply_cb"
})
def viewparameters(request, tplname='core/parameters.html'):
return render_to_json_response({
"left_selection": "parameters",
"content": _render_to_string(request, tplname, {
"forms": parameters.get_admin_forms
})
})
def _domains(request):
sort_order, sort_dir = get_sort_order(request.GET, "name")
filters = dict(
(flt, request.GET.get(flt, None))
for flt in ['domfilter', 'searchquery']
+ events.raiseQueryEvent('ExtraDomainFilters')
)
request.session['domains_filters'] = filters
domainlist = get_domains(request.user, **filters)
if sort_order == 'name':
domainlist = sorted(
domainlist,
key=lambda d: getattr(d, sort_order), reverse=sort_dir == '-'
)
else:
domainlist = sorted(domainlist, key=lambda d: d.tags[0],
reverse=sort_dir == '-')
context = {
"handle_mailboxes": parameters.get_admin(
"HANDLE_MAILBOXES", raise_error=False),
"auto_account_removal": parameters.get_admin("AUTO_ACCOUNT_REMOVAL")
}
page = get_listing_page(domainlist, request.GET.get("page", 1))
if page is None:
context["length"] = 0
else:
context["rows"] = _render_to_string(
request, "admin/domains_table.html", {
'domains': page.object_list,
}
)
context["pages"] = [page.number]
return render_to_json_response(context)
def parameters(request, tplname="core/parameters.html"):
"""View to display and save global parameters."""
if request.method == "POST":
forms = param_tools.registry.get_forms("global",
request.POST,
localconfig=request.localconfig)
for formdef in forms:
form = formdef["form"]
if form.is_valid():
form.save()
form.to_django_settings()
continue
return render_to_json_response(
{
"form_errors": form.errors,
"prefix": form.app
}, status=400)
request.localconfig.save()
return render_to_json_response(_("Parameters saved"))
return render_to_json_response({
"left_selection":
"parameters",
"content":
_render_to_string(
request, tplname, {
"forms":
param_tools.registry.get_forms("global",
localconfig=request.localconfig)
})
})
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.fromdate = form.cleaned_data["fromdate"]
arm.untildate = form.cleaned_data["untildate"]
arm.mbox = mb
arm.save()
return render_to_json_response(
_("Auto reply message updated successfully."))
return render_to_json_response({"form_errors": form.errors},
status=400)
form = ARmessageForm(instance=arm)
return render_to_json_response({
"content":
_render_to_string(request, tplname, {"form": form}),
"onload_cb":
"autoreply_cb"
})
def send_mail(request, form, posturl=None):
"""Email verification and sending.
If the form does not present any error, a new MIME message is
constructed. Then, a connection is established with the defined
SMTP server and the message is finally sent.
:param request: a Request object
:param posturl: the url to post the message form to
:return: a 2-uple (True|False, HttpResponse)
"""
if not form.is_valid():
editormode = parameters.get_user(request.user, "EDITOR")
listing = _render_to_string(
request, "modoboa_webmail/compose.html", {
"form": form,
"noerrors": True,
"body": form.cleaned_data.get("body", "").strip(),
"posturl": posturl
})
return False, dict(status="ko", listing=listing, editor=editormode)
msg = form.to_msg(request)
rcpts = prepare_addresses(form.cleaned_data["to"], "envelope")
for hdr in ["cc", "cci"]:
if form.cleaned_data[hdr]:
msg[hdr.capitalize()] = prepare_addresses(form.cleaned_data[hdr])
rcpts += prepare_addresses(form.cleaned_data[hdr], "envelope")
try:
secmode = parameters.get_admin("SMTP_SECURED_MODE")
if secmode == "ssl":
s = smtplib.SMTP_SSL(parameters.get_admin("SMTP_SERVER"),
int(parameters.get_admin("SMTP_PORT")))
else:
s = smtplib.SMTP(parameters.get_admin("SMTP_SERVER"),
int(parameters.get_admin("SMTP_PORT")))
if secmode == "starttls":
s.starttls()
except Exception as text:
raise WebmailInternalError(str(text))
if parameters.get_admin("SMTP_AUTHENTICATION") == "yes":
try:
s.login(request.user.username, get_password(request))
except smtplib.SMTPException as err:
raise WebmailInternalError(str(err))
try:
s.sendmail(request.user.email, rcpts, msg.as_string())
s.quit()
except smtplib.SMTPException as err:
raise WebmailInternalError(str(err))
sentfolder = parameters.get_user(request.user, "SENT_FOLDER")
get_imapconnector(request).push_mail(sentfolder, msg)
clean_attachments(request.session["compose_mail"]["attachments"])
del request.session["compose_mail"]
return True, {}
def viewextensions(request, tplname='core/extensions.html'):
"""List available extensions."""
from modoboa.core.extensions import exts_pool
exts = exts_pool.list_all()
return render_to_json_response({
"callback": "extensions",
"content": _render_to_string(request, tplname, {"extensions": exts})
})
def dologin(request):
"""Try to authenticate."""
error = None
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
logger = logging.getLogger('modoboa.auth')
user = authenticate(username=form.cleaned_data["username"],
password=form.cleaned_data["password"])
if user and user.is_active:
login(request, user)
if not form.cleaned_data["rememberme"]:
request.session.set_expiry(0)
request.session["django_language"] = \
parameters.get_user(request.user, "LANG")
logger.info(
_("User '%s' successfully logged in" % user.username))
events.raiseEvent("UserLogin", request,
form.cleaned_data["username"],
form.cleaned_data["password"])
nextlocation = request.POST.get("next", None)
if nextlocation is None or nextlocation == "None":
if user.group == "SimpleUsers":
nextlocation = reverse("topredirection")
else:
# FIXME
nextlocation = reverse("modoboa_admin:domain_list")
return HttpResponseRedirect(nextlocation)
error = _(
"Your username and password didn't match. Please try again.")
logger.warning(
"Failed connection attempt from '%(addr)s' as user '%(user)s'"
% {
"addr": request.META["REMOTE_ADDR"],
"user": form.cleaned_data["username"]
})
nextlocation = request.POST.get("next", None)
httpcode = 401
else:
form = LoginForm()
nextlocation = request.GET.get("next", None)
httpcode = 200
return HttpResponse(_render_to_string(
request, "registration/login.html", {
"form": form,
"error": error,
"next": nextlocation,
"annoucements": events.raiseQueryEvent("GetAnnouncement",
"loginpage")
}),
status=httpcode)
def dologin(request):
"""Try to authenticate."""
error = None
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
logger = logging.getLogger('modoboa.auth')
user = authenticate(username=form.cleaned_data["username"],
password=form.cleaned_data["password"])
if user and user.is_active:
nextlocation = None
if not user.last_login:
# Redirect to profile on first login
nextlocation = reverse("core:user_index")
login(request, user)
if not form.cleaned_data["rememberme"]:
request.session.set_expiry(0)
translation.activate(request.user.language)
request.session[translation.LANGUAGE_SESSION_KEY] = (
request.user.language)
logger.info(
_("User '%s' successfully logged in" % user.username)
)
events.raiseEvent("UserLogin", request,
form.cleaned_data["username"],
form.cleaned_data["password"])
if nextlocation is None:
nextlocation = request.POST.get("next", None)
if nextlocation is None or nextlocation == "None":
if user.group == "SimpleUsers":
nextlocation = reverse("topredirection")
else:
nextlocation = reverse("admin:domain_list")
return HttpResponseRedirect(nextlocation)
error = _(
"Your username and password didn't match. Please try again.")
logger.warning(
"Failed connection attempt from '%(addr)s' as user '%(user)s'"
% {"addr": request.META["REMOTE_ADDR"],
"user": form.cleaned_data["username"]}
)
nextlocation = request.POST.get("next", None)
httpcode = 401
else:
form = LoginForm()
nextlocation = request.GET.get("next", None)
httpcode = 200
return HttpResponse(_render_to_string(request, "registration/login.html", {
"form": form, "error": error, "next": nextlocation,
"annoucements": events.raiseQueryEvent("GetAnnouncement", "loginpage")
}), status=httpcode)
def send_mail(request, form, posturl=None):
"""Email verification and sending.
If the form does not present any error, a new MIME message is
constructed. Then, a connection is established with the defined
SMTP server and the message is finally sent.
:param request: a Request object
:param posturl: the url to post the message form to
:return: a 2-uple (True|False, HttpResponse)
"""
if not form.is_valid():
editormode = parameters.get_user(request.user, "EDITOR")
listing = _render_to_string(
request, "webmail/compose.html",
{"form": form, "noerrors": True,
"body": form.cleaned_data.get("body", "").strip(),
"posturl": posturl}
)
return False, dict(status="ko", listing=listing, editor=editormode)
msg = form.to_msg(request)
rcpts = prepare_addresses(form.cleaned_data["to"], "envelope")
for hdr in ["cc", "cci"]:
if form.cleaned_data[hdr]:
msg[hdr.capitalize()] = prepare_addresses(form.cleaned_data[hdr])
rcpts += prepare_addresses(form.cleaned_data[hdr], "envelope")
try:
secmode = parameters.get_admin("SMTP_SECURED_MODE")
if secmode == "ssl":
s = smtplib.SMTP_SSL(parameters.get_admin("SMTP_SERVER"),
int(parameters.get_admin("SMTP_PORT")))
else:
s = smtplib.SMTP(parameters.get_admin("SMTP_SERVER"),
int(parameters.get_admin("SMTP_PORT")))
if secmode == "starttls":
s.starttls()
except Exception as text:
raise WebmailInternalError(str(text))
if parameters.get_admin("SMTP_AUTHENTICATION") == "yes":
try:
s.login(request.user.username, get_password(request))
except smtplib.SMTPException as err:
raise WebmailInternalError(str(err))
try:
s.sendmail(request.user.email, rcpts, msg.as_string())
s.quit()
except smtplib.SMTPException as err:
raise WebmailInternalError(str(err))
sentfolder = parameters.get_user(request.user, "SENT_FOLDER")
get_imapconnector(request).push_mail(sentfolder, msg)
clean_attachments(request.session["compose_mail"]["attachments"])
del request.session["compose_mail"]
return True, {}
def viewextensions(request, tplname='core/extensions.html'):
"""List available extensions."""
from modoboa.core.extensions import exts_pool
exts = exts_pool.list_all()
return render_to_json_response({
"callback":
"extensions",
"content":
_render_to_string(request, tplname, {"extensions": exts})
})
def render_mboxes_list(request, imapc):
"""Return the HTML representation of a mailboxes list
:param request: a ``Request`` object
:param imapc: an ``IMAPconnector` object
:return: a string
"""
curmbox = WebmailNavigationParameters(request).get("mbox", "INBOX")
return _render_to_string(request, "webmail/folders.html", {
"selected": curmbox,
"mboxes": imapc.getmboxes(request.user),
"withunseen": True
})
def dologin(request):
"""Try to authenticate."""
error = None
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
logger = logging.getLogger('modoboa.auth')
user = authenticate(username=form.cleaned_data["username"],
password=form.cleaned_data["password"])
if user and user.is_active:
login(request, user)
if not form.cleaned_data["rememberme"]:
request.session.set_expiry(0)
translation.activate(request.user.language)
request.session[translation.LANGUAGE_SESSION_KEY] = (
request.user.language)
logger.info(
_("User '%s' successfully logged in") % user.username)
signals.user_login.send(sender="dologin",
username=form.cleaned_data["username"],
password=form.cleaned_data["password"])
return HttpResponseRedirect(find_nextlocation(request, user))
error = _(
"Your username and password didn't match. Please try again.")
logger.warning(
"Failed connection attempt from '%(addr)s' as user '%(user)s'"
% {
"addr": request.META["REMOTE_ADDR"],
"user": form.cleaned_data["username"]
})
nextlocation = request.POST.get("next", None)
httpcode = 401
else:
form = LoginForm()
nextlocation = request.GET.get("next", None)
httpcode = 200
announcements = signals.get_announcements.send(sender="login",
location="loginpage")
announcements = [announcement[1] for announcement in announcements]
return HttpResponse(_render_to_string(
request, "registration/login.html", {
"form": form,
"error": error,
"next": nextlocation,
"annoucements": announcements
}),
status=httpcode)
def render_mboxes_list(request, imapc):
"""Return the HTML representation of a mailboxes list
:param request: a ``Request`` object
:param imapc: an ``IMAPconnector` object
:return: a string
"""
curmbox = WebmailNavigationParameters(request).get("mbox", "INBOX")
return _render_to_string(
request, "webmail/folders.html", {
"selected": curmbox,
"mboxes": imapc.getmboxes(request.user),
"withunseen": True
})
def listing_page(request):
"""Return a listing page."""
navparams = QuarantineNavigationParameters(request)
previous_page_id = int(navparams["page"]) if "page" in navparams else None
navparams.store()
connector = get_connector(user=request.user, navparams=navparams)
context = get_listing_pages(request, connector)
if context is None:
context = {"length": 0}
navparams["page"] = previous_page_id
else:
context["rows"] = _render_to_string(request, "amavis/emails_page.html",
{"email_list": context["rows"]})
return render_to_json_response(context)
def listing_page(request):
"""Return a listing page."""
navparams = QuarantineNavigationParameters(request)
previous_page_id = int(navparams["page"]) if "page" in navparams else None
navparams.store()
connector = get_connector(user=request.user, navparams=navparams)
context = get_listing_pages(request, connector)
if context is None:
context = {"length": 0}
navparams["page"] = previous_page_id
else:
context["rows"] = _render_to_string(
request, "amavis/emails_page.html", {"email_list": context["rows"]}
)
return render_to_json_response(context)
def api_access(request):
"""A view to configure API access."""
if request.method == "POST":
form = APIAccessForm(request.POST, user=request.user)
if form.is_valid():
if form.cleaned_data.get("enable_api_access"):
Token.objects.get_or_create(user=request.user)
else:
Token.objects.filter(user=request.user).delete()
return render_to_json_response(_("Access updated"))
return render_to_json_response({"form_errors": form.errors},
status=400)
form = APIAccessForm(user=request.user)
return render_to_json_response({
"content":
_render_to_string(request, "core/api_access.html", {"form": form})
})
def calendars_page(request, tplname="modoboa_radicale/calendars_page.html"):
"""Return a page of calendars.
The content depends on current user's role.
"""
page = get_calendar_page(request)
if page is None:
context = {"length": 0}
else:
context = {
"rows": _render_to_string(request, tplname, {
"calendars": page.object_list,
"with_owner": request.user.role != "SimpleUsers"
}),
"page": page.number
}
return render_to_json_response(context)
def calendars_page(request, tplname="radicale/calendars_page.html"):
"""Return a page of calendars.
The content depends on current user's role.
"""
page = get_calendar_page(request)
if page is None:
context = {"length": 0}
else:
context = {
"rows": _render_to_string(request, tplname, {
"calendars": page.object_list,
"with_owner": request.user.group != "SimpleUsers"
}),
"page": page.number
}
return render_to_json_response(context)
def listmailbox(request, defmailbox="INBOX", update_session=True):
"""Mailbox content listing.
Return a list of messages contained in the specified mailbox. The
number of elements returned depends on the ``MESSAGES_PER_PAGE``
parameter. (user preferences)
:param request: a ``Request`` object
:param defmailbox: the default mailbox (when not present inside
request arguments)
:return: a dictionnary
"""
navparams = WebmailNavigationParameters(request, defmailbox)
previous_page_id = int(navparams["page"]) if "page" in navparams else None
if update_session:
navparams.store()
mbox = navparams.get('mbox')
page_id = int(navparams["page"])
mbc = get_imapconnector(request)
mbc.parse_search_parameters(
navparams.get("criteria"), navparams.get("pattern"))
paginator = Paginator(
mbc.messages_count(folder=mbox, order=navparams.get("order")),
int(parameters.get_user(request.user, "MESSAGES_PER_PAGE"))
)
page = paginator.getpage(page_id)
content = ""
if page is not None:
email_list = mbc.fetch(page.id_start, page.id_stop, mbox)
content = _render_to_string(
request, "modoboa_webmail/email_list.html", {
"email_list": email_list,
"page": page_id,
"with_top_div": request.GET.get("scroll", "false") == "false"
})
length = len(content)
else:
if page_id == 1:
content = "<div class='alert alert-info'>{0}</div>".format(
_("Empty mailbox")
)
length = 0
if previous_page_id is not None:
navparams["page"] = previous_page_id
return {"listing": content, "length": length, "pages": [page_id]}
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 render_to_json_response({
"prefix": form.app, "form_errors": form.errors
}, status=400)
return render_to_json_response(_("Preferences saved"))
return render_to_json_response({
"content": _render_to_string(request, "core/user_preferences.html", {
"forms": parameters.get_user_forms(request.user)
})
})
def api_access(request):
"""A view to configure API access."""
if request.method == "POST":
form = APIAccessForm(request.POST, user=request.user)
if form.is_valid():
if form.cleaned_data.get("enable_api_access"):
Token.objects.get_or_create(user=request.user)
else:
Token.objects.filter(user=request.user).delete()
return render_to_json_response(_("Access updated"))
return render_to_json_response({
"form_errors": form.errors
}, status=400)
form = APIAccessForm(user=request.user)
return render_to_json_response({
"content": _render_to_string(
request, "core/api_access.html", {"form": form})
})
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 render_to_json_response({
"prefix": form.app, "form_errors": form.errors
}, status=400)
return render_to_json_response(_("Preferences saved"))
return render_to_json_response({
"content": _render_to_string(request, "core/user_preferences.html", {
"forms": parameters.get_user_forms(request.user)
})
})
def listmailbox(request, defmailbox="INBOX", update_session=True):
"""Mailbox content listing.
Return a list of messages contained in the specified mailbox. The
number of elements returned depends on the ``MESSAGES_PER_PAGE``
parameter. (user preferences)
:param request: a ``Request`` object
:param defmailbox: the default mailbox (when not present inside
request arguments)
:return: a dictionnary
"""
navparams = WebmailNavigationParameters(request, defmailbox)
previous_page_id = int(navparams["page"]) if "page" in navparams else None
if update_session:
navparams.store()
mbox = navparams.get('mbox')
page_id = int(navparams["page"])
mbc = get_imapconnector(request)
mbc.parse_search_parameters(navparams.get("criteria"),
navparams.get("pattern"))
paginator = Paginator(
mbc.messages_count(folder=mbox, order=navparams.get("order")),
int(parameters.get_user(request.user, "MESSAGES_PER_PAGE")))
page = paginator.getpage(page_id)
content = ""
if page is not None:
email_list = mbc.fetch(page.id_start, page.id_stop, mbox)
content = _render_to_string(
request, "webmail/email_list.html", {
"email_list": email_list,
"page": page_id,
"with_top_div": request.GET.get("scroll", "false") == "false"
})
length = len(content)
else:
if page_id == 1:
content = "<div class='alert alert-info'>{0}</div>".format(
_("Empty mailbox"))
length = 0
if previous_page_id is not None:
navparams["page"] = previous_page_id
return {"listing": content, "length": length, "pages": [page_id]}
def forward(request, tplname='admin/forward.html'):
mb = request.user.mailbox_set.all()[0]
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():
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, creator=request.user
)
return render_to_json_response(_("Forward updated"))
return render_to_json_response(
{'form_errors': form.errors}, status=400
)
form = ForwardForm()
if al is not None:
form.fields["dest"].initial = al.extmboxes
try:
al.mboxes.get(pk=mb.id)
except Mailbox.DoesNotExist:
pass
else:
form.fields["keepcopies"].initial = True
return render_to_json_response({
"content": _render_to_string(request, tplname, {
"form": form
})
})
def _domains(request):
sort_order, sort_dir = get_sort_order(request.GET, "name")
extra_filters = reduce(
lambda a, b: a + b,
[result[1] for result in
signals.extra_domain_filters.send(sender="_domains")]
)
filters = dict(
(flt, request.GET.get(flt, None))
for flt in ["domfilter", "searchquery"] + extra_filters
)
request.session['domains_filters'] = filters
domainlist = get_domains(request.user, **filters)
if sort_order == 'name':
domainlist = sorted(
domainlist,
key=lambda d: getattr(d, sort_order), reverse=sort_dir == '-'
)
else:
domainlist = sorted(domainlist, key=lambda d: d.tags[0],
reverse=sort_dir == '-')
context = {
"handle_mailboxes": request.localconfig.parameters.get_value(
"handle_mailboxes", raise_exception=False),
"auto_account_removal": request.localconfig.parameters.get_value(
"auto_account_removal"),
}
page = get_listing_page(domainlist, request.GET.get("page", 1))
if page is None:
context["length"] = 0
else:
parameters = request.localconfig.parameters
context["rows"] = _render_to_string(
request, "admin/domains_table.html", {
"domains": page.object_list,
"enable_mx_checks": parameters.get_value("enable_mx_checks"),
"enable_dnsbl_checks": (
parameters.get_value("enable_dnsbl_checks"))
}
)
context["pages"] = [page.number]
return render_to_json_response(context)
def viewextensions(request, tplname='core/extensions.html'):
"""List available extensions."""
from modoboa.core.extensions import exts_pool
exts = exts_pool.list_all()
for ext in exts:
try:
dbext = Extension.objects.get(name=ext["id"])
ext["selection"] = dbext.enabled
except Extension.DoesNotExist:
dbext = Extension()
dbext.name = ext["id"]
dbext.enabled = False
dbext.save()
ext["selection"] = False
return render_to_json_response({
"callback": "extensions",
"content": _render_to_string(request, tplname, {"extensions": exts})
})
def render_compose(request, form, posturl, email=None, insert_signature=False):
"""Render the compose form."""
resp = {}
if email is None:
body = u""
textheader = u""
else:
body = email.body
textheader = email.textheader
if insert_signature:
signature = EmailSignature(request.user)
body += unicode(signature)
randid = None
if "id" not in request.GET:
if "compose_mail" in request.session:
clean_attachments(request.session["compose_mail"]["attachments"])
randid = set_compose_session(request)
elif "compose_mail" not in request.session \
or request.session["compose_mail"]["id"] != request.GET["id"]:
randid = set_compose_session(request)
attachment_list = request.session["compose_mail"]["attachments"]
if attachment_list:
resp["menuargs"] = {"attachment_counter": len(attachment_list)}
content = _render_to_string(request, "webmail/compose.html", {
"form": form,
"bodyheader": textheader,
"body": body,
"posturl": posturl
})
resp.update({
"listing": content,
"editor": parameters.get_user(request.user, "EDITOR")
})
if randid is not None:
resp["id"] = randid
return resp
def forward(request, tplname='admin/forward.html'):
mb = request.user.mailbox_set.all()[0]
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():
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,
creator=request.user)
return render_to_json_response(_("Forward updated"))
return render_to_json_response({'form_errors': form.errors},
status=400)
form = ForwardForm()
if al is not None:
form.fields["dest"].initial = al.extmboxes
try:
al.mboxes.get(pk=mb.id)
except Mailbox.DoesNotExist:
pass
else:
form.fields["keepcopies"].initial = True
return render_to_json_response(
{"content": _render_to_string(request, tplname, {"form": form})})
def parameters(request, tplname="core/parameters.html"):
"""View to display and save global parameters."""
if request.method == "POST":
forms = param_tools.registry.get_forms(
"global", request.POST, localconfig=request.localconfig)
for formdef in forms:
form = formdef["form"]
if form.is_valid():
form.save()
form.to_django_settings()
continue
return render_to_json_response(
{"form_errors": form.errors, "prefix": form.app}, status=400
)
request.localconfig.save()
return render_to_json_response(_("Parameters saved"))
return render_to_json_response({
"left_selection": "parameters",
"content": _render_to_string(request, tplname, {
"forms": param_tools.registry.get_forms(
"global", localconfig=request.localconfig)
})
})
def render_compose(request, form, posturl, email=None, insert_signature=False):
"""Render the compose form."""
resp = {}
if email is None:
body = u""
textheader = u""
else:
body = email.body
textheader = email.textheader
if insert_signature:
signature = EmailSignature(request.user)
body += unicode(signature)
randid = None
if "id" not in request.GET:
if "compose_mail" in request.session:
clean_attachments(request.session["compose_mail"]["attachments"])
randid = set_compose_session(request)
elif "compose_mail" not in request.session \
or request.session["compose_mail"]["id"] != request.GET["id"]:
randid = set_compose_session(request)
attachment_list = request.session["compose_mail"]["attachments"]
if attachment_list:
resp["menuargs"] = {"attachment_counter": len(attachment_list)}
content = _render_to_string(request, "webmail/compose.html", {
"form": form, "bodyheader": textheader,
"body": body, "posturl": posturl
})
resp.update({
"listing": content,
"editor": parameters.get_user(request.user, "EDITOR")
})
if randid is not None:
resp["id"] = randid
return resp
def _listing(request):
"""Listing initial view.
Called the first time the listing page is displayed.
"""
if not request.user.is_superuser and request.user.group != 'SimpleUsers':
if not Domain.objects.get_for_admin(request.user).count():
return empty_quarantine()
navparams = QuarantineNavigationParameters(request)
navparams.store()
connector = get_connector(user=request.user, navparams=navparams)
context = get_listing_pages(request, connector)
if context is None:
return empty_quarantine()
context["listing"] = _render_to_string(
request, "amavis/email_list.html", {"email_list": context["rows"]}
)
del context["rows"]
if request.session.get('location', 'listing') != 'listing':
context["menu"] = quar_menu(request.user)
request.session["location"] = "listingx"
return render_to_json_response(context)
