Show domain next to URL if available

boards/forms/__init__.py

@@ -1,483 +1,483
 import hashlib
 import logging
 import re
 import time
 
 import pytz
 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
 
 import boards.settings as board_settings
 import neboard
 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 Tag
-from boards.models.attachment.downloaders import download
+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 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|magnet):\/\/', 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')
 
 ERROR_SPEED = 'Please wait %(delay)d second before sending message'
 ERROR_SPEED_PLURAL = 'Please wait %(delay)d seconds before sending message'
 ERROR_MANY_FILES = _('Too many files.')
 
 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)
     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
     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)
 
         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(ERROR_MANY_FILES)
         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))
 
         return files
 
     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:
             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):
+                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._errors['text'] = self.error_class([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._errors['text'] = self.error_class([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._errors['text'] = self.error_class(
                 [_('Invalid PoW.')])
 
 
 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():
             if tag_string.strip().lower() == default_tag_name:
                 required_tag_exists = True
                 tag, created = Tag.objects.get_or_create(
                         name=tag_string.strip().lower(), required=True)
             else:
                 tag, created = Tag.objects.get_or_create(
                         name=tag_string.strip().lower())
             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=settings.THEMES, label=_('Theme'))
     image_viewer = forms.ChoiceField(choices=settings.IMAGE_VIEWERS, 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/management/commands/statistics.py

@@ -1,35 +1,34
 from django.core.management import BaseCommand
 from django.db.models import Count
 
 from boards.models import Attachment
 from boards.utils import get_domain
 
 
 class Command(BaseCommand):
     help = 'Gather board statistics'
 
     def handle(self, *args, **options):
         print('* Domains and their usage')
         domains = {}
         for attachment in Attachment.objects.exclude(url=''):
-            full_domain = attachment.url.split('/')[2]
-            domain = get_domain(full_domain)
+            domain = get_domain(attachment.url)
             if domain in domains:
                 domains[domain] += 1
             else:
                 domains[domain] = 1
 
         for domain in domains:
             print('{}: {}'.format(domain, domains[domain]))
 
         print('* Overall numbers')
         print('{} attachments in the system, {} of them as URLs'.format(
             Attachment.objects.count(),
             Attachment.objects.exclude(url='').count()))
 
         print('* File types')
         mimetypes = Attachment.objects.filter(url='')\
-                .values('mimetype').annotate(count=Count('id'))\
-                .order_by('-count')
+            .values('mimetype').annotate(count=Count('id'))\
+            .order_by('-count')
         for mimetype in mimetypes:
             print('{}: {}'.format(mimetype['mimetype'], mimetype['count']))

boards/models/attachment/downloaders.py

@@ -1,95 +1,97
-import os
 import re
 
-from django.core.files.uploadedfile import SimpleUploadedFile, \
-    TemporaryUploadedFile
+import requests
+from django.core.files.uploadedfile import TemporaryUploadedFile
 from pytube import YouTube
-import requests
 
 from boards.utils import validate_file_size
 
 YOUTUBE_VIDEO_FORMAT = 'webm'
 
 HTTP_RESULT_OK = 200
 
 HEADER_CONTENT_LENGTH = 'content-length'
 HEADER_CONTENT_TYPE = 'content-type'
 
 FILE_DOWNLOAD_CHUNK_BYTES = 200000
 
-YOUTUBE_URL = re.compile(r'https?://((www\.)?youtube\.com/watch\?v=|youtu.be/)[-\w]+')
+REGEX_YOUTUBE_URL = re.compile(r'https?://((www\.)?youtube\.com/watch\?v=|youtu.be/)[-\w]+')
+REGEX_MAGNET = re.compile(r'magnet:\?xt=urn:(btih:)?[a-z0-9]{20,50}.*')
 
 TYPE_URL_ONLY = (
     'application/xhtml+xml',
     'text/html',
 )
 
 
 class Downloader:
     @staticmethod
     def handles(url: str) -> bool:
         return False
 
     @staticmethod
     def download(url: str):
         # Verify content headers
         response_head = requests.head(url, verify=False)
         content_type = response_head.headers[HEADER_CONTENT_TYPE].split(';')[0]
         length_header = response_head.headers.get(HEADER_CONTENT_LENGTH)
         if length_header:
             length = int(length_header)
             validate_file_size(length)
         # Get the actual content into memory
         response = requests.get(url, verify=False, stream=True)
 
         # Download file, stop if the size exceeds limit
         size = 0
 
         # Set a dummy file name that will be replaced
         # anyway, just keep the valid extension
         filename = 'file.' + content_type.split('/')[1]
 
         file = TemporaryUploadedFile(filename, content_type, 0, None, None)
         for chunk in response.iter_content(FILE_DOWNLOAD_CHUNK_BYTES):
             size += len(chunk)
             validate_file_size(size)
             file.write(chunk)
 
         if response.status_code == HTTP_RESULT_OK:
             return file
 
 
 def download(url):
     for downloader in Downloader.__subclasses__():
         if downloader.handles(url):
             return downloader.download(url)
     # If nobody of the specific downloaders handles this, use generic
     # one
     return Downloader.download(url)
 
 
 class YouTubeDownloader(Downloader):
     @staticmethod
     def download(url: str):
         yt = YouTube()
         yt.from_url(url)
         videos = yt.filter(YOUTUBE_VIDEO_FORMAT)
         if len(videos) > 0:
             video = videos[0]
             return Downloader.download(video.url)
 
     @staticmethod
     def handles(url: str) -> bool:
-        return YOUTUBE_URL.match(url)
+        return REGEX_YOUTUBE_URL.match(url) is not None
 
 
 class NothingDownloader(Downloader):
     @staticmethod
     def handles(url: str) -> bool:
+        if REGEX_MAGNET.match(url) or REGEX_YOUTUBE_URL.match(url):
+            return True
+
         response_head = requests.head(url, verify=False)
         content_type = response_head.headers[HEADER_CONTENT_TYPE].split(';')[0]
-        return content_type in TYPE_URL_ONLY and not YOUTUBE_URL.match(url)
+        return content_type in TYPE_URL_ONLY
 
     @staticmethod
     def download(url: str):
         return None

boards/models/attachment/viewers.py

@@ -1,193 +1,201
 import re
 
 from django.contrib.staticfiles import finders
 from django.contrib.staticfiles.templatetags.staticfiles import static
 from django.core.files.images import get_image_dimensions
 from django.template.defaultfilters import filesizeformat
 
 from boards.utils import get_domain
 
 
 FILE_STUB_IMAGE = 'images/file.png'
 FILE_STUB_URL = 'url'
 
 
 FILE_TYPES_VIDEO = (
     'webm',
     'mp4',
     'mpeg',
     'ogv',
 )
 FILE_TYPE_SVG = 'svg'
 FILE_TYPES_AUDIO = (
     'ogg',
     'mp3',
     'opus',
 )
 FILE_TYPES_IMAGE = (
     'jpeg',
     'jpg',
     'png',
     'bmp',
     'gif',
 )
 
 PLAIN_FILE_FORMATS = {
     'pdf': 'pdf',
     'djvu': 'djvu',
     'txt': 'txt',
     'tex': 'tex',
     'xcf': 'xcf',
     'zip': 'archive',
     'tar': 'archive',
     'gz': 'archive',
 }
 
 URL_PROTOCOLS = {
     'magnet': 'magnet',
 }
 
 CSS_CLASS_IMAGE = 'image'
 CSS_CLASS_THUMB = 'thumb'
 
 
 def get_viewers():
     return AbstractViewer.__subclasses__()
 
 
 def get_static_dimensions(filename):
     file_path = finders.find(filename)
     return get_image_dimensions(file_path)
 
 
 # TODO Move this to utils
 def file_exists(filename):
     return finders.find(filename) is not None
 
 
 class AbstractViewer:
     def __init__(self, file, file_type, hash, url):
         self.file = file
         self.file_type = file_type
         self.hash = hash
         self.url = url
 
     @staticmethod
     def supports(file_type):
         return True
 
     def get_view(self):
         return '<div class="image">'\
                '{}'\
                '<div class="image-metadata"><a href="{}" download >{}, {}</a></div>'\
                '</div>'.format(self.get_format_view(), self.file.url,
                                self.file_type, filesizeformat(self.file.size))
 
     def get_format_view(self):
         if self.file_type in PLAIN_FILE_FORMATS:
             image = 'images/fileformats/{}.png'.format(
                     PLAIN_FILE_FORMATS[self.file_type])
         else:
             image = FILE_STUB_IMAGE
 
         w, h = get_static_dimensions(image)
 
         return '<a href="{}">'\
                '<img class="url-image" src="{}" width="{}" height="{}"/>'\
                '</a>'.format(self.file.url, static(image), w, h)
 
 
 class VideoViewer(AbstractViewer):
     @staticmethod
     def supports(file_type):
         return file_type in FILE_TYPES_VIDEO
 
     def get_format_view(self):
         return '<video width="200" height="150" controls src="{}"></video>'\
                .format(self.file.url)
 
 
 class AudioViewer(AbstractViewer):
     @staticmethod
     def supports(file_type):
         return file_type in FILE_TYPES_AUDIO
 
     def get_format_view(self):
         return '<audio controls src="{}"></audio>'.format(self.file.url)
 
 
 class SvgViewer(AbstractViewer):
     @staticmethod
     def supports(file_type):
         return file_type == FILE_TYPE_SVG
 
     def get_format_view(self):
         return '<a class="thumb" href="{}">'\
                '<img class="post-image-preview" width="200" height="150" src="{}" />'\
                '</a>'.format(self.file.url, self.file.url)
 
 
 class ImageViewer(AbstractViewer):
     @staticmethod
     def supports(file_type):
         return file_type in FILE_TYPES_IMAGE
 
     def get_format_view(self):
         metadata = '{}, {}'.format(self.file.name.split('.')[-1],
                                    filesizeformat(self.file.size))
         width, height = get_image_dimensions(self.file.file)
         preview_path = self.file.path.replace('.', '.200x150.')
         pre_width, pre_height = get_image_dimensions(preview_path)
 
         split = self.file.url.rsplit('.', 1)
         w, h = 200, 150
         thumb_url = '%s.%sx%s.%s' % (split[0], w, h, split[1])
 
         return '<a class="{}" href="{full}">' \
                '<img class="post-image-preview"' \
                ' src="{}"' \
                ' alt="{}"' \
                ' width="{}"' \
                ' height="{}"' \
                ' data-width="{}"' \
                ' data-height="{}" />' \
                '</a>' \
             .format(CSS_CLASS_THUMB,
                     thumb_url,
                     self.hash,
                     str(pre_width),
                     str(pre_height), str(width), str(height),
                     full=self.file.url, image_meta=metadata)
 
 
 class UrlViewer(AbstractViewer):
     @staticmethod
     def supports(file_type):
         return file_type is None
 
     def get_view(self):
         return '<div class="image">' \
                '{}' \
-               '</div>'.format(self.get_format_view())
+               '<div class="image-metadata">{}</div>' \
+               '</div>'.format(self.get_format_view(), get_domain(self.url))
 
     def get_format_view(self):
         protocol = self.url.split('://')[0]
-        full_domain = self.url.split('/')[2]
-        domain = get_domain(full_domain)
+
+        domain = get_domain(self.url)
 
         if protocol in URL_PROTOCOLS:
             url_image_name = URL_PROTOCOLS.get(protocol)
-        else:
+        elif domain:
             filename = 'images/domains/{}.png'.format(domain)
             if file_exists(filename):
                 url_image_name = 'domains/' + domain
             else:
                 url_image_name = FILE_STUB_URL
+        else:
+            url_image_name = FILE_STUB_URL
 
         image_path = 'images/{}.png'.format(url_image_name)
         image = static(image_path)
         w, h = get_static_dimensions(image_path)
 
         return '<a href="{}">' \
                '<img class="url-image" src="{}" width="{}" height="{}"/>' \
                '</a>'.format(self.url, image, w, h)
+
+
+    def _get_protocol(self):
+        pass
+

boards/utils.py

@@ -1,173 +1,179
 """
 This module contains helper functions and helper classes.
 """
 import hashlib
 from boards.abstracts.constants import FILE_DIRECTORY
 from random import random
 import time
 import hmac
 
 from django.core.cache import cache
 from django.db.models import Model
 from django import forms
 from django.template.defaultfilters import filesizeformat
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
 import magic
 import os
 
 import boards
 from boards.settings import get_bool
 from neboard import settings
 
 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 = '.'
 
 KNOWN_DOMAINS = (
         'org.ru',
 )
 
 
 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)
 
 
 def get_websocket_token(user_id='', timestamp=''):
     """
     Create token to validate information provided by new connection.
     """
 
     sign = hmac.new(settings.CENTRIFUGE_PROJECT_SECRET.encode())
     sign.update(settings.CENTRIFUGE_PROJECT_ID.encode())
     sign.update(user_id.encode())
     sign.update(timestamp.encode())
     token = sign.hexdigest()
 
     return token
 
 
 # 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 + ':' + 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')
     if size > max_size:
         raise forms.ValidationError(
             _('File 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):
     # TODO Use something other than random number in file name
     extension = get_extension(old_filename)
     new_name = '{}{}.{}'.format(
         str(int(time.mktime(time.gmtime()))),
         str(int(random() * 1000)),
         extension)
 
     return os.path.join(FILE_DIRECTORY, new_name)
 
 
 def get_file_mimetype(file) -> str:
     file_type = magic.from_buffer(file.chunks().__next__(), mime=True)
     if file_type is None:
         file_type = 'application/octet-stream'
     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.
     """
-    levels = url.split('.')
-    if len(levels) < 2:
-        return url
-
-    top = levels[-1]
-    second = levels[-2]
+    domain_parts = url.split('/')
+    if len(domain_parts) >= 2:
+        full_domain = domain_parts[2]
+    else:
+        full_domain = ''
 
-    has_third_level = len(levels) > 2
-    if has_third_level:
-        third = levels[-3]
+    result = full_domain
+    if full_domain:
+        levels = full_domain.split('.')
+        if len(levels) >= 2:
+            top = levels[-1]
+            second = levels[-2]
 
-    if has_third_level and ('{}.{}'.format(second, top) in KNOWN_DOMAINS):
-        result = '{}.{}.{}'.format(third, second, top)
-    else:
-        result = '{}.{}'.format(second, top)
+            has_third_level = len(levels) > 2
+            if has_third_level:
+                third = levels[-3]
+
+            if has_third_level and ('{}.{}'.format(second, top) in KNOWN_DOMAINS):
+                result = '{}.{}.{}'.format(third, second, top)
+            else:
+                result = '{}.{}'.format(second, top)
 
     return result