Moved some settings to boards.settings

boards/admin.py

@@ -1,23 +1,25 b''
 from django.contrib import admin
 from boards.models import Post, Tag, User, Ban
 
+
 class PostAdmin(admin.ModelAdmin):
 
     list_display = ('id', 'title', 'text')
     list_filter = ('pub_time', 'tags')
     search_fields = ('id', 'title', 'text')
 
+
 class TagAdmin(admin.ModelAdmin):
 
     list_display = ('name', 'linked')
     list_filter = ('linked',)
 
 
 class UserAdmin(admin.ModelAdmin):
 
     list_display = ('user_id', 'rank')
 
 admin.site.register(Post, PostAdmin)
 admin.site.register(Tag, TagAdmin)
 admin.site.register(User, UserAdmin)
 admin.site.register(Ban)

boards/forms.py

@@ -1,254 +1,252 b''
 import re
 from captcha.fields import CaptchaField
 from django import forms
 from django.forms.util import ErrorList
 from django.utils.translation import ugettext_lazy as _
 import time
 from boards.models import TITLE_MAX_LENGTH, User
 from neboard import settings
 from boards import utils
+import boards.settings as board_settings
 
 LAST_POST_TIME = "last_post_time"
 LAST_LOGIN_TIME = "last_login_time"
 
-LOGIN_DELAY = 60 * 60
-
-MAX_TEXT_LENGTH = 30000
-MAX_IMAGE_SIZE = 8 * 1024 * 1024
-
 
 class PlainErrorList(ErrorList):
     def __unicode__(self):
         return self.as_text()
 
     def as_text(self):
         return ''.join([u'(!) %s ' % e for e in self])
 
 
 class NeboardForm(forms.Form):
 
     def as_p(self):
         "Returns this form rendered as HTML <p>s."
         return self._html_output(
             normal_row='<div class="form-row">'
                        '<div class="form-label">'
                        '%(label)s'
                        '</div>'
                        '<div class="form-input">'
                        '%(field)s'
                        '</div>'
                        '%(help_text)s'
                        '</div>',
             error_row='<div class="form-errors">%s</div>',
             row_ender='</p>',
             help_text_html=' <span class="helptext">%s</span>',
             errors_on_separate_row=True)
 
 
 class PostForm(NeboardForm):
 
     title = forms.CharField(max_length=TITLE_MAX_LENGTH, required=False,
                             label=_('Title'))
     text = forms.CharField(widget=forms.Textarea, required=False,
                            label=_('Text'))
     image = forms.ImageField(required=False, label=_('Image'))
 
     # This field is for spam prevention only
     email = forms.CharField(max_length=100, required=False, label=_('e-mail'),
                             widget=forms.TextInput(attrs={
                                 'class': 'form-email'}))
 
     session = None
     need_to_ban = False
 
     def clean_title(self):
         title = self.cleaned_data['title']
         if title:
             if len(title) > TITLE_MAX_LENGTH:
                 raise forms.ValidationError(_('Title must have less than %s '
                                               'characters') %
                                             str(TITLE_MAX_LENGTH))
         return title
 
     def clean_text(self):
         text = self.cleaned_data['text']
         if text:
-            if len(text) > MAX_TEXT_LENGTH:
+            if len(text) > board_settings.MAX_TEXT_LENGTH:
                 raise forms.ValidationError(_('Text must have less than %s '
                                               'characters') %
-                                            str(MAX_TEXT_LENGTH))
+                                            str(board_settings
+                                            .MAX_TEXT_LENGTH))
         return text
 
     def clean_image(self):
         image = self.cleaned_data['image']
         if image:
