post.py
416 lines
| 12.2 KiB
| text/x-python
|
PythonLexer
|
r586 | from datetime import datetime, timedelta, date | |
|
r407 | from datetime import time as dtime | |
|
r853 | from adjacent import Client | |
|
r639 | import logging | |
|
r386 | import re | |
|
r527 | ||
|
r410 | from django.core.cache import cache | |
|
r589 | from django.core.urlresolvers import reverse | |
|
r566 | from django.db import models, transaction | |
|
r853 | from django.shortcuts import get_object_or_404 | |
from django.template import RequestContext | |||
|
r692 | from django.template.loader import render_to_string | |
|
r384 | from django.utils import timezone | |
from markupfield.fields import MarkupField | |||
|
r853 | from boards import settings | |
|
r723 | ||
|
r693 | from boards.models import PostImage | |
|
r692 | from boards.models.base import Viewable | |
|
r691 | from boards.models.thread import Thread | |
|
r853 | from boards.utils import datetime_to_epoch | |
|
r384 | ||
|
r853 | WS_CHANNEL_THREAD = "thread:" | |
|
r622 | ||
|
r410 | APP_LABEL_BOARDS = 'boards' | |
CACHE_KEY_PPD = 'ppd' | |||
|
r589 | CACHE_KEY_POST_URL = 'post_url' | |
|
r410 | ||
|
r745 | POSTS_PER_DAY_RANGE = 7 | |
|
r408 | ||
|
r384 | BAN_REASON_AUTO = 'Auto' | |
IMAGE_THUMB_SIZE = (200, 150) | |||
|
r612 | TITLE_MAX_LENGTH = 200 | |
|
r384 | ||
|
r736 | DEFAULT_MARKUP_TYPE = 'bbcode' | |
|
r384 | ||
|
r702 | # TODO This should be removed | |
|
r384 | NO_IP = '0.0.0.0' | |
|
r702 | ||
# TODO Real user agent should be saved instead of this | |||
|
r384 | UNKNOWN_UA = '' | |
|
r702 | ||
|
r765 | REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]') | |
|
r384 | ||
|
r853 | PARAMETER_TRUNCATED = 'truncated' | |
PARAMETER_TAG = 'tag' | |||
PARAMETER_OFFSET = 'offset' | |||
PARAMETER_DIFF_TYPE = 'type' | |||
DIFF_TYPE_HTML = 'html' | |||
DIFF_TYPE_JSON = 'json' | |||
|
r639 | logger = logging.getLogger(__name__) | |
|
r384 | ||
class PostManager(models.Manager): | |||
|
r728 | def create_post(self, title, text, image=None, thread=None, ip=NO_IP, | |
tags=None): | |||
|
r418 | """ | |
|
r622 | Creates new post | |
|
r418 | """ | |
|
r766 | if not tags: | |
tags = [] | |||
|
r384 | posting_time = timezone.now() | |
|
r398 | if not thread: | |
thread = Thread.objects.create(bump_time=posting_time, | |||
last_edit_time=posting_time) | |||
|
r615 | new_thread = True | |
|
r398 | else: | |
thread.bump() | |||
thread.last_edit_time = posting_time | |||
thread.save() | |||
|
r615 | new_thread = False | |
|
r384 | ||
post = self.create(title=title, | |||
text=text, | |||
pub_time=posting_time, | |||
|
r398 | thread_new=thread, | |
|
r384 | poster_ip=ip, | |
|
r484 | poster_user_agent=UNKNOWN_UA, # TODO Get UA at | |
# last! | |||
|
r728 | last_edit_time=posting_time) | |
|
r384 | ||
|
r851 | logger.info('Created post #%d with title "%s"' % (post.id, | |
|
r850 | post.title)) | |
|
r693 | if image: | |
post_image = PostImage.objects.create(image=image) | |||
post.images.add(post_image) | |||
logger.info('Created image #%d for post #%d' % (post_image.id, | |||
post.id)) | |||
|
r398 | thread.replies.add(post) | |
|
r770 | list(map(thread.add_tag, tags)) | |
|
r384 | ||
|
r615 | if new_thread: | |
|
r716 | Thread.objects.process_oldest_threads() | |
|
r384 | self.connect_replies(post) | |
return post | |||
def delete_post(self, post): | |||
|
r418 | """ | |
|
r622 | Deletes post and update or delete its thread | |
|
r418 | """ | |
|
r552 | ||
|
r639 | post_id = post.id | |
|
r619 | thread = post.get_thread() | |
|
r418 | ||
|
r552 | if post.is_opening(): | |
|
r718 | thread.delete() | |
|
r456 | else: | |
thread.last_edit_time = timezone.now() | |||
thread.save() | |||
|
r384 | ||
|
r470 | post.delete() | |
|
r384 | ||
|
r742 | logger.info('Deleted post #%d (%s)' % (post_id, post.get_title())) | |
|
r639 | ||
|
r384 | def delete_posts_by_ip(self, ip): | |
|
r418 | """ | |
|
r622 | Deletes all posts of the author with same IP | |
|
r418 | """ | |
|
r384 | posts = self.filter(poster_ip=ip) | |
|
r766 | for post in posts: | |
self.delete_post(post) | |||
|
r384 | ||
|
r853 | def connect_replies(self, post): | |
|
r418 | """ | |
|
r622 | Connects replies to a post to show them as a reflink map | |
|
r418 | """ | |
|
r384 | ||
|
r753 | for reply_number in re.finditer(REGEX_REPLY, post.text.raw): | |
|
r384 | post_id = reply_number.group(1) | |
ref_post = self.filter(id=post_id) | |||
if ref_post.count() > 0: | |||
referenced_post = ref_post[0] | |||
referenced_post.referenced_posts.add(post) | |||
referenced_post.last_edit_time = post.pub_time | |||
|
r674 | referenced_post.build_refmap() | |
|
r715 | referenced_post.save(update_fields=['refmap', 'last_edit_time']) | |
|
r384 | ||
|
r619 | referenced_thread = referenced_post.get_thread() | |
|
r535 | referenced_thread.last_edit_time = post.pub_time | |
|
r715 | referenced_thread.save(update_fields=['last_edit_time']) | |
|
r535 | ||
|
r407 | def get_posts_per_day(self): | |
|
r418 | """ | |
|
r622 | Gets average count of posts per day for the last 7 days | |
|
r418 | """ | |
|
r407 | ||
|
r745 | day_end = date.today() | |
day_start = day_end - timedelta(POSTS_PER_DAY_RANGE) | |||
cache_key = CACHE_KEY_PPD + str(day_end) | |||
ppd = cache.get(cache_key) | |||
|
r410 | if ppd: | |
return ppd | |||
|
r745 | day_time_start = timezone.make_aware(datetime.combine( | |
day_start, dtime()), timezone.get_current_timezone()) | |||
day_time_end = timezone.make_aware(datetime.combine( | |||
day_end, dtime()), timezone.get_current_timezone()) | |||
|
r413 | ||
|
r745 | posts_per_period = float(self.filter( | |
pub_time__lte=day_time_end, | |||
pub_time__gte=day_time_start).count()) | |||
|
r408 | ||
|
r745 | ppd = posts_per_period / POSTS_PER_DAY_RANGE | |
|
r408 | ||
|
r745 | cache.set(cache_key, ppd) | |
|
r410 | return ppd | |
|
r407 | ||
|
r384 | ||
|
r692 | class Post(models.Model, Viewable): | |
|
r384 | """A post is a message.""" | |
objects = PostManager() | |||
class Meta: | |||
|
r410 | app_label = APP_LABEL_BOARDS | |
|
r649 | ordering = ('id',) | |
|
r384 | ||
title = models.CharField(max_length=TITLE_MAX_LENGTH) | |||
pub_time = models.DateTimeField() | |||
text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE, | |||
escape_html=False) | |||
|
r693 | images = models.ManyToManyField(PostImage, null=True, blank=True, | |
related_name='ip+', db_index=True) | |||
|
r384 | ||
poster_ip = models.GenericIPAddressField() | |||
poster_user_agent = models.TextField() | |||
|
r661 | thread_new = models.ForeignKey('Thread', null=True, default=None, | |
|
r715 | db_index=True) | |
|
r384 | last_edit_time = models.DateTimeField() | |
referenced_posts = models.ManyToManyField('Post', symmetrical=False, | |||
null=True, | |||
|
r661 | blank=True, related_name='rfp+', | |
db_index=True) | |||
|
r674 | refmap = models.TextField(null=True, blank=True) | |
|
r384 | ||
def __unicode__(self): | |||
return '#' + str(self.id) + ' ' + self.title + ' (' + \ | |||
self.text.raw[:50] + ')' | |||
def get_title(self): | |||
|
r622 | """ | |
Gets original post title or part of its text. | |||
""" | |||
|
r384 | title = self.title | |
|
r618 | if not title: | |
|
r521 | title = self.text.rendered | |
|
r384 | ||
return title | |||
|
r674 | def build_refmap(self): | |
|
r740 | """ | |
Builds a replies map string from replies list. This is a cache to stop | |||
the server from recalculating the map on every post show. | |||
""" | |||
|
r674 | map_string = '' | |
first = True | |||
for refpost in self.referenced_posts.all(): | |||
if not first: | |||
map_string += ', ' | |||
|
r740 | map_string += '<a href="%s">>>%s</a>' % (refpost.get_url(), | |
refpost.id) | |||
|
r674 | first = False | |
self.refmap = map_string | |||
|
r398 | def get_sorted_referenced_posts(self): | |
|
r674 | return self.refmap | |
|
r398 | ||
def is_referenced(self): | |||
|
r674 | return len(self.refmap) > 0 | |
|
r398 | ||
|
r400 | def is_opening(self): | |
|
r622 | """ | |
Checks if this is an opening post or just a reply. | |||
""" | |||
|
r620 | return self.get_thread().get_opening_post_id() == self.id | |
|
r400 | ||
|
r566 | @transaction.atomic | |
def add_tag(self, tag): | |||
edit_time = timezone.now() | |||
|
r619 | thread = self.get_thread() | |
|
r566 | thread.add_tag(tag) | |
self.last_edit_time = edit_time | |||
|
r740 | self.save(update_fields=['last_edit_time']) | |
|
r566 | ||
thread.last_edit_time = edit_time | |||
|
r740 | thread.save(update_fields=['last_edit_time']) | |
|
r566 | ||
@transaction.atomic | |||
def remove_tag(self, tag): | |||
edit_time = timezone.now() | |||
|
r619 | thread = self.get_thread() | |
|
r576 | thread.remove_tag(tag) | |
|
r566 | self.last_edit_time = edit_time | |
|
r740 | self.save(update_fields=['last_edit_time']) | |
|
r566 | ||
thread.last_edit_time = edit_time | |||
|
r740 | thread.save(update_fields=['last_edit_time']) | |
|
r566 | ||
|
r625 | def get_url(self, thread=None): | |
|
r589 | """ | |
|
r622 | Gets full url to the post. | |
|
r589 | """ | |
cache_key = CACHE_KEY_POST_URL + str(self.id) | |||
link = cache.get(cache_key) | |||
if not link: | |||
|
r625 | if not thread: | |
thread = self.get_thread() | |||
opening_id = thread.get_opening_post_id() | |||
|
r614 | ||
if self.id != opening_id: | |||
|
r608 | link = reverse('thread', kwargs={ | |
|
r614 | 'post_id': opening_id}) + '#' + str(self.id) | |
|
r589 | else: | |
link = reverse('thread', kwargs={'post_id': self.id}) | |||
cache.set(cache_key, link) | |||
return link | |||
|
r617 | def get_thread(self): | |
|
r622 | """ | |
Gets post's thread. | |||
""" | |||
|
r617 | return self.thread_new | |
|
r660 | def get_referenced_posts(self): | |
|
r692 | return self.referenced_posts.only('id', 'thread_new') | |
def get_text(self): | |||
return self.text | |||
def get_view(self, moderator=False, need_open_link=False, | |||
truncated=False, *args, **kwargs): | |||
if 'is_opening' in kwargs: | |||
is_opening = kwargs['is_opening'] | |||
else: | |||
is_opening = self.is_opening() | |||
if 'thread' in kwargs: | |||
thread = kwargs['thread'] | |||
else: | |||
thread = self.get_thread() | |||
if 'can_bump' in kwargs: | |||
can_bump = kwargs['can_bump'] | |||
else: | |||
can_bump = thread.can_bump() | |||
|
r724 | if is_opening: | |
opening_post_id = self.id | |||
else: | |||
opening_post_id = thread.get_opening_post_id() | |||
|
r692 | ||
return render_to_string('boards/post.html', { | |||
'post': self, | |||
'moderator': moderator, | |||
'is_opening': is_opening, | |||
'thread': thread, | |||
'bumpable': can_bump, | |||
'need_open_link': need_open_link, | |||
'truncated': truncated, | |||
'opening_post_id': opening_post_id, | |||
}) | |||
|
r693 | def get_first_image(self): | |
return self.images.earliest('id') | |||
|
r715 | def delete(self, using=None): | |
""" | |||
|
r740 | Deletes all post images and the post itself. | |
|
r715 | """ | |
self.images.all().delete() | |||
|
r736 | super(Post, self).delete(using) | |
|
r853 | ||
def get_post_data(self, format_type=DIFF_TYPE_JSON, request=None, | |||
include_last_update=False): | |||
""" | |||
Gets post HTML or JSON data that can be rendered on a page or used by | |||
API. | |||
""" | |||
if format_type == DIFF_TYPE_HTML: | |||
context = RequestContext(request) | |||
context['post'] = self | |||
if PARAMETER_TRUNCATED in request.GET: | |||
context[PARAMETER_TRUNCATED] = True | |||
return render_to_string('boards/api_post.html', context) | |||
elif format_type == DIFF_TYPE_JSON: | |||
post_json = { | |||
'id': self.id, | |||
'title': self.title, | |||
'text': self.text.rendered, | |||
} | |||
if self.images.exists(): | |||
post_image = self.get_first_image() | |||
post_json['image'] = post_image.image.url | |||
post_json['image_preview'] = post_image.image.url_200x150 | |||
if include_last_update: | |||
post_json['bump_time'] = datetime_to_epoch( | |||
self.thread_new.bump_time) | |||
return post_json | |||
def send_to_websocket(self, request, recursive=True): | |||
""" | |||
Sends post HTML data to the thread web socket. | |||
""" | |||
if not settings.WEBSOCKETS_ENABLED: | |||
return | |||
client = Client() | |||
channel_name = WS_CHANNEL_THREAD + str(self.get_thread().get_opening_post_id()) | |||
client.publish(channel_name, { | |||
'html': self.get_post_data( | |||
format_type=DIFF_TYPE_HTML, | |||
request=request), | |||
'diff_type': 'added' if recursive else 'updated', | |||
}) | |||
client.send() | |||
logger.info('Sent post #{} to channel {}'.format(self.id, channel_name)) | |||
if recursive: | |||
for reply_number in re.finditer(REGEX_REPLY, self.text.raw): | |||
post_id = reply_number.group(1) | |||
ref_post = Post.objects.filter(id=post_id)[0] | |||
ref_post.send_to_websocket(request, recursive=False) |