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