Code cleanup. Update only edited fields while performing thread archiving or post editing. Remove image when post is removed

boards/migrations/0005_auto.py

@@ -1,75 +1,73 b''
 # -*- coding: utf-8 -*-
-import datetime
 from south.db import db
 from south.v2 import SchemaMigration
 from django.db import models
-from boards.models.post import Post, NO_PARENT
 
 
 class Migration(SchemaMigration):
 
     def forwards(self, orm):
         # Adding M2M table for field replies on 'Post'
         m2m_table_name = db.shorten_name(u'boards_post_replies')
         db.create_table(m2m_table_name, (
             ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
             ('from_post', models.ForeignKey(orm[u'boards.post'], null=False)),
             ('to_post', models.ForeignKey(orm[u'boards.post'], null=False))
         ))
         db.create_unique(m2m_table_name, ['from_post_id', 'to_post_id'])
 
     def backwards(self, orm):
         # Removing M2M table for field replies on 'Post'
         db.delete_table(db.shorten_name(u'boards_post_replies'))
 
 
     models = {
         u'boards.ban': {
             'Meta': {'object_name': 'Ban'},
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'})
         },
         u'boards.post': {
             'Meta': {'object_name': 'Post'},
             '_text_rendered': ('django.db.models.fields.TextField', [], {}),
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'image': ('boards.thumbs.ImageWithThumbsField', [], {'max_length': '100', 'blank': 'True'}),
             'image_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
             'image_width': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
             'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
             'parent': ('django.db.models.fields.BigIntegerField', [], {}),
             'poster_ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
             'poster_user_agent': ('django.db.models.fields.TextField', [], {}),
             'pub_time': ('django.db.models.fields.DateTimeField', [], {}),
             'replies': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'re+'", 'null': 'True', 'symmetrical': 'False', 'to': u"orm['boards.Post']"}),
             'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['boards.Tag']", 'symmetrical': 'False'}),
             'text': ('markupfield.fields.MarkupField', [], {'rendered_field': 'True'}),
             'text_markup_type': ('django.db.models.fields.CharField', [], {'default': "'markdown'", 'max_length': '30'}),
             'title': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
             'user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': u"orm['boards.User']", 'null': 'True'})
         },
         u'boards.setting': {
             'Meta': {'object_name': 'Setting'},
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
             'user': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['boards.User']"}),
             'value': ('django.db.models.fields.CharField', [], {'max_length': '50'})
         },
         u'boards.tag': {
             'Meta': {'object_name': 'Tag'},
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
         },
         u'boards.user': {
             'Meta': {'object_name': 'User'},
             'fav_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u"orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
             'fav_threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'+'", 'null': 'True', 'symmetrical': 'False', 'to': u"orm['boards.Post']"}),
             u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
             'last_access_time': ('django.db.models.fields.DateTimeField', [], {}),
             'rank': ('django.db.models.fields.IntegerField', [], {}),
             'registration_time': ('django.db.models.fields.DateTimeField', [], {}),
             'user_id': ('django.db.models.fields.CharField', [], {'max_length': '50'})
         }
     }
 
     complete_apps = ['boards']
  No newline at end of file

boards/models/post.py

@@ -1,381 +1,354 b''
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 import logging
 import os
 from random import random
 import time
 import re
 import hashlib
 
 from django.core.cache import cache
 from django.core.urlresolvers import reverse
 from django.db import models, transaction
 from django.template.loader import render_to_string
 from django.utils import timezone
 from markupfield.fields import MarkupField
 from boards.models import PostImage
 from boards.models.base import Viewable
 
 from boards.models.thread import Thread
 from neboard import settings
 from boards import thumbs
 
 
 APP_LABEL_BOARDS = 'boards'
 
 CACHE_KEY_PPD = 'ppd'
 CACHE_KEY_POST_URL = 'post_url'
 
 POSTS_PER_DAY_RANGE = range(7)
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 200
 
 DEFAULT_MARKUP_TYPE = 'markdown'
 
