Added reviews app

examples/vanilla/settings.py

@@ -209,6 +209,7 @@ INSTALLED_APPS = (
     'oscar.apps.promotions',
     'oscar.apps.reports',
     'oscar.apps.search',
+    'oscar.apps.reviews',
     'pyzen',
     'sorl.thumbnail',
 )

oscar/apps/product/urls.py

@@ -2,9 +2,19 @@ from django.conf.urls.defaults import *
 
 from oscar.core.decorators import class_based_view
 from oscar.core.loading import import_module
-import_module('product.views', ['ItemDetailView', 'ProductListView', 'ItemClassListView'], locals())
+import_module('product.views', ['ItemDetailView', 'ProductListView', 'ItemClassListView'], locals())  # basic product stuffs
+import_module('product.views', ['ProductReviewView', 'ProductReviewDetailView',\
+                                 'ProductReviewListView', 'ProductReviewVoteView'], locals())  # product review stuff  
+
+product_url = r'(?P<item_class_slug>[\w-]+)/(?P<item_slug>[\w-]*)-(?P<item_id>\d+)/'
 
 urlpatterns = patterns('oscar.product.views',
+    #product reviews stuff    
+    url(product_url + r'review/(?P<review_id>\d+)/vote/$', class_based_view(ProductReviewVoteView), name='oscar-vote-review'),
+    url(product_url + r'review/(?P<review_id>\d+)/$', ProductReviewDetailView.as_view(), name='oscar-product-review'),
+    url(product_url + r'reviews/$', ProductReviewListView.as_view(), name='oscar-product-reviews'),
+    url(product_url + r'add-review/$', class_based_view(ProductReviewView), name='oscar-product-review-add'),
+    #basic product item stuff
     url(r'(?P<item_class_slug>[\w-]+)/(?P<item_slug>[\w-]*)-(?P<item_id>\d+)/$', ItemDetailView.as_view(), name='oscar-product-item'),
     url(r'(?P<item_class_slug>[\w-]+)/$', ItemClassListView.as_view(), name='oscar-product-item-class'),
     url(r'^$', ProductListView.as_view(), name='oscar-products'),

oscar/apps/product/views.py

@@ -1,18 +1,24 @@
 from django.conf import settings
 from django.http import HttpResponse, Http404, HttpResponsePermanentRedirect, HttpResponseRedirect
 from django.template import Context, loader, RequestContext
-from django.shortcuts import get_object_or_404
+from django.shortcuts import get_object_or_404, render
 from django.core.urlresolvers import reverse
 from django.core.paginator import Paginator, InvalidPage, EmptyPage
 from django.views.generic import ListView, DetailView
 from django.template.response import TemplateResponse
+from django.db.models import Avg
+from django.core.exceptions import ObjectDoesNotExist
+from django.contrib import messages
 
 from oscar.core.loading import import_module
+from oscar.apps.reviews.models import ProductReview, Vote
+from oscar.apps.reviews.forms import make_review_form, ProductReviewForm
 
 product_models = import_module('product.models', ['Item', 'ItemClass'])
 product_signals = import_module('product.signals', ['product_viewed', 'product_search'])
 basket_forms = import_module('basket.forms', ['FormFactory'])
 history_helpers = import_module('customer.history_helpers', ['receive_product_view'])
+review_models = import_module('reviews.models', ['ProductReview', 'Vote'])
 
 
 class ItemDetailView(DetailView):
@@ -64,12 +70,33 @@ class ItemDetailView(DetailView):
     def get_context_data(self, **kwargs):
         context = super(ItemDetailView, self).get_context_data(**kwargs)
         context['basket_form'] = self.get_add_to_basket_form()
+        # product reviews stuffs
+        context['reviews'] = self.get_product_review()
+        context['avg_score'] = self.get_avg_review()
+        context['review_votes'] = self.get_review_votes()
         return context
     
     def get_add_to_basket_form(self):
         factory = basket_forms.FormFactory()
         return factory.create(self.object)
     
+    def get_product_review(self):
+        if settings.OSCAR_MODERATE_REVIEWS:        
+            return ProductReview.approved_only.all()
+        else:
+            return ProductReview.objects.all()
+    
+    def get_avg_review(self):
+        if settings.OSCAR_MODERATE_REVIEWS:        
+            avg = ProductReview.approved_only.aggregate(Avg('score'))
+        else:
+            avg = ProductReview.objects.aggregate(Avg('score'))
+        return avg['score__avg']
+    
+    def get_review_votes(self):
+        return Vote.objects.all()
+
+    
 class ItemClassListView(ListView):
     u"""View products filtered by item-class."""
     context_object_name = "products"
@@ -114,3 +141,163 @@ class ProductListView(ListView):
             context['summary'] = "Products matching '%s'" % q
             context['search_term'] = q
         return context
+
+
+class ProductReviewView(object):
+    u"""
+    A separate product review page
+    * The URL for browsing a products offers should be the normal product URL with /reviews appended at the end
+    * The product page shows the average score based on the reviews
+    """
+    template_name = "oscar/reviews/add_review.html"
+    def _is_review_done(self):
+        u"""
+        Check if the user already reviewed this product
+        """                
+        try:
+            review = review_models.ProductReview.objects.get(product=self.kwargs['item_id'], user=self.request.user.id)
+            if review:
+                return True
+        except ObjectDoesNotExist:                
+            return False
+    
+    def __call__(self, request, *args, **kwargs):        
+        self.request = request
+        self.args = args
+        self.kwargs = kwargs
+        self.user = self.request.user
+        # get the product                
+        item = get_object_or_404(product_models.Item, pk=self.kwargs['item_id'])                
+        if (self.user.is_authenticated()) and self._is_review_done():            
+            messages.info(self.request, "Your have already reviewed this product!")
+            url = item.get_absolute_url()             
+            return HttpResponsePermanentRedirect(url) 
+        # process request
+        if self.request.method == 'POST':        
+            review_form = make_review_form(self.user, self.request.POST)            
+            if review_form.is_valid():
+                if self.user.is_authenticated():
+                    review = ProductReview(product=item, user=self.request.user)                   
+                elif settings.OSCAR_ALLOW_ANON_REVIEWS:                    
+                    review = ProductReview(product=item, user=None, name=self.request.POST['name'], email=self.request.POST['email'])
+                else:
+                    messages.info(self.request, "Please login to submit a review!")
+                    return HttpResponsePermanentRedirect(item.get_absolute_url())
+                
+                rform = ProductReviewForm(self.request.POST, instance=review)
+                rform.save()
+                messages.info(self.request, "Your review has been submitted successfully!")
+                return HttpResponsePermanentRedirect(item.get_absolute_url())                                                   
+        else:            
+            review_form = make_review_form(self.request.user)
+        
+        return render(self.request, self.template_name, {
+                    "item" : item,
+                    "review_form": review_form,
+                    })
+
+
+class ProductReviewDetailView(DetailView):
+    u"""
+    Places each review on its own page
+    """
+    template_name = "oscar/reviews/review.html"
+    _review = None
+    
+    def get(self, request, **kwargs):
+        u"""
+        Ensures that the correct URL is used
+        """
+        # get the product review                
+        review = self.get_object()        
+        correct_path = review.get_absolute_url()
+        if correct_path != request.path:
+            return HttpResponsePermanentRedirect(correct_path)        
+        return super(ProductReviewDetailView, self).get(request, **kwargs)
+    
+    def get_object(self):
+        u"""
+        Return a review object
+        """
+        try:            
+            self._review = review_models.ProductReview.objects.get(pk=self.kwargs['review_id'])            
+            return self._review
+        except ObjectDoesNotExist:                
+            raise
+    
+    def get_context_data(self, **kwargs):
+        context = super(ProductReviewDetailView, self).get_context_data(**kwargs)        
+        context['review'] = self.get_object()
+        return context
+
+    
+class ProductReviewListView(ListView):
+    u"""A list of reviews for a particular product
+    * The review browsing page allows reviews to be sorted by score, or recency.
+    """    
+    context_object_name = "reviews"
+    model = ProductReview
+    template_name = 'oscar/reviews/reviews.html'
+    paginate_by = 3
+     
+    def get_queryset(self):
+        if 'sort_by' in self.request.GET:
+            if self.request.GET['sort_by'] == 'score':
+                 self.objects = review_models.ProductReview.top_scored.filter(product=self.kwargs['item_id'])
+            elif self.request.GET['sort_by'] == 'recency':
+                 self.objects = review_models.ProductReview.recent.filter(product=self.kwargs['item_id'])
+        else:
+            self.objects = review_models.ProductReview.objects.filter(product=self.kwargs['item_id'])
+        return self.objects 
+     
+    def get_context_data(self, **kwargs):
+        context = super(ProductReviewListView, self).get_context_data(**kwargs)
+        item = get_object_or_404(product_models.Item, pk=self.kwargs['item_id'])    
+        context['item'] = item
+        context['avg_score'] = self.objects.aggregate(Avg('score'))           
+        return context
+
+
+class ProductReviewVoteView(object):
+    u"""Processes voting of product reviews
+    """
+    
+    template_name = "oscar/product/detail.html"   
+    
+    def _is_vote_done(self):
+        u"""
+        Check if the user already reviewed this product
+        """                
+        try:
+            vote = review_models.Vote.objects.get(review=self.kwargs['review_id'])
+            if vote:
+                return True
+        except ObjectDoesNotExist:                
+            return False
+    
+    def __call__(self, request, *args, **kwargs):        
+        self.request = request
+        self.args = args
+        self.kwargs = kwargs
+        template_name = "oscar/product/detail.html" 
+        # get the product                    
+        item = get_object_or_404(product_models.Item, pk=self.kwargs['item_id'])
+        review = get_object_or_404(review_models.ProductReview, pk=self.kwargs['review_id'])
+        if self.request.method == 'POST':
+            if self._is_vote_done():
+                messages.info(self.request, "Your have already voted for this product!")         
+                return HttpResponsePermanentRedirect(item.get_absolute_url()) 
+            else:                                
+                vote = Vote.objects.create(review=review, user=self.request.user, choice=0)                        
+                if self.request.POST['action'] == 'voteup':
+                    vote.choice = 1                    
+                elif self.request.POST['action'] == 'votedown':
+                    vote.choice = -1
+                vote.save()
+                messages.info(self.request, "Your vote has been submitted successfully!")
+                return HttpResponsePermanentRedirect(item.get_absolute_url())                                                   
+        reviews = review_models.ProductReview.approved_only.filter(product=self.kwargs['item_id'])
+        return render(self.request, template_name, {
+                    "item" : item,
+                    "reviews": reviews,
+                    })

oscar/apps/reviews/abstract_models.py

@@ -0,0 +1,130 @@
+"""
+Core product reviews
+"""
+from django.db import models
+from django.utils.translation import gettext as _
+from django.core.urlresolvers import reverse
+from django.core.exceptions import ValidationError
+
+from oscar.apps.reviews.managers import ApprovedReviewsManager,\
+ RecentReviewsManager, TopScoredReviewsManager, TopVotedReviewsManager
+
+
+class AbstractProductReview(models.Model):
+    u"""
+    Superclass ProductReview. Some key aspects have been implemented from the original spec.
+    * Each product can have reviews attached to it. Each review has a title, a body and a score from 1-5.
+    * Signed in users can always submit reviews, anonymous users can only submit reviews if a setting
+      OSCAR_ALLOW_ANON_REVIEWS is set to true - it should default to false.
+    * If anon users can submit reviews, then we require their name, email address and an (optional) URL.
+    * By default, reviews must be approved before they are live.
+      However, if a setting OSCAR_MODERATE_REVIEWS is set to false, then they don't need moderation.
+    * Each review should have a permalink, ie it has its own page.
+    * Each reviews can be voted up or down by other users
+    * Only signed in users can vote
+    * A user can only vote once on each product once
+    """
+    SCORE_CHOICES = (
+        ('1', 1),
+        ('2', 2),
+        ('3', 3),
+        ('4', 4),
+        ('5', 5)
+    )
+    product = models.ForeignKey('product.Item', related_name='product')
+    user = models.ForeignKey('auth.User', related_name='review', null=True, blank=True)
+    # anonymous users
+    name = models.CharField(_("Name"), max_length=100, null=True, blank=True)
+    email = models.EmailField(_("Email"), null=True, blank=True, unique=True)
+    url = models.URLField(_("URL"), null=True, blank=True)
+    # real review stuffs
+    title = models.CharField(_("Title"), max_length=100)
+    body = models.TextField(_("Comment"), max_length=300, blank=True)
+    score = models.CharField(_("Score"), max_length=1, choices=SCORE_CHOICES)
+    approved = models.BooleanField(default=False)
+    date_created = models.DateTimeField(auto_now_add=True)
+    # vote statistics
+    total_votes = models.IntegerField(_("Total Votes"), default=0, blank=True)  # upvotes + down votes
+    delta_votes = models.IntegerField(_("Delta Votes"), default=0, blank=True)  # upvotes - down votes
+    # mangers
+    objects = models.Manager()
+    approved_only = ApprovedReviewsManager()
+    recent = RecentReviewsManager()
+    top_scored = TopScoredReviewsManager()
+    top_voted = TopVotedReviewsManager()
+
+    class Meta:
+        abstract = True
+        ordering = ['-delta_votes']
+
+    def get_absolute_url(self):
+        args = {'review_id': self.id,
+                'item_class_slug': self.product.get_item_class().slug,
+                'item_slug': self.product.slug,
+                'item_id': self.product.id}
+        return reverse('oscar-product-review',  kwargs=args)
+
+    def get_vote_url(self):
+        return reverse('oscar-vote-review',
+                       kwargs={'review_id': self.id,
+                               'item_class_slug': str(self.product.item_class),
+                               'item_slug': self.product.slug,
+                                'item_id': str(self.product.id)})
+
+    def __unicode__(self):
+        return self.title
+
+    def save(self, *args, **kwargs):
+        if not (self.title and self.score):
+            raise ValidationError("Review must have a title")
+        if not self.user:  # anonymous review
+            if not (self.name and self.email):
+                raise ValidationError("Anonymous review must have a name and an email")
+        super(AbstractProductReview, self).save(*args, **kwargs)
+
+    def get_upvotes(self):
+        u"""returns the total yes votes"""
+        return int((self.total_votes + self.delta_votes) / 2)
+
+    def update_votes(self, choice):
+        u""" updates total and delta votes"""
+        self.total_votes += 1
+        self.delta_votes += choice
+        self.save()
+
+
+class AbstractVote(models.Model):
+    u"""
+    Records user ratings as yes/no vote.
+    * Only signed-in users can vote.
+    * Each user can vote only once.
+    """
+    VOTE_CHOICES = ((1, 1), (-1, -1), (0, 0))
+    user = models.ForeignKey('auth.User', related_name='vote')
+    review = models.ForeignKey('reviews.ProductReview', related_name='review')
+    choice = models.SmallIntegerField(choices=VOTE_CHOICES)
+    date_created = models.DateTimeField(auto_now_add=True)
+
+    objects = models.Manager()
+
+    class Meta:
+        abstract = True
+        ordering = ['-date_created']
+        unique_together = (('user', 'review'),)
+
+    def __unicode__(self):
+        return self.review.title
+
+    def save(self, *args, **kwargs):
+        u"""
+        Validates model and raises error if validation fails
+        """
+        if not self.user.is_authenticated():
+                raise ValidationError("Only logged-in users can vote!")
+        if self.choice == None:
+            raise ValidationError("Votes must have a choice (Yes/No)")
+        if self.choice == 0:  # empty vote
+            return
+        else:
+            self.review.update_votes(self.choice)
+        super(AbstractVote, self).save(*args, **kwargs)

oscar/apps/reviews/admin.py

@@ -0,0 +1,16 @@
+from django.contrib import admin
+
+from oscar.apps.reviews.models import ProductReview, Vote
+
+
+class ProductReviewAdmin(admin.ModelAdmin):
+    list_display = ('title', 'score', 'approved', 'date_created', 'total_votes', 'delta_votes')
+    read_only = ('title', 'body', 'score', 'total_votes', 'delta_votes')
+
+
+class VoteAdmin(admin.ModelAdmin):
+    list_display = ('review', 'user', 'choice', 'date_created')
+    read_only = ('review', 'user', 'choice', 'date_created')
+
+admin.site.register(ProductReview, ProductReviewAdmin)
+admin.site.register(Vote, VoteAdmin)

oscar/apps/reviews/fixtures/sample-product.json

@@ -0,0 +1,44 @@
+[
+    {
+        "pk": 1, 
+        "model": "product.itemclass", 
+        "fields": {
+            "options": [], 
+            "name": "books", 
+            "slug": "books"
+        }
+    }, 
+    {
+        "pk": 1, 
+        "model": "product.item", 
+        "fields": {
+            "description": "", 
+            "parent": null, 
+            "title": "The Django Book v2", 
+            "date_updated": "2011-05-19 17:33:27", 
+            "upc": "978-1430219361", 
+            "item_class": 1, 
+            "item_options": [], 
+            "date_created": "2011-05-19 17:32:37", 
+            "slug": "books"
+        }
+    }, 
+    {
+        "pk": 1, 
+        "model": "product.attributetype", 
+        "fields": {
+            "code": "price", 
+            "name": "price", 
+            "has_choices": false
+        }
+    }, 
+    {
+        "pk": 1, 
+        "model": "product.itemattributevalue", 
+        "fields": {
+            "product": 1, 
+            "type": 1, 
+            "value": "25"
+        }
+    }
+]

oscar/apps/reviews/fixtures/sample-reviews.json

@@ -0,0 +1,57 @@
+[
+    {
+        "pk": 2, 
+        "model": "reviews.productreview", 
+        "fields": {
+            "body": "Test review 1 says product is good", 
+            "product": 1, 
+            "name": "", 
+            "title": "Test review 1", 
+            "url": "", 
+            "approved": true, 
+            "score": "4", 
+            "user": 1, 
+            "date_created": "2011-05-19 18:00:48", 
+            "delta_votes": 1, 
+            "email": "", 
+            "total_votes": 1
+        }
+    }, 
+    {
+        "pk": 4, 
+        "model": "reviews.productreview", 
+        "fields": {
+            "body": "anon says we don't know about this product", 
+            "product": 1, 
+            "name": "Anon2", 
+            "title": "Anon review 2", 
+            "url": "", 
+            "approved": true, 
+            "score": "3", 
+            "user": null, 
+            "date_created": "2011-05-20 10:51:54", 
+            "delta_votes": 0, 
+            "email": "axxx@b.com", 
+            "total_votes": 0
+        }
+    }, 
+    {
+        "pk": 3, 
+        "model": "reviews.productreview", 
+        "fields": {
+            "body": "we rate it 5", 
+            "product": 1, 
+            "name": "Anon1", 
+            "title": "another review", 
+            "url": "", 
+            "approved": true, 
+            "score": "5", 
+            "user": null, 
+            "date_created": "2011-05-20 10:10:46", 
+            "delta_votes": -1, 
+            "email": "a@bcd.com", 
+            "total_votes": 1
+        }
+    } 
+    
+]

oscar/apps/reviews/forms.py

@@ -0,0 +1,23 @@
+from django.forms import BaseForm, ModelForm, CharField, EmailField
+
+from oscar.apps.reviews.models import ProductReview
+
+
+class ProductReviewForm(ModelForm):
+    class Meta:
+        model = ProductReview
+        fields = ('title', 'score', 'body')
+
+    def __init__(self, *args, **kwargs):
+        super(ProductReviewForm, self).__init__(*args, **kwargs)
+
+
+def make_review_form(user, values=None):
+    form = ProductReviewForm()
+    fields = form.fields
+    if not user.is_authenticated():
+        fields['name'] = CharField(max_length=100)
+        fields['email'] = EmailField()
+        fields['url'] = CharField(max_length=100, required=False)
+    form_class = type('ProductReviewForm', (BaseForm,), {'base_fields': fields})
+    return form_class(values)

oscar/apps/reviews/managers.py

@@ -0,0 +1,21 @@
+from django.db import models
+
+
+class ApprovedReviewsManager(models.Manager):
+    def get_query_set(self):
+        return super(ApprovedReviewsManager, self).get_query_set().filter(approved=True)
+
+
+class RecentReviewsManager(models.Manager):
+    def get_query_set(self):
+        return super(RecentReviewsManager, self).get_query_set().filter(approved=True).order_by('-date_created')
+
+
+class TopScoredReviewsManager(models.Manager):
+    def get_query_set(self):
+        return super(TopScoredReviewsManager, self).get_query_set().filter(approved=True).order_by('-score')
+
+
+class TopVotedReviewsManager(models.Manager):
+    def get_query_set(self):
+        return super(TopVotedReviewsManager, self).get_query_set().filter(approved=True).order_by('-delta_votes')

oscar/apps/reviews/models.py

@@ -0,0 +1,9 @@
+from oscar.apps.reviews.abstract_models import AbstractProductReview, AbstractVote
+
+
+class ProductReview(AbstractProductReview):
+    pass
+
+
+class Vote(AbstractVote):
+    pass

oscar/apps/reviews/tests.py

@@ -0,0 +1,149 @@
+from random import randint
+from sys import maxint
+from django.test import TestCase, Client
+from django.core.exceptions import ValidationError
+from django.contrib.auth.models import User, AnonymousUser
+from django.db import IntegrityError
+from django.core.urlresolvers import reverse
+from django.utils import unittest
+
+from oscar.apps.product.models import Item, ItemClass
+from oscar.apps.reviews.models import ProductReview, Vote
+
+
+class ProductReviewTests(unittest.TestCase):
+    u"""
+    Basic setup
+    """
+    def setUp(self):
+        username = str(randint(0, maxint))
+        self.user = User.objects.create_user(username, '%s@users.com'%username, '%spass123'%username)
+        self.anon_user = AnonymousUser()
+        self.item_class,_ = ItemClass.objects.get_or_create(name='Books')
+        self.item,_ = Item.objects.get_or_create(title='Django Book v2', item_class=self.item_class)
+        self.review,_ = ProductReview.objects.get_or_create(title='Django Book v2 Review',\
+                            product=self.item, user=self.user, score=3, approved=True)
+
+
+class TopLevelProductReviewTests(ProductReviewTests):
+    u"""
+    Basic tests for ProductReview model
+    """
+    def test_top_level_reviews_must_have_titles_and_scores(self):
+        self.assertRaises(ValidationError, ProductReview.objects.create, product=self.item,\
+                           user=self.user)
+
+    def test_top_level_anonymous_reviews_must_have_names_and_emails(self):
+        self.assertRaises(ValidationError, ProductReview.objects.create, product=self.item,\
+                           user=None, title="Anonymous review", score=3)
+
+
+class TopLevelProductReviewVoteTests(ProductReviewTests):
+    u"""
+    Basic tests for Vote model
+    """
+    def setUp(self):
+        super(TopLevelProductReviewVoteTests, self).setUp()
+
+    def test_top_level_vote_must_have_choice(self):
+        self.assertRaises(ValidationError, Vote.objects.create, review=self.review,\
+                           user=self.user)
+
+    def test_try_vote_without_login(self):
+        self.assertRaises(ValueError, Vote.objects.create, review=self.review, choice =-1, user=self.anon_user)
+
+    def test_try_vote_more_than_once(self):
+        vote1 = Vote.objects.create(review=self.review, user=self.user, choice=1)
+        self.assertTrue(vote1)
+        self.assertRaises(IntegrityError, Vote.objects.create, review=self.review, choice=-1, user=self.user)
+
+
+class SingleProductReviewViewTest(ProductReviewTests, TestCase):
+    u"""
+    Tests for each product review 
+    """
+    def setUp(self):
+        self.client = Client()
+        super(SingleProductReviewViewTest, self).setUp()
+        self.kwargs = {'item_class_slug': self.item.get_item_class().slug,
+                'item_slug': self.item.slug,
+                'item_id': str(self.item.id)}
+        
+    def test_each_product_has_review(self):
+        url = reverse('oscar-product-item', kwargs=self.kwargs)
+        response = self.client.get(url)
+        self.assertEquals(200, response.status_code)
+    
+    def test_user_can_add_product_review(self):
+        url = reverse('oscar-product-review-add', kwargs=self.kwargs)
+        self.client.login(username='testuser', password='secret')
+        response = self.client.get(url)
+        self.assertEquals(200, response.status_code)
+        # check necessary review fields for logged in user
+        self.assertContains(response, 'title')
+        self.assertContains(response, 'score')
+        # check additional fields for anonymous user
+        self.client.login(username=None)
+        response = self.client.get(url)
+        self.assertContains(response, 'name')
+        self.assertContains(response, 'email')
+        
+    def test_each_review_has_own_page(self):  # FIXME: broken for reverse
+        self.kwargs['review_id'] = self.review.id
+        url = reverse('oscar-product-review', kwargs = self.kwargs)
+        response = self.client.get(url)
+        self.assertEquals(200, response.status_code)
+
+
+class SingleProductReviewVoteViewTest(ProductReviewTests, TestCase):
+    u"""
+    Each product review can be voted up or down
+    """
+    def setUp(self):
+        self.client = Client()
+        super(SingleProductReviewVoteViewTest, self).setUp()   
+        self.kwargs = {'item_class_slug': self.item.get_item_class().slug, 
+                'item_slug': self.item.slug,
+                'item_id': self.item.id,
+                'review_id': self.review.id}
+        
+    def test_vote_up_product_review(self):
+        url = reverse('oscar-vote-review', kwargs=self.kwargs)
+        self.client.login(username='testuser', password='secret')
+        response = self.client.get(url)
+        self.assertEquals(200, response.status_code)
+    
+
+class ProductReviewVotingActionTests(TestCase):
+    u"""
+    Includes the behaviour tests after voting on a review
+    """
+    fixtures = ['sample-product', 'sample-reviews']    
+    
+    def setUp(self):
+        # get reviews
+        self.reviews = ProductReview.objects.all()       
+        # dummy voters
+        self.voters = 10        
+        self.users = []
+        for i in xrange(self.voters):
+            u = User.objects.create_user('user%d'%i, 'user%d@users.com'%i, 'userpass%d'%i)
+            self.users.append(u)        
+    
+    def test_upvote_can_boost_up_review(self):
+        # get a review
+        old_rank = 1
+        self.assertTrue(self.reviews)
+        self.review = self.reviews[old_rank]        
+        review_id = self.review.id
+        old_votes = self.review.total_votes
+        # vote up
+        for i in xrange(self.voters):
+            vote = Vote.objects.create(review=self.review, user=self.users[i], choice=1)
+            self.assertTrue(vote)
+        # test vote count
+        self.failUnlessEqual(self.review.total_votes, (self.voters + old_votes))
+        # test rank
+        reviews = ProductReview.top_voted.all()
+        new_rank = list(reviews.values_list('id', flat=True)).index(review_id)
+        self.failUnless(new_rank < old_rank)

oscar/defaults.py

@@ -26,4 +26,8 @@ OSCAR_PROMOTION_MERCHANDISING_BLOCK_TYPES = (
     (LIST, "Horizontal list"),
     (TABBED_BLOCK, "Tabbed block"),
     (SINGLE_PRODUCT, "Single product"),
-)   
+)
+
+# Reviews
+OSCAR_ALLOW_ANON_REVIEWS = True
+OSCAR_MODERATE_REVIEWS = False