-            if image._size > MAX_IMAGE_SIZE:
-                raise forms.ValidationError(_('Image must be less than %s '
-                                              'bytes') % str(MAX_IMAGE_SIZE))
+            if image._size > board_settings.MAX_IMAGE_SIZE:
+                raise forms.ValidationError(
+                    _('Image must be less than %s bytes')
+                    % str(board_settings.MAX_IMAGE_SIZE))
         return image
 
     def clean(self):
         cleaned_data = super(PostForm, self).clean()
 
         if not self.session:
             raise forms.ValidationError('Humans have sessions')
 
         if cleaned_data['email']:
             self.need_to_ban = True
             raise forms.ValidationError('A human cannot enter a hidden field')
 
         if not self.errors:
             self._clean_text_image()
 
         if not self.errors and self.session:
             self._validate_posting_speed()
 
         return cleaned_data
 
     def _clean_text_image(self):
         text = self.cleaned_data.get('text')
         image = self.cleaned_data.get('image')
 
         if (not text) and (not image):
             error_message = _('Either text or image must be entered.')
             self._errors['text'] = self.error_class([error_message])
 
     def _validate_posting_speed(self):
         can_post = True
 
         if LAST_POST_TIME in self.session:
             now = time.time()
             last_post_time = self.session[LAST_POST_TIME]
 
             current_delay = int(now - last_post_time)
 
             if current_delay < settings.POSTING_DELAY:
                 error_message = _('Wait %s seconds after last posting') % str(
                     settings.POSTING_DELAY - current_delay)
                 self._errors['text'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_POST_TIME] = time.time()
 
 
 class ThreadForm(PostForm):
 
     regex_tags = re.compile(ur'^[\w\s\d]+$', re.UNICODE)
 
     tags = forms.CharField(max_length=100, label=_('Tags'))
 
     def clean_tags(self):
         tags = self.cleaned_data['tags']
 
         if tags:
             if not self.regex_tags.match(tags):
                 raise forms.ValidationError(
                     _('Inappropriate characters in tags.'))
 
         return tags
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
 
 class PostCaptchaForm(PostForm):
     captcha = CaptchaField()
 
     def __init__(self, *args, **kwargs):
         self.request = kwargs['request']
         del kwargs['request']
 
         super(PostCaptchaForm, self).__init__(*args, **kwargs)
 
     def clean(self):
         cleaned_data = super(PostCaptchaForm, self).clean()
 
         success = self.is_valid()
         utils.update_captcha_access(self.request, success)
 
         if success:
             return cleaned_data
         else:
             raise forms.ValidationError(_("Captcha validation failed"))
 
 
 class ThreadCaptchaForm(ThreadForm):
     captcha = CaptchaField()
 
     def __init__(self, *args, **kwargs):
         self.request = kwargs['request']
         del kwargs['request']
 
         super(ThreadCaptchaForm, self).__init__(*args, **kwargs)
 
     def clean(self):
         cleaned_data = super(ThreadCaptchaForm, self).clean()
 
         success = self.is_valid()
         utils.update_captcha_access(self.request, success)
 
         if success:
             return cleaned_data
         else:
             raise forms.ValidationError(_("Captcha validation failed"))
 
 
 class SettingsForm(NeboardForm):
 
     theme = forms.ChoiceField(choices=settings.THEMES,
                               label=_('Theme'))
 
 
 class ModeratorSettingsForm(SettingsForm):
 
     moderate = forms.BooleanField(required=False, label=_('Enable moderation '
                                                           'panel'))
 
 
 class LoginForm(NeboardForm):
 
     user_id = forms.CharField()
 
     session = None
 
     def clean_user_id(self):
         user_id = self.cleaned_data['user_id']
         if user_id:
             users = User.objects.filter(user_id=user_id)
             if len(users) == 0:
                 raise forms.ValidationError(_('No such user found'))
 
         return user_id
 
     def _validate_login_speed(self):
         can_post = True
 
         if LAST_LOGIN_TIME in self.session:
             now = time.time()
             last_login_time = self.session[LAST_LOGIN_TIME]
 
             current_delay = int(now - last_login_time)
 
