Truncating thread text in threads list. Fixed tag threads order.

boards/models.py

@@ -1,109 +1,109 b''
 from django.db import models
 from django.utils import timezone
 
 from neboard import settings
 
 import thumbs
 
 NO_PARENT = -1
 NO_IP = '0.0.0.0'
 UNKNOWN_UA = ''
 
 
 class PostManager(models.Manager):
     def create_post(self, title, text, image=None, parent_id=NO_PARENT,
                     ip=NO_IP, tags=None):
         post = self.create(title=title,
                            text=text,
                            pub_time=timezone.now(),
                            parent=parent_id,
                            image=image,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,
                            last_edit_time=timezone.now())
 
         if tags:
             for tag in tags:
                 post.tags.add(tag)
 
         if parent_id != NO_PARENT:
             parent = self.get(id=parent_id)
             parent.last_edit_time=timezone.now()
             parent.save()
 
         return post
 
     def delete_post(self, post):
         children = self.filter(parent=post.id)
         for child in children:
             self.delete_post(child)
         post.delete()
 
     def delete_posts_by_ip(self, ip):
         posts = self.filter(poster_ip=ip)
         for post in posts:
             self.delete_post(post)
 
     def get_threads(self, tag=None):
-        if tag is None:
+        if tag:
+            threads = self.filter(parent=NO_PARENT, tags=tag)
+        else:
             threads = self.filter(parent=NO_PARENT)
-        else:
-            threads = self.filter(parent=NO_PARENT, tag=tag)
         threads = list(threads.order_by('-last_edit_time'))
 
         return threads
 
     def get_thread(self, opening_post_id):
         opening_post = self.get(id=opening_post_id)
         replies = self.filter(parent=opening_post_id)
 
         thread = [opening_post]
         thread.extend(replies)
 
         return thread
 
     def exists(self, post_id):
         posts = self.filter(id=post_id)
 
         return len(posts) > 0
 
 
 class Tag(models.Model):
     """
     A tag is a text node assigned to the post. The tag serves as a board
     section. There can be multiple tags for each message
     """
 
     name = models.CharField(max_length=100)
 
 
 class Post(models.Model):
     """A post is a message."""
 
     objects = PostManager()
 
     title = models.CharField(max_length=100)
     pub_time = models.DateTimeField()
     text = models.TextField()
     image = thumbs.ImageWithThumbsField(upload_to='images/',
                                         blank=True, sizes=((200, 150),))
     poster_ip = models.IPAddressField()
     poster_user_agent = models.TextField()
     parent = models.BigIntegerField()
     tags = models.ManyToManyField(Tag)
     last_edit_time = models.DateTimeField()
 
     def __unicode__(self):
         return self.title + ' (' + self.text + ')'
 
 
 class Admin(models.Model):
     """
     Model for admin users
     """
     name = models.CharField(max_length=100)
     password = models.CharField(max_length=100)
 
     def __unicode__(self):
         return self.name + '/' + '*' * len(self.password)
 

boards/views.py

@@ -1,125 +1,125 b''
 from django.template import RequestContext
 from boards import forms
 import boards
 from boards.forms import NewThreadForm
 from boards.models import Post, Admin, Tag
 from django.shortcuts import render, get_list_or_404, redirect
 from django.http import HttpResponseRedirect, Http404
 
 
 def index(request):
     context = RequestContext(request)
 
     if request.method == 'POST':
         return new_post(request)
     else:
         threads = Post.objects.get_threads()
 
         context['threads'] = None if len(threads) == 0 else threads
         context['form'] = forms.NewThreadForm()
 
         return render(request, 'posting_general.html',
                       context)
 
 
 def new_post(request, thread_id=boards.models.NO_PARENT):
     """Add a new post (in thread or as a reply)."""
 
     form = NewThreadForm(request.POST, request.FILES)
 
     title = request.POST['title']
     text = request.POST['text']
 
     if 'image' in request.FILES.keys():
         image = request.FILES['image']
     else:
         image = None
 
     ip = request.META['REMOTE_ADDR']
 
     tags = []
     if thread_id == boards.models.NO_PARENT:
         tag_strings = request.POST['tags']
 
         if tag_strings:
             tag_strings = tag_strings.split(',')
             for tag_name in tag_strings:
                 tag_name = tag_name.strip()
                 if len(tag_name) > 0:
                     tag, created = Tag.objects.get_or_create(name=tag_name)
                     tags.append(tag)
 
     # TODO Add a possibility to define a link image instead of an image file.
     # If a link is given, download the image automatically.
 
     post = Post.objects.create_post(title=title, text=text, ip=ip,
                                     parent_id=thread_id, image=image,
                                     tags=tags)
 
     thread_to_show = (post.id if thread_id == boards.models.NO_PARENT else
                       thread_id)
     return redirect(thread, post_id=thread_to_show)
 
 
 def tag(request, tag_name):
     """Get all tag threads (posts without a parent)."""
 
     tag = Tag.objects.get(name=tag_name)
