Major tidy-up of reviews branch.

Move into product app
Rewrote views to use generic classes
Tidied up POST actions of forms

examples/recreate_project_tables.sh

 fi
 echo "Recreating all tables in $PROJECT_FOLDER"
 echo "Dropping tables"
-$MANAGE_COMMAND sqlclear promotions analytics payment offer shipping order basket partner image address product datacash | \
+$MANAGE_COMMAND sqlclear promotions analytics payment reviews offer shipping order basket partner image address product datacash | \
 	awk 'BEGIN {print "set foreign_key_checks=0;"} {print $0}' | \
     $MANAGE_COMMAND dbshell && \
     $MANAGE_COMMAND syncdb

examples/vanilla/settings.py

     'oscar.apps.promotions',
     'oscar.apps.reports',
     'oscar.apps.search',
-    'oscar.apps.reviews',
+    'oscar.apps.product.reviews',
     'pyzen',
     'sorl.thumbnail',
 )

oscar/apps/product/reviews/abstract_models.py

+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 django.conf import settings
+
+from oscar.apps.product.reviews.managers import (ApprovedReviewsManager, RecentReviewsManager, 
+                                                 TopScoredReviewsManager, TopVotedReviewsManager)
+
+
+class AbstractProductReview(models.Model):
+    """
+    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
+    """
+    
+    # Note we keep the review even if the product is deleted
+    product = models.ForeignKey('product.Item', related_name='product', null=True, on_delete=models.SET_NULL)
+    
+    SCORE_CHOICES = tuple([(x, x) for x in range(0, 6)])
+    score = models.SmallIntegerField(_("Score"), choices=SCORE_CHOICES)
+    title = models.CharField(_("Title"), max_length=255)
+    body = models.TextField(_("Body"))
+    
+    # User information.  We include fields to handle anonymous users
+    user = models.ForeignKey('auth.User', related_name='reviews', null=True, blank=True)
+    name = models.CharField(_("Name"), max_length=255, null=True, blank=True)
+    email = models.EmailField(_("Email"), null=True, blank=True)
+    homepage = models.URLField(_("URL"), null=True, blank=True)
+    
+    FOR_MODERATION, APPROVED, REJECTED = range(0, 3)
+    STATUS_CHOICES = (
+        (FOR_MODERATION, _("Requires moderation")),
+        (APPROVED, _("Approved")),
+        (REJECTED, _("Rejected")), 
+    ) 
+    default_status = FOR_MODERATION if settings.OSCAR_MODERATE_REVIEWS else APPROVED
+    status = models.SmallIntegerField(_("Status"), choices=STATUS_CHOICES, default=default_status)
+    
+    # Denormalised vote totals
+    total_votes = models.IntegerField(_("Total Votes"), default=0)  # upvotes + down votes
+    delta_votes = models.IntegerField(_("Delta Votes"), default=0, db_index=True)  # upvotes - down votes  
+    
+    date_created = models.DateTimeField(auto_now_add=True)
+    
+    # Managers
+    objects = models.Manager()
+    approved = ApprovedReviewsManager()
+
+    class Meta:
+        abstract = True
+        ordering = ['-delta_votes']
+
+    @models.permalink
+    def get_absolute_url(self):
+        return ('oscar-product-review', (), {
+            'item_class_slug': self.product.get_item_class().slug,
+            'item_slug': self.product.slug,
+            'item_id': self.product.id,
+            'pk': self.id})
+
+    def __unicode__(self):
+        return self.title
+
+    def save(self, *args, **kwargs):
+        if not self.user and not (self.name and self.email):  
+            raise ValidationError("Anonymous review must have a name and an email")
+        super(AbstractProductReview, self).save(*args, **kwargs)
+
+    def has_votes(self):
+        return self.total_votes > 0
+
+    def num_up_votes(self):
+        """Returns the total up votes"""
+        return int((self.total_votes + self.delta_votes) / 2)
+    
+    def num_down_votes(self):
+        """Returns the total down votes"""
+        return int((self.total_votes - self.delta_votes) / 2)
+
+    def update_totals(self, vote):
+        """Updates total and delta votes"""
+        self.total_votes += 1
+        self.delta_votes += vote.delta
+        self.save()
+
+
+class AbstractVote(models.Model):
+    """
+    Records user ratings as yes/no vote.
+    * Only signed-in users can vote.
+    * Each user can vote only once.
+    """
+    review = models.ForeignKey('reviews.ProductReview', related_name='votes')
+    user = models.ForeignKey('auth.User', related_name='review_votes')
+    UP, DOWN = 1, -1
+    VOTE_CHOICES = (
+        (UP, _("Up")),
+        (DOWN, _("Down"))
+    )
+    delta = models.SmallIntegerField(choices=VOTE_CHOICES)
+    date_created = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        abstract = True
+        ordering = ['-date_created']
+        unique_together = (('user', 'review'),)
+
+    def __unicode__(self):
+        return u"%s vote for %s" % (self.delta, self.review)
+
+    def save(self, *args, **kwargs):
+        u"""
+        Validates model and raises error if validation fails
+        """
+        self.review.update_totals(self)
+        super(AbstractVote, self).save(*args, **kwargs)

