Exemplo n.º 1
0
def register(model, import_unmoderated=False, auto_moderator=None, long_desc=None,
             manager_name='objects', status_name='moderation_status',
             flagged_name='flagged', moderation_object_name='moderation_object',
             base_manager=None):
    if not model in registered_models:
        signals.post_save.connect(save_handler, sender=model)
        signals.pre_delete.connect(delete_handler, sender=model)
        # pass extra params onto add_fields to define what fields are named
        add_fields(model, manager_name, status_name, flagged_name, 
                   moderation_object_name, base_manager)
        registered_models[model] = {
            'auto_moderator': auto_moderator,
            'long_desc': long_desc or _default_long_desc,
        }
        if import_unmoderated:
            try:
                mod_obj_ids = model.objects.all().values_list('pk', flat=True)
                unmod_objs = model._base_manager.exclude(pk__in=mod_obj_ids)
                print 'importing %s unmoderated objects...' % unmod_objs.count()
                for obj in unmod_objs:
                    mo = ModeratedObject(
                        moderation_status=DEFAULT_STATUS,
                        content_object=obj,
                        timestamp=datetime.datetime.now())
                    mo.save()
            except:
                pass
def save_handler(sender, **kwargs):
    if kwargs.get('created', None):
        instance = kwargs['instance']
        
        mo = ModeratedObject(
            moderation_status=DEFAULT_STATUS,
            content_object=instance,
            timestamp=datetime.datetime.now())
        mo.save()
        
        if ENABLE_AUTOMODERATION:
            auto_moderator = registered_models[instance.__class__]
            if auto_moderator:
                mod = auto_moderator(mo)
                if mod is None:
                    pass # ignore the moderator if it returns None
                elif mod:
                    mo.approve(_get_automod_user())
                else:
                    mo.reject(_get_automod_user())
            
            if mo.moderation_status == PENDING_STATUS: # if status is pending
                user = get_current_user()
                if user and user.is_authenticated():
                    if user.is_superuser or user.has_perm('gatekeeper.change_moderatedobject'):
                        mo.approve(user)
        
        if MODERATOR_LIST and mo.moderation_status < APPROVED_STATUS: # if there are moderators and the object is not approved
            subject = "[pending-moderation] %s" % instance
            message = "New object pending moderation.\n%s\nhttp://%s%s" % (instance, Site.objects.get_current().domain, reverse("admin:admin_gatekeeper_moderated_object_batch_change_status"))
            from_addr = settings.DEFAULT_FROM_EMAIL 
            send_mail(subject, message, from_addr, MODERATOR_LIST, fail_silently=True)
Exemplo n.º 3
0
def save_handler(sender, **kwargs):

    if kwargs.get('created', None):
    
        instance = kwargs['instance']
    
        mo = ModeratedObject(
            status=DEFAULT_STATUS,
            content_object=instance,
            timestamp=datetime.datetime.now())
        mo.save()
    
        if ENABLE_AUTOMODERATION:
        
            auto_moderator = registered_models[instance.__class__]
            if auto_moderator:
                mod = auto_moderator(mo)
                if mod is None:
                    pass # ignore the moderator if it returns None
                elif mod:
                    mo.approve(_get_automod_user())
                else:
                    mo.reject(_get_automod_user())
        
            if mo.status == 0: # if status is still pending
                user = get_current_user()
                if user and user.is_authenticated():
                    if user.is_superuser or user.has_perm('gatekeeper.change_moderatedobject'):
                        mo.approve(user)
                    
        if MODERATOR_LIST:
            subject = "[pending-moderation] %s" % instance
            message = "New object pending moderation.\n%s\n%s" % (instance, reverse("gatekeeper_moderate_list"))
            from_addr = "*****@*****.**"
            send_mail(subject, message, from_addr, MODERATOR_LIST, fail_silently=True)
Exemplo n.º 4
0
def save_handler(sender, **kwargs):

    if kwargs.get('created', None):
    
        instance = kwargs['instance']
    
        mo = ModeratedObject(
            moderation_status=DEFAULT_STATUS,
            content_object=instance,
            timestamp=datetime.datetime.now())
        mo.save()

        # do automoderation
        auto_moderator = registered_models[instance.__class__]['auto_moderator']
        if auto_moderator:
            mod = auto_moderator(mo)
            if mod is None:
                pass # ignore the moderator if it returns None
            elif mod:
                mo.approve(_get_automod_user())
            else:
                mo.reject(_get_automod_user())

        if ENABLE_AUTOMODERATION:
            if mo.moderation_status == PENDING_STATUS: # if status is pending
                user = get_current_user()
                if user and user.is_authenticated():
                    if user.is_superuser or user.has_perm('gatekeeper.change_moderatedobject'):
                        mo.approve(user)
                    
        if MODERATOR_LIST:
            
            from django.contrib.sites.models import Site
            domain = Site.objects.get(id=settings.SITE_ID).domain
            
            status = mo.get_moderation_status_display()
            instance_class = instance.__class__.__name__
            long_desc = registered_models[instance.__class__]['long_desc']
            
            # message
            message = _long_desc(instance, long_desc)
            if status == 'Pending':
                message = "%s\n\nTo moderate, go to http://%s%s" % (message, domain, reverse("gatekeeper_moderate_list"))
            
            # subject
            key = "%s:%s" % (instance_class, status)
            if mo.moderation_status_by and mo.moderation_status_by.username == 'gatekeeper_automod':
                key = "%s:auto" % key
            subject = "[%s] New gatekeeper object on %s" % (key, domain)
            
            # sender
            from_addr = settings.DEFAULT_FROM_EMAIL
            
            send_mail(subject, message, from_addr, MODERATOR_LIST, fail_silently=True)
