Added a 'next' attribute to the delete page to return to the current page after deletion.

boards/templates/boards/posting_general.html

@@ -1,180 +1,180 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load markup %}
 
 {% block head %}
     {% if tag %}
         <title>Neboard - {{ tag }}</title>
     {% else %}
         <title>Neboard</title>
     {% endif %}
 {% endblock %}
 
 {% block content %}
 
 {% if tag %}
     <div class="tag_info">
         <h2>{% trans 'Tag: ' %}{{ tag }}</h2>
     </div>
 {% endif %}
 
     {% if threads %}
         {% for thread in threads %}
             <div class="thread">
             {% if thread.can_bump %}
 		<div class="post" id="{{thread.id}}">
             {% else %}
 		<div class="post dead_post" id="{{ thread.id }}">
             {% endif %}
             {% if thread.image %}
                 <div class="image">
                     <a class="fancy"
                        href="{{ thread.image.url }}"><img
                             src="{{ thread.image.url_200x150 }}"
                             alt="{% trans 'Post image' %}"
                             data-width="{{ thread.image_width }}"
                             data-height="{{ thread.image_height }}" />
                     </a>
                 </div>
             {% endif %}
             <div class="message">
                 <div class="post-info">
                     <span class="title">{{ thread.title }}</span>
 		    <a class="post_id" href="{% url 'thread' thread.id %}"
 			>(#{{ thread.id }})</a>
                     [{{ thread.pub_time }}]
                     [<a class="link" href="{% url 'thread' thread.id %}#form"
                         >{% trans "Reply" %}</a>]
 
                     {% if user.is_moderator %}
                         <span class="moderator_info">
                             ({{ thread.poster_ip }})
-                            [<a href="{% url 'delete' post_id=thread.id %}"
+                            [<a href="{% url 'delete' post_id=thread.id %}?next={{ request.path }}"
                                 >{% trans 'Delete' %}</a>]
                         </span>
                     {% endif %}
                 </div>
                 {% autoescape off %}
                     {{ thread.text.rendered|truncatewords_html:50 }}
                 {% endautoescape %}
             </div>
             <div class="metadata">
                 {{ thread.get_reply_count }} {% trans 'replies' %},
                 {{ thread.get_images_count }} {% trans 'images' %}.
                 {% 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>
             {% if thread.get_last_replies %}
                 <div class="last-replies">
                     {% for post in thread.get_last_replies %}
                         {% if thread.can_bump %}
 			    <div class="post" id="{{ post.id }}">
                         {% else %}
 			    <div class="post dead_post id="{{ post.id }}"">
                         {% endif %}
                             {% if post.image %}
                                 <div class="image">
                                     <a class="fancy"
                                        href="{{ post.image.url }}"><img
                                             src=" {{ post.image.url_200x150 }}"
                                             alt="{% trans 'Post image' %}"
                                             data-width="{{ post.image_width }}"
                                             data-height="{{ post.image_height }}"/>
                                     </a>
                                 </div>
                             {% endif %}
                             <div class="message">
                                 <div class="post-info">
                                     <span class="title">{{ post.title }}</span>
                                     <a class="post_id" href="
                                 {% url 'thread' thread.id %}#{{ post.id }}">
                                         (#{{ post.id }})</a>
                                     [{{ post.pub_time }}]
                                 </div>
                                 {% autoescape off %}
                                     {{ post.text.rendered|truncatewords_html:50 }}
                                 {% endautoescape %}
                         </div>
                         </div>
                     {% endfor %}
                 </div>
             {% endif %}
         </div>
         {% endfor %}
     {% else %}
         <div class="post">
             {% trans 'No threads exist. Create the first one!' %}</div>
 	{% endif %}
 
     <form enctype="multipart/form-data" method="post">{% csrf_token %}
     <div class="post-form-w">
 
         <div class="form-title">{% trans "Create new thread" %}</div>
         <div class="post-form">
             <div class="form-row">
                 <div class="form-label">{% trans 'Title' %}</div>
                 <div class="form-input">{{ form.title }}</div>
                 <div class="form-errors">{{ form.title.errors }}</div>
             </div>
             <div class="form-row">
                 <div class="form-label">{% trans 'Text' %}</div>
                 <div class="form-input">{{ form.text }}</div>
                 <div class="form-errors">{{ form.text.errors }}</div>
             </div>
             <div class="form-row">
                 <div class="form-label">{% trans 'Image' %}</div>
                 <div class="form-input">{{ form.image }}</div>
                 <div class="form-errors">{{ form.image.errors }}</div>
             </div>
             <div class="form-row">
                 <div class="form-label">{% trans 'Tags' %}</div>
                 <div class="form-input">{{ form.tags }}</div>
                 <div class="form-errors">{{ form.tags.errors }}</div>
             </div>
             <div class="form-row">
                 {{ form.captcha }}
                 <div class="form-errors">{{ form.captcha.errors }}</div>
             </div>
             <div class="form-row">
                 <div class="form-errors">{{ form.other.errors }}</div>
             </div>
         </div>
         <div class="form-submit">
             <input type="submit" value="{% trans "Post" %}"/></div>
         <div>
             {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
         </div>
         <div><a href="{% url "staticpage" name="help" %}">
             {% trans 'Text syntax' %}</a></div>
     </div>
     </form>
 
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
         <b><a href="{% url "authors" %}">Neboard</a> 1.1</b>
         {% trans "Pages:" %}
         {% for page in pages %}
             [<a href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=page %}
             {% else %}
                 {% url "index" page=page %}
             {% endif %}
             ">{{ page }}</a>]
         {% endfor %}
         [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/views.py

@@ -1,331 +1,337 b''
 import hashlib
 from django.core.urlresolvers import reverse
+from django.http import HttpResponseRedirect
 from django.template import RequestContext
 from django.shortcuts import render, redirect, get_object_or_404
 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, LoginForm
 
 from boards.models import Post, Tag, Ban, User, RANK_USER, 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)
         form.session = request.session
 
         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)
         form.session = request.session
 
         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 with user id"""
 
     context = _init_default_context(request)
 
     if request.method == 'POST':
         form = LoginForm(request.POST, request.FILES,
                          error_class=PlainErrorList)
         if form.is_valid():
             user = User.objects.get(user_id=form.cleaned_data['user_id'])
             request.session['user_id'] = user.id
             return redirect(index)
 
     else:
         form = LoginForm()
 
     context['form'] = form
 
     return render(request, 'boards/login.html', context)
 
 
 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():
         # TODO Show confirmation page before deletion
         Post.objects.delete_post(post)
     
     if NO_PARENT == post.parent:
-        return redirect(index)
+        return _redirect_to_next(request)
     else:
         return redirect(thread, post_id=post.parent)
 
 
 def you_are_banned(request):
     context = _init_default_context(request)
     return render(request, 'boards/staticpages/banned.html', context)
 
 
 def page_404(request):
     context = _init_default_context(request)
     return render(request, 'boards/404.html', context)
 
 
 def tag_subscribe(request, tag_name):
     user = _get_user(request)
     tag = get_object_or_404(Tag, name=tag_name)
 
     if not tag in user.fav_tags.all():
         user.fav_tags.add(tag)
 
     return redirect(all_tags)
 
 
 def tag_unsubscribe(request, tag_name):
     user = _get_user(request)
     tag = get_object_or_404(Tag, name=tag_name)
 
     if tag in user.fav_tags.all():
         user.fav_tags.remove(tag)
 
     return redirect(all_tags)
 
 
 def static_page(request, name):
     context = _init_default_context(request)
     return render(request, 'boards/staticpages/' + name + '.html', context)
 
 
 def _get_theme(request, user=None):
     """Get user's CSS theme"""
 
     if not user:
         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)
 
     user = _get_user(request)
     context['user'] = user
     context['tags'] = user.get_sorted_fav_tags()
     context['theme'] = _get_theme(request, user)
 
     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=time_now,
                                    last_access_time=time_now)
 
         session['user_id'] = user.id
     else:
         user = User.objects.get(id=session['user_id'])
         user.last_access_time = timezone.now()
         user.save()
 
     return user
+
+
+def _redirect_to_next(request):
+    next_page = request.GET['next']
+    return HttpResponseRedirect(next_page)

neboard/settings.py

@@ -1,202 +1,202 b''
 # Django settings for neboard project.
 import os
 import markdown
 from boards.mdx_neboard import markdown_extended
 
 DEBUG = True
 TEMPLATE_DEBUG = DEBUG
 
 ADMINS = (
     # ('Your Name', '[e-mail]'),
     ('admin', '[e-mail]')
 )
 
 MANAGERS = ADMINS
 
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
         'NAME': 'database.db',                      # Or path to database file if using sqlite3.
         'USER': '',                      # Not used with sqlite3.
         'PASSWORD': '',                  # Not used with sqlite3.
         'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
         'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
     }
 }
 
 # Local time zone for this installation. Choices can be found here:
 # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
 # although not all choices may be available on all operating systems.
 # In a Windows environment this must be set to your system time zone.
 TIME_ZONE = 'Europe/Kiev'
 
 # Language code for this installation. All choices can be found here:
 # http://www.i18nguy.com/unicode/language-identifiers.html
 LANGUAGE_CODE = 'en'
 
 SITE_ID = 1
 
 # If you set this to False, Django will make some optimizations so as not
 # to load the internationalization machinery.
 USE_I18N = True
 
 # If you set this to False, Django will not format dates, numbers and
 # calendars according to the current locale.
 USE_L10N = True
 
 # If you set this to False, Django will not use timezone-aware datetimes.
 USE_TZ = True
 
 # Absolute filesystem path to the directory that will hold user-uploaded files.
 # Example: "/home/media/media.lawrence.com/media/"
 MEDIA_ROOT = './media/' 
 
 # URL that handles the media served from MEDIA_ROOT. Make sure to use a
 # trailing slash.
 # Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
 MEDIA_URL = '/media/'
 
 # Absolute path to the directory static files should be collected to.
 # Don't put anything in this directory yourself; store your static files
 # in apps' "static/" subdirectories and in STATICFILES_DIRS.
 # Example: "/home/media/media.lawrence.com/static/"
 STATIC_ROOT = ''
 
 # URL prefix for static files.
 # Example: "http://media.lawrence.com/static/"
 STATIC_URL = '/static/'
 
 # Additional locations of static files
 # It is really a hack, put real paths, not related
 STATICFILES_DIRS = (
     os.path.dirname(__file__) + '/boards/static',
 
 #    '/d/work/python/django/neboard/neboard/boards/static',
     # Put strings here, like "/home/html/static" or "C:/www/django/static".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
 )
 
 # List of finder classes that know how to find static files in
 # various locations.
 STATICFILES_FINDERS = (
     'django.contrib.staticfiles.finders.FileSystemFinder',
     'django.contrib.staticfiles.finders.AppDirectoriesFinder',
 #    'django.contrib.staticfiles.finders.DefaultStorageFinder',
 )
 
 # Make this unique, and don't share it with anybody.
 SECRET_KEY = '@1rc$o(7=tt#kd+4s$u6wchm**z^)4x90)7f6z(i&55@o11*8o'
 
 # List of callables that know how to import templates from various sources.
 TEMPLATE_LOADERS = (
     'django.template.loaders.filesystem.Loader',
     'django.template.loaders.app_directories.Loader',
 #     'django.template.loaders.eggs.Loader',
 )
 
 TEMPLATE_CONTEXT_PROCESSORS = (
     'django.core.context_processors.media',
     'django.core.context_processors.static',
     'django.core.context_processors.request',
     'django.contrib.auth.context_processors.auth',
 )
 
 MIDDLEWARE_CLASSES = (
     'django.contrib.sessions.middleware.SessionMiddleware',
     'django.middleware.locale.LocaleMiddleware',
     'django.middleware.common.CommonMiddleware',
 #    'django.middleware.csrf.CsrfViewMiddleware',
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     # Uncomment the next line for simple clickjacking protection:
     # 'django.middleware.clickjacking.XFrameOptionsMiddleware',
 )
 
 ROOT_URLCONF = 'neboard.urls'
 
 # Python dotted path to the WSGI application used by Django's runserver.
 WSGI_APPLICATION = 'neboard.wsgi.application'
 
 TEMPLATE_DIRS = (
     # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
     # Always use forward slashes, even on Windows.
     # Don't forget to use absolute paths, not relative paths.
     'templates',
 )
 
 INSTALLED_APPS = (
     'django.contrib.auth',
     'django.contrib.contenttypes',
     'django.contrib.sessions',
     # 'django.contrib.sites',
     'django.contrib.messages',
     'django.contrib.staticfiles',
     # Uncomment the next line to enable the admin:
      'django.contrib.admin',
     # Uncomment the next line to enable admin documentation:
     # 'django.contrib.admindocs',
     'django.contrib.markup',
     'django_cleanup',
     'boards',
     'captcha',
     'south',
 )
 
 # TODO: NEED DESIGN FIXES
 CAPTCHA_OUTPUT_FORMAT = (u' %(hidden_field)s '
                          u'<div class="form-label">%(image)s</div>'
                          u'<div class="form-text">%(text_field)s</div>')
 
 # A sample logging configuration. The only tangible logging
 # performed by this configuration is to send an email to
 # the site admins on every HTTP 500 error when DEBUG=False.
 # See http://docs.djangoproject.com/en/dev/topics/logging for
 # more details on how to customize your logging configuration.
 LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'filters': {
         'require_debug_false': {
             '()': 'django.utils.log.RequireDebugFalse'
         }
     },
     'handlers': {
         'mail_admins': {
             'level': 'ERROR',
             'filters': ['require_debug_false'],
             'class': 'django.utils.log.AdminEmailHandler'
         }
     },
     'loggers': {
         'django.request': {
             'handlers': ['mail_admins'],
             'level': 'ERROR',
             'propagate': True,
         },
     }
 }
 
 MARKUP_FIELD_TYPES = (
     ('markdown', markdown_extended),
 )
 # Custom imageboard settings
-MAX_POSTS_PER_THREAD = 10 # Thread bumplimit
-MAX_THREAD_COUNT = 500 # Old threads will be deleted to preserve this count
+MAX_POSTS_PER_THREAD = 10  # Thread bumplimit
+MAX_THREAD_COUNT = 500  # Old threads will be deleted to preserve this count
 THREADS_PER_PAGE = 10
 SITE_NAME = 'Neboard'
 
 THEMES = [
     ('md', 'Mystic Dark'),
     ('sw', 'Snow White')
 ]
 
 DEFAULT_THEME = 'md'
 
 POPULAR_TAGS = 10
 LAST_REPLIES_COUNT = 3
 
 ENABLE_CAPTCHA = False
 # if user tries to post before CAPTCHA_DEFAULT_SAFE_TIME. Captcha will be shown
 CAPTCHA_DEFAULT_SAFE_TIME = 30  # seconds
-POSTING_DELAY = 20 # seconds
  No newline at end of file
+POSTING_DELAY = 30  # seconds
  No newline at end of file