|
|
from datetime import datetime, timedelta
|
|
|
from datetime import time as dtime
|
|
|
import os
|
|
|
from random import random
|
|
|
import time
|
|
|
import math
|
|
|
import re
|
|
|
from django.core.cache import cache
|
|
|
|
|
|
from django.db import models
|
|
|
from django.http import Http404
|
|
|
from django.utils import timezone
|
|
|
from markupfield.fields import MarkupField
|
|
|
|
|
|
from neboard import settings
|
|
|
from boards import thumbs
|
|
|
|
|
|
APP_LABEL_BOARDS = 'boards'
|
|
|
|
|
|
CACHE_KEY_PPD = 'ppd'
|
|
|
|
|
|
POSTS_PER_DAY_RANGE = range(7)
|
|
|
|
|
|
BAN_REASON_AUTO = 'Auto'
|
|
|
|
|
|
IMAGE_THUMB_SIZE = (200, 150)
|
|
|
|
|
|
TITLE_MAX_LENGTH = 50
|
|
|
|
|
|
DEFAULT_MARKUP_TYPE = 'markdown'
|
|
|
|
|
|
NO_PARENT = -1
|
|
|
NO_IP = '0.0.0.0'
|
|
|
UNKNOWN_UA = ''
|
|
|
ALL_PAGES = -1
|
|
|
IMAGES_DIRECTORY = 'images/'
|
|
|
FILE_EXTENSION_DELIMITER = '.'
|
|
|
|
|
|
SETTING_MODERATE = "moderate"
|
|
|
|
|
|
REGEX_REPLY = re.compile('>>(\d+)')
|
|
|
|
|
|
|
|
|
class PostManager(models.Manager):
|
|
|
|
|
|
def create_post(self, title, text, image=None, thread=None,
|
|
|
ip=NO_IP, tags=None, user=None):
|
|
|
"""
|
|
|
Create new post
|
|
|
"""
|
|
|
|
|
|
posting_time = timezone.now()
|
|
|
if not thread:
|
|
|
thread = Thread.objects.create(bump_time=posting_time,
|
|
|
last_edit_time=posting_time)
|
|
|
else:
|
|
|
thread.bump()
|
|
|
thread.last_edit_time = posting_time
|
|
|
thread.save()
|
|
|
|
|
|
post = self.create(title=title,
|
|
|
text=text,
|
|
|
pub_time=posting_time,
|
|
|
thread_new=thread,
|
|
|
image=image,
|
|
|
poster_ip=ip,
|
|
|
poster_user_agent=UNKNOWN_UA, # TODO Get UA at last!
|
|
|
last_edit_time=posting_time,
|
|
|
user=user)
|
|
|
|
|
|
thread.replies.add(post)
|
|
|
if tags:
|
|
|
linked_tags = []
|
|
|
for tag in tags:
|
|
|
tag_linked_tags = tag.get_linked_tags()
|
|
|
if len(tag_linked_tags) > 0:
|
|
|
linked_tags.extend(tag_linked_tags)
|
|
|
|
|
|
tags.extend(linked_tags)
|
|
|
map(thread.add_tag, tags)
|
|
|
|
|
|
self._delete_old_threads()
|
|
|
self.connect_replies(post)
|
|
|
|
|
|
return post
|
|
|
|
|
|
def delete_post(self, post):
|
|
|
"""
|
|
|
Delete post and update or delete its thread
|
|
|
"""
|
|
|
|
|
|
thread = post.thread_new
|
|
|
|
|
|
if thread.get_opening_post() == self:
|
|
|
thread.replies.delete()
|
|
|
|
|
|
thread.delete()
|
|
|
else:
|
|
|
thread.last_edit_time = timezone.now()
|
|
|
thread.save()
|
|
|
|
|
|
post.delete()
|
|
|
|
|
|
def delete_posts_by_ip(self, ip):
|
|
|
"""
|
|
|
Delete all posts of the author with same IP
|
|
|
"""
|
|
|
|
|
|
posts = self.filter(poster_ip=ip)
|
|
|
map(self.delete_post, posts)
|
|
|
|
|
|
# TODO Move this method to thread manager
|
|
|
def get_threads(self, tag=None, page=ALL_PAGES,
|
|
|
order_by='-bump_time'):
|
|
|
if tag:
|
|
|
threads = tag.threads
|
|
|
|
|
|
if not threads.exists():
|
|
|
raise Http404
|
|
|
else:
|
|
|
threads = Thread.objects.all()
|
|
|
|
|
|
threads = threads.order_by(order_by)
|
|
|
|
|
|
if page != ALL_PAGES:
|
|
|
thread_count = threads.count()
|
|
|
|
|
|
if page < self._get_page_count(thread_count):
|
|
|
start_thread = page * settings.THREADS_PER_PAGE
|
|
|
end_thread = min(start_thread + settings.THREADS_PER_PAGE,
|
|
|
thread_count)
|
|
|
threads = threads[start_thread:end_thread]
|
|
|
|
|
|
return threads
|
|
|
|
|
|
# TODO Move this method to thread manager
|
|
|
def get_thread_page_count(self, tag=None):
|
|
|
if tag:
|
|
|
threads = Thread.objects.filter(tags=tag)
|
|
|
else:
|
|
|
threads = Thread.objects.all()
|
|
|
|
|
|
return self._get_page_count(threads.count())
|
|
|
|
|
|
# TODO Move this method to thread manager
|
|
|
def _delete_old_threads(self):
|
|
|
"""
|
|
|
Preserves maximum thread count. If there are too many threads,
|
|
|
delete the old ones.
|
|
|
"""
|
|
|
|
|
|
# TODO Move old threads to the archive instead of deleting them.
|
|
|
# Maybe make some 'old' field in the model to indicate the thread
|
|
|
# must not be shown and be able for replying.
|
|
|
|
|
|
threads = self.get_threads()
|
|
|
thread_count = threads.count()
|
|
|
|
|
|
if thread_count > settings.MAX_THREAD_COUNT:
|
|
|
num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
|
|
|
old_threads = threads[thread_count - num_threads_to_delete:]
|
|
|
|
|
|
map(Thread.delete_with_posts, old_threads)
|
|
|
|
|
|
def connect_replies(self, post):
|
|
|
"""
|
|
|
Connect replies to a post to show them as a reflink map
|
|
|
"""
|
|
|
|
|
|
for reply_number in re.finditer(REGEX_REPLY, post.text.raw):
|
|
|
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
|
|
|
referenced_post.save()
|
|
|
|
|
|
def _get_page_count(self, thread_count):
|
|
|
"""
|
|
|
Get number of pages that will be needed for all threads
|
|
|
"""
|
|
|
|
|
|
return int(math.ceil(thread_count / float(settings.THREADS_PER_PAGE)))
|
|
|
|
|
|
def get_posts_per_day(self):
|
|
|
"""
|
|
|
Get average count of posts per day for the last 7 days
|
|
|
"""
|
|
|
|
|
|
today = datetime.now().date()
|
|
|
ppd = cache.get(CACHE_KEY_PPD + str(today))
|
|
|
if ppd:
|
|
|
return ppd
|
|
|
|
|
|
posts_per_days = []
|
|
|
for i in POSTS_PER_DAY_RANGE:
|
|
|
day_end = today - timedelta(i + 1)
|
|
|
day_start = today - timedelta(i + 2)
|
|
|
|
|
|
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())
|
|
|
|
|
|
posts_per_days.append(float(self.filter(
|
|
|
pub_time__lte=day_time_end,
|
|
|
pub_time__gte=day_time_start).count()))
|
|
|
|
|
|
ppd = (sum(posts_per_day for posts_per_day in posts_per_days) /
|
|
|
len(posts_per_days))
|
|
|
cache.set(CACHE_KEY_PPD, ppd)
|
|
|
return ppd
|
|
|
|
|
|
|
|
|
class Post(models.Model):
|
|
|
"""A post is a message."""
|
|
|
|
|
|
objects = PostManager()
|
|
|
|
|
|
class Meta:
|
|
|
app_label = APP_LABEL_BOARDS
|
|
|
|
|
|
# TODO Save original file name to some field
|
|
|
def _update_image_filename(self, filename):
|
|
|
"""Get unique image filename"""
|
|
|
|
|
|
path = IMAGES_DIRECTORY
|
|
|
new_name = str(int(time.mktime(time.gmtime())))
|
|
|
new_name += str(int(random() * 1000))
|
|
|
new_name += FILE_EXTENSION_DELIMITER
|
|
|
new_name += filename.split(FILE_EXTENSION_DELIMITER)[-1:][0]
|
|
|
|
|
|
return os.path.join(path, new_name)
|
|
|
|
|
|
title = models.CharField(max_length=TITLE_MAX_LENGTH)
|
|
|
pub_time = models.DateTimeField()
|
|
|
text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
|
|
|
escape_html=False)
|
|
|
|
|
|
image_width = models.IntegerField(default=0)
|
|
|
image_height = models.IntegerField(default=0)
|
|
|
|
|
|
image_pre_width = models.IntegerField(default=0)
|
|
|
image_pre_height = models.IntegerField(default=0)
|
|
|
|
|
|
image = thumbs.ImageWithThumbsField(upload_to=_update_image_filename,
|
|
|
blank=True, sizes=(IMAGE_THUMB_SIZE,),
|
|
|
width_field='image_width',
|
|
|
height_field='image_height',
|
|
|
preview_width_field='image_pre_width',
|
|
|
preview_height_field='image_pre_height')
|
|
|
|
|
|
poster_ip = models.GenericIPAddressField()
|
|
|
poster_user_agent = models.TextField()
|
|
|
|
|
|
thread = models.ForeignKey('Post', null=True, default=None)
|
|
|
thread_new = models.ForeignKey('Thread', null=True, default=None)
|
|
|
last_edit_time = models.DateTimeField()
|
|
|
user = models.ForeignKey('User', null=True, default=None)
|
|
|
|
|
|
referenced_posts = models.ManyToManyField('Post', symmetrical=False,
|
|
|
null=True,
|
|
|
blank=True, related_name='rfp+')
|
|
|
|
|
|
def __unicode__(self):
|
|
|
return '#' + str(self.id) + ' ' + self.title + ' (' + \
|
|
|
self.text.raw[:50] + ')'
|
|
|
|
|
|
def get_title(self):
|
|
|
title = self.title
|
|
|
if len(title) == 0:
|
|
|
title = self.text.raw[:20]
|
|
|
|
|
|
return title
|
|
|
|
|
|
def get_sorted_referenced_posts(self):
|
|
|
return self.referenced_posts.order_by('id')
|
|
|
|
|
|
def is_referenced(self):
|
|
|
return self.referenced_posts.all().exists()
|
|
|
|
|
|
def is_opening(self):
|
|
|
return self.thread_new.get_replies()[0] == self
|
|
|
|
|
|
|
|
|
class Thread(models.Model):
|
|
|
|
|
|
class Meta:
|
|
|
app_label = APP_LABEL_BOARDS
|
|
|
|
|
|
tags = models.ManyToManyField('Tag')
|
|
|
bump_time = models.DateTimeField()
|
|
|
last_edit_time = models.DateTimeField()
|
|
|
replies = models.ManyToManyField('Post', symmetrical=False, null=True,
|
|
|
blank=True, related_name='tre+')
|
|
|
|
|
|
def get_tags(self):
|
|
|
"""
|
|
|
Get a sorted tag list
|
|
|
"""
|
|
|
|
|
|
return self.tags.order_by('name')
|
|
|
|
|
|
def bump(self):
|
|
|
"""
|
|
|
Bump (move to up) thread
|
|
|
"""
|
|
|
|
|
|
if self.can_bump():
|
|
|
self.bump_time = timezone.now()
|
|
|
|
|
|
def get_reply_count(self):
|
|
|
return self.replies.count()
|
|
|
|
|
|
def get_images_count(self):
|
|
|
return self.replies.filter(image_width__gt=0).count()
|
|
|
|
|
|
def can_bump(self):
|
|
|
"""
|
|
|
Check if the thread can be bumped by replying
|
|
|
"""
|
|
|
|
|
|
post_count = self.get_reply_count()
|
|
|
|
|
|
return post_count < settings.MAX_POSTS_PER_THREAD
|
|
|
|
|
|
def delete_with_posts(self):
|
|
|
"""
|
|
|
Completely delete thread and all its posts
|
|
|
"""
|
|
|
|
|
|
if self.replies.count() > 0:
|
|
|
self.replies.all().delete()
|
|
|
|
|
|
self.delete()
|
|
|
|
|
|
def get_last_replies(self):
|
|
|
"""
|
|
|
Get last replies, not including opening post
|
|
|
"""
|
|
|
|
|
|
if settings.LAST_REPLIES_COUNT > 0:
|
|
|
reply_count = self.get_reply_count()
|
|
|
|
|
|
if reply_count > 0:
|
|
|
reply_count_to_show = min(settings.LAST_REPLIES_COUNT,
|
|
|
reply_count - 1)
|
|
|
last_replies = self.replies.all().order_by('pub_time')[
|
|
|
reply_count - reply_count_to_show:]
|
|
|
|
|
|
return last_replies
|
|
|
|
|
|
def get_replies(self):
|
|
|
"""
|
|
|
Get sorted thread posts
|
|
|
"""
|
|
|
|
|
|
return self.replies.all().order_by('pub_time')
|
|
|
|
|
|
def add_tag(self, tag):
|
|
|
"""
|
|
|
Connect thread to a tag and tag to a thread
|
|
|
"""
|
|
|
|
|
|
self.tags.add(tag)
|
|
|
tag.threads.add(self)
|
|
|
|
|
|
def get_opening_post(self):
|
|
|
"""
|
|
|
Get first post of the thread
|
|
|
"""
|
|
|
|
|
|
return self.get_replies()[0]
|
|
|
|
|
|
def __unicode__(self):
|
|
|
return str(self.get_replies()[0].id)
|
|
|
|
|
|
def get_pub_time(self):
|
|
|
"""
|
|
|
Thread does not have its own pub time, so we need to get it from
|
|
|
the opening post
|
|
|
"""
|
|
|
|
|
|
return self.get_opening_post().pub_time
|
|
|
|
