def test_instance_with_many_moderations(self): # Register a moderator that keeps the history # un-register UserProfile from moderation import moderation class KeepHistoryModerator(GenericModerator): keep_history = True moderation.unregister(UserProfile) moderation.register(UserProfile, KeepHistoryModerator) profile = UserProfile(description='Profile for new user', url='http://www.yahoo.com', user=self.user) profile.save() # There should only be one ModeratedObject self.assertEqual(1, ModeratedObject.objects.count()) profile.url = 'http://www.google.com' profile.save() # Should now be two self.assertEqual(2, ModeratedObject.objects.count()) # Getting for instance should return the one with the google url moderated_object = ModeratedObject.objects.get_for_instance(profile) self.assertEqual(profile.url, moderated_object.changed_object.url) # Get the first object, and does it have the yahoo address moderated_object_pk1 = ModeratedObject.objects.get(pk=1) self.assertEqual('http://www.yahoo.com', moderated_object_pk1.changed_object.url)
def setUp(self): setup_moderation() self.client.login(username='******', password='******') class UserProfileModerator(GenericModerator): fields_exclude = ['url'] moderation.register(UserProfile, UserProfileModerator)
def setup_moderation(models=[]): from moderation import moderation for model in models: try: model_class, generic_moderator = model except TypeError: moderation.register(model) else: moderation.register(model_class, generic_moderator) return moderation
def setup_moderation(models=[]): from moderation import moderation moderation._registered_models = {} for model in models: try: model_class, generic_moderator = model moderation.register(model_class, generic_moderator) except TypeError: moderation.register(model) return moderation
def load_growing_places(file_name='growing_places.csv'): reader = csv.DictReader(open(settings.DATA_ROOT + '/' + file_name)) # Stop moderating GrowingPlace objects for now moderation.unregister(GrowingPlace) for place in reader: # skip empty rows if not place['Organization']: continue address = _strip_string(place['Address']) city = _strip_string(place['City']) state = _strip_string(place['State']) zipcode = _strip_string(place['ZIP']) # watch out for weird stuff in the zipcode field if not re.match('^[\d-]+$', zipcode): zipcode = None lng, lat = geocode(' '.join(filter(None, (address, city, state, zipcode)))) try: centroid = Point(lng, lat) except TypeError: centroid = None try: saved_place, created = GrowingPlace.objects.get_or_create( name=place['Organization'].strip(), city=city, state_province=state, defaults={ 'address_line1': address, 'centroid': centroid, 'country': 'USA', 'mission': place['Mission'].strip(), 'contact': place['Phone'].strip(), 'postal_code': zipcode, 'url': place['Website'].strip(), }, ) saved_place.activities = _get_activities(place) saved_place.save() print 'added', saved_place.name except Exception: print 'Exception while adding "%s"' % place['Organization'] traceback.print_exc() continue # Start moderating GrowingPlace objects again moderation.register(GrowingPlace)
def test_save_handler_keep_history(self): # de-register current Moderator and replace it with one that # has keep_history set to True from moderation import moderation class KeepHistoryModerator(GenericModerator): keep_history = True notify_moderator = False moderation.unregister(UserProfile) moderation.register(UserProfile, KeepHistoryModerator) from django.db.models import signals signals.pre_save.connect(self.moderation.pre_save_handler, sender=UserProfile) signals.post_save.connect(self.moderation.post_save_handler, sender=UserProfile) profile = UserProfile(description='Profile for new user', url='http://www.yahoo.com', user=User.objects.get(username='******')) profile.save() moderated_object = ModeratedObject.objects.get_for_instance(profile) self.assertEqual(moderated_object.content_object, profile) # Now update it and make sure it gets the right history object... profile.url = 'http://www.google.com' profile.save() moderated_object = ModeratedObject.objects.get_for_instance(profile) self.assertEqual(moderated_object.content_object, profile) # There should only be two moderated objects self.assertEqual(2, ModeratedObject.objects.count()) # Approve the change moderated_object.approve(by=self.user, reason='Testing post save handlers') # There should *still* only be two moderated objects self.assertEqual(2, ModeratedObject.objects.count()) signals.pre_save.disconnect(self.moderation.pre_save_handler, UserProfile) signals.post_save.disconnect(self.moderation.post_save_handler, UserProfile) self.moderation = False
def setup_moderation(models=None): from moderation import moderation if models is None: models = [] for model in models: try: model_class, generic_moderator = model except TypeError: moderation.register(model) else: moderation.register(model_class, generic_moderator) return moderation
from moderation import moderation from .models import IndigenousLand, IndigenousVillage, ArchaeologicalPlace moderation.register(IndigenousLand) moderation.register(IndigenousVillage) moderation.register(ArchaeologicalPlace)
from geoads.contrib.moderation.moderator import AdModerator from moderation import moderation from customads.models import TestModeratedAd moderation.register(TestModeratedAd, AdModerator)
from moderation import moderation from changingthefoodchain.moderator import StandardModerator from .models import Photo, Video class PhotoModerator(StandardModerator): pass class VideoModerator(StandardModerator): pass moderation.register(Photo, PhotoModerator) moderation.register(Video, VideoModerator)
class Creator(models.Model): ''' Represents an author, illustrator, editor, publisher, etc of a light novel For people, use Lastname, Firstname format. Comma is required. ''' name = models.CharField(max_length=100, default="") role = models.CharField(choices=CREATORS, default='Author', max_length=100) def __unicode__(self): return self.name class Meta: unique_together = ('name', 'role') ordering = ['name'] moderation.register(Creator) class Contributor(models.Model): ''' Represents a fan translators, editor, proofreader of a light novel translation ''' name = models.CharField(max_length=100, unique=True, default="") #role def __unicode__(self): return self.name moderation.register(Contributor) class Series(models.Model): '''
class ContentModerator(GenericModerator): manager_names = ['objects', 'itms', 'items'] notify_user = False auto_approve_for_superusers = True auto_approve_for_staff = True message_backend_class = StandartMessageBackend notify_moderator = False auto_approve_for_authenticated = False bypass_moderation_after_approval = True #bypass_moderation_after_approval = True #visibility_column = 'visible' class CommentModerator(GenericModerator): notify_user = False auto_approve_for_superusers = True auto_approve_for_authenticated = True class SignatureModerator(GenericModerator): notify_user = False auto_approve_for_superusers = True auto_approve_for_authenticated = True moderation.register(ContentItem, ContentModerator) moderation.register(ThreadedComment, CommentModerator) #moderation.register(OuterParticipant, SignatureModerator)
from moderation import moderation from purf_app.models import Professor moderation.register(Professor)
# subject_template_user # message_template_user # Use these lines to run fix_moderation_after_imports # notify_moderator = False # notify_user = False def send(self, content_object, subject_template, message_template, recipient_list, extra_context=None): # FIXME: when rejecting, the content_object is None. This seens to be a BUG in moderator.models if not content_object: return context = { 'moderated_object': content_object.moderated_object, 'content_object': content_object, 'site': Site.objects.get_current(), 'content_type': content_object.moderated_object.content_type} if extra_context: context.update(extra_context) message = render_to_string(message_template, context) subject = render_to_string(subject_template, context) backend = self.get_message_backend() backend.send( subject=subject, message=message, recipient_list=recipient_list) moderation.register(IndigenousLand, BaseModerator) moderation.register(IndigenousVillage, BaseModerator) moderation.register(ArchaeologicalPlace, BaseModerator)
""" A screening. """ time = models.DateTimeField(_('time')) price = models.DecimalField(_('price'), max_digits=5, decimal_places=2, blank=True, null=True, ) venue = models.ForeignKey('Venue') url = models.URLField(_('url'), blank=True, null=True, ) def __unicode__(self): try: time = self.time.astimezone(get_current_timezone()) except Exception: time = self.time return u'%s: %s' % (self.venue.name, time.strftime('%b %d, %Y at %I:%M %Z')) class Venue(Place): def __unicode__(self): return self.name or u'%d' % self.pk moderation.register(Screening, SiteModerator)
from __future__ import unicode_literals from moderation import moderation from .models import Book moderation.register(Book)
from django.db import models from django.contrib.auth.models import User from django.contrib import admin from moderation import moderation class ExampleUserProfile(models.Model): user = models.ForeignKey(User) description = models.TextField() url = models.URLField() def __unicode__(self): return "%s - %s" % (self.user, self.url) def get_absolute_url(self): return '/test/' moderation.register(ExampleUserProfile)
from moderation import moderation from moderation.moderator import GenericModerator from backoffice.models import Work class WorkModerator(GenericModerator): auto_approve_for_staff = False visibility_column = 'visible' moderation.register(Work, WorkModerator)
from moderation import moderation, moderator from models import ShiftEvent class MyModerator(moderator.GenericModerator): visibility_column = 'visible' pending_column = 'pending' # visible_until_rejected = True def inform_moderator(self, content_object, extra_context=None): '''Send notification to moderator''' extra_context={'test':'test'} super(MyModerator, self).inform_moderator(content_object, extra_context) def inform_user(self, content_object, user, extra_context=None): '''Send notification to user when object is approved or rejected''' extra_context={'test':'test'} super(MyModerator, self).inform_user(content_object, user, extra_context) moderation.register(ShiftEvent, MyModerator) #moderation.register(ShiftEvent)
from moderation import moderation from models import SuccessCase moderation.register(SuccessCase)
from moderation import moderation from repsf.map.models import Location moderation.register(Location)
from moderation import moderation from moderation.moderator import GenericModerator from investment_report import models class Moderator(GenericModerator): notify_user = True auto_approve_for_superusers = False auto_approve_for_staff = False keep_history = False notify_moderator = True for model_class in [ models.FrontPage, models.ContentsPage, models.SectorOverview, models.KillerFacts, models.MacroContextBetweenCountries, models.UKMarketOverview, models.SectorInitiatives, models.CaseStudySector, models.HowWeCanHelp, models.SmartWorkforceSector, models.LastPage, models.MarketContact, ]: moderation.register(model_class, Moderator)
class Moderator(GenericModerator): fields_exclude=['updated','hits'] visible_until_rejected=False auto_approve_for_superusers=True auto_approve_for_staff=True notify_user=False notify_moderator=False def is_auto_approve(self, obj, user): if obj.state == "raw": return self.reason('Not Submitted Yet !') g=Group.objects.get(name="Trusted Users") if g in user.groups.all(): return self.reason('Trusted User !') super(Moderator, self).is_auto_approve(obj, user) def is_auto_reject(self, obj, user): g=Group.objects.get(name="Banned Users") if g in user.groups.all(): return self.reason('Banned User !') super(Moderator, self).is_auto_approve(obj, user) moderation.register(Tutorial,Moderator) moderation.register(Snippet,Moderator) moderation.register(Wiki,Moderator) moderation.register(Blog,Moderator) moderation.register(Announcement,Moderator) moderation.register(News,Moderator) moderation.register(Package,Moderator) moderation.register(Event,Moderator) moderation.register(EducationalResource,Moderator)
videos = generic.GenericRelation(Video) activities = models.ManyToManyField('Activity', blank=True, null=True, verbose_name=_('activities') ) def __unicode__(self): return self.name class Activity(models.Model): name = models.CharField(_('name'), max_length = 100, ) description = models.TextField(_('description'), null=True, blank=True, ) order = models.PositiveIntegerField(_('order'), default=0) def __unicode__(self): return self.name class Meta: ordering = ('order',) verbose_name_plural = _('activities') moderation.register(GrowingPlace, SiteModerator)
from moderation import moderation from issue.models import MyModel moderation.register(MyModel)
from moderation.managers import ModeratedObjectManager from firstperson.models import Story from django.contrib.sites.models import Site from django.template.loader import render_to_string class CustomModerator(GenericModerator): notify_user = True notify_moderator = False auto_approve_for_superusers = True auto_approve_for_staff = True message_template_user = '******' subject_template_user = '******' recipient_email = '*****@*****.**' # recipient_email = Story.definition def inform_user(self, content_object, user, extra_context=None): '''Send notification to user when object is approved or rejected''' if self.notify_user: self.send( content_object=content_object, subject_template=self.subject_template_user, message_template=self.message_template_user, recipient_list=[str(content_object)], extra_context=extra_context) moderation.register(Story, CustomModerator)
from django import VERSION from moderation import moderation from example_project.example_app.models import ExampleUserProfile from moderation.moderator import GenericModerator class UserProfileModerator(GenericModerator): notify_user = False auto_approve_for_superusers = False auto_approve_for_staff = False moderation.register(ExampleUserProfile) if VERSION[:2] >= (1, 5): from example_project.example_app.models import UserProfileWithCustomUser moderation.register(UserProfileWithCustomUser, UserProfileModerator)
from moderation import moderation from moderation.moderator import GenericModerator from moderation.db import ModeratedModel from .models import Nexus, Post, Identity class NexusModerator(GenericModerator): auto_reject_for_groups = ['banned'] visibility_column = 'is_public' class PostModerator(GenericModerator): auto_reject_for_groups = ['banned'] visibility_column = 'is_public' class IdentityModerator(GenericModerator): auto_reject_for_groups = ['banned'] visibility_column = 'is_public' moderation.register(Post, PostModerator) moderation.register(Nexus, NexusModerator) moderation.register(Identity, IdentityModerator)
[ResizeToFit(300, 150)], source='image', format='JPEG', options={'quality': 90} ) video_url = models.URLField(_('video url'), null=True, blank=True, ) text = models.TextField(_('text'), null=True, blank=True, ) featured = models.BooleanField(_('featured'), default=True, ) order = models.PositiveIntegerField(_('order'), default=0) class Meta: ordering = ('order',) verbose_name_plural = _('stories') @models.permalink def get_absolute_url(self): return ('stories:story_detail', (), { 'pk': self.pk }) def __unicode__(self): return self.title moderation.register(Story, SiteModerator)
from moderation import moderation from moderation.moderator import GenericModerator from .models import Plan, PlanAnnualAttribute, Government, GovernmentAnnualAttribute class PlanModerator(GenericModerator): auto_approve_for_staff = False auto_approve_for_superusers = False keep_history = True moderation.register(Plan, PlanModerator) moderation.register(PlanAnnualAttribute, PlanModerator) class GovernmentModerator(GenericModerator): auto_approve_for_staff = False auto_approve_for_superusers = False keep_history = True moderation.register(Government, GovernmentModerator) moderation.register(GovernmentAnnualAttribute, GovernmentModerator)
from moderation import moderation from models import Book moderation.register(Book)
from django.conf import settings from django.template.defaultfilters import urlencode from django.contrib.gis.geos import GEOSGeometry from django.db.models.signals import post_save from moderation import moderation from moderation.signals import post_moderation from geoads.events import ad_post_save_handler from sites.louersanscom.ads.models import HomeForRentAd from sites.achetersanscom.ads.models import HomeForSaleAd from utils.moderator import AdModerator moderation.register(HomeForRentAd, AdModerator) moderation.register(HomeForSaleAd, AdModerator) # need to remove signal ad and subclass ad_post_save_handler post_save.disconnect(ad_post_save_handler, sender=HomeForRentAd, dispatch_uid="ad_post_save_handler_HomeForRentAd") post_save.disconnect(ad_post_save_handler, sender=HomeForSaleAd, dispatch_uid="ad_post_save_handler_HomeForSaleAd") def post_moderation_abstract_handler(sender, instance, status, **kwargs): # here I call signal function coming form django-geoads ad_post_save_handler(sender, instance, **kwargs) # #tip: ContentType.objects.get_for_model(instance) #tip: here we could get instance.filterset