Search duplicates for file, not hash

boards/models/attachment/viewers.py

@@ -1,231 +1,231 b''
 import re
 
 from PIL import Image
 
 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 django.core.urlresolvers import reverse
 from django.utils.translation import ugettext_lazy as _, ungettext_lazy
 
 from boards.utils import get_domain, cached_result
 from boards import settings
 
 
 FILE_STUB_IMAGE = 'images/file.png'
 FILE_STUB_URL = 'url'
 FILE_FILEFORMAT = 'images/fileformats/{}.png'
 
 
 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 = {
     'zip': 'archive',
     'tar': 'archive',
     'gz': 'archive',
     'mid' : 'midi',
 }
 
 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):
         search_host = settings.get('External', 'ImageSearchHost')
         if search_host:
             if search_host.endswith('/'):
                 search_host = search_host[:-1]
             search_url = search_host + self.file.url
         else:
             search_url = ''
 
         return '<div class="image">'\
                '{}'\
                '<div class="image-metadata"><a href="{}" download >{}, {}</a>'\
-               ' <a class="file-menu" href="#" data-type="{}" data-search-url="{}" data-hash="{}">🔍 </a></div>'\
+               ' <a class="file-menu" href="#" data-type="{}" data-search-url="{}" data-filename="{}">🔍 </a></div>'\
                '</div>'.format(self.get_format_view(), self.file.url,
                                self.file_type, filesizeformat(self.file.size),
-                               self.file_type, search_url, self.hash)
+                               self.file_type, search_url, self.file.name)
 
     def get_format_view(self):
         image_name = PLAIN_FILE_FORMATS.get(self.file_type, self.file_type)
         file_name = FILE_FILEFORMAT.format(image_name)
 
         if file_exists(file_name):
             image = file_name
         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))
 
         try:
             width, height = get_image_dimensions(self.file.path)
         except Exception:
             # If the image is a decompression bomb, treat it as just a regular
             # file
             return super().get_format_view()
 
         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 class="image-metadata">{}</div>' \
                '</div>'.format(self.get_format_view(), get_domain(self.url))
 
     def get_format_view(self):
         protocol = self.url.split(':')[0]
 
         domain = get_domain(self.url)
 
         if protocol in URL_PROTOCOLS:
             url_image_name = URL_PROTOCOLS.get(protocol)
         elif domain:
             url_image_name = self._find_image_for_domains(domain) or 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)
 
     @cached_result()
     def _find_image_for_domains(self, domain):
         """
         Searches for the domain image for every domain level except top.
         E.g. for l3.example.co.uk it will search for l3.example.co.uk, then
         example.co.uk, then co.uk
         """
         levels = domain.split('.')
         while len(levels) > 1:
             domain = '.'.join(levels)
 
             filename = 'images/domains/{}.png'.format(domain)
             if file_exists(filename):
                 return 'domains/' + domain
             else:
                 del levels[0]
 

boards/static/js/main.js

