예제 #1
0
    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
예제 #2
0
    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.']}
        )
예제 #3
0
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})
예제 #4
0
파일: views.py 프로젝트: JayCay/Academe
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 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
예제 #6
0
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)
예제 #7
0
    def test_add_review_form_invalid(self):
        form = ReviewForm({
            'content': 'Test content',
            'rating': True,
        })

        self.assertFalse(form.is_valid())
예제 #8
0
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)
예제 #9
0
파일: views.py 프로젝트: pissall20/labodega
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
    })
예제 #10
0
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 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)
예제 #12
0
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})
예제 #13
0
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))
예제 #14
0
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})
예제 #15
0
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
    })
예제 #16
0
 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.'],
     })
예제 #17
0
    def test_add_review_form_valid(self):
        form = ReviewForm({
            'title': 'Test Form',
            'content': 'Test content',
            'rating': True,
        })

        self.assertTrue(form.is_valid())
예제 #18
0
 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())
예제 #19
0
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]))
예제 #20
0
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)
예제 #21
0
파일: views.py 프로젝트: Acme-Board/board
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})
예제 #22
0
 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.']}
     )
예제 #23
0
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('/')
예제 #24
0
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"})
예제 #25
0
 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 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)
예제 #27
0
 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)
예제 #28
0
파일: views.py 프로젝트: JayCay/Academe
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})
예제 #29
0
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)
예제 #30
0
파일: views.py 프로젝트: JayCay/Academe
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})
예제 #31
0
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})
예제 #32
0
def product_detail(request, id):
    """Specific details of a particular book"""
    product = get_object_or_404(Product, id=id)
    reviews = Review.objects.filter(product_id=id).order_by('pub_date')
    product.views = product.views + 1
    product.save()
    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, 'reviews': reviews, 'form': form}
    return render(request, 'product_detail.html', context)
예제 #33
0
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})
예제 #34
0
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})
예제 #35
0
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 book(request, book_id):
    '''
    Returns the view for a single book
    '''
    book = get_object_or_404(Books, pk=book_id)
    reviews = Review.objects.filter(book_id=book_id).order_by("pub_date")
    authors = book.author
    author = Author.objects.all().filter(name=True)
    if request.method == "POST":
        form = ReviewForm(request.POST, request.FILES)
        if form.is_valid():
            review = form.save(commit=False)
            review.book = book
            review.user = request.user
            review.save()
            return HttpResponseRedirect(request.META.get("HTTP_REFERER"))
    else:
        form = ReviewForm()
    context = {"book": book, "author": "author", "reviews": reviews, "form": form}
    return render(request, "books/book.html", context)
예제 #37
0
def update_review(request, review_id):

    review_to_be_updated = get_object_or_404(Review, pk=review_id)

    if request.method == 'POST':

        update_form = ReviewForm(request.POST, instance=review_to_be_updated)
        if update_form.is_valid():
            update_form.save()

            messages.info(
                request,
                f"{update_form.cleaned_data['title']} has been updated")
            return redirect(reverse(index))
        else:
            return render(request, 'reviews/update-template.html',
                          {'form': update_form})
    else:
        update_form = ReviewForm(instance=review_to_be_updated)
        return render(request, 'reviews/update-template.html',
                      {'form': update_form})
예제 #38
0
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)
예제 #39
0
파일: views.py 프로젝트: iangbb/gitgudgames
def add_review(request, game_slug):
    try:
        game = Game.objects.get(slug=game_slug)
    except Game.DoesNotExist:
        return restricted(request,
                          status=404,
                          message="The game you're looking for doesn't exist")

    if request.method == 'POST':
        review_form = ReviewForm(data=request.POST)
        if review_form.is_valid():
            # Save review to database
            review = review_form.save(commit=False)
            review.poster = request.user
            review.game = game
            review.save()
            messages.success(request, "Your review has been added")

            # Update stored average rating
            game.average_rating = \
                (game.average_rating * game.number_ratings + int(review.rating)) / (game.number_ratings + 1)
            game.number_ratings += 1
            game.save()

            print(review.id)

            return HttpResponseRedirect(
                reverse('game', kwargs={'game_slug': game_slug}))
        else:
            messages.error(request, "You submitted an invalid review")
            review_form = ReviewForm()
    else:
        review_form = ReviewForm()

    context_dict = init_context_dict(request, "Add Review")
    context_dict['review_form'] = review_form
    context_dict['slug'] = game_slug

    return render(request, 'reviews/review.html', context=context_dict)
