Beispiel #1
0
def moderate_rel_objects(given, status, user = None):
    """
    `given` can either be any model object or a queryset. Moderate given
    object(s) and all specified related objects.
    TODO: Permissions must be checked before each iteration.
    """
    from django_monitor import model_from_queue
    # Not sure how we can find whether `given` is a queryset or object.
    # Now assume `given` is a queryset/related_manager if it has 'all'
    if not given:
        # given may become None. Stop there.
        return
    if hasattr(given, 'all'):
        qset = given.all()
        for obj in qset:
            obj.moderate(status, user)
            model = model_from_queue(qset.model)
            if model:
                for rel_name in model['rel_fields']:
                    rel_obj = getattr(obj, rel_name, None)
                    if rel_obj:
                        moderate_rel_objects(rel_obj, status, user)
    else:
        given.moderate(status, user)
        model = model_from_queue(given.__class__)
        if model:
            for rel_name in model['rel_fields']:
                rel_obj = getattr(given, rel_name, None)
                if rel_obj:
                    moderate_rel_objects(rel_obj, status, user)
Beispiel #2
0
def delete_handler(sender, instance, **kwargs):
    """ When an instance is deleted, delete corresponding monitor_entries too"""
    from django_monitor import model_from_queue
    from django_monitor.models import MonitorEntry
    from django.contrib.contenttypes.models import ContentType

    if model_from_queue(sender):
        me = MonitorEntry.objects.get_for_instance(instance)
        if me:
            me.delete()
        # Delete monitor_entries of parents too
        monitored_parents = filter(
            lambda x: model_from_queue(x),
            instance._meta.parents.keys()
        )
        for parent in monitored_parents:
            parent_ct = ContentType.objects.get_for_model(parent)
            parent_pk_field = instance._meta.get_ancestor_link(parent)
            parent_pk = getattr(instance, parent_pk_field.attname)
            try:
                me = MonitorEntry.objects.get(
                    content_type = parent_ct, object_id = parent_pk
                )
                me.delete()
            except MonitorEntry.DoesNotExist:
                pass
Beispiel #3
0
def moderate_rel_objects(given, status, user=None):
    """
    `given` can either be any model object or a queryset. Moderate given
    object(s) and all specified related objects.
    TODO: Permissions must be checked before each iteration.
    """
    from django_monitor import model_from_queue
    # Not sure how we can find whether `given` is a queryset or object.
    # Now assume `given` is a queryset/related_manager if it has 'all'
    if not given:
        # given may become None. Stop there.
        return
    if hasattr(given, 'all'):
        qset = given.all()
        for obj in qset:
            obj.moderate(status, user)
            model = model_from_queue(qset.model)
            if model:
                for rel_name in model['rel_fields']:
                    rel_obj = getattr(obj, rel_name, None)
                    if rel_obj:
                        moderate_rel_objects(rel_obj, status, user)
    else:
        given.moderate(status, user)
        model = model_from_queue(given.__class__)
        if model:
            for rel_name in model['rel_fields']:
                rel_obj = getattr(given, rel_name, None)
                if rel_obj:
                    moderate_rel_objects(rel_obj, status, user)