oscar/templates/oscar/product/detail.html

@@ -52,6 +52,10 @@
         <th>{{ attribute.type.name }}</th>
         <th>{{ attribute.value }}</th>
     </tr>
+    <tr>
+        <td><a href="{{ item.get_absolute_url }}add-review/"> Add a review</a></td>
+        <td><a href="{{ item.get_absolute_url }}reviews/"> See all reviews</a></td>
+    </tr>
     {% endfor %}
 </table>
 
@@ -87,5 +91,41 @@
 </div>
 {% endif %}
 
+{% block product_review %}
+
+{% if reviews %}
+	{% if avg_score %}
+		<h3> Product Reviews </h3>
+		<h4> Average score: {{ avg_score|floatformat:1  }} / 5.0 </h4>
+	{% endif %}
+	{% for review in reviews|slice:":5" %}		
+		<h4> {{ forloop.counter}}. {{ review.title }} </h4>
+		<p> Score: {{ review.score|floatformat:1 }} / 5.0</p>
+		<p> Comments: {{ review.body|truncatewords:50 }}</p>		
+		<p> Date created: {{ review.date_created }}</p>
+		<a href="{{ review.get_absolute_url }}"> View full review</a>			
+	{% if review.total_votes %}
+		<h5> {{ review.get_upvotes }} out of {{ review.total_votes }} customers found this review useful.</h5>
+	{% endif %}
+	{% if user.is_anonymous %}
+		<h5> Please log-in to rate this review.</h5>
+	{% endif %}	
+	{% if user.is_authenticated %}		
+		<h4> Was this review helpful to you? </h4>
+		<form  action="{{ review.get_vote_url }}" method="post">
+			{% csrf_token %}               
+            <input type="hidden" name="action" id="action_id" value="voteup"/>
+            <input type="submit" value="Yes" /> 
+        </form>
+		<form  action="{{ review.get_vote_url }}" method="post">
+			{% csrf_token %}                
+            <input type="hidden" name="action" id="action_id" value="votedown"/>
+            <input type="submit" value="No" /> 
+        </form>
+	{% endif %}			
+	{% endfor %}
+{% endif %}
+{% endblock product_review %}
+
 {% endblock content %}
 