-# TODO This should be removed when no code relies on it because thread id field
-# was removed a long time ago
-NO_PARENT = -1
-
 # TODO This should be removed
 NO_IP = '0.0.0.0'
 
 # TODO Real user agent should be saved instead of this
 UNKNOWN_UA = ''
 
-# TODO This should be checked for usage and removed because a nativa
-# paginator is used now
-ALL_PAGES = -1
-
-IMAGES_DIRECTORY = 'images/'
-FILE_EXTENSION_DELIMITER = '.'
-
 SETTING_MODERATE = "moderate"
 
 REGEX_REPLY = re.compile('>>(\d+)')
 
 logger = logging.getLogger(__name__)
 
 
 class PostManager(models.Manager):
 
     def create_post(self, title, text, image=None, thread=None,
                     ip=NO_IP, tags=None, user=None):
         """
         Creates new post
         """
 
         posting_time = timezone.now()
         if not thread:
             thread = Thread.objects.create(bump_time=posting_time,
                                            last_edit_time=posting_time)
             new_thread = True
         else:
             thread.bump()
             thread.last_edit_time = posting_time
             thread.save()
             new_thread = False
 
         post = self.create(title=title,
                            text=text,
                            pub_time=posting_time,
                            thread_new=thread,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,  # TODO Get UA at
                            # last!
                            last_edit_time=posting_time,
                            user=user)
 
         if image:
             post_image = PostImage.objects.create(image=image)
             post.images.add(post_image)
             logger.info('Created image #%d for post #%d' % (post_image.id,
                                                             post.id))
 
         thread.replies.add(post)
         if tags:
             linked_tags = []
             for tag in tags:
                 tag_linked_tags = tag.get_linked_tags()
                 if len(tag_linked_tags) > 0:
                     linked_tags.extend(tag_linked_tags)
 
             tags.extend(linked_tags)
             map(thread.add_tag, tags)
 
         if new_thread:
-            self._delete_old_threads()
+            Thread.objects.archive_oldest_threads()
         self.connect_replies(post)
 
         logger.info('Created post #%d' % post.id)
 
         return post
 
     def delete_post(self, post):
         """
         Deletes post and update or delete its thread
         """
 
         post_id = post.id
 
         thread = post.get_thread()
 
         if post.is_opening():
             thread.delete_with_posts()
         else:
             thread.last_edit_time = timezone.now()
             thread.save()
 
             post.delete()
 
         logger.info('Deleted post #%d' % post_id)
 
     def delete_posts_by_ip(self, ip):
         """
         Deletes all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         map(self.delete_post, posts)
 
-    # TODO Move this method to thread manager
-    # TODO Rename it, because the threads are archived instead of plain
-    # removal. Split the delete and archive methods and make a setting to
-    # enable or disable archiving.
-    def _delete_old_threads(self):
-        """
-        Preserves maximum thread count. If there are too many threads,
-        archive the old ones.
-        """
-
-        threads = Thread.objects.filter(archived=False).order_by('-bump_time')
-        thread_count = threads.count()
-
-        if thread_count > settings.MAX_THREAD_COUNT:
-            num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
-            old_threads = threads[thread_count - num_threads_to_delete:]
-
-            for thread in old_threads:
-                thread.archived = True
-                thread.last_edit_time = timezone.now()
-                thread.save()
-
-            logger.info('Archived %d old threads' % num_threads_to_delete)
-
     def connect_replies(self, post):
         """
         Connects replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, post.text.raw):
             post_id = reply_number.group(1)
             ref_post = self.filter(id=post_id)
             if ref_post.count() > 0:
                 referenced_post = ref_post[0]
                 referenced_post.referenced_posts.add(post)
                 referenced_post.last_edit_time = post.pub_time
                 referenced_post.build_refmap()
-                referenced_post.save()
+                referenced_post.save(update_fields=['refmap', 'last_edit_time'])
 
                 referenced_thread = referenced_post.get_thread()
                 referenced_thread.last_edit_time = post.pub_time