Beispiel #4
0
def save_handler(sender, instance, **kwargs):
    """
    The following things are done after creating an object in moderated class:
    1. Creates monitor entries for object and its parents.
    2. Auto-approves object, its parents & specified related objects if user
       has ``moderate`` permission. Otherwise, they are put in pending.
    """
    import django_monitor
    from django_monitor.models import MonitorEntry
    from django.contrib.contenttypes.models import ContentType

    # Auto-moderation
    user = get_current_user()
    opts = instance.__class__._meta
    mod_perm = '%s.moderate_%s' % (
        opts.app_label.lower(), opts.object_name.lower()
    )
    if user and user.has_perm(mod_perm):
        status = APPROVED_STATUS
    else:
        status = PENDING_STATUS

    # Create corresponding monitor entry
    if kwargs.get('created', None):
        me = MonitorEntry.objects.create(
            status = status,
            content_object = instance,
            timestamp = datetime.now()
        )
        me.moderate(status, user)

        # Create one monitor_entry per moderated parent.
        monitored_parents = filter(
            lambda x: django_monitor.model_from_queue(x),
            instance._meta.parents.keys()
        )
        for parent in monitored_parents:
            parent_ct = ContentType.objects.get_for_model(parent)
            parent_pk_field = instance._meta.get_ancestor_link(parent)
            parent_pk = getattr(instance, parent_pk_field.attname)
            try:
                me = MonitorEntry.objects.get(
                    content_type = parent_ct, object_id = parent_pk
                )
            except MonitorEntry.DoesNotExist:
                me = MonitorEntry(
                    content_type = parent_ct, object_id = parent_pk,
                )
            me.moderate(status, user)

        # Moderate related objects too...
        model = django_monitor.model_from_queue(instance.__class__)
        if model:
            for rel_name in model['rel_fields']:
                rel_obj = getattr(instance, rel_name, None)
                if rel_obj:
                    moderate_rel_objects(rel_obj, status, user)
Beispiel #5
0
def save_handler(sender, instance, **kwargs):
    """
    The following things are done after creating an object in moderated class:
    1. Creates monitor entries for object and its parents.
    2. Auto-approves object, its parents & specified related objects if user
       has ``moderate`` permission. Otherwise, they are put in pending.
    """
    import django_monitor
    from django_monitor.models import MonitorEntry
    from django.contrib.contenttypes.models import ContentType

    # Auto-moderation
    user = get_current_user()
    opts = instance.__class__._meta
    mod_perm = '%s.moderate_%s' % (opts.app_label.lower(),
                                   opts.object_name.lower())
    if user and user.has_perm(mod_perm):
        status = APPROVED_STATUS
    else:
        status = PENDING_STATUS

    # Create corresponding monitor entry
    if kwargs.get('created', None):
        me = MonitorEntry.objects.create(status=status,
                                         content_object=instance,
                                         timestamp=datetime.now())
        me.moderate(status, user)

        # Create one monitor_entry per moderated parent.
        monitored_parents = filter(
            lambda x: django_monitor.model_from_queue(x),
            instance._meta.parents.keys())
        for parent in monitored_parents:
            parent_ct = ContentType.objects.get_for_model(parent)
            parent_pk_field = instance._meta.get_ancestor_link(parent)
            parent_pk = getattr(instance, parent_pk_field.attname)
            try:
                me = MonitorEntry.objects.get(content_type=parent_ct,
                                              object_id=parent_pk)
            except MonitorEntry.DoesNotExist:
                me = MonitorEntry(
                    content_type=parent_ct,
                    object_id=parent_pk,
                )
            me.moderate(status, user)

        # Moderate related objects too...
        model = django_monitor.model_from_queue(instance.__class__)
        if model:
            for rel_name in model['rel_fields']:
                rel_obj = getattr(instance, rel_name, None)
                if rel_obj:
                    moderate_rel_objects(rel_obj, status, user)
Beispiel #6
0
 def moderate_related(self, obj, user, status):
     """Moderate related objects"""
     model = model_from_queue(obj.__class__)
     if model:
         for rel_name in model['rel_fields']:
             rel_obj = getattr(obj, rel_name, None)
             if rel_obj:
                 moderate_rel_objects(rel_obj, status, user)
Beispiel #7
0
 def moderate_related(self, obj, user, status):
     """Moderate related objects"""
     model = model_from_queue(obj.__class__)
     if model:
         for rel_name in model['rel_fields']:
             rel_obj = getattr(obj, rel_name, None)
             if rel_obj:
                 moderate_rel_objects(rel_obj, status, user)
Beispiel #8
0
 def has_delete_permission(self, request, obj = None):
     """
     If ``can_delete_approved`` is set to False in moderation queue and
     the given object is approved, this will return False. Otherwise,
     this behaves the same way as the parent class method does.
     """
     model = model_from_queue(self.model)
     if (
         model and (not model['can_delete_approved']) and
         obj is not None and obj.is_approved
     ):
         return False
     return super(MonitorAdmin, self).has_delete_permission(request, obj)