oscar/apps/product/reviews/admin.py

+from django.contrib import admin
+
+from oscar.apps.product.reviews.models import ProductReview, Vote
+
+
+class ProductReviewAdmin(admin.ModelAdmin):
+    list_display = ('product', 'title', 'score', 'status', 'total_votes', 'delta_votes', 'date_created')
+    readonly_fields = ('total_votes', 'delta_votes')
+
+
+class VoteAdmin(admin.ModelAdmin):
+    list_display = ('review', 'user', 'delta', 'date_created')
+
+admin.site.register(ProductReview, ProductReviewAdmin)
+admin.site.register(Vote, VoteAdmin)

oscar/apps/reviews/forms.py → oscar/apps/product/reviews/forms.py

 from django.forms import BaseForm, ModelForm, CharField, EmailField
 
-from oscar.apps.reviews.models import ProductReview
+from oscar.apps.product.reviews.models import ProductReview
 
 
 class ProductReviewForm(ModelForm):
+    
     class Meta:
         model = ProductReview
         fields = ('title', 'score', 'body')
         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)
+    return type('ProductReviewForm', (BaseForm,), {'base_fields': fields})

oscar/apps/reviews/managers.py → oscar/apps/product/reviews/managers.py

 
 class ApprovedReviewsManager(models.Manager):
     def get_query_set(self):
-        return super(ApprovedReviewsManager, self).get_query_set().filter(approved=True)
+        return super(ApprovedReviewsManager, self).get_query_set().filter(status=1)
+
 
 
 class RecentReviewsManager(models.Manager):

oscar/apps/reviews/models.py → oscar/apps/product/reviews/models.py

-from oscar.apps.reviews.abstract_models import AbstractProductReview, AbstractVote
+from oscar.apps.product.reviews.abstract_models import AbstractProductReview, AbstractVote
 
 
 class ProductReview(AbstractProductReview):

oscar/apps/product/reviews/urls.py

+from django.conf.urls.defaults import *
+
+from oscar.core.decorators import class_based_view
+from oscar.core.loading import import_module
+import_module('product.reviews.views', ['CreateProductReviewView', 'ProductReviewDetailView',
+                                        'ProductReviewListView'], locals())  
+
+urlpatterns = patterns('oscar.product.reviews.views',
+    url(r'(?P<pk>\d+)/$', ProductReviewDetailView.as_view(), name='oscar-product-review'),
+    url(r'add/$', CreateProductReviewView.as_view(), name='oscar-product-review-add'),
+    url(r'all/$', ProductReviewListView.as_view(), name='oscar-product-reviews'),
+)

oscar/apps/product/reviews/views.py

