Tag name is now stored in the alias with default locale

boards/migrations/0062_auto_20170301_1053.py

@@ -0,0 +1,23 b''
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10.5 on 2017-03-01 08:53
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    def tag_name_to_alias(apps, schema_editor):
+        Tag = apps.get_model('boards', 'Tag')
+        TagAlias = apps.get_model('boards', 'TagAlias')
+
+        for tag in Tag.objects.all():
+            TagAlias.objects.get_or_create(name=tag.name, locale='default', parent=tag)
+
+    dependencies = [
+        ('boards', '0061_auto_20170227_1739'),
+    ]
+
+    operations = [
+        migrations.RunPython(tag_name_to_alias),
+    ]

boards/migrations/0063_auto_20170301_1058.py

@@ -0,0 +1,23 b''
+# -*- coding: utf-8 -*-
+# Generated by Django 1.10.5 on 2017-03-01 08:58
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0062_auto_20170301_1053'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='tag',
+            options={},
+        ),
+        migrations.RemoveField(
+            model_name='tag',
+            name='name',
+        ),
+    ]

boards/abstracts/settingsmanager.py

@@ -1,200 +1,200 b''
 from boards import settings
 from boards.models import Tag
 from boards.models.thread import FAV_THREAD_NO_UPDATES
 
 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(name__in=tag_names))
+            tags = list(Tag.objects.filter(aliases__name__in=tag_names))
         return tags
 
     def add_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if not tags:
-            tags = [tag.name]
+            tags = [tag.get_name()]
         else:
-            if not tag.name in tags:
-                tags.append(tag.name)
+            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.name in tags:
-            tags.remove(tag.name)
+        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(name__in=tag_names))
+            tags = list(Tag.objects.filter(aliases__name__in=tag_names))
 
         return tags
 
     def add_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if not tags:
-            tags = [tag.name]
+            tags = [tag.get_name()]
         else:
-            if not tag.name in tags:
-                tags.append(tag.name)
+            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.name in tags:
-            tags.remove(tag.name)
+        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')
         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_image_by_alias(self, alias):
         images = self.get_setting(SETTING_IMAGES)
         if images is not None and len(images) > 0:
             return images.get(alias)
 
     def add_image_alias(self, alias, image):
         images = self.get_setting(SETTING_IMAGES)
         if images is None:
             images = dict()
         images.put(alias, image)
 
 
 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/admin.py

@@ -1,175 +1,179 b''
 from boards.models.attachment import FILE_TYPES_IMAGE
 from django.contrib import admin
 from django.utils.translation import ugettext_lazy as _
 from django.core.urlresolvers import reverse
 from boards.models import Post, Tag, Ban, Thread, Banner, Attachment, \
         KeyPair, GlobalId, TagAlias
 
 
 @admin.register(Post)
 class PostAdmin(admin.ModelAdmin):
 
     list_display = ('id', 'title', 'text', 'poster_ip', 'linked_images',
             'foreign', 'tags')
     list_filter = ('pub_time',)
     search_fields = ('id', 'title', 'text', 'poster_ip')
     exclude = ('referenced_posts', 'refmap', 'images', 'global_id')
     readonly_fields = ('poster_ip', 'thread', 'linked_images',
             'attachments', 'uid', 'url', 'pub_time', 'opening', 'linked_global_id',
             'version', 'foreign', 'tags')
 
     def ban_poster(self, request, queryset):
         bans = 0
         for post in queryset:
             poster_ip = post.poster_ip
             ban, created = Ban.objects.get_or_create(ip=poster_ip)
             if created:
                 bans += 1
         self.message_user(request, _('{} posters were banned').format(bans))
 
     def ban_latter_with_delete(self, request, queryset):
         bans = 0
         hidden = 0
         for post in queryset:
             poster_ip = post.poster_ip
             ban, created = Ban.objects.get_or_create(ip=poster_ip)
             if created:
                 bans += 1
             posts = Post.objects.filter(poster_ip=poster_ip, id__gte=post.id)
             hidden += posts.count()
             posts.delete()
         self.message_user(request, _('{} posters were banned, {} messages were removed.').format(bans, hidden))
     ban_latter_with_delete.short_description = _('Ban user and delete posts starting from this one and later')
 
     def linked_images(self, obj: Post):
         images = obj.attachments.filter(mimetype__in=FILE_TYPES_IMAGE)
         image_urls = ['<a href="{}"><img src="{}" /></a>'.format(
             reverse('admin:%s_%s_change' % (image._meta.app_label,
                                             image._meta.model_name),
                     args=[image.id]), image.get_thumb_url()) for image in images]
         return ', '.join(image_urls)
     linked_images.allow_tags = True
 
     def linked_global_id(self, obj: Post):
         global_id = obj.global_id
         if global_id is not None:
             return '<a href="{}">{}</a>'.format(
                 reverse('admin:%s_%s_change' % (global_id._meta.app_label,
                                                 global_id._meta.model_name),
                         args=[global_id.id]), str(global_id))
     linked_global_id.allow_tags = True
 
     def tags(self, obj: Post):
         return ', '.join([tag.name for tag in obj.get_tags()])
 
     def save_model(self, request, obj, form, change):
         obj.increment_version()
         obj.save()
         obj.clear_cache()
 
     def foreign(self, obj: Post):
         return obj is not None and obj.global_id is not None and\
                 not obj.global_id.is_local()
 
     actions = ['ban_poster', 'ban_latter_with_delete']
 
 
 @admin.register(Tag)
 class TagAdmin(admin.ModelAdmin):
 
     def thread_count(self, obj: Tag) -> int:
         return obj.get_thread_count()
 
     def display_children(self, obj: Tag):
         return ', '.join([str(child) for child in obj.get_children().all()])
 
+    def name(self, obj: Tag):
+        return obj.get_name()
+
     def save_model(self, request, obj, form, change):
         super().save_model(request, obj, form, change)
         for thread in obj.get_threads().all():
             thread.refresh_tags()
     list_display = ('name', 'thread_count', 'display_children')
     search_fields = ('name',)
