Don't return posts with the same image in random view

boards/models/image.py

@@ -1,110 +1,120 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
+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 = self.get_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_hash(self, image):
         """
         Gets hash of an image.
         """
         md5 = hashlib.md5()
         for chunk in image.chunks():
             md5.update(chunk)
         return md5.hexdigest()
 
+    def get_random_images(self, count):
+        return self.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
         """
 
         path = IMAGES_DIRECTORY
 
         # 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(path, 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 = PostImage.objects.get_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>'\
             .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):
+        return boards.models.Post.objects.filter(images__in=[self])\
+            .order_by('?').first()

boards/templates/boards/random.html

@@ -1,32 +1,32 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 
 {% block head %}
     <title>{% trans 'Random images' %} - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
 
-    {% if posts %}
+    {% if images %}
         <div class="random-images-table">
             <div>
-            {% for post in posts %}
+            {% for image in images %}
                 <div class="gallery_image">
-                {% with post.get_first_image as image %}
                     {% autoescape off %}
                         {{ image.get_view }}
                     {% endautoescape %}
-                    <a href="{{ post.get_absolute_url }}">>>{{ post.id }}</a>
-                {% endwith %}
+                    {% with image.get_random_associated_post as post %}
+                        <a href="{{ post.get_absolute_url }}">>>{{ post.id }}</a>
+                    {% endwith %}
                 </div>
                 {% if forloop.counter|divisibleby:"3" %}
                 </div>
                 <div>
                 {% endif %}
             {% endfor %}
             </div>
         </div>
     {% endif %}
 
 {% endblock %}

boards/views/random.py

@@ -1,28 +1,22 b''
 from django.shortcuts import render
-from django.template import RequestContext
 from django.views.generic import View
-from django.db.models import Count
 
-from boards.models import Post
-from boards.mdx_neboard import Parser
+from boards.models import PostImage
 
 __author__ = 'neko259'
 
 TEMPLATE = 'boards/random.html'
 
-CONTEXT_POSTS = 'posts'
+CONTEXT_IMAGES = 'images'
 
 RANDOM_POST_COUNT = 9
 
 
 class RandomImageView(View):
     def get(self, request):
         params = dict()
 
-        posts = Post.objects.annotate(images_count=Count(
-            'images')).filter(images_count__gt=0).order_by('?')\
-                    [:RANDOM_POST_COUNT]
-
-        params[CONTEXT_POSTS] = posts
+        params[CONTEXT_IMAGES] = PostImage.objects.get_random_images(
+            RANDOM_POST_COUNT)
 
         return render(request, TEMPLATE, params)