Some more constant extracts

boards/abstracts/settingsmanager.py

@@ -1,227 +1,228 b''
 from boards import settings
 from boards.models import Tag, TagAlias, Attachment
 from boards.models.attachment import AttachmentSticker
 from boards.models.thread import FAV_THREAD_NO_UPDATES
 from boards.models.tag import DEFAULT_LOCALE
+from boards.settings import SECTION_VIEW
 
 MAX_TRIPCODE_COLLISIONS = 50
 
 __author__ = 'neko259'
 
 SESSION_SETTING = 'setting'
 
 # Remove this, it is not used any more cause there is a user's permission
 PERMISSION_MODERATE = 'moderator'
 
 SETTING_THEME = 'theme'
 SETTING_FAVORITE_TAGS = 'favorite_tags'
 SETTING_FAVORITE_THREADS = 'favorite_threads'
 SETTING_HIDDEN_TAGS = 'hidden_tags'
 SETTING_PERMISSIONS = 'permissions'
 SETTING_USERNAME = 'username'
 SETTING_LAST_NOTIFICATION_ID = 'last_notification'
 SETTING_IMAGE_VIEWER = 'image_viewer'
 SETTING_TRIPCODE = 'tripcode'
 SETTING_IMAGES = 'images_aliases'
 SETTING_ONLY_FAVORITES = 'only_favorites'
 
 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 has_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if permissions:
             return permission in permissions
         else:
             return False
 
     def get_setting(self, setting, default=None):
         pass
 
     def set_setting(self, setting, value):
         pass
 
     def add_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if not permissions:
             permissions = [permission]
         else:
             permissions.append(permission)
         self.set_setting(SETTING_PERMISSIONS, permissions)
 
     def del_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if not permissions:
             permissions = []
         else:
             permissions.remove(permission)
         self.set_setting(SETTING_PERMISSIONS, permissions)
 
     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 get_fav_threads(self) -> dict:
         return self.get_setting(SETTING_FAVORITE_THREADS, default=dict())
 
     def add_or_read_fav_thread(self, opening_post):
         threads = self.get_fav_threads()
 
-        max_fav_threads = settings.get_int('View', 'MaxFavoriteThreads')
+        max_fav_threads = settings.get_int(SECTION_VIEW, 'MaxFavoriteThreads')
         if (str(opening_post.id) in threads) or (len(threads) < max_fav_threads):
             thread = opening_post.get_thread()
             # Don't check for new posts if the thread is archived already
             if thread.is_archived():
                 last_id = FAV_THREAD_NO_UPDATES
             else:
                 last_id = thread.get_replies().last().id
             threads[str(opening_post.id)] = last_id
             self.set_setting(SETTING_FAVORITE_THREADS, threads)
 
     def del_fav_thread(self, opening_post):
         threads = self.get_fav_threads()
         if self.thread_is_fav(opening_post):
             del threads[str(opening_post.id)]
             self.set_setting(SETTING_FAVORITE_THREADS, threads)
 
     def thread_is_fav(self, opening_post):
         return str(opening_post.id) in self.get_fav_threads()
 
     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
 
 
 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
 
 
 def get_settings_manager(request) -> SettingsManager:
     """
     Get settings manager based on the request object. Currently only
     session-based manager is supported. In the future, cookie-based or
     database-based managers could be implemented.
     """
     return SessionSettingsManager(request.session)

boards/forms/__init__.py

@@ -1,588 +1,588 b''
 import logging
 import time
 
 import hashlib
 import pytz
 import re
 from PIL import Image
 from django import forms
 from django.core.cache import cache
 from django.core.files.images import get_image_dimensions
 from django.core.files.uploadedfile import SimpleUploadedFile, UploadedFile
 from django.forms.utils import ErrorList
 from django.utils.translation import ugettext_lazy as _, ungettext_lazy
 
 import boards.settings as board_settings
 from boards import utils
 from boards.abstracts.constants import REGEX_TAGS
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.abstracts.sticker_factory import get_attachment_by_alias
 from boards.forms.fields import UrlFileField
 from boards.mdx_neboard import formatters
 from boards.models import Attachment
 from boards.models import Tag
 from boards.models.attachment import StickerPack
 from boards.models.attachment.downloaders import download, REGEX_MAGNET
 from boards.models.attachment.viewers import FILE_TYPES_IMAGE
 from boards.models.post import TITLE_MAX_LENGTH
 from boards.utils import validate_file_size, get_file_mimetype, \
     FILE_EXTENSION_DELIMITER, get_tripcode_from_text