+    readonly_fields = ('name',)
 
 
 @admin.register(TagAlias)
 class TagAliasAdmin(admin.ModelAdmin):
     list_display = ('locale', 'name', 'parent')
 
 
 @admin.register(Thread)
 class ThreadAdmin(admin.ModelAdmin):
 
     def title(self, obj: Thread) -> str:
         return obj.get_opening_post().get_title()
 
     def reply_count(self, obj: Thread) -> int:
         return obj.get_reply_count()
 
     def ip(self, obj: Thread):
         return obj.get_opening_post().poster_ip
 
     def display_tags(self, obj: Thread):
         return ', '.join([str(tag) for tag in obj.get_tags().all()])
 
     def op(self, obj: Thread):
         return obj.get_opening_post_id()
 
     # Save parent tags when editing tags
     def save_related(self, request, form, formsets, change):
         super().save_related(request, form, formsets, change)
         form.instance.refresh_tags()
 
     def save_model(self, request, obj, form, change):
         op = obj.get_opening_post()
         op.increment_version()
         op.save(update_fields=['version'])
         obj.save()
         op.clear_cache()
 
     list_display = ('id', 'op', 'title', 'reply_count', 'status', 'ip',
             'display_tags')
     list_filter = ('bump_time', 'status')
     search_fields = ('id', 'title')
     filter_horizontal = ('tags',)
 
 
 @admin.register(KeyPair)
 class KeyPairAdmin(admin.ModelAdmin):
     list_display = ('public_key', 'primary')
     list_filter = ('primary',)
     search_fields = ('public_key',)
 
 
 @admin.register(Ban)
 class BanAdmin(admin.ModelAdmin):
     list_display = ('ip', 'can_read')
     list_filter = ('can_read',)
     search_fields = ('ip',)
 
 
 @admin.register(Banner)
 class BannerAdmin(admin.ModelAdmin):
     list_display = ('title', 'text')
 
 
 @admin.register(Attachment)
 class AttachmentAdmin(admin.ModelAdmin):
     list_display = ('__str__', 'mimetype', 'file', 'url', 'alias')
     search_fields = ('alias',)
 
     def delete_alias(self, request, queryset):
         for attachment in queryset:
             attachment.alias = None
             attachment.save(update_fields=['alias'])
         self.message_user(request, _('Aliases removed'))
 
     actions = ['delete_alias']
 
 
 @admin.register(GlobalId)
 class GlobalIdAdmin(admin.ModelAdmin):
     def is_linked(self, obj):
         return Post.objects.filter(global_id=obj).exists()
 
     list_display = ('__str__', 'is_linked',)
     readonly_fields = ('content',)

boards/forms/__init__.py

