Fixed medadata design when an image is present. Added a method to determine if the tag is empty (has no attached threads).

boards/forms.py

@@ -1,53 +1,57 b''
 from django import forms
 
 
 class PostForm(forms.Form):
     MAX_TEXT_LENGTH = 10000
     MAX_IMAGE_SIZE = 8 * 1024 * 1024
 
     title = forms.CharField(max_length=50, required=False)
     text = forms.CharField(widget=forms.Textarea, required=False)
     image = forms.ImageField(required=False)
 
     def clean_text(self):
         text = self.cleaned_data['text']
         if text:
             if len(text) > self.MAX_TEXT_LENGTH:
                 raise forms.ValidationError('Too many text')
         return text
 
     def clean_image(self):
         image = self.cleaned_data['image']
         if image:
             if image._size > self.MAX_IMAGE_SIZE:
                 raise forms.ValidationError('Too large image: more than ' +
                                             str(self.MAX_IMAGE_SIZE) + ' bytes')
         return image
 
     def clean(self):
         cleaned_data = super(PostForm, self).clean()
 
         text = cleaned_data.get('text')
         image = cleaned_data.get('image')
 
         if (not text) and (not image):
             raise forms.ValidationError('Enter either text or image')
 
         return cleaned_data
 
 
 class ThreadForm(PostForm):
+    INVALID_TAG_CHARACTERS = ['+', '/', '&', '=', '?']
+
     tags = forms.CharField(max_length=100)
 
     def clean_tags(self):
         tags = self.cleaned_data['tags']
         if tags:
-            if ('+' in tags) or ('/' in tags):
-                raise forms.ValidationError('Inappropriate characters in tags')
+            for character in tags:
+                if character in self.INVALID_TAG_CHARACTERS:
+                    raise forms.ValidationError(
+                        'Inappropriate characters in tags')
 
         return tags
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
  No newline at end of file

boards/models.py

@@ -1,190 +1,208 b''
 import os
 import re
 from django.db import models
 from django.utils import timezone
 import time
 
 from neboard import settings
 
 import thumbs
 
 NO_PARENT = -1
 NO_IP = '0.0.0.0'
 UNKNOWN_UA = ''
 
 
 def update_image_filename(instance, filename):
     """Get unique image filename"""
 
     path = 'images/'
     new_name = str(int(time.mktime(time.gmtime()))) + '_' + filename
     return os.path.join(path, new_name)
 
 
 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()
         else:
             self._delete_old_threads()
 
         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:
             threads = self.filter(parent=NO_PARENT, tags=tag)
         else:
             threads = self.filter(parent=NO_PARENT)
         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)
+
+        if opening_post.parent == NO_PARENT:
+            replies = self.filter(parent=opening_post_id)
 
-        thread = [opening_post]
-        thread.extend(replies)
+            thread = [opening_post]
+            thread.extend(replies)
 
-        return thread
+            return thread
 
     def exists(self, post_id):
         posts = self.filter(id=post_id)
 
         return len(posts) > 0
 
     def _delete_old_threads(self):
         """
         Preserves maximum thread count. If there are too many threads,
         delete the old ones.
         """
 
         # TODO Try to find a better way to get the active thread count.
 
         # TODO Move old threads to the archive instead of deleting them.
         # Maybe make some 'old' field in the model to indicate the thread
         # must not be shown and be able for replying.
 
         threads = self.get_threads()
         thread_count = len(threads)
 
         if thread_count > settings.MAX_THREAD_COUNT:
             num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
             old_threads = threads[-num_threads_to_delete:]
 
             for thread in old_threads:
                 self.delete_post(thread)
 
 