@@ -1,220 +1,220 b''
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
  Copyright (C) 2013  neko259
 
  The JavaScript code in this page is free software: you can
  redistribute it and/or modify it under the terms of the GNU
  General Public License (GNU GPL) as published by the Free Software
  Foundation, either version 3 of the License, or (at your option)
  any later version.  The code is distributed WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
 
  As additional permission under GNU GPL version 3 section 7, you
  may distribute non-source (e.g., minimized or compacted) forms of
  that code without the copy of the GNU GPL normally required by
  section 4, provided you include this license notice and a URL
  through which recipients can access the Corresponding Source.
 
  @licend  The above is the entire license notice
  for the JavaScript code in this page.
  */
 
 var ITEM_VOLUME_LEVEL = 'volumeLevel';
 var IMAGE_TYPES = ['png', 'jpg', 'jpeg', 'bmp'];
 
 /**
  * An email is a hidden file to prevent spam bots from posting. It has to be
  * hidden.
  */
 function hideEmailFromForm() {
     $('.form-email').parent().parent().hide();
 }
 
 /**
  * Highlight code blocks with code highlighter
  */
 function highlightCode(node) {
     node.find('pre code').each(function(i, e) {
         hljs.highlightBlock(e);
     });
 }
 
 function updateFavPosts(data) {
     var includePostBody = $('#fav-panel').is(":visible");
 
     var allNewPostCount = 0;
 
     if (includePostBody) {
         var favoriteThreadPanel = $('#fav-panel');
         favoriteThreadPanel.empty();
     }
 
     $.each($.parseJSON(data), function (_, dict) {
         var newPostCount = dict.new_post_count;
         allNewPostCount += newPostCount;
 
         if (includePostBody) {
             var favThreadNode = $('<div class="post"></div>');
             favThreadNode.append($(dict.post_url));
             favThreadNode.append(' ');
             favThreadNode.append($('<span class="title">' + dict.title + '</span>'));
 
             if (newPostCount > 0) {
                 favThreadNode.append(' (<a href="' + dict.newest_post_link + '">+' + newPostCount + "</a>)");
             }
 
             favoriteThreadPanel.append(favThreadNode);
 
             addRefLinkPreview(favThreadNode[0]);
         }
     });
 
     var newPostCountNode = $('#new-fav-post-count');
     if (allNewPostCount > 0) {
         newPostCountNode.text('(+' + allNewPostCount + ')');
         newPostCountNode.show();
     } else {
         newPostCountNode.hide();
     }
 }
 
 function initFavPanel() {
     var favPanelButton = $('#fav-panel-btn');
     if (favPanelButton.length > 0 && typeof SharedWorker != 'undefined') {
         var worker = new SharedWorker($('body').attr('data-update-script'));
         worker.port.onmessage = function(e) {
             updateFavPosts(e.data);
         };
         worker.onerror = function(event){
             throw new Error(event.message + " (" + event.filename + ":" + event.lineno + ")");
         };
         worker.port.start();
 
         $(favPanelButton).click(function() {
             var favPanel = $('#fav-panel');
             favPanel.toggle();
 
             worker.port.postMessage({ includePostBody: favPanel.is(':visible')});
 
             return false;
         });
 
         $(document).on('keyup.removepic', function(e) {
             if(e.which === 27) {
                 $('#fav-panel').hide();
             }
         });
     }
 }
 
 function setVolumeLevel(level) {
     localStorage.setItem(ITEM_VOLUME_LEVEL, level);
 }
 
 function getVolumeLevel() {
     var level = localStorage.getItem(ITEM_VOLUME_LEVEL);
     if (level == null) {
         level = 1.0;
     }
     return level
 }
 
 function processVolumeUser(node) {
     if (!window.localStorage) return;
     node.prop("volume", getVolumeLevel());
     node.on('volumechange', function(event) {
         setVolumeLevel(event.target.volume);
         $("video,audio").prop("volume", getVolumeLevel());
     });
 }
 
 /**
  * Add all scripts than need to work on post, when the post is added to the
  * document.
  */
 function addScriptsToPost(post) {
     addRefLinkPreview(post[0]);
     highlightCode(post);
     processVolumeUser(post.find("video,audio"));
 }
 
 /**
  * Fix compatibility issues with some rare browsers
  */
 function compatibilityCrutches() {
     if (window.operamini) {
         $('#form textarea').each(function() { this.placeholder = ''; });
     }
 }
 
 function addContextMenu() {
     $.contextMenu({
         selector: '.file-menu',
         trigger: 'left',
 
         build: function($trigger, e) {
             var fileSearchUrl = $trigger.data('search-url');
             var isImage = IMAGE_TYPES.indexOf($trigger.data('type')) > -1;
             var hasUrl = fileSearchUrl.length > 0;
             return {
                 items: {
                     duplicates: {
                         name: gettext('Duplicates search'),
                         callback: function(key, opts) {
-                            window.location = '/feed/?image_hash=' + $trigger.data('hash');
+                            window.location = '/feed/?image=' + $trigger.data('filename');
                         }
                     },
                     google: {
                         name: 'Google',
                         visible: isImage && hasUrl,
                         callback: function(key, opts) {
                             window.location = 'https://www.google.com/searchbyimage?image_url=' + fileSearchUrl;
                         }
                     },
                     iqdb: {
                         name: 'IQDB',
                         visible: isImage && hasUrl,
                         callback: function(key, opts) {
                             window.location = 'http://iqdb.org/?url=' + fileSearchUrl;
                         }
                     },
                     tineye: {
                         name: 'TinEye',
                         visible: isImage && hasUrl,
                         callback: function(key, opts) {
                             window.location = 'http://tineye.com/search?url=' + fileSearchUrl;
                         }
                     }
                 },
             };
         }
     });
 }
 
 $( document ).ready(function() {
     hideEmailFromForm();
 
     $("a[href='#top']").click(function() {
         $("html, body").animate({ scrollTop: 0 }, "slow");
         return false;
     });
 
     addImgPreview();
 
     addRefLinkPreview();
 
     highlightCode($(document));
 
     initFavPanel();
 
     var volumeUsers = $("video,audio");
     processVolumeUser(volumeUsers);
 
     addContextMenu();
 
     compatibilityCrutches();
 });

