Speed up loading favorite list. Add reflinks to the list to see favorite

threads

boards/static/js/main.js

@@ -1,129 +1,126
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
  Copyright (C) 2013  neko259
 
  The JavaScript code in this page is free software: you can
  redistribute it and/or modify it under the terms of the GNU
  General Public License (GNU GPL) as published by the Free Software
  Foundation, either version 3 of the License, or (at your option)
  any later version.  The code is distributed WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
 
  As additional permission under GNU GPL version 3 section 7, you
  may distribute non-source (e.g., minimized or compacted) forms of
  that code without the copy of the GNU GPL normally required by
  section 4, provided you include this license notice and a URL
  through which recipients can access the Corresponding Source.
 
  @licend  The above is the entire license notice
  for the JavaScript code in this page.
  */
 
 var FAV_POST_UPDATE_PERIOD = 10000;
 
 /**
  * An email is a hidden file to prevent spam bots from posting. It has to be
  * hidden.
  */
 function hideEmailFromForm() {
     $('.form-email').parent().parent().hide();
 }
 
 /**
  * Highlight code blocks with code highlighter
  */
 function highlightCode(node) {
     node.find('pre code').each(function(i, e) {
         hljs.highlightBlock(e);
     });
 }
 
 function updateFavPosts() {
     var includePostBody = $('#fav-panel').is(":visible");
     var url = '/api/new_posts/';
     if (includePostBody) {
         url += '?include_posts'
     }
     $.getJSON(url,
         function(data) {
             var allNewPostCount = 0;
 
             if (includePostBody) {
                 var favoriteThreadPanel = $('#fav-panel');
                 favoriteThreadPanel.empty();
             }
 
             $.each(data, function (_, dict) {
                 var newPostCount = dict.new_post_count;
                 allNewPostCount += newPostCount;
 
                 if (includePostBody) {
-                    var post = $(dict.post);
-
-                    var id = post.find('.post_id');
-                    var title = post.find('.title');
-
                     var favThreadNode = $('<div class="post"></div>');
-                    favThreadNode.append(id);
+                    favThreadNode.append($(dict.post_url));
                     favThreadNode.append(' ');
-                    favThreadNode.append(title);
+                    favThreadNode.append($('<span class="title">' + dict.title + '</span>'));
 
                     if (newPostCount > 0) {
                         favThreadNode.append(' (<a href="' + dict.newest_post_link + '">+' + newPostCount + "</a>)");
                     }
 
                     favoriteThreadPanel.append(favThreadNode);
+
+                    addRefLinkPreview(favThreadNode[0]);
                 }
             });
 
             var newPostCountNode = $('#new-fav-post-count');
             if (allNewPostCount > 0) {
                 newPostCountNode.text('(+' + allNewPostCount + ')');
                 newPostCountNode.show();
             } else {
                 newPostCountNode.hide();
             }
         }
     );
 }
 
 function initFavPanel() {
     updateFavPosts();
 
     if ($('#fav-panel-btn').length > 0) {
         setInterval(updateFavPosts, FAV_POST_UPDATE_PERIOD);
         $('#fav-panel-btn').click(function() {
             $('#fav-panel').toggle();
             updateFavPosts();
 
             return false;
         });
 
         $(document).on('keyup.removepic', function(e) {
             if(e.which === 27) {
                 $('#fav-panel').hide();
             }
         });
     }
 }
 
 $( document ).ready(function() {
     hideEmailFromForm();
 
     $("a[href='#top']").click(function() {
         $("html, body").animate({ scrollTop: 0 }, "slow");
         return false;
     });
 
     addImgPreview();
 
     addRefLinkPreview();
 
     highlightCode($(document));
 
     initFavPanel();
 });

boards/views/api.py