+class TagManager(models.Manager):
+    def get_not_empty_tags(self):
+        all_tags = self.all()
+        tags = []
+        for tag in all_tags:
+            if not tag.is_empty():
+                tags.append(tag)
+
+        return tags
+
+
 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
     """
 
+    objects = TagManager()
+
     name = models.CharField(max_length=100)
     # TODO Connect the tag to its posts to check the number of threads for
     # the tag.
 
     def __unicode__(self):
         return self.name
 
     def is_empty(self):
+        return self.get_post_count() == 0
+
+    def get_post_count(self):
         posts_with_tag = Post.objects.get_threads(tag=self)
-        return len(posts_with_tag) == 0
+        return len(posts_with_tag)
 
 
 class Post(models.Model):
     """A post is a message."""
 
     objects = PostManager()
 
     title = models.CharField(max_length=50)
     pub_time = models.DateTimeField()
     text = models.TextField()
     image = thumbs.ImageWithThumbsField(upload_to=update_image_filename,
                                         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 + ')'
 
     def _get_replies(self):
         return Post.objects.filter(parent=self.id)
 
     def get_reply_count(self):
         return len(self._get_replies())
 
     def get_images_count(self):
         images_count = 1 if self.image else 0
         for reply in self._get_replies():
             if reply.image:
                 images_count += 1
 
         return images_count
 
     def get_gets_count(self):
         gets_count = 1 if self.is_get() else 0
         for reply in self._get_replies():
             if reply.is_get():
                 gets_count += 1
 
         return gets_count
 
     def is_get(self):
         """If the post has pretty id (1, 1000, 77777), than it is called GET"""
 
         # TODO Make a better algorithm for describing gets
         return self.id == 1 or self.id % 10 == 0
 
     def get_parsed_text(self):
         text = self.text
 
         # TODO Implement parsing
         # Make //text colored
         # Make >>12 links to posts
 
         return 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/static/css/base_page.css

@@ -1,79 +1,86 b''
 html {
     background: #555;
     color: #ffffff;
 }
 
 #admin_panel {
     background: #FF0000;
     color: #00FF00
 }
 
 .title {
     font-weight: bold;
     color: #ffcc00;
 }
 
 .post-form {
     text-align: left;
     display: table;
     border-radius: 5px;
     padding: 5px;
     margin: 5px;
     background: #334;
 }
 
 .form-row {
     display: table-row;
 }
 
 .form-input {
     display: table-cell;
 }
 
 .link {
     color: #afdcec;
 }
 
 .link:hover {
     color: #fff380;
 }
 
 .post_id {
     color: #ffffff;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .tag {
     color: #b4cfec;
 }
 
 .tag:hover {
     color: #d0edb4;
 }
 
 .post_id {
     color: #fff380;
 }
 
 .post {
     background: #333;
     margin: 5px;
     padding: 10px;
     border-radius: 5px;
 }
 
 .form-title {
     font-weight: bolder;
 }
 
 .metadata {
     padding: 2px;
     margin-top: 10px;
     border: solid 1px #666;
     font-size: 0.9em;
     color: #ddd
+}
+
+#navigation_panel {
+    background: #444;
+    margin: 5px;
+    padding: 10px;
+    border-radius: 5px;
 }
  No newline at end of file

boards/views.py

@@ -1,133 +1,136 b''
 from django.template import RequestContext
 from boards import forms
 import boards
 from boards.forms import ThreadForm, PostForm
 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.ThreadForm()
+        context['tags'] = Tag.objects.get_not_empty_tags()
 
         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)."""
 
     if thread_id == boards.models.NO_PARENT:
         form = ThreadForm(request.POST, request.FILES)
     else:
         form = PostForm(request.POST, request.FILES)
 
     if form.is_valid():
         data = form.cleaned_data
     else:
         return redirect(index)
 
     title = data['title']
     text = data['text']
 
     if 'image' in data.keys():
         image = data['image']
     else:
         image = None
 
     ip = request.META['REMOTE_ADDR']
 
     tags = []
     if thread_id == boards.models.NO_PARENT:
         tag_strings = data['tags']
 
         if tag_strings:
