Do not load fav tags when need to only check notifications

boards/abstracts/settingsmanager.py

@@ -1,252 +1,255 b''
 import boards
 from boards.models import Tag, TagAlias, Attachment
 from boards.models.attachment import AttachmentSticker
 from boards.models.user import UserSettings
 
 MAX_TRIPCODE_COLLISIONS = 50
 
 __author__ = 'neko259'
 
 SESSION_SETTING = 'setting'
 
 SETTING_THEME = 'theme'
 SETTING_FAVORITE_TAGS = 'favorite_tags'
 SETTING_FAVORITE_THREADS = 'favorite_threads'
 SETTING_HIDDEN_TAGS = 'hidden_tags'
 SETTING_USERNAME = 'username'
 SETTING_LAST_NOTIFICATION_ID = 'last_notification'
 SETTING_IMAGE_VIEWER = 'image_viewer'
 SETTING_IMAGES = 'images_aliases'
 SETTING_ONLY_FAVORITES = 'only_favorites'
 SETTING_LAST_POSTS = 'last_posts'
 
 DEFAULT_THEME = 'md'
 
 
 class SettingsManager:
     """
     Base settings manager class. get_setting and set_setting methods should
     be overriden.
     """
     def __init__(self):
         pass
 
     def get_theme(self) -> str:
         theme = self.get_setting(SETTING_THEME)
         if not theme:
             theme = DEFAULT_THEME
             self.set_setting(SETTING_THEME, theme)
 
         return theme
 
     def set_theme(self, theme):
         self.set_setting(SETTING_THEME, theme)
 
     def get_setting(self, setting, default=None):
         pass
 
     def set_setting(self, setting, value):
         pass
 
     def get_fav_tags(self) -> list:
         tag_names = self.get_setting(SETTING_FAVORITE_TAGS)
         tags = []
         if tag_names:
             tags = list(Tag.objects.filter(aliases__in=TagAlias.objects
                 .filter_localized(parent__aliases__name__in=tag_names))
                 .order_by('aliases__name'))
         return tags
 
     def add_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if not tags:
             tags = [tag.get_name()]
         else:
             if not tag.get_name() in tags:
                 tags.append(tag.get_name())
 
         tags.sort()
         self.set_setting(SETTING_FAVORITE_TAGS, tags)
 
     def del_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if tag.get_name() in tags:
             tags.remove(tag.get_name())
             self.set_setting(SETTING_FAVORITE_TAGS, tags)
 
     def get_hidden_tags(self) -> list:
         tag_names = self.get_setting(SETTING_HIDDEN_TAGS)
         tags = []
         if tag_names:
             tags = list(Tag.objects.filter(aliases__in=TagAlias.objects
                 .filter_localized(parent__aliases__name__in=tag_names))
                 .order_by('aliases__name'))
 
         return tags
 
     def add_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if not tags:
             tags = [tag.get_name()]
         else:
             if not tag.get_name() in tags:
                 tags.append(tag.get_name())
 
         tags.sort()
         self.set_setting(SETTING_HIDDEN_TAGS, tags)
 
     def del_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if tag.get_name() in tags:
             tags.remove(tag.get_name())
             self.set_setting(SETTING_HIDDEN_TAGS, tags)
 
     def add_or_read_fav_thread(self, opening_post):
         last_post_ids = self.get_setting(SETTING_LAST_POSTS)
         if not last_post_ids:
             last_post_ids = []
 
         self.del_fav_thread(opening_post)
         
         last_post_id = opening_post.get_thread().get_replies().last().id
         last_post_ids.append(last_post_id)
 
         self.set_setting(SETTING_LAST_POSTS, last_post_ids)
 
     def del_fav_thread(self, opening_post):
         last_posts_ids = self.get_setting(SETTING_LAST_POSTS)
 
         for post in self.get_last_posts():
             if post.get_thread() == opening_post.get_thread():
                 last_posts_ids.remove(post.id)
 
         self.set_setting(SETTING_LAST_POSTS, last_posts_ids)
 
     def thread_is_fav(self, opening_post):
         for post in self.get_last_posts():
             if post.get_thread() == opening_post.get_thread():
                 return True
         return False
 
     def get_notification_usernames(self):
         names = set()
         name_list = self.get_setting(SETTING_USERNAME)
         if name_list is not None:
             name_list = name_list.strip()
             if len(name_list) > 0:
                 names = name_list.lower().split(',')
                 names = set(name.strip() for name in names)
         return names
 
     def get_attachment_by_alias(self, alias):
         images = self.get_setting(SETTING_IMAGES)
         if images and alias in images:
             try:
                 return Attachment.objects.get(id=images.get(alias))
             except Attachment.DoesNotExist:
                 self.remove_attachment_alias(alias)
 
     def add_attachment_alias(self, alias, attachment):
         images = self.get_setting(SETTING_IMAGES)
         if images is None:
             images = dict()
         images[alias] = attachment.id
         self.set_setting(SETTING_IMAGES, images)
 
     def remove_attachment_alias(self, alias):
         images = self.get_setting(SETTING_IMAGES)
         del images[alias]
         self.set_setting(SETTING_IMAGES, images)
 
     def get_stickers(self):
         images = self.get_setting(SETTING_IMAGES)
         stickers = []
         if images:
             for key, value in images.items():
                 try:
                     attachment = Attachment.objects.get(id=value)
                     stickers.append(AttachmentSticker(name=key, attachment=attachment))
                 except Attachment.DoesNotExist:
                     self.remove_attachment_alias(key)
         return stickers
 
     def tag_is_fav(self, tag):
         fav_tag_names = self.get_setting(SETTING_FAVORITE_TAGS)
         return fav_tag_names is not None and tag.get_name() in fav_tag_names
 
     def tag_is_hidden(self, tag):
         hidden_tag_names = self.get_setting(SETTING_HIDDEN_TAGS)
         return hidden_tag_names is not None and tag.get_name() in hidden_tag_names
 
     def get_last_posts(self):
         post_ids = self.get_setting(SETTING_LAST_POSTS) or []
         return list(boards.models.Post.objects.filter(id__in=post_ids).order_by('thread__id'))
 
 
 class SessionSettingsManager(SettingsManager):
     """
     Session-based settings manager. All settings are saved to the user's
     session.
     """
     def __init__(self, session):
         SettingsManager.__init__(self)
         self.session = session
 
     def get_setting(self, setting, default=None):
         if setting in self.session:
             return self.session[setting]
         else:
             self.set_setting(setting, default)
             return default
 
     def set_setting(self, setting, value):
         self.session[setting] = value
 
 
 class DatabaseSettingsManager(SessionSettingsManager):
     def __init__(self, session):
         super().__init__(session)
 
         # First time a user accesses the server, his session is not saved
         # and does not have the key yet. In order to create the settings object
         # we need to save it manually
         if not session.session_key:
             session.save()
 
         self.settings, created = UserSettings.objects.get_or_create(session_key=session.session_key)
 
     def add_fav_tag(self, tag):
         self.settings.fav_tags.add(tag)
 
     def del_fav_tag(self, tag):
         self.settings.fav_tags.remove(tag)
 
     def get_fav_tags(self) -> list:
         return self.settings.fav_tags.filter(
             aliases__in=TagAlias.objects.filter_localized())\
             .order_by('aliases__name')
 
     def get_hidden_tags(self) -> list:
         return self.settings.hidden_tags.all()
 
     def add_hidden_tag(self, tag):
         self.settings.hidden_tags.add(tag)
         
     def del_hidden_tag(self, tag):
         self.settings.hidden_tags.remove(tag)
 
     def tag_is_fav(self, tag):
         return self.settings.fav_tags.filter(id=tag.id).exists()
 
     def tag_is_hidden(self, tag):
         return self.settings.hidden_tags.filter(id=tag.id).exists()
 