oscar/templates/oscar/reviews/add_review.html

@@ -0,0 +1,68 @@
+{% extends "layout.html" %}
+
+{% load currency_filters %}
+
+{% block header %}
+<h2>{{item.get_title}}</h2>
+{% endblock header %}
+
+{% block content%}
+
+<div class="images">
+    {% for image in item.images.all %}
+    <img src="{{ image.fullsize_url }}" title="{{ item.get_title }}" />
+    <div class="caption">{{ image.caption }}</div>
+    {% endfor %}
+</div>
+
+<table>
+    <caption>Product details</caption>
+    <tr>
+        <th>UPC</th><td>{{item.upc}}</td>
+    </tr>
+    <tr>
+        <th>Product class</th><td><a href="{{ item.item_class.get_absolute_url }}">{{item.item_class.name}}</a></td>
+    </tr>
+{% if item.stockrecord %}
+    <tr>
+        <th>Price (excl. tax)</th><td>{{item.stockrecord.price_incl_tax|currency}}</td>
+    </tr>
+    <tr>
+        <th>Price (incl. tax)</th><td>{{item.stockrecord.price_excl_tax|currency}}</td>
+    </tr>
+    <tr>
+        <th>Availability</th>
+        <td>{{ item.stockrecord.availability }}</td>
+    </tr>
+{% endif %}
+    <tr>
+        <th>Product type</th>
+        <td>
+        {% if item.is_group %}Product group{% else %}{% if item.is_variant %}Variant{% else %}Stand-alone{% endif %}{% endif %}
+        </td>
+    </tr>
+    {% for attribute in item.attributes.all %}
+    <tr>
+        <th>{{ attribute.type.name }}</th>
+        <th>{{ attribute.value }}</th>
+    </tr>
+    {% endfor %}
+</table>
+
+{% if item.stockrecord %}
+<form action="{% url oscar-basket %}" method="post">
+    {% csrf_token %}
+    {{ form.as_p }}
+    <input type="submit" value="Add to basket" />
+</form>
+{% endif %}
+
+
+
+<h4>Leave a product review</h4>
+<form method="post" action="">
+	{% csrf_token %}
+    {{ review_form.as_p }}
+     <input type="submit" value="Submit" /> 
+</form>
+{% endblock content %}

oscar/templates/oscar/reviews/review.html

@@ -0,0 +1,9 @@
+{% extends "oscar/product/detail.html" %}
+
+{% block product_review %}
+{% if review %}		
+		<h4> {{ review.title }} </h4>
+		<p> Score: {{ review.score|floatformat:1 }} / 5.0</p>
+		<p> Comments: {{ review.body }}</p>						
+{% endif %}
+{% endblock %}

oscar/templates/oscar/reviews/reviews.html

@@ -0,0 +1,45 @@
+{% extends "oscar/product/detail.html" %}
+
+{% block product_review %}
+{% if reviews %}
+	{% if avg_score %}
+		<h3> All Product Reviews ({{ reviews.count }}) </h3>
+		<h4> Sort by: </h4>
+		<form  action="{{ request.get_full_path }}" method="get">
+			{% csrf_token %}
+            <select name="sort_by">
+            	<option value="score"> Score </option>
+            	<option value="recency"> Recency </option>
+            	<input type="submit" value="Go" /> 
+            </select>            
+        </form>
+		<h4> Average score: {{ avg_score|floatformat:1  }} / 5.0 </h4>
+	{% endif %}
+	{% for review in reviews  %}		
+		<h4> {{ forloop.counter}}. {{ review.title }} </h4>
+		<p> Score: {{ review.score|floatformat:1 }} / 5.0</p>
+		<p> Comments: {{ review.body }}</p>
+		<p> Date created: {{ review.date_created }}</p>		
+	{% endfor %}
+	
+{% if page_obj %}
+<div class="pagination">
+    <span class="step-links">
+    
+        {% if page_obj.has_previous %}
+            <a href="?page={{ page_obj.previous_page_number }}">Previous</a>
+        {% endif %}
+
+        <span class="current">
+            Page {{ page_obj.number }} of {{ paginator.num_pages }}.
+        </span>
+
+        {% if page_obj.has_next %}
+            <a href="?page={{ page_obj.next_page_number }}">Next</a>
+        {% endif %}
+    </span>
+</div>
+{% endif %}
+							
+{% endif %}
+{% endblock %}