Beispiel #9
0
 def has_delete_permission(self, request, obj = None):
     """
     If ``can_delete_approved`` is set to False in moderation queue and
     the given object is approved, this will return False. Otherwise,
     this behaves the same way as the parent class method does.
     """
     model = model_from_queue(self.model)
     if (
         model and (not model['can_delete_approved']) and
         obj is not None and obj.is_approved
     ):
         return False
     return super(MonitorAdmin, self).has_delete_permission(request, obj)
Beispiel #10
0
def delete_handler(sender, instance, **kwargs):
    """ When an instance is deleted, delete corresponding monitor_entries too"""
    from django_monitor import model_from_queue
    from django_monitor.models import MonitorEntry
    from django.contrib.contenttypes.models import ContentType

    if model_from_queue(sender):
        me = MonitorEntry.objects.get_for_instance(instance)
        if me:
            me.delete()
        # Delete monitor_entries of parents too
        monitored_parents = filter(lambda x: model_from_queue(x),
                                   instance._meta.parents.keys())
        for parent in monitored_parents:
            parent_ct = ContentType.objects.get_for_model(parent)
            parent_pk_field = instance._meta.get_ancestor_link(parent)
            parent_pk = getattr(instance, parent_pk_field.attname)
            try:
                me = MonitorEntry.objects.get(content_type=parent_ct,
                                              object_id=parent_pk)
                me.delete()
            except MonitorEntry.DoesNotExist:
                pass
Beispiel #11
0
 def moderate(self, status, user = None, notes = ''):
     """ developers may use this to moderate objects """
     import django_monitor
     getattr(self, monitor_name).moderate(status, user, notes)
     # Auto-Moderate parents also
     monitored_parents = filter(
         lambda x: django_monitor.model_from_queue(x),
         self._meta.parents.keys()
     )
     for parent in monitored_parents:
         parent_ct = ContentType.objects.get_for_model(parent)
         parent_pk_field = self._meta.get_ancestor_link(parent)
         parent_pk = getattr(self, parent_pk_field.attname)
         me = MonitorEntry.objects.get(
             content_type = parent_ct, object_id = parent_pk
         )
         me.moderate(status, user)
Beispiel #12
0
 def moderate_parents(self, obj, user, status):
     """Create one monitor_entry per moderated parent"""
     monitored_parents = filter(lambda x: model_from_queue(x),
                                obj._meta.parents.keys())
     for parent in monitored_parents:
         parent_ct = ContentType.objects.get_for_model(parent)
         parent_pk_field = obj._meta.get_ancestor_link(parent)
         parent_pk = getattr(obj, parent_pk_field.attname)
         try:
             me = MonitorEntry.objects.get(content_type=parent_ct,
                                           object_id=parent_pk)
         except MonitorEntry.DoesNotExist:
             me = MonitorEntry(
                 content_type=parent_ct,
                 object_id=parent_pk,
             )
         me.moderate(status, user)
Beispiel #13
0
 def moderate_parents(self, obj, user, status):
     """Create one monitor_entry per moderated parent"""
     monitored_parents = filter(
         lambda x: model_from_queue(x),
         obj._meta.parents.keys()
     )
     for parent in monitored_parents:
         parent_ct = ContentType.objects.get_for_model(parent)
         parent_pk_field = obj._meta.get_ancestor_link(parent)
         parent_pk = getattr(obj, parent_pk_field.attname)
         try:
             me = MonitorEntry.objects.get(
                 content_type = parent_ct, object_id = parent_pk
             )
         except MonitorEntry.DoesNotExist:
             me = MonitorEntry(
                 content_type = parent_ct, object_id = parent_pk,
             )
         me.moderate(status, user)