+from boards.settings import SECTION_FORMS
 
-SECTION_FORMS = 'Forms'
 
 POW_HASH_LENGTH = 16
 POW_LIFE_MINUTES = 5
 
 REGEX_USERNAMES = re.compile(r'^[\w\s\d,]+$', re.UNICODE)
 REGEX_URL = re.compile(r'^(http|https|ftp):\/\/', re.UNICODE)
 
 VETERAN_POSTING_DELAY = 5
 
 ATTRIBUTE_PLACEHOLDER = 'placeholder'
 ATTRIBUTE_ROWS = 'rows'
 
 LAST_POST_TIME = 'last_post_time'
 LAST_LOGIN_TIME = 'last_login_time'
 TEXT_PLACEHOLDER = _('Type message here. Use formatting panel for more advanced usage.')
 TAGS_PLACEHOLDER = _('music images i_dont_like_tags')
 
 LABEL_TITLE = _('Title')
 LABEL_TEXT = _('Text')
 LABEL_TAG = _('Tag')
 LABEL_SEARCH = _('Search')
 LABEL_FILE = _('File')
 LABEL_DUPLICATES = _('Check for duplicates')
 LABEL_URL = _('Do not download URLs')
 
 ERROR_SPEED = 'Please wait %(delay)d second before sending message'
 ERROR_SPEED_PLURAL = 'Please wait %(delay)d seconds before sending message'
 ERROR_MANY_FILES = 'You can post no more than %(files)d file.'
 ERROR_MANY_FILES_PLURAL = 'You can post no more than %(files)d files.'
 ERROR_DUPLICATES = 'Some files are already present on the board.'
 
 TAG_MAX_LENGTH = 20
 
 TEXTAREA_ROWS = 4
 
 TRIPCODE_DELIM = '##'
 
 # TODO Maybe this may be converted into the database table?
 MIMETYPE_EXTENSIONS = {
     'image/jpeg': 'jpeg',
     'image/png': 'png',
     'image/gif': 'gif',
     'video/webm': 'webm',
     'application/pdf': 'pdf',
     'x-diff': 'diff',
     'image/svg+xml': 'svg',
     'application/x-shockwave-flash': 'swf',
     'image/x-ms-bmp': 'bmp',
     'image/bmp': 'bmp',
 }
 
 DOWN_MODE_DOWNLOAD = 'DOWNLOAD'
 DOWN_MODE_DOWNLOAD_UNIQUE = 'DOWNLOAD_UNIQUE'
 DOWN_MODE_URL = 'URL'
 DOWN_MODE_TRY = 'TRY'
 
 
 logger = logging.getLogger('boards.forms')
 
 
 def get_timezones():
     timezones = []
     for tz in pytz.common_timezones:
         timezones.append((tz, tz),)
     return timezones
 
 
 class FormatPanel(forms.Textarea):
     """
     Panel for text formatting. Consists of buttons to add different tags to the
     form text area.
     """
 
     def render(self, name, value, attrs=None):
         output = '<div id="mark-panel">'
         for formatter in formatters:
             output += '<span class="mark_btn"' + \
                       ' onClick="addMarkToMsg(\'' + formatter.format_left + \
                       '\', \'' + formatter.format_right + '\')">' + \
                       formatter.preview_left + formatter.name + \
                       formatter.preview_right + '</span>'
 
         output += '</div>'
         output += super(FormatPanel, self).render(name, value, attrs=attrs)
 
         return output
 
 
 class PlainErrorList(ErrorList):
     def __unicode__(self):
         return self.as_text()
 
     def as_text(self):
         return ''.join(['(!) %s ' % e for e in self])
 
 
 class NeboardForm(forms.Form):
     """
     Form with neboard-specific formatting.
     """
     required_css_class = 'required-field'
 
     def as_div(self):
         """
         Returns this form rendered as HTML <as_div>s.
         """
 
         return self._html_output(
             # TODO Do not show hidden rows in the list here
             normal_row='<div class="form-row">'
                        '<div class="form-label">'
                        '%(label)s'
                        '</div>'
                        '<div class="form-input">'
                        '%(field)s'
                        '</div>'
                        '</div>'
                        '<div class="form-row">'
                        '%(help_text)s'
                        '</div>',
             error_row='<div class="form-row">'
                       '<div class="form-label"></div>'
                       '<div class="form-errors">%s</div>'
                       '</div>',
             row_ender='</div>',
             help_text_html='%s',
             errors_on_separate_row=True)
 
     def as_json_errors(self):
         errors = []
 
         for name, field in list(self.fields.items()):
             if self[name].errors:
                 errors.append({
                     'field': name,
                     'errors': self[name].errors.as_text(),
                 })
 
         return errors
 
 
 class PostForm(NeboardForm):
 
     title = forms.CharField(max_length=TITLE_MAX_LENGTH, required=False,
                             label=LABEL_TITLE,
                             widget=forms.TextInput(
                                 attrs={ATTRIBUTE_PLACEHOLDER: 'Title{}tripcode'.format(TRIPCODE_DELIM)}))
     text = forms.CharField(
         widget=FormatPanel(attrs={
             ATTRIBUTE_PLACEHOLDER: TEXT_PLACEHOLDER,
             ATTRIBUTE_ROWS: TEXTAREA_ROWS,
         }),
         required=False, label=LABEL_TEXT)
     download_mode = forms.ChoiceField(
             choices=(
                 (DOWN_MODE_TRY, _('Download or insert as URLs')),
                 (DOWN_MODE_DOWNLOAD, _('Download')),
                 (DOWN_MODE_DOWNLOAD_UNIQUE, _('Download and check for uniqueness')),
                 (DOWN_MODE_URL, _('Insert as URLs')),
             ),
             initial=DOWN_MODE_TRY,
             label=_('File process mode'))
     file = UrlFileField(required=False, label=LABEL_FILE)
 
     # This field is for spam prevention only
     email = forms.CharField(max_length=100, required=False, label=_('e-mail'),
                             widget=forms.TextInput(attrs={
                                 'class': 'form-email'}))
     subscribe = forms.BooleanField(required=False, label=_('Subscribe to thread'))
 
     guess = forms.CharField(widget=forms.HiddenInput(), required=False)
     timestamp = forms.CharField(widget=forms.HiddenInput(), required=False)
     iteration = forms.CharField(widget=forms.HiddenInput(), required=False)
 
     session = None
     need_to_ban = False
 
     def clean_title(self):
         title = self.cleaned_data['title']
         if title:
             if len(title) > TITLE_MAX_LENGTH:
                 raise forms.ValidationError(_('Title must have less than %s '
                                               'characters') %
                                             str(TITLE_MAX_LENGTH))
         return title
 
     def clean_text(self):
         text = self.cleaned_data['text'].strip()
         if text:
             max_length = board_settings.get_int(SECTION_FORMS, 'MaxTextLength')
             if len(text) > max_length:
                 raise forms.ValidationError(_('Text must have less than %s '
                                               'characters') % str(max_length))
         return text
 
     def clean_file(self):
         return self._clean_files(self.cleaned_data['file'])
 
     def clean(self):
         cleaned_data = super(PostForm, self).clean()
 
         if cleaned_data['email']:
             if board_settings.get_bool(SECTION_FORMS, 'Autoban'):
                 self.need_to_ban = True
             raise forms.ValidationError('A human cannot enter a hidden field')
 
         if not self.errors:
             self._clean_text_file()
 
         limit_speed = board_settings.get_bool(SECTION_FORMS, 'LimitPostingSpeed')
         limit_first = board_settings.get_bool(SECTION_FORMS, 'LimitFirstPosting')
 
         settings_manager = get_settings_manager(self)
         if not self.errors and limit_speed or (limit_first and not settings_manager.get_setting('confirmed_user')):
             pow_difficulty = board_settings.get_int(SECTION_FORMS, 'PowDifficulty')
             if pow_difficulty > 0:
                 # PoW-based
                 if cleaned_data['timestamp'] \
                         and cleaned_data['iteration'] and cleaned_data['guess'] \
                         and not settings_manager.get_setting('confirmed_user'):
                     self._validate_hash(cleaned_data['timestamp'], cleaned_data['iteration'], cleaned_data['guess'], cleaned_data['text'])
             else:
                 # Time-based
                 self._validate_posting_speed()
             settings_manager.set_setting('confirmed_user', True)
         if self.cleaned_data['download_mode'] == DOWN_MODE_DOWNLOAD_UNIQUE:
             self._check_file_duplicates(self.get_files())
 
         return cleaned_data
 
     def get_files(self):
         """
         Gets file from form or URL.
         """
 
         files = []
         for file in self.cleaned_data['file']:
             if isinstance(file, UploadedFile):
                 files.append(file)
 
         return files
 
     def get_file_urls(self):
         files = []
         for file in self.cleaned_data['file']:
             if type(file) == str:
                 files.append(file)
 
         return files
 
     def get_tripcode(self):
         title = self.cleaned_data['title']
         if title is not None and TRIPCODE_DELIM in title:
             tripcode = get_tripcode_from_text(title.split(TRIPCODE_DELIM, maxsplit=1)[1])
         else:
             tripcode = ''
         return tripcode
 
     def get_title(self):
         title = self.cleaned_data['title']
         if title is not None and TRIPCODE_DELIM in title:
             return title.split(TRIPCODE_DELIM, maxsplit=1)[0]
         else:
             return title
 
     def get_images(self):
         return self.cleaned_data.get('stickers', [])
 
     def is_subscribe(self):
         return self.cleaned_data['subscribe']
 
     def _update_file_extension(self, file):
         if file:
             mimetype = get_file_mimetype(file)
             extension = MIMETYPE_EXTENSIONS.get(mimetype)
             if extension:
                 filename = file.name.split(FILE_EXTENSION_DELIMITER, 1)[0]
                 new_filename = filename + FILE_EXTENSION_DELIMITER + extension
 
                 file.name = new_filename
             else:
                 logger.info('Unrecognized file mimetype: {}'.format(mimetype))
 
     def _clean_files(self, inputs):
         files = []
 
         max_file_count = board_settings.get_int(SECTION_FORMS, 'MaxFileCount')
         if len(inputs) > max_file_count:
             raise forms.ValidationError(
                 ungettext_lazy(ERROR_MANY_FILES, ERROR_MANY_FILES,
                                max_file_count) % {'files': max_file_count})
 
         size = 0
         for file_input in inputs:
             if isinstance(file_input, UploadedFile):
                 file = self._clean_file_file(file_input)
                 size += file.size
                 files.append(file)
             else:
                 files.append(self._clean_file_url(file_input))
 
         for file in files:
             self._validate_image_dimensions(file)
         validate_file_size(size)
 
         return files
 
     def _validate_image_dimensions(self, file):
         if isinstance(file, UploadedFile):
             mimetype = get_file_mimetype(file)
             if mimetype.split('/')[-1] in FILE_TYPES_IMAGE:
                 Image.warnings.simplefilter('error', Image.DecompressionBombWarning)
                 try:
                     print(get_image_dimensions(file))
                 except Exception:
                     raise forms.ValidationError('Possible decompression bomb or large image.')
 
     def _clean_file_file(self, file):
         self._update_file_extension(file)
 
         return file
 
     def _clean_file_url(self, url):
         file = None
 
         if url:
             mode = self.cleaned_data['download_mode']
             if mode == DOWN_MODE_URL:
                 return url
 
             try:
                 image = get_attachment_by_alias(url, self.session)
                 if image is not None:
                     if 'stickers' not in self.cleaned_data:
                         self.cleaned_data['stickers'] = []
                     self.cleaned_data['stickers'].append(image)
                     return
 
                 if file is None:
                     file = self._get_file_from_url(url)
                     if not file:
                         raise forms.ValidationError(_('Invalid URL'))
                 self._update_file_extension(file)
             except forms.ValidationError as e:
                 # Assume we will get the plain URL instead of a file and save it
                 if mode == DOWN_MODE_TRY and (REGEX_URL.match(url) or REGEX_MAGNET.match(url)):
                     logger.info('Error in forms: {}'.format(e))
                     return url
                 else:
                     raise e
 
         return file
 
     def _clean_text_file(self):
         text = self.cleaned_data.get('text')
         file = self.get_files()
         file_url = self.get_file_urls()
         images = self.get_images()
 
         if (not text) and (not file) and (not file_url) and len(images) == 0:
             error_message = _('Either text or file must be entered.')
             self._add_general_error(error_message)
 
     def _get_cache_key(self, key):
         return '{}_{}'.format(self.session.session_key, key)
 
     def _set_session_cache(self, key, value):
         cache.set(self._get_cache_key(key), value)
 
     def _get_session_cache(self, key):
         return cache.get(self._get_cache_key(key))
 
     def _get_last_post_time(self):
         last = self._get_session_cache(LAST_POST_TIME)
         if last is None:
             last = self.session.get(LAST_POST_TIME)
         return last
 
     def _validate_posting_speed(self):
         can_post = True
 
         posting_delay = board_settings.get_int(SECTION_FORMS, 'PostingDelay')
 
         if board_settings.get_bool(SECTION_FORMS, 'LimitPostingSpeed'):
             now = time.time()
 
             current_delay = 0
 
             if LAST_POST_TIME not in self.session:
                 self.session[LAST_POST_TIME] = now
 
                 need_delay = True
             else:
                 last_post_time = self._get_last_post_time()
                 current_delay = int(now - last_post_time)
 
                 need_delay = current_delay < posting_delay
 
             self._set_session_cache(LAST_POST_TIME, now)
 
             if need_delay:
                 delay = posting_delay - current_delay
                 error_message = ungettext_lazy(ERROR_SPEED, ERROR_SPEED_PLURAL,
                                                delay) % {'delay': delay}
                 self._add_general_error(error_message)
 
                 can_post = False
 
             if can_post:
                 self.session[LAST_POST_TIME] = now
             else:
                 # Reset the time since posting failed
                 self._set_session_cache(LAST_POST_TIME, self.session[LAST_POST_TIME])
 
     def _get_file_from_url(self, url: str) -> SimpleUploadedFile:
         """
         Gets an file file from URL.
         """
 
         try:
             return download(url)
         except forms.ValidationError as e:
             raise e
         except Exception as e:
             raise forms.ValidationError(e)
 
     def _validate_hash(self, timestamp: str, iteration: str, guess: str, message: str):
         payload = timestamp + message.replace('\r\n', '\n')
         difficulty = board_settings.get_int(SECTION_FORMS, 'PowDifficulty')
         target = str(int(2 ** (POW_HASH_LENGTH * 3) / difficulty))
         if len(target) < POW_HASH_LENGTH:
             target = '0' * (POW_HASH_LENGTH - len(target)) + target
 
         computed_guess = hashlib.sha256((payload + iteration).encode())\
                              .hexdigest()[0:POW_HASH_LENGTH]
         if guess != computed_guess or guess > target:
             self._add_general_error(_('Invalid PoW.'))
 
     def _check_file_duplicates(self, files):
         for file in files:
             file_hash = utils.get_file_hash(file)
             if Attachment.objects.get_existing_duplicate(file_hash, file):
                 self._add_general_error(_(ERROR_DUPLICATES))
 
     def _add_general_error(self, message):
         self.add_error('text', forms.ValidationError(message))
 
 
 class ThreadForm(PostForm):
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'), required=True)
     monochrome = forms.BooleanField(label=_('Monochrome'), required=False)
     stickerpack = forms.BooleanField(label=_('Sticker Pack'), required=False)
 
     def clean_tags(self):
         tags = self.cleaned_data['tags'].strip()
 
         if not tags or not REGEX_TAGS.match(tags):
             raise forms.ValidationError(
                 _('Inappropriate characters in tags.'))
 
         default_tag_name = board_settings.get(SECTION_FORMS, 'DefaultTag')\
                 .strip().lower()
 
         required_tag_exists = False
         tag_set = set()
         for tag_string in tags.split():
             tag_name = tag_string.strip().lower()
             if tag_name == default_tag_name:
                 required_tag_exists = True
                 tag, created = Tag.objects.get_or_create_with_alias(
                         name=tag_name, required=True)
             else:
                 tag, created = Tag.objects.get_or_create_with_alias(name=tag_name)
             tag_set.add(tag)
 
             # If this is a new tag, don't check for its parents because nobody
             # added them yet
             if not created:
                 tag_set |= set(tag.get_all_parents())
 
         for tag in tag_set:
             if tag.required:
                 required_tag_exists = True
                 break
 
         # Use default tag if no section exists
         if not required_tag_exists:
             default_tag, created = Tag.objects.get_or_create_with_alias(
                     name=default_tag_name, required=True)
             tag_set.add(default_tag)
 
         return tag_set
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
     def is_monochrome(self):
         return self.cleaned_data['monochrome']
 
     def clean_stickerpack(self):
         stickerpack = self.cleaned_data['stickerpack']
         if stickerpack:
             tripcode = self.get_tripcode()
             if not tripcode:
                 raise forms.ValidationError(_(
                     'Tripcode should be specified to own a stickerpack.'))
             title = self.get_title()
             if not title:
                 raise forms.ValidationError(_(
                     'Title should be specified as a stickerpack name.'))
             if not REGEX_TAGS.match(title):
                 raise forms.ValidationError(_('Inappropriate sticker pack name.'))
 
             existing_pack = StickerPack.objects.filter(name=title).first()
             if existing_pack:
                 if existing_pack.tripcode != tripcode:
                     raise forms.ValidationError(_(
                         'A sticker pack with this name already exists and is'
                         ' owned by another tripcode.'))
                 if not existing_pack.tripcode:
                     raise forms.ValidationError(_(
                         'This sticker pack can only be updated by an '
                         'administrator.'))
 
         return stickerpack
 
     def is_stickerpack(self):
         return self.cleaned_data['stickerpack']
 
 
 class SettingsForm(NeboardForm):
 
     theme = forms.ChoiceField(
             choices=board_settings.get_list_dict('View', 'Themes'),
             label=_('Theme'))
     image_viewer = forms.ChoiceField(
             choices=board_settings.get_list_dict('View', 'ImageViewers'),
             label=_('Image view mode'))
     username = forms.CharField(label=_('User name'), required=False)
     timezone = forms.ChoiceField(choices=get_timezones(), label=_('Time zone'))
 
     def clean_username(self):
         username = self.cleaned_data['username']
 
         if username and not REGEX_USERNAMES.match(username):
             raise forms.ValidationError(_('Inappropriate characters.'))
 
         return username
 
 
 class SearchForm(NeboardForm):
     query = forms.CharField(max_length=500, label=LABEL_SEARCH, required=False)