@@ -1,274 +1,274
 from collections import OrderedDict
 import json
 import logging
 
 from django.db import transaction
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404
 from django.core import serializers
 from boards.abstracts.settingsmanager import get_settings_manager
 
 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
 from boards.models.user import Notification
 from boards.mdx_neboard import Parser
 
 
 __author__ = 'neko259'
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 PARAMETER_POST = 'post'
 PARAMETER_UPDATED = 'updated'
 PARAMETER_LAST_UPDATE = 'last_update'
 PARAMETER_THREAD = 'thread'
 PARAMETER_UIDS = 'uids'
 
 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):
     """
     Gets posts that were changed or added since time
     """
 
     thread_id = request.POST.get(PARAMETER_THREAD)
     uids_str = request.POST.get(PARAMETER_UIDS).strip()
     uids = uids_str.split(' ')
 
     opening_post = get_object_or_404(Post, id=thread_id)
     thread = opening_post.get_thread()
 
     json_data = {
         PARAMETER_UPDATED: [],
         PARAMETER_LAST_UPDATE: None,  # TODO Maybe this can be removed already?
     }
     posts = Post.objects.filter(threads__in=[thread]).exclude(uid__in=uids)
 
     diff_type = request.GET.get(PARAMETER_DIFF_TYPE, DIFF_TYPE_HTML)
 
     for post in posts:
         json_data[PARAMETER_UPDATED].append(post.get_post_data(
             format_type=diff_type, request=request))
     json_data[PARAMETER_LAST_UPDATE] = str(thread.last_edit_time)
 
     # If the tag is favorite, update the counter
     settings_manager = get_settings_manager(request)
     favorite = settings_manager.thread_is_fav(opening_post)
     if favorite:
         settings_manager.add_or_read_fav_thread(opening_post)
 
     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.
     """
 
     post = get_object_or_404(Post, id=post_id)
     truncated = PARAMETER_TRUNCATED in request.GET
 
     return HttpResponse(content=post.get_view(truncated=truncated))
 
 
 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.get_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
         post_data = opening_post.get_post_data(include_last_update=True)
         post_data['bumpable'] = thread.can_bump()
         post_data['archived'] = thread.archived
 
         opening_posts.append(post_data)
 
     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()
 
     term = request.GET.get('term')
     if term is not None:
         tags = tags.filter(name__contains=term)
 
     tag_names = [tag.name for tag in tags]
 
     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(post.get_post_data())
     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_notifications(request, username):
     last_notification_id_str = request.GET.get('last', None)
     last_id = int(last_notification_id_str) if last_notification_id_str is not None else None
 
     posts = Notification.objects.get_notification_posts(username=username,
                                                         last=last_id)
 
     json_post_list = []
     for post in posts:
         json_post_list.append(post.get_post_data())
     return HttpResponse(content=json.dumps(json_post_list))
 
 
 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 api_get_preview(request):
     raw_text = request.POST['raw_text']
 
     parser = Parser()
     return HttpResponse(content=parser.parse(parser.preparse(raw_text)))
 
 
 def api_get_new_posts(request):
     """
     Gets favorite threads and unread posts count.
     """
     posts = list()
 
     include_posts = 'include_posts' in request.GET
 
     settings_manager = get_settings_manager(request)
     fav_threads = settings_manager.get_fav_threads()
     fav_thread_ops = Post.objects.filter(id__in=fav_threads.keys())\
         .order_by('-pub_time').prefetch_related('thread')
 
     for op in fav_thread_ops:
         last_read_post = fav_threads[str(op.id)]
         new_posts = op.get_thread().get_replies_newer(last_read_post)
         new_post_count = new_posts.count()
         fav_thread_dict = dict()
         fav_thread_dict['id'] = op.id
         fav_thread_dict['new_post_count'] = new_post_count
 
         if include_posts:
-            fav_thread_dict['post'] = op.get_post_data(
-                format_type=DIFF_TYPE_HTML)
+            fav_thread_dict['post_url'] = op.get_link_view()
+            fav_thread_dict['title'] = op.title
             if new_post_count > 0:
                 fav_thread_dict['newest_post_link'] = new_posts.first()\
                     .get_absolute_url()
 
         posts.append(fav_thread_dict)
 
     return HttpResponse(content=json.dumps(posts))