-            if current_delay < LOGIN_DELAY:
+            if current_delay < board_settings.LOGIN_TIMEOUT:
                 error_message = _('Wait %s minutes after last login') % str(
-                    (LOGIN_DELAY - current_delay) / 60)
+                    (board_settings.LOGIN_TIMEOUT - current_delay) / 60)
                 self._errors['user_id'] = self.error_class([error_message])
 
                 can_post = False
 
         if can_post:
             self.session[LAST_LOGIN_TIME] = time.time()
 
     def clean(self):
         if not self.session:
             raise forms.ValidationError('Humans have sessions')
 
         self._validate_login_speed()
 
         cleaned_data = super(LoginForm, self).clean()
 
         return cleaned_data

boards/profiler.py

@@ -1,23 +1,23 b''
 import sys
-import cProfile
 from cStringIO import StringIO
 from django.conf import settings
-import  line_profiler
+import line_profiler
+
 
 class ProfilerMiddleware(object):
     def process_view(self, request, callback, callback_args, callback_kwargs):
         if settings.DEBUG and 'prof' in request.GET:
             self.profiler = line_profiler.LineProfiler()
             self.profiler.add_function(callback)
             self.profiler.enable()
             args = (request,) + callback_args
             return callback(*args, **callback_kwargs)
 
     def process_response(self, request, response):
         if settings.DEBUG and 'prof' in request.GET:
             out = StringIO()
             old_stdout, sys.stdout = sys.stdout, out
             self.profiler.print_stats()
             sys.stdout = old_stdout
             response.content = '<pre>%s</pre>' % out.getvalue()
         return response

boards/rss.py

@@ -1,78 +1,79 b''
 from django.contrib.syndication.views import Feed
 from django.core.urlresolvers import reverse
 from django.shortcuts import get_object_or_404
 from boards.models import Post, Tag
 from neboard import settings
 
 __author__ = 'neko259'
 
+
 # TODO Make tests for all of these
 class AllThreadsFeed(Feed):
 
     title = settings.SITE_NAME + ' - All threads'
     link = '/'
     description_template = 'boards/rss/post.html'
 
     def items(self):
-	return Post.objects.get_threads(order_by='-pub_time')
+        return Post.objects.get_threads(order_by='-pub_time')
 
     def item_title(self, item):
         return item.title
 
     def item_link(self, item):
         return reverse('thread', args={item.id})
 
     def item_pubdate(self, item):
         return item.pub_time
 
 
 class TagThreadsFeed(Feed):
 
     link = '/'
     description_template = 'boards/rss/post.html'
 
     def items(self, obj):
         return Post.objects.get_threads(tag=obj,
                                         order_by='-pub_time')
 
     def get_object(self, request, tag_name):
         return get_object_or_404(Tag, name=tag_name)
 
     def item_title(self, item):
         return item.title
 
     def item_link(self, item):
         return reverse('thread', args={item.id})
 
     def item_pubdate(self, item):
         return item.pub_time
 
     def title(self, obj):
         return obj.name
 
 
 class ThreadPostsFeed(Feed):
 
     link = '/'
     description_template = 'boards/rss/post.html'
 
     def items(self, obj):
         return Post.objects.get_thread(opening_post_id=obj)
 
     def get_object(self, request, post_id):
         return post_id
 
     def item_title(self, item):
         return item.title
 
     def item_link(self, item):
         if item.thread:
             return reverse('thread', args={item.thread.id}) + "#" + str(item.id)
         else:
             return reverse('thread', args={item.id})
 
     def item_pubdate(self, item):
         return item.pub_time
 
     def title(self, obj):
         return get_object_or_404(Post, id=obj).title

boards/settings.py

@@ -1,1 +1,4 b''
-CACHE_TIMEOUT = 600 # Timeout for caching, if cache is used
  No newline at end of file
+CACHE_TIMEOUT = 600  # Timeout for caching, if cache is used
+LOGIN_TIMEOUT = 3600  # Timeout between login tries
+MAX_TEXT_LENGTH = 30000  # Max post length in characters
+MAX_IMAGE_SIZE = 8 * 1024 * 1024  # Max image size