boards/settings.py

@@ -1,41 +1,42 b''
 import configparser
 
 
 CONFIG_DEFAULT_SETTINGS = 'boards/config/default_settings.ini'
 CONFIG_SETTINGS = 'boards/config/settings.ini'
 
 
 SECTION_FORMS = 'Forms'
+SECTION_VIEW = 'View'
 
 VALUE_TRUE = 'true'
 
 LIST_DELIMITER = ','
 DICT_DELIMITER = ':'
 
 
 config = configparser.ConfigParser()
 config.read(CONFIG_DEFAULT_SETTINGS)
 config.read(CONFIG_SETTINGS)
 
 
 def get(section, name):
     return config[section][name]
 
 
 def get_int(section, name):
     return int(get(section, name))
 
 
 def get_bool(section, name):
     return get(section, name) == VALUE_TRUE
 
 
 def get_list_dict(section, name):
     str_dict = get(section, name)
     return [item.split(DICT_DELIMITER) for item in str_dict.split(LIST_DELIMITER)]
 
 
 def get_list(section, name):
     str_list = get(section, name)
     return str_list.split(LIST_DELIMITER)
 

boards/utils.py

@@ -1,161 +1,161 b''
 """
 This module contains helper functions and helper classes.
 """
 import time
 import uuid
 
 import hashlib
 import magic
 import os
 from django import forms
 from django.core.cache import cache
 from django.db.models import Model
 from django.template.defaultfilters import filesizeformat
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
 
 import boards
 from neboard import settings
 from boards.abstracts.constants import FILE_DIRECTORY
