Fixed some tests and views. Added migration for admin model removal.

boards/migrations/0004_auto__del_admin__add_user__add_setting__add_field_post_user.py

@@ -0,0 +1,130 b''
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Deleting model 'Admin'
+        db.delete_table(u'boards_admin')
+
+        # Adding model 'User'
+        db.create_table(u'boards_user', (
+            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('user_id', self.gf('django.db.models.fields.CharField')(max_length=50)),
+            ('rank', self.gf('django.db.models.fields.IntegerField')()),
+            ('registration_time', self.gf('django.db.models.fields.DateTimeField')()),
+            ('last_access_time', self.gf('django.db.models.fields.DateTimeField')()),
+        ))
+        db.send_create_signal(u'boards', ['User'])
+
+        # Adding M2M table for field fav_tags on 'User'
+        m2m_table_name = db.shorten_name(u'boards_user_fav_tags')
+        db.create_table(m2m_table_name, (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('user', models.ForeignKey(orm[u'boards.user'], null=False)),
+            ('tag', models.ForeignKey(orm[u'boards.tag'], null=False))
+        ))
+        db.create_unique(m2m_table_name, ['user_id', 'tag_id'])
+
+        # Adding M2M table for field fav_threads on 'User'
+        m2m_table_name = db.shorten_name(u'boards_user_fav_threads')
+        db.create_table(m2m_table_name, (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('user', models.ForeignKey(orm[u'boards.user'], null=False)),
+            ('post', models.ForeignKey(orm[u'boards.post'], null=False))
+        ))
+        db.create_unique(m2m_table_name, ['user_id', 'post_id'])
+
+        # Adding model 'Setting'
+        db.create_table(u'boards_setting', (
+            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('name', self.gf('django.db.models.fields.CharField')(max_length=50)),
+            ('value', self.gf('django.db.models.fields.CharField')(max_length=50)),
+            ('user', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['boards.User'])),
+        ))
+        db.send_create_signal(u'boards', ['Setting'])
+
+        # Adding field 'Post.user'
+        db.add_column(u'boards_post', 'user',
+                      self.gf('django.db.models.fields.related.ForeignKey')(default=None, to=orm['boards.User'], null=True),
+                      keep_default=False)
+
+
+    def backwards(self, orm):
+        # Adding model 'Admin'
+        db.create_table(u'boards_admin', (
+            ('password', self.gf('django.db.models.fields.CharField')(max_length=100)),
+            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('name', self.gf('django.db.models.fields.CharField')(max_length=100)),
+        ))
+        db.send_create_signal(u'boards', ['Admin'])
+
+        # Deleting model 'User'
+        db.delete_table(u'boards_user')
+
+        # Removing M2M table for field fav_tags on 'User'
+        db.delete_table(db.shorten_name(u'boards_user_fav_tags'))
+
+        # Removing M2M table for field fav_threads on 'User'
+        db.delete_table(db.shorten_name(u'boards_user_fav_threads'))
+
+        # Deleting model 'Setting'
+        db.delete_table(u'boards_setting')
+
+        # Deleting field 'Post.user'
+        db.delete_column(u'boards_post', 'user_id')
+
+
+    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', [], {}),
+            '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', [], {'to': u"orm['boards.Tag']", 'symmetrical': 'False'}),
+            'fav_threads': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'+'", '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/tests.py

@@ -1,183 +1,177 b''
 # coding=utf-8
 from django.utils.unittest import TestCase
 from django.test.client import Client
 
 import boards
 
