def addReview(request, book_id): book = get_object_or_404(Book, pk=book_id) userReview = request.user.adult.reviews.filter(book=book) if request.method == "GET": if (len(userReview) > 0): return render(request, "review/addReview.html", { "form": ReviewForm(instance=userReview[0]), "book_id": book_id }) else: return render(request, "review/addReview.html", { "form": ReviewForm(), "book_id": book_id }) elif request.method == "POST": if (len(userReview) > 0): Review.delete(userReview[0]) form = ReviewForm(request.POST) if form.is_valid(): newReview = form.save(commit=False) newReview.save() newReview.book.add(book) request.user.adult.reviews.add(newReview) return redirect("book_card", book_id) else: return render(request, "review/addReview.html", { "form": ReviewForm(), "book_id": book_id, "error": "bad data" })
def review_add_view(request, pk): user = request.user if not user.is_authenticated: return HttpResponse(status=403) member = Member.objects.get(pk=user.id) if member.member_type != 0: return HttpResponse(status=401) market = Market.objects.get(pk=pk) form = ReviewForm() if request.method == 'POST': form = ReviewForm(data=request.POST) if form.is_valid(): review = form.save(commit=False) review.market_idx = market.id review.reviewer_idx = member.consumer_idx review.reviewer_name = member.username review.save() market.stars += review.stars market.save() return redirect('market_post', pk=pk) context = {'form': form, 'market': market} return render(request, 'review/add.html', context=context)
def create_review(request, id_ticket=None): review = None context = {} if id_ticket is not None: ticket = get_object_or_404(Ticket, pk=id_ticket) context = {'post': {'content': ticket}} review = Review(ticket=ticket, rating=None, headline=None, body=None, user=request.user, time_created=None) else: review = Review(ticket=None, rating=None, headline=None, body=None, user=request.user, time_created=None) if request.method == 'GET': form = ReviewForm(instance=review) context['form'] = form return render(request, 'review/addreview.html', context) elif request.method == 'POST': form = ReviewForm(request.POST) if form.is_valid(): form.save() ticket.save() return redirect('flux') else: return render(request, 'review/addreview.html', context)
def create_review(request): created = False if request.method == 'POST': review_form = ReviewForm(data=request.POST) if review_form.is_valid(): review = review_form.save() review.save() created = True else: print(review_form.errors) else: review_form = ReviewForm() return render(request, 'review/create_review.html', { 'review_form': review_form, 'created': created })
def handle(self, request, goal_slug, suggestion_slug): suggestion = get_object_or_404(Suggestion, slug=suggestion_slug) latest_revision = suggestion.get_current_revision() all_reviews = Review.objects.filter(revision__suggestion=suggestion) review = ( None if not request.member else self.__get_or_create_review(request, latest_revision, all_reviews) ) submit = request.POST.get('submit', 'none') if submit == 'cancel' and review.is_draft: submit = 'save draft' if request.method == 'POST': bound_form = ReviewForm(request.POST, request.FILES) if submit in ('save', 'save draft'): self.__update_review_and_save(review, bound_form, submit) review_form = None if request.global_user and suggestion.owner != request.global_user: review_form = ( bound_form if submit == 'save' else ReviewForm(instance=review) ) if suggestion.type == Suggestion.TYPE_ACTION: review_form.fields['experience'].choices = \ tuple(list(Review.EXPERIENCE_CHOICES)[:-1]) published_reviews = \ all_reviews.filter(is_draft=False).order_by('-pub_date') context = { 'latest_revision': latest_revision, 'review': review, 'post_button_header': ( None if not review else "Rate this suggestion and give feedback" if review.is_draft else "Update your review of this suggestion" ), 'post_button_label': ( None if not review else "Submit" if review.is_draft else "Update" ), 'form': review_form, 'published_reviews': published_reviews, } return render(request, 'review/reviews.html', context)
def post(self, request): form = ReviewForm(request.POST) print(form) if form.is_valid(): print(' in review create') form.save(commit=True) else: print('in else') form = ReviewForm() return render(request, 'companyreview.html', {'form': form})
def sample(request): rev_form = ReviewForm() if request.POST: rev_form = ReviewForm(request.POST) if rev_form.is_valid(): form1 = rev_form.save() context={'form1':rev_form} return render(request, "forms.html", context)
def review_update(request, service_id, review_id): categories = Category.objects.all().order_by('updated_at') my_re = Review.objects.get(pk=review_id) try: service = Service.objects.get(pk=service_id) except: raise Http404 review = Review.objects.filter(service_obj=service) review_form = ReviewForm(instance=my_re) if request.method=="POST": updated_form = ReviewForm(request.POST, instance=my_re) if updated_form.is_valid(): updated_form.save() return redirect('my_review') return render(request, 'service.html', {'review':review,'review_form':review_form,'categories':categories,'service':service})
def modify_review(request, id_review): context = {} review = get_object_or_404(Review, pk=id_review) if request.method == 'GET': if review is None: pass else: form = ReviewForm(instance=review) context = {'post': {'content': review.ticket}, 'form': form} return render(request, 'review/addreview.html', context) elif request.method == 'POST': form = ReviewForm(request.POST, instance=review) if form.is_valid(): form.save() return redirect('posts')
def reviews(request): reviews_set = Review.objects.filter(is_active=True).order_by('date') department_set = Department.objects.all() review_form = ReviewForm(request.POST or None) if request.method == 'POST' and review_form.is_valid(): review_form.save() return HttpResponseRedirect(request.META.get('HTTP_REFERER')) appointment_form = AppointmentForm(request.POST or None) if request.method == 'POST' and appointment_form.is_valid(): appointment_form.save() return HttpResponseRedirect(request.META.get('HTTP_REFERER')) paginator = Paginator(reviews_set, 4, orphans=2) page = request.GET.get('page') try: articles = paginator.page(page) except PageNotAnInteger: articles = paginator.page(1) except EmptyPage: articles = paginator.page(paginator.num_pages) return render( request, 'reviews.html', { "articles": articles, "review_form": review_form, 'appointment_form': appointment_form, 'departments': department_set })
def test_allows_changes_after_waitlisted_decision_sent(self): self._apply() self._review(status="Waitlisted") form = ReviewForm(instance=self.user.application, data=self.data, request=self.request) self.assertTrue(form.is_valid())
def post(self, request, pk): print(self.request.POST) new_review = ReviewForm(request.POST) lecture = Lecture.objects.get(pk=pk) current_student = Student.objects.get_current_student(request) context = { 'lecture': lecture, 'form': ReviewForm, 'review_list': Review.objects.filter(lecture=lecture), 'student': current_student } if new_review.is_valid(): print(self.request.POST) # 省略する title = new_review.cleaned_data['title'] comment = new_review.cleaned_data['comment'] rate_pass = new_review.cleaned_data['rate_pass'] rate_professor = new_review.cleaned_data['rate_professor'] Review.objects.create(lecture=lecture, title=title, comment=comment, rate_pass=rate_pass, rate_professor=rate_professor, student=current_student) # 省略する return render(request, self.template_name, context) else: context['form'] = new_review return render(request, self.template_name, context)
def get_context_data(self, **kwargs): context = super(ReviewDetail, self).get_context_data(**kwargs) context['submission'] = Submission.objects.get(pk=kwargs.get('pk', None)) context['review_form'] = ReviewForm() return context
def add_review_to_portfolio(request, pk): portfolio = get_object_or_404(ArtistPortfolio, pk=pk) if request.POST: form = ReviewForm(request.POST) if form.is_valid(): review = form.save(commit=False) review.portfolio = portfolio review.name = request.user review.save() messages.success(request, "Review created successfully ") url = reverse_lazy('artist:detail', kwargs={'slug': portfolio.slug}) return redirect(url) form = ReviewForm(initial={'portfolio': portfolio}) return render(request, 'reviews/add_review.html', {'form': form})
def test_does_not_initialize_with_no_instance(self): form = ReviewForm(request=self.request) for field in ( "interest", "experience", "quality", "status", "reviewer_comments", ): self.assertIsNone(form.fields[field].initial)
def test_review_forms_without_comment(self): """ test is valid without comment """ form = ReviewForm( data={ "score_intention": 4, "score_technical": 4, "score_picture": 4, "score_global": 4 }) self.assertTrue(form.is_valid)
def test_does_not_allow_changes_after_reject_decision_sent(self): self._apply() self._review(status="Rejected") form = ReviewForm(instance=self.user.application, data=self.data, request=self.request) self.assertFalse(form.is_valid()) self.assertEqual(len(form.non_field_errors()), 1) self.assertIn( "Reviews cannot be changed after a decision has been sent.", form.non_field_errors()[0], )
def edit_review(request, comment_id): commit = request.GET.get('commit') db_comment = request.GET.get('comment') if request.method == 'POST': print("data posted") form = ReviewForm(request.POST) #if form.is_valid(): review = Review.objects.get(id=comment_id) comment = form.data['comment'] review.comment = comment review.save(update_fields=['comment']) if commit == 'true': return HttpResponse("Changes made") form = ReviewForm() context = { 'form_edit': form, 'r_id': comment_id, 'review': db_comment, } return render(request, 'review/review_edit.html', context)
def post(self, request, pk): product = get_object_or_404(Product, id=pk) form = ReviewForm(data=request.POST) if form.is_valid(): review = Review.objects.create( author=self.request.user, product=product, text=form.cleaned_data.get('text'), rating=form.cleaned_data.get('rating') ) review.save() return redirect('review:product-list')
def test_initializes_fields_from_instance(self): self._apply() self._review() form = ReviewForm(instance=self.user.application, request=self.request) for field in ( "interest", "experience", "quality", "status", "reviewer_comments", ): self.assertEqual(form.fields[field].initial, getattr(self.review, field))
def test_review_forms_not_all_score(self): """ test missing score """ form = ReviewForm( data={ "score_intention": 4, "score_technical": 4, "score_picture": 4, "comment_intention": "comment_intention", "comment_technical": "comment_technical", "comment_picture": "comment_picture", "comment_global": "comment_global" }) self.assertEqual(form.errors['score_global'][0], "Ce champ est obligatoire.")
def test_review_forms_all_score(self): """ test all score is valid """ form = ReviewForm( data={ "score_intention": 4, "score_technical": 4, "score_picture": 4, "score_global": 4, "comment_intention": "comment_intention", "comment_technical": "comment_technical", "comment_picture": "comment_picture", "comment_global": "comment_global" }) self.assertTrue(form.is_valid)
def test_save_form_with_no_existing_review(self): self._apply() form = ReviewForm(instance=self.user.application, data=self.data, request=self.request) self.assertTrue(form.is_valid()) form.save() self.user.refresh_from_db() self.assertTrue(hasattr(self.user.application, "review")) review = self.user.application.review for field in self.data: self.assertEqual(getattr(review, field), self.data[field]) self.assertEqual(review.reviewer, self.reviewer2)
def restaurant_detail(request, restaurant_slug): restaurant_instance = get_object_or_404(Restaurant, slug=restaurant_slug) # content_type = ContentType.objects.get_for_model(Restaurant) # obj_id = restaurant.id # Restaurant.objects.get(id=restaurant.id) # reviews = Review.objects.filter_by_instance(instance) initial_data = { 'content_type': restaurant_instance. get_content_type, # no need to give () because its a parenthesis 'object_id': restaurant_instance.id } form = ReviewForm(request.POST or None, initial=initial_data) if form.is_valid(): print('review form', form.cleaned_data) c_type = form.cleaned_data.get('content_type') print('c_type', c_type) content_type = ContentType.objects.get(model=c_type) print('content_type form', content_type) object_id = form.cleaned_data.get('object_id') review = form.cleaned_data.get('review') parent_obj = None try: parent_id = int(request.POST.get( 'parent_id')) # <input type="hidden" name="parent_id" /> print('parent_id', parent_id) except: parent_id = None if parent_id: parent_qs = Review.objects.filter(id=parent_id) print('parent_qs', parent_qs) if parent_qs.exists(): parent_obj = parent_qs.first() print('parent_obj', parent_obj) new_review, created = Review.objects.get_or_create( reviewer=request.user, content_type=content_type, object_id=object_id, review=review, parent=parent_obj) return redirect(new_review.content_object.get_absolute_url()) reviews = restaurant_instance.review return render( request, 'restaurant/restaurant_detail.html', { 'restaurant_instance': restaurant_instance, 'reviews': reviews, 'review_form': form })
def post(self, request, *args, **kwargs): submission = Submission.objects.get(pk=kwargs.get('pk', None)) if submission.status == 0: submission.status = 1 submission.save() return redirect('review', submission.pk) elif submission.status == 1: form = ReviewForm(request.POST) if form.is_valid(): review = Review(reviewer=request.user.judge, submission=submission, comment=request.POST['comment']) review.save() submission.status = request.POST['status'] submission.save() return redirect('reviews')
def post(self, request, *args, **kargs): form = ReviewForm(request.POST) if (form.is_valid()): review = form.save(commit=False) review.movie = Movie.objects.get(pk=kargs['movie_pk']) review.created_by = User.objects.get(id=request.user.id) try: review.save() except IntegrityError as e: old_review = Review.objects.filter( movie=review.movie, created_by=review.created_by)[0] old_review.comment = review.comment old_review.rate = review.rate old_review.save() return redirect( "movies:movie", kargs['movie_pk'], )
def review_form(request, username, template_name="review/review_form.html"): healer = get_object_or_404(Healer, user__username__iexact=username) if not healer.is_review_permission(request.user): raise Http404 reviewer = get_object_or_404(Client, user=request.user) try: review = Review.objects.filter(healer=healer, reviewer=reviewer)[0] notify = False title = 'Edit My Review for ' except IndexError: review = None notify = True title = 'Write a Review for ' title += str(healer.user.client) prev_rating = review.rating if review else None fb = request.GET.get('fb', False) if fb: template_name = "review/review_fb_form.html" form = ReviewForm(request.POST or None, instance=review) if form.is_valid(): review = form.save(commit=False) review.healer = healer review.reviewer = reviewer review.save() if notify: review.notify() healer.update_rating(review.rating, prev_rating) if healer.review_permission == Healer.VISIBLE_EVERYONE and not is_my_client(healer.user, request.user): friend_process(request, 'clients', healer.user.id, 'invite') return redirect(reverse('review_form_success', args=[healer.user.username]) + ('?fb=1' if fb else '')) return render_to_response(template_name, { "title": title, "healer": healer, "form": form, "fb": fb }, context_instance=RequestContext(request))
def test_save_form_does_not_clear_decision_sent_date_for_waitlisted_changes( self): """ When waitlisted, changes are still allowed to the review. Unlike above, if their status is not changed to something else, changes get saved but decision_sent_date should not get cleared. """ self._apply() self._review(status="Waitlisted") form = ReviewForm(instance=self.user.application, data=self.data, request=self.request) self.assertTrue(form.is_valid()) form.save() self.user.refresh_from_db() review = self.user.application.review self.assertIsNotNone(review.decision_sent_date)
def test_save_form_with_existing_review(self): """ Reviews are allowed to be changed as long as a decision has not been sent (tested above) """ self._apply() self._review(decision_sent_date=None) form = ReviewForm(instance=self.user.application, data=self.data, request=self.request) self.assertTrue(form.is_valid()) form.save() self.user.refresh_from_db() review = self.user.application.review for field in self.data: self.assertEqual(getattr(review, field), self.data[field]) # The reviewer should be updated self.assertEqual(review.reviewer, self.reviewer2)
def test_save_with_commit_false(self): """ When save is called with commit=False, the review should be set on the form and form.save_m2m should be set to form._save_m2m_and_review() """ self._apply() form = ReviewForm(instance=self.user.application, data=self.data, request=self.request) form.is_valid() form.save(commit=False) self.assertIsInstance(form.review, Review) self.user.refresh_from_db() self.assertFalse(hasattr(self.user.application, "review")) form.save_m2m() self.user.refresh_from_db() self.assertTrue(hasattr(self.user.application, "review")) self.assertEqual(form.review, self.user.application.review)