-from boards.settings import get_bool
+from boards.settings import get_bool, SECTION_FORMS
 
 CACHE_KEY_DELIMITER = '_'
 
 HTTP_FORWARDED = 'HTTP_X_FORWARDED_FOR'
 META_REMOTE_ADDR = 'REMOTE_ADDR'
 
 SETTING_MESSAGES = 'Messages'
 SETTING_ANON_MODE = 'AnonymousMode'
 
 ANON_IP = '127.0.0.1'
 
 FILE_EXTENSION_DELIMITER = '.'
 URL_DELIMITER = '/'
 CACHE_KEY_DELIMITER = ':'
 
 DEFAULT_MIMETYPE = 'application/octet-stream'
 
 
 def is_anonymous_mode():
     return get_bool(SETTING_MESSAGES, SETTING_ANON_MODE)
 
 
 def get_client_ip(request):
     if is_anonymous_mode():
         ip = ANON_IP
     else:
         x_forwarded_for = request.META.get(HTTP_FORWARDED)
         if x_forwarded_for:
             ip = x_forwarded_for.split(',')[-1].strip()
         else:
             ip = request.META.get(META_REMOTE_ADDR)
     return ip
 
 
 # TODO The output format is not epoch because it includes microseconds
 def datetime_to_epoch(datetime):
     return int(time.mktime(timezone.localtime(
         datetime,timezone.get_current_timezone()).timetuple())
                * 1000000 + datetime.microsecond)
 
 
 # TODO Test this carefully
 def cached_result(key_method=None):
     """
     Caches method result in the Django's cache system, persisted by object name,
     object name, model id if object is a Django model, args and kwargs if any.
     """
     def _cached_result(function):
         def inner_func(obj, *args, **kwargs):
             cache_key_params = [obj.__class__.__name__, function.__name__]
 
             cache_key_params += args
             for key, value in kwargs:
                 cache_key_params.append(key + CACHE_KEY_DELIMITER + value)
 
             if isinstance(obj, Model):
                 cache_key_params.append(str(obj.id))
 
             if key_method is not None:
                 cache_key_params += [str(arg) for arg in key_method(obj)]
 
             cache_key = CACHE_KEY_DELIMITER.join(cache_key_params)
 
             persisted_result = cache.get(cache_key)
             if persisted_result is not None:
                 result = persisted_result
             else:
                 result = function(obj, *args, **kwargs)
                 if result is not None:
                     cache.set(cache_key, result)
 
             return result
 
         return inner_func
     return _cached_result
 
 
 def get_file_hash(file) -> str:
     md5 = hashlib.md5()
     for chunk in file.chunks():
         md5.update(chunk)
     return md5.hexdigest()
 
 
 def validate_file_size(size: int):
