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())