if request.method == 'POST':
ctx['form'] = TagCreateAliasForm( request.POST )
if ctx['form'].is_valid():
cleaned_data = ctx['form'].cleaned_data
tag = cleaned_data['tag']
aliases = cleaned_data['aliases']
already_added = TagAlias.objects.filter( tag=tag )
for added in already_added:
if added.name in aliases:
aliases.remove( added.name )
else:
added.delete()
for alias in aliases:
TagAlias.objects.create( tag=tag, name=alias )
messages.add_message( request, messages.INFO, _( "Alias created!" ) )
return redirect( self.get_absolute_url() )
else:
ctx['form'] = TagCreateAliasForm()
return render( request, 'moderation/tag_aliases/create.html', ctx )
registry.register( TagAliasTool() )
registry.register( TagRenamingTool() )
super( ExternalLinkToRemove, self ).reject( user, reason )
self.send_notification();
def send_notification( self ):
if self.user != self.moderation_status_by and notification:
notification.send( [ self.user ], "link_to_remove_moderated", { "item": self } )
# register moderated items
from film20.moderation.registry import registry
from film20.moderation.items import ModeratedObjectItem
moderated_links = ModeratedObjectItem(
ExternalLink, "externallink.can_add_link",
name="externallink",
item_template_name="moderation/externallink/record.html",
rss_template_name="moderation/externallink/rss.xml"
)
moderated_links_to_remove = ModeratedObjectItem(
ExternalLinkToRemove, "externallink.can_add_link",
name="externallink-tr",
item_template_name="moderation/externallink-tr/record.html",
rss_template_name="moderation/externallink-tr/rss.xml"
)
registry.register( moderated_links )
registry.register( moderated_links_to_remove )
def get_queryset(self, status):
if status == ModeratedObject.STATUS_UNKNOWN:
status = FilmToImport.UNKNOW
elif status == ModeratedObject.STATUS_ACCEPTED:
status = FilmToImport.ACCEPTED
elif status == ModeratedObject.STATUS_REJECTED:
status = FilmToImport.NOT_ACCEPTED
return self.model._default_manager.filter(status=status)
def accept_item(self, item, user, **kwargs):
if self.can_accept(item, user):
item.accept(user, **kwargs)
else:
raise ModerationException(_("Permission denied!"))
def reject_item(self, item, user, reason=None):
if self.can_reject(item, user):
item.reject(user, reason)
else:
raise ModerationException(_("Permission denied!"))
moderated_added_film = FilmToImportModeratedItem()
registry.register(moderated_added_film)
pass
# if moderated send notification ...
if instance.moderation_status != AddedFilm.STATUS_UNKNOWN \
and instance.user != instance.moderation_status_by:
if notification:
notification.send( [ instance.user ], "added_film_moderated", { "item": instance,
"accepted": instance.moderation_status == AddedFilm.STATUS_ACCEPTED } )
post_save.connect( added_film_post_save, sender=AddedFilm )
class AddedCharacter( models.Model ):
person = models.ForeignKey( Person, verbose_name=_( "Person" ) )
added_film = models.ForeignKey( AddedFilm, verbose_name=_( "Film" ) )
importance = models.IntegerField( _( "Importance" ), blank=True, null=True )
character = models.CharField( _( "Character" ), max_length=255, blank=True, null=True )
from film20.config.urls import urls
from film20.moderation.registry import registry
from film20.moderation.items import ModeratedObjectItem
moderated_added_film = ModeratedObjectItem(
AddedFilm, "add_films.can_accept_added_films",
name=urls["MODERATED_FILMS"], item_template_name="moderation/add_films/record.html",
rss_template_name="moderation/add_films/rss.xml"
)
registry.register( moderated_added_film )
template_name = 'moderation/film_features/edit.html'
def get_context_data( self, *args, **kwargs ):
context = super( ModerationEditFeaturesView, self ).get_context_data( *args, **kwargs )
moderated_items = registry.get_by_user( self.request.user )
context.update({
"all" : self.request.method == 'GET' and self.request.GET.get( 'all', False ),
"tag" : self.request.method == 'GET' and self.request.GET.get( 'tag', '' ),
"moderated_item" : registry.get_by_name( "film-features" ),
"moderated_items": moderated_items['items'],
"moderator_tools": moderated_items['tools'],
"from_moderation": True,
})
return context
class FilmFeaturesTool( ModeratorTool ):
name = "film-features"
permission = "core.can_edit_localized_title"
verbose_name = _( "Film features" )
def get_view( self, request ):
all = request.method == 'GET' and request.GET.get( 'all', False )
tag = request.method == 'GET' and request.GET.get( 'tag', '' )
next_film_to_vote = FilmFeature.objects.next_film_to_vote( request.user, all_movies=all, tag=tag )
if next_film_to_vote is None:
return render( request, 'moderation/film_features/edit.html', { 'all': all, 'tag': tag } )
return ModerationEditFeaturesView.as_view()( request, pk=next_film_to_vote.pk )
registry.register( FilmFeaturesTool() )
"moderator_tools": moderated_items['tools']
}
lang = settings.LANGUAGE_CODE
to_lang = TagTranslation.to_lang()
if request.method == 'POST':
for f, t in request.POST.items():
TagTranslation.create_translation(f, t)
if request.is_ajax():
return HttpResponse(json.dumps({'success': True}))
kwargs = {"%s__isnull" % to_lang: False}
translated = [
t[lang]
for t in TagTranslation.objects.filter(**kwargs).values(lang)
]
ctx['items'] = Tag.objects.all().exclude(
name__in=translated).order_by('weight')
ctx['lang'] = lang
ctx['to_lang'] = to_lang
return render(request, 'moderation/tag_translation/list.html', ctx)
registry.register(TagAliasTool())
registry.register(TagRenamingTool())
registry.register(TagTranslateToolA())
registry.register(TagTranslateToolB())
ua.object_slug = instance.content_object.permalink
ua.content = instance.content_object.image
ua.save()
# if moderated send notification ...
if instance.moderation_status != ModeratedPhoto.STATUS_UNKNOWN \
and instance.user != instance.moderation_status_by:
if notification:
notification.send( [ instance.user ], "photo_moderated", { "item": instance,
"status": instance.moderation_status } )
else:
raise NotImplementedError
post_save.connect( photo_post_save, sender=ModeratedPhoto )
from film20.config.urls import urls
from film20.moderation.registry import registry
from film20.moderation.items import ModeratedObjectItem
moderated_photo_item = ModeratedObjectItem(
ModeratedPhoto, "posters.can_accept_posters",
name=urls["MODERATED_PHOTOS"], item_template_name="moderation/posters/record.html",
rss_template_name="moderation/posters/rss.xml"
)
registry.register( moderated_photo_item )
ua.object_slug = instance.content_object.permalink
ua.content = poster.image
ua.save()
# if moderated send notification ...
if instance.moderation_status != ModeratedPhoto.STATUS_UNKNOWN \
and instance.user != instance.moderation_status_by:
if notification:
notification.send( [ instance.user ], "photo_moderated", { "item": instance,
"status": instance.moderation_status } )
else:
raise NotImplementedError
post_save.connect( photo_post_save, sender=ModeratedPhoto )
from film20.config.urls import urls
from film20.moderation.registry import registry
from film20.moderation.items import ModeratedObjectItem
moderated_photo_item = ModeratedObjectItem(
ModeratedPhoto, "posters.can_accept_posters",
name=urls["MODERATED_PHOTOS"], item_template_name="moderation/posters/record.html",
rss_template_name="moderation/posters/rss.xml"
)
registry.register( moderated_photo_item )
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#-------------------------------------------------------------------------------
from django.db import models
from django.contrib.auth.models import User
from film20.moderation.models import ModeratedObject
from film20.moderation.registry import registry, AlreadyRegistered
from film20.moderation.items import ModeratedItem, ModeratedObjectItem
class TestModeratedObject( ModeratedObject ):
user = models.ForeignKey( User )
class Meta:
permissions = (
( "test_moderation_permission", "Can moderate" ),
)
class ModeratedItem1( ModeratedItem ):
name = 'user-test'
model = User
permission = 'tests.test_moderation_permission'
registry.register(
ModeratedObjectItem(
TestModeratedObject, "tests.test_moderation_permission",
name = "test-moderated-object", item_template_name='moderation/record.html'
)
)
moderated_items['items'],
"moderator_tools":
moderated_items['tools'],
"from_moderation":
True,
})
return context
class FilmFeaturesTool(ModeratorTool):
name = "film-features"
permission = "core.can_edit_localized_title"
verbose_name = _("Film features")
def get_view(self, request):
all = request.method == 'GET' and request.GET.get('all', False)
tag = request.method == 'GET' and request.GET.get('tag', '')
next_film_to_vote = FilmFeature.objects.next_film_to_vote(
request.user, all_movies=all, tag=tag)
if next_film_to_vote is None:
return render(request, 'moderation/film_features/edit.html', {
'all': all,
'tag': tag
})
return ModerationEditFeaturesView.as_view()(request,
pk=next_film_to_vote.pk)
registry.register(FilmFeaturesTool())
"moderated_item": registry.get_by_name( self.name ),
"moderated_items": moderated_items['items'],
"moderator_tools": moderated_items['tools']
}
lang = settings.LANGUAGE_CODE
to_lang = TagTranslation.to_lang()
if request.method == 'POST':
for f, t in request.POST.items():
TagTranslation.create_translation( f, t )
if request.is_ajax():
return HttpResponse( json.dumps( { 'success': True } ) )
kwargs = {
"%s__isnull" % to_lang: False
}
translated = [ t[lang] for t in TagTranslation.objects.filter( **kwargs ).values( lang ) ]
ctx['items'] = Tag.objects.all().exclude( name__in=translated ).order_by( 'weight' )
ctx['lang'] = lang
ctx['to_lang'] = to_lang
return render( request, 'moderation/tag_translation/list.html', ctx )
registry.register( TagAliasTool() )
registry.register( TagRenamingTool() )
registry.register( TagTranslateToolA() )
registry.register( TagTranslateToolB() )
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#-------------------------------------------------------------------------------
from django.db import models
from django.contrib.auth.models import User
from film20.moderation.models import ModeratedObject
from film20.moderation.registry import registry, AlreadyRegistered
from film20.moderation.items import ModeratedItem, ModeratedObjectItem
class TestModeratedObject(ModeratedObject):
user = models.ForeignKey(User)
class Meta:
permissions = (("test_moderation_permission", "Can moderate"), )
class ModeratedItem1(ModeratedItem):
name = 'user-test'
model = User
permission = 'tests.test_moderation_permission'
registry.register(
ModeratedObjectItem(TestModeratedObject,
"tests.test_moderation_permission",
name="test-moderated-object",
item_template_name='moderation/record.html'))
