def product_item(request, product_id):
product = get_object_or_404(Product, pk=product_id)
colors = Color.objects.filter(product=product.pk)
product = get_object_or_404(Product, pk=product_id)
if request.user.is_authenticated:
user = Profile.objects.get(user=request.user)
else:
user = None
# get all reviews for given product
reviews = Review.objects.filter(product=product)
# If user has reviewed an item
try:
# retrieve review for selected item by user
item_review = Review.objects.get(user=user, product=product)
# get a prefilled form with specific review
edit_review_form = ReviewForm(instance=item_review)
# If there are no reviews by the user
except Review.DoesNotExist:
edit_review_form = None
review_form = ReviewForm()
template = 'products/product_item.html'
context = {
'product': product,
'colors': colors,
'reviews': reviews,
'review_form': review_form,
'edit_review_form': edit_review_form,
}
return render(request, template, context)
def class_page(request, class_id):
educator_class = EducatorClass.objects.get(id=class_id)
educator = educator_class.user.educator
reviews = Review.objects.filter(educator_class=educator_class)
if request.method == 'POST':
review_form = ReviewForm(data=request.POST)
if review_form.is_valid():
review = review_form.save(commit=False)
review.user = request.user
review.educator = educator
review.educator_class = educator_class
review.save()
return render(request, 'class_page.html', {'educator_class' : educator_class,
'educator' : educator,
'reviews' : reviews,
'review_form' : review_form})
else:
review_form = ReviewForm()
return render(request, 'class_page.html', {'educator_class' : educator_class,
'educator' : educator,
'reviews' : reviews,
'review_form' : review_form})
def tamperWithForm(self, **kwargs):
a = Article.objects.get(pk=1)
d = self.getValidData(a)
d.update(kwargs)
f = ReviewForm(Article.objects.get(pk=1), data=d)
self.assertFalse(f.is_valid())
return f
def test_add_review_form_invalid(self):
form = ReviewForm({
'content': 'Test content',
'rating': True,
})
self.assertFalse(form.is_valid())
def get_context_data(self, **kwargs):
# return the user review if it exists, and return all other reviews
context = super().get_context_data(**kwargs)
if self.request.user.is_authenticated:
# my reviews for this book
mine = Review.objects.filter(book=self.get_object(),
user=self.request.user)
# all other reviews
others = Review.objects.filter(book=self.get_object()).exclude(
user=self.request.user)
context['reviews'] = others
context['mine'] = mine.first()
context['read_by_me'] = self.request.user.my_books.filter(
id=self.get_object().id).exists()
else:
mine = None
context['reviews'] = Review.objects.filter(
book=self.get_object()).order_by('-timestamp')
context['mine'] = mine
# return add or edit review form in the context
if mine:
context["form"] = ReviewForm(instance=mine.first())
context['newReview'] = False
else:
context["form"] = ReviewForm()
context['newReview'] = True
context['review_count'] = Review.objects.filter(
book=self.get_object()).count()
return context
def product_detail(request,id):
product = get_object_or_404(Product,id=id)
reviews = Review.objects.all().filter(product=product)
average_rating = reviews.aggregate(Avg('rating'))
if average_rating['rating__avg']:
average_rating = int(round(average_rating['rating__avg']))
else:
average_rating = 0
reviews_count = reviews.aggregate(Count('id'))
reviews_count = reviews_count['id__count']
form = ReviewForm(request.POST or None)
if form.is_valid() and request.user.is_authenticated():
review = form.save(commit=False)
review.user = request.user
review.product = product
review.save()
return HttpResponseRedirect(product.get_absolute_url())
context = {
"title":product.name,
"instance":product,
"review_form":form,
"reviews":reviews,
"average_rating":average_rating,
"reviews_count":reviews_count
}
return render(request,"product_detail.html",context)
def add_review(request, wine_id):
wine = get_object_or_404(Wine, pk=wine_id)
form = ReviewForm(request.POST)
if form.is_valid():
rating = form.cleaned_data["rating"]
print(rating)
print(form.cleaned_data)
comment = form.cleaned_data["comments"]
user_name = request.user.username
review = Review()
review.wine = wine
review.user_name = user_name
review.rating = rating
review.comments = comment
review.pub_date = datetime.datetime.now()
review.save()
update_clusters()
# Always return an HttpResponseRedirect after successfully dealing
# with POST data. This prevents data from being posted twice if a
# user hits the Back button.
return HttpResponseRedirect(
reverse("reviews:wine_detail", args=(wine.id, )))
return render(request, "reviews/wine_detail.html", {
"wine": wine,
"form": form
})
def review_project(request, slug):
project = get_object_or_404(Project, slug=slug)
profile = request.user.get_profile()
reviewer = Reviewer.objects.get(user=profile)
if request.method == 'POST':
form = ReviewForm(request.POST)
if form.is_valid():
review = form.save(commit=False)
review.project = project
review.author = profile
review.save()
if reviewer.can_feature:
project.community_featured = review.mark_featured
if reviewer.can_delete:
project.deleted = review.mark_deleted
if reviewer.can_feature or reviewer.can_delete:
project.save()
review.send_notifications()
messages.success(request, _('Review posted!'))
return http.HttpResponseRedirect(review.get_absolute_url())
else:
messages.error(request, _('Please correct errors below.'))
else:
form = ReviewForm()
context = {'form': form, 'project': project, 'reviewer': reviewer}
return render_to_response('reviews/review_project.html',
context, context_instance=RequestContext(request))
def educator_profile(request, educator_id):
educator = Educator.objects.get(pk=educator_id)
profile_form = EducatorProfileForm(instance=educator)
if Review.objects.all().exists():
reviews = Review.objects.filter(educator=educator)
else:
reviews = None
if request.method == 'POST':
review_form = ReviewForm(data=request.POST)
if review_form.is_valid():
review = review_form.save(commit=False)
review.user = request.user
review.educator = educator
review.save()
return HttpResponseRedirect('/profiles/%d/' % educator.id)
else:
review_form = ReviewForm()
return render(request, 'educator_profile.html', {'educator' : educator,
'profile_form' : profile_form, 'review_form' : review_form,
'reviews' : reviews})
def product_view(request, p_id):
try:
temp = Product.objects.get(pk=p_id)
except Product.DoesNotExist:
return HttpResponseNotFound('<h1>Page not found</h1>')
if not temp.is_active:
return HttpResponseNotFound('<h1>Page not found</h1>')
form = ReviewForm(request.POST or None)
if request.method == "POST":
if not request.user.is_authenticated:
return redirect("/login")
if form.is_valid():
try:
OrderedItem.objects.get(user=request.user, product=temp)
except OrderedItem.DoesNotExist:
return HttpResponseNotAllowed(
"you have not ordered item please order it to review")
except OrderedItem.MultipleObjectsReturned:
pass
review_given = True
try:
ProductReview.objects.get(user=request.user, product=temp)
except ProductReview.DoesNotExist:
review_given = False
except ProductReview.MultipleObjectsReturned:
pass
if review_given:
return HttpResponseNotAllowed(
"you have already submited review")
form = form.save(commit=False)
form.user = request.user
form.product = temp
print(type(form.rating))
if form.rating == 1:
temp.rating_1 += 1
elif form.rating == 2:
temp.rating_2 += 1
elif form.rating == 3:
temp.rating_3 += 1
elif form.rating == 4:
temp.rating_4 += 1
elif form.rating == 5:
temp.rating_5 += 1
temp.rating_avg = round(
((temp.rating_1 + 2 * temp.rating_2 + 3 * temp.rating_3 +
4 * temp.rating_4 + 5 * temp.rating_5) /
(temp.rating_1 + temp.rating_2 + temp.rating_3 +
temp.rating_4 + temp.rating_5)), 2)
form.save()
temp.save()
form = ReviewForm()
product_user = temp.user
is_seller = product_user.username == request.user.username
return render(request, "product_template.html", {
"product": temp,
"form": form,
"is_seller": is_seller
})
def test_add_review_form_valid(self):
form = ReviewForm({
'title': 'Test Form',
'content': 'Test content',
'rating': True,
})
self.assertTrue(form.is_valid())
def test_blank_form(self):
form = ReviewForm({})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors, {
'author': ['This field is required.'],
'rating': ['This field is required.'],
'content': ['This field is required.'],
})
def test_form_valid(self):
form_data = {
'user_display_name': 'Me',
'title': 'Test title',
'rating': 3,
'review': 'Not bad'
}
form = ReviewForm(data=form_data)
self.assertTrue(form.is_valid())
def post_review(request, template_name='reviews/photo_upload.html', next=None):
if request.method == 'POST':
# Fill out some initial data fields from an authenticated user, if present
data = request.POST.copy()
# Look up the object we're trying to review about
ctype = data.get("content_type")
object_pk = data.get("object_pk")
if ctype is None or object_pk is None:
return ReviewPostBadRequest("Missing content_type or object_pk field.")
try:
model = models.get_model(*ctype.split(".", 1))
target = model._default_manager.get(pk=object_pk)
except TypeError:
return ReviewPostBadRequest(
"Invalid content_type value: %r" % escape(ctype))
except AttributeError:
return ReviewPostBadRequest(
"The given content-type %r does not resolve to a valid model." % \
escape(ctype))
except ObjectDoesNotExist:
return ReviewPostBadRequest(
"No object matching content-type %r and object PK %r exists." % \
(escape(ctype), escape(object_pk)))
# Construct the review form
form = ReviewForm(target, data=data)
# If there are errors or if we requested a preview show the review
if form.errors:
template_list = [
"reviews/%s_%s_preview.html" % tuple(str(model._meta).split(".")),
"reviews/%s_preview.html" % model._meta.app_label,
"reviews/preview.html",
]
return render_to_response(
template_list, {
"review" : form.data.get("review", ""),
"form" : form,
},
RequestContext(request, {})
)
# Otherwise create the review
review = form.get_review_object()
if request.user.is_authenticated():
review.user = request.user
# Save the review
review.save()
return HttpResponseRedirect(data.get('next'))
else:
add_form = ReviewForm()
return render_response(request, template_name, { 'form': add_form, })
def add_review(request, movie_id):
movie = get_object_or_404(Movie, pk=movie_id)
form = ReviewForm(request.POST)
if form.is_valid():
review = form.save(commit=False)
review.movie = movie
review.save()
if request.is_ajax():
return HttpResponse(json.dumps({'author': review.author, 'body': review.body }), status=200)
return HttpResponseRedirect(reverse('movie-detail', args=[movie_id]))
def product_reviews(request, product_id):
"""
Returns a view with all the reviews for a specific product. If current user
has a review, get that and allow them to update.
"""
product = get_object_or_404(Product, pk=product_id)
reviews = Review.objects.filter(product=product_id)
form = ReviewForm()
user_review = ""
user_purchased = False
if request.user.is_authenticated:
user_profile = UserProfile.objects.get(user=request.user)
user_purchased = verify_purchase(user_profile, Order, product)
for review in reviews:
if review.user_profile == user_profile:
user_review = review
form = ReviewForm(instance=user_review)
if request.method == "POST":
if user_review != "":
form = ReviewForm(request.POST, instance=user_review)
else:
if len(request.POST["review_content"]) <= 15:
messages.error(
request,
"Review not long enough, please write a review longer than 15 characters.",
)
return redirect(reverse("product_reviews",
args=(product_id, )))
form_data = {
"review_content": request.POST["review_content"],
}
form = ReviewForm(form_data)
if form.is_valid():
review = form.save(commit=False)
review.user_profile = user_profile
review.product = product
review.save()
messages.success(request, "Review added.")
return redirect(reverse("product_reviews", args=(product_id, )))
messages.error(request, "Error adding review.")
return redirect(reverse("product_reviews", args=(product_id, )))
context = {
"product": product,
"reviews": reviews,
"form": form,
"user_review": user_review,
"user_purchased": user_purchased,
"page_title": f"{product.name} reviews",
}
return render(request, "products/product-reviews.html", context)
def create_review(request, id_user):
form = ReviewForm()
if request.method == "POST":
form = ReviewForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
rate = form.cleaned_data['valoration']
com = form.cleaned_data['comment']
if 0.0 <= float(rate) <= 5.0:
fromUser = get_object_or_404(User, pk=request.user.id)
toUser = get_object_or_404(User, pk=id_user)
rent_list_from = Rent.objects.filter(user=fromUser)
rent_list_to = Rent.objects.filter(user=toUser)
games_from = Game.objects.filter(owner=fromUser)
games_to = Game.objects.filter(owner=toUser)
#Voy a comprobar si ambos usuarios comparten un alquiler
existRent = False
if rent_list_from:
for rent in rent_list_from:
for game in games_to:
if rent.game == game:
existRent = True
break
if rent_list_to:
for rent in rent_list_to:
for game in games_from:
if rent.game == game:
existRent = True
break
if existRent:
valoration = Valoration(fromUser=fromUser, toUser=toUser, rate=rate)
comment = Comment(fromUser=fromUser, toUser=toUser, comment=com)
valoration.save()
comment.save()
list_valoration = Valoration.objects.filter(toUser=toUser)
suma = 0.0
numero = 0
for valor in list_valoration:
suma = suma + valor.rate
numero = numero + 1
media = suma/numero
toUser.rate = media
try:
toUser.save()
except DataError:
return redirect('/profile/{}'.format(toUser.id))
return redirect('/profile/{}'.format(toUser.id))
else:
return render(request, "createReview.html", {'form': form, 'mensaje':
'Necesitas haber alquilado algun producto del Usuario para poder darle una valoración'})
else:
return render(request, "createReview.html", {'form': form})
return render(request, "createReview.html", {'form': form})
def test_invalid_rating(self):
form_data = {
'rating': 0,
'review': 'Not bad'
}
form = ReviewForm(data=form_data)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'rating': ['Rating must be between 1 and 5.']}
)
def views_create(request, event):
if request.method == 'POST':
form = ReviewForm(request.POST)
if form.is_valid():
event = Event.objects.get(pk=event)
event.reviews.create(user=request.user,review=request.POST['review'])
return redirect('events:musics_show', event.id)
return HttpResponse({"message": "works"})
def submit(request):
if request.method == "POST":
review_form = ReviewForm(data=request.POST)
next_url = request.POST.get("next_url", "/")
if review_form.is_valid():
review = review_form.save(commit=False)
review.user = request.user
review.save()
return redirect(next_url)
else:
return public(request, review_form)
return redirect('/')
def post(self, request, pk):
url = f'/furniture/details/{self.get_object().id}/'
post_values = request.POST.copy()
form = ReviewForm(post_values)
if form.is_valid():
author = Profile.objects.get(user__pk=request.user.id)
post_values['furniture'] = self.get_object()
review = Review(content=post_values['content'],
score=post_values['score'],
furniture=self.get_object(),
author=author)
review.save()
return HttpResponseRedirect(url)
def index(request):
# Make a request
if(request.method=='POST'):
post_values = request.POST.copy()
post_values['user'] = request.user.id
form = ReviewForm(post_values)
if(form.is_valid()):
form.save()
# Go to that profs page
prof_id = post_values['prof']
return redirect(reverse('profs_getProf', args=(prof_id,)))
profs = all_profs()
return render(request, 'profs/index.html', {'review_form': ReviewForm, 'profs': profs})
def test_valid_data(self):
form = ReviewForm({
'author': 'test author',
'rating': 5,
'content': "This is an awesome supplier!"
})
self.assertTrue(form.is_valid())
test_review = form.save(commit=False)
test_review.supplier = self.ts1
test_review.save()
self.assertEqual(test_review.author, 'test author')
self.assertEqual(test_review.rating, 5)
self.assertEqual(test_review.content, 'This is an awesome supplier!')
self.assertEqual(test_review.status, 'draft')
self.assertIs(test_review.supplier, self.ts1)
def product_detail(request, id):
items = get_object_or_404(Product, id=id)
form = ReviewForm()
return render(request, "products/productdetails.html", {
'items': items,
'review_form': form
})
def product_details(request, id):
product = get_object_or_404(Product, pk=id)
form = ReviewForm()
return render(request, "products/product_detail.html", {
"product": product,
"form": form
})
def wine_detail(request, wine_id):
wine = get_object_or_404(Wine, pk=wine_id)
form = ReviewForm()
return render(request, "reviews/wine_detail.html", {
"wine": wine,
"form": form
})
def product_details(request, product_id):
product = get_object_or_404(Product, pk=product_id)
review_form = ReviewForm()
return render(request, 'product/one_product.template.html', {
'product': product,
'form': review_form
})
def property_detail(request, id):
the_property = get_object_or_404(Property, pk=id)
form = ReviewForm()
return render(request, "rentedproperties/rented_properties_detail.html", {
'property': the_property,
'form': form
})
def view_product(request, id):
products = get_object_or_404(Product, pk=id)
form = ReviewForm()
return render(request, "products/view_product.html", {
'products': products,
'review_form': form
})
def content_update(request, username, category, content_id):
member = User.objects.get(username=username)
if category == "opinions":
opinion = Opinion.objects.get(id=content_id)
form = OpinionForm(request.POST or None,
request.FILES or None,
instance=opinion)
if form.is_valid():
form.save()
messages.success(request, 'Opinion updated.')
return redirect("home:member", member.username)
elif category == "reviews":
review = Review.objects.get(id=content_id)
form = ReviewForm(request.POST or None, instance=review)
if form.is_valid():
form.save()
messages.success(request, 'Review updated.')
return redirect("home:member", member.username)
elif category == "reviews_us":
review = ReviewUS.objects.get(id=content_id)
form = ReviewUSForm(request.POST or None, instance=review)
if form.is_valid():
form.save()
messages.success(request, 'Review updated.')
return redirect("home:member", member.username)
elif category == "listings":
listing = Listing.objects.get(id=content_id)
form = ListingForm(request.POST or None,
request.FILES or None,
make=listing.car.make,
years=listing.car.years,
body_type=listing.car.body_type,
instance=listing)
if form.is_valid():
form.save()
messages.success(request, 'Listing updated.')
return redirect("home:member", member.username)
elif category == "listings_us":
listing = ListingUS.objects.get(id=content_id)
form = ListingUSForm(request.POST or None,
request.FILES or None,
make=listing.car.make,
model=listing.car.model,
trim=listing.car.trim,
version=listing.car.version,
year=listing.car.year,
instance=listing)
if form.is_valid():
form.save()
messages.success(request, 'Listing updated.')
return redirect("home:member", member.username)
context = {"member": member, "form": form, "category": category}
return render(request, "home/update.html", context)
def view_book_details(request, book_id):
book = get_object_or_404(Book, pk=book_id)
review_form = ReviewForm()
return render(request, 'books/details.template.html', {
'book': book,
'review_form': review_form
})
def product_item(request, id):
product = get_object_or_404(Product, pk=id)
form = ReviewForm()
return render(request, "products/product_item.html", {
'product': product,
'review_form': form
})
def detailcoffee(request, id):
product = get_object_or_404(Product, pk=id)
form = ReviewForm()
return render(request, "products/detailcoffee.html", {
'product': product,
'review_form': form
})
def views_show(request, pk):
try:
event = Event.objects.get(pk=pk)
except Event.DoesNotExist:
return redirect('events:musics_index')
if request.GET.get('action') == 'del':
event.delete()
return redirect('events:musics_index')
if request.method == 'POST' and request.GET['action'] == 'edit':
form = EventForm(request.POST, request.FILES, instance=event)
if form.is_valid():
form.save()
return redirect('events:musics_show', event.id)
if request.GET.get('action') == 'edit':
form = EventForm(instance=event)
context = {"form":form, "event":event, "edit":True}
return render(request, 'musics/show.html', context)
review_form = ReviewForm()
context = {"event":event, "edit":False, "review_form":review_form}
return render(request, 'musics/show.html', context)
def product_detail(request, product_id):
product = get_object_or_404(Product, pk=product_id)
""" A view to show individual product details """
product = get_object_or_404(Product, pk=product_id)
if request.user.is_authenticated:
user = UserProfile.objects.get(user=request.user)
else:
user = None
reviews = Review.objects.filter(product=product)
# If user has reviewed an item
try:
item_review = Review.objects.filter(user=user, product=product)
except Review.DoesNotExist:
edit_review_form = None
review_form = ReviewForm()
template = 'products/product_detail.html'
context = {
'product': product,
'reviews': reviews,
'review_form': review_form,
}
return render(request, template, context)
def testGetReviewObject(self):
f = self.testValidPost()
r = f.get_review_object()
self.assertTrue(isinstance(r, Review))
self.assertEqual(r.content_object, Article.objects.get(pk=1))
self.assertEqual(r.comment, "This is my comment")
r.save()
self.assertEqual(Review.objects.count(), 1)
# Create a review for the second site. We only test for site_id, not
# what has already been tested above.
a = Article.objects.get(pk=1)
d = self.getValidData(a)
d["comment"] = "testGetReviewObject with a site"
f = ReviewForm(Article.objects.get(pk=1), data=d)
r = f.get_review_object(site_id=self.site_2.id)
self.assertEqual(r.site_id, self.site_2.id)
def getProf(request, prof_id):
# Make a new review for the specific prof
if(request.method=='POST'):
# Insert the current user, and the prof with the id
post_values = request.POST.copy()
post_values['prof'] = prof_id
post_values['user'] = request.user.id
form = ReviewForm(post_values)
if(form.is_valid()):
form.save()
return redirect(reverse('profs_getProf', args=(prof_id,)))
else:
messages.error(request, "Error")
return render(request, 'profs/prof.html')
prof = Prof.objects.get(pk=prof_id)
reviews = Review.objects.filter(prof = prof)
return render(request, 'profs/prof.html', {'review_form': ReviewForm, 'prof': prof, 'reviews': reviews})
def book_detail(request, book_id):
"""" A view for book detail page """
book = get_object_or_404(Book, pk=book_id)
book_reviews_found = Review.objects.filter(
book_id=book_id).order_by('-review_id')
if book_reviews_found.count() > 0:
book_reviews_count = book_reviews_found.count() + book.ratings_count
else:
book_reviews_count = book.ratings_count
form = ReviewForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.instance.user = request.user
form.instance.book = book
form.save()
messages.success(request, 'Review Submitted')
form = ReviewForm(None)
return redirect(
reverse('book_detail', kwargs={'book_id': book.book_id}))
context = {
"book": book,
"book_reviews_count": book_reviews_count,
"form": form,
}
return render(request, 'books/book_detail.html', context)
def review(request, prof_id=None):
""" Review a prof """
if (request.method == 'POST'):
# Insert the current user, and the prof with the id
# Happens when review is made through Review
post_values = request.POST.copy()
if prof_id:
post_values['prof'] = prof_id
post_values['user'] = request.user.id
print(post_values)
form = ReviewForm(post_values)
if (form.is_valid()):
form.save()
prof_id = post_values['prof']
return redirect(reverse('profs_getProf', args=(prof_id, )))
else:
print(form.errors)
return render(request, 'reviews/review_form.html')
# If there's an input prof, return review page for that prof
if prof_id:
user = User.objects.get(pk=request.user.id)
prof = prof_views.prof(prof_id)
course = prof.course_set.all()
data = {'user': user, 'prof': prof}
review_form = ReviewForm(initial=data)
review_form.fields['course'].queryset = course
curr_prof = True
return render(request, 'reviews/review_form.html', {
'review_form': review_form,
'curr_prof': curr_prof,
'prof': prof
})
review_form = ReviewForm()
return render(request, 'reviews/review_form.html',
{'review_form': review_form})
def add_review(request, laptop_id):
laptop = get_object_or_404(Laptop, id=laptop_id)
form = ReviewForm(request.POST)
if form.is_valid():
rating = form.cleaned_data['rating']
comment = form.cleaned_data['comment']
review = Review()
review.laptop = laptop
review.rating = rating
review.comment = comment
review.pub_date = datetime.datetime.now()
review.save()
# Always return an HttpResponseRedirect after successfully dealing
# with POST data. This prevents data from being posted twice if a
# user hits the Back button.
return HttpResponseRedirect(reverse('reviews:review_detail', args=(review.id,)))
return render(request, 'add_review.html', {'laptop': laptop, 'form': form})
def create(request):
if request.method == "GET":
form = ReviewForm(initial={'hours': 0})
return TemplateResponse(request, 'reviews/edit.html', {'form': form})
elif request.method == "POST":
review = Review(user=request.user)
form = ReviewForm(request.POST, instance=review)
if form.is_valid():
form.save()
profile = request.user.userprofile
profile.semester_reviews = F('semester_reviews') + 1
profile.total_reviews = F('total_reviews') + 1
profile.save()
return redirect('prof_course_detail',
course_slug=review.prof_course.course.slug,
prof_slug=review.prof_course.prof.slug)
else:
return TemplateResponse(request, 'reviews/edit.html', {'form': form})
def add_review(request, game_id):
game = get_object_or_404(Game, pk=game_id)
form = ReviewForm(request.POST)
if form.is_valid():
rating = form.cleaned_data['rating']
comment = form.cleaned_data['comment']
user_name = request.user.username
review = Review()
review.game = game
review.user_name = user_name
review.rating = rating
review.comment = comment
review.pub_date = datetime.datetime.now()
review.save()
"""Always return an HttpResponseRedirect after successfully dealing
with POST data. This prevents data from being posted twice if a
user hits the Back button."""
return HttpResponseRedirect(reverse('game_detail', args=(game.id,)))
return render(request, 'game_detail.html', {'game': game, 'form': form})
def write_review_view(request, product_slug):
product = Product.objects.filter(slug=product_slug).first()
review_form = ReviewForm(request.POST or None)
if request.method == 'POST':
if review_form.is_valid():
title = review_form.cleaned_data['title']
body = review_form.cleaned_data['body']
score = review_form.cleaned_data['score']
new_review = Review(user = request.user , product = product , title=title, body=body, score=score)
new_review.save()
return redirect('product_view', product_slug=product_slug)
context = {
'product': product,
'review_form': review_form,
}
return render(request, 'products/write_review.html', context)
def test_missing_data(self):
# missing title and user_display_name is allowed
form_data = {
'rating': 3,
'review': 'Not bad'
}
form = ReviewForm(data=form_data)
self.assertTrue(form.is_valid())
form_data = {
'review': 'Not bad'
}
form = ReviewForm(data=form_data)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'rating': ['This field is required.']}
)
form_data = {
'rating': 2
}
form = ReviewForm(data=form_data)
self.assertFalse(form.is_valid())
self.assertEqual(
form.errors,
{'review': ['This field is required.']}
)
def edit(request, review_id):
review = get_object_or_404(Review.objects.select_related(), id=review_id)
# Cannot view an individual review of another user
if request.user != review.user:
raise Http404
# Show the edit page
if request.method == "GET":
form = ReviewForm(instance=review)
return TemplateResponse(request, 'reviews/edit.html', {'form': form})
# Update the review
elif request.method == "POST":
form = ReviewForm(request.POST, instance=review)
if form.is_valid():
form.save()
return redirect('index')
else:
return TemplateResponse(request, 'reviews/edit.html', {'form': form})
else:
return HttpResponse(status=404)
def test_review_form_renders_review_inputs(self):
form = ReviewForm()
self.assertIn('What was your experience?', form.as_p())