+    def get_user_settings(self):
+        return self.settings
+
 
 def get_settings_manager(request) -> SettingsManager:
     """
     Get settings manager based on the request object. Currently database-based
     settings manager is implemented over the session-based one (settings that
     are not connected to the database in any way are stored in session). Pure
     session-based manager is also supported but not used by default.
     """
     return DatabaseSettingsManager(request.session)

boards/context_processors.py

@@ -1,84 +1,84 b''
 from boards.abstracts.settingsmanager import get_settings_manager, \
     SETTING_LAST_NOTIFICATION_ID, SETTING_IMAGE_VIEWER, SETTING_ONLY_FAVORITES
 from boards.models import Banner
 from boards.models.user import Notification
 from boards import settings
 from boards.models import Post, Tag, Thread
 from boards.settings import SECTION_FORMS, SECTION_VIEW, SECTION_VERSION
 
 THEME_CSS = 'css/{}/base_page.css'
 
 CONTEXT_SITE_NAME = 'site_name'
 CONTEXT_VERSION = 'version'
 CONTEXT_THEME_CSS = 'theme_css'
 CONTEXT_THEME = 'theme'
 CONTEXT_PPD = 'posts_per_day'
 CONTEXT_USER = 'user'
 CONTEXT_NEW_NOTIFICATIONS_COUNT = 'new_notifications_count'
 CONTEXT_USERNAMES = 'usernames'
 CONTEXT_TAGS_STR = 'tags_str'
 CONTEXT_IMAGE_VIEWER = 'image_viewer'
 CONTEXT_HAS_FAV_THREADS = 'has_fav_threads'
 CONTEXT_POW_DIFFICULTY = 'pow_difficulty'
 CONTEXT_NEW_POST_COUNT = 'new_post_count'
 CONTEXT_BANNERS = 'banners'
 CONTEXT_ONLY_FAVORITES = 'only_favorites'
 
 
 def get_notifications(context, settings_manager):
     usernames = settings_manager.get_notification_usernames()
     fav_tags = settings_manager.get_fav_tags()
     new_notifications_count = 0
     if usernames or fav_tags:
         last_notification_id = settings_manager.get_setting(
             SETTING_LAST_NOTIFICATION_ID)
 
         new_notifications_count = Notification.objects.get_notification_posts(
-                usernames=usernames, last=last_notification_id, fav_tags=fav_tags).only('id').count()
+                usernames=usernames, last=last_notification_id, user_settings=settings_manager.get_user_settings()).count()
     context[CONTEXT_NEW_NOTIFICATIONS_COUNT] = new_notifications_count
     context[CONTEXT_USERNAMES] = usernames
 
 
 def get_new_post_count(context, settings_manager):
     last_posts = settings_manager.get_last_posts()
     count = Thread.objects.get_new_post_count(last_posts)
     if count > 0:
         context[CONTEXT_NEW_POST_COUNT] = '(+{})'.format(count)
 
 
 def user_and_ui_processor(request):
     context = dict()
 
     context[CONTEXT_PPD] = float(Post.objects.get_posts_per_day())
 
     settings_manager = get_settings_manager(request)
     fav_tags = settings_manager.get_fav_tags()
 
     context[CONTEXT_TAGS_STR] = Tag.objects.get_tag_url_list(fav_tags)
     theme = settings_manager.get_theme()
     context[CONTEXT_THEME] = theme
 
     # TODO Use static here
     context[CONTEXT_THEME_CSS] = THEME_CSS.format(theme)
 
     context[CONTEXT_VERSION] = settings.get(SECTION_VERSION, 'Version')
     context[CONTEXT_SITE_NAME] = settings.get(SECTION_VERSION, 'SiteName')
 
     if settings.get_bool(SECTION_FORMS, 'LimitFirstPosting'):
         context[CONTEXT_POW_DIFFICULTY] = settings.get_int(SECTION_FORMS, 'PowDifficulty')
 
     context[CONTEXT_IMAGE_VIEWER] = settings_manager.get_setting(
         SETTING_IMAGE_VIEWER,
         default=settings.get(SECTION_VIEW, 'DefaultImageViewer'))
 
     context[CONTEXT_HAS_FAV_THREADS] =\
         len(settings_manager.get_last_posts()) > 0
 
     context[CONTEXT_BANNERS] = Banner.objects.order_by('-id')
     context[CONTEXT_ONLY_FAVORITES] = settings_manager.get_setting(
             SETTING_ONLY_FAVORITES, default=False)
 
     get_notifications(context, settings_manager)
     get_new_post_count(context, settings_manager)
 
     return context

