Fixed image search by google. Added duplicates search for images

boards/config/default_settings.ini

@@ -1,45 +1,48 b''
 [Version]
 Version = 4.0.0 2017
 SiteName = Neboard DEV
 
 [Cache]
 # Timeout for caching, if cache is used
 CacheTimeout = 600
 
 [Forms]
 # Max post length in characters
 MaxTextLength = 30000
 MaxFileSize = 8000000
 LimitFirstPosting = true
 LimitPostingSpeed = false
 PowDifficulty = 0
 # Delay in seconds
 PostingDelay = 30
 Autoban = false
 DefaultTag = test
 MaxFileCount = 1
 
 [Messages]
 # Thread bumplimit
 MaxPostsPerThread = 10
 ThreadArchiveDays = 300
 AnonymousMode = false
 
 [View]
 DefaultTheme = md
 DefaultImageViewer = simple
 LastRepliesCount = 3
 ThreadsPerPage = 3
 PostsPerPage = 10
 ImagesPerPageGallery = 20
 MaxFavoriteThreads = 20
 MaxLandingThreads = 20
 Themes=md:Mystic Dark,md_centered:Mystic Dark (centered),sw:Snow White,pg:Photon Grey,ad:Amanita Dark,iw:Inocibe White
 ImageViewers=simple:Simple,popup:Popup
 
 [Storage]
 # Enable archiving threads instead of deletion when the thread limit is reached
 ArchiveThreads = true
 
 [RSS]
 MaxItems = 20
+
+[External]
+ImageSearchHost=http://127.0.0.1/

boards/templates/boards/thread_gallery.html

@@ -1,39 +1,40 b''
 {% extends "boards/thread.html" %}
 
 {% load i18n %}
 {% load static from staticfiles %}
 {% load board %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
     <title>{{ thread.get_opening_post.get_title|striptags|truncatewords:10 }}
         - {{ site_name }}</title>
 {% endblock %}
 
 {% block thread_content %}
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     <div id="posts-table">
         {% if posts %}
             {% for post in posts %}
                 {% for image in post.get_images %}
                     <div class="gallery_image">
                         {% autoescape off %}
                             {{ image.get_view }}
                             <div class="gallery_image_metadata">
                                 {{ image.get_size.0 }}x{{ image.get_size.1 }}
-                                {% image_actions image.file.url request.get_host %}
+                                {% image_actions image.file.url %},
+                                [<a href="{% url 'feed' %}?image_hash={{ image.hash }}">{{ site_name }}</a>]
                                 <br />
                                 <a href="{{ post.get_absolute_url }}">>>{{ post.id }}</a>
                             </div>
                         {% endautoescape %}
                     </div>
                 {% endfor %}
             {% endfor %}
         {% else %}
             {% trans 'No images.' %}
         {% endif %}
     </div>
 {% endblock %}

boards/templatetags/board.py

@@ -1,119 +1,123 b''
 import re
 
 from django.shortcuts import get_object_or_404
 from django import template
 from django.utils.text import re_tag
+from django.core.urlresolvers import reverse
 
 from boards.mdx_neboard import LINE_BREAK_HTML
+from boards import settings
 
 
 IMG_ACTION_URL = '[<a href="{}">{}</a>]'
 REGEX_NEWLINE = re.compile(LINE_BREAK_HTML)
 TRUNCATOR = '...'
 HTML4_SINGLETS =(
     'br', 'col', 'link', 'base', 'img', 'param', 'area', 'hr', 'input'
 )
 
 
 register = template.Library()
 
 actions = [
     {
         'name': 'google',
-        'link': 'http://google.com/searchbyimage?image_url=%s',
+        'link': 'https://www.google.com/searchbyimage?image_url={}',
     },
     {
         'name': 'iqdb',
-        'link': 'http://iqdb.org/?url=%s',
+        'link': 'http://iqdb.org/?url={}',
     },
 ]
 
 
 @register.simple_tag(name='post_url')
 def post_url(*args, **kwargs):
     post_id = args[0]
 
     post = get_object_or_404('Post', id=post_id)
 
     return post.get_absolute_url()
 
 
 @register.simple_tag(name='image_actions')
 def image_actions(*args, **kwargs):
     image_link = args[0]
-    if len(args) > 1:
-        image_link = 'http://' + args[1] + image_link  # TODO https?
+    host = settings.get('External', 'ImageSearchHost')
+    if host.endswith('/'):
+        host = host[:-1]
+    image_link = settings.get('External', 'ImageSearchHost') + image_link
 
     return ', '.join([IMG_ACTION_URL.format(
-        action['link'] % image_link, action['name']) for action in actions])
+        action['link'].format(image_link), action['name']) for action in actions])
 
 
 @register.inclusion_tag('boards/post.html', name='post_view', takes_context=True)
 def post_view(context, post, *args, **kwargs):
     kwargs['perms'] = context['perms']
     return post.get_view_params(*args, **kwargs)
 
 
 @register.simple_tag(name='page_url')
 def page_url(paginator, page_number, *args, **kwargs):
     if paginator.supports_urls():
         return paginator.get_page_url(page_number)
 
 
 @register.filter(name='truncatenewlines_html')
 def truncatenewlines_html(value, arg):
     end_pos = 0
     start_pos = 0
     match_count = 0
 
     # Collect places for truncation
     while match_count <= arg:
         m = REGEX_NEWLINE.search(value, end_pos)
         if m is None:
             break
         else:
             match_count += 1
             end_pos = m.end()
             start_pos = m.start()
 
     # Find and close open tags
     if match_count > arg:
         truncate_pos = start_pos
 
         open_tags = []
         text = value[:truncate_pos]
         current_pos = 0
         while True:
             tag = re_tag.search(text, current_pos)
             if tag is None:
                 break
             else:
                 closing_tag, tagname, self_closing = tag.groups()
                 tagname = tagname.lower()
                 if self_closing or tagname in HTML4_SINGLETS:
                     pass
                 elif closing_tag:
                     # Check for match in open tags list
                     try:
                         i = open_tags.index(tagname)
                     except ValueError:
                         pass
                     else:
                         # SGML: An end tag closes, back to the matching start tag,
                         # all unclosed intervening start tags with omitted end tags
                         open_tags = open_tags[i + 1:]
                 else:
                     # Add it to the start of the open tags list
                     open_tags.insert(0, tagname)
 
                 current_pos = tag.end()
 
         if not text.endswith(TRUNCATOR):
             text += TRUNCATOR
         for tag in open_tags:
             text += '</{}>'.format(tag)
     else:
         text = value
 
     return text
 

boards/views/feed.py

@@ -1,74 +1,123 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_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
+
+
+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)
+        return filtered_posts
+
+
+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
+
+
+class HashFilter(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)
+        return filtered_posts
+
+
 class FeedView(PostMixin, BaseBoardView):
+    filters = (
+            TripcodeFilter,
+            FavoritesFilter,
+            IpFilter,
+            HashFilter,
+    )
 
     def get(self, request):
         page = request.GET.get('page', DEFAULT_PAGE)
-        tripcode = request.GET.get('tripcode', None)
-        favorites = 'favorites' in request.GET
-        ip = request.GET.get('ip', None)
 
         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')
-        if tripcode:
-            posts = posts.filter(tripcode=tripcode)
-        if favorites:
-            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]
-            posts = posts.filter(thread__in=fav_threads)
-        if ip and request.user.has_perm('post_delete'):
-            posts = posts.filter(poster_ip=ip)
+        for filter in self.filters:
+            posts = filter.get_filtered_posts(request, posts)
 
         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())