Exemplo n.º 5
0
def register(model, import_unmoderated=False, auto_moderator=None):
    if not model in registered_models:
        signals.post_save.connect(save_handler, sender=model)
        signals.pre_delete.connect(delete_handler, sender=model)
        registered_models[model] = auto_moderator
        if import_unmoderated:
            try:
                unmod_objs = unmoderated(model.objects.all())
                for obj in unmod_objs:
                    mo = ModeratedObject(
                        status=DEFAULT_STATUS,
                        content_object=obj,
                        timestamp=datetime.datetime.now())
                    mo.save()
            except:
                pass
Exemplo n.º 6
0
def register(
    model,
    import_unmoderated=False,
    auto_moderator=None,
    long_desc=None,
    manager_name="objects",
    status_name="moderation_status",
    flagged_name="flagged",
    moderation_object_name="moderation_object",
    base_manager=None,
    moderator_list=None,
    notify_moderators=None,
):
    if not model in registered_models:
        signals.post_save.connect(save_handler, sender=model)
        signals.pre_delete.connect(delete_handler, sender=model)
        # pass extra params onto add_fields to define what fields are named
        add_fields(model, manager_name, status_name, flagged_name, moderation_object_name, base_manager)
        registered_models[model] = {
            "auto_moderator": auto_moderator,
            "long_desc": long_desc or _default_long_desc,
            "moderator_list": moderator_list,
            "notify_moderators": notify_moderators,
        }
        if import_unmoderated:
            try:
                mod_obj_ids = model.objects.all().values_list("pk", flat=True)
                unmod_objs = model._base_manager.exclude(pk__in=mod_obj_ids)
                print "importing %s unmoderated objects..." % unmod_objs.count()
                for obj in unmod_objs:
                    mo = ModeratedObject(
                        moderation_status=DEFAULT_STATUS, content_object=obj, timestamp=datetime.datetime.now()
                    )
                    mo.save()
            except:
                pass
Exemplo n.º 7
0
def save_handler(sender, instance, **kwargs):

    if kwargs.get('created', None):

        mo = ModeratedObject(
            moderation_status=DEFAULT_STATUS,
            content_object=instance,
            timestamp=datetime.datetime.now())
        mo.save()

        # do automoderation
        auto_moderator = registered_models[instance.__class__]['auto_moderator']
        if auto_moderator:
            mod = auto_moderator(mo)
            if mod is None:
                pass # ignore the moderator if it returns None
            elif mod:
                mo.approve(_get_automod_user())
            else:
                mo.reject(_get_automod_user())

        # do old-style automoderation if automoderator did nothing
        if ENABLE_AUTOMODERATION and mo.moderation_status == PENDING_STATUS:
            user = get_current_user()
            if user and user.has_perm('gatekeeper.change_moderatedobject'):
                mo.approve(user)

        if MODERATOR_LIST:

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

            status = mo.get_moderation_status_display()
            instance_class = instance.__class__.__name__
            long_desc = registered_models[instance.__class__]['long_desc']

            # message
            message = _long_desc(instance, long_desc)
            if status == 'Pending':
                message += "\n\nTo moderate, go to http://%s/admin/gatekeeper/moderatedobject/?ot=desc&o=2" % (message, domain)

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

            # sender
            from_addr = settings.DEFAULT_FROM_EMAIL

            send_mail(subject, message, from_addr, MODERATOR_LIST, fail_silently=True)
Exemplo n.º 8
0
def save_handler(sender, instance, **kwargs):

    if kwargs.get("created", None):
        user = get_current_user()

        mo = ModeratedObject(
            moderation_status=DEFAULT_STATUS,
            content_object=instance,
            timestamp=datetime.datetime.now(),
            created_by=user if user and not user.is_anonymous() else None,
            created_ip=get_current_user_ip(),
        )
        mo.save()

        # do automoderation
        auto_moderator = registered_models[instance.__class__]["auto_moderator"]
        if auto_moderator:
            mod = auto_moderator(mo)
            if mod is None:
                pass  # ignore the moderator if it returns None
            elif mod:
                mo.approve(_get_automod_user())
            else:
                mo.reject(_get_automod_user())

        # do old-style automoderation if automoderator did nothing
        if ENABLE_AUTOMODERATION and mo.moderation_status == PENDING_STATUS:
            if user and user.has_perm("gatekeeper.change_moderatedobject"):
                mo.approve(user)
    else:
        mo = ModeratedObject.objects.get(
            object_id=instance.id, content_type=ContentType.objects.get_for_model(instance)
        )

    if callable(registered_models[instance.__class__]["notify_moderators"]):
        if not registered_models[instance.__class__]["notify_moderators"](instance):
            return

    moderator_list = None
    if MODERATOR_LIST:
        moderator_list = MODERATOR_LIST
    if callable(registered_models[instance.__class__]["moderator_list"]):
        moderator_list = registered_models[instance.__class__]["moderator_list"](instance)

    if moderator_list:

        from django.contrib.sites.models import Site

        domain = Site.objects.get(id=settings.SITE_ID).domain

        status = mo.get_moderation_status_display()
        instance_class = instance.__class__.__name__
        long_desc = registered_models[instance.__class__]["long_desc"]

        # message
        message = _long_desc(instance, long_desc)
        if status == "Pending":
            if callable(getattr(instance, "get_absolute_url", None)):
                message += "\n\nTo view, go to http://%s%s" % (domain, instance.get_absolute_url())
            message += (
                "\n\nTo moderate, go to http://%s/admin/gatekeeper/moderatedobject/?ot=desc&moderation_status__exact=0&o=2"
                % domain
            )

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

        # sender
        from_addr = settings.DEFAULT_FROM_EMAIL

        send_mail(subject, message, from_addr, moderator_list, fail_silently=True)