-                referenced_thread.save()
+                referenced_thread.save(update_fields=['last_edit_time'])
 
     def get_posts_per_day(self):
         """
         Gets average count of posts per day for the last 7 days
         """
 
         today = date.today()
         ppd = cache.get(CACHE_KEY_PPD + str(today))
         if ppd:
             return ppd
 
         posts_per_days = []
         for i in POSTS_PER_DAY_RANGE:
             day_end = today - timedelta(i + 1)
             day_start = today - timedelta(i + 2)
 
             day_time_start = timezone.make_aware(datetime.combine(
                 day_start, dtime()), timezone.get_current_timezone())
             day_time_end = timezone.make_aware(datetime.combine(
                 day_end, dtime()), timezone.get_current_timezone())
 
             posts_per_days.append(float(self.filter(
                 pub_time__lte=day_time_end,
                 pub_time__gte=day_time_start).count()))
 
         ppd = (sum(posts_per_day for posts_per_day in posts_per_days) /
                len(posts_per_days))
         cache.set(CACHE_KEY_PPD + str(today), ppd)
         return ppd
 
 
 class Post(models.Model, Viewable):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
         ordering = ('id',)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
                        escape_html=False)
 
     images = models.ManyToManyField(PostImage, null=True, blank=True,
                                     related_name='ip+', db_index=True)
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread_new = models.ForeignKey('Thread', null=True, default=None,
             db_index=True)
     last_edit_time = models.DateTimeField()
     user = models.ForeignKey('User', null=True, default=None, db_index=True)
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+',
                                               db_index=True)
     refmap = models.TextField(null=True, blank=True)
 
     def __unicode__(self):
         return '#' + str(self.id) + ' ' + self.title + ' (' + \
                self.text.raw[:50] + ')'
 
     def get_title(self):
         """
         Gets original post title or part of its text.
         """
 
         title = self.title
         if not title:
             title = self.text.rendered
 
         return title
 
     def build_refmap(self):
         map_string = ''
 
         first = True
         for refpost in self.referenced_posts.all():
             if not first:
                 map_string += ', '
             map_string += '<a href="%s">&gt;&gt;%s</a>' % (refpost.get_url(), refpost.id)
             first = False
 
         self.refmap = map_string
 
     def get_sorted_referenced_posts(self):
         return self.refmap
 
     def is_referenced(self):
         return len(self.refmap) > 0
 
     def is_opening(self):
         """
         Checks if this is an opening post or just a reply.
         """
 
         return self.get_thread().get_opening_post_id() == self.id
 
     @transaction.atomic
     def add_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.get_thread()
         thread.add_tag(tag)
         self.last_edit_time = edit_time
         self.save()
 
         thread.last_edit_time = edit_time
         thread.save()
 
     @transaction.atomic
     def remove_tag(self, tag):
         edit_time = timezone.now()
 
         thread = self.get_thread()
         thread.remove_tag(tag)
         self.last_edit_time = edit_time
         self.save()
 
         thread.last_edit_time = edit_time
         thread.save()
 
     def get_url(self, thread=None):
         """
         Gets full url to the post.
         """
 
         cache_key = CACHE_KEY_POST_URL + str(self.id)
         link = cache.get(cache_key)
 
         if not link:
             if not thread:
                 thread = self.get_thread()
 
             opening_id = thread.get_opening_post_id()
 
             if self.id != opening_id:
                 link = reverse('thread', kwargs={
                     'post_id': opening_id}) + '#' + str(self.id)
             else:
                 link = reverse('thread', kwargs={'post_id': self.id})
 
             cache.set(cache_key, link)
 
         return link
 
     def get_thread(self):
         """
         Gets post's thread.
         """
 
         return self.thread_new
 
     def get_referenced_posts(self):
         return self.referenced_posts.only('id', 'thread_new')
 
     def get_text(self):
         return self.text
 
     def get_view(self, moderator=False, need_open_link=False,
                  truncated=False, *args, **kwargs):
         if 'is_opening' in kwargs:
             is_opening = kwargs['is_opening']
         else:
             is_opening = self.is_opening()
 
         if 'thread' in kwargs:
             thread = kwargs['thread']
         else:
             thread = self.get_thread()
 
         if 'can_bump' in kwargs:
             can_bump = kwargs['can_bump']
         else:
             can_bump = thread.can_bump()
 
         opening_post_id = thread.get_opening_post_id()
 
         return render_to_string('boards/post.html', {
             'post': self,
             'moderator': moderator,
             'is_opening': is_opening,
             'thread': thread,
             'bumpable': can_bump,
             'need_open_link': need_open_link,
             'truncated': truncated,
             'opening_post_id': opening_post_id,
         })
 
     def get_first_image(self):
         return self.images.earliest('id')
 