Beispiel #14
0
def moderate_selected(modeladmin, request, queryset, status):
    """
    Generic action to moderate selected objects plus all related objects.
    """
    opts = modeladmin.model._meta
    
    # If moderation is disabled..
    if not model_from_queue(modeladmin.model):
        return 0

    # Check that the user has required permission for the actual model.
    # To reset to pending status, change_perm is enough. For all else,
    # user need to have moderate_perm.
    if (
        (status == PENDING_STATUS and
            not modeladmin.has_change_permission(request)
        ) or 
        (status != PENDING_STATUS and
            not modeladmin.has_moderate_permission(request)
        )
    ):
        raise PermissionDenied

    # Approved objects can not further be moderated.
    queryset = queryset.exclude_approved()

    # After moderating objects in queryset, moderate related objects also
    q_count = queryset.count()

    # We want to use the status display rather than abbreviations in logs.
    status_display = STATUS_DICT[status]

    if q_count:
        #for obj in queryset:
            #message = 'Changed status from %s to %s.' % (
            #    obj.get_status_display(), status_display
            #)
            #modeladmin.log_moderation(request, obj, message)
            #me = MonitorEntry.objects.get_for_instance(obj)
        moderate_rel_objects(queryset, status, request.user)
    return q_count
Beispiel #15
0
 def test_1_check_additional_fields(self):
     """
     monitor puts some additional attrs to each moderated class.
     Let's check for their existence.
     """
     import django_monitor
     qd_book = django_monitor.model_from_queue(Book)
     monitor_name = qd_book['monitor_name']
     status_name = qd_book['status_name']
     self.assertEquals(hasattr(Book, monitor_name), True)
     self.assertEquals(hasattr(Book, 'monitor_status'), True)
     self.assertEquals(hasattr(Book, status_name), True)
     self.assertEquals(hasattr(Book, 'get_monitor_status_display'), True)
     self.assertEquals(hasattr(Book, 'moderate'), True)
     self.assertEquals(hasattr(Book, 'approve'), True)
     self.assertEquals(hasattr(Book, 'challenge'), True)
     self.assertEquals(hasattr(Book, 'reset_to_pending'), True)
     self.assertEquals(hasattr(Book, 'is_approved'), True)
     self.assertEquals(hasattr(Book, 'is_challenged'), True)
     self.assertEquals(hasattr(Book, 'is_pending'), True)
     # monitor has changed the default manager, ``objects`` too.
     self.assertEquals(
         str(Book.objects)[:34], '<django_monitor.util.CustomManager')
Beispiel #16
0
 def test_1_check_additional_fields(self):
     """
     monitor puts some additional attrs to each moderated class.
     Let's check for their existence.
     """
     import django_monitor
     qd_book = django_monitor.model_from_queue(Book)
     monitor_name = qd_book['monitor_name']
     status_name = qd_book['status_name']
     self.assertEquals(hasattr(Book, monitor_name), True) 
     self.assertEquals(hasattr(Book, 'monitor_status'), True)
     self.assertEquals(hasattr(Book, status_name), True)
     self.assertEquals(hasattr(Book, 'get_monitor_status_display'), True)
     self.assertEquals(hasattr(Book, 'moderate'), True)
     self.assertEquals(hasattr(Book, 'approve'), True)
     self.assertEquals(hasattr(Book, 'challenge'), True)
     self.assertEquals(hasattr(Book, 'reset_to_pending'), True)
     self.assertEquals(hasattr(Book, 'is_approved'), True)
     self.assertEquals(hasattr(Book, 'is_challenged'), True)
     self.assertEquals(hasattr(Book, 'is_pending'), True)
     # monitor has changed the default manager, ``objects`` too.
     self.assertEquals(
         str(Book.objects)[:34], '<django_monitor.util.CustomManager'
     )
