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 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 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 _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 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 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 _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)