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)