Removed tag popularity ratings, they are too slow. Added API to get tag

popularity.

boards/mdx_neboard.py

@@ -1,192 +1,192 b''
-from django.core.urlresolvers import reverse
 import markdown
-from markdown.inlinepatterns import Pattern
+from markdown.inlinepatterns import Pattern, SubstituteTagPattern
 from markdown.util import etree
 import boards
 
 __author__ = 'neko259'
 
 
 AUTOLINK_PATTERN = r'(https?://\S+)'
 QUOTE_PATTERN = r'^(?<!>)(>[^>].*)$'
 REFLINK_PATTERN = r'((>>)(\d+))'
 SPOILER_PATTERN = r'%%([^(%%)]+)%%'
 COMMENT_PATTERN = r'^(//(.+))'
 STRIKETHROUGH_PATTERN = r'~(.+)~'
 
 
 class TextFormatter():
     """
     An interface for formatter that can be used in the text format panel
     """
 
     name = ''
 
     # Left and right tags for the button preview
     preview_left = ''
     preview_right = ''
 
     # Left and right characters for the textarea input
     format_left = ''
     format_right = ''
 
 
 class AutolinkPattern(Pattern):
     def handleMatch(self, m):
         link_element = etree.Element('a')
         href = m.group(2)
         link_element.set('href', href)
         link_element.text = href
 
         return link_element
 
 
 class QuotePattern(Pattern, TextFormatter):
     name = ''
     preview_left = '<span class="quote">&gt; '
     preview_right = '</span>'
 
     format_left = '&gt;'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'quote')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class ReflinkPattern(Pattern):
     def handleMatch(self, m):
         post_id = m.group(4)
 
         posts = boards.models.Post.objects.filter(id=post_id)
         if posts.count() > 0:
             ref_element = etree.Element('a')
 
             post = posts[0]
 
             ref_element.set('href', post.get_url())
             ref_element.text = m.group(2)
 
             return ref_element
 
 
 class SpoilerPattern(Pattern, TextFormatter):
     name = 's'
     preview_left = '<span class="spoiler">'
     preview_right = '</span>'
 
     format_left = '%%'
     format_right = '%%'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'spoiler')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class CommentPattern(Pattern, TextFormatter):
     name = ''
     preview_left = '<span class="comment">// '
     preview_right = '</span>'
 
     format_left = '//'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'comment')
         quote_element.text = '//' + m.group(3)
 
         return quote_element
 
 
 class StrikeThroughPattern(Pattern, TextFormatter):
     name = 's'
     preview_left = '<span class="strikethrough">'
     preview_right = '</span>'
 
     format_left = '~'
     format_right = '~'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'strikethrough')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class ItalicPattern(TextFormatter):
     name = 'i'
     preview_left = '<i>'
     preview_right = '</i>'
 
     format_left = '_'
     format_right = '_'
 
 
 class BoldPattern(TextFormatter):
     name = 'b'
     preview_left = '<b>'
     preview_right = '</b>'
 
     format_left = '__'
     format_right = '__'
 
 
 class CodePattern(TextFormatter):
     name = 'code'
     preview_left = '<code>'
     preview_right = '</code>'
 
     format_left = '    '
 
 
 class NeboardMarkdown(markdown.Extension):
     def extendMarkdown(self, md, md_globals):
         self._add_neboard_patterns(md)
         self._delete_patterns(md)
 
     def _delete_patterns(self, md):
         del md.parser.blockprocessors['quote']
 
         del md.inlinePatterns['image_link']
         del md.inlinePatterns['image_reference']
 
     def _add_neboard_patterns(self, md):
         autolink = AutolinkPattern(AUTOLINK_PATTERN, md)
         quote = QuotePattern(QUOTE_PATTERN, md)
         reflink = ReflinkPattern(REFLINK_PATTERN, md)
         spoiler = SpoilerPattern(SPOILER_PATTERN, md)
         comment = CommentPattern(COMMENT_PATTERN, md)
         strikethrough = StrikeThroughPattern(STRIKETHROUGH_PATTERN, md)
 
         md.inlinePatterns[u'autolink_ext'] = autolink
         md.inlinePatterns[u'spoiler'] = spoiler
         md.inlinePatterns[u'strikethrough'] = strikethrough
         md.inlinePatterns[u'comment'] = comment
         md.inlinePatterns[u'reflink'] = reflink
         md.inlinePatterns[u'quote'] = quote
 
 
 def make_extension(configs=None):
     return NeboardMarkdown(configs=configs)
 
 neboard_extension = make_extension()
 
 
 def markdown_extended(markup):
-    return markdown.markdown(markup, [neboard_extension], safe_mode=True)
+    return markdown.markdown(markup, [neboard_extension, 'nl2br'],
+                             safe_mode=True)
 
 formatters = [
     QuotePattern,
     SpoilerPattern,
     ItalicPattern,
     BoldPattern,
     CommentPattern,
     StrikeThroughPattern,
     CodePattern,
 ]

boards/templates/boards/tags.html

@@ -1,27 +1,27 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 
 {% block head %}
     <title>Neboard - {% trans "Tags" %}</title>
 {% endblock %}
 
 {% block content %}
 
 {% cache 600 all_tags_list %}
     <div class="post">
         {% if all_tags %}
             {% for tag in all_tags %}
-                <div class="tag_item" style="opacity: {{ tag.get_font_value }}">
+                <div class="tag_item">
                 <a class="tag" href="{% url 'tag' tag.name %}">
                 #{{ tag.name }}</a>
                 </div>
             {% endfor %}
         {% else %}
             {% trans 'No tags found.' %}
         {% endif %}
     </div>
 {% endcache %}
 
 {% endblock %}

boards/urls.py

@@ -1,83 +1,85 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, archived_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'),
 
     url(r'^archive/$', archived_threads.ArchiveView.as_view(), name='archive'),
     url(r'^archive/page/(?P<page>\w+)/$',
         archived_threads.ArchiveView.as_view(), name='archive'),
 
     # 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'),
 
 )

boards/views/api.py

@@ -1,239 +1,248 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()
 
     logger.info('Getting thread #%s diff since %s' % (thread_id,
         last_update_time))
 
     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.image:
             post_json['image'] = post.image.url
             post_json['image_preview'] = post.image.url_200x150
         if include_last_update:
             post_json['bump_time'] = datetime_to_epoch(
                     post.thread_new.bump_time)
         return post_json