-    max_size = boards.settings.get_int('Forms', 'MaxFileSize')
+    max_size = boards.settings.get_int(SECTION_FORMS, 'MaxFileSize')
     if 0 < max_size < size:
         raise forms.ValidationError(
             _('Total file size must be less than %s but is %s.')
             % (filesizeformat(max_size), filesizeformat(size)))
 
 
 def get_extension(filename):
     return filename.split(FILE_EXTENSION_DELIMITER)[-1:][0]
 
 
 def get_upload_filename(model_instance, old_filename):
     extension = get_extension(old_filename)
     new_name = '{}.{}'.format(uuid.uuid4(), extension)
 
     # Create 2 directories to split the files because holding many files in
     # one directory may impact performance
     dir1 = new_name[0]
     dir2 = new_name[1]
 
     return os.path.join(FILE_DIRECTORY, dir1, dir2, new_name)
 
 
 def get_file_mimetype(file) -> str:
     buf = b''
     for chunk in file.chunks():
         buf += chunk
 
     file_type = magic.from_buffer(buf, mime=True)
     if file_type is None:
         file_type = DEFAULT_MIMETYPE
     elif type(file_type) == bytes:
         file_type = file_type.decode()
     return file_type
 
 
 def get_domain(url: str) -> str:
     """
     Gets domain from an URL with random number of domain levels.
     """
     domain_parts = url.split(URL_DELIMITER)
     if len(domain_parts) >= 2:
         full_domain = domain_parts[2]
     else:
         full_domain = ''
 
     return full_domain
 
 
 def get_tripcode_from_text(text: str) -> str:
     tripcode = ''
     if text:
         code = text + settings.SECRET_KEY
         tripcode = hashlib.md5(code.encode()).hexdigest()
     return tripcode
 