Beispiel #17
0
def moderate_selected(modeladmin, request, queryset, status):
    """
    Generic action to moderate selected objects plus all related objects.
    """

    # If moderation is disabled..
    if not model_from_queue(modeladmin.model):
        return 0

    # Check that the user has required permission for the actual model.
    # To reset to pending status, change_perm is enough. For all else,
    # user need to have moderate_perm.
    if ((status == PENDING_STATUS
         and not modeladmin.has_change_permission(request))
            or (status != PENDING_STATUS
                and not modeladmin.has_moderate_permission(request))):
        raise PermissionDenied

    # Approved objects can not further be moderated.
    queryset = queryset.exclude_approved()

    # After moderating objects in queryset, moderate related objects also
    q_count = queryset.count()

    # We want to use the status display rather than abbreviations in logs.
    status_display = STATUS_DICT[status]

    if q_count:
        #for obj in queryset:
        #message = 'Changed status from %s to %s.' % (
        #    obj.get_status_display(), status_display
        #)
        #modeladmin.log_moderation(request, obj, message)
        #me = MonitorEntry.objects.get_for_instance(obj)
        moderate_rel_objects(queryset, status, request.user)
    return q_count
Beispiel #18
0
 def is_monitored(self):
     """Returns whether the underlying model is monitored or not."""
     return bool(model_from_queue(self.model))
Beispiel #19
0
def save_handler(sender, instance, **kwargs):
    """
    The following things are done after creating an object in moderated class:
    1. Creates monitor entries for object and its parents.
    2. Auto-approves object, its parents & specified related objects if user 
       has ``moderate`` permission. Otherwise, they are put in pending.
    """
    import django_monitor
    # Auto-moderation
    user = get_current_user()
    opts = instance.__class__._meta
    mod_perm = '%s.moderate_%s' % (
        opts.app_label.lower(), opts.object_name.lower()
    )
    if user and user.has_perm(mod_perm):
        status = APPROVED_STATUS
    else:
        status = PENDING_STATUS

    # Create corresponding monitor entry
    if kwargs.get('created', None):
        from django_monitor import _queue
        
        me = MonitorEntry.objects.create(
            status = status,
            content_object = instance,
            timestamp = datetime.now()
        )
        me.moderate(status, user)

        # Create one monitor_entry per moderated parent.
        monitored_parents = filter(
            lambda x: django_monitor.model_from_queue(x),
            instance._meta.parents.keys()
        )
        for parent in monitored_parents:
            parent_ct = ContentType.objects.get_for_model(parent)
            parent_pk_field = instance._meta.get_ancestor_link(parent)
            parent_pk = getattr(instance, parent_pk_field.attname)
            try:
                me = MonitorEntry.objects.get(
                    content_type = parent_ct, object_id = parent_pk
                )
            except MonitorEntry.DoesNotExist:
                me = MonitorEntry(
                    content_type = parent_ct, object_id = parent_pk,
                )
            me.moderate(status, user)

        # Moderate related objects too... 
        model = django_monitor.model_from_queue(instance.__class__)
        if model:
            for rel_name in model['rel_fields']:
                rel_obj = getattr(instance, rel_name, None)
                if rel_obj:
                    moderate_rel_objects(rel_obj, status, user)
                    
        if callable(_queue[instance.__class__]['notify_moderators']):
            if not _queue[instance.__class__]['notify_moderators'](instance):
                return

        if MODERATOR_LIST:

            from django.contrib.sites.models import Site
            domain = Site.objects.get(id=settings.SITE_ID).domain

            status = me.get_status_display()
            instance_class = instance.__class__.__name__
            app_label = instance._meta.app_label
            long_desc = _queue[instance.__class__]['long_desc']

            # message
            message = _long_desc(instance, long_desc)
            if status == 'Pending':
                message += "\n\nTo moderate, go to http://%s%s?ot=desc&status=IP&o=2" % (domain, reverse('admin:%s_%s_changelist' % (app_label, instance_class.lower())))

            # subject
            key = "%s:%s" % (instance_class, status)
#             if me.moderation_status_by and me.moderation_status_by.username == 'gatekeeper_automod':
#                 key = "%s:auto" % key
            subject = "[%s] New monitor object on %s" % (key, domain)

            # sender
            from_addr = settings.DEFAULT_FROM_EMAIL

            send_mail(subject, message, from_addr, MODERATOR_LIST, fail_silently=True)
Beispiel #20
0
 def is_monitored(self):
     """Returns whether the underlying model is monitored or not."""
     return bool(model_from_queue(self.model))