def handle(self, *args, **options): """Command entry point.""" load_core_settings() if not User.objects.filter(is_superuser=True).count(): admin = User(username="******", is_superuser=True) admin.set_password("password") admin.save() ObjectAccess.objects.create(user=admin, content_object=admin, is_owner=True) exts_pool.load_all() superadmin = User.objects.filter(is_superuser=True).first() groups = PERMISSIONS.keys() + [ role[0] for role in events.raiseQueryEvent("GetExtraRoles", superadmin, None) ] for groupname in groups: group, created = Group.objects.get_or_create(name=groupname) permissions = ( PERMISSIONS.get(groupname, []) + events.raiseQueryEvent("GetExtraRolePermissions", groupname)) if not permissions: continue add_permissions_to_group(group, permissions) for extname in exts_pool.extensions.keys(): extension = exts_pool.get_extension(extname) extension.load_initial_data() events.raiseEvent("InitialDataLoaded", extname)
def handle(self, *args, **options): """Command entry point.""" load_core_settings() if not User.objects.filter(is_superuser=True).count(): admin = User(username="******", is_superuser=True) admin.set_password("password") admin.save() ObjectAccess.objects.create( user=admin, content_object=admin, is_owner=True) exts_pool.load_all() superadmin = User.objects.filter(is_superuser=True).first() groups = PERMISSIONS.keys() + [ role[0] for role in events.raiseQueryEvent("GetExtraRoles", superadmin, None) ] for groupname in groups: group, created = Group.objects.get_or_create(name=groupname) permissions = ( PERMISSIONS.get(groupname, []) + events.raiseQueryEvent("GetExtraRolePermissions", groupname) ) if not permissions: continue add_permissions_to_group(group, permissions) for extname in exts_pool.extensions.keys(): extension = exts_pool.get_extension(extname) extension.load_initial_data() events.raiseEvent("InitialDataLoaded", extname)
def user_menu(user, selection): entries = [{ "name": "user", "img": "icon-user icon-white", "label": user.fullname, "menu": [{ "name": "settings", "img": "icon-list", "label": _("Settings"), "url": reverse("modoboa.core.views.user.index") }] }] entries[0]["menu"] += \ events.raiseQueryEvent("UserMenuDisplay", "options_menu", user) \ + [{"name": "logout", "url": reverse("modoboa.core.views.auth.dologout"), "label": _("Logout"), "img": "icon-off"}] return render_to_string("common/menulist.html", { "selection": selection, "entries": entries, "user": user })
def extra_head_content(user): tpl = Template("{% for sc in static_content %}{{ sc|safe }}{% endfor %}") return tpl.render( Context( dict(static_content=events.raiseQueryEvent("GetStaticContent", user)) ) )
def identity_actions(user, ident): name = ident.__class__.__name__ objid = ident.id if name == "User": actions = events.raiseQueryEvent("ExtraAccountActions", ident) actions += [ {"name" : "delaccount", "url" : reverse("modoboa.admin.views.delaccount", args=[objid]), "img" : "icon-trash", "title" : _("Delete this account")}, ] else: if ident.get_recipients_count() >= 2: actions = [ {"name" : "deldlist", "url" : reverse("modoboa.admin.views.deldlist") + "?selection=%s" % objid, "img" : "icon-trash", "title" : _("Delete this distribution list")}, ] elif ident.extmboxes != "": actions = [ {"name" : "delforward", "url" : reverse("modoboa.admin.views.delforward") + "?selection=%s" % objid, "img" : "icon-trash", "title" : _("Delete this forward")}, ] else: actions = [ {"name" : "delalias", "url" : reverse("modoboa.admin.views.delalias") + "?selection=%s" % objid, "img" : "icon-trash", "title" : _("Delete this alias")}, ] return render_actions(actions)
def __init__(self, *args, **kwargs): if "instance" in kwargs: self.mb = kwargs["instance"] del kwargs["instance"] else: self.mb = None super(AccountFormMail, self).__init__(*args, **kwargs) self.field_widths = { "quota": 3 } self.extra_fields = [] result = events.raiseQueryEvent('ExtraFormFields', 'mailform', self.mb) for fname, field in result: self.fields[fname] = field self.extra_fields.append(fname) if self.mb is not None: self.fields["email"].required = True cpt = 1 qset = self.mb.aliasrecipient_set.select_related("alias") for ralias in qset: if ralias.alias.recipients_count >= 2: continue name = "aliases_%d" % cpt self._create_field( UTF8EmailField, name, ralias.alias.address) cpt += 1 self.fields["email"].initial = self.mb.full_address self.fields["quota_act"].initial = self.mb.use_domain_quota if not self.mb.use_domain_quota and self.mb.quota: self.fields["quota"].initial = self.mb.quota else: self.fields["quota_act"].initial = True if len(args) and isinstance(args[0], QueryDict): self._load_from_qdict(args[0], "aliases", UTF8EmailField)
def __init__(self, *args, **kwargs): self.mb = kwargs.pop("instance", None) super(AccountFormMail, self).__init__(*args, **kwargs) self.field_widths = { "quota": 3 } self.extra_fields = [] result = events.raiseQueryEvent('ExtraFormFields', 'mailform', self.mb) for fname, field in result: self.fields[fname] = field self.extra_fields.append(fname) if self.mb is not None: self.fields["email"].required = True cpt = 1 qset = self.mb.aliasrecipient_set.filter(alias__internal=False) for ralias in qset: name = "aliases_%d" % cpt self._create_field( lib_fields.UTF8AndEmptyUserEmailField, name, ralias.alias.address) cpt += 1 self.fields["email"].initial = self.mb.full_address self.fields["quota_act"].initial = self.mb.use_domain_quota if not self.mb.use_domain_quota and self.mb.quota: self.fields["quota"].initial = self.mb.quota else: self.fields["quota_act"].initial = True if len(args) and isinstance(args[0], QueryDict): self._load_from_qdict( args[0], "aliases", lib_fields.UTF8AndEmptyUserEmailField)
def uprefs_menu(selection, user): entries = [ { "name": "profile", "class": "ajaxlink", "url": "profile/", "label": _("Profile") }, { "name": "preferences", "class": "ajaxlink", "url": "preferences/", "label": _("Preferences") }, ] if user.has_mailbox: entries.insert( 0, { "name": "forward", "class": "ajaxlink", "url": "forward/", "label": _("Forward") }) entries += events.raiseQueryEvent("UserMenuDisplay", "uprefs_menu", user) entries = sorted(entries, key=lambda e: e["label"]) return render_to_string( 'common/menu.html', { "entries": entries, "css": "nav nav-list", "selection": selection, "user": user })
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 __init__(self, *args, **kwargs): if "instance" in kwargs: self.mb = kwargs["instance"] del kwargs["instance"] else: self.mb = None super(AccountFormMail, self).__init__(*args, **kwargs) self.extra_fields = [] for fname, field in events.raiseQueryEvent('ExtraFormFields', 'mailform', self.mb): self.fields[fname] = field self.extra_fields.append(fname) if self.mb is not None: self.fields["email"].required = True cpt = 1 for alias in self.mb.alias_set.all(): if len(alias.get_recipients()) >= 2: continue name = "aliases_%d" % cpt self._create_field(forms.EmailField, name, alias.full_address) cpt += 1 self.fields["email"].initial = self.mb.full_address self.fields["quota_act"].initial = self.mb.use_domain_quota if not self.mb.use_domain_quota and self.mb.quota: self.fields["quota"].initial = self.mb.quota else: self.fields["quota_act"].initial = True if len(args) and isinstance(args[0], QueryDict): self._load_from_qdict(args[0], "aliases", forms.EmailField)
def import_domains(request): if request.method == "POST": return importdata(request) helptext = _("""Provide a CSV file where lines respect one of the following formats: <ul> <li><em>domain; name; quota; enabled</em></li> <li><em>domainalias; name; targeted domain; enabled</em></li> %s </ul> <p>The first element of each line is mandatory and must be equal to one of the previous values.</p> <p>You can use a different character as separator.</p> """ % ''.join([unicode(hlp) for hlp in events.raiseQueryEvent('ExtraDomainImportHelp')])) ctx = dict( title=_("Import domains"), action_label=_("Import"), action_classes="submit", action=reverse(import_domains), formid="importform", enctype="multipart/form-data", target="import_target", helptext=helptext, form=ImportDataForm() ) return render(request, "admin/importform.html", ctx)
def __init__(self, request, *args, **kwargs): self.user = request.user self.forms = [{ "id": "general", "title": _("General"), "formtpl": "admin/account_general_form.html", "cls": AccountFormGeneral, "new_args": [self.user], "mandatory": True }, { "id": "mail", "title": _("Mail"), "formtpl": "admin/mailform.html", "cls": AccountFormMail }, { "id": "perms", "title": _("Permissions"), "formtpl": "admin/permsform.html", "cls": AccountPermissionsForm }] cbargs = [self.user] if "instances" in kwargs: cbargs += [kwargs["instances"]["general"]] self.forms += events.raiseQueryEvent("ExtraAccountForm", *cbargs) super(AccountForm, self).__init__(request, *args, **kwargs)
def admin_menu(selection, user): entries = [] if user.has_perm("admin.view_domains"): entries += [{ "name": "domains", "url": reverse("modoboa.admin.views.domains"), "label": _("Domains") }] entries += \ events.raiseQueryEvent("AdminMenuDisplay", "top_menu", user) if user.has_perm("admin.add_user") or user.has_perm("admin.add_alias"): entries += [ { "name": "identities", "url": reverse("modoboa.admin.views.identities"), "label": _("Identities") }, ] if user.is_superuser: entries += [{ "name": "settings", "label": _("Modoboa"), "url": reverse("modoboa.admin.views.viewsettings") }] if not len(entries): return "" return render_to_string("common/menulist.html", { "entries": entries, "selection": selection, "user": user })
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 __init__(self, *args, **kwargs): self.mb = kwargs.pop("instance", None) super(AccountFormMail, self).__init__(*args, **kwargs) self.field_widths = {"quota": 3} self.extra_fields = [] result = events.raiseQueryEvent('ExtraFormFields', 'mailform', self.mb) for fname, field in result: self.fields[fname] = field self.extra_fields.append(fname) if self.mb is not None: self.fields["email"].required = True qset = self.mb.aliasrecipient_set.filter(alias__internal=False) for cpt, ralias in enumerate(qset): name = "aliases_{}".format(cpt + 1) self._create_field(lib_fields.UTF8AndEmptyUserEmailField, name, ralias.alias.address) for cpt, saddress in enumerate(self.mb.senderaddress_set.all()): name = "senderaddress_{}".format(cpt + 1) self._create_field(lib_fields.UTF8AndEmptyUserEmailField, name, saddress.address) self.fields["email"].initial = self.mb.full_address self.fields["quota_act"].initial = self.mb.use_domain_quota if not self.mb.use_domain_quota and self.mb.quota: self.fields["quota"].initial = self.mb.quota else: self.fields["quota_act"].initial = True if len(args) and isinstance(args[0], QueryDict): self._load_from_qdict(args[0], "aliases", lib_fields.UTF8AndEmptyUserEmailField) self._load_from_qdict(args[0], "senderaddress", lib_fields.UTF8AndEmptyUserEmailField)
def uprefs_menu(selection, user): entries = [ {"name": "profile", "class": "ajaxnav", "url": "profile/", "label": _("Profile")}, {"name": "preferences", "class": "ajaxnav", "url": "preferences/", "label": _("Preferences")}, ] if user.is_superuser: entries.append({ "name": "api", "class": "ajaxnav", "url": "api/", "label": _("API"), }) entries += events.raiseQueryEvent("UserMenuDisplay", "uprefs_menu", user) entries = sorted(entries, key=lambda e: e["label"]) return render_to_string('common/menu.html', { "entries": entries, "css": "nav nav-sidebar", "selection": selection, "user": user })
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 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 import_domains(request): if request.method == "POST": return importdata(request) helptext = _( """Provide a CSV file where lines respect one of the following formats: <ul> <li><em>domain; name; quota; enabled</em></li> <li><em>domainalias; name; targeted domain; enabled</em></li> %s </ul> <p>The first element of each line is mandatory and must be equal to one of the previous values.</p> <p>You can use a different character as separator.</p> """ % ''.join([ unicode(hlp) for hlp in events.raiseQueryEvent('ExtraDomainImportHelp') ])) ctx = dict(title=_("Import domains"), action_label=_("Import"), action_classes="submit", action=reverse("admin:domain_import"), formid="importform", enctype="multipart/form-data", target="import_target", helptext=helptext, form=ImportDataForm()) return render(request, "admin/importform.html", ctx)
def identity_actions(user, ident): name = ident.__class__.__name__ objid = ident.id if name == "User": actions = events.raiseQueryEvent("ExtraAccountActions", ident) actions += [ { "name": "delaccount", "url": reverse("admin:account_delete", args=[objid]), "img": "fa fa-trash", "title": _("Delete %s?" % ident.username) }, ] else: actions = [ { "name": "delalias", "url": "{}?selection={}".format(reverse("admin:alias_delete"), objid), "img": "fa fa-trash", "title": _("Delete %s?" % ident.address) }, ] return render_actions(actions)
def admin_menu(selection, user): entries = [] if user.has_perm("admin.view_domains"): entries += [ {"name" : "domains", "url" : reverse("modoboa.admin.views.domains"), "label" : _("Domains")} ] entries += \ events.raiseQueryEvent("AdminMenuDisplay", "top_menu", user) if user.has_perm("admin.add_user") or user.has_perm("admin.add_alias"): entries += [ {"name" : "identities", "url" : reverse("modoboa.admin.views.identities"), "label" : _("Identities")}, ] if user.is_superuser: entries += [ {"name" : "settings", "label" : _("Modoboa"), "url" : reverse("modoboa.admin.views.viewsettings")} ] if not len(entries): return "" return render_to_string("common/menulist.html", {"entries" : entries, "selection" : selection, "user" : 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 identity_actions(user, ident): name = ident.__class__.__name__ objid = ident.id if name == "User": actions = events.raiseQueryEvent("ExtraAccountActions", ident) actions += [ {"name" : "delaccount", "url" : reverse("modoboa.admin.views.delaccount") + "?selection=%s" % objid, "img" : "icon-trash", "title" : _("Delete this account")}, ] else: if ident.get_recipients_count() >= 2: actions = [ {"name" : "deldlist", "url" : reverse("modoboa.admin.views.deldlist") + "?selection=%s" % objid, "img" : "icon-trash", "title" : _("Delete this distribution list")}, ] elif ident.extmboxes != "": actions = [ {"name" : "delforward", "url" : reverse("modoboa.admin.views.delforward") + "?selection=%s" % objid, "img" : "icon-trash", "title" : _("Delete this forward")}, ] else: actions = [ {"name" : "delalias", "url" : reverse("modoboa.admin.views.delalias") + "?selection=%s" % objid, "img" : "icon-trash", "title" : _("Delete this alias")}, ] return render_actions(actions)
def uprefs_menu(selection, user): entries = [ {"name": "profile", "class": "ajaxlink", "url": "profile/", "label": _("Profile")}, {"name": "preferences", "class": "ajaxlink", "url": "preferences/", "label": _("Preferences")}, ] if user.has_mailbox: entries.insert(0, {"name": "forward", "class": "ajaxlink", "url": "forward/", "label": _("Forward")}) entries += events.raiseQueryEvent("UserMenuDisplay", "uprefs_menu", user) entries = sorted(entries, key=lambda e: e["label"]) return render_to_string('common/menu.html', { "entries": entries, "css": "nav nav-list", "selection": selection, "user": user })
def identity_actions(user, ident): name = ident.__class__.__name__ objid = ident.id if name == "User": actions = events.raiseQueryEvent("ExtraAccountActions", ident) actions += [ { "name": "delaccount", "url": reverse("modoboa.extensions.admin.views.identity.delaccount", args=[objid]), "img": "icon-trash", "title": _("Delete %s?" % ident.username) }, ] else: actions = [ { "name": "delalias", "url": reverse("modoboa.extensions.admin.views.alias.delalias") + "?selection=%s" % objid, "img": "icon-trash", "title": _("Delete %s?" % ident.full_address) }, ] return render_actions(actions)
def user_menu(user, selection): entries = [{ "name": "user", "img": "fa fa-user", "label": user.fullname, "menu": [{ "name": "settings", "img": "fa fa-list", "label": _("Settings"), "url": reverse("core:user_index") }] }] entries[0]["menu"] += \ events.raiseQueryEvent("UserMenuDisplay", "options_menu", user) \ + [{"name": "logout", "url": reverse("core:logout"), "label": _("Logout"), "img": "fa fa-sign-out"}] return render_to_string("common/menulist.html", { "selection": selection, "entries": entries, "user": user })
def __init__(self, *args, **kwargs): if "instance" in kwargs: self.mb = kwargs["instance"] del kwargs["instance"] else: self.mb = None super(AccountFormMail, self).__init__(*args, **kwargs) self.field_widths = {"quota": 3} self.extra_fields = [] result = events.raiseQueryEvent('ExtraFormFields', 'mailform', self.mb) for fname, field in result: self.fields[fname] = field self.extra_fields.append(fname) if self.mb is not None: self.fields["email"].required = True cpt = 1 qset = self.mb.aliasrecipient_set.select_related("alias") for ralias in qset: if ralias.alias.recipients_count >= 2: continue name = "aliases_%d" % cpt self._create_field(forms.EmailField, name, ralias.alias.address) cpt += 1 self.fields["email"].initial = self.mb.full_address self.fields["quota_act"].initial = self.mb.use_domain_quota if not self.mb.use_domain_quota and self.mb.quota: self.fields["quota"].initial = self.mb.quota else: self.fields["quota_act"].initial = True if len(args) and isinstance(args[0], QueryDict): self._load_from_qdict(args[0], "aliases", forms.EmailField)
def extensions_menu(selection, user): menu = events.raiseQueryEvent("UserMenuDisplay", "top_menu", user) return render_to_string('common/menulist.html', { "selection": selection, "entries": menu, "user": user })
def uprefs_menu(selection, user): entries = [ { "name": "profile", "class": "ajaxnav", "url": "profile/", "label": _("Profile") }, { "name": "preferences", "class": "ajaxnav", "url": "preferences/", "label": _("Preferences") }, ] if user.is_superuser: entries.append({ "name": "api", "class": "ajaxnav", "url": "api/", "label": _("API"), }) entries += events.raiseQueryEvent("UserMenuDisplay", "uprefs_menu", user) entries = sorted(entries, key=lambda e: e["label"]) return render_to_string( 'common/menu.html', { "entries": entries, "css": "nav nav-sidebar", "selection": selection, "user": user })
def domain_actions(user, domain): actions = [] if domain.__class__.__name__ == 'Domain': actions = [{ "name": "listidentities", "url": reverse("modoboa.extensions.admin.views.identity.identities") + "#list/?searchquery=@%s" % domain.name, "title": _("View the domain's identities"), "img": "icon-user" }] if user.has_perm("admin.delete_domain"): actions.append({ "name": "deldomain", "url": reverse("modoboa.extensions.admin.views.domain.deldomain", args=[domain.id]), "title": _("Delete %s?" % domain.name), "img": "icon-trash" }) else: actions = events.raiseQueryEvent('GetDomainActions', user, domain) return render_actions(actions)
def domains_menu(selection, user): """Specific menu for domain related operations. Corresponds to the menu visible on the left column when you go to *Domains*. :param str selection: menu entry currently selected :param ``User`` user: connected user :rtype: str :return: rendered menu (as HTML) """ domain_list_url = ("list/" if selection != "statistics" else reverse("admin:domain_list")) entries = [{ "name": "domains", "label": _("List domains"), "img": "fa fa-user", "class": "ajaxnav navigation", "url": domain_list_url }, { "name": "statistics", "label": _("Statistics"), "img": "fa fa-line-chart", "class": "navigation", "url": reverse("admin:domain_statistics") }] if user.has_perm("admin.add_domain"): entries += [ { "name": "newdomain", "label": _("Add domain"), "img": "fa fa-plus", "modal": True, "modalcb": "admin.newdomain_cb", "url": reverse("admin:domain_add") }, ] entries += events.raiseQueryEvent("ExtraDomainMenuEntries", user) entries += [{ "name": "import", "label": _("Import"), "img": "fa fa-folder-open", "url": reverse("admin:domain_import"), "modal": True, "modalcb": "admin.importform_cb" }, { "name": "export", "label": _("Export"), "img": "fa fa-share-alt", "url": reverse("admin:domain_export"), "modal": True, "modalcb": "admin.exportform_cb" }] return render_to_string('common/menulist.html', { "entries": entries, "selection": selection, "user": user })
def extra_head_content(user): tpl = template.Template( "{% for sc in static_content %}{{ sc|safe }}{% endfor %}") return tpl.render( template.Context({ 'static_content': events.raiseQueryEvent("GetStaticContent", user) }))
def extra_roles(user, account): """Return new roles.""" filters = events.raiseQueryEvent("UserCanSetRole", user, "DomainAdmins", account) if user.has_perm("admin.add_domain") and \ (not filters or True in filters): return [("DomainAdmins", _("Domain administrator"))] return []
def domains_menu(selection, user): """Specific menu for domain related operations. Corresponds to the menu visible on the left column when you go to Domains. :param str selection: menu entry currently selected :param ``User`` user: connected user :rtype: str :return: rendered menu (as HTML) """ if not user.has_perm("admin.add_domain"): return "" entries = [ { "name": "newdomain", "label": _("Add domain"), "img": "icon-plus", "modal": True, "modalcb": "admin.newdomain_cb", "url": reverse("modoboa.extensions.admin.views.domain.newdomain") }, ] entries += events.raiseQueryEvent("ExtraDomainMenuEntries", user) entries += [{ "name": "import", "label": _("Import"), "img": "icon-folder-open", "url": reverse("modoboa.extensions.admin.views.import.import_domains"), "modal": True, "modalcb": "admin.importform_cb" }, { "name": "export", "label": _("Export"), "img": "icon-share-alt", "url": reverse("modoboa.extensions.admin.views.export.export_domains"), "modal": True, "modalcb": "admin.exportform_cb" }] return render_to_string('common/menulist.html', { "entries": entries, "selection": selection, "user": user })
def __init__(self, user, *args, **kwargs): super(DomainFormOptions, self).__init__(*args, **kwargs) if False in events.raiseQueryEvent("UserCanSetRole", user, "DomainAdmins"): self.fields = {} return if args: if args[0].get("create_dom_admin", "no") == "yes": self.fields["dom_admin_username"].required = True self.fields["create_aliases"].required = True
def extra_head_content(user): tpl = template.Template( "{% for sc in static_content %}{{ sc|safe }}{% endfor %}" ) return tpl.render( template.Context({ 'static_content': events.raiseQueryEvent("GetStaticContent", user) }) )
def __init__(self, user, *args, **kwargs): super(DomainFormOptions, self).__init__(*args, **kwargs) if False in events.raiseQueryEvent('UserCanSetRole', user, 'DomainAdmins'): self.fields = {} return if args: if args[0].get("create_dom_admin", "no") == "yes": self.fields["dom_admin_username"].required = True self.fields["create_aliases"].required = True
def extra_roles(user, account): """Return new roles.""" filters = events.raiseQueryEvent( "UserCanSetRole", user, "DomainAdmins", account ) if user.has_perm("admin.add_domain") and \ (not filters or True in filters): return [("DomainAdmins", _("Domain administrator"))] return []
def handle(self, *args, **options): """Command entry point.""" if not models.User.objects.filter(is_superuser=True).count(): admin = models.User(username=options["admin_username"], is_superuser=True) admin.set_password("password") admin.save() models.ObjectAccess.objects.create(user=admin, content_object=admin, is_owner=True) lc = models.LocalConfig.objects.first() secret_key = lc.parameters.get_value("secret_key") if not secret_key: lc.parameters.set_value("secret_key", random_key()) lc.save() for service_name in ["relay", "smtp"]: relay_models.Service.objects.get_or_create(name=service_name) exts_pool.load_all() superadmin = models.User.objects.filter(is_superuser=True).first() groups = PERMISSIONS.keys() + [ role[0] for role in events.raiseQueryEvent("GetExtraRoles", superadmin, None) ] for groupname in groups: group, created = Group.objects.get_or_create(name=groupname) permissions = ( PERMISSIONS.get(groupname, []) + events.raiseQueryEvent("GetExtraRolePermissions", groupname)) if not permissions: continue add_permissions_to_group(group, permissions) for extname in exts_pool.extensions.keys(): extension = exts_pool.get_extension(extname) extension.load_initial_data() events.raiseEvent("InitialDataLoaded", extname) if options["extra_fixtures"]: from modoboa.admin import factories factories.populate_database()
def handle(self, *args, **options): """Command entry point.""" if not models.User.objects.filter(is_superuser=True).count(): admin = models.User( username=options["admin_username"], is_superuser=True) admin.set_password("password") admin.save() models.ObjectAccess.objects.create( user=admin, content_object=admin, is_owner=True) lc = models.LocalConfig.objects.first() secret_key = lc.parameters.get_value("secret_key") if not secret_key: lc.parameters.set_value("secret_key", random_key()) lc.save() for service_name in ["relay", "smtp"]: relay_models.Service.objects.get_or_create(name=service_name) exts_pool.load_all() superadmin = models.User.objects.filter(is_superuser=True).first() groups = PERMISSIONS.keys() + [ role[0] for role in events.raiseQueryEvent("GetExtraRoles", superadmin, None) ] for groupname in groups: group, created = Group.objects.get_or_create(name=groupname) permissions = ( PERMISSIONS.get(groupname, []) + events.raiseQueryEvent("GetExtraRolePermissions", groupname) ) if not permissions: continue add_permissions_to_group(group, permissions) for extname in exts_pool.extensions.keys(): extension = exts_pool.get_extension(extname) extension.load_initial_data() events.raiseEvent("InitialDataLoaded", extname) if options["extra_fixtures"]: from modoboa.admin import factories factories.populate_database()
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 domains_menu(selection, user): """Specific menu for domain related operations. Corresponds to the menu visible on the left column when you go to *Domains*. :param str selection: menu entry currently selected :param ``User`` user: connected user :rtype: str :return: rendered menu (as HTML) """ domain_list_url = ( "list/" if selection != "statistics" else reverse("admin:domain_list") ) entries = [ {"name": "domains", "label": _("List domains"), "img": "fa fa-user", "class": "ajaxnav navigation", "url": domain_list_url}, {"name": "statistics", "label": _("Statistics"), "img": "fa fa-line-chart", "class": "navigation", "url": reverse("admin:domain_statistics")} ] if user.has_perm("admin.add_domain"): entries += [ {"name": "newdomain", "label": _("Add domain"), "img": "fa fa-plus", "modal": True, "modalcb": "admin.newdomain_cb", "url": reverse("admin:domain_add")}, ] entries += events.raiseQueryEvent("ExtraDomainMenuEntries", user) entries += [ {"name": "import", "label": _("Import"), "img": "fa fa-folder-open", "url": reverse("admin:domain_import"), "modal": True, "modalcb": "admin.importform_cb"}, {"name": "export", "label": _("Export"), "img": "fa fa-share-alt", "url": reverse("admin:domain_export"), "modal": True, "modalcb": "admin.exportform_cb"} ] return render_to_string('common/menulist.html', { "entries": entries, "selection": selection, "user": user })
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 handle(self, *args, **options): """Command entry point.""" load_core_settings() load_admin_settings() load_limits_settings() if not User.objects.filter(is_superuser=True).count(): admin = User(username="******", is_superuser=True) admin.set_password("password") admin.save() ObjectAccess.objects.create(user=admin, content_object=admin, is_owner=True) param_name = "core.SECRET_KEY" qset = lib_models.Parameter.objects.filter(name=param_name) if not qset.exists(): lib_models.Parameter.objects.create(name=param_name, value=random_key()) for service_name in ['relay', 'smtp']: relay_models.Service.objects.get_or_create(name=service_name) exts_pool.load_all() superadmin = User.objects.filter(is_superuser=True).first() groups = PERMISSIONS.keys() + [ role[0] for role in events.raiseQueryEvent("GetExtraRoles", superadmin, None) ] for groupname in groups: group, created = Group.objects.get_or_create(name=groupname) permissions = ( PERMISSIONS.get(groupname, []) + events.raiseQueryEvent("GetExtraRolePermissions", groupname)) if not permissions: continue add_permissions_to_group(group, permissions) for extname in exts_pool.extensions.keys(): extension = exts_pool.get_extension(extname) extension.load_initial_data() events.raiseEvent("InitialDataLoaded", extname)
def handle(self, *args, **options): """Command entry point.""" load_core_settings() load_admin_settings() load_limits_settings() if not User.objects.filter(is_superuser=True).count(): admin = User(username="******", is_superuser=True) admin.set_password("password") admin.save() ObjectAccess.objects.create( user=admin, content_object=admin, is_owner=True) param_name = "core.SECRET_KEY" qset = lib_models.Parameter.objects.filter(name=param_name) if not qset.exists(): lib_models.Parameter.objects.create( name=param_name, value=random_key()) for service_name in ['relay', 'smtp']: relay_models.Service.objects.get_or_create(name=service_name) exts_pool.load_all() superadmin = User.objects.filter(is_superuser=True).first() groups = PERMISSIONS.keys() + [ role[0] for role in events.raiseQueryEvent("GetExtraRoles", superadmin, None) ] for groupname in groups: group, created = Group.objects.get_or_create(name=groupname) permissions = ( PERMISSIONS.get(groupname, []) + events.raiseQueryEvent("GetExtraRolePermissions", groupname) ) if not permissions: continue add_permissions_to_group(group, permissions) for extname in exts_pool.extensions.keys(): extension = exts_pool.get_extension(extname) extension.load_initial_data() events.raiseEvent("InitialDataLoaded", extname)
def importdata(request, formclass=ImportDataForm): """Generic import function As the process of importing data from a CSV file is the same whatever the type, we do a maximum of the work here. :param request: a ``Request`` instance :param typ: a string indicating the object type being imported :return: a ``Response`` instance """ error = None form = formclass(request.POST, request.FILES) if form.is_valid(): try: reader = csv.reader(request.FILES['sourcefile'], delimiter=form.cleaned_data['sepchar']) except csv.Error as inst: error = str(inst) if error is None: try: cpt = 0 for row in reader: if not row: continue try: fct = getattr(lib, "import_%s" % row[0].strip()) except AttributeError: fct = events.raiseQueryEvent( 'ImportObject', row[0].strip() ) if not fct: continue fct = fct[0] with transaction.atomic(): try: fct(request.user, row, form.cleaned_data) except Conflict: if form.cleaned_data["continue_if_exists"]: continue raise Conflict( _("Object already exists: %s" % form.cleaned_data['sepchar'].join(row[:2])) ) cpt += 1 msg = _("%d objects imported successfully" % cpt) return render(request, "modoboa_admin/import_done.html", { "status": "ok", "msg": msg }) except (ModoboaException) as e: error = str(e) return render(request, "modoboa_admin/import_done.html", { "status": "ko", "msg": error })
def importdata(request, formclass=ImportDataForm): """Generic import function As the process of importing data from a CSV file is the same whatever the type, we do a maximum of the work here. :param request: a ``Request`` instance :param typ: a string indicating the object type being imported :return: a ``Response`` instance """ error = None form = formclass(request.POST, request.FILES) if form.is_valid(): try: reader = csv.reader(request.FILES['sourcefile'], delimiter=form.cleaned_data['sepchar']) except csv.Error as inst: error = str(inst) if error is None: try: cpt = 0 for row in reader: if not row: continue try: fct = getattr(lib, "import_%s" % row[0].strip()) except AttributeError: fct = events.raiseQueryEvent('ImportObject', row[0].strip()) if not fct: continue fct = fct[0] with transaction.atomic(): try: fct(request.user, row, form.cleaned_data) except Conflict: if form.cleaned_data["continue_if_exists"]: continue raise Conflict( _("Object already exists: %s" % form.cleaned_data['sepchar'].join(row[:2]))) cpt += 1 msg = _("%d objects imported successfully" % cpt) return render(request, "admin/import_done.html", { "status": "ok", "msg": msg }) except (ModoboaException) as e: error = str(e) return render(request, "admin/import_done.html", { "status": "ko", "msg": error })
def get_account_roles(user, account=None): """Return the list of available account roles. This function is used to create or modify an account. The returned list can be extended by listening to the ``GetExtraRoles`` event. :param ``User`` user: connected user :param ``User`` account: account beeing modified (None on creation) :return: list of strings """ result = [SIMPLEUSERS_ROLE] filters = events.raiseQueryEvent("UserCanSetRole", user, "DomainAdmins", account) if user.has_perm("admin.add_domain") and \ (not filters or True in filters): result += [DOMAINADMINS_ROLE] if user.is_superuser: result += [RESELLERS_ROLE, SUPERADMINS_ROLE] result += events.raiseQueryEvent("GetExtraRoles", user, account) return sorted(result, key=lambda role: role[1])
def top_notifications(request): """A context processor to include top notifications.""" if request.user.is_anonymous(): return {} interval = request.localconfig.parameters.get_value( "top_notifications_check_interval") return { "notifications_check_interval": interval * 1000, "top_notifications": events.raiseQueryEvent( "TopNotifications", request, False) }
def __init__(self, request): super(DomainWizard, self).__init__(request) self.add_step( WizardStep("general", DomainFormGeneral, _("General"), "admin/domain_general_form.html")) steps = events.raiseQueryEvent("ExtraDomainWizardSteps") for step in steps: self.add_step(step) self.add_step( WizardStep("options", DomainFormOptions, _("Options"), "admin/domain_options_form.html", [self.request.user]))
def get_account_roles(user, account=None): """Return the list of available account roles. This function is used to create or modify an account. The returned list can be extended by listening to the ``GetExtraRoles`` event. :param ``User`` user: connected user :param ``User`` account: account beeing modified (None on creation) :return: list of strings """ std_roles = [("SimpleUsers", _("Simple user"))] if user.is_superuser: std_roles += [("SuperAdmins", _("Super administrator"))] filters = events.raiseQueryEvent( 'UserCanSetRole', user, 'DomainAdmins', account ) if user.has_perm("admin.add_domain") and \ (not filters or True in filters): std_roles += [("DomainAdmins", _("Domain administrator"))] std_roles += events.raiseQueryEvent("GetExtraRoles", user) return sorted(std_roles, key=lambda role: role[1])
def top_notifications(request): """ A context processor to include top notifications. """ if request.user.is_anonymous(): return {} return { "notifications_check_interval": int(parameters.get_admin("TOP_NOTIFICATIONS_CHECK_INTERVAL")) * 1000, "top_notifications": events.raiseQueryEvent( "TopNotifications", request, False) }
def to_csv(self, csvwriter): """Export this account. The CSV format is used to export. :param csvwriter: csv object """ row = ["account", self.username.encode("utf-8"), self.password.encode("utf-8"), self.first_name.encode("utf-8"), self.last_name.encode("utf-8"), self.is_active, self.group, self.email.encode("utf-8")] row += events.raiseQueryEvent("AccountExported", self) csvwriter.writerow(row)
def get_account_roles(user, account=None): """Return the list of available account roles. This function is used to create or modify an account. The returned list can be extended by listening to the ``GetExtraRoles`` event. :param ``User`` user: connected user :param ``User`` account: account beeing modified (None on creation) :return: list of strings """ result = [SIMPLEUSERS_ROLE] filters = events.raiseQueryEvent( "UserCanSetRole", user, "DomainAdmins", account ) if user.has_perm("admin.add_domain") and \ (not filters or True in filters): result += [DOMAINADMINS_ROLE] if user.is_superuser: result += [RESELLERS_ROLE, SUPERADMINS_ROLE] result += events.raiseQueryEvent("GetExtraRoles", user, account) return sorted(result, key=lambda role: role[1])
def _before_is_valid(self, form): if form["id"] == "general": return True if hasattr(self, "check_%s" % form["id"]): if not getattr(self, "check_%s" % form["id"])(self.account): return False return True if False in events.raiseQueryEvent("CheckExtraAccountForm", self.account, form): return False return True
def dologin(request): 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) if request.user.has_mailbox: request.session["password"] = encrypt(form.cleaned_data["password"]) request.session["django_language"] = parameters.get_user(request.user, "LANG", app="general") 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("modoboa.lib.webutils.topredirection") else: nextlocation = reverse("domains") 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 __init__(self, user, *args, **kwargs): self.user = user self.forms = [ dict(id="general", title=_("General"), cls=AccountFormGeneral, new_args=[user], mandatory=True), dict(id="mail", title=_("Mail"), formtpl="admin/mailform.html", cls=AccountFormMail), dict(id="perms", title=_("Permissions"), formtpl="admin/permsform.html", cls=AccountPermissionsForm), ] cbargs = [user] if "instances" in kwargs: cbargs += [kwargs["instances"]["general"]] self.forms += events.raiseQueryEvent("ExtraAccountForm", *cbargs) super(AccountForm, self).__init__(*args, **kwargs)