def log_object_removal(sender, instance, **kwargs):
"""Custom post-delete hook.
We want to know who was responsible for an object deletion.
"""
from reversion.models import Version
if not reversion.is_registered(sender):
return
del_list = reversion.get_deleted(sender)
try:
version = del_list.get(object_id=instance.id)
except Version.DoesNotExist:
return
logger = logging.getLogger("modoboa.admin")
msg = _("%(object)s '%(name)s' %(action)s by ") % {
"object": smart_text(version.content_type).capitalize(),
"name": version.object_repr,
"action": _("deleted")
}
request = get_request()
if request:
msg += _("user {}").format(request.user.username)
else:
msg += _("management command")
logger.critical(msg)
def get_localconfig():
"""Retrieve current LocalConfig instance."""
from modoboa.core import models as core_models
request = signals.get_request()
if request:
return request.localconfig
return core_models.LocalConfig.objects.first()
def mailbox_deleted_handler(sender, **kwargs):
"""``Mailbox`` pre_delete signal receiver.
In order to properly handle deletions (ie. we don't want to leave
orphan records into the db), we define this custom receiver.
It manually removes the mailbox from the aliases it is linked to
and then remove all empty aliases.
"""
from modoboa.lib.permissions import ungrant_access_to_object
mb = kwargs["instance"]
ungrant_access_to_object(mb)
for ralias in mb.aliasrecipient_set.select_related("alias"):
alias = ralias.alias
ralias.delete()
if not alias.aliasrecipient_set.exists():
alias.delete()
models.Quota.objects.filter(username=mb.full_address).delete()
request = lib_signals.get_request()
if not request.localconfig.parameters.get_value(
"handle_mailboxes", raise_exception=False):
return
keepdir = request.POST.get("keepdir", "false") == "true"
if keepdir:
return
mb.delete_dir()
def get_localconfig():
"""Retrieve current LocalConfig instance."""
from modoboa.core import models as core_models
request = signals.get_request()
if request:
return request.localconfig
return core_models.LocalConfig.objects.first()
def update_permissions(sender, instance, **kwargs):
"""Permissions cleanup."""
request = get_request()
# request migth be None (management command context)
if request:
from_user = request.user
if from_user == instance:
raise exceptions.PermDeniedException(
_("You can't delete your own account")
)
if not from_user.can_access(instance):
raise exceptions.PermDeniedException
# We send an additional signal before permissions are removed
core_signals.account_deleted.send(
sender="update_permissions", user=instance)
owner = permissions.get_object_owner(instance)
if owner == instance:
# The default admin is being removed...
owner = from_user
# Change ownership of existing objects
for ooentry in instance.objectaccess_set.filter(is_owner=True):
if ooentry.content_object is not None:
permissions.grant_access_to_object(
owner, ooentry.content_object, True)
permissions.ungrant_access_to_object(
ooentry.content_object, instance)
# Remove existing permissions on this user
permissions.ungrant_access_to_object(instance)
def update_permissions(sender, instance, **kwargs):
"""Permissions cleanup."""
request = get_request()
# request migth be None (management command context)
if request:
from_user = request.user
if from_user == instance:
raise exceptions.PermDeniedException(
_("You can't delete your own account"))
if not from_user.can_access(instance):
raise exceptions.PermDeniedException
# We send an additional signal before permissions are removed
core_signals.account_deleted.send(sender="update_permissions",
user=instance)
owner = permissions.get_object_owner(instance)
if owner == instance:
# The default admin is being removed...
owner = from_user
# Change ownership of existing objects
for ooentry in instance.objectaccess_set.filter(is_owner=True):
if ooentry.content_object is not None:
permissions.grant_access_to_object(owner, ooentry.content_object,
True)
permissions.ungrant_access_to_object(ooentry.content_object,
instance)
# Remove existing permissions on this user
permissions.ungrant_access_to_object(instance)
def post_revision_commit(sender, **kwargs):
"""Custom post-revision hook.
We want to track all creations and modifications of admin. objects
(alias, mailbox, user, domain, domain alias, etc.) so we use
django-reversion for that.
"""
from modoboa.lib.signals import get_request
current_user = get_request().user.username
logger = logging.getLogger("modoboa.admin")
for version in kwargs["versions"]:
if version.object is None:
continue
prev_revisions = reversion.get_for_object(version.object)
if prev_revisions.count() == 1:
action = _("added")
level = "info"
else:
action = _("modified")
level = "warning"
message = _("%(object)s '%(name)s' %(action)s by user %(user)s") % {
"object": unicode(version.content_type).capitalize(),
"name": version.object_repr, "action": action,
"user": current_user
}
getattr(logger, level)(message)
def mailbox_deleted_handler(sender, **kwargs):
"""``Mailbox`` pre_delete signal receiver.
In order to properly handle deletions (ie. we don't want to leave
orphan records into the db), we define this custom receiver.
It manually removes the mailbox from the aliases it is linked to
and then remove all empty aliases.
"""
from modoboa.lib.permissions import ungrant_access_to_object
mb = kwargs["instance"]
ungrant_access_to_object(mb)
for ralias in mb.aliasrecipient_set.select_related("alias"):
alias = ralias.alias
ralias.delete()
if not alias.aliasrecipient_set.exists():
alias.delete()
models.Quota.objects.filter(username=mb.full_address).delete()
request = lib_signals.get_request()
if request:
if not request.localconfig.parameters.get_value("handle_mailboxes",
raise_exception=False):
return
keepdir = request.POST.get("keepdir", "false") == "true"
if keepdir:
return
mb.delete_dir()
else:
# Management command context
localconfig = core_models.LocalConfig.objects.first()
if not localconfig.parameters.get_value("handle_mailboxes",
raise_exception=False):
return
mb.delete_dir()
def post_revision_commit(sender, **kwargs):
"""Custom post-revision hook.
We want to track all creations and modifications of admin. objects
(alias, mailbox, user, domain, domain alias, etc.) so we use
django-reversion for that.
"""
from modoboa.lib.signals import get_request
current_user = get_request().user.username
logger = logging.getLogger("modoboa.admin")
for version in kwargs["versions"]:
if version.object is None:
continue
prev_revisions = reversion.get_for_object(version.object)
if prev_revisions.count() == 1:
action = _("added")
level = "info"
else:
action = _("modified")
level = "warning"
message = _("%(object)s '%(name)s' %(action)s by user %(user)s") % {
"object": unicode(version.content_type).capitalize(),
"name": version.object_repr,
"action": action,
"user": current_user
}
getattr(logger, level)(message)
def parse_date(value, **kwargs):
"""Parse a Date: header."""
tmp = email.utils.parsedate_tz(value)
if not tmp:
return value
ndate = datetime.datetime.fromtimestamp(email.utils.mktime_tz(tmp))
if ndate.tzinfo is not None:
tz = timezone.get_current_timezone()
ndate = tz.localize(datetime.datetime.fromtimestamp(ndate))
current_language = get_request().user.language
if datetime.datetime.now() - ndate > datetime.timedelta(7):
return date_format(ndate, DATETIME_FORMATS[current_language]['LONG'])
return date_format(ndate, DATETIME_FORMATS[current_language]['SHORT'])
def save(self, *args, **kwargs):
"""Create remote cal if necessary."""
super(UserSettings, self).save(*args, **kwargs)
if not self.cleaned_data["enable_carddav_sync"]:
return
abook = self.user.addressbook_set.first()
if abook.last_sync:
return
request = lib_signals.get_request()
tasks.create_cdav_addressbook(
abook, cryptutils.decrypt(request.session["password"]))
if not abook.contact_set.exists():
abook.last_sync = timezone.now()
abook.save(update_fields=["last_sync"])
def check_for_new_versions(sender, include_all, **kwargs):
"""Check if new versions are available."""
request = get_request()
if not request.user.is_superuser:
return []
status, extensions = utils.check_for_updates()
if not status:
return [{"id": "newversionavailable"}] if include_all else []
return [{
"id": "newversionavailable",
"url": reverse("core:index") + "#info/",
"text": _("One or more updates are available"),
"level": "info",
}]
def check_for_new_versions(sender, include_all, **kwargs):
"""Check if new versions are available."""
request = get_request()
if not request.user.is_superuser:
return []
status, extensions = utils.check_for_updates(request)
if not status:
return [{"id": "newversionavailable"}] if include_all else []
return [{
"id": "newversionavailable",
"url": reverse("core:index") + "#info/",
"text": _("One or more updates are available"),
"level": "info",
}]
def create_user_limits(sender, instance, **kwargs):
"""Create limits for new user."""
if not kwargs.get("created"):
return
request = lib_signals.get_request()
creator = request.user if request else None
global_params = dict(param_tools.get_global_parameters("limits"))
for name, definition in utils.get_user_limit_templates():
ct = ContentType.objects.get_by_natural_key(
*definition["content_type"].split("."))
max_value = 0
# creator can be None if user was created by a factory
if not creator or creator.is_superuser:
max_value = global_params["deflt_user_{0}_limit".format(name)]
models.UserObjectLimit.objects.create(
user=instance, name=name, content_type=ct, max_value=max_value)
def create_user_limits(sender, instance, **kwargs):
"""Create limits for new user."""
if not kwargs.get("created"):
return
request = lib_signals.get_request()
creator = request.user if request else None
for name, definition in utils.get_limit_templates():
ct = ContentType.objects.get_by_natural_key(
*definition["content_type"].split("."))
max_value = 0
# creator can be None if user was created by a factory
if not creator or creator.is_superuser:
max_value = int(
parameters.get_admin("DEFLT_{}_LIMIT".format(name.upper())))
models.ObjectLimit.objects.create(
user=instance, name=name, content_type=ct, max_value=max_value)
def create_user_limits(sender, instance, **kwargs):
"""Create limits for new user."""
if not kwargs.get("created"):
return
request = lib_signals.get_request()
creator = request.user if request else None
global_params = dict(param_tools.get_global_parameters("limits"))
for name, definition in utils.get_user_limit_templates():
ct = ContentType.objects.get_by_natural_key(
*definition["content_type"].split("."))
max_value = 0
# creator can be None if user was created by a factory
if not creator or creator.is_superuser:
max_value = global_params["deflt_user_{0}_limit".format(name)]
models.UserObjectLimit.objects.create(
user=instance, name=name, content_type=ct, max_value=max_value)
def create_user_limits(sender, instance, **kwargs):
"""Create limits for new user."""
if not kwargs.get("created"):
return
request = lib_signals.get_request()
creator = request.user if request else None
for name, definition in utils.get_user_limit_templates():
ct = ContentType.objects.get_by_natural_key(
*definition["content_type"].split("."))
max_value = 0
# creator can be None if user was created by a factory
if not creator or creator.is_superuser:
max_value = int(
parameters.get_admin(
"DEFLT_USER_{}_LIMIT".format(name.upper())))
models.UserObjectLimit.objects.create(
user=instance, name=name, content_type=ct, max_value=max_value)
def log_object_removal(sender, instance, **kwargs):
"""Custom post-delete hook.
We want to know who was responsible for an object deletion.
"""
from reversion.models import Version
if not reversion.is_registered(sender):
return
del_list = reversion.get_deleted(sender)
try:
version = del_list.get(object_id=instance.id)
except Version.DoesNotExist:
return
logger = logging.getLogger("modoboa.admin")
msg = _("%(object)s '%(name)s' %(action)s by user %(user)s") % {
"object": smart_text(version.content_type).capitalize(),
"name": version.object_repr, "action": _("deleted"),
"user": get_request().user.username
}
logger.critical(msg)
def log_object_removal(sender, instance, **kwargs):
"""Custom post-delete hook.
We want to know who was responsible for an object deletion.
"""
from reversion.models import Version
from modoboa.lib.signals import get_request
if not reversion.is_registered(sender):
return
del_list = reversion.get_deleted(sender)
try:
version = del_list.get(object_id=instance.id)
except Version.DoesNotExist:
return
logger = logging.getLogger("modoboa.admin")
msg = _("%(object)s '%(name)s' %(action)s by user %(user)s") % {
"object": unicode(version.content_type).capitalize(),
"name": version.object_repr, "action": _("deleted"),
"user": get_request().user.username
}
logger.critical(msg)
def check_for_pending_requests(sender, include_all, **kwargs):
"""Check if release requests are pending."""
request = lib_signals.get_request()
condition = (param_tools.get_global_parameter("user_can_release")
or request.user.role == "SimpleUsers")
if condition:
return []
nbrequests = SQLconnector(user=request.user).get_pending_requests()
if not nbrequests:
return [{"id": "nbrequests", "counter": 0}] if include_all \
else []
url = reverse("modoboa_amavis:index")
url += "#listing/?viewrequests=1"
return [{
"id": "nbrequests",
"url": url,
"text": _("Pending requests"),
"counter": nbrequests,
"level": "danger"
}]
def log_object_removal(sender, instance, **kwargs):
"""Custom post-delete hook.
We want to know who was responsible for an object deletion.
"""
if not reversion.is_registered(sender):
return
del_list = Version.objects.get_deleted(sender)
try:
version = del_list.get(object_id=instance.id)
except Version.DoesNotExist:
return
logger = logging.getLogger("modoboa.admin")
msg = _("%(object)s '%(name)s' %(action)s by ") % {
"object": smart_text(version.content_type).capitalize(),
"name": version.object_repr, "action": _("deleted")
}
request = get_request()
if request:
msg += _("user {}").format(request.user.username)
else:
msg += _("management command")
logger.critical(msg)
def user_logged_in(sender, username, password, **kwargs):
"""Store user password in session."""
request = lib_signals.get_request()
if hasattr(request.user, "mailbox"):
request.session["password"] = encrypt(password)
def user_logged_in(sender, username, password, **kwargs):
"""Store user password in session."""
request = lib_signals.get_request()
if hasattr(request.user, "mailbox"):
request.session["password"] = encrypt(password)
