post.py
447 lines
| 13.7 KiB
| text/x-python
|
PythonLexer
|
r586 | from datetime import datetime, timedelta, date | ||
|
r407 | from datetime import time as dtime | ||
|
r639 | import logging | ||
|
r386 | import re | ||
|
r527 | |||
|
r881 | from adjacent import Client | ||
|
r410 | from django.core.cache import cache | ||
|
r589 | from django.core.urlresolvers import reverse | ||
|
r566 | from django.db import models, transaction | ||
|
r881 | from django.db.models import TextField | ||
|
r692 | from django.template.loader import render_to_string | ||
|
r384 | from django.utils import timezone | ||
|
r881 | |||
|
r853 | from boards import settings | ||
|
r881 | from boards.mdx_neboard import bbcode_extended | ||
|
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 | |||
|
r917 | |||
|
r915 | WS_NOTIFICATION_TYPE_NEW_POST = 'new_post' | ||
WS_NOTIFICATION_TYPE = 'notification_type' | ||||
|
r881 | |||
|
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 | |||
|
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' | ||||
|
r917 | PARAMETER_BUMPABLE = 'bumpable' | ||
PARAMETER_THREAD = 'thread' | ||||
PARAMETER_IS_OPENING = 'is_opening' | ||||
PARAMETER_MODERATOR = 'moderator' | ||||
PARAMETER_POST = 'post' | ||||
PARAMETER_OP_ID = 'opening_post_id' | ||||
PARAMETER_NEED_OPEN_LINK = 'need_open_link' | ||||
|
r853 | |||
DIFF_TYPE_HTML = 'html' | ||||
DIFF_TYPE_JSON = 'json' | ||||
|
r865 | PREPARSE_PATTERNS = { | ||
|
r886 | r'>>(\d+)': r'[post]\1[/post]', # Reflink ">>123" | ||
|
r926 | r'^>([^>].+)': r'[quote]\1[/quote]', # Quote ">text" | ||
|
r888 | r'^//(.+)': r'[comment]\1[/comment]', # Comment "//text" | ||
|
r865 | } | ||
|
r384 | |||
class PostManager(models.Manager): | ||||
|
r915 | @transaction.atomic | ||
def create_post(self, title: str, text: str, image=None, thread=None, | ||||
ip=NO_IP, tags: list=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: | ||
|
r615 | new_thread = False | ||
|
r384 | |||
|
r865 | pre_text = self._preparse_text(text) | ||
|
r384 | post = self.create(title=title, | ||
|
r865 | text=pre_text, | ||
|
r384 | 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 | |||
|
r868 | logger = logging.getLogger('boards.post.create') | ||
|
r866 | |||
|
r888 | logger.info('Created post {} by {}'.format( | ||
post, post.poster_ip)) | ||||
|
r850 | |||
|
r693 | if image: | ||
|
r944 | # Try to find existing image. If it exists, assign it to the post | ||
# instead of createing the new one | ||||
image_hash = PostImage.get_hash(image) | ||||
existing = PostImage.objects.filter(hash=image_hash) | ||||
if len(existing) > 0: | ||||
post_image = existing[0] | ||||
else: | ||||
post_image = PostImage.objects.create(image=image) | ||||
logger.info('Created new image #{} for post #{}'.format( | ||||
post_image.id, post.id)) | ||||
|
r693 | post.images.add(post_image) | ||
|
r398 | thread.replies.add(post) | ||
|
r770 | list(map(thread.add_tag, tags)) | ||
|
r384 | |||
|
r615 | if new_thread: | ||
|
r716 | Thread.objects.process_oldest_threads() | ||
|
r885 | else: | ||
thread.bump() | ||||
thread.last_edit_time = posting_time | ||||
thread.save() | ||||
|
r384 | self.connect_replies(post) | ||
return post | ||||
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: | ||
|
r880 | post.delete() | ||
|
r384 | |||
|
r853 | def connect_replies(self, post): | ||
|
r418 | """ | ||
|
r622 | Connects replies to a post to show them as a reflink map | ||
|
r418 | """ | ||
|
r384 | |||
|
r881 | for reply_number in re.finditer(REGEX_REPLY, post.get_raw_text()): | ||
|
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 | |||
|
r949 | 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 | |||
|
r865 | def _preparse_text(self, text): | ||
""" | ||||
Preparses text to change patterns like '>>' to a proper bbcode | ||||
tags. | ||||
""" | ||||
for key, value in PREPARSE_PATTERNS.items(): | ||||
|
r887 | text = re.sub(key, value, text, flags=re.MULTILINE) | ||
|
r865 | |||
return text | ||||
|
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() | ||||
|
r881 | text = TextField(blank=True, null=True) | ||
_text_rendered = TextField(blank=True, null=True, editable=False) | ||||
|
r384 | |||
|
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 | |||
|
r875 | def __str__(self): | ||
|
r878 | return 'P#{}/{}'.format(self.id, self.title) | ||
|
r384 | |||
|
r911 | def get_title(self) -> str: | ||
|
r622 | """ | ||
Gets original post title or part of its text. | ||||
""" | ||||
|
r384 | title = self.title | ||
|
r618 | if not title: | ||
|
r881 | title = self.get_text() | ||
|
r384 | |||
return title | ||||
|
r911 | def build_refmap(self) -> None: | ||
|
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 | |||
|
r911 | def is_referenced(self) -> bool: | ||
|
r872 | if not self.refmap: | ||
return False | ||||
else: | ||||
return len(self.refmap) > 0 | ||||
|
r398 | |||
|
r911 | def is_opening(self) -> bool: | ||
|
r622 | """ | ||
Checks if this is an opening post or just a reply. | ||||
""" | ||||
|
r949 | return self.get_thread().get_opening_post_id() == self.id | ||
|
r400 | |||
|
r566 | @transaction.atomic | ||
def add_tag(self, tag): | ||||
edit_time = timezone.now() | ||||
|
r949 | 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 | |||
|
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: | ||
|
r949 | thread = self.get_thread() | ||
|
r625 | |||
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 | ||||
|
r911 | def get_thread(self) -> Thread: | ||
|
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_view(self, moderator=False, need_open_link=False, | ||||
truncated=False, *args, **kwargs): | ||||
|
r917 | """ | ||
Renders post's HTML view. Some of the post params can be passed over | ||||
kwargs for the means of caching (if we view the thread, some params | ||||
are same for every post and don't need to be computed over and over. | ||||
""" | ||||
|
r692 | |||
|
r917 | is_opening = kwargs.get(PARAMETER_IS_OPENING, self.is_opening()) | ||
|
r949 | thread = kwargs.get(PARAMETER_THREAD, self.get_thread()) | ||
|
r917 | can_bump = kwargs.get(PARAMETER_BUMPABLE, thread.can_bump()) | ||
|
r692 | |||
|
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', { | ||||
|
r917 | PARAMETER_POST: self, | ||
PARAMETER_MODERATOR: moderator, | ||||
PARAMETER_IS_OPENING: is_opening, | ||||
PARAMETER_THREAD: thread, | ||||
PARAMETER_BUMPABLE: can_bump, | ||||
PARAMETER_NEED_OPEN_LINK: need_open_link, | ||||
PARAMETER_TRUNCATED: truncated, | ||||
PARAMETER_OP_ID: opening_post_id, | ||||
|
r692 | }) | ||
|
r922 | def get_search_view(self, *args, **kwargs): | ||
return self.get_view(args, kwargs) | ||||
|
r911 | def get_first_image(self) -> PostImage: | ||
|
r693 | return self.images.earliest('id') | ||
|
r715 | def delete(self, using=None): | ||
""" | ||||
|
r950 | Deletes all post images and the post itself. | ||
|
r715 | """ | ||
|
r944 | for image in self.images.all(): | ||
image_refs_count = Post.objects.filter(images__in=[image]).count() | ||||
if image_refs_count == 1: | ||||
image.delete() | ||||
|
r715 | |||
|
r950 | thread = self.get_thread() | ||
thread.last_edit_time = timezone.now() | ||||
thread.save() | ||||
|
r880 | |||
|
r884 | super(Post, self).delete(using) | ||
|
r880 | |||
logging.getLogger('boards.post.delete').info( | ||||
|
r888 | 'Deleted post {}'.format(self)) | ||
|
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: | ||||
|
r917 | params = dict() | ||
params['post'] = self | ||||
|
r853 | if PARAMETER_TRUNCATED in request.GET: | ||
|
r917 | params[PARAMETER_TRUNCATED] = True | ||
|
r853 | |||
|
r917 | return render_to_string('boards/api_post.html', params) | ||
|
r853 | elif format_type == DIFF_TYPE_JSON: | ||
post_json = { | ||||
'id': self.id, | ||||
'title': self.title, | ||||
|
r886 | 'text': self._text_rendered, | ||
|
r853 | } | ||
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() | ||||
|
r949 | thread = self.get_thread() | ||
|
r915 | thread_id = thread.id | ||
channel_name = WS_CHANNEL_THREAD + str(thread.get_opening_post_id()) | ||||
|
r853 | client.publish(channel_name, { | ||
|
r915 | WS_NOTIFICATION_TYPE: WS_NOTIFICATION_TYPE_NEW_POST, | ||
|
r853 | }) | ||
client.send() | ||||
|
r868 | logger = logging.getLogger('boards.post.websocket') | ||
|
r866 | |||
|
r915 | logger.info('Sent notification from post #{} to channel {}'.format( | ||
self.id, channel_name)) | ||||
|
r853 | |||
if recursive: | ||||
|
r881 | for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()): | ||
|
r853 | post_id = reply_number.group(1) | ||
ref_post = Post.objects.filter(id=post_id)[0] | ||||
|
r915 | # If post is in this thread, its thread was already notified. | ||
# Otherwise, notify its thread separately. | ||||
|
r916 | if ref_post.thread_new_id != thread_id: | ||
|
r915 | ref_post.send_to_websocket(request, recursive=False) | ||
|
r881 | |||
def save(self, force_insert=False, force_update=False, using=None, | ||||
update_fields=None): | ||||
self._text_rendered = bbcode_extended(self.get_raw_text()) | ||||
super().save(force_insert, force_update, using, update_fields) | ||||
|
r911 | def get_text(self) -> str: | ||
|
r881 | return self._text_rendered | ||
|
r911 | def get_raw_text(self) -> str: | ||
|
r881 | return self.text | ||