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 submitfilter( request, setname, okmsg, tplname, tplctx, update=False, sc=None): form = build_filter_form_from_qdict(request) if form.is_valid(): if sc is None: sc = SieveClient(user=request.user.username, password=request.session["password"]) fset = sc.getscript(setname, format="fset") conditions, actions = form.tofilter() match_type = form.cleaned_data["match_type"] if match_type == "all": match_type = "anyof" conditions = [("true",)] fltname = form.cleaned_data["name"].encode("utf-8") try: if not update: fset.addfilter(fltname, conditions, actions, match_type) else: oldname = request.POST["oldname"].encode("utf-8") fset.updatefilter( oldname, fltname, conditions, actions, match_type ) except (BadArgument, BadValue) as inst: raise BadRequest(str(inst)) sc.pushscript(fset.name, str(fset)) return render_to_json_response(okmsg) return render_to_json_response({'form_errors': form.errors}, status=400)
def newfolder(request, tplname="webmail/folder.html"): mbc = IMAPconnector(user=request.user.username, password=request.session["password"]) 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 render_to_json_response({ 'respmsg': _("Mailbox created"), 'newmb': form.cleaned_data["name"], 'parent': pf }) return render_to_json_response({'form_errors': form.errors}, status=400) ctx = {"title": _("Create a new mailbox"), "formid": "mboxform", "action": reverse("webmail:folder_add"), "action_label": _("Create"), "action_classes": "submit", "withunseen": False, "selectonly": True, "mboxes": mbc.getmboxes(request.user), "hdelimiter": mbc.hdelimiter, "form": FolderForm(), "selected": None} return render(request, tplname, ctx)
def autoreply(request, tplname="modoboa_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(mb, request.POST, instance=arm) else: form = ARmessageForm(mb, request.POST) if form.is_valid(): form.save() return render_to_json_response( _("Auto reply message updated successfully.") ) return render_to_json_response( {"form_errors": form.errors}, status=400 ) form = ARmessageForm(mb, instance=arm) return render_to_json_response({ "content": render_to_string(tplname, {"form": form}, request), "onload_cb": "autoreply_cb" })
def profile(request, tplname="core/user_profile.html"): """Profile detail/update view.""" update_password = True results = signals.allow_password_change.send( sender="profile", user=request.user) if True in [result[1] for result in results]: 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"] = force_text(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(tplname, { "form": form }, request) })
def shared_calendar(request, pk): """Edit or remove a shared calendar.""" try: scal = SharedCalendar.objects.select_related().get(pk=pk) except SharedCalendar.DoesNotExist: raise NotFound if not request.user.can_access(scal.domain): raise PermDeniedException if request.method == "DELETE": if not request.user.can_access(scal.domain): raise PermDeniedException scal.delete() return render_to_json_response(_("Calendar removed")) if request.method == "POST": form = SharedCalendarForm(request.user, request.POST, instance=scal) if form.is_valid(): form.save() return render_to_json_response(_("Calendar updated")) return render_to_json_response( {"form_errors": form.errors}, status=400 ) form = SharedCalendarForm(request.user, instance=scal) return render(request, "common/generic_modal_form.html", { "form": form, "formid": "sharedcal_form", "title": scal.name, "action": reverse("radicale:shared_calendar", args=[scal.pk]), "action_classes": "submit", "action_label": _("Submit") })
def graphs(request): gset = request.GET.get("gset", None) gsets = events.raiseDictEvent("GetGraphSets") if gset not in gsets: raise NotFound(_("Unknown graphic set")) searchq = request.GET.get("searchquery", None) period = request.GET.get("period", "day") tplvars = dict(graphs={}, period=period) domain = check_domain_access(request.user, searchq) if domain is None: return render_to_json_response({}) tplvars["domain"] = domain if period == "custom": if "start" not in request.GET or "end" not in request.GET: raise BadRequest(_("Bad custom period")) start = request.GET["start"] end = request.GET["end"] expr = re.compile(r'[:\- ]') period_name = "%s_%s" % (expr.sub('', start), expr.sub('', end)) start = date_to_timestamp(expr.split(start)) end = date_to_timestamp(expr.split(end)) else: end = int(time.mktime(time.localtime())) start = "-1%s" % period period_name = period tplvars["graphs"] = gsets[gset].export(tplvars["domain"], start, end) tplvars["period_name"] = period_name tplvars["start"] = start tplvars["end"] = end return render_to_json_response(tplvars)
def mark_messages(request, selection, mtype, recipient_db=None): """Mark a selection of messages as spam. :param str selection: message unique identifier :param str mtype: type of marking (spam or ham) """ if not manual_learning_enabled(request.user): return render_to_json_response({"status": "ok"}) if recipient_db is None: recipient_db = ( "user" if request.user.group == "SimpleUsers" else "global" ) selection = check_mail_id(request, selection) connector = get_connector() saclient = SpamassassinClient(request.user, recipient_db) for item in selection: rcpt, mail_id = item.split() content = connector.get_mail_content(mail_id) result = saclient.learn_spam(rcpt, content) if mtype == "spam" \ else saclient.learn_ham(rcpt, content) if not result: break connector.set_msgrcpt_status(rcpt, mail_id, mtype[0].upper()) if saclient.error is None: saclient.done() message = ungettext("%(count)d message processed successfully", "%(count)d messages processed successfully", len(selection)) % {"count": len(selection)} else: message = saclient.error status = 400 if saclient.error else 200 return render_to_json_response({ "message": message, "reload": True }, status=status)
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 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 get_templates(request, ftype): if ftype == "condition": return render_to_json_response( FilterForm([], [], request).cond_templates ) return render_to_json_response( FilterForm([], [], request).action_templates )
def removefilter(request, setname, fname): sc = SieveClient(user=request.user.username, password=request.session["password"]) fset = sc.getscript(setname, format="fset") if fset.removefilter(fname.encode("utf-8")): sc.pushscript(fset.name, str(fset)) return render_to_json_response(_("Filter removed")) return render_to_json_response(_("Failed to remove filter"), status=500)
def send_virus(request): status, error = sendmail_fromfile( "*****@*****.**", request.user.username, os.path.join(settings.MODOBOA_DIR, "tmp/virus.msg") ) if status: return render_to_json_response(_("Message sent")) return render_to_json_response(error, status=500)
def scan_for_services(request): try: Service.objects.load_from_master_cf() except IOError as e: return render_to_json_response([str(e)], status=500) return render_to_json_response( dict((srv.name, srv.id) for srv in Service.objects.all()) )
def saveparameters(request): for formdef in parameters.get_admin_forms(request.POST): form = formdef["form"] if form.is_valid(): form.save() form.to_django_settings() continue return render_to_json_response( {'form_errors': form.errors, 'prefix': form.app}, status=400 ) return render_to_json_response(_("Parameters saved"))
def editfolder(request, tplname="modoboa_webmail/folder.html"): mbc = IMAPconnector(user=request.user.username, password=request.session["password"]) ctx = {"title": _("Edit mailbox"), "formid": "mboxform", "action": reverse("modoboa_webmail:folder_change"), "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) oldname, oldparent = separate_mailbox( request.POST["oldname"], sep=mbc.hdelimiter ) res = {'respmsg': _("Mailbox updated")} if form.cleaned_data["name"] != oldname \ or (pf != oldparent): newname = form.cleaned_data["name"] if pf is None \ else mbc.hdelimiter.join([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 WebmailNavigationParameters(request).remove('mbox') return render_to_json_response(res) return render_to_json_response( {'form_errors': form.errors}, status=400) name = request.GET.get("name", None) if name is None: raise BadRequest(_("Invalid request")) shortname, parent = separate_mailbox(name, sep=mbc.hdelimiter) ctx = {"title": _("Edit mailbox"), "formid": "mboxform", "action": reverse("modoboa_webmail:folder_change"), "action_label": _("Update"), "action_classes": "submit", "withunseen": False, "selectonly": True, "hdelimiter": mbc.hdelimiter, "mboxes": mbc.getmboxes(request.user, until_mailbox=parent), "form": FolderForm(), "selected": parent} ctx["form"].fields["oldname"].initial = name ctx["form"].fields["name"].initial = shortname return render(request, tplname, ctx)
def release(request, mail_id): """Release message selection. :param str mail_id: message unique identifier """ mail_id = check_mail_id(request, mail_id) msgrcpts = [] connector = get_connector() valid_addresses = get_user_valid_addresses(request.user) for mid in mail_id: r, i = mid.split() if valid_addresses and r not in valid_addresses: continue msgrcpts += [connector.get_recipient_message(r, i)] if request.user.group == "SimpleUsers" and \ parameters.get_admin("USER_CAN_RELEASE") == "no": for msgrcpt in msgrcpts: connector.set_msgrcpt_status( msgrcpt.rid.email, msgrcpt.mail.mail_id, 'p' ) message = ungettext("%(count)d request sent", "%(count)d requests sent", len(mail_id)) % {"count": len(mail_id)} return render_to_json_response({ "message": message, "url": QuarantineNavigationParameters(request).back_to_listing() }) amr = AMrelease() error = None for rcpt in msgrcpts: result = amr.sendreq( rcpt.mail.mail_id, rcpt.mail.secret_id, rcpt.rid.email ) if result: connector.set_msgrcpt_status(rcpt.rid.email, rcpt.mail.mail_id, 'R') else: error = result break if not error: message = ungettext("%(count)d message released successfully", "%(count)d messages released successfully", len(mail_id)) % {"count": len(mail_id)} else: message = error status = 400 if error else 200 return render_to_json_response({ "message": message, "url": QuarantineNavigationParameters(request).back_to_listing() }, status=status)
def _validate_alias(request, form, successmsg, callback=None): """Alias validation Common function shared between creation and modification actions. """ if form.is_valid(): try: alias = form.save() except IntegrityError: raise Conflict(_("Alias with this name already exists")) if callback: callback(request.user, alias) return render_to_json_response(successmsg) return render_to_json_response({'form_errors': form.errors}, status=400)
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 check_top_notifications(request): """ AJAX service to check for new top notifications to display. """ return render_to_json_response( events.raiseQueryEvent("TopNotifications", request, True) )
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 list_quotas(request): sort_order, sort_dir = get_sort_order(request.GET, "name") domains = Domain.objects.get_for_admin(request.user) domains = domains.exclude(quota=0) if sort_order in ["name", "quota"]: domains = domains.order_by("{}{}".format(sort_dir, sort_order)) elif sort_order == "allocated_quota": domains = ( domains.annotate(allocated_quota=Sum("mailbox__quota")) .order_by("{}{}".format(sort_dir, sort_order)) ) page = get_listing_page(domains, request.GET.get("page", 1)) context = { "headers": render_to_string( "admin/domains_quota_headers.html", {}, request ) } if page is None: context["length"] = 0 else: context["rows"] = render_to_string( "admin/domains_quotas.html", {"domains": page}, request ) context["pages"] = [page.number] return render_to_json_response(context)
def check_top_notifications(request): """AJAX service to check for new top notifications to display.""" notifications = signals.get_top_notifications.send( sender="top_notifications", include_all=True) notifications = reduce( lambda a, b: a + b, [notif[1] for notif in notifications]) return render_to_json_response(notifications)
def learning_recipient(request): """A view to select the recipient database of a learning action.""" if request.method == "POST": form = LearningRecipientForm(request.user, request.POST) if form.is_valid(): return mark_messages( request, form.cleaned_data["selection"].split(","), form.cleaned_data["ltype"], form.cleaned_data["recipient"] ) return render_to_json_response( {"form_errors": form.errors}, status=400 ) ltype = request.GET.get("type", None) selection = request.GET.get("selection", None) if ltype is None or selection is None: raise BadRequest form = LearningRecipientForm(request.user) form.fields["ltype"].initial = ltype form.fields["selection"].initial = selection return render(request, "common/generic_modal_form.html", { "title": _("Select a database"), "formid": "learning_recipient_form", "action": reverse("amavis:learning_recipient_set"), "action_classes": "submit", "action_label": _("Validate"), "form": form })
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": request.localconfig.parameters.get_value( "handle_mailboxes", raise_exception=False) } page = get_listing_page(objects, request.GET.get("page", 1)) if page is None: context["length"] = 0 else: context["headers"] = render_to_string( "admin/identity_headers.html", {}, request) context["rows"] = render_to_string( "admin/identities_table.html", { "identities": page.object_list }, request ) context["pages"] = [page.number] return render_to_json_response(context)
def getfs(request, name): sc = SieveClient(user=request.user.username, password=request.session["password"]) editormode = parameters.get_user(request.user, "EDITOR_MODE") error = None try: content = sc.getscript(name, format=editormode) except SieveClientError as e: error = str(e) else: if content is None: error = _("Failed to retrieve filters set") if error is not None: return ajax_response(request, "ko", respmsg=error) if editormode == "raw": htmlcontent = render_to_string("modoboa_sievefilters/rawfilter.html", dict( name=name, scriptcontent=content )) else: htmlcontent = render_to_string("modoboa_sievefilters/guieditor.html", dict( fs=content )) menu = '<ul id="fsetmenu" class="nav nav-sidebar"><li class="nav-header">%s</li>%s</ul>' % \ (_("Actions"), fset_menu(editormode, name)) resp = dict(menu=menu, content=htmlcontent) return render_to_json_response(resp)
def submailboxes(request): """Retrieve the sub mailboxes of a mailbox.""" topmailbox = request.GET.get('topmailbox', '') with_unseen = request.GET.get('unseen', None) mboxes = get_imapconnector(request).getmboxes( request.user, topmailbox, unseen_messages=with_unseen == 'true') return render_to_json_response(mboxes)
def done(self): from modoboa.lib.web_utils import render_to_json_response account = self.first_step.form.save() account.post_create(self.request.user) mailform = self.steps[1].form mailform.save(self.request.user, account) return render_to_json_response(_("Account created"))
def done(self): calendar = self.first_step.form.save(commit=False) if self.request.user.group == 'SimpleUsers': calendar.mailbox = self.request.user.mailbox_set.all()[0] calendar.save() self.steps[1].form.calendar = calendar self.steps[1].form.save() return render_to_json_response(_("Calendar created"))
def information(request, tplname="core/information.html"): status, extensions = check_for_updates(request) return render_to_json_response({ "content": render_to_string(tplname, { "update_avail": status, "extensions": extensions, }), })
def move(request): for arg in ["msgset", "to"]: if arg not in request.GET: raise BadRequest(_("Invalid request")) mbc = get_imapconnector(request) navparams = WebmailNavigationParameters(request) mbc.move(request.GET["msgset"], navparams.get('mbox'), request.GET["to"]) resp = listmailbox(request, navparams.get('mbox'), update_session=False) return render_to_json_response(resp)
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 done(self): genform = self.first_step.form domain = genform.save(self.request.user) domain.post_create(self.request.user) for step in self.steps[1:]: if not step.check_access(self): continue step.form.save(user=self.request.user, domain=domain) return render_to_json_response(_("Domain created"))
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 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 delete_selfservice(request, mail_id): rcpt = request.GET.get("rcpt", None) if rcpt is None: raise BadRequest(_("Invalid request")) try: get_connector().set_msgrcpt_status(rcpt, mail_id, 'D') except Msgrcpt.DoesNotExist: raise BadRequest(_("Invalid request")) return render_to_json_response(_("Message deleted"))
def delalias(request): selection = request.GET["selection"].split(",") for alid in selection: alias = Alias.objects.get(pk=alid) if not request.user.can_access(alias): raise PermDeniedException alias.delete() msg = ungettext("Alias deleted", "Aliases deleted", len(selection)) return render_to_json_response(msg)
def mark_as_junk(request): """Mark a message as SPAM.""" count = _move_selection_to_folder( request, request.user.parameters.get_value("junk_folder")) message = ungettext("%(count)d message marked", "%(count)d messages marked", count) % { "count": count } return render_to_json_response(message)
def empty_quarantine(): """Shortcut to use when no content can be displayed.""" content = loader.render_to_string( "modoboa_amavis/empty_quarantine.html", { "message_types": constants.MESSAGE_TYPES } ) ctx = getctx("ok", level=2, listing=content) return render_to_json_response(ctx)
def empty(request): """Empty the trash folder.""" name = request.GET.get("name", None) if name != request.user.parameters.get_value("trash_folder"): raise BadRequest(_("Invalid request")) get_imapconnector(request).empty(name) content = u"<div class='alert alert-info'>%s</div>" % _("Empty folder") return render_to_json_response({ 'listing': content, 'mailbox': name, 'pages': [1] })
def check_unseen_messages(request): mboxes = request.GET.get("mboxes", None) if not mboxes: raise BadRequest(_("Invalid request")) mboxes = mboxes.split(",") counters = {} imapc = get_imapconnector(request) for mb in mboxes: counters[mb] = imapc.unseen_messages(mb) return render_to_json_response(counters)
def remove_filters_set(request, name): sc = SieveClient(user=request.user.username, password=request.session["password"]) sc.deletescript(name) acs, scripts = sc.listscripts() ctx = { "respmsg": _("Filters set deleted"), "newfs": acs, } return render_to_json_response(ctx)
def get_domain_list(request): """Get the list of domains (and relay domains) the user can see.""" doms = [dom.name for dom in Domain.objects.get_for_admin(request.user)] if exts_pool.is_extension_enabled("postfix_relay_domains"): from modoboa.extensions.postfix_relay_domains.models import RelayDomain doms += [ rdom.name for rdom in RelayDomain.objects.get_for_admin(request.user) ] return render_to_json_response(doms)
def new_shared_calendar(request): """Shared calendar creation view.""" if request.method == "POST": form = SharedCalendarForm(request.user, request.POST) if form.is_valid(): form.save() return render_to_json_response(_("Calendar created")) return render_to_json_response({"form_errors": form.errors}, status=400) form = SharedCalendarForm(request.user) return render( request, "common/generic_modal_form.html", { "form": form, "formid": "sharedcal_form", "title": _("New shared calendar"), "action": reverse("modoboa_radicale:shared_calendar_add"), "action_classes": "submit", "action_label": _("Submit") })
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 validate_step(self): stepid = self.request.POST.get("stepid", None) if stepid is None: raise BadRequest(_("Invalid request")) stepid = int(stepid.replace("step", "")) if stepid < 0 or stepid > len(self.steps): raise BadRequest(_("Invalid request")) self.create_forms(self.request.POST) statuses = [] for cpt in xrange(0, stepid): statuses.append(self.steps[cpt].form.is_valid()) if False in statuses: return render_to_json_response({ 'stepid': stepid, 'form_errors': self.errors }, status=400) if stepid == len(self.steps): return self.done() return render_to_json_response( {'title': self.steps[stepid].title, 'stepid': stepid} )
def done(self): genform = self.first_step.form domain = genform.save(self.request.user) domain.post_create(self.request.user) try: self.steps[1].form.save(self.request.user, domain) except ModoboaException: from django.db import transaction transaction.rollback() raise return render_to_json_response(_("Domain created"))
def logs_page(request, tplname="core/logs_page.html"): """Return a page containing logs.""" page = get_logs_page(request) if page is None: context = {"length": 0} else: context = { "rows": render_to_string(tplname, {"logs": page.object_list}), "pages": [page.number] } return render_to_json_response(context)
def create(request, tplname="postfix_relay_domains/new_relaydomain_form.html"): events.raiseEvent("CanCreate", request.user, "relay_domains") if request.method == 'POST': form = RelayDomainFormGeneral(request.POST) if form.is_valid(): rdom = form.save(request.user) rdom.post_create(request.user) return render_to_json_response(_("Relay domain created")) return render_to_json_response({'form_errors': form.errors}, status=400) ctx = { "title": _("New relay domain"), "action_label": _("Create"), "action_classes": "submit", "action": reverse("postfix_relay_domains:relaydomain_add"), "formid": "rdomform", "form": RelayDomainFormGeneral() } return render(request, tplname, ctx)
def _domains(request): sort_order, sort_dir = get_sort_order(request.GET, "name") extra_filters = signals.extra_domain_filters.send(sender="_domains") if extra_filters: extra_filters = reduce(lambda a, b: a + b, [result[1] for result in extra_filters]) filters = { 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]["name"], 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)) parameters = request.localconfig.parameters dns_checks = { "enable_mx_checks": parameters.get_value("enable_mx_checks"), "enable_spf_checks": parameters.get_value("enable_spf_checks"), "enable_dkim_checks": parameters.get_value("enable_dkim_checks"), "enable_dmarc_checks": parameters.get_value("enable_dmarc_checks"), "enable_autoconfig_checks": (parameters.get_value("enable_autoconfig_checks")), "enable_dnsbl_checks": parameters.get_value("enable_dnsbl_checks") } context["headers"] = render_to_string("admin/domain_headers.html", dns_checks, request) if page is None: context["length"] = 0 else: tpl_context = {"domains": page.object_list} tpl_context.update(dns_checks) context["rows"] = render_to_string("admin/domains_table.html", tpl_context, request) context["pages"] = [page.number] return render_to_json_response(context)
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'): update_password = True if True in events.raiseQueryEvent("PasswordChange", request.user): update_password = False if request.method == "POST": form = ProfileForm(update_password, request.POST, instance=request.user) if form.is_valid(): form.save() if update_password and form.cleaned_data["confirmation"] != "": request.session["password"] = encrypt( form.cleaned_data["confirmation"]) return 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 logs(request, tplname="core/logs.html"): """Return a list of log entries. This view is only called the first time the page is displayed. """ page = get_logs_page(request, 1) return render_to_json_response({ "callback": "logs", "content": render_to_string(tplname, {"logs": page.object_list}), "page": page.number })
def profile(request, tplname="core/user_profile.html"): """Profile detail/update view.""" update_password = True results = signals.allow_password_change.send(sender="profile", user=request.user) if True in [result[1] for result in results]: update_password = False password_url = request.localconfig.parameters.get_value( "update_password_url") show_password_url = False if not request.user.is_local and password_url: show_password_url = True 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"] = force_text( 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( tplname, { "form": form, "show_password_url": show_password_url, "password_url": password_url }, request) })
def send_spam(request): status, error = sendmail_simple( "*****@*****.**", request.user.username, content=""" This is the GTUBE, the Generic Test for Unsolicited Bulk Email If your spam filter supports it, the GTUBE provides a test by which you can verify that the filter is installed correctly and is detecting incoming spam. You can send yourself a test mail containing the following string of characters (in upper case and with no white spaces and line breaks): XJS*C4JDBQADN1.NSBN3*2IDNEN*GTUBE-STANDARD-ANTI-UBE-TEST-EMAIL*C.34X You should send this test mail from an account outside of your network. """) if status: return render_to_json_response(_("Message sent")) return render_to_json_response(respmsg=error, status=500)
def process_exception(self, request, exception): if not isinstance(exception, ModoboaException): return None if request.is_ajax() or "/api/" in request.path: if exception.http_code is None: return ajax_response(request, status="ko", respmsg=unicode(exception), norefresh=True) return render_to_json_response(unicode(exception), status=exception.http_code) return _render_error(request, user_context=dict(error=str(exception)))
def username_list(request): """Get the list of username the current user can see.""" result = [] qset = Mailbox.objects.select_related("user") if request.user.has_perm("admin.add_mailbox"): qset = qset.filter( domain__in=Domain.objects.get_for_admin(request.user)) else: user_domain = request.user.mailbox.domain qset = qset.filter(domain=user_domain) for mbox in qset: result.append(mbox.user.username) return render_to_json_response(result)
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 done(self): genform = self.first_step.form domain = genform.save(self.request.user) domain.post_create(self.request.user) for step in self.steps[1:]: if not step.check_access(self): continue try: step.form.save(user=self.request.user, domain=domain) except ModoboaException: from django.db import transaction transaction.rollback() raise return render_to_json_response(_("Domain created"))