-from boards.models import Post, Admin, Tag
+from boards.models import Post, Tag
 from neboard import settings
 
 TEST_TEXT = 'test text'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 THREAD_PAGE = '/thread/'
 TAG_PAGE = '/tag/'
 HTTP_CODE_REDIRECT = 302
 HTTP_CODE_OK = 200
 HTTP_CODE_NOT_FOUND = 404
 
 
 class BoardTests(TestCase):
     def _create_post(self):
         return Post.objects.create_post(title='title',
                                         text='text')
 
     def test_post_add(self):
         post = self._create_post()
 
         self.assertIsNotNone(post)
         self.assertEqual(boards.models.NO_PARENT, post.parent)
 
     def test_delete_post(self):
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_post(post)
 
         self.assertFalse(Post.objects.exists(post_id))
 
     def test_delete_posts_by_ip(self):
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_posts_by_ip('0.0.0.0')
 
         self.assertFalse(Post.objects.exists(post_id))
 
     # Authentication tests
 
     def _create_test_user(self):
         admin = Admin(name='test_username12313584353165',
                       password='test_userpassword135135512')
 
         admin.save()
         return admin
 
     def test_get_thread(self):
         opening_post = self._create_post()
         op_id = opening_post.id
 
         for i in range(0, 2):
             Post.objects.create_post('title', 'text',
                                      parent_id=op_id)
 
         thread = Post.objects.get_thread(op_id)
 
         self.assertEqual(3, len(thread))
 
     def test_create_post_with_tag(self):
         tag = Tag.objects.create(name='test_tag')
         post = Post.objects.create_post(title='title', text='text', tags=[tag])
         self.assertIsNotNone(post)
 
     def test_thread_max_count(self):
         for i in range(settings.MAX_THREAD_COUNT + 1):
             self._create_post()
 
         self.assertEqual(settings.MAX_THREAD_COUNT,
                          len(Post.objects.get_threads()))
 