+    def delete(self, using=None):
+        """
+        Delete all post images and the post itself.
+        """
+
+        self.images.all().delete()
+
+        super(Post, self).delete(using)
  No newline at end of file

boards/models/tag.py

@@ -1,141 +1,100 b''
 from django.template.loader import render_to_string
 from boards.models import Thread, Post
 from django.db import models
 from django.db.models import Count, Sum
 from django.core.urlresolvers import reverse
 from boards.models.base import Viewable
 
 __author__ = 'neko259'
 
-# TODO Tag popularity ratings are not used any more, remove all of this
-MAX_TAG_FONT = 1
-MIN_TAG_FONT = 0.2
-
-TAG_POPULARITY_MULTIPLIER = 20
-
-ARCHIVE_POPULARITY_MODIFIER = 0.5
-
 
 class TagManager(models.Manager):
 
     def get_not_empty_tags(self):
         """
         Gets tags that have non-archived threads.
         """
 
         tags = self.annotate(Count('threads')) \
             .filter(threads__count__gt=0).order_by('name')
 
         return tags
 
 
 class Tag(models.Model, Viewable):
     """
     A tag is a text node assigned to the thread. The tag serves as a board
     section. There can be multiple tags for each thread
     """
 
     objects = TagManager()
 
     class Meta:
         app_label = 'boards'
         ordering = ('name',)
 
     name = models.CharField(max_length=100, db_index=True)
     threads = models.ManyToManyField(Thread, null=True,
                                      blank=True, related_name='tag+')
     linked = models.ForeignKey('Tag', null=True, blank=True)
 
     def __unicode__(self):
         return self.name
 
     def is_empty(self):
         """
         Checks if the tag has some threads.
         """
 
         return self.get_thread_count() == 0
 
     def get_thread_count(self):
         return self.threads.count()
 
-    # TODO Remove, not used any more
-    def get_popularity(self):
-        """
-        Gets tag's popularity value as a percentage of overall board post
-        count.
-        """
-
-        all_post_count = Post.objects.count()
-
-        tag_reply_count = 0.0
-
-        tag_reply_count += self.get_post_count()
-        tag_reply_count +=\
-            self.get_post_count(archived=True) * ARCHIVE_POPULARITY_MODIFIER
-
-        popularity = tag_reply_count / all_post_count
-
-        return popularity
-
     def get_linked_tags(self):
         """
         Gets tags linked to the current one.
         """
 
         tag_list = []
         self.get_linked_tags_list(tag_list)
 
         return tag_list
 
     def get_linked_tags_list(self, tag_list=[]):
         """
         Returns the list of tags linked to current. The list can be got
         through returned value or tag_list parameter
         """
 
         linked_tag = self.linked
 
         if linked_tag and not (linked_tag in tag_list):
             tag_list.append(linked_tag)
 
             linked_tag.get_linked_tags_list(tag_list)
 
