Removed obsolete code. Added download link to files

boards/abstracts/tripcode.py

@@ -1,30 +1,26 b''
 class Tripcode:
     def __init__(self, code_str):
         self.tripcode = code_str
 
     def get_color(self):
         return self.tripcode[:6]
 
     def get_background(self):
         code = self.get_color()
         result = ''
 
         for i in range(0, len(code), 2):
             p = code[i:i+2]
             background = hex(255 - int(p, 16))[2:]
             if len(background) < 2:
                 background = '0' + background
             result += background
 
         return result
 
     def get_short_text(self):
         return self.tripcode[:8]
 
     def get_full_text(self):
         return self.tripcode
 
-    def get_view(self):
-        return '<span class="tripcode" title="{title}" style="border: solid 2px #{color}; border-left: solid 1ex #{color};">{text}</span>'\
-            .format(title=self.get_full_text(), color=self.get_color(),
-                    text=self.get_short_text())

boards/models/attachment/viewers.py

@@ -1,70 +1,70 b''
 from django.template.defaultfilters import filesizeformat
 from django.contrib.staticfiles.templatetags.staticfiles import static
 
 FILE_STUB_IMAGE = 'images/file.png'
 
 FILE_TYPES_VIDEO = (
     'webm',
     'mp4',
 )
 FILE_TYPE_SVG = 'svg'
 FILE_TYPES_AUDIO = (
     'ogg',
     'mp3',
 )
 
 
 def get_viewers():
     return AbstractViewer.__subclasses__()
 
 
 class AbstractViewer:
     def __init__(self, file, file_type):
         self.file = file
         self.file_type = file_type
 
     @staticmethod
     def supports(file_type):
         return True
 
     def get_view(self):
         return '<div class="image">'\
                '{}'\
-               '<div class="image-metadata">{}, {}</div>'\
-               '</div>'.format(self.get_format_view(),
+               '<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):
         return '<a href="{}">'\
                '<img src="{}" width="200" height="150"/>'\
-               '</a>'.format(self.file.url,static(FILE_STUB_IMAGE))
+               '</a>'.format(self.file.url, static(FILE_STUB_IMAGE))
 
 
 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)

boards/models/image.py

@@ -1,112 +1,114 b''
 import hashlib
 import os
 from random import random
 import time
 
 from django.db import models
 from django.template.defaultfilters import filesizeformat
 
 from boards import thumbs, utils
 import boards
 from boards.models.base import Viewable
 
 __author__ = 'neko259'
 
 
 IMAGE_THUMB_SIZE = (200, 150)
 IMAGES_DIRECTORY = 'images/'
 FILE_EXTENSION_DELIMITER = '.'
 HASH_LENGTH = 36
 
 CSS_CLASS_IMAGE = 'image'
 CSS_CLASS_THUMB = 'thumb'
 
 
 class PostImageManager(models.Manager):
     def create_with_hash(self, image):
         image_hash = utils.get_file_hash(image)
         existing = self.filter(hash=image_hash)
         if len(existing) > 0:
             post_image = existing[0]
         else:
             post_image = PostImage.objects.create(image=image)
 
         return post_image
 
     def get_random_images(self, count, include_archived=False, tags=None):
         images = self.filter(post_images__thread__archived=include_archived)
         if tags is not None:
             images = images.filter(post_images__threads__tags__in=tags)
         return images.order_by('?')[:count]
 
 
 class PostImage(models.Model, Viewable):
     objects = PostImageManager()
 
     class Meta:
         app_label = 'boards'
         ordering = ('id',)
 
     def _update_image_filename(self, filename):
         """
         Gets unique image filename
         """
 
         # TODO Use something other than random number in file name
         new_name = '{}{}.{}'.format(
             str(int(time.mktime(time.gmtime()))),
             str(int(random() * 1000)),
             filename.split(FILE_EXTENSION_DELIMITER)[-1:][0])
 
         return os.path.join(IMAGES_DIRECTORY, new_name)
 
     width = models.IntegerField(default=0)
     height = models.IntegerField(default=0)
 
     pre_width = models.IntegerField(default=0)
     pre_height = models.IntegerField(default=0)
 
     image = thumbs.ImageWithThumbsField(upload_to=_update_image_filename,
                                         blank=True, sizes=(IMAGE_THUMB_SIZE,),
                                         width_field='width',
                                         height_field='height',
                                         preview_width_field='pre_width',
                                         preview_height_field='pre_height')
     hash = models.CharField(max_length=HASH_LENGTH)
 
     def save(self, *args, **kwargs):
         """
         Saves the model and computes the image hash for deduplication purposes.
         """
 
         if not self.pk and self.image:
             self.hash = utils.get_file_hash(self.image)
         super(PostImage, self).save(*args, **kwargs)
 
     def __str__(self):
         return self.image.url
 
     def get_view(self):
         metadata = '{}, {}'.format(self.image.name.split('.')[-1],
                                    filesizeformat(self.image.size))
         return '<div class="{}">' \
                '<a class="{}" href="{full}">' \
                '<img class="post-image-preview"' \
                ' src="{}"' \
                ' alt="{}"' \
                ' width="{}"' \
                ' height="{}"' \
                ' data-width="{}"' \
                ' data-height="{}" />' \
                '</a>' \
-               '<div class="image-metadata">{image_meta}</div>' \
+               '<div class="image-metadata">'\
+               '<a href="{full}" download>{image_meta}</a>'\
+               '</div>' \
                '</div>'\
             .format(CSS_CLASS_IMAGE, CSS_CLASS_THUMB,
                     self.image.url_200x150,
                     str(self.hash), str(self.pre_width),
                     str(self.pre_height), str(self.width), str(self.height),
                     full=self.image.url, image_meta=metadata)
 
     def get_random_associated_post(self):
         posts = boards.models.Post.objects.filter(images__in=[self])
         return posts.order_by('?').first()