boards/views/all_threads.py

@@ -1,132 +1,133 b''
 from django.core.paginator import EmptyPage
 from django.http import Http404
 from django.shortcuts import render, redirect
 from django.urls import reverse
 from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_protect
 
 from boards import settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager, \
     SETTING_ONLY_FAVORITES
 from boards.forms import ThreadForm, PlainErrorList
 from boards.models import Post, Thread
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.mixins import FileUploadMixin, PaginatedMixin, \
     DispatcherMixin, PARAMETER_METHOD
+from boards.settings import SECTION_VIEW, SECTION_FORMS
 
 FORM_TAGS = 'tags'
 FORM_TEXT = 'text'
 FORM_TITLE = 'title'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 TAG_DELIMITER = ' '
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_THREADS = 'threads'
 PARAMETER_ADDITIONAL = 'additional_params'
 PARAMETER_MAX_FILE_SIZE = 'max_file_size'
 PARAMETER_RSS_URL = 'rss_url'
 PARAMETER_MAX_FILES = 'max_files'
 
 TEMPLATE = 'boards/all_threads.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(FileUploadMixin, BaseBoardView, PaginatedMixin,
                      DispatcherMixin):
 
     tag_name = ''
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
     @method_decorator(csrf_protect)
     def get(self, request, form: ThreadForm=None):
         page = request.GET.get('page', DEFAULT_PAGE)
 
         params = self.get_context_data(request=request)
 
         if not form:
             form = ThreadForm(error_class=PlainErrorList,
                     initial={FORM_TAGS: self.tag_name})
 
         self.settings_manager = get_settings_manager(request)
 
         threads = self.get_threads()
 
         order = request.GET.get('order', 'bump')
         if order == 'bump':
             threads = threads.order_by('-bump_time')
         else:
             threads = threads.filter(replies__opening=True)\
                 .order_by('-replies__pub_time')
         filter = request.GET.get('filter')
         threads = threads.distinct()
 
         paginator = get_paginator(threads,
-                                  settings.get_int('View', 'ThreadsPerPage'))
+                                  settings.get_int(SECTION_VIEW, 'ThreadsPerPage'))
         paginator.current_page = int(page)
 
         try:
             threads = paginator.page(page).object_list
         except EmptyPage:
             raise Http404()
 
         params[PARAMETER_THREADS] = threads
         params[CONTEXT_FORM] = form
         params[PARAMETER_MAX_FILE_SIZE] = self.get_max_upload_size()
         params[PARAMETER_RSS_URL] = self.get_rss_url()