-    # TODO Remove
-    def get_font_value(self):
-        """
-        Gets tag font value to differ most popular tags in the list
-        """
-
-        popularity = self.get_popularity()
-
-        font_value = popularity * Tag.objects.get_not_empty_tags().count()
-        font_value = max(font_value, MIN_TAG_FONT)
-        font_value = min(font_value, MAX_TAG_FONT)
-
-        return str(font_value)
-
     def get_post_count(self, archived=False):
         """
         Gets posts count for the tag's threads.
         """
 
         posts_count = 0
 
         threads = self.threads.filter(archived=archived)
         if threads.exists():
-            posts_count = threads.annotate(posts_count=Count('replies')).aggregate(
-                posts_sum=Sum('posts_count'))['posts_sum']
+            posts_count = threads.annotate(posts_count=Count('replies')) \
+                .aggregate(posts_sum=Sum('posts_count'))['posts_sum']
 
         if not posts_count:
             posts_count = 0
 
         return posts_count
 
     def get_url(self):
         return reverse('tag', kwargs={'tag_name': self.name})
 
     def get_view(self, *args, **kwargs):
         return render_to_string('boards/tag.html', {
             'tag': self,
         })

boards/models/thread.py

@@ -1,163 +1,186 b''
 import logging
 from django.db.models import Count
 from django.utils import timezone
 from django.core.cache import cache
 from django.db import models
 from neboard import settings
 
 __author__ = 'neko259'
 
 
 logger = logging.getLogger(__name__)
 
 
 CACHE_KEY_OPENING_POST = 'opening_post_id'
 
 
+class ThreadManager(models.Manager):
+    def archive_oldest_threads(self):
+        """
+         Preserves maximum thread count. If there are too many threads,
+         archive the old ones.
+         """
+
+        threads = Thread.objects.filter(archived=False).order_by('-bump_time')
+        thread_count = threads.count()
+
+        if thread_count > settings.MAX_THREAD_COUNT:
+            num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
+            old_threads = threads[thread_count - num_threads_to_delete:]
+
+            for thread in old_threads:
+                thread.archived = True
+                thread.last_edit_time = timezone.now()
+                thread.save(update_fields=['archived', 'last_edit_time'])
+
+            logger.info('Archived %d old threads' % num_threads_to_delete)
+
+
 class Thread(models.Model):