예제 #40
0
def movie_detail(request, movie_pk):
    movie = get_object_or_404(Movie, pk=movie_pk)
    error = ''
    recommendations = Movie.objects.filter(category=movie.category).exclude(
        pk=movie_pk)

    if request.method == 'POST':
        review_form = ReviewForm(request.POST)

        if request.user.is_authenticated():
            if review_form.is_valid():
                new_review = review_form.save(commit=False)
                new_review.movie = movie
                new_review.user = request.user
                new_review.save()

                return redirect(reverse('movies:detail', args=(movie.pk, )))
        else:
            error = 'Debes estar logeado para dejar una review'

    review_form = ReviewForm()

    avg_rating = Movie.avg_rating(movie)

    if request.user.is_staff:
        reviews = movie.reviews.a_moderar()
    else:
        reviews = movie.reviews.aceptado()

    context = {
        'movie': movie,
        'review_form': review_form,
        'error': error,
        'avg_rating': avg_rating,
        'recommendations': recommendations,
        'reviews': reviews
    }
    return render(request, 'movie_detail.html', context)
예제 #41
0
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)
예제 #42
0
def book_info(request, book_id):
    books = Book.objects.all()
    books_nav = books.order_by('-release_date')[:2]
    cart = request.session.get('shopping_cart', {})
    grand_total = 0
    for item in cart:
        grand_total += cart[item]['subtotal']

    book_selected = get_object_or_404(Book, pk=book_id)
    book_form = BookForm(instance=book_selected)
    review_form = ReviewForm(request.POST)
    reviews = Review.objects.filter(book=book_id)

    if request.method == "POST":
        if request.user.is_authenticated:
            if review_form.is_valid():
                review = review_form.save(commit=False)
                review.user = request.user
                review.book = book_selected
                review.save()
                messages.success(
                    request,
                    f"Review has been posted on {book_selected.title}")
                return redirect('book_info', book_id=book_id)
        else:
            messages.warning(request, "Kindly log in to post reviews !")
            return redirect('account_login')

    return render(
        request, 'books/book_info.template.html', {
            "books_nav": books_nav,
            "form": book_form,
            "book": book_selected,
            "reviews": reviews,
            "review_form": review_form,
            "grand_total": grand_total,
        })
예제 #43
0
 def test_form_review_ok(self):
     form = ReviewForm({'content': "content", "rating": "5"})
     self.assertTrue(form.is_valid())
def create_review(request, order_id):

    order_model = get_object_or_404(Order, pk=order_id)

    if request.method == "POST":

        review_form = ReviewForm(request.POST)

        # save the review into the database and flash out a review
        # successfully added message
        if review_form.is_valid():

            filled_review_form = review_form.save(commit=False)

            filled_review_form.reviewed_by = request.user

            filled_review_form.plant = order_model.plant

            filled_review_form.order = order_model

            filled_review_form.save()

            # to retrieve the plant to display on product page
            plant = get_object_or_404(Plant, pk=filled_review_form.plant.id)

            query = Q(plant__exact=plant)
            # to retrieve all reviews
            reviews = Review.objects.all()
            # to retrieve all the reviews for the plant
            plant_reviews = reviews.filter(query).values().distinct()

            # to retrieve ave ratings of the selected plant
            plant_ave_rating = plant_reviews.aggregate(Avg('rating'))

            # to retrieve total number of reviews for the selected plant
            plant_total_reviews = plant_reviews.count()

            # to save the plant total reviews and average ratings
            if plant_ave_rating != None and plant_total_reviews:

                plant.rating = float(plant_ave_rating['rating__avg'])

                plant.save(update_fields=["rating"])

                plant.reviews = plant_total_reviews

                plant.save(update_fields=["reviews"])

            messages.success(request, "Your review is successfully added.")

            return redirect(reverse(user_account))

        else:

            create_review_form = ReviewForm()

            return render(request, 'reviews/user_review-template.html', {
                'form': create_review_form,
                "order": order_model
            })

    else:

        create_review_form = ReviewForm()

        return render(request, 'reviews/user_review-template.html', {
            'form': create_review_form,
            "order": order_model
        })