boards/views/feed.py

@@ -1,151 +1,151 b''
 from django.core.urlresolvers import reverse
 from django.shortcuts import render
 
 from boards import settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.models import Post
 from boards.views.base import BaseBoardView
 from boards.views.posting_mixin import PostMixin
 
 POSTS_PER_PAGE = settings.get_int('View', 'PostsPerPage')
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_POSTS = 'posts'
 PARAMETER_QUERIES = 'queries'
 
 PARAMETER_PREV_LINK = 'prev_page_link'
 PARAMETER_NEXT_LINK = 'next_page_link'
 
 TEMPLATE = 'boards/feed.html'
 DEFAULT_PAGE = 1
 
 
 class FeedFilter:
     @staticmethod
     def get_filtered_posts(request, posts):
         return posts
 
     @staticmethod
     def get_query(request):
         return None
 
 
 class TripcodeFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
         tripcode = request.GET.get('tripcode', None)
         if tripcode:
             filtered_posts = filtered_posts.filter(tripcode=tripcode)
         return filtered_posts
 
     @staticmethod
     def get_query(request):
         tripcode = request.GET.get('tripcode', None)
         if tripcode:
             return 'Tripcode: {}'.format(tripcode)
 
 
 class FavoritesFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
 
         favorites = 'favorites' in request.GET
         if favorites:
             settings_manager = get_settings_manager(request)
             fav_thread_ops = Post.objects.filter(id__in=settings_manager.get_fav_threads().keys())
             fav_threads = [op.get_thread() for op in fav_thread_ops]
             filtered_posts = filtered_posts.filter(thread__in=fav_threads)
         return filtered_posts
 
 
 class IpFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
 
         ip = request.GET.get('ip', None)
         if ip and request.user.has_perm('post_delete'):
             filtered_posts = filtered_posts.filter(poster_ip=ip)
         return filtered_posts
 
     @staticmethod
     def get_query(request):
         ip = request.GET.get('ip', None)
         if ip:
             return 'IP: {}'.format(ip)
 
 
-class HashFilter(FeedFilter):
+class ImageFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
 
-        image_hash = request.GET.get('image_hash', None)
-        if image_hash:
-            filtered_posts = filtered_posts.filter(attachments__hash=image_hash)
+        image = request.GET.get('image', None)
+        if image:
+            filtered_posts = filtered_posts.filter(attachments__file=image)
         return filtered_posts
 
     @staticmethod
     def get_query(request):
-        image_hash = request.GET.get('image_hash', None)
-        if image_hash:
-            return 'Hash: {}'.format(image_hash)
+        image = request.GET.get('image', None)
+        if image:
+            return 'File: {}'.format(image)
 
 
 class FeedView(PostMixin, BaseBoardView):
     filters = (
             TripcodeFilter,
             FavoritesFilter,
             IpFilter,
-            HashFilter,
+            ImageFilter,
     )
 
     def get(self, request):
         page = request.GET.get('page', DEFAULT_PAGE)
 
         params = self.get_context_data(request=request)
 
         settings_manager = get_settings_manager(request)
 
         posts = Post.objects.exclude(
             thread__tags__in=settings_manager.get_hidden_tags()).order_by(
             '-pub_time').prefetch_related('attachments', 'thread')
         queries = []
         for filter in self.filters:
             posts = filter.get_filtered_posts(request, posts)
             query = filter.get_query(request)
             if query:
                 queries.append(query)
         params[PARAMETER_QUERIES] = queries
 
         paginator = get_paginator(posts, POSTS_PER_PAGE)
         paginator.current_page = int(page)
 
         params[PARAMETER_POSTS] = paginator.page(page).object_list
 
         paginator.set_url(reverse('feed'), request.GET.dict())
 
         self.get_page_context(paginator, params, page)
 
         return render(request, TEMPLATE, params)
 
     # TODO Dedup this into PagedMixin
     def get_page_context(self, paginator, params, page):
         """
         Get pagination context variables
         """
 
         params[PARAMETER_PAGINATOR] = paginator
         current_page = paginator.page(int(page))
         params[PARAMETER_CURRENT_PAGE] = current_page
         if current_page.has_previous():
             params[PARAMETER_PREV_LINK] = paginator.get_page_url(
                     current_page.previous_page_number())
         if current_page.has_next():
             params[PARAMETER_NEXT_LINK] = paginator.get_page_url(
                     current_page.next_page_number())