views.py
562 lines
| 16.0 KiB
| text/x-python
|
PythonLexer
/ boards / views.py
|
r110 | import hashlib | |
|
r361 | import json | |
|
r199 | import string | |
|
r363 | import time | |
|
r370 | import calendar | |
|
r363 | ||
from datetime import datetime | |||
|
r221 | from django.core import serializers | |
|
r41 | from django.core.urlresolvers import reverse | |
|
r155 | from django.http import HttpResponseRedirect | |
|
r221 | from django.http.response import HttpResponse | |
|
r9 | from django.template import RequestContext | |
|
r79 | from django.shortcuts import render, redirect, get_object_or_404 | |
|
r121 | from django.utils import timezone | |
|
r335 | from django.db import transaction | |
|
r76 | ||
|
r14 | from boards import forms | |
|
r20 | import boards | |
|
r78 | from boards import utils | |
from boards.forms import ThreadForm, PostForm, SettingsForm, PlainErrorList, \ | |||
|
r205 | ThreadCaptchaForm, PostCaptchaForm, LoginForm, ModeratorSettingsForm | |
|
r78 | ||
|
r312 | from boards.models import Post, Tag, Ban, User, RANK_USER, SETTING_MODERATE, \ | |
REGEX_REPLY | |||
|
r103 | from boards import authors | |
|
r210 | from boards.utils import get_client_ip | |
|
r35 | import neboard | |
|
r312 | import re | |
|
r0 | ||
|
r340 | BAN_REASON_SPAM = 'Autoban: spam bot' | |
|
r22 | ||
|
r46 | def index(request, page=0): | |
|
r101 | context = _init_default_context(request) | |
|
r14 | ||
|
r95 | if utils.need_include_captcha(request): | |
threadFormClass = ThreadCaptchaForm | |||
kwargs = {'request': request} | |||
else: | |||
threadFormClass = ThreadForm | |||
kwargs = {} | |||
|
r78 | ||
|
r14 | if request.method == 'POST': | |
|
r78 | form = threadFormClass(request.POST, request.FILES, | |
|
r95 | error_class=PlainErrorList, **kwargs) | |
|
r153 | form.session = request.session | |
|
r78 | ||
|
r76 | if form.is_valid(): | |
return _new_post(request, form) | |||
|
r271 | if form.need_to_ban: | |
# Ban user because he is suspected to be a bot | |||
_ban_current_user(request) | |||
|
r20 | else: | |
|
r95 | form = threadFormClass(error_class=PlainErrorList, **kwargs) | |
|
r76 | ||
|
r163 | threads = [] | |
for thread in Post.objects.get_threads(page=int(page)): | |||
|
r318 | threads.append({ | |
'thread': thread, | |||
'bumpable': thread.can_bump(), | |||
'last_replies': thread.get_last_replies(), | |||
}) | |||
|
r18 | ||
|
r343 | # TODO Make this generic for tag and threads list pages | |
|
r76 | context['threads'] = None if len(threads) == 0 else threads | |
context['form'] = form | |||
|
r343 | ||
page_count = Post.objects.get_thread_page_count() | |||
context['pages'] = range(page_count) | |||
page = int(page) | |||
if page < page_count - 1: | |||
context['next_page'] = str(page + 1) | |||
if page > 0: | |||
context['prev_page'] = str(page - 1) | |||
|
r9 | ||
|
r84 | return render(request, 'boards/posting_general.html', | |
|
r76 | context) | |
|
r18 | ||
|
r14 | ||
|
r335 | @transaction.commit_on_success | |
|
r76 | def _new_post(request, form, thread_id=boards.models.NO_PARENT): | |
|
r4 | """Add a new post (in thread or as a reply).""" | |
|
r210 | ip = get_client_ip(request) | |
is_banned = Ban.objects.filter(ip=ip).exists() | |||
|
r116 | ||
if is_banned: | |||
return redirect(you_are_banned) | |||
|
r76 | data = form.cleaned_data | |
|
r22 | ||
|
r29 | title = data['title'] | |
text = data['text'] | |||
|
r0 | ||
|
r312 | text = _remove_invalid_links(text) | |
|
r29 | if 'image' in data.keys(): | |
image = data['image'] | |||
|
r22 | else: | |
image = None | |||
|
r24 | tags = [] | |
|
r41 | ||
new_thread = thread_id == boards.models.NO_PARENT | |||
if new_thread: | |||
|
r29 | tag_strings = data['tags'] | |
|
r0 | ||
|
r24 | if tag_strings: | |
|
r35 | tag_strings = tag_strings.split(' ') | |
|
r24 | for tag_name in tag_strings: | |
|
r199 | tag_name = string.lower(tag_name.strip()) | |
|
r24 | if len(tag_name) > 0: | |
tag, created = Tag.objects.get_or_create(name=tag_name) | |||
tags.append(tag) | |||
|
r6 | ||
|
r319 | linked_tags = tag.get_linked_tags() | |
|
r279 | if len(linked_tags) > 0: | |
tags.extend(linked_tags) | |||
|
r174 | op = None if thread_id == boards.models.NO_PARENT else \ | |
get_object_or_404(Post, id=thread_id) | |||
|
r22 | post = Post.objects.create_post(title=title, text=text, ip=ip, | |
|
r174 | thread=op, image=image, | |
|
r185 | tags=tags, user=_get_user(request)) | |
|
r4 | ||
|
r41 | thread_to_show = (post.id if new_thread else thread_id) | |
|
r5 | ||
|
r41 | if new_thread: | |
return redirect(thread, post_id=thread_to_show) | |||
else: | |||
|
r174 | return redirect(reverse(thread, kwargs={'post_id': thread_to_show}) + | |
'#' + str(post.id)) | |||
|
r22 | ||
|
r5 | ||
|
r46 | def tag(request, tag_name, page=0): | |
|
r271 | """ | |
Get all tag threads. Threads are split in pages, so some page is | |||
requested. Default page is 0. | |||
""" | |||
|
r4 | ||
|
r79 | tag = get_object_or_404(Tag, name=tag_name) | |
|
r164 | threads = [] | |
for thread in Post.objects.get_threads(tag=tag, page=int(page)): | |||
|
r318 | threads.append({ | |
'thread': thread, | |||
'bumpable': thread.can_bump(), | |||
'last_replies': thread.get_last_replies(), | |||
}) | |||
|
r5 | ||
|
r24 | if request.method == 'POST': | |
|
r76 | form = ThreadForm(request.POST, request.FILES, | |
error_class=PlainErrorList) | |||
|
r278 | form.session = request.session | |
|
r76 | if form.is_valid(): | |
return _new_post(request, form) | |||
|
r271 | if form.need_to_ban: | |
# Ban user because he is suspected to be a bot | |||
_ban_current_user(request) | |||
|
r24 | else: | |
|
r76 | form = forms.ThreadForm(initial={'tags': tag_name}, | |
error_class=PlainErrorList) | |||
|
r12 | ||
|
r101 | context = _init_default_context(request) | |
|
r76 | context['threads'] = None if len(threads) == 0 else threads | |
|
r179 | context['tag'] = tag | |
|
r343 | ||
page_count = Post.objects.get_thread_page_count(tag=tag) | |||
context['pages'] = range(page_count) | |||
page = int(page) | |||
if page < page_count - 1: | |||
context['next_page'] = str(page + 1) | |||
if page > 0: | |||
context['prev_page'] = str(page - 1) | |||
|
r4 | ||
|
r76 | context['form'] = form | |
|
r84 | return render(request, 'boards/posting_general.html', | |
|
r76 | context) | |
|
r22 | ||
|
r4 | ||
|
r24 | def thread(request, post_id): | |
|
r5 | """Get all thread posts""" | |
|
r95 | if utils.need_include_captcha(request): | |
postFormClass = PostCaptchaForm | |||
kwargs = {'request': request} | |||
else: | |||
postFormClass = PostForm | |||
kwargs = {} | |||
|
r78 | ||
|
r20 | if request.method == 'POST': | |
|
r78 | form = postFormClass(request.POST, request.FILES, | |
|
r95 | error_class=PlainErrorList, **kwargs) | |
|
r153 | form.session = request.session | |
|
r76 | if form.is_valid(): | |
return _new_post(request, form, post_id) | |||
|
r271 | if form.need_to_ban: | |
# Ban user because he is suspected to be a bot | |||
_ban_current_user(request) | |||
|
r20 | else: | |
|
r95 | form = postFormClass(error_class=PlainErrorList, **kwargs) | |
|
r12 | ||
|
r76 | posts = Post.objects.get_thread(post_id) | |
|
r5 | ||
|
r101 | context = _init_default_context(request) | |
|
r12 | ||
|
r76 | context['posts'] = posts | |
context['form'] = form | |||
|
r161 | context['bumpable'] = posts[0].can_bump() | |
|
r281 | if context['bumpable']: | |
context['posts_left'] = neboard.settings.MAX_POSTS_PER_THREAD - len( | |||
posts) | |||
|
r319 | context['bumplimit_progress'] = str( | |
float(context['posts_left']) / | |||
neboard.settings.MAX_POSTS_PER_THREAD * 100) | |||
|
r370 | context["last_update"] = _datetime_to_epoch(posts[0].last_edit_time) | |
|
r76 | ||
|
r84 | return render(request, 'boards/thread.html', context) | |
|
r9 | ||
def login(request): | |||
|
r144 | """Log in with user id""" | |
|
r9 | ||
|
r144 | context = _init_default_context(request) | |
|
r13 | ||
|
r144 | if request.method == 'POST': | |
|
r147 | form = LoginForm(request.POST, request.FILES, | |
error_class=PlainErrorList) | |||
|
r211 | form.session = request.session | |
|
r144 | if form.is_valid(): | |
user = User.objects.get(user_id=form.cleaned_data['user_id']) | |||
request.session['user_id'] = user.id | |||
return redirect(index) | |||
|
r9 | ||
|
r144 | else: | |
form = LoginForm() | |||
|
r22 | ||
|
r144 | context['form'] = form | |
return render(request, 'boards/login.html', context) | |||
|
r35 | ||
def settings(request): | |||
|
r101 | """User's settings""" | |
|
r110 | context = _init_default_context(request) | |
|
r205 | user = _get_user(request) | |
is_moderator = user.is_moderator() | |||
|
r35 | ||
if request.method == 'POST': | |||
|
r370 | with transaction.commit_on_success(): | |
if is_moderator: | |||
form = ModeratorSettingsForm(request.POST, | |||
error_class=PlainErrorList) | |||
else: | |||
form = SettingsForm(request.POST, error_class=PlainErrorList) | |||
|
r205 | ||
|
r370 | if form.is_valid(): | |
selected_theme = form.cleaned_data['theme'] | |||
|
r110 | ||
|
r370 | user.save_setting('theme', selected_theme) | |
|
r35 | ||
|
r370 | if is_moderator: | |
moderate = form.cleaned_data['moderate'] | |||
user.save_setting(SETTING_MODERATE, moderate) | |||
|
r205 | ||
|
r370 | return redirect(settings) | |
|
r35 | else: | |
selected_theme = _get_theme(request) | |||
|
r205 | if is_moderator: | |
form = ModeratorSettingsForm(initial={'theme': selected_theme, | |||
'moderate': context['moderator']}, | |||
|
r319 | error_class=PlainErrorList) | |
|
r205 | else: | |
form = SettingsForm(initial={'theme': selected_theme}, | |||
error_class=PlainErrorList) | |||
context['form'] = form | |||
return render(request, 'boards/settings.html', context) | |||
|
r35 | ||
|
r57 | def all_tags(request): | |
|
r101 | """All tags list""" | |
context = _init_default_context(request) | |||
|
r57 | context['all_tags'] = Tag.objects.get_not_empty_tags() | |
|
r84 | return render(request, 'boards/tags.html', context) | |
|
r57 | ||
|
r98 | def jump_to_post(request, post_id): | |
|
r101 | """Determine thread in which the requested post is and open it's page""" | |
|
r98 | post = get_object_or_404(Post, id=post_id) | |
|
r174 | if not post.thread: | |
|
r319 | return redirect(thread, post_id=post.id) | |
|
r98 | else: | |
|
r174 | return redirect(reverse(thread, kwargs={'post_id': post.thread.id}) | |
|
r98 | + '#' + str(post.id)) | |
|
r103 | def authors(request): | |
|
r221 | """Show authors list""" | |
|
r103 | context = _init_default_context(request) | |
context['authors'] = boards.authors.authors | |||
return render(request, 'boards/authors.html', context) | |||
|
r335 | @transaction.commit_on_success | |
|
r112 | def delete(request, post_id): | |
|
r221 | """Delete post""" | |
|
r112 | user = _get_user(request) | |
post = get_object_or_404(Post, id=post_id) | |||
if user.is_moderator(): | |||
|
r147 | # TODO Show confirmation page before deletion | |
|
r112 | Post.objects.delete_post(post) | |
|
r370 | ||
|
r174 | if not post.thread: | |
|
r155 | return _redirect_to_next(request) | |
|
r112 | else: | |
|
r174 | return redirect(thread, post_id=post.thread.id) | |
|
r112 | ||
|
r145 | ||
|
r335 | @transaction.commit_on_success | |
|
r156 | def ban(request, post_id): | |
|
r221 | """Ban user""" | |
|
r156 | user = _get_user(request) | |
post = get_object_or_404(Post, id=post_id) | |||
if user.is_moderator(): | |||
# TODO Show confirmation page before ban | |||
|
r340 | ban, created = Ban.objects.get_or_create(ip=post.poster_ip) | |
if created: | |||
ban.reason = 'Banned for post ' + str(post_id) | |||
ban.save() | |||
|
r156 | ||
return _redirect_to_next(request) | |||
|
r116 | def you_are_banned(request): | |
|
r221 | """Show the page that notifies that user is banned""" | |
|
r116 | context = _init_default_context(request) | |
|
r340 | ||
ban = get_object_or_404(Ban, ip=utils.get_client_ip(request)) | |||
context['ban_reason'] = ban.reason | |||
|
r152 | return render(request, 'boards/staticpages/banned.html', context) | |
|
r116 | ||
|
r130 | def page_404(request): | |
|
r221 | """Show page 404 (not found error)""" | |
|
r130 | context = _init_default_context(request) | |
return render(request, 'boards/404.html', context) | |||
|
r335 | @transaction.commit_on_success | |
|
r145 | def tag_subscribe(request, tag_name): | |
|
r221 | """Add tag to favorites""" | |
|
r145 | user = _get_user(request) | |
tag = get_object_or_404(Tag, name=tag_name) | |||
if not tag in user.fav_tags.all(): | |||
|
r323 | user.add_tag(tag) | |
|
r145 | ||
|
r179 | return _redirect_to_next(request) | |
|
r145 | ||
|
r335 | @transaction.commit_on_success | |
|
r145 | def tag_unsubscribe(request, tag_name): | |
|
r221 | """Remove tag from favorites""" | |
|
r145 | user = _get_user(request) | |
tag = get_object_or_404(Tag, name=tag_name) | |||
if tag in user.fav_tags.all(): | |||
|
r323 | user.remove_tag(tag) | |
|
r145 | ||
|
r179 | return _redirect_to_next(request) | |
|
r145 | ||
|
r152 | def static_page(request, name): | |
|
r221 | """Show a static page that needs only tags list and a CSS""" | |
|
r152 | context = _init_default_context(request) | |
return render(request, 'boards/staticpages/' + name + '.html', context) | |||
|
r222 | def api_get_post(request, post_id): | |
|
r221 | """ | |
|
r222 | Get the JSON of a post. This can be | |
|
r221 | used as and API for external clients. | |
""" | |||
post = get_object_or_404(Post, id=post_id) | |||
json = serializers.serialize("json", [post], fields=( | |||
"pub_time", "_text_rendered", "title", "text", "image", | |||
"image_width", "image_height", "replies", "tags" | |||
)) | |||
return HttpResponse(content=json) | |||
|
r363 | def api_get_threaddiff(request, thread_id, last_update_time): | |
|
r370 | """Get posts that were changed or added since time""" | |
|
r361 | thread = get_object_or_404(Post, id=thread_id) | |
|
r363 | ||
|
r370 | filter_time = datetime.fromtimestamp(float(last_update_time) / 1000, | |
timezone.get_current_timezone()) | |||
|
r361 | ||
json_data = { | |||
|
r363 | 'added': [], | |
|
r364 | 'updated': [], | |
|
r370 | 'last_update': None, | |
|
r361 | } | |
|
r364 | added_posts = Post.objects.filter(thread=thread, pub_time__gt=filter_time) | |
updated_posts = Post.objects.filter(thread=thread, | |||
|
r370 | pub_time__lt=filter_time, | |
last_edit_time__gt=filter_time) | |||
|
r363 | for post in added_posts: | |
|
r361 | json_data['added'].append(get_post(request, post.id).content.strip()) | |
|
r364 | for post in updated_posts: | |
json_data['updated'].append(get_post(request, post.id).content.strip()) | |||
|
r370 | json_data['last_update'] = _datetime_to_epoch(thread.last_edit_time) | |
|
r361 | ||
return HttpResponse(content=json.dumps(json_data)) | |||
|
r222 | def get_post(request, post_id): | |
|
r271 | """Get the html of a post. Used for popups.""" | |
|
r222 | ||
post = get_object_or_404(Post, id=post_id) | |||
|
r361 | thread = post.thread | |
|
r222 | ||
context = RequestContext(request) | |||
context["post"] = post | |||
|
r361 | context["can_bump"] = thread.can_bump() | |
|
r368 | if "truncated" in request.GET: | |
context["truncated"] = True | |||
|
r222 | ||
return render(request, 'boards/post.html', context) | |||
|
r147 | def _get_theme(request, user=None): | |
|
r101 | """Get user's CSS theme""" | |
|
r147 | if not user: | |
user = _get_user(request) | |||
|
r110 | theme = user.get_setting('theme') | |
if not theme: | |||
theme = neboard.settings.DEFAULT_THEME | |||
return theme | |||
|
r70 | ||
|
r101 | def _init_default_context(request): | |
"""Create context with default values that are used in most views""" | |||
context = RequestContext(request) | |||
|
r147 | ||
user = _get_user(request) | |||
context['user'] = user | |||
|
r149 | context['tags'] = user.get_sorted_fav_tags() | |
|
r260 | ||
theme = _get_theme(request, user) | |||
context['theme'] = theme | |||
context['theme_css'] = 'css/' + theme + '/base_page.css' | |||
|
r205 | ||
|
r271 | # This shows the moderator panel | |
|
r205 | moderate = user.get_setting(SETTING_MODERATE) | |
if moderate == 'True': | |||
context['moderator'] = user.is_moderator() | |||
else: | |||
context['moderator'] = False | |||
|
r101 | ||
return context | |||
|
r110 | ||
def _get_user(request): | |||
|
r271 | """ | |
Get current user from the session. If the user does not exist, create | |||
a new one. | |||
""" | |||
|
r110 | ||
session = request.session | |||
|
r112 | if not 'user_id' in session: | |
|
r110 | request.session.save() | |
md5 = hashlib.md5() | |||
md5.update(session.session_key) | |||
new_id = md5.hexdigest() | |||
|
r141 | time_now = timezone.now() | |
|
r121 | user = User.objects.create(user_id=new_id, rank=RANK_USER, | |
|
r202 | registration_time=time_now) | |
|
r110 | ||
|
r112 | session['user_id'] = user.id | |
|
r110 | else: | |
|
r112 | user = User.objects.get(id=session['user_id']) | |
|
r196 | ||
|
r137 | return user | |
|
r155 | ||
def _redirect_to_next(request): | |||
|
r271 | """ | |
If a 'next' parameter was specified, redirect to the next page. This is | |||
used when the user is required to return to some page after the current | |||
view has finished its work. | |||
""" | |||
|
r156 | if 'next' in request.GET: | |
next_page = request.GET['next'] | |||
return HttpResponseRedirect(next_page) | |||
else: | |||
return redirect(index) | |||
|
r271 | ||
|
r340 | @transaction.commit_on_success | |
|
r271 | def _ban_current_user(request): | |
"""Add current user to the IP ban list""" | |||
ip = utils.get_client_ip(request) | |||
|
r340 | ban, created = Ban.objects.get_or_create(ip=ip) | |
if created: | |||
ban.can_read = False | |||
ban.reason = BAN_REASON_SPAM | |||
ban.save() | |||
|
r312 | ||
def _remove_invalid_links(text): | |||
""" | |||
Replace invalid links in posts so that they won't be parsed. | |||
Invalid links are links to non-existent posts | |||
""" | |||
for reply_number in re.finditer(REGEX_REPLY, text): | |||
|
r319 | post_id = reply_number.group(1) | |
post = Post.objects.filter(id=post_id) | |||
if not post.exists(): | |||
text = string.replace(text, '>>' + id, id) | |||
|
r312 | ||
return text | |||
|
r370 | ||
def _datetime_to_epoch(datetime): | |||
return int(time.mktime(timezone.localtime( | |||
datetime,timezone.get_current_timezone()).timetuple()) | |||
* 1000 + datetime.microsecond) |