@@ -1,534 +1,529 b''
 import hashlib
 import logging
 import re
 import time
 import traceback
 
 import pytz
 
 from PIL import Image
 
 from django import forms
 from django.core.files.uploadedfile import SimpleUploadedFile, UploadedFile
 from django.forms.utils import ErrorList
 from django.utils.translation import ugettext_lazy as _, ungettext_lazy
 from django.core.files.images import get_image_dimensions
 
 import boards.settings as board_settings
 import neboard
 from boards import utils
 from boards.abstracts.attachment_alias import get_image_by_alias
 from boards.abstracts.settingsmanager import get_settings_manager
 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.downloaders import download, REGEX_MAGNET
 from boards.models.post import TITLE_MAX_LENGTH
 from boards.utils import validate_file_size, get_file_mimetype, \
     FILE_EXTENSION_DELIMITER
 from boards.models.attachment.viewers import FILE_TYPES_IMAGE
 from neboard import settings
 
 SECTION_FORMS = 'Forms'
 
 POW_HASH_LENGTH = 16
 POW_LIFE_MINUTES = 5
 
 REGEX_TAGS = re.compile(r'^[\w\s\d]+$', re.UNICODE)
 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',
 }
 
 
 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'}))
     text = forms.CharField(
         widget=FormatPanel(attrs={
             ATTRIBUTE_PLACEHOLDER: TEXT_PLACEHOLDER,
             ATTRIBUTE_ROWS: TEXTAREA_ROWS,
         }),
         required=False, label=LABEL_TEXT)
     no_download = forms.BooleanField(required=False, label=LABEL_URL)
     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'))
     check_duplicates = forms.BooleanField(required=False, label=LABEL_DUPLICATES)
 
     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
     image = None
 
     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['check_duplicates']:
             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:
             code = title.split(TRIPCODE_DELIM, maxsplit=1)[1] + neboard.settings.SECRET_KEY
             tripcode = hashlib.md5(code.encode()).hexdigest()
         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):
         if self.image:
             return [self.image]
         else:
             return []
 
     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})
         for file_input in inputs:
             if isinstance(file_input, UploadedFile):
                 files.append(self._clean_file_file(file_input))
             else:
                 files.append(self._clean_file_url(file_input))
 
         for file in files:
             self._validate_image_dimensions(file)
 
         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):
         validate_file_size(file.size)
         self._update_file_extension(file)
 
         return file
 
     def _clean_file_url(self, url):
         file = None
 
         if url:
             if self.cleaned_data['no_download']:
                 return url
 
             try:
                 file = get_image_by_alias(url, self.session)
                 self.image = file
 
                 if file is not None:
                     return
 
                 if file is None:
                     file = self._get_file_from_url(url)
                     if not file:
                         raise forms.ValidationError(_('Invalid URL'))
                     else:
                         validate_file_size(file.size)
                 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 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 _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.session.get(LAST_POST_TIME)
                 current_delay = int(now - last_post_time)
 
                 need_delay = current_delay < posting_delay
 
             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
 
     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)
 
     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(
+                tag, created = Tag.objects.get_or_create_with_alias(
                         name=tag_name, required=True)
             else:
-                tag = Tag.objects.get_by_alias(tag_name)
-                if tag:
-                    created = False
-                else:
-                    tag, created = Tag.objects.get_or_create(
-                            name=tag_name)
+                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(
                     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']
 
 
 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/models/tag.py

@@ -1,177 +1,194 b''
 import hashlib
 import re
 
 from boards.models.attachment import FILE_TYPES_IMAGE
 from django.template.loader import render_to_string
 from django.db import models
 from django.db.models import Count
 from django.core.urlresolvers import reverse
 from django.utils.translation import get_language
 
 from boards.models import Attachment
 from boards.models.base import Viewable
 from boards.models.thread import STATUS_ACTIVE, STATUS_BUMPLIMIT, STATUS_ARCHIVE
 from boards.utils import cached_result
 import boards
 
 __author__ = 'neko259'
 
 
 RELATED_TAGS_COUNT = 5
+DEFAULT_LOCALE = 'default'
 
 
 class TagAlias(models.Model, Viewable):
     class Meta:
         app_label = 'boards'
         ordering = ('name',)
 
     name = models.CharField(max_length=100, db_index=True)
     locale = models.CharField(max_length=10, db_index=True)
 
     parent = models.ForeignKey('Tag', null=True, blank=True,
             related_name='aliases')
 
 
 class TagManager(models.Manager):
     def get_not_empty_tags(self):
         """
         Gets tags that have non-archived threads.
         """
 
-        return self.annotate(num_threads=Count('thread_tags')).filter(num_threads__gt=0)\
-            .order_by('name')
+        return self.annotate(num_threads=Count('thread_tags'))\
+                .filter(num_threads__gt=0)\
+                .filter(aliases__locale=DEFAULT_LOCALE)\
+                .order_by('aliases__name')
 
     def get_tag_url_list(self, tags: list) -> str:
         """
         Gets a comma-separated list of tag links.
         """
 
         return ', '.join([tag.get_view() for tag in tags])
 
     def get_by_alias(self, alias):
         tag = None
         aliases = TagAlias.objects.filter(name=alias).all()
         if aliases:
             tag = aliases[0].parent
 
         return tag
 
+    def get_or_create_with_alias(self, name, required=False):
+        tag = self.get_by_alias(name)
+        created = False
+        if not tag:
+            tag = self.create(required=required)
+            TagAlias.objects.create(name=alias, locale=DEFAULT_LOCALE, parent=tag)
+            created = True
+        return tag, created
+
 
 class Tag(models.Model, Viewable):
     """
     A tag is a text node assigned to the thread. The tag serves as a board
     section. There can be multiple tags for each thread
     """
 
     objects = TagManager()
 
     class Meta:
         app_label = 'boards'
-        ordering = ('name',)
 
-    name = models.CharField(max_length=100, db_index=True, unique=True)
     required = models.BooleanField(default=False, db_index=True)
     description = models.TextField(blank=True)
 
     parent = models.ForeignKey('Tag', null=True, blank=True,
             related_name='children')
 
+    @cached_result()
+    def get_name(self):
+        return self.aliases.get(locale=DEFAULT_LOCALE).name
+
     def __str__(self):
-        return self.name
+        return self.get_name()
 
     def is_empty(self) -> bool:
         """
         Checks if the tag has some threads.
         """
 
         return self.get_thread_count() == 0
 
     def get_thread_count(self, status=None) -> int:
         threads = self.get_threads()
         if status is not None:
             threads = threads.filter(status=status)
         return threads.count()
 
     def get_active_thread_count(self) -> int:
         return self.get_thread_count(status=STATUS_ACTIVE)
 
     def get_bumplimit_thread_count(self) -> int:
         return self.get_thread_count(status=STATUS_BUMPLIMIT)
 
     def get_archived_thread_count(self) -> int:
         return self.get_thread_count(status=STATUS_ARCHIVE)
 
     def get_absolute_url(self):
-        return reverse('tag', kwargs={'tag_name': self.name})
+        return reverse('tag', kwargs={'tag_name': self.get_name()})
 
     def get_threads(self):
         return self.thread_tags.order_by('-bump_time')
 
     def is_required(self):
         return self.required
 
     def get_view(self):
         locale = get_language()
 
         try:
             localized_tag_name = self.aliases.get(locale=locale).name
         except TagAlias.DoesNotExist:
             localized_tag_name = ''
 
-        name = '{} ({})'.format(self.name, localized_tag_name) if localized_tag_name else self.name
+        default_name = self.get_name()
+
+        name = '{} ({})'.format(default_name, localized_tag_name) if localized_tag_name else default_name
         link = '<a class="tag" href="{}">{}</a>'.format(
             self.get_absolute_url(), name)
         if self.is_required():
             link = '<b>{}</b>'.format(link)
         return link
 
     @cached_result()
     def get_post_count(self):
         return self.get_threads().aggregate(num_posts=Count('replies'))['num_posts']
 
     def get_description(self):
         return self.description
 
     def get_random_image_post(self, status=[STATUS_ACTIVE, STATUS_BUMPLIMIT]):
         posts = boards.models.Post.objects.filter(attachments__mimetype__in=FILE_TYPES_IMAGE)\
             .annotate(images_count=Count(
             'attachments')).filter(images_count__gt=0, thread__tags__in=[self])
         if status is not None:
             posts = posts.filter(thread__status__in=status)
         return posts.order_by('?').first()
 
     def get_first_letter(self):
-        return self.name and self.name[0] or ''
+        name = self.get_name()
+        return name and name[0] or ''
 
     def get_related_tags(self):
         return set(Tag.objects.filter(thread_tags__in=self.get_threads()).exclude(
             id=self.id).order_by('?')[:RELATED_TAGS_COUNT])
 
     @cached_result()
     def get_color(self):
         """
         Gets color hashed from the tag name.
         """
-        return hashlib.md5(self.name.encode()).hexdigest()[:6]
+        return hashlib.md5(self.get_name().encode()).hexdigest()[:6]
 
     def get_parent(self):
         return self.parent
 
     def get_all_parents(self):
         parents = list()
         parent = self.get_parent()
         if parent and parent not in parents:
             parents.insert(0, parent)
             parents = parent.get_all_parents() + parents
 
         return parents
 
     def get_children(self):
         return self.children
 
     def get_images(self):
         return Attachment.objects.filter(
             attachment_posts__thread__tags__in=[self]).filter(
             mimetype__in=FILE_TYPES_IMAGE).order_by('-attachment_posts__pub_time')
 
 

boards/models/thread.py

@@ -1,313 +1,313 b''
 import logging
 from datetime import timedelta
 
 from django.db import models, transaction
 from django.db.models import Count, Sum, QuerySet, Q
 from django.utils import timezone
 
 import boards
 from boards import settings
 from boards.models import STATUS_BUMPLIMIT, STATUS_ACTIVE, STATUS_ARCHIVE
 from boards.models.attachment import FILE_TYPES_IMAGE
 from boards.models.post import Post
-from boards.models.tag import Tag
+from boards.models.tag import Tag, DEFAULT_LOCALE
 from boards.utils import cached_result, datetime_to_epoch
 
 FAV_THREAD_NO_UPDATES = -1
 
 
 __author__ = 'neko259'
 
 
 logger = logging.getLogger(__name__)
 
 
 WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
 WS_NOTIFICATION_TYPE = 'notification_type'
 
 WS_CHANNEL_THREAD = "thread:"
 
 STATUS_CHOICES = (
         (STATUS_ACTIVE, STATUS_ACTIVE),
         (STATUS_BUMPLIMIT, STATUS_BUMPLIMIT),
         (STATUS_ARCHIVE, STATUS_ARCHIVE),
 )
 
 
 class ThreadManager(models.Manager):
     def process_old_threads(self):
         """
          Preserves maximum thread count. If there are too many threads,
          archive or delete the old ones.
          """
         old_time_delta = settings.get_int('Messages', 'ThreadArchiveDays')
         old_time = timezone.now() - timedelta(days=old_time_delta)
         old_ops = Post.objects.filter(opening=True, pub_time__lte=old_time).exclude(thread__status=STATUS_ARCHIVE)
 
         for op in old_ops:
             thread = op.get_thread()
             if settings.get_bool('Storage', 'ArchiveThreads'):
                 self._archive_thread(thread)
             else:
                 thread.delete()
             logger.info('Processed old thread {}'.format(thread))
 
 
     def _archive_thread(self, thread):
         thread.status = STATUS_ARCHIVE
         thread.last_edit_time = timezone.now()
         thread.update_posts_time()
         thread.save(update_fields=['last_edit_time', 'status'])
 
     def get_new_posts(self, datas):
         query = None
         # TODO Use classes instead of dicts
         for data in datas:
             if data['last_id'] != FAV_THREAD_NO_UPDATES:
                 q = (Q(id=data['op'].get_thread_id())
                      & Q(replies__id__gt=data['last_id']))
                 if query is None:
                     query = q
                 else:
                     query = query | q
         if query is not None:
             return self.filter(query).annotate(
                 new_post_count=Count('replies'))
 
     def get_new_post_count(self, datas):
         new_posts = self.get_new_posts(datas)
         return new_posts.aggregate(total_count=Count('replies'))\
                 ['total_count'] if new_posts else 0
 
 
 def get_thread_max_posts():
     return settings.get_int('Messages', 'MaxPostsPerThread')
 
 
 class Thread(models.Model):
     objects = ThreadManager()
 
     class Meta:
         app_label = 'boards'
 
     tags = models.ManyToManyField('Tag', related_name='thread_tags')
     bump_time = models.DateTimeField(db_index=True)
     last_edit_time = models.DateTimeField()
     max_posts = models.IntegerField(default=get_thread_max_posts)
     status = models.CharField(max_length=50, default=STATUS_ACTIVE,
             choices=STATUS_CHOICES, db_index=True)
     monochrome = models.BooleanField(default=False)
 
     def get_tags(self) -> QuerySet:
         """
         Gets a sorted tag list.
         """
 
-        return self.tags.order_by('name')
+        return self.tags.filter(aliases__locale=DEFAULT_LOCALE).order_by('aliases__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.status = STATUS_BUMPLIMIT
             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().filter(
             attachments__mimetype__in=FILE_TYPES_IMAGE)\
             .annotate(images_count=Count(
             'attachments')).aggregate(Sum('images_count'))['images_count__sum'] or 0
 
     def can_bump(self) -> bool:
         """
         Checks if the thread can be bumped by replying to it.
         """
 
         return self.get_status() == STATUS_ACTIVE
 
     def get_last_replies(self) -> QuerySet:
         """
         Gets several last replies, not including opening post
         """
 
         last_replies_count = settings.get_int('View', 'LastRepliesCount')
 
         if last_replies_count > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(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.get_int('View', 'LastRepliesCount'),
                                  reply_count - 1)
         return reply_count - last_replies_count - 1
 
     # TODO Remove argument, it is not used
     def get_replies(self, view_fields_only=True) -> QuerySet:
         """
         Gets sorted thread posts
         """
         query = self.replies.order_by('pub_time').prefetch_related(
             'attachments')
         return query
 
     def get_viewable_replies(self) -> QuerySet:
         """
         Gets replies with only fields that are used for viewing.
         """
         return self.get_replies().defer('text', 'last_edit_time', 'version')
 
     def get_top_level_replies(self) -> QuerySet:
         return self.get_replies().exclude(refposts__threads__in=[self])
 
     def get_replies_with_images(self, view_fields_only=False) -> QuerySet:
         """
         Gets replies that have at least one image attached
         """
         return self.get_replies(view_fields_only).filter(
             attachments__mimetype__in=FILE_TYPES_IMAGE).annotate(images_count=Count(
             'attachments')).filter(images_count__gt=0)
 
     def get_opening_post(self, only_id=False) -> Post:
         """
         Gets the first post of the thread
         """
 
         query = self.get_replies().filter(opening=True)
         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 __str__(self):
         return 'T#{}'.format(self.id)
 
     def get_tag_url_list(self) -> list:
-        return boards.models.Tag.objects.get_tag_url_list(self.get_tags())
+        return boards.models.Tag.objects.get_tag_url_list(self.get_tags().all())
 
     def update_posts_time(self, exclude_posts=None):
         last_edit_time = self.last_edit_time
 
         for post in self.replies.all():
             if exclude_posts is None or post not in exclude_posts:
                 # Manual update is required because uids are generated on save
                 post.last_edit_time = last_edit_time
                 post.save(update_fields=['last_edit_time'])
 
     def get_absolute_url(self):
         return self.get_opening_post().get_absolute_url()
 
     def get_required_tags(self):
         return self.get_tags().filter(required=True)
 
     def get_sections_str(self):
         return Tag.objects.get_tag_url_list(self.get_required_tags())
 
     def get_replies_newer(self, post_id):
         return self.get_replies().filter(id__gt=post_id)
 
     def is_archived(self):
         return self.get_status() == STATUS_ARCHIVE
 
     def get_status(self):
         return self.status
 
     def is_monochrome(self):
         return self.monochrome
 
     # If tags have parent, add them to the tag list
     @transaction.atomic
     def refresh_tags(self):
         for tag in self.get_tags().all():
             parents = tag.get_all_parents()
             if len(parents) > 0:
                 self.tags.add(*parents)
 
     def get_reply_tree(self):
         replies = self.get_replies().prefetch_related('refposts')
         tree = []
         for reply in replies:
             parents = reply.refposts.all()
 
             found_parent = False
             searching_for_index = False
 
             if len(parents) > 0:
                 index = 0
                 parent_depth = 0
 
                 indexes_to_insert = []
 
                 for depth, element in tree:
                     index += 1
 
                     # If this element is next after parent on the same level,
                     # insert child before it
                     if searching_for_index and depth <= parent_depth:
                         indexes_to_insert.append((index - 1, parent_depth))
                         searching_for_index = False
 
                     if element in parents:
                         found_parent = True
                         searching_for_index = True
                         parent_depth = depth
 
             if not found_parent:
                 tree.append((0, reply))
             else:
                 if searching_for_index:
                     tree.append((parent_depth + 1, reply))
 
                 offset = 0
                 for last_index, parent_depth in indexes_to_insert:
                     tree.insert(last_index + offset, (parent_depth + 1, reply))
                     offset += 1
 
         return tree

boards/templates/boards/all_threads.html

@@ -1,208 +1,208 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load board %}
 {% load static %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
 
     {% if tag %}
-        <title>{{ tag.name }} - {{ site_name }}</title>
+        <title>{{ tag.get_name }} - {{ site_name }}</title>
     {% else %}
         <title>{{ site_name }}</title>
     {% endif %}
 
     {% if prev_page_link %}
         <link rel="prev" href="{{ prev_page_link }}" />
     {% endif %}
     {% if next_page_link %}
         <link rel="next" href="{{ next_page_link }}" />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     {% for banner in banners %}
         <div class="post">
             <div class="title">{{ banner.title }}</div>
             <div>{{ banner.get_text|safe }}</div>
             <div>{% trans 'Details' %}: <a href="{{ banner.post.get_absolute_url }}">>>{{ banner.post.id }}</a></div>
         </div>
     {% endfor %}
 
 {% if tag %}
     <div class="tag_info" style="border-bottom: solid .5ex #{{ tag.get_color }}">
         {% if random_image_post %}
             <div class="tag-image">
                 {% with image=random_image_post.get_first_image %}
                     <a href="{{ random_image_post.get_absolute_url }}"><img 
                         src="{{ image.get_thumb_url }}"
                         width="{{ image.get_preview_size.0 }}"
                         height="{{ image.get_preview_size.1 }}"
                         alt="{{ random_image_post.id }}"/></a>
                 {% endwith %}
             </div>
         {% endif %}
         <div class="tag-text-data">
             <h2>
                 /{{ tag.get_view|safe }}/
             </h2>
             {% if perms.change_tag %}
                 <div class="moderator_info"><a href="{% url 'admin:boards_tag_change' tag.id %}">{% trans 'Edit tag' %}</a></div>
             {% endif %}
             <p>
-                <form action="{% url 'tag' tag.name %}" method="post" class="post-button-form">
+                <form action="{% url 'tag' tag.get_name %}" method="post" class="post-button-form">
                     {% if is_favorite %}
                         <button name="method" value="unsubscribe" class="fav">★ {% trans "Remove from favorites" %}</button>
                     {% else %}
                         <button name="method" value="subscribe" class="not_fav">★ {% trans "Add to favorites" %}</button>
                     {% endif %}
                 </form>
-                <form action="{% url 'tag' tag.name %}" method="post" class="post-button-form">
+                <form action="{% url 'tag' tag.get_name %}" method="post" class="post-button-form">
                     {% if is_hidden %}
                         <button name="method" value="unhide" class="fav">{% trans "Show" %}</button>
                     {% else %}
                         <button name="method" value="hide" class="not_fav">{% trans "Hide" %}</button>
                     {% endif %}
                 </form>
-                <a href="{% url 'tag_gallery' tag.name %}">{% trans 'Gallery' %}</a>
+                <a href="{% url 'tag_gallery' tag.get_name %}">{% trans 'Gallery' %}</a>
             </p>
             {% if tag.get_description %}
                 <p>{{ tag.get_description|safe }}</p>
             {% endif %}
             <p>
                 {% with active_count=tag.get_active_thread_count bumplimit_count=tag.get_bumplimit_thread_count archived_count=tag.get_archived_thread_count %}
                     {% if active_count %}
                         ● {{ active_count }}&ensp;
                     {% endif %}
                     {% if bumplimit_count %}
                         ◍ {{ bumplimit_count }}&ensp;
                     {% endif %}
                     {% if archived_count %}
                         ○ {{ archived_count }}&ensp;
                     {% endif %}
                 {% endwith %}
                 ♥ {{ tag.get_post_count }}
             </p>
             {% if tag.get_all_parents %}
                 <p>
                     {% for parent in tag.get_all_parents %}
                         {{ parent.get_view|safe }} &gt;
                     {% endfor %}
                     {{ tag.get_view|safe }}
                 </p>
             {% endif %}
             {% if tag.get_children.all %}
                 <p>
                 {% trans "Subsections: " %}
                 {% for child in tag.get_children.all %}
                     {{ child.get_view|safe }}{% if not forloop.last%}, {% endif %}
                 {% endfor %}
                 </p>
             {% endif %}
         </div>
     </div>
 {% endif %}
 
     {% if threads %}
         {% if prev_page_link %}
             <div class="page_link">
                 <a href="{{ prev_page_link }}">&lt;&lt; {% trans "Previous page" %} &lt;&lt;</a>
             </div>
         {% endif %}
 
         {% for thread in threads %}
             <div class="thread">
                 {% post_view thread.get_opening_post thread=thread truncated=True need_open_link=True %}
                 {% if not thread.archived %}
                     {% with last_replies=thread.get_last_replies %}
                         {% if last_replies %}
                             {% with skipped_replies_count=thread.get_skipped_replies_count %}
                                 {% if skipped_replies_count %}
                                     <div class="skipped_replies">
                                         <a href="{% url 'thread' thread.get_opening_post_id %}">
                                             {% blocktrans count count=skipped_replies_count %}Skipped {{ count }} reply. Open thread to see all replies.{% plural %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
                                         </a>
                                     </div>
                                 {% endif %}
                             {% endwith %}
                             <div class="last-replies">
                                 {% for post in last_replies %}
                                     {% post_view post truncated=True %}
                                 {% endfor %}
                             </div>
                         {% endif %}
                     {% endwith %}
                 {% endif %}
             </div>
         {% endfor %}
 
         {% if next_page_link %}
             <div class="page_link">
                 <a href="{{ next_page_link }}">&gt;&gt; {% trans "Next page" %} &gt;&gt;</a>
             </div>
         {% endif %}
     {% else %}
         <div class="post">
             {% trans 'No threads exist. Create the first one!' %}</div>
     {% endif %}
 
     <div class="post-form-w">
         <script src="{% static 'js/panel.js' %}"></script>
         <div class="post-form" data-hasher="{% static 'js/3party/sha256.js' %}"
                                data-pow-script="{% static 'js/proof_of_work.js' %}">
             <div class="form-title">{% trans "Create new thread" %}</div>
             <div class="swappable-form-full">
             <form enctype="multipart/form-data" method="post" id="form">{% csrf_token %}
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans "Post" %}"/>
                     <button id="preview-button" type="button" onclick="return false;">{% trans 'Preview' %}</button>
                 </div>
             </form>
             </div>
             <div>
                 {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
                 {% with size=max_file_size|filesizeformat %}
                     {% blocktrans %}Max file size is {{ size }}.{% endblocktrans %}
                 {% endwith %}
                 {% blocktrans %}Max file number is {{ max_files }}.{% endblocktrans %}
             </div>
             <div id="preview-text"></div>
             <div><a href="{% url "staticpage" name="help" %}">{% trans 'Text syntax' %}</a></div>
         </div>
     </div>
 
     <script src="{% static 'js/form.js' %}"></script>
         <script src="{% static 'js/3party/jquery.blockUI.js' %}"></script>
     <script src="{% static 'js/thread_create.js' %}"></script>
 
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
         {% trans "Pages:" %}
         [
         {% with dividers=paginator.get_dividers %}
             {% for page in paginator.get_divided_range %}
                 {% if page in dividers %}
                     …,
                 {% endif %}
                 <a
                     {% ifequal page current_page.number %}
                         class="current_page"
                     {% endifequal %}
                     href="{% page_url paginator page %}">{{ page }}</a>{% if not forloop.last %},{% endif %}
             {% endfor %}
         {% endwith %}
         ]
     </span>
 
 {% endblock %}

boards/views/api.py

@@ -1,315 +1,315 b''
 import json
 import logging
 
 from django.core import serializers
 from django.db import transaction
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404
 from django.views.decorators.csrf import csrf_protect
 
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.forms import PostForm, PlainErrorList
 from boards.mdx_neboard import Parser
-from boards.models import Post, Thread, Tag, Attachment
+from boards.models import Post, Thread, Tag, Attachment, TagAlias
 from boards.models.thread import STATUS_ARCHIVE
 from boards.models.user import Notification
 from boards.utils import datetime_to_epoch
 from boards.views.thread import ThreadView
 from boards.models.attachment.viewers import FILE_TYPES_IMAGE
 
 __author__ = 'neko259'
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 PARAMETER_POST = 'post'
 PARAMETER_UPDATED = 'updated'
 PARAMETER_LAST_UPDATE = 'last_update'
 PARAMETER_THREAD = 'thread'
 PARAMETER_UIDS = 'uids'
 PARAMETER_SUBSCRIBED = 'subscribed'
 
 DIFF_TYPE_HTML = 'html'
 DIFF_TYPE_JSON = 'json'
 
 STATUS_OK = 'ok'
 STATUS_ERROR = 'error'
 
 logger = logging.getLogger(__name__)
 
 
 @transaction.atomic
 def api_get_threaddiff(request):
     """
     Gets posts that were changed or added since time
     """
 
     thread_id = request.POST.get(PARAMETER_THREAD)
     uids_str = request.POST.get(PARAMETER_UIDS)
 
     if not thread_id or not uids_str:
         return HttpResponse(content='Invalid request.')
 
     uids = uids_str.strip().split(' ')
 
     opening_post = get_object_or_404(Post, id=thread_id)
     thread = opening_post.get_thread()
 
     json_data = {
         PARAMETER_UPDATED: [],
         PARAMETER_LAST_UPDATE: None,  # TODO Maybe this can be removed already?
     }
     posts = Post.objects.filter(thread=thread).exclude(uid__in=uids)
 
     diff_type = request.GET.get(PARAMETER_DIFF_TYPE, DIFF_TYPE_HTML)
 
     for post in posts:
         json_data[PARAMETER_UPDATED].append(post.get_post_data(
             format_type=diff_type, request=request))
     json_data[PARAMETER_LAST_UPDATE] = str(thread.last_edit_time)
 
     settings_manager = get_settings_manager(request)
     json_data[PARAMETER_SUBSCRIBED] = str(settings_manager.thread_is_fav(opening_post))
 
     # If the tag is favorite, update the counter
     settings_manager = get_settings_manager(request)
     favorite = settings_manager.thread_is_fav(opening_post)
     if favorite:
         settings_manager.add_or_read_fav_thread(opening_post)
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 @csrf_protect
 def api_add_post(request, opening_post_id):
     """
     Adds a post and return the JSON response for it
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
 
     logger.info('Adding post via api...')
 
     status = STATUS_OK
     errors = []
 
     if request.method == 'POST':
         form = PostForm(request.POST, request.FILES, error_class=PlainErrorList)
         form.session = request.session
 
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             # _ban_current_user(request)
             status = STATUS_ERROR
         if form.is_valid():
             post = ThreadView().new_post(request, form, opening_post,
                                          html_response=False)
             if not post:
                 status = STATUS_ERROR
             else:
                 logger.info('Added post #%d via api.' % post.id)
         else:
             status = STATUS_ERROR
             errors = form.as_json_errors()
 
     response = {
         'status': status,
         'errors': errors,
     }
 
     return HttpResponse(content=json.dumps(response))
 
 
 def get_post(request, post_id):
     """
     Gets the html of a post. Used for popups. Post can be truncated if used
     in threads list with 'truncated' get parameter.
     """
 
     post = get_object_or_404(Post, id=post_id)
     truncated = PARAMETER_TRUNCATED in request.GET
 
     return HttpResponse(content=post.get_view(truncated=truncated, need_op_data=True))
 
 
 def api_get_threads(request, count):
     """
     Gets the JSON thread opening posts list.
     Parameters that can be used for filtering:
     tag, offset (from which thread to get results)
     """
 
     if PARAMETER_TAG in request.GET:
         tag_name = request.GET[PARAMETER_TAG]
         if tag_name is not None:
             tag = get_object_or_404(Tag, name=tag_name)
             threads = tag.get_threads().exclude(status=STATUS_ARCHIVE)
     else: 
         threads = Thread.objects.exclude(status=STATUS_ARCHIVE)
 
     if PARAMETER_OFFSET in request.GET:
         offset = request.GET[PARAMETER_OFFSET]
         offset = int(offset) if offset is not None else 0
     else:
         offset = 0
 
     threads = threads.order_by('-bump_time')
     threads = threads[offset:offset + int(count)]
 
     opening_posts = []
     for thread in threads:
         opening_post = thread.get_opening_post()
 
         # TODO Add tags, replies and images count
         post_data = opening_post.get_post_data(include_last_update=True)
         post_data['status'] = thread.get_status()
 
         opening_posts.append(post_data)
 
     return HttpResponse(content=json.dumps(opening_posts))
 
 
 # TODO Test this
 def api_get_tags(request):
     """
     Gets all tags or user tags.
     """
 
     # TODO Get favorite tags for the given user ID
 
-    tags = Tag.objects.get_not_empty_tags()
+    tags = TagAlias.objects.all()
 
     term = request.GET.get('term')
     if term is not None:
         tags = tags.filter(name__contains=term)
 
     tag_names = [tag.name for tag in tags]
 
     return HttpResponse(content=json.dumps(tag_names))
 
 
 def api_get_stickers(request):
     attachments = Attachment.objects.filter(mimetype__in=FILE_TYPES_IMAGE)\
         .exclude(alias='').exclude(alias=None)
 
     term = request.GET.get('term')
     if term:
         attachments = attachments.filter(alias__contains=term)
 
     image_dict = [{'thumb': attachment.get_thumb_url(),
                    'alias': attachment.alias}
                   for attachment in attachments]
 
     return HttpResponse(content=json.dumps(image_dict))
 
 
 # TODO The result can be cached by the thread last update time
 # TODO Test this
 def api_get_thread_posts(request, opening_post_id):
     """
     Gets the JSON array of thread posts
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
     thread = opening_post.get_thread()
     posts = thread.get_replies()
 
     json_data = {
         'posts': [],
         'last_update': None,
     }
     json_post_list = []
 
     for post in posts:
         json_post_list.append(post.get_post_data())
     json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
     json_data['posts'] = json_post_list
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 def api_get_notifications(request, username):
     last_notification_id_str = request.GET.get('last', None)
     last_id = int(last_notification_id_str) if last_notification_id_str is not None else None
 
     posts = Notification.objects.get_notification_posts(usernames=[username],
                                                         last=last_id)
 
     json_post_list = []
     for post in posts:
         json_post_list.append(post.get_post_data())
     return HttpResponse(content=json.dumps(json_post_list))
 
 
 def api_get_post(request, post_id):
     """
     Gets the JSON of a post. This can be
     used as and API for external clients.
     """
 
     post = get_object_or_404(Post, id=post_id)
 
     json = serializers.serialize("json", [post], fields=(
         "pub_time", "_text_rendered", "title", "text", "image",
         "image_width", "image_height", "replies", "tags"
     ))
 
     return HttpResponse(content=json)
 
 
 def api_get_preview(request):
     raw_text = request.POST['raw_text']
 
     parser = Parser()
     return HttpResponse(content=parser.parse(parser.preparse(raw_text)))
 
 
 def api_get_new_posts(request):
     """
     Gets favorite threads and unread posts count.
     """
     posts = list()
 
     include_posts = 'include_posts' in request.GET
 
     settings_manager = get_settings_manager(request)
     fav_threads = settings_manager.get_fav_threads()
     fav_thread_ops = Post.objects.filter(id__in=fav_threads.keys())\
         .order_by('-pub_time').prefetch_related('thread')
 
     ops = [{'op': op, 'last_id': fav_threads[str(op.id)]} for op in fav_thread_ops]
     if include_posts:
         new_post_threads = Thread.objects.get_new_posts(ops)
         if new_post_threads:
             thread_ids = {thread.id: thread for thread in new_post_threads}
         else:
             thread_ids = dict()
 
         for op in fav_thread_ops:
             fav_thread_dict = dict()
 
             op_thread = op.get_thread()
             if op_thread.id in thread_ids:
                 thread = thread_ids[op_thread.id]
                 new_post_count = thread.new_post_count
                 fav_thread_dict['newest_post_link'] = thread.get_replies()\
                         .filter(id__gt=fav_threads[str(op.id)])\
                         .first().get_absolute_url(thread=thread)
             else:
                 new_post_count = 0
             fav_thread_dict['new_post_count'] = new_post_count
 
             fav_thread_dict['id'] = op.id
 
             fav_thread_dict['post_url'] = op.get_link_view()
             fav_thread_dict['title'] = op.title
 
             posts.append(fav_thread_dict)
     else:
         fav_thread_dict = dict()
         fav_thread_dict['new_post_count'] = \
             Thread.objects.get_new_post_count(ops)
         posts.append(fav_thread_dict)
 
     return HttpResponse(content=json.dumps(posts))

boards/views/landing.py

@@ -1,40 +1,42 b''
 from datetime import datetime
 from datetime import timedelta
 
 from django.db.models import Count
 from django.shortcuts import render
 from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_protect
 
 from boards import settings
 from boards.models import Post
 from boards.models import Tag, Attachment, STATUS_ACTIVE
+from boards.models.tag import DEFAULT_LOCALE
 from boards.views.base import BaseBoardView
 
 PARAM_SECTION_STR = 'section_str'
 PARAM_LATEST_THREADS = 'latest_threads'
 
 TEMPLATE = 'boards/landing.html'
 
 
 class LandingView(BaseBoardView):
     @method_decorator(csrf_protect)
     def get(self, request):
         params = dict()
 
         params[PARAM_SECTION_STR] = Tag.objects.get_tag_url_list(
-                Tag.objects.filter(required=True))
+                Tag.objects.filter(required=True).filter(
+                    aliases__locale=DEFAULT_LOCALE).order_by('aliases__name'))
 
         today = datetime.now() - timedelta(1)
         ops = Post.objects.filter(thread__replies__pub_time__gt=today, opening=True, thread__status=STATUS_ACTIVE)\
                   .annotate(today_post_count=Count('thread__replies'))\
                   .order_by('-pub_time')
 
         max_landing_threads = settings.get_int('View', 'MaxFavoriteThreads')
         if max_landing_threads > 0:
             ops = ops[:max_landing_threads]
 
         params[PARAM_LATEST_THREADS] = ops
 
         return render(request, TEMPLATE, params)
 

boards/views/tag_threads.py

@@ -1,118 +1,124 b''
 from django.shortcuts import get_object_or_404, redirect
 from django.core.urlresolvers import reverse
 
 from boards.abstracts.settingsmanager import get_settings_manager, \
         SETTING_FAVORITE_TAGS, SETTING_HIDDEN_TAGS
-from boards.models import Tag
+from boards.models import Tag, TagAlias
 from boards.views.all_threads import AllThreadsView
 from boards.views.mixins import DispatcherMixin, PARAMETER_METHOD
 from boards.forms import ThreadForm, PlainErrorList
 
 PARAM_HIDDEN_TAGS = 'hidden_tags'
 PARAM_TAG = 'tag'
 PARAM_IS_FAVORITE = 'is_favorite'
 PARAM_IS_HIDDEN = 'is_hidden'
 PARAM_RANDOM_IMAGE_POST = 'random_image_post'
 PARAM_RELATED_TAGS = 'related_tags'
 
 
 __author__ = 'neko259'
 
 
 class TagView(AllThreadsView, DispatcherMixin):
 
     tag_name = None
 
     def get_threads(self):
-        tag = get_object_or_404(Tag, name=self.tag_name)
+        tag_alias = get_object_or_404(TagAlias, name=self.tag_name)
+        tag = tag_alias.parent
 
         hidden_tags = self.settings_manager.get_hidden_tags()
 
         try:
             hidden_tags.remove(tag)
         except ValueError:
             pass
 
         return tag.get_threads().exclude(
             tags__in=hidden_tags)
 
     def get_context_data(self, **kwargs):
         params = super(TagView, self).get_context_data(**kwargs)
 
         settings_manager = get_settings_manager(kwargs['request'])
 
-        tag = get_object_or_404(Tag, name=self.tag_name)
+        tag_alias = get_object_or_404(TagAlias, name=self.tag_name)
+        tag = tag_alias.parent
         params[PARAM_TAG] = tag
 
         fav_tag_names = settings_manager.get_setting(SETTING_FAVORITE_TAGS)
         hidden_tag_names = settings_manager.get_setting(SETTING_HIDDEN_TAGS)
 
-        params[PARAM_IS_FAVORITE] = fav_tag_names is not None and tag.name in fav_tag_names
-        params[PARAM_IS_HIDDEN] = hidden_tag_names is not None and tag.name in hidden_tag_names
+        params[PARAM_IS_FAVORITE] = fav_tag_names is not None and tag.get_name() in fav_tag_names
+        params[PARAM_IS_HIDDEN] = hidden_tag_names is not None and tag.get_name() in hidden_tag_names
 
         params[PARAM_RANDOM_IMAGE_POST] = tag.get_random_image_post()
         params[PARAM_RELATED_TAGS] = tag.get_related_tags()
 
         return params
 
     def get_reverse_url(self):
         return reverse('tag', kwargs={'tag_name': self.tag_name})
 
     def get(self, request, tag_name, form=None):
         self.tag_name = tag_name
 
         return super(TagView, self).get(request, form)
 
 
     def post(self, request, tag_name):
         self.tag_name = tag_name
 
         if PARAMETER_METHOD in request.POST:
             self.dispatch_method(request)
 
             return redirect('tag', tag_name)
         else:
             form = ThreadForm(request.POST, request.FILES,
                               error_class=PlainErrorList)
             form.session = request.session
 
             if form.is_valid():
                 return self.create_thread(request, form)
             if form.need_to_ban:
                 # Ban user because he is suspected to be a bot
                 self._ban_current_user(request)
 
             return self.get(request, tag_name, form)
 
     def subscribe(self, request):
-        tag = get_object_or_404(Tag, name=self.tag_name)
+        alias = get_object_or_404(TagAlias, name=self.tag_name)
+        tag = alias.parent
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_fav_tag(tag)
 
     def unsubscribe(self, request):
-        tag = get_object_or_404(Tag, name=self.tag_name)
+        alias = get_object_or_404(TagAlias, name=self.tag_name)
+        tag = alias.parent
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_fav_tag(tag)
 
     def hide(self, request):
         """
         Adds tag to user's hidden tags. Threads with this tag will not be
         shown.
         """
 
-        tag = get_object_or_404(Tag, name=self.tag_name)
+        alias = get_object_or_404(TagAlias, name=self.tag_name)
+        tag = alias.parent
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_hidden_tag(tag)
 
     def unhide(self, request):
         """
         Removed tag from user's hidden tags.
         """
 
-        tag = get_object_or_404(Tag, name=self.tag_name)
+        alias = get_object_or_404(TagAlias, name=self.tag_name)
+        tag = alias.parent
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_hidden_tag(tag)