+    objects = ThreadManager()
 
     class Meta:
         app_label = 'boards'
 
     tags = models.ManyToManyField('Tag')
     bump_time = models.DateTimeField()
     last_edit_time = models.DateTimeField()
     replies = models.ManyToManyField('Post', symmetrical=False, null=True,
                                      blank=True, related_name='tre+')
     archived = models.BooleanField(default=False)
 
     def get_tags(self):
         """
         Gets a sorted tag list.
         """
 
         return self.tags.order_by('name')
 
     def bump(self):
         """
         Bumps (moves to up) thread if possible.
         """
 
         if self.can_bump():
             self.bump_time = timezone.now()
 
             logger.info('Bumped thread %d' % self.id)
 
     def get_reply_count(self):
         return self.replies.count()
 
     def get_images_count(self):
         # TODO Use sum
         total_count = 0
         for post_with_image in self.replies.annotate(images_count=Count(
                 'images')):
             total_count += post_with_image.images_count
         return total_count
 
     def can_bump(self):
         """
         Checks if the thread can be bumped by replying to it.
         """
 
         if self.archived:
             return False
 
         post_count = self.get_reply_count()
 
         return post_count < settings.MAX_POSTS_PER_THREAD
 
     def delete_with_posts(self):
         """
         Completely deletes thread and all its posts
         """
 
         if self.replies.exists():
             self.replies.all().delete()
 
         self.delete()
 
     def get_last_replies(self):
         """
         Gets several last replies, not including opening post
         """
 
         if settings.LAST_REPLIES_COUNT > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(settings.LAST_REPLIES_COUNT,
                                           reply_count - 1)
                 replies = self.get_replies()
                 last_replies = replies[reply_count - reply_count_to_show:]
 
                 return last_replies
 
     def get_skipped_replies_count(self):
         """
         Gets number of posts between opening post and last replies.
         """
         reply_count = self.get_reply_count()
         last_replies_count = min(settings.LAST_REPLIES_COUNT,
                                  reply_count - 1)
         return reply_count - last_replies_count - 1
 
     def get_replies(self, view_fields_only=False):
         """
         Gets sorted thread posts
         """
 
         query = self.replies.order_by('pub_time').prefetch_related('images')
         if view_fields_only:
             query = query.defer('poster_user_agent', 'text_markup_type')
         return query.all()
 
     def get_replies_with_images(self, view_fields_only=False):
         return self.get_replies(view_fields_only).annotate(images_count=Count(
             'images')).filter(images_count__gt=0)
 
     def add_tag(self, tag):
         """
         Connects thread to a tag and tag to a thread
         """
 
         self.tags.add(tag)
         tag.threads.add(self)
 
     def remove_tag(self, tag):
         self.tags.remove(tag)
         tag.threads.remove(self)
 
     def get_opening_post(self, only_id=False):
         """
         Gets the first post of the thread
         """
 
         query = self.replies.order_by('pub_time')
         if only_id:
             query = query.only('id')
         opening_post = query.first()
 
         return opening_post
 
     def get_opening_post_id(self):
         """
         Gets ID of the first thread post.
         """
 
         cache_key = CACHE_KEY_OPENING_POST + str(self.id)
         opening_post_id = cache.get(cache_key)
         if not opening_post_id:
             opening_post_id = self.get_opening_post(only_id=True).id
             cache.set(cache_key, opening_post_id)
 
         return opening_post_id
 
     def __unicode__(self):
         return str(self.id)
 
     def get_pub_time(self):
         """
         Gets opening post's pub time because thread does not have its own one.
         """
 
         return self.get_opening_post().pub_time

boards/urls.py

@@ -1,84 +1,82 b''
 from django.conf.urls import patterns, url, include
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 from boards.views import api, tag_threads, all_threads, \
         login, settings, all_tags
 from boards.views.authors import AuthorsView
 from boards.views.delete_post import DeletePostView
 from boards.views.ban import BanUserView
 from boards.views.static import StaticPageView
 from boards.views.post_admin import PostAdminView
 
 js_info_dict = {
     'packages': ('boards',),
 }
 
 urlpatterns = patterns('',
 
     # /boards/
     url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
     # /boards/page/
     url(r'^page/(?P<page>\w+)/$', all_threads.AllThreadsView.as_view(),
         name='index'),
 
     # login page
     url(r'^login/$', login.LoginView.as_view(), name='login'),
 
     # /boards/tag/tag_name/
     url(r'^tag/(?P<tag_name>\w+)/$', tag_threads.TagView.as_view(),
         name='tag'),
     # /boards/tag/tag_id/page/
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/$',
         tag_threads.TagView.as_view(), name='tag'),
 
     # /boards/thread/
     url(r'^thread/(?P<post_id>\w+)/$', views.thread.ThreadView.as_view(),
         name='thread'),
     url(r'^thread/(?P<post_id>\w+)/mode/(?P<mode>\w+)/$', views.thread.ThreadView
         .as_view(), name='thread_mode'),
 
     # /boards/post_admin/
     url(r'^post_admin/(?P<post_id>\w+)/$', PostAdminView.as_view(),
             name='post_admin'),
 
     url(r'^settings/$', settings.SettingsView.as_view(), name='settings'),
     url(r'^tags/$', all_tags.AllTagsView.as_view(), name='tags'),
     url(r'^captcha/', include('captcha.urls')),
     url(r'^authors/$', AuthorsView.as_view(), name='authors'),
     url(r'^delete/(?P<post_id>\w+)/$', DeletePostView.as_view(),
             name='delete'),
     url(r'^ban/(?P<post_id>\w+)/$', BanUserView.as_view(), name='ban'),
 
     url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
         name='staticpage'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\w+)/rss/$', AllThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/rss/$', TagThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/rss/$', TagThreadsFeed()),
     url(r'^thread/(?P<post_id>\w+)/rss/$', ThreadPostsFeed()),
 
     # i18n
     url(r'^jsi18n/$', 'boards.views.cached_js_catalog', js_info_dict,
         name='js_info_dict'),
 
     # API
     url(r'^api/post/(?P<post_id>\w+)/$', api.get_post, name="get_post"),
     url(r'^api/diff_thread/(?P<thread_id>\w+)/(?P<last_update_time>\w+)/$',
         api.api_get_threaddiff, name="get_thread_diff"),
     url(r'^api/threads/(?P<count>\w+)/$', api.api_get_threads,
             name='get_threads'),
     url(r'^api/tags/$', api.api_get_tags, name='get_tags'),
     url(r'^api/thread/(?P<opening_post_id>\w+)/$', api.api_get_thread_posts,
             name='get_thread'),
     url(r'^api/add_post/(?P<opening_post_id>\w+)/$', api.api_add_post,
             name='add_post'),