boards/models/user.py

@@ -1,57 +1,57 b''
 from django.db import models
 from django.db.models import Q
 import boards
 
 __author__ = 'neko259'
 
 BAN_REASON_AUTO = 'Auto'
 BAN_REASON_MAX_LENGTH = 200
 
 SESSION_KEY_MAX_LENGTH = 100
 
 
 class Ban(models.Model):
 
     class Meta:
         app_label = 'boards'
 
     ip = models.GenericIPAddressField()
     reason = models.CharField(default=BAN_REASON_AUTO,
                               max_length=BAN_REASON_MAX_LENGTH)
     can_read = models.BooleanField(default=True)
 
     def __str__(self):
         return self.ip
 
 
 class NotificationManager(models.Manager):
-    def get_notification_posts(self, usernames: list, last: int = None, fav_tags=None):
+    def get_notification_posts(self, usernames: list, last: int = None, user_settings=None):
         lower_names = [username.lower() for username in usernames]
         posts = boards.models.post.Post.objects.filter(
                 Q(notification__name__in=lower_names) |
-                (Q(thread__tags__in=fav_tags) & Q(opening=True))).distinct()
+                (Q(thread__tags__settings_as_fav=user_settings) & Q(opening=True))).distinct()
         if last is not None:
             posts = posts.filter(id__gt=last)
         posts = posts.order_by('-id')
 
         return posts
 
 
 class Notification(models.Model):
 
     class Meta:
         app_label = 'boards'
 
     objects = NotificationManager()
 
     post = models.ForeignKey('Post', on_delete=models.CASCADE)
     name = models.TextField()
 
 
 class UserSettings(models.Model):
     class Meta:
         app_label = 'boards'
 
     session_key = models.CharField(max_length=SESSION_KEY_MAX_LENGTH, unique=True)
     fav_tags = models.ManyToManyField('Tag', related_name='settings_as_fav')
     hidden_tags = models.ManyToManyField('Tag', related_name='settings_as_hidden')

