mirror of
https://github.com/jwinterm/modoboa.git
synced 2026-11-16 09:34:03 +01:00
Better navigation parameters storing. We don't use the same places to store webmail and quarantine parameters anymore. see #375
593 lines
20 KiB
Python
593 lines
20 KiB
Python
# coding: utf-8
|
|
import os
|
|
from rfc6266 import build_header
|
|
from django.conf import settings
|
|
from django.http import HttpResponse
|
|
from django.shortcuts import render
|
|
from django.template import Template, Context
|
|
from django.utils.translation import ugettext as _, ungettext
|
|
from django.core.urlresolvers import reverse
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
from django.views.decorators.gzip import gzip_page
|
|
from modoboa.lib import parameters
|
|
from modoboa.lib.webutils import (
|
|
_render_to_string, ajax_response, ajax_simple_response
|
|
)
|
|
from modoboa.extensions.admin.lib import needs_mailbox
|
|
from .exceptions import WebmailError
|
|
from .forms import FolderForm, AttachmentForm, ComposeMailForm
|
|
from .imaputils import get_imapconnector, IMAPconnector, separate_mailbox
|
|
from .lib import (
|
|
decode_payload, AttachmentUploadHandler,
|
|
save_attachment, ImapListing, EmailSignature,
|
|
clean_attachments, set_compose_session, send_mail,
|
|
ImapEmail
|
|
)
|
|
from templatetags import webmail_tags
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
@gzip_page
|
|
def getattachment(request):
|
|
"""Fetch a message attachment
|
|
|
|
FIXME: par manque de caching, le bodystructure du message est
|
|
redemandé pour accéder aux headers de cette pièce jointe.
|
|
|
|
:param request: a ``Request`` object
|
|
"""
|
|
mbox = request.GET.get("mbox", None)
|
|
mailid = request.GET.get("mailid", None)
|
|
pnum = request.GET.get("partnumber", None)
|
|
fname = request.GET.get("fname", None)
|
|
if not mbox or not mailid or not pnum or not fname:
|
|
raise WebmailError(_("Invalid request"))
|
|
|
|
imapc = get_imapconnector(request)
|
|
partdef, payload = imapc.fetchpart(mailid, mbox, pnum)
|
|
resp = HttpResponse(decode_payload(partdef["encoding"], payload))
|
|
resp["Content-Type"] = partdef["Content-Type"]
|
|
resp["Content-Transfer-Encoding"] = partdef["encoding"]
|
|
resp["Content-Disposition"] = build_header(fname)
|
|
if int(partdef["size"]) < 200:
|
|
resp["Content-Length"] = partdef["size"]
|
|
return resp
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
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"], get_navparam(request, 'mbox'), request.GET["to"])
|
|
resp = listmailbox(request, get_navparam(request, 'mbox'), update_session=False)
|
|
resp.update(status="ok")
|
|
return ajax_simple_response(resp)
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
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)
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
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))
|
|
)
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
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
|
|
))
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
def compact(request, name):
|
|
imapc = get_imapconnector(request)
|
|
imapc.compact(name)
|
|
return ajax_simple_response(dict(status="ok"))
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
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)
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
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
|
|
remove_navparam(request, '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)
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
def delfolder(request):
|
|
name = request.GET.get("name", None)
|
|
if name is None:
|
|
raise WebmailError(_("Bad request"))
|
|
mbc = IMAPconnector(user=request.user.username,
|
|
password=request.session["password"])
|
|
mbc.delete_folder(name)
|
|
remove_navparam(request, 'mbox')
|
|
return ajax_response(request)
|
|
|
|
|
|
@login_required
|
|
@csrf_exempt
|
|
@needs_mailbox()
|
|
def attachments(request, tplname="webmail/attachments.html"):
|
|
if request.method == "POST":
|
|
csuploader = AttachmentUploadHandler()
|
|
request.upload_handlers.insert(0, csuploader)
|
|
error = None
|
|
form = AttachmentForm(request.POST, request.FILES)
|
|
if form.is_valid():
|
|
try:
|
|
fobj = request.FILES["attachment"]
|
|
tmpname = save_attachment(fobj)
|
|
request.session["compose_mail"]["attachments"] \
|
|
+= [{"fname": str(fobj),
|
|
"content-type": fobj.content_type,
|
|
"size": fobj.size,
|
|
"tmpname": os.path.basename(tmpname)}]
|
|
request.session.modified = True
|
|
return render(request, "webmail/upload_done.html", {
|
|
"status": "ok", "fname": request.FILES["attachment"],
|
|
"tmpname": os.path.basename(tmpname)
|
|
})
|
|
except WebmailError, inst:
|
|
error = _("Failed to save attachment: ") + str(inst)
|
|
|
|
if csuploader.toobig:
|
|
error = _("Attachment is too big (limit: %s)"
|
|
% parameters.get_admin("MAX_ATTACHMENT_SIZE"))
|
|
return render(request, "webmail/upload_done.html", {
|
|
"status": "ko", "error": error
|
|
})
|
|
ctx = {
|
|
"title": _("Attachments"),
|
|
"formid": "uploadfile",
|
|
"target": "upload_target",
|
|
"enctype": "multipart/form-data",
|
|
"form": AttachmentForm(),
|
|
"action": reverse(attachments),
|
|
"attachments": request.session["compose_mail"]["attachments"]
|
|
}
|
|
return render(request, tplname, ctx)
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
def delattachment(request):
|
|
if not "compose_mail" in request.session \
|
|
or not "name" in request.GET \
|
|
or not request.GET["name"]:
|
|
return ajax_response(request, "ko", respmsg=_("Bad query"))
|
|
|
|
error = None
|
|
for att in request.session["compose_mail"]["attachments"]:
|
|
if att["tmpname"] == request.GET["name"]:
|
|
request.session["compose_mail"]["attachments"].remove(att)
|
|
fullpath = os.path.join(
|
|
settings.MEDIA_ROOT, "webmail", att["tmpname"]
|
|
)
|
|
try:
|
|
os.remove(fullpath)
|
|
except OSError, e:
|
|
error = _("Failed to remove attachment: ") + str(e)
|
|
break
|
|
request.session.modified = True
|
|
return ajax_response(request)
|
|
if error is None:
|
|
error = _("Unknown attachment")
|
|
return ajax_response(request, "ko", respmsg=error)
|
|
|
|
|
|
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 = get_navparam(request, "mbox", "INBOX")
|
|
return _render_to_string(request, "webmail/folders.html", {
|
|
"selected": curmbox,
|
|
"mboxes": imapc.getmboxes(request.user),
|
|
"withunseen": True
|
|
})
|
|
|
|
|
|
def store_navparams(request, extra_parameters=None):
|
|
"""Store navigation parameters into session
|
|
|
|
:param request: current request object
|
|
"""
|
|
import re
|
|
|
|
sessionkey = 'webmail_navparams'
|
|
if not sessionkey in request.session:
|
|
request.session[sessionkey] = {}
|
|
navparams = request.session[sessionkey]
|
|
navparams["page"] = int(request.GET.get("page", 1))
|
|
navparams["order"] = request.GET.get("sort_order", "-date")
|
|
for param, defvalue in [("pattern", ""), ("criteria", "from_addr")]:
|
|
navparams[param] = re.escape(request.GET.get(param, defvalue))
|
|
if extra_parameters is None:
|
|
return
|
|
for param, defvalue in extra_parameters:
|
|
navparams[param] = re.escape(request.GET.get(param, defvalue))
|
|
|
|
|
|
def get_navparam(request, param, defaultvalue=None):
|
|
"""Retrieve a navigation parameter.
|
|
|
|
Just a simple getter to avoid using the full key name to access a
|
|
parameter.
|
|
|
|
:param request: current request object
|
|
:param str param: parameter name
|
|
:param defaultvalue: default value if none is found
|
|
:return: parameter's value
|
|
"""
|
|
return request.session['webmail_navparams'].get(param, defaultvalue)
|
|
|
|
|
|
def remove_navparam(request, param):
|
|
"""Remove a navigation parameter from session.
|
|
|
|
:param request: current request object
|
|
:param str param: parameter name
|
|
"""
|
|
navparams = request.session["webmail_navparams"]
|
|
if param in navparams:
|
|
del navparams[param]
|
|
|
|
|
|
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
|
|
"""
|
|
if update_session:
|
|
store_navparams(request, [('mbox', defmailbox)])
|
|
mbox = get_navparam(request, 'mbox')
|
|
lst = ImapListing(
|
|
request.user, request.session["password"],
|
|
baseurl="?action=listmailbox&mbox=%s&" % mbox,
|
|
folder=mbox,
|
|
elems_per_page=int(parameters.get_user(request.user, "MESSAGES_PER_PAGE")),
|
|
**request.session["webmail_navparams"]
|
|
)
|
|
return lst.render(request, get_navparam(request, 'page'))
|
|
|
|
|
|
def render_compose(request, form, posturl, email=None, insert_signature=False):
|
|
editor = parameters.get_user(request.user, "EDITOR")
|
|
if email is None:
|
|
body = ""
|
|
textheader = ""
|
|
else:
|
|
body = email.body
|
|
textheader = email.textheader
|
|
if insert_signature:
|
|
signature = EmailSignature(request.user)
|
|
body += str(signature)
|
|
randid = None
|
|
if not "id" in request.GET:
|
|
if "compose_mail" in request.session:
|
|
clean_attachments(request.session["compose_mail"]["attachments"])
|
|
randid = set_compose_session(request)
|
|
elif not "compose_mail" in request.session \
|
|
or request.session["compose_mail"]["id"] != request.GET["id"]:
|
|
randid = set_compose_session(request)
|
|
|
|
attachments = request.session["compose_mail"]["attachments"]
|
|
if len(attachments):
|
|
short_att_list = "(%s)" \
|
|
% ", ".join(map(lambda att: att["fname"],
|
|
attachments[:2] + [{"fname": "..."}] \
|
|
if len(attachments) > 2 else attachments))
|
|
else:
|
|
short_att_list = ""
|
|
content = _render_to_string(request, "webmail/compose.html", {
|
|
"form": form, "bodyheader": textheader,
|
|
"body": body, "posturl": posturl,
|
|
"attachments": attachments, "short_att_list": short_att_list
|
|
})
|
|
|
|
ctx = dict(listing=content, editor=editor)
|
|
if randid is not None:
|
|
ctx["id"] = randid
|
|
return ctx
|
|
|
|
|
|
def compose(request):
|
|
url = "?action=compose"
|
|
if request.method == "POST":
|
|
status, resp = send_mail(request, posturl=url)
|
|
return resp
|
|
|
|
form = ComposeMailForm()
|
|
return render_compose(request, form, url, insert_signature=True)
|
|
|
|
|
|
def compose_and_send(request, action, callback=None):
|
|
mbox = request.GET.get("mbox", None)
|
|
mailid = request.GET.get("mailid", None)
|
|
if mbox is None or mailid is None:
|
|
raise WebmailError(_("Bad request"))
|
|
url = "?action=%s&mbox=%s&mailid=%s" % (action, mbox, mailid)
|
|
if request.method == "POST":
|
|
status, resp = send_mail(request, url)
|
|
if status and callback:
|
|
callback(mbox, mailid)
|
|
return resp
|
|
|
|
form = ComposeMailForm()
|
|
modclass = globals()["%sModifier" % action.capitalize()]
|
|
email = modclass(mbox, mailid, request, form, addrfull=True, links="1")
|
|
return render_compose(request, form, url, email)
|
|
|
|
|
|
def reply(request):
|
|
def msg_replied(mbox, mailid):
|
|
get_imapconnector(request).msg_answered(mbox, mailid)
|
|
|
|
return compose_and_send(request, "reply", msg_replied)
|
|
|
|
|
|
def forward(request):
|
|
def msg_forwarded(mbox, mailid):
|
|
get_imapconnector(request).msg_forwarded(mbox, mailid)
|
|
|
|
return compose_and_send(request, "forward", msg_forwarded)
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
def getmailcontent(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"))
|
|
email = ImapEmail(mbox, mailid, request, links=int(request.GET["links"]))
|
|
return render(request, "common/viewmail.html", {
|
|
"headers": email.render_headers(folder=mbox, mail_id=mailid),
|
|
"folder": mbox, "imapid": mailid,
|
|
"mailbody": email.body if email.body else ""
|
|
})
|
|
|
|
|
|
def viewmail(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"))
|
|
links = request.GET.get("links", None)
|
|
if links is None:
|
|
links = 1 if parameters.get_user(request.user, "ENABLE_LINKS") == "yes" else 0
|
|
else:
|
|
links = int(links)
|
|
|
|
url = reverse(getmailcontent) + "?mbox=%s&mailid=%s&links=%d" % \
|
|
(mbox, mailid, links)
|
|
content = Template("""
|
|
<iframe src="{{ url }}" id="mailcontent"></iframe>
|
|
""").render(Context({"url": url}))
|
|
|
|
return dict(listing=content, menuargs=dict(mail_id=mailid))
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
def submailboxes(request):
|
|
topmailbox = request.GET.get('topmailbox', '')
|
|
mboxes = get_imapconnector(request).getmboxes(request.user, topmailbox)
|
|
return ajax_simple_response(dict(status="ok", mboxes=mboxes))
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
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))
|
|
|
|
|
|
@login_required
|
|
@needs_mailbox()
|
|
def index(request):
|
|
"""Webmail actions handler
|
|
|
|
Problèmes liés à la navigation 'anchor based'
|
|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
|
|
Lors d'un rafraichissemt complet, une première requête est envoyée
|
|
vers /webmail/. On ne connait pas encore l'action qui va être
|
|
demandée mais on peut déjà envoyer des informations indépendantes
|
|
(comme les dossiers, le quota).
|
|
|
|
Si on se contente de cela, l'affichage donnera un aspect décomposé
|
|
qui n'est pas très séduisant (à cause de la latence notamment). Il
|
|
faudrait pouvoir envoyer le menu par la même occasion, le souci
|
|
étant de savoir lequel...
|
|
|
|
Une solution possible : il suffirait de déplacer le menu vers la
|
|
droite pour l'aligner avec le contenu, remonter la liste des
|
|
dossiers (même hauteur que le menu) et renvoyer le menu en même
|
|
temps que le contenu. Le rendu sera plus uniforme je pense.
|
|
|
|
"""
|
|
action = request.GET.get("action", None)
|
|
|
|
if action is not None:
|
|
if not action in globals():
|
|
raise WebmailError(_("Undefined action"))
|
|
response = globals()[action](request)
|
|
else:
|
|
if request.is_ajax():
|
|
raise WebmailError(_("Bad request"))
|
|
response = dict(selection="webmail")
|
|
|
|
curmbox = get_navparam(request, "mbox", "INBOX")
|
|
if not request.is_ajax():
|
|
request.session["lastaction"] = None
|
|
imapc = get_imapconnector(request)
|
|
response["hdelimiter"] = imapc.hdelimiter
|
|
response["mboxes"] = render_mboxes_list(request, imapc)
|
|
imapc.getquota(curmbox)
|
|
response["refreshrate"] = \
|
|
int(parameters.get_user(request.user, "REFRESH_INTERVAL"))
|
|
response["quota"] = ImapListing.computequota(imapc)
|
|
trash = parameters.get_user(request.user, "TRASH_FOLDER")
|
|
response["trash"] = trash
|
|
response["ro_mboxes"] = [
|
|
"INBOX", "Junk",
|
|
parameters.get_user(request.user, "SENT_FOLDER"),
|
|
trash,
|
|
parameters.get_user(request.user, "DRAFTS_FOLDER")
|
|
]
|
|
return render(request, "webmail/index.html", response)
|
|
|
|
if action in ["reply", "forward"]:
|
|
action = "compose"
|
|
if request.session["lastaction"] != action:
|
|
extra_args = {}
|
|
if "menuargs" in response:
|
|
extra_args = response["menuargs"]
|
|
del response["menuargs"]
|
|
try:
|
|
response["menu"] = \
|
|
getattr(webmail_tags, "%s_menu" % action)("", curmbox, request.user, **extra_args)
|
|
except KeyError:
|
|
pass
|
|
|
|
response.update(callback=action)
|
|
if not "status" in response:
|
|
response.update(status="ok")
|
|
return ajax_simple_response(response)
|