-    def test_get(self):
-        """Test if the get computes properly"""
-
-        post = self._create_post()
-
-        self.assertTrue(post.is_get())
-
     def test_pages(self):
         """Test that the thread list is properly split into pages"""
 
         for i in range(settings.MAX_THREAD_COUNT):
             self._create_post()
 
         all_threads = Post.objects.get_threads()
 
         posts_in_second_page = Post.objects.get_threads(page=1)
         first_post = posts_in_second_page[0]
 
         self.assertEqual(all_threads[settings.THREADS_PER_PAGE].id,
                          first_post.id)
 
     def test_post_validation(self):
         """Test the validation of the post form"""
 
         # Disable captcha for the test
         captcha_enabled = settings.ENABLE_CAPTCHA
         settings.ENABLE_CAPTCHA = False
 
         Post.objects.all().delete()
 
         client = Client()
 
         valid_tags = u'tag1 tag_2 тег_3'
         invalid_tags = u'$%_356 ---'
 
         response = client.post(NEW_THREAD_PAGE, {'title': 'test title',
                                                  'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(response.status_code, HTTP_CODE_REDIRECT,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(1, Post.objects.count(),
                          msg='No posts were created')
 
         client.post(NEW_THREAD_PAGE, {'text': TEST_TEXT,
                                       'tags': invalid_tags})
         self.assertEqual(1, Post.objects.count(), msg='The validation passed '
                                                       'where it should fail')
 
         response = client.post(THREAD_PAGE_ONE, {'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(HTTP_CODE_REDIRECT, response.status_code,
                          msg=u'Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(2, Post.objects.count(),
                          msg=u'No posts were created')
 
         # Restore captcha setting
         settings.ENABLE_CAPTCHA = captcha_enabled
 
     def test_404(self):
         """Test receiving error 404 when opening a non-existent page"""
 
         Post.objects.all().delete()
         Tag.objects.all().delete()
 
         tag_name = u'test_tag'
         tags, = [Tag.objects.get_or_create(name=tag_name)]
         client = Client()
 
         Post.objects.create_post('title', TEST_TEXT, tags=tags)
 
         existing_post_id = Post.objects.all()[0].id
         response_existing = client.get(THREAD_PAGE + str(existing_post_id) +
                                        '/')
         self.assertEqual(HTTP_CODE_OK, response_existing.status_code,
                          u'Cannot open existing thread')
 
         response_not_existing = client.get(THREAD_PAGE + str(
             existing_post_id + 1) + '/')
+        response_not_existing.get_full_path()
         self.assertEqual(HTTP_CODE_NOT_FOUND,
                          response_not_existing.status_code,
                          u'Not existing thread is opened')
 
         response_existing = client.get(TAG_PAGE + tag_name + '/')
         self.assertEqual(HTTP_CODE_OK,
                          response_existing.status_code,
                          u'Cannot open existing tag')
 
         response_not_existing = client.get(TAG_PAGE + u'not_tag' + '/')
         self.assertEqual(HTTP_CODE_NOT_FOUND,
                          response_not_existing.status_code,
                          u'Not existing tag is opened')
 
         reply_id = Post.objects.create_post('', TEST_TEXT,
                                             parent_id=existing_post_id)
         response_not_existing = client.get(THREAD_PAGE + str(
             reply_id) + '/')
         self.assertEqual(HTTP_CODE_NOT_FOUND,
                          response_not_existing.status_code,
                          u'Not existing thread is opened')

boards/views.py

@@ -1,305 +1,307 b''
 import hashlib
 from django.core.urlresolvers import reverse
 from django.template import RequestContext
 from django.shortcuts import render, redirect, get_object_or_404
 from django.http import HttpResponseRedirect
 from django.utils import timezone
 
 from boards import forms
 import boards
 from boards import utils
 from boards.forms import ThreadForm, PostForm, SettingsForm, PlainErrorList, \
     ThreadCaptchaForm, PostCaptchaForm
 
-from boards.models import Post, Admin, Tag, Ban, User, RANK_USER, RANK_MODERATOR, NO_PARENT
+from boards.models import Post, Tag, Ban, User, RANK_USER, RANK_MODERATOR, NO_PARENT
 from boards import authors
 import neboard
 
 
 def index(request, page=0):
     context = _init_default_context(request)
 
     if utils.need_include_captcha(request):
         threadFormClass = ThreadCaptchaForm
         kwargs = {'request': request}
     else:
         threadFormClass = ThreadForm
         kwargs = {}
 
     if request.method == 'POST':
         form = threadFormClass(request.POST, request.FILES,
                                error_class=PlainErrorList, **kwargs)
 
         if form.is_valid():
             return _new_post(request, form)
     else:
         form = threadFormClass(error_class=PlainErrorList, **kwargs)
 
     threads = Post.objects.get_threads(page=int(page))
 
     context['threads'] = None if len(threads) == 0 else threads
     context['form'] = form
     context['pages'] = range(Post.objects.get_thread_page_count())
 
     return render(request, 'boards/posting_general.html',
                   context)
 
 
 def _new_post(request, form, thread_id=boards.models.NO_PARENT):
     """Add a new post (in thread or as a reply)."""
 
     ip = _get_client_ip(request)
     is_banned = Ban.objects.filter(ip=ip).count() > 0
 
     if is_banned:
         return redirect(you_are_banned)
 
     data = form.cleaned_data
 
     title = data['title']
     text = data['text']
 
     if 'image' in data.keys():
         image = data['image']
     else:
         image = None
 
     tags = []
 
     new_thread = thread_id == boards.models.NO_PARENT
     if new_thread:
         tag_strings = data['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 new_thread else thread_id)
 
     if new_thread:
         return redirect(thread, post_id=thread_to_show)
     else:
         return redirect(reverse(thread,
                                 kwargs={'post_id': thread_to_show}) + '#'
                         + str(post.id))
 
 
 def tag(request, tag_name, page=0):
     """Get all tag threads (posts without a parent)."""
 
     tag = get_object_or_404(Tag, name=tag_name)
     threads = Post.objects.get_threads(tag=tag, page=int(page))
 
     if request.method == 'POST':
         form = ThreadForm(request.POST, request.FILES,
                           error_class=PlainErrorList)
         if form.is_valid():
             return _new_post(request, form)
     else:
         form = forms.ThreadForm(initial={'tags': tag_name},
                                 error_class=PlainErrorList)
 
     context = _init_default_context(request)
     context['threads'] = None if len(threads) == 0 else threads
     context['tag'] = tag_name
     context['pages'] = range(Post.objects.get_thread_page_count(tag=tag))
 
     context['form'] = form
 
     return render(request, 'boards/posting_general.html',
                   context)
 
 
 def thread(request, post_id):
     """Get all thread posts"""
 
     if utils.need_include_captcha(request):
         postFormClass = PostCaptchaForm
         kwargs = {'request': request}
     else:
         postFormClass = PostForm
         kwargs = {}
 
     if request.method == 'POST':
         form = postFormClass(request.POST, request.FILES,
                              error_class=PlainErrorList, **kwargs)
         if form.is_valid():
             return _new_post(request, form, post_id)
     else:
         form = postFormClass(error_class=PlainErrorList, **kwargs)
 
     posts = Post.objects.get_thread(post_id)
 
     context = _init_default_context(request)
 
     context['posts'] = posts
     context['form'] = form
 
     return render(request, 'boards/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, 'boards/login.html', {'error': 'Login error'})
     else:
         response = render(request, 'boards/login.html', {})
 
     return response
 
 
 def logout(request):
     request.session['admin'] = False
     return HttpResponseRedirect('/')
 
 
 def settings(request):
     """User's settings"""
 
     context = _init_default_context(request)
 
     if request.method == 'POST':
         form = SettingsForm(request.POST)
         if form.is_valid():
             selected_theme = form.cleaned_data['theme']
 
             user = _get_user(request)
             user.save_setting('theme', selected_theme)
 
         return redirect(settings)
     else:
         selected_theme = _get_theme(request)
         form = SettingsForm(initial={'theme': selected_theme})
         context['form'] = form
 
         return render(request, 'boards/settings.html', context)
 
 
 def all_tags(request):
     """All tags list"""
 
     context = _init_default_context(request)
     context['all_tags'] = Tag.objects.get_not_empty_tags()
 
     return render(request, 'boards/tags.html', context)
 
 
 def jump_to_post(request, post_id):
     """Determine thread in which the requested post is and open it's page"""
 
     post = get_object_or_404(Post, id=post_id)
 
     if boards.models.NO_PARENT == post.parent:
         return redirect(thread, post_id=post.id)
     else:
         parent_thread = get_object_or_404(Post, id=post.parent)
         return redirect(reverse(thread, kwargs={'post_id': parent_thread.id})
                         + '#' + str(post.id))
 
 
 def authors(request):
     context = _init_default_context(request)
     context['authors'] = boards.authors.authors
 
     return render(request, 'boards/authors.html', context)
 
 
 def delete(request, post_id):
     user = _get_user(request)
     post = get_object_or_404(Post, id=post_id)
 
     if user.is_moderator():
         Post.objects.delete_post(post)
     
     if NO_PARENT == post.parent:
         return redirect(index)
     else:
         return redirect(thread, post_id=post.parent)
 
 def you_are_banned(request):
     context = _init_default_context(request)
     return render(request, 'boards/banned.html', context)
 
 
 def page_404(request):
     context = _init_default_context(request)
     return render(request, 'boards/404.html', context)
 
 
 def _get_theme(request):
     """Get user's CSS theme"""
 
     user = _get_user(request)
     theme = user.get_setting('theme')
     if not theme:
         theme = neboard.settings.DEFAULT_THEME
 
     return theme
 
 
 def _get_client_ip(request):
     x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
     if x_forwarded_for:
         ip = x_forwarded_for.split(',')[-1].strip()
     else:
         ip = request.META.get('REMOTE_ADDR')
     return ip
 
 
 def _init_default_context(request):
     """Create context with default values that are used in most views"""
 
     context = RequestContext(request)
     context['tags'] = Tag.objects.get_popular_tags()
     context['theme'] = _get_theme(request)
     context['user'] = _get_user(request)
 
     return context
 
 
 def _get_user(request):
     """Get current user from the session"""
 
     session = request.session
     if not 'user_id' in session:
         request.session.save()
 
         md5 = hashlib.md5()
         md5.update(session.session_key)
         new_id = md5.hexdigest()
 
+        time_now = timezone.now()
         user = User.objects.create(user_id=new_id, rank=RANK_USER,
-                                   registration_time=timezone.now())
+                                   registration_time=time_now,
+                                   last_access_time=time_now)
 
         session['user_id'] = user.id
     else:
         user = User.objects.get(id=session['user_id'])
         user.save()
 
     user.last_access_time = timezone.now()
 
     return user