-        params[PARAMETER_MAX_FILES] = settings.get_int('Forms', 'MaxFileCount')
+        params[PARAMETER_MAX_FILES] = settings.get_int(SECTION_FORMS, 'MaxFileCount')
 
         paginator.set_url(self.get_reverse_url(), request.GET.dict())
         params.update(self.get_page_context(paginator, page))
 
         return render(request, TEMPLATE, params)
 
     @method_decorator(csrf_protect)
     def post(self, request):
         if PARAMETER_METHOD in request.POST:
             self.dispatch_method(request)
 
             return redirect('index')  # FIXME Different for different modes
 
         form = ThreadForm(request.POST, request.FILES,
                           error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             return Post.objects.create_from_form(request, form, None)
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             self._ban_current_user(request)
 
         return self.get(request, form)
 
     def get_reverse_url(self):
         return reverse('index')
 
     def get_threads(self):
         """
         Gets list of threads that will be shown on a page.
         """
 
         threads = Thread.objects\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())
         if self.settings_manager.get_setting(SETTING_ONLY_FAVORITES):
             fav_tags = self.settings_manager.get_fav_tags()
             if len(fav_tags) > 0:
                 threads = threads.filter(tags__in=fav_tags)
 
         return threads
 
     def get_rss_url(self):
         return self.get_reverse_url() + 'rss/'
 
     def toggle_fav(self, request):
         settings_manager = get_settings_manager(request)
         settings_manager.set_setting(SETTING_ONLY_FAVORITES,
                 not settings_manager.get_setting(SETTING_ONLY_FAVORITES, False))