import logging from adjacent import Client from django.db.models import Count, Sum from django.utils import timezone from django.db import models from boards import settings import boards from boards.utils import cached_result, datetime_to_epoch from boards.models.post import Post from boards.models.tag import Tag __author__ = 'neko259' logger = logging.getLogger(__name__) WS_NOTIFICATION_TYPE_NEW_POST = 'new_post' WS_NOTIFICATION_TYPE = 'notification_type' WS_CHANNEL_THREAD = "thread:" class ThreadManager(models.Manager): def process_oldest_threads(self): """ Preserves maximum thread count. If there are too many threads, archive or delete the old ones. """ threads = Thread.objects.filter(archived=False).order_by('-bump_time') 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:] for thread in old_threads: if settings.ARCHIVE_THREADS: self._archive_thread(thread) else: thread.delete() logger.info('Processed %d old threads' % num_threads_to_delete) def _archive_thread(self, thread): thread.archived = True thread.bumpable = False thread.last_edit_time = timezone.now() thread.update_posts_time() thread.save(update_fields=['archived', 'last_edit_time', 'bumpable']) def get_thread_max_posts(): return settings.MAX_POSTS_PER_THREAD class Thread(models.Model): objects = ThreadManager() class Meta: app_label = 'boards' tags = models.ManyToManyField('Tag') bump_time = models.DateTimeField(db_index=True) last_edit_time = models.DateTimeField() archived = models.BooleanField(default=False) bumpable = models.BooleanField(default=True) max_posts = models.IntegerField(default=get_thread_max_posts) def get_tags(self) -> list: """ Gets a sorted tag list. """ return self.tags.order_by('name') def bump(self): """ Bumps (moves to up) thread if possible. """ if self.can_bump(): self.bump_time = self.last_edit_time self.update_bump_status() logger.info('Bumped thread %d' % self.id) def has_post_limit(self) -> bool: return self.max_posts > 0 def update_bump_status(self, exclude_posts=None): if self.has_post_limit() and self.get_reply_count() >= self.max_posts: self.bumpable = False self.update_posts_time(exclude_posts=exclude_posts) def _get_cache_key(self): return [datetime_to_epoch(self.last_edit_time)] @cached_result(key_method=_get_cache_key) def get_reply_count(self) -> int: return self.get_replies().count() @cached_result(key_method=_get_cache_key) def get_images_count(self) -> int: return self.get_replies().annotate(images_count=Count( 'images')).aggregate(Sum('images_count'))['images_count__sum'] def can_bump(self) -> bool: """ Checks if the thread can be bumped by replying to it. """ return self.bumpable and not self.archived def get_last_replies(self) -> list: """ Gets several 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) replies = self.get_replies() last_replies = replies[reply_count - reply_count_to_show:] return last_replies def get_skipped_replies_count(self) -> int: """ Gets number of posts between opening post and last replies. """ reply_count = self.get_reply_count() last_replies_count = min(settings.LAST_REPLIES_COUNT, reply_count - 1) return reply_count - last_replies_count - 1 def get_replies(self, view_fields_only=False) -> list: """ Gets sorted thread posts """ query = Post.objects.filter(threads__in=[self]) query = query.order_by('pub_time').prefetch_related('images', 'thread', 'threads') if view_fields_only: query = query.defer('poster_ip') return query.all() def get_replies_with_images(self, view_fields_only=False) -> list: """ Gets replies that have at least one image attached """ return self.get_replies(view_fields_only).annotate(images_count=Count( 'images')).filter(images_count__gt=0) # TODO Do we still need this? def add_tag(self, tag: Tag): """ Connects thread to a tag and tag to a thread """ self.tags.add(tag) def get_opening_post(self, only_id=False) -> Post: """ Gets the first post of the thread """ query = self.get_replies().order_by('pub_time') if only_id: query = query.only('id') opening_post = query.first() return opening_post @cached_result() def get_opening_post_id(self) -> int: """ Gets ID of the first thread post. """ return self.get_opening_post(only_id=True).id def get_pub_time(self): """ Gets opening post's pub time because thread does not have its own one. """ return self.get_opening_post().pub_time def delete(self, using=None): """ Deletes thread with all replies. """ for reply in self.get_replies().all(): reply.delete() super(Thread, self).delete(using) def __str__(self): return 'T#{}/{}'.format(self.id, self.get_opening_post_id()) def get_tag_url_list(self) -> list: return boards.models.Tag.objects.get_tag_url_list(self.get_tags()) def update_posts_time(self, exclude_posts=None): for post in self.post_set.all(): if exclude_posts is not None and post not in exclude_posts: # Manual update is required because uids are generated on save post.last_edit_time = self.last_edit_time post.save(update_fields=['last_edit_time']) post.threads.update(last_edit_time=self.last_edit_time) def notify_clients(self): if not settings.WEBSOCKETS_ENABLED: return client = Client() channel_name = WS_CHANNEL_THREAD + str(self.get_opening_post_id()) client.publish(channel_name, { WS_NOTIFICATION_TYPE: WS_NOTIFICATION_TYPE_NEW_POST, }) client.send()