-    url(r'^api/get_tag_popularity/(?P<tag_name>\w+)$', api.get_tag_popularity,
-            name='get_tag_popularity'),
 
     # Search
     url(r'^search/', include('haystack.urls')),
 
 )

boards/views/api.py

@@ -1,246 +1,237 b''
 from datetime import datetime
 import json
 import logging
 from django.db import transaction
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, render
 from django.template import RequestContext
 from django.utils import timezone
 from django.core import serializers
 
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post, Thread, Tag
 from boards.utils import datetime_to_epoch
 from boards.views.thread import ThreadView
 
 __author__ = 'neko259'
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 
 DIFF_TYPE_HTML = 'html'
 DIFF_TYPE_JSON = 'json'
 
 STATUS_OK = 'ok'
 STATUS_ERROR = 'error'
 
 logger = logging.getLogger(__name__)
 
 
 @transaction.atomic
 def api_get_threaddiff(request, thread_id, last_update_time):
     """
     Gets posts that were changed or added since time
     """
 
     thread = get_object_or_404(Post, id=thread_id).get_thread()
 
     filter_time = datetime.fromtimestamp(float(last_update_time) / 1000000,
                                          timezone.get_current_timezone())
 
     json_data = {
         'added': [],
         'updated': [],
         'last_update': None,
     }
     added_posts = Post.objects.filter(thread_new=thread,
                                       pub_time__gt=filter_time) \
         .order_by('pub_time')
     updated_posts = Post.objects.filter(thread_new=thread,
                                         pub_time__lte=filter_time,
                                         last_edit_time__gt=filter_time)
 
     diff_type = DIFF_TYPE_HTML
     if PARAMETER_DIFF_TYPE in request.GET:
         diff_type = request.GET[PARAMETER_DIFF_TYPE]
 
     for post in added_posts:
         json_data['added'].append(_get_post_data(post.id, diff_type, request))
     for post in updated_posts:
         json_data['updated'].append(_get_post_data(post.id, diff_type, request))
     json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 def api_add_post(request, opening_post_id):
     """
     Adds a post and return the JSON response for it
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
 
     logger.info('Adding post via api...')
 
     status = STATUS_OK
     errors = []
 
     if request.method == 'POST':
         form = PostForm(request.POST, request.FILES, error_class=PlainErrorList)
         form.session = request.session
 
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             # _ban_current_user(request)
             status = STATUS_ERROR
         if form.is_valid():
             post = ThreadView().new_post(request, form, opening_post,
                                          html_response=False)
             if not post:
                 status = STATUS_ERROR
             else:
                 logger.info('Added post #%d via api.' % post.id)
         else:
             status = STATUS_ERROR
             errors = form.as_json_errors()
 
     response = {
         'status': status,
         'errors': errors,
     }
 
     return HttpResponse(content=json.dumps(response))
 
 
 def get_post(request, post_id):
     """
     Gets the html of a post. Used for popups. Post can be truncated if used
     in threads list with 'truncated' get parameter.
     """
 
     logger.info('Getting post #%s' % post_id)
 
     post = get_object_or_404(Post, id=post_id)
 
     context = RequestContext(request)
     context['post'] = post
     if PARAMETER_TRUNCATED in request.GET:
         context[PARAMETER_TRUNCATED] = True
 
     return render(request, 'boards/api_post.html', context)
 
 
 # TODO Test this
 def api_get_threads(request, count):
     """
     Gets the JSON thread opening posts list.
     Parameters that can be used for filtering:
     tag, offset (from which thread to get results)
     """
 
     if PARAMETER_TAG in request.GET:
         tag_name = request.GET[PARAMETER_TAG]
         if tag_name is not None:
             tag = get_object_or_404(Tag, name=tag_name)
             threads = tag.threads.filter(archived=False)
     else: 
         threads = Thread.objects.filter(archived=False)
 
     if PARAMETER_OFFSET in request.GET:
         offset = request.GET[PARAMETER_OFFSET]
         offset = int(offset) if offset is not None else 0
     else:
         offset = 0
 
     threads = threads.order_by('-bump_time')
     threads = threads[offset:offset + int(count)]
 
     opening_posts = []
     for thread in threads:
         opening_post = thread.get_opening_post()
 
         # TODO Add tags, replies and images count
         opening_posts.append(_get_post_data(opening_post.id,
                                             include_last_update=True))
 
     return HttpResponse(content=json.dumps(opening_posts))
 
 
 # TODO Test this
 def api_get_tags(request):
     """
     Gets all tags or user tags.
     """
 
     # TODO Get favorite tags for the given user ID
 
     tags = Tag.objects.get_not_empty_tags()
     tag_names = []
     for tag in tags:
         tag_names.append(tag.name)
 
     return HttpResponse(content=json.dumps(tag_names))
 
 
 # TODO The result can be cached by the thread last update time
 # TODO Test this
 def api_get_thread_posts(request, opening_post_id):
     """
     Gets the JSON array of thread posts
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
     thread = opening_post.get_thread()
     posts = thread.get_replies()
 
     json_data = {
         'posts': [],
         'last_update': None,
     }
     json_post_list = []
 
     for post in posts:
         json_post_list.append(_get_post_data(post.id))
     json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
     json_data['posts'] = json_post_list
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 def api_get_post(request, post_id):
     """
     Gets the JSON of a post. This can be
     used as and API for external clients.
     """
 
     post = get_object_or_404(Post, id=post_id)
 
     json = serializers.serialize("json", [post], fields=(
         "pub_time", "_text_rendered", "title", "text", "image",
         "image_width", "image_height", "replies", "tags"
     ))
 
     return HttpResponse(content=json)
 
 
-def get_tag_popularity(request, tag_name):
-    tag = get_object_or_404(Tag, name=tag_name)
-
-    json_data = []
-    json_data['popularity'] = tag.get_popularity()
-
-    return HttpResponse(content=json.dumps(json_data))
-
-
 # TODO Add pub time and replies
 def _get_post_data(post_id, format_type=DIFF_TYPE_JSON, request=None,
         include_last_update=False):
     if format_type == DIFF_TYPE_HTML:
         return get_post(request, post_id).content.strip()
     elif format_type == DIFF_TYPE_JSON:
         post = get_object_or_404(Post, id=post_id)
         post_json = {
             'id': post.id,
             'title': post.title,
             'text': post.text.rendered,
         }
         if post.images.exists():
             post_image = post.get_first_image()
             post_json['image'] = post_image.image.url
             post_json['image_preview'] = post_image.image.url_200x150
         if include_last_update:
             post_json['bump_time'] = datetime_to_epoch(
                 post.thread_new.bump_time)
         return post_json