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 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 testProfanities(self): """Test REVIEW_ALLOW_PROFANITIES and PROFANITIES_LIST settings""" a = Article.objects.get(pk=1) d = self.getValidData(a) # Save settings in case other tests need 'em saved = getattr(settings, 'PROFANITIES_LIST', []), getattr(settings, 'REVIEW_ALLOW_PROFANITIES', False) # Don't wanna swear in the unit tests if we don't have to... settings.PROFANITIES_LIST = ["rooster"] # Try with REVIEW_ALLOW_PROFANITIES off settings.REVIEW_ALLOW_PROFANITIES = False f = ReviewForm(a, data=dict(d, comment="What a rooster!", rating="4")) self.assertFalse(f.is_valid()) # Now with REVIEW_ALLOW_PROFANITIES on settings.REVIEW_ALLOW_PROFANITIES = True f = ReviewForm(a, data=dict(d, comment="What a rooster!", rating="4")) self.assertTrue(f.is_valid()) # Restore settings settings.PROFANITIES_LIST, settings.REVIEW_ALLOW_PROFANITIES = saved
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 create_review(request, book_id): if request.method == "POST": create_form = ReviewForm(request.POST) if create_form.is_valid(): # The commit=false optional parameter is passed to the form.save() function. # This will create a new instance of Review using the data in the POST request, # but won't save to the database yet so that we can assign the user to the review. review = create_form.save(commit=False) # To access the current user by referring to the user object inside the request object. # When the review is added, we will assign the current logged # in user to the user variable in the Review object. review.user = request.user review.book = get_object_or_404(Book, pk=book_id) review.save() messages.success( request, f"New Book Review, {create_form.cleaned_data['title']}, has been created" ) return redirect(reverse(index)) else: return render(request, 'reviews/create-template.html', {'form': create_form}) else: create_form = ReviewForm() return render(request, 'reviews/create-template.html', {'form': create_form})
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_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 product_detail(request, pk): ''' Create a view that returns a single Product object based on the product ID (pk) and render it to the 'product_detail.html' template Or return a 404 if the post is not found. ''' product = get_object_or_404(Product, pk=pk) avg_rating = Review.objects.filter(product_id=pk).aggregate(Avg('rating')) try: reviews = Review.objects.filter(product_id=pk).order_by('-created') except: reviews = None if request.method == 'POST': form = ReviewForm(request.POST, request.FILES) if form.is_valid(): review = form.save(commit=False) review.product = product review.user = request.user review.save() return HttpResponseRedirect(request.META.get('HTTP_REFERER')) else: form = ReviewForm() context = { 'product': product, 'avg_rating': avg_rating, 'reviews': reviews, 'form': form, } return render(request, "product_detail.html", context)
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 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 post(self, *args, **kwargs): qs = Review.objects.filter(user=self.request.user, book=self.get_object()) if not qs.exists(): form = ReviewForm(self.request.POST) if form.is_valid(): obj = form.save(commit=False) obj.user = self.request.user obj.book = self.get_object() obj.save() else: form = ReviewForm(self.request.POST, instance=qs.first()) form.save() return redirect('books:book_detail', self.get_object().id)
def add_review(request, id): """ View to add a review for an artifact, redirect back to view detail. """ if request.method == "POST": review_form = ReviewForm(request.POST) if review_form.is_valid(): review_artifact = review_form.save(commit=False) try: review_artifact.review_id = Review.objects.get(artifact=id) except: review_artifact.review_id = Review.objects.create( artifact=Artifact.objects.get(pk=id)) review_artifact.review_owner_id = request.user.id review_artifact.review_date = timezone.now() review_artifact.save() messages.success( request, "You have successfully added a review for the artifact.") else: messages.error( request, "Sorry, there was a problem with your review submission.") else: review_form = ReviewForm() reviewed = False reviews = ReviewLineItem.objects.filter(review_id__artifact=id) artifact = Artifact.objects.get(id=id) ownership = OrderLineItem.objects.filter(artifact=id).filter( owner_id=request.user.id).first() if ownership != None: owner = True for review in reviews: if review.review_owner_id == ownership.owner_id: reviewed = True else: owner = False return render( request, "review.html", { "artifact": artifact, "review_form": review_form, "reviews": reviews, "owner": owner, "reviewed": reviewed, }) return redirect("view_artifact", id=id)
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 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 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 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, id): items = get_object_or_404(Product, id=id) form = ReviewForm() return render(request, "products/productdetails.html", { 'items': items, 'review_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 test_add_review_form_invalid(self): form = ReviewForm({ 'content': 'Test content', 'rating': True, }) self.assertFalse(form.is_valid())
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 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 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 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 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 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 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 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 test_add_review_form_valid(self): form = ReviewForm({ 'title': 'Test Form', 'content': 'Test content', 'rating': True, }) self.assertTrue(form.is_valid())