boards/abstracts/settingsmanager.py

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'
SETTING_CONFIRMED_USER = 'confirmed_user'

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)