boards/views/notifications.py

@@ -1,50 +1,48 b''
 from django.shortcuts import render
 
 from boards.abstracts.constants import PARAM_PAGE
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager, \
     SETTING_LAST_NOTIFICATION_ID
 from boards.models.user import Notification
 from boards.views.base import BaseBoardView
 
 DEFAULT_PAGE = '1'
 
 TEMPLATE = 'boards/notifications.html'
 PARAM_USERNAMES = 'notification_usernames'
 RESULTS_PER_PAGE = 10
 
 
 class NotificationView(BaseBoardView):
 
     def get(self, request, username=None):
         params = self.get_context_data()
 
         settings_manager = get_settings_manager(request)
 
         # If we open our notifications, reset the "new" count
         if username is None:
             notification_usernames = settings_manager.get_notification_usernames()
         else:
             notification_usernames = [username]
 
-        fav_tags = settings_manager.get_fav_tags()
-
         posts = Notification.objects.get_notification_posts(
-                usernames=notification_usernames, fav_tags=fav_tags)
+                usernames=notification_usernames, user_settings=settings_manager.get_user_settings())
 
         if username is None:
             last = posts.first()
             if last is not None:
                 last_id = last.id
                 settings_manager.set_setting(SETTING_LAST_NOTIFICATION_ID,
                                              last_id)
 
 
         paginator = get_paginator(posts, RESULTS_PER_PAGE)
 
         page = int(request.GET.get(PARAM_PAGE, DEFAULT_PAGE))
 
         params[PARAM_PAGE] = paginator.page(page)
         params[PARAM_USERNAMES] = notification_usernames
 
         return render(request, TEMPLATE, params)