def test_integrity_error_on_duplicate_spam_comments(self):
class AllIsSpamModerator(EntryCommentModerator):
spam_checker_backends = [
'zinnia.spam_checker.backends.all_is_spam'
]
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, AllIsSpamModerator)
datas = {
'name': 'Jim Bob',
'email': '*****@*****.**',
'url': '',
'comment': 'This is my comment'
}
f = CommentForm(self.entry)
datas.update(f.initial)
url = reverse('comments-post-comment')
self.assertEquals(self.entry.comment_count, 0)
connect_discussion_signals()
self.client.post(url, datas)
self.client.post(url, datas)
disconnect_discussion_signals()
self.assertEqual(comments.get_model().objects.count(), 1)
entry_reloaded = Entry.objects.get(pk=self.entry.pk)
self.assertEquals(entry_reloaded.comment_count, 0)
def test_comment_count_denormalization(self):
class AllIsSpamModerator(EntryCommentModerator):
spam_checker_backends = ["zinnia.spam_checker.backends.all_is_spam"]
class NoMailNoSpamModerator(EntryCommentModerator):
def email(self, *ka, **kw):
pass
def moderate(self, *ka, **kw):
return False
datas = {"name": "Jim Bob", "email": "*****@*****.**", "url": "", "comment": "This is my comment"}
f = CommentForm(self.entry)
datas.update(f.initial)
url = reverse("comments-post-comment")
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, AllIsSpamModerator)
self.assertEqual(self.entry.comment_count, 0)
connect_discussion_signals()
self.client.post(url, datas)
entry_reloaded = Entry.objects.get(pk=self.entry.pk)
self.assertEqual(entry_reloaded.comment_count, 0)
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, NoMailNoSpamModerator)
datas["comment"] = "This a published comment"
self.client.post(url, datas)
disconnect_discussion_signals()
entry_reloaded = Entry.objects.get(pk=self.entry.pk)
self.assertEqual(entry_reloaded.comment_count, 1)
def __new__(cls, name, bases, attrs):
model = super(CommentableModelBase, cls).__new__(cls, name, bases, attrs)
try:
moderator.register(model, CommentableModelModerator)
except AlreadyModerated:
pass
return model
def moderate_model(ParentModel, publication_date_field=None, enable_comments_field=None):
"""
Register a parent model (e.g. ``Blog`` or ``Article``) that should receive comment moderation.
:param ParentModel: The parent model, e.g. a ``Blog`` or ``Article`` model.
:param publication_date_field: The field name of a :class:`~django.db.models.DateTimeField` in the parent model which stores the publication date.
:type publication_date_field: str
:param enable_comments_field: The field name of a :class:`~django.db.models.BooleanField` in the parent model which stores the whether comments are enabled.
:type enable_comments_field: str
"""
attrs = {
'auto_close_field': publication_date_field,
'auto_moderate_field': publication_date_field,
'enable_field': enable_comments_field,
}
ModerationClass = type(ParentModel.__name__ + 'Moderator', (FluentCommentsModerator,), attrs)
moderator.register(ParentModel, ModerationClass)
def moderate_model(ParentModel, publication_date_field=None, enable_comments_field=None):
"""
Register a parent model (e.g. ``Blog`` or ``Article``) that should receive comment moderation.
:param ParentModel: The parent model, e.g. a ``Blog`` or ``Article`` model.
:param publication_date_field: The field name of a :class:`~django.db.models.DateTimeField` in the parent model which stores the publication date.
:type publication_date_field: str
:param enable_comments_field: The field name of a :class:`~django.db.models.BooleanField` in the parent model which stores the whether comments are enabled.
:type enable_comments_field: str
"""
attrs = {
'auto_close_field': publication_date_field,
'auto_moderate_field': publication_date_field,
'enable_field': enable_comments_field,
}
ModerationClass = type(ParentModel.__name__ + 'Moderator', (FluentCommentsModerator,), attrs)
moderator.register(ParentModel, ModerationClass)
def test_integrity_error_on_duplicate_spam_comments(self):
class AllIsSpamModerator(EntryCommentModerator):
spam_checker_backends = ["zinnia.spam_checker.backends.all_is_spam"]
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, AllIsSpamModerator)
datas = {"name": "Jim Bob", "email": "*****@*****.**", "url": "", "comment": "This is my comment"}
f = CommentForm(self.entry)
datas.update(f.initial)
url = reverse("comments-post-comment")
self.assertEquals(self.entry.comment_count, 0)
connect_discussion_signals()
self.client.post(url, datas)
self.client.post(url, datas)
disconnect_discussion_signals()
self.assertEqual(comments.get_model().objects.count(), 1)
entry = Entry.objects.get(pk=self.entry.pk)
self.assertEquals(entry.comment_count, 0)
def test_comment_count_denormalization(self):
class AllIsSpamModerator(EntryCommentModerator):
spam_checker_backends = [
'zinnia.spam_checker.backends.all_is_spam'
]
class NoMailNoSpamModerator(EntryCommentModerator):
def email(self, *ka, **kw):
pass
def moderate(self, *ka, **kw):
return False
datas = {
'name': 'Jim Bob',
'email': '*****@*****.**',
'url': '',
'comment': 'This is my comment'
}
f = CommentForm(self.entry)
datas.update(f.initial)
url = reverse('comments-post-comment')
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, AllIsSpamModerator)
self.assertEquals(self.entry.comment_count, 0)
connect_discussion_signals()
self.client.post(url, datas)
entry_reloaded = Entry.objects.get(pk=self.entry.pk)
self.assertEquals(entry_reloaded.comment_count, 0)
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, NoMailNoSpamModerator)
datas['comment'] = 'This a published comment'
self.client.post(url, datas)
disconnect_discussion_signals()
entry_reloaded = Entry.objects.get(pk=self.entry.pk)
self.assertEquals(entry_reloaded.comment_count, 1)
def test_integrity_error_on_duplicate_spam_comments(self):
class AllIsSpamModerator(EntryCommentModerator):
spam_checker_backends = [
'zinnia.spam_checker.backends.all_is_spam']
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, AllIsSpamModerator)
datas = {'name': 'Jim Bob',
'email': '*****@*****.**',
'url': '',
'comment': 'This is my comment'}
f = CommentForm(self.entry)
datas.update(f.initial)
url = reverse('comments-post-comment')
self.client.post(url, datas)
self.client.post(url, datas)
self.assertEqual(comments.get_model().objects.count(), 1)
self.assertEqual(
comments.get_model().objects.all()[0].flags.count(), 1)
def test_comment_count_denormalization(self):
class AllIsSpamModerator(EntryCommentModerator):
spam_checker_backends = [
'zinnia.spam_checker.backends.all_is_spam']
class NoMailNoSpamModerator(EntryCommentModerator):
def email(self, *ka, **kw):
pass
def moderate(self, *ka, **kw):
return False
datas = {'name': 'Jim Bob',
'email': '*****@*****.**',
'url': '',
'comment': 'This is my comment'}
f = CommentForm(self.entry)
datas.update(f.initial)
url = reverse('comments-post-comment')
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, AllIsSpamModerator)
self.assertEquals(self.entry.comment_count, 0)
connect_discussion_signals()
self.client.post(url, datas)
entry_reloaded = Entry.objects.get(pk=self.entry.pk)
self.assertEquals(entry_reloaded.comment_count, 0)
moderator_stack.unregister(Entry)
moderator_stack.register(Entry, NoMailNoSpamModerator)
datas['comment'] = 'This a published comment'
self.client.post(url, datas)
disconnect_discussion_signals()
entry_reloaded = Entry.objects.get(pk=self.entry.pk)
self.assertEquals(entry_reloaded.comment_count, 1)
auto_close_field = 'date_published'
else:
auto_close_field = None
close_after = settings.CLOSE_AFTER_DAYS
email_notification = settings.EMAIL_COMMENTS_TO_STAFF
def allow(self, comment, content_object, request):
if settings.COMMENTERS_MUST_BE_AUTHENTICATED and\
not request.user.is_authenticated():
return False
else:
return super(ArticleModerator,self).allow(comment, content_object, request)
moderator.register(Article, ArticleModerator)
class OutOfDate(models.Model):
'''Reserved for future use.
Will represent articles that are out-of-date and superceded by other content.
'''
article = models.OneToOneField(Article)
is_out_of_date = models.BooleanField(default=False)
referral_url = models.URLField(blank=True)
referral_url_title = models.CharField(max_length=MAX_LENGTH, blank=True)
class Meta:
verbose_name = _('out of date article')
verbose_name_plural = _('out of date articles')
def initiator_linked (self):
return self._linked_names('initiator')
@property
def author_linked (self):
return self._linked_names('author')
from django.contrib.comments.moderation import CommentModerator, moderator
class DraftLawModerator (CommentModerator):
email_notification = True
enable_field = 'enable_annotations'
auto_moderate_field = 'moderate_annotations'
moderate_after = 0 # immediately
moderator.register(DraftLaw, DraftLawModerator)
class DraftLawDiscussion (models.Model):
"""Discussion about a law."""
PASSEDDISC_CHOICES = (
('N', _('Not passed')),
('P', _('Passed')),
)
#: law being discussed
draftlaw = models.ForeignKey(DraftLaw, related_name='discussions', help_text=_('Draft Law'))
#: date of discussion
date = models.DateField(help_text=_('Date of Discussion'))
#: place of discussion
place = models.CharField(max_length=255, help_text=_('Place of Discussion'))
class Meta:
ordering = ("-date",)
title = models.CharField(verbose_name="Naslov", max_length=150)
text = HTMLField(verbose_name="Novica")
image = models.ImageField(blank=True,
null=True,
upload_to='announce/%Y/%m/',
verbose_name="Slika ob objavi")
date = models.DateTimeField(auto_now_add=True, db_index=True)
slug = models.SlugField(max_length=150, unique=True)
author = models.ForeignKey(User)
#the field for calendar id's which can not be matched by title to stories
# TODO: make this foreignkeys to events
calendar_id = models.IntegerField(blank=True, null=True)
language = models.CharField(max_length=2,
default='si',
choices=settings.LANGUAGES,
blank=True,
null=True)
def get_absolute_url(self):
return reverse('intranet.www.views.news_detail', args=[self.id,
self.slug])
def __unicode__(self):
return self.title
moderator.register(News, AkismetModerator)
def testAutoCloseFieldImmediate(self):
moderator.register(Entry, EntryModerator6)
c1, c2 = self.createSomeComments()
self.assertEquals(Comment.objects.all().count(), 0)
class CountryMEP(models.Model):
mep = models.ForeignKey(MEP)
country = models.ForeignKey(Country)
party = models.ForeignKey(LocalParty)
begin = models.DateField(null=True)
end = models.DateField(null=True)
class OrganizationMEP(models.Model):
mep = models.ForeignKey(MEP)
organization = models.ForeignKey(Organization)
role = models.CharField(max_length=255)
begin = models.DateField(null=True)
end = models.DateField(null=True)
@reify
def instance(self):
return self.organization
class MepModerator(CommentModerator):
email_notification = True
moderate_after = 0
def moderate(self, comment, content_object, request):
return True
moderator.register(MEP, MepModerator)
dot = ENTRY_BASE_MODEL.rindex('.')
module_name = ENTRY_BASE_MODEL[:dot]
class_name = ENTRY_BASE_MODEL[dot + 1:]
try:
_class = getattr(import_module(module_name), class_name)
return _class
except (ImportError, AttributeError):
warnings.warn('%s cannot be imported' % ENTRY_BASE_MODEL,
RuntimeWarning)
return EntryAbstractClass
class Entry(get_base_model()):
"""Final Entry model"""
class Meta:
"""Entry's Meta"""
ordering = ['-creation_date']
verbose_name = _('entry')
verbose_name_plural = _('entries')
permissions = (('can_view_all', 'Can view all'),
('can_change_author', 'Can change author'), )
moderator.register(Entry, EntryCommentModerator)
mptt.register(Category, order_insertion_by=['title'])
post_save.connect(ping_directories_handler, sender=Entry,
dispatch_uid='zinnia.entry.post_save.ping_directories')
post_save.connect(ping_external_urls_handler, sender=Entry,
dispatch_uid='zinnia.entry.post_save.ping_external_urls')
if app_settings.CLOSE_COMMENTS_AFTER:
if post_parm.date_published + \
datetime.timedelta(days=app_settings.CLOSE_COMMENTS_AFTER) \
<= datetime.datetime.now():
return 'closed'
if app_settings.AUTHENTICATED_COMMENTS_ONLY and\
not user.is_authenticated():
return 'authenticate'
return 'true'
def allow(self, comment, content_object, request):
if self.can_comment(content_object, request.user) != 'true':
return False
else:
return super(PostModerator, self).allow(comment, content_object,
request)
class EditorChoice(models.Model):
comment = models.OneToOneField(Comment)
editors_choice = models.BooleanField(default=False,
verbose_name="Editor's Choice")
for p in [BasicPost, PostWithImage, PostWithSlideshow, PostWithEmbeddedObject]:
if p not in moderator._registry:
moderator.register(p, PostModerator)
def testAutoCloseField(self):
moderator.register(Entry, EntryModerator3)
self.createSomeComments()
self.assertEqual(Comment.objects.all().count(), 0)
def testEmailNotification(self):
with override_settings(MANAGERS=("*****@*****.**",)):
moderator.register(Entry, EntryModerator1)
self.createSomeComments()
self.assertEqual(len(mail.outbox), 2)
class Blog(models.Model):
title = models.CharField(max_length=100,
unique_for_date="posted",
verbose_name="Заголовок")
description = models.TextField(verbose_name="Краткое содержание")
content = models.TextField(verbose_name="Полное содержание")
posted = models.DateTimeField(default=datetime.now(),
db_index=True,
verbose_name="Опубликована")
is_commentable = models.BooleanField(default=True,
verbose_name="Разрешены комментарии")
tags = TaggableManager(blank=True, verbose_name="Теги")
user = models.ForeignKey(User, editable=False)
def get_absolute_url(self):
return reverse("blog_detail", kwargs={"pk": self.pk})
class Meta:
ordering = ["-posted"]
verbose_name = "статья блога"
verbose_name_plural = "статьи блога"
class BlogModerator(CommentModerator):
email_notification = True
enable_field = "is_commentable"
moderator.register(Blog, BlogModerator)
def get_tags(self):
return Tag.objects.get_for_object(self)
#metodo para devolver la url exacta del objeto
def get_full_url(self):
return "/noticias/%s/" % self.slug
#metodo para obtener el nombre del objeto
def get_name(self):
return self.titulo
# def categorias(self):
# return self.Noticia.all()[0].categoria.nombre
from django.db.models import signals
class NoticiaModerador(CommentModerator):
email_notification = True
auto_moderate_field = 'fecha'
moderate_after = 15
signals.post_save.connect(comment_notifier, sender=Comment)
try:
moderator.register(Noticia, NoticiaModerador)
except AlreadyModerated:
pass
from django.contrib.comments.moderation import CommentModerator, moderator
from django.db import models
from django.utils.translation import ugettext as _
from cms.models import CMSPlugin
class Discussion(models.Model):
title = models.CharField(_('Title'), max_length=128)
enable_comments = models.BooleanField(default=True)
def __unicode__(self):
return self.title
class DiscussionPlugin(CMSPlugin):
discussion = models.ForeignKey(Discussion)
class EntryModerator(CommentModerator):
"""
email admins when comment is inserted
"""
email_notification = True
enable_field = 'enable_comments'
moderator.register(Discussion, EntryModerator)
if self.wishlist_set.filter(user=user).first():
return True
else:
return False
class ProductModerator(CommentModerator):
moderate_after = 30
def moderate(self, comment, content_object, request):
already_moderated = super(ProductModerator,self).moderate(comment, content_object, request)
if already_moderated:
return True
return True
moderator.register(Product, ProductModerator)
class Promotion(models.Model):
name = models.CharField("Name", max_length=100)
description = models.TextField(validators=[MaxLengthValidator(500)])
products = models.ManyToManyField(Product)
percent = models.FloatField("Percent",)
start_date = models.DateField(default=datetime.datetime.now())
status = models.CharField(max_length=1,
choices=DISCOUNT_STATUS_CHOICES.choices,
default=DISCOUNT_STATUS_CHOICES.PENDING)
def __unicode__(self):
return self.name
def testEmailNotification(self):
moderator.register(Entry, EntryModerator1)
c1, c2 = self.createSomeComments()
self.assertEquals(len(mail.outbox), 2)
url = models.URLField(unique=True)
text = models.CharField(max_length=100)
is_published = models.BooleanField(default=True)
def __unicode__(self):
return self.text
def get_absolute_url(self):
return self.url
class CommentModerator(CommentModerator):
email_notification = True
enable_field = 'is_public'
#Helper methods
def _infer_title_or_slug(text):
return '-'.join(text.split()[:5])
def _generate_summary(text):
return ' '.join(text.split()[:100])
moderator.register(Comment, CommentModerator)
from south.modelsinspector import add_introspection_rules
add_introspection_rules([], ["^markupfield\.fields\.MarkupField"])
"""Models for Zinnia""" from zinnia.models.entry import Entry from zinnia.models.author import Author from zinnia.models.category import Category from zinnia.signals import connect_entry_signals from zinnia.signals import connect_discussion_signals from zinnia.moderator import EntryCommentModerator from django.contrib.comments.moderation import moderator # Here we import the Zinnia's Model classes # to register the Models at the loading, not # when the Zinnia's URLs are parsed. Issue #161. __all__ = [Entry.__name__, Author.__name__, Category.__name__] # Register the comment moderator on Entry moderator.register(Entry, EntryCommentModerator) # Connect the signals connect_entry_signals() connect_discussion_signals()
class Meta:
verbose_name = _("News")
verbose_name_plural = _("News")
ordering = ["-created_at"]
class NewsCommentModerator(CommentModerator):
"""
News comments moderator.
The following logic applies:
- unauthenticated users' comments are always moderated
and an email is sent to the administrators
- respect the ``comments_enabled`` flag on news
- comments are closed after 30 days the news item was
created
"""
email_notification = True
auto_close_field = "created_at"
close_after = 30
enable_field = "comments_enabled"
def email(self, comment, content_object, request):
if not request.user.is_authenticated():
return True
return False
def moderate(self, comment, content_object, request):
if not request.user.is_authenticated():
return True
return False
moderator.register(News, NewsCommentModerator)
def __unicode__(self):
return '%s: %s' % (self.title, self.get_status_display())
@models.permalink
def get_absolute_url(self):
"""Return objecttype's URL"""
return ('gstudio_objecttype_detail', (), {
'year': self.creation_date.strftime('%Y'),
'month': self.creation_date.strftime('%m'),
'day': self.creation_date.strftime('%d'),
'slug': self.slug})
class Meta:
"""Objecttype's Meta"""
ordering = ['-creation_date']
verbose_name = _('object type')
verbose_name_plural = _('object types')
permissions = (('can_view_all', 'Can view all'),
('can_change_author', 'Can change author'), )
moderator.register(Objecttype, ObjecttypeCommentModerator)
mptt.register(Metatype, order_insertion_by=['title'])
mptt.register(Objecttype, order_insertion_by=['title'])
post_save.connect(ping_directories_handler, sender=Objecttype,
dispatch_uid='gstudio.objecttype.post_save.ping_directories')
post_save.connect(ping_external_urls_handler, sender=Objecttype,
dispatch_uid='gstudio.objecttype.post_save.ping_external_urls')
year_refs = [ref.year, []]
month_refs[1].append(ref)
prev_year = ref.year
prev_yearmonth = ref.year + ref.month_b
if len(year_refs) > 0:
year_refs[1].append(month_refs)
refs.append(year_refs)
return refs
class TopicModerator(CommentModerator):
email_notification = False
enable_field = 'allow_comments'
moderator.register(Topic, TopicModerator)
def topic_categories_changed(sender, **kwargs):
"""
When we add or remove categories on this topic, we need to re-set those
categories' topic counts.
"""
if kwargs['reverse'] == False:
# We're changing the categories on a topic.
if kwargs['action'] == 'pre_clear':
# Before we do anything,
# store the PKs of the current categories on this topic.
kwargs['instance']._original_categories_pks = [
c.pk for c in kwargs['instance'].categories.all()
]
class Confirmation(models.Model):
key = models.CharField(max_length=64, blank=True)
email = models.EmailField()
violation = models.ForeignKey(Violation)
class Admin:
pass
class ViolationModerator(CommentModerator):
email_notification = True
moderate_after = 0
def moderate(self, comment, content_object, request):
return True
if Violation not in moderator._registry:
moderator.register(Violation, ViolationModerator)
class FeaturedCase(models.Model):
case = models.OneToOneField(Violation)
class Admin:
pass
def __unicode__(self):
return u"*%s*" % self.case
'month': self.publish_at.month,
'day': self.publish_at.day,
'object_id': self.pk,
})
def clean(self, **kwargs):
if self.is_draft and self.publish_at:
self.publish_at = None
elif not self.is_draft and not self.publish_at:
self.publish_at = date.today()
super(Article, self).clean(**kwargs)
def validate_unique(self, exclude=None):
if isinstance(exclude, (list, tuple)):
if 'publish_at' in exclude: exclude.remove('publish_at')
super(Article, self).validate_unique(exclude)
from django.contrib.comments.moderation import CommentModerator, moderator, AlreadyModerated
class ArticleModerator(CommentModerator):
email_notification = True
enable_field = 'enable_comments'
try:
moderator.register(Article, ArticleModerator)
except AlreadyModerated:
pass
from cards.models import Cards, Tag, Category
class CardsAdmin(admin.ModelAdmin):
list_display = ('topic', 'owner', 'tag', 'added')
list_editable = ('tag',)
ordering = ('-added', )
search_fields = ['topic',]
date_hierarchy = 'added'
list_filter = ('owner',)
admin.site.register(Cards, CardsAdmin)
class CardsModerator(CommentModerator):
email_notification = True
moderator.register(Cards, CardsModerator)
class TagInline(admin.TabularInline):
model = Tag
class CategoryAdmin(admin.ModelAdmin):
list_display = ('title', 'slug', 'has_cards', 'sort')
list_editable = ('sort',)
inlines = [ TagInline ]
admin.site.register(Category, CategoryAdmin)
class TagAdmin(admin.ModelAdmin):
pass
admin.site.register(Tag, TagAdmin)
class EpisodeModerator(AkismetModerator):
enable_field = 'enable_comments'
def email(self, comment, content_object, request):
moderators = []
chief = settings.EDITORS['chief']
moderators.append(chief)
managing = settings.EDITORS['managing']
moderators.append(managing)
online_dev = settings.EDITORS['online_dev']
moderators.append(online_dev)
multimedia = settings.EDITORS['multimedia']
moderators.append(multimedia)
online_assistant = settings.EDITORS['online_assistant']
moderators.append(online_assistant)
context = {'comment': comment, 'content_object': content_object}
subject = 'New comment awaiting moderation on "%s"' % content_object
render_email_and_send(
context=context,
message_template='podcasts/comment_notification_email.txt',
subject=subject,
recipients=moderators)
def moderate(self, comment, content_object, request):
return True
moderator.register(Episode, EpisodeModerator)
super(Bookmark, self).save(*args, **kwargs)
self.snippet.update_bookmark_count()
def delete(self, *args, **kwargs):
super(Bookmark, self).delete(*args, **kwargs)
self.snippet.update_bookmark_count()
class SnippetModerator(SpamFighterModerator):
# Regular options by Django's contributed CommentModerator
email_notification = True
# Spam fighter options:
# Check with Akismet for spam
akismet_check = True
# If Akismet marks this message as spam, delete it instantly (False) or
# add it the comment the moderation queue (True). Default is True.
akismet_check_moderate = True
# Do a keyword check
keyword_check = False
# If a keyword is found, delete it instantly (False) or add the comment to
# the moderation queue (True). Default is False.
keyword_check_moderate = True
moderator.register(Snippet, SnippetModerator)
from cab.listeners import start_listening
start_listening()
def testAutoCloseField(self):
moderator.register(Entry, EntryModerator3)
c1, c2 = self.createSomeComments()
self.assertEquals(Comment.objects.all().count(), 0)
from django.db import models
from django.contrib.auth.models import User
from django.db.models import Count
import datetime
class Model2(models.Model):
title = models.CharField(max_length=50,help_text="title - max length 50 characters")
fieldmodel2 = models.CharField(max_length=50,help_text="fieldmodel2 - max length 50 characters")
pub_date = models.DateTimeField('date published')
enable_comments = models.BooleanField(default=True)
def was_published_today(self):
return self.pub_date.date() == datetime.date.today()
was_published_today.short_description = 'Published today?'
def __unicode__(self):
return self.title
# Register MaybeLessSpamCommentModerator moderator for Model2
from django.contrib.comments.moderation import moderator
from maybelessspamcomment.moderation import MaybeLessSpamCommentModerator
moderator.register(Model2, MaybeLessSpamCommentModerator)
if instance.tweet_this:
try:
if settings.TWITTER_USERNAME and settings.TWITTER_PASSWORD:
url = content_tiny_url("%s/%s" % (settings.ROOT_BLOG_URL,
instance.get_absolute_url()))
api = twitter.Api(username = settings.TWITTER_USERNAME,
password = settings.TWITTER_PASSWORD)
api.PostUpdate("New blog post - %s" % url)
except:
pass
def config_name(sender, instance, created, **kwargs):
if created:
temp = Configuration.objects.all()
if temp.count() > 2:
raise Exception(
"There can only be one configuration entry, \
thus only one theme. Sorry!")
class PostModerator(CommentModerator):
email_notification = True
enable_field = 'enable_comments'
moderator.register(Story, PostModerator)
moderator.register(Article, PostModerator)
moderator.register(Gallery, PostModerator)
post_save.connect(config_name, sender=Configuration)
post_save.connect(post_tweet, sender=Article)
post_save.connect(post_tweet, sender=Story)
def register(model):
"""Just a wrapper around django.contrib.comments.moderation.register.
It's only argument is the model for comment moderation."""
moderator.register(model, CookieModerator)
return reverse("goods_detail", kwargs = {"pk": self.pk})
class Meta:
verbose_name = "товар"
verbose_name_plural = "товары"
class GoodImage(models.Model):
good = models.ForeignKey(Good)
image = models.ImageField(upload_to = "goods/detail", verbose_name = "Дополнительное изображение")
def save(self, *args, **kwargs):
try:
this_record = GoodImage.objects.get(pk = self.pk)
if this_record.image != self.image:
this_record.image.delete(save = False)
except:
pass
super(GoodImage, self).save(*args, **kwargs)
def delete(self, *args, **kwargs):
self.image.delete(save = False)
super(GoodImage, self).delete(*args, **kwargs)
class Meta:
verbose_name = "изображение к товару"
verbose_name_plural = "изображения к товару"
class GoodModerator(CommentModerator):
email_notification = True
moderator.register(Good, GoodModerator)
def testRegisterExistingModel(self):
moderator.register(Entry, EntryModerator1)
self.assertRaises(AlreadyModerated, moderator.register, Entry, EntryModerator1)
class Image(models.Model):
"""
A model that allows the blog author(s) to add images to each blog post. As this model is
related to a specific Post instance by ForeignKey, each post can have as many associated
Image objects as the author wants. There are optional name and caption fields.
"""
post = models.ForeignKey(Post, related_name="images")
name = models.CharField(max_length=20, blank=True)
image = models.ImageField(upload_to="photos/%Y/%m/%d")
caption = models.CharField(max_length=1000, blank=True)
def __unicode__(self):
return self.name
class PostModerator(CommentModerator):
"""
An subclass of CommendModerator that makes all comments subject to moderation immediately
after they are posted.
"""
email_notification = False
auto_moderate_field = "pub_date"
moderate_after = 0
moderator.register(Post, PostModerator)
def testCommentsEnabled(self):
moderator.register(Entry, EntryModerator2)
c1, c2 = self.createSomeComments()
self.assertEquals(Comment.objects.all().count(), 1)
#
# import myproject.project_moderation
from django.conf import settings
from django.utils.translation import activate
from django.utils.translation import get_language
from django.contrib.comments.moderation import moderator
from zinnia.models import Entry
from zinnia.moderator import EntryCommentModerator
class ProjectEntryCommentModerator(EntryCommentModerator):
def email(self, comment, content_object, request):
"""Always send mail on new comments"""
current_language = get_language()
try:
activate(settings.LANGUAGE_CODE)
if self.mail_comment_notification_recipients:
self.do_email_notification(comment, content_object, request)
if self.email_authors:
self.do_email_authors(comment, content_object, request)
if self.email_reply:
self.do_email_reply(comment, content_object, request)
finally:
activate(current_language)
moderator.unregister(Entry)
moderator.register(Entry, ProjectEntryCommentModerator)
def testAutoModerateField(self):
moderator.register(Entry, EntryModerator4)
c1, c2 = self.createSomeComments()
self.assertEquals(c2.is_public, False)
blank=True, null=False)
system_set = models.ManyToManyField('self', related_name="in_system_set_of",
verbose_name='nested systems',
blank=True, null=False)
def __unicode__(self):
return self.title
if not reversion.is_registered(Process):
reversion.register(Process, follow=["priorstate_attribute_set", "priorstate_relation_set", "poststate_attribute_set", "poststate_relation_set", "prior_nodes", "posterior_nodes"])
if not reversion.is_registered(System):
reversion.register(System, follow=["systemtypes", "gbobject_set", "relation_set", "attribute_set", "process_set", "system_set", "prior_nodes", "posterior_nodes"])
if not reversion.is_registered(Gbobject):
reversion.register(Gbobject, follow=["node_ptr","objecttypes", "prior_nodes", "posterior_nodes"])
moderator.register(Gbobject, GbobjectCommentModerator)
post_save.connect(ping_directories_handler, sender=Gbobject,
dispatch_uid='objectapp.gbobject.post_save.ping_directories')
post_save.connect(ping_external_urls_handler, sender=Gbobject,
dispatch_uid='objectapp.gbobject.post_save.ping_external_urls')
'month': self.month,
'day': self.day,
'slug': self.slug,
})
def make_references(self):
"""
Sets all the Encyclopedia Topics the text of this letter (and
footnotes) refers to. Saves them to the database.
"""
self.topics.clear()
# Get a list of all the Topic IDs mentioned in text and footnotes:
ids = re.findall(r'pepysdiary.com\/encyclopedia\/(\d+)\/', '%s %s' % (
self.text, self.footnotes))
# Make sure list of Topic IDs is unique:
# From http://stackoverflow.com/a/480227/250962
seen = set()
seen_add = seen.add
unique_ids = [id for id in ids if id not in seen and not seen_add(id)]
for id in unique_ids:
topic = Topic.objects.get(pk=id)
topic.letter_references.add(self)
class LetterModerator(CommentModerator):
email_notification = False
enable_field = 'allow_comments'
moderator.register(Letter, LetterModerator)
if not reversion.is_registered(Process):
reversion.register(Process,
follow=[
"priorstate_attribute_set",
"priorstate_relation_set",
"poststate_attribute_set", "poststate_relation_set",
"priornodes", "posteriornodes"
])
if not reversion.is_registered(System):
reversion.register(System,
follow=[
"systemtypes", "object_set", "relation_set",
"attribute_set", "process_set", "system_set",
"priornodes", "posteriornodes"
])
if not reversion.is_registered(Gbobject):
reversion.register(Gbobject,
follow=["objecttypes", "priornodes", "posteriornodes"])
moderator.register(Gbobject, GbobjectCommentModerator)
post_save.connect(ping_directories_handler,
sender=Gbobject,
dispatch_uid='objectapp.gbobject.post_save.ping_directories')
post_save.connect(
ping_external_urls_handler,
sender=Gbobject,
dispatch_uid='objectapp.gbobject.post_save.ping_external_urls')
refs.append(year_refs)
year_refs = [ref.year, []]
month_refs[1].append(ref)
prev_year = ref.year
prev_yearmonth = ref.year + ref.month_b
if len(year_refs) > 0:
year_refs[1].append(month_refs)
refs.append(year_refs)
return refs
class TopicModerator(CommentModerator):
email_notification = False
enable_field = 'allow_comments'
moderator.register(Topic, TopicModerator)
def topic_categories_changed(sender, **kwargs):
"""
When we add or remove categories on this topic, we need to re-set those
categories' topic counts.
"""
if kwargs['reverse'] == False:
# We're changing the categories on a topic.
if kwargs['action'] == 'pre_clear':
# Before we do anything,
# store the PKs of the current categories on this topic.
kwargs['instance']._original_categories_pks = [
c.pk for c in kwargs['instance'].categories.all()]
def __unicode__(self):
return u'%s' % (self.title)
def save(self, *args, **kwargs):
self.intro_html = markdown(self.intro)
self.text_html = markdown(self.text)
if self.date_published is None and \
self.status == self.STATUS_PUBLISHED:
# If we're published, and the date_published hasn't been set,
# then set it.
self.date_published = timezone.now()
super(Post, self).save(*args, **kwargs)
def get_absolute_url(self):
return reverse('post_detail',
kwargs={
'year': self.date_published.strftime('%Y'),
'month': self.date_published.strftime('%m'),
'day': self.date_published.strftime('%d'),
'pk': self.pk,
})
class PostModerator(CommentModerator):
email_notification = False
enable_field = 'allow_comments'
moderator.register(Post, PostModerator)
url = models.URLField(unique=True)
text = models.CharField(max_length=100)
is_published = models.BooleanField(default=True)
def __unicode__(self):
return self.text
def get_absolute_url(self):
return self.url
class CommentModerator(CommentModerator):
email_notification = True
enable_field = 'is_public'
#Helper methods
def _infer_title_or_slug(text):
return '-'.join(text.split()[:5])
def _generate_summary(text):
return ' '.join(text.split()[:100])
moderator.register(Comment, CommentModerator)
from south.modelsinspector import add_introspection_rules
add_introspection_rules([], ["^markupfield\.fields\.MarkupField"])
if settings.TWITTER_USERNAME and settings.TWITTER_PASSWORD:
url = content_tiny_url("%s/%s" % (settings.ROOT_BLOG_URL, instance.get_absolute_url()))
api = twitter.Api(username=settings.TWITTER_USERNAME, password=settings.TWITTER_PASSWORD)
api.PostUpdate("New blog post - %s" % url)
except:
pass
def config_name(sender, instance, created, **kwargs):
if created:
temp = Configuration.objects.all()
if temp.count() > 2:
raise Exception(
"There can only be one configuration entry, \
thus only one theme. Sorry!"
)
class PostModerator(CommentModerator):
email_notification = True
enable_field = "enable_comments"
moderator.register(Story, PostModerator)
moderator.register(Article, PostModerator)
moderator.register(Gallery, PostModerator)
post_save.connect(config_name, sender=Configuration)
post_save.connect(post_tweet, sender=Article)
post_save.connect(post_tweet, sender=Story)
from akismet import Akismet
from django.conf import settings
from django.contrib.comments.moderation import CommentModerator, moderator
from django.contrib.comments.models import Comment
from django.contrib.comments.signals import comment_will_be_posted
from django.contrib.sites.models import Site
from django.core.mail import mail_managers
from django.utils.encoding import smart_str
class EntryModerator(CommentModerator):
auto_moderate_field = 'pub_date'
moderate_after = 30
email_notification = True
def moderate(self, comment, content_object, request):
already_moderated = super(EntryModerator, self).moderate(comment, content_object)
if already_moderated:
return True
akismet_api = Akismet(key=settings.AKISMET_API_KEY, blog_url="http:/%s/" % Site.objects.get_current().domain)
if akismet_api.verify_key():
akismet_data = { 'comment_type': 'comment', 'referrer': request.META['HTTP_REFERER'], 'user_ip': comment.ip_address, 'user-agent': request.META['HTTP_USER_AGENT']}
return akismet_api.comment_check(smart_str(comment.comment), akismet_data, build_data=True)
return False
moderator.register(Entry, EntryModerator)
#email_body = "%s posted a new commenton the entry '%s'."
#mail_managers("New comment posted", email_body % (comment.name, comment.content_object))
#comment_will_be_posted.connect(moderate_comment, sender=Comment)
def testRegisterExistingModel(self):
moderator.register(Entry, EntryModerator1)
self.assertRaises(AlreadyModerated, moderator.register, Entry,
EntryModerator1)
online_assistant = settings.EDITORS["online_assistant"]
moderators.append(online_assistant)
context = {"comment": comment, "content_object": content_object}
subject = 'New comment awaiting moderation on "%s"' % content_object
render_email_and_send(
context=context,
message_template="multimedia/video_comment_notification_email.txt",
subject=subject,
recipients=moderators,
)
def moderate(self, comment, content_object, request):
return True
moderator.register(Video, VideoModerator)
# NEW: This model includes the following new field: zip
# Be sure to add it to the database.
class Slideshow(Content):
title = models.CharField(max_length=150, db_index=True)
# FIXME: This was a ForeignKey in the 2008 site. Change this in the
# database.
description = models.TextField()
length = models.PositiveSmallIntegerField(
help_text="Length of the slideshow in seconds. Enter a zero if there is no audio."
)
image = models.ImageField(
"preview photo",
upload_to="%Y/%m%d/slideshows",
help_text="Upload a photo to represent this slideshow on the site. It will automatically be resized for you.",
def testEmailNotification(self):
moderator.register(Entry, EntryModerator1)
self.createSomeComments()
self.assertEquals(len(mail.outbox), 2)
return reverse("goods_detail", kwargs = {"pk": self.pk})
class Meta:
verbose_name = "товар"
verbose_name_plural = "товары"
class GoodImage(models.Model):
good = models.ForeignKey(Good)
image = models.ImageField(upload_to = "goods/detail", verbose_name = "Дополнительное изображение")
def save(self, *args, **kwargs):
try:
this_record = GoodImage.objects.get(pk = self.pk)
if this_record.image != self.image:
this_record.image.delete(save = False)
except:
pass
super(GoodImage, self).save(*args, **kwargs)
def delete(self, *args, **kwargs):
self.image.delete(save = False)
super(GoodImage, self).delete(*args, **kwargs)
class Meta:
verbose_name = "изображение к товару"
verbose_name_plural = "изображения к товару"
class GoodModerator(CommentModerator):
email_notification = True
moderator.register(Good, GoodModerator)
def testCommentsEnabled(self):
moderator.register(Entry, EntryModerator2)
self.createSomeComments()
self.assertEquals(Comment.objects.all().count(), 1)
author = models.ForeignKey(User, editable=False, verbose_name=_("author"))
class Meta:
ordering = ["-date"]
verbose_name = "Eintrag"
verbose_name_plural = "Eintraege"
def get_absolute_url(self):
return "/blog/%s/%s/" % (self.date.strftime("%Y/%m/%d"), self.slug)
def get_next_public_by_date(self):
return self.get_next_by_date(is_public=True)
def get_previous_public_by_date(self):
return self.get_previous_by_date(is_public=True)
def __unicode__(self):
return u"%s" % self.title
class EntryModerator(CommentModerator):
email_notification = True
enable_field = "enable_comments"
auto_close_field = "date"
moderate_after = -1
auto_moderate_field = "date"
close_after = 14
moderator.register(Entry, EntryModerator)
def testAutoModerateFieldImmediate(self):
moderator.register(Entry, EntryModerator5)
c1, c2 = self.createSomeComments()
self.assertEquals(c2.is_public, False)
