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 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 models import SuccessCase moderation.register(SuccessCase)
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)
from geoads.contrib.moderation.moderator import AdModerator from moderation import moderation from customads.models import TestModeratedAd moderation.register(TestModeratedAd, AdModerator)
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 backoffice.models import Work
class WorkModerator(GenericModerator):
auto_approve_for_staff = False
visibility_column = 'visible'
moderation.register(Work, WorkModerator)
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 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 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
