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