-            tag_strings = tag_strings.split(' ')
+            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 = 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['tags'] = Tag.objects.get_not_empty_tags()
 
         context['form'] = forms.ThreadForm(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.PostForm()
+        context['tags'] = Tag.objects.get_not_empty_tags()
 
         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

locale/ru/LC_MESSAGES/django.po

@@ -1,60 +1,72 b''
 # SOME DESCRIPTIVE TITLE.
 # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
 # This file is distributed under the same license as the PACKAGE package.
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2013-04-11 21:26+0300\n"
+"POT-Creation-Date: 2013-04-13 22:07+0300\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
 "Language: ru\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
 "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
 
-#: templates/posting_general.html:22
+#: templates/base.html:22
+msgid "All threads"
+msgstr "Все ники"
+
+#: templates/posting_general.html:26
 msgid "View"
 msgstr "Просмотр"
 
-#: templates/posting_general.html:25
+#: templates/posting_general.html:31
 msgid "replies"
 msgstr "ответов"
 
-#: templates/posting_general.html:26
+#: templates/posting_general.html:32
 msgid "images"
 msgstr "изображений"
 
-#: templates/posting_general.html:29 templates/posting_general.html.py:61
-#: templates/thread.html:23
+#: templates/posting_general.html:33
+msgid "gets"
+msgstr "геты"
+
+#: templates/posting_general.html:35 templates/posting_general.html.py:67
+#: templates/thread.html:31
 msgid "Tags"
 msgstr "Теги"
 
-#: templates/posting_general.html:46
+#: templates/posting_general.html:52
 msgid "Create new thread"
-msgstr "Создать новый тред"
+msgstr "Создать новую нить"
 
-#: templates/posting_general.html:49 templates/thread.html:42
+#: templates/posting_general.html:55 templates/thread.html:50
 msgid "Title"
 msgstr "Заголовок"
 
-#: templates/posting_general.html:53 templates/thread.html:46
+#: templates/posting_general.html:59 templates/thread.html:54
 msgid "Text"
 msgstr "Текст"
 
-#: templates/posting_general.html:57 templates/thread.html:50
+#: templates/posting_general.html:63 templates/thread.html:58
 msgid "Image"
 msgstr "Картинка"
 
-#: templates/posting_general.html:64 templates/thread.html:53
+#: templates/posting_general.html:70 templates/thread.html:61
 msgid "Post"
 msgstr "Отправить"
 
-#: templates/thread.html:39
+#: templates/posting_general.html:72
+msgid "Tags must be delimited by spaces. Text or image is required."
+msgstr "Теги должны быть разделены пробелами. Текст или изображение обязательны."
+
+#: templates/thread.html:47
 msgid "Reply to the thread"
-msgstr "Ответить в тред"
+msgstr "Ответить в нить"

templates/base.html

@@ -1,23 +1,32 b''
 {% load staticfiles %}
+{% load i18n %}
 
 <!DOCTYPE html>
 <html>
 <head>
     <link rel="stylesheet" type="text/css"
           href="{% static "css/base_page.css" %}" media="all"/>
     {% block head %}{% endblock %}
 </head>
 <body>
 <div id="admin_panel">
 
     {% if request.session.admin == True %}
         Admin panel TODO: Need to implement <BR />
     {% endif %}
 
 
 </div>
 
+<div id="navigation_panel">
+    <a class="link" href="{% url 'index' %}">{% trans "All threads" %}</a>
+    {% for tag in tags %}
+        <a class="tag" href=" {% url 'tag' tag_name=tag.name %}">
+            {{ tag.name }}</a>({{ tag.get_post_count }})
+    {% endfor %}
+</div>
+
 {% block content %}{% endblock %}
 
 </body>
 </html>
  No newline at end of file

templates/posting_general.html

@@ -1,72 +1,76 b''
 {% extends "base.html" %}
 
 {% load i18n %}
 
+{% block head %}
+    <title>Neboard</title>
+{% endblock %}
+
 {% block content %}
 
 	{% if threads %}
 		{% for thread in threads %}
             <div class="post">
             {% 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="{% url 'thread' thread.id %}"
                     >{% trans "View" %}</a>]<br />
                 {{ thread.get_parsed_text|linebreaksbr|truncatechars:300 }}<br
                     />
             </div>
                 <div class="metadata">
                     {{ thread.get_reply_count }} {% trans 'replies' %},
                     {{ thread.get_images_count }} {% trans 'images' %},
                     {{ thread.get_gets_count }} {% trans 'gets' %}.
                     {% if thread.tags.all %}
                         <span class="tags">{% trans 'Tags' %}:
                             {% for tag in thread.tags.all %}
                                 <a class="tag" href="
                                 {% url 'tag' tag_name=tag.name %}">
                                     {{ tag.name }}</a>
                             {% endfor %}
                         </span>
                     {% endif %}
                 </div>
             </div>
         {% endfor %}
 	{% else %}
 		No threads found.
         <hr />
 	{% endif %}
 
     <div class="post-form">
         <span class="form-title">{% trans "Create new thread" %}</span>
         <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' %}" />
             <hr />
             {% trans "Tags must be delimited by spaces. Text or image is required." %}
         </form>
     </div>
 
 {% endblock %}
  No newline at end of file

templates/thread.html

@@ -1,61 +1,65 b''
 {% extends "base.html" %}
 
 {% load i18n %}
 
+{% block head %}
+    <title>Neboard</title>
+{% endblock %}
+
 {% block content %}
 
 	{% if posts %}
 		{% for post in posts %}
             <a name="{{ post.id }}"></a>
             <div class="post">
             {% if post.image %}
                 <div class="block">
                     <a href="{{ post.image.url }}"><img
                         src="{{ post.image.url_200x150 }}" />
                     </a>
                 </div>
             {% endif %}
             <div class="block">
                 <span class="title">{{ post.title }}</span>
                 <a class="post_id" href="#{{ post.id }}">
                     (#{{ post.id }})</a>
                 [{{ post.pub_time }}]<br />
                 {{ post.get_parsed_text|linebreaksbr }}<br />
             </div>
             {% if post.tags.all %}
                 <div class="metadata">
                     <span class="tags">{% trans 'Tags' %}:
                         {% for tag in post.tags.all %}
                             <a class="tag" href="{% url 'tag' tag.name %}">
                                 {{ tag.name }}</a>
                         {% endfor %}
                     </span>
                 </div>
             {% endif %}
             </div>
 		{% endfor %}
 	{% else %}
 		No threads found.
         <hr />
 	{% endif %}
 
     <div class="post-form">
         <span class="form-title">{% trans "Reply to the thread" %}</span>
         <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>
             <input type="submit" value="{% trans 'Post' %}" />
         </form>
     </div>
 
 {% endblock %}
  No newline at end of file