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