-    threads = get_list_or_404(Post, tags=tag)
+    threads = Post.objects.get_threads(tag=tag)
 
     if request.method == 'POST':
         return new_post(request)
     else:
         context = RequestContext(request)
         context['threads'] = None if len(threads) == 0 else threads
         context['tag'] = tag_name
 
         context['form'] = forms.NewThreadForm(initial={'tags': tag_name})
 
         return render(request, 'posting_general.html',
                       context)
 
 
 def thread(request, post_id):
     """Get all thread posts"""
 
     if request.method == 'POST':
         return new_post(request, post_id)
     else:
         # TODO Show 404 if there is no such thread
         posts = Post.objects.get_thread(post_id)
 
         context = RequestContext(request)
         context['posts'] = posts
 
         context['form'] = forms.NewThreadForm()
 
         return render(request, 'thread.html', context)
 
 
 def login(request):
     """Log in as admin"""
 
     if 'name' in request.POST and 'password' in request.POST:
         request.session['admin'] = False
 
         isAdmin = len(Admin.objects.filter(name=request.POST['name'],
                                            password=request.POST[
                                                'password'])) > 0
 
         if isAdmin:
             request.session['admin'] = True
 
             response = HttpResponseRedirect('/')
 
         else:
             response = render(request, 'login.html', {'error': 'Login error'})
     else:
         response = render(request, 'login.html', {})
 
     return response
 
 
 def logout(request):
     request.session['admin'] = False
     return HttpResponseRedirect('/')
  No newline at end of file

templates/posting_general.html

@@ -1,63 +1,63 b''
 {% extends "base.html" %}
 
 {% load i18n %}
 
 {% block content %}
 
 	{% if threads %}
 		{% for thread in threads %}
             {% if thread.image %}
                 <div class="block">
                     <a href="{{ thread.image.url }}"><img
                             src="{{ thread.image.url_200x150 }}" />
                     </a>
                 </div>
             {% endif %}
             <div class="block">
                 <span class="title">{{ thread.title }}</span>
                 <span class="post_id">(#{{ thread.id }})</span>
                 [{{ thread.pub_time }}]
                 <a class="link" href="/thread/{{ thread.id }}/">
                     [{% trans "View" %}]</a><br />
-                {{ thread.text }}<br />
+                {{ thread.text|truncatechars:300 }}<br />
                 {% if thread.tags %}
                     <span class="tags">{% trans 'Tags' %}:
                         {% for tag in thread.tags.all %}
                             <a class="tag" href="/tag/{{ tag.name }}">
                                 {{ tag.name }}</a>
                         {% endfor %}
                     </span>
                 {% endif %}
             </div>
             <hr />
         {% endfor %}
 	{% else %}
 		No threads found.
         <hr />
 	{% endif %}
 
     <div class="post-form">
         <div class="post-form">
             <form enctype="multipart/form-data" method="post">{% csrf_token %}
                 <div class="form-row">
                     <div class="form-input">{% trans 'Title' %}</div>
                     <div class="form-input">{{ form.title }}</div>
                 </div>
                 <div class="form-row">
                     <div class="form-input">{% trans 'Text' %}</div>
                     <div class="form-input">{{ form.text }}</div>
                 </div>
                 <div class="form-row">
                     <div class="form-input">{% trans 'Image' %}</div>
                     <div class="form-input">{{ form.image }}</div>
                 </div>
                 <div class="form-row">
                     <div class="form-input">{% trans 'Tags' %}</div>
                     <div class="form-input">{{ form.tags }}</div>
                 </div>
                 <input type="submit" value="{% trans 'Post' %}" />
             </form>
         </div>
     </div>
 
 {% endblock %}
  No newline at end of file