+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, render
+from django.core.urlresolvers import reverse
+from django.core.paginator import Paginator, InvalidPage, EmptyPage
+from django.views.generic import ListView, DetailView, CreateView
+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.view.generic import PostActionMixin
+from oscar.core.loading import import_module
+import_module('product.models', ['Item', 'ItemClass'], locals())
+import_module('basket.forms', ['FormFactory'], locals())
+import_module('product.reviews.models', ['ProductReview', 'Vote'], locals())
+
+
+class CreateProductReviewView(CreateView):
+    template_name = "oscar/reviews/add_review.html"
+    model = ProductReview
+    
+    def get_context_data(self, **kwargs):
+        context = super(CreateProductReviewView, self).get_context_data(**kwargs)
+        context['item'] = get_object_or_404(Item, pk=self.kwargs['item_id'])
+        return context
+    
+    def _get_form_class(self):
+        return make_review_form(self.request.user)
+
+
+class ProductReviewDetailView(DetailView, PostActionMixin):
+    """
+    Places each review on its own page
+    """
+    template_name = "oscar/reviews/review.html"
+    context_object_name = 'review'
+    model = ProductReview
+    
+    def get_context_data(self, **kwargs):
+        context = super(ProductReviewDetailView, self).get_context_data(**kwargs)
+        context['item'] = get_object_or_404(Item, pk=self.kwargs['item_id'])
+        return context
+    
+    def do_vote_up(self, review):
+        return self.vote_on_review(review, Vote.UP)
+    
+    def do_vote_down(self, review):
+        return self.vote_on_review(review, Vote.DOWN)   
+    
+    def vote_on_review(self, review, delta):
+        user = self.request.user
+        self.response = HttpResponseRedirect(review.get_absolute_url())
+        if review.user == user:
+            messages.info(self.request, "You cannot vote on your own reviews!")
+        else:
+            try:
+                Vote.objects.get(review=review, user=user)
+                messages.info(self.request, "You have already voted on this review!") 
+            except Vote.DoesNotExist:
+                Vote.objects.create(review=review, user=user, delta=delta)
+                messages.info(self.request, "Thanks for voting!")   
+
+    
+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.
+    """    
+    template_name = 'oscar/reviews/reviews.html'
+    context_object_name = "reviews"
+    model = ProductReview
+    paginate_by = 20
+     
+    def get_queryset(self):
+        qs = ProductReview.approved.filter(product=self.kwargs['item_id'])
+        if 'sort_by' in self.request.GET and self.request.GET['sort_by'] == 'score':
+            return qs.order_by('-score')
+        return qs.order_by('-date_created')
+     
+    def get_context_data(self, **kwargs):
+        context = super(ProductReviewListView, self).get_context_data(**kwargs)
+        context['item'] = get_object_or_404(Item, pk=self.kwargs['item_id'])  
+        context['avg_score'] = self.object_list.aggregate(Avg('score'))           
+        return context

oscar/apps/product/urls.py

 
 from oscar.core.decorators import class_based_view
 from oscar.core.loading import import_module
-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+)/'
+import_module('product.views', ['ItemDetailView', 'ProductListView', 'ItemClassListView'], locals())  
 
 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+)/review/', include('oscar.apps.product.reviews.urls')),
     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

 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.views.generic import ListView, DetailView, CreateView
 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.view.generic import PostActionMixin
 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'])
+import_module('product.models', ['Item', 'ItemClass'], locals())
+import_module('product.signals', ['product_viewed', 'product_search'], locals())
+import_module('basket.forms', ['FormFactory'], locals())
+import_module('customer.history_helpers', ['receive_product_view'], locals())
+import_module('product.reviews.models', ['ProductReview', 'Vote'], locals())
 
 
 class ItemDetailView(DetailView):
         response = super(ItemDetailView, self).get(request, **kwargs)
         
         # Send signal to record the view of this product
-        product_signals.product_viewed.send(sender=self, product=item, user=request.user, request=request, response=response)
+        product_viewed.send(sender=self, product=item, user=request.user, request=request, response=response)
         return response;
     
     def get_template_names(self):
         
         We cache the object as this method gets called twice."""
         if not self._item:
-            self._item = get_object_or_404(product_models.Item, pk=self.kwargs['item_id'])
+            self._item = get_object_or_404(Item, pk=self.kwargs['item_id'])
         return self._item
     
     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()
+        context['reviews'] = self.get_reviews()
+        context['avg_score'] = self.get_avg_review_score()
         return context
     
     def get_add_to_basket_form(self):
-        factory = basket_forms.FormFactory()
+        factory = 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_reviews(self):
+        return ProductReview.approved.filter(product=self.get_object())
     
-    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()
+    def get_avg_review_score(self):
+        return ProductReview.approved.aggregate(Avg('score'))['score__avg']
 
     
 class ItemClassListView(ListView):
     paginate_by = 20
 
     def get_queryset(self):
-        item_class = get_object_or_404(product_models.ItemClass, slug=self.kwargs['item_class_slug'])
-        return product_models.Item.browsable.filter(item_class=item_class)
+        item_class = get_object_or_404(ItemClass, slug=self.kwargs['item_class_slug'])
+        return Item.browsable.filter(item_class=item_class)
 
 
 class ProductListView(ListView):
         q = self.get_search_query()
         if q:
             # Send signal to record the view of this product
-            product_signals.product_search.send(sender=self, query=q, user=self.request.user)
+            product_search.send(sender=self, query=q, user=self.request.user)
             
-            return product_models.Item.browsable.filter(title__icontains=q)
+            return Item.browsable.filter(title__icontains=q)
         else:
-            return product_models.Item.browsable.all()
+            return Item.browsable.all()
         
     def get_context_data(self, **kwargs):
         context = super(ProductListView, self).get_context_data(**kwargs)
             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

-"""
-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

-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/templates/oscar/product/detail.html

 {% load thumbnail %}
 
 {% block header %}
-<h2>{{item.get_title}}</h2>
+<h2>{{ item.get_title }}</h2>
 {% endblock header %}
 
 
     <tr>
         <th>Product class</th><td><a href="{{ item.item_class.get_absolute_url }}">{{item.item_class.name}}</a></td>
     </tr>
-{% if item.stockrecord %}
+    {% if item.stockrecord %}
     <tr>
         <th>Price (excl. tax)</th><td>{{item.stockrecord.price_incl_tax|currency}}</td>
     </tr>
         <th>Availability</th>
         <td>{{ item.stockrecord.availability }}</td>
     </tr>
-{% endif %}
+    {% endif %}
     <tr>
         <th>Product type</th>
         <td>
         <th>{{ attribute.type.name }}</th>
         <th>{{ attribute.value }}</th>
     </tr>
+    {% endfor %}
     <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>
+        <td><a href="{% url oscar-product-review-add item.item_class.slug item.slug item.id %}">Add a review</a></td>
+        <td><a href="{% url oscar-product-reviews item.item_class.slug item.slug item.id %}">See all reviews</a></td>
     </tr>
-    {% endfor %}
+    
 </table>
 
 {% if item.stockrecord %}
 </form>
 {% endif %}
 
-{% recently_viewed_products %}
-
 {% if item.related_items.count %}
 <div class="products">
     <h4>Related items</h4>
 
 {% 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 %}
+    {% if reviews %}
+    	<h3> Product Reviews </h3>
+    	<h4> Average score: {{ avg_score|floatformat:1  }} / 5.0 </h4>
+    	{% 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.has_votes %}
+            	<h5> {{ review.num_up_votes }} out of {{ review.total_votes }} customers found this review useful.</h5>
+            {% endif %}
+            {% if user.is_authenticated %}
+        		<h4>Was this review helpful to you?</h4>
+        		<form action="{{ review.get_absolute_url }}" method="post">
+        			{% csrf_token %}               
+                    <input type="hidden" name="action" value="vote_up"/>
+                    <input type="submit" value="Yes" /> 
+                </form>
+        		<form  action="{{ review.get_absolute_url }}" method="post">
+        			{% csrf_token %}                
+                    <input type="hidden" name="action" value="vote_down"/>
+                    <input type="submit" value="No" /> 
+                </form>
+    	    {% endif %}			
+    	{% endfor %}
+    {% endif %}
+
 {% endblock product_review %}
 
+{% recently_viewed_products %}
+
 {% endblock content %}
 

oscar/templates/oscar/reviews/add_review.html

-{% extends "layout.html" %}
+{% extends "oscar/product/detail.html" %}
 
-{% load currency_filters %}
+{% block product_review %}
 
-{% block header %}
-<h2>{{item.get_title}}</h2>
-{% endblock header %}
+    <h4>Leave a product review</h4>
+    <form method="post" action="{% url oscar-product-review-add item.item_class.slug item.slug item.id %}">
+        {% csrf_token %}
+        {{ form.as_p }}
+        <input type="submit" value="Submit" /> 
+    </form>
 
-{% 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 %}
+{% endblock %}

oscar/templates/oscar/reviews/reviews.html

 {% 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 %}
+		<form action="{{ request.get_full_path }}" method="get">
             <select name="sort_by">
-            	<option value="score"> Score </option>
-            	<option value="recency"> Recency </option>
-            	<input type="submit" value="Go" /> 
-            </select>            
+            	<option value="score">Score</option>
+            	<option value="recency">Recency</option>
+            </select>
+            <input type="submit" value="Go" />             
         </form>
 		<h4> Average score: {{ avg_score|floatformat:1  }} / 5.0 </h4>
 	{% endif %}
 		<p> Date created: {{ review.date_created }}</p>		
 	{% endfor %}
 	
-{% if page_obj %}
-<div class="pagination">
-    <span class="step-links">
+    {% 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 %}
     
-        {% 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 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 %}
+		
+{% else %}
 
-        {% if page_obj.has_next %}
-            <a href="?page={{ page_obj.next_page_number }}">Next</a>
-        {% endif %}
-    </span>
-</div>
-{% endif %}
-							
+<p>This product does not have any reviews yet.</p>        
+        					
 {% endif %}
 {% endblock %}