def reviews(request): c = get_common_context(request) # display all approved reviews with pagination items = Review.objects.filter(approved=True) paginator = Paginator(items, PAGINATION_COUNT) page = int(request.GET.get("page", "1")) try: items = paginator.page(page) except PageNotAnInteger: page = 1 items = paginator.page(page) except EmptyPage: page = paginator.num_pages items = paginator.page(page) c["page"] = page c["page_range"] = paginator.page_range if len(c["page_range"]) > 1: c["need_pagination"] = True c["reviews"] = items # get places list to populate place choices c["places"] = Place.objects.all() if request.method == "POST": form = ReviewForm(request.POST, request.FILES) if form.is_valid(): form.save() c["review_ok"] = True form = ReviewForm() c.update({"form": form}) return render_to_response("reviews.html", c, context_instance=RequestContext(request))
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 authorPage(request, id): try: authorPage=Profile.objects.get(pk=id) if authorPage.image: scale=scaleImage(400, authorPage.image.height) width=scale*authorPage.image.width height=scale*authorPage.image.height else: width=0 height=0 ReviewList = Review.objects.filter(Q(reviewed=authorPage)).order_by('-date') reviewed=authorPage flag='' if request.user.is_authenticated(): reviewer=Profile.objects.get(user=request.user) if Review.objects.filter(reviewer = reviewer).filter(reviewed=reviewed).exists(): flag='flag' if request.method=='POST': if reviewer==reviewed: return HttpResponseRedirect('/profiles/'+str(id)+'/') reviewForm=ReviewForm(data=request.POST) if reviewForm.is_valid(): body=reviewForm.cleaned_data['body'] rating=reviewForm.cleaned_data['ratings'] date=timezone.now() newReview=Review(reviewer=reviewer,reviewed=reviewed,body=body,ratings=rating,date=date) newReview.save() else: reviewForm=ReviewForm() except Profile.DoesNotExist: raise Http404("This profile does not exist") return render(request,"author.html",{"authorPage":authorPage,'reviewForm': reviewForm, 'ReviewList':ReviewList,'width':width,'height':height,'flag':flag})
def insert(request, itemid): try: form = ReviewForm() review = ReviewItem.objects.filter(deleted=False, item_id=itemid).order_by('id') if request.method == 'POST': form = ReviewForm(request.POST) if form.is_valid(): cd = form.cleaned_data review = cd['review'] created = datetime.datetime.now() modified = datetime.datetime.now() user = request.user.id result = ReviewItem.objects.create(review=review, item_id=itemid, createdBy_id=user, created=created, modified=created, deleted=False) if result: messages.add_message(request, messages.INFO, "Thank you for Review") else: messages.add_message(request, messages.ERROR, "Error occured. Please Try Again.") return HttpResponseRedirect('/review/' + itemid + '/') else: return render(request,'review/add.html', {'form':form, 'review':review}) else: return render(request,'review/add.html', {'form':form, 'review':review}) except: messages.add_message(request, messages.ERROR, sys.exc_info()[1]) return render(request,'review/index.html')
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 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 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 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_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 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 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 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 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 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 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 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 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_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_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 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 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): # Create one review from review.forms import ReviewForm if request.method == 'POST': form = ReviewForm(request.POST) # if review: form = ReviewForm(request.POST, instance=review) if form.is_valid(): instance = form.save() messages.success(request, "This review has been saved.") instance.user = request.user instance.save() # return HttpResponseRedirect(reverse('review.views.dashboard_view', )) else: messages.error(request, "Unable to save this review.") else: form = ReviewForm() # if review: form = ReviewForm(instance = review) movies = Movie.objects.all() return render_to_response('create_review.html', {'form': form, 'movies': movies}, context_instance=RequestContext(request))
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): 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 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_save_form_clears_decision_sent_date_when_changing_from_waitlisted( self): """ If the status of the review has been changed from waitlisted to something else, clear the decision sent date so that they can be sent a new notification email. The form will pass validation if a field has changed after a decision has been sent only if they are waitlisted, tested above. """ self._apply() self._review(status="Waitlisted") data = self.data.copy() data["status"] = "Accepted" form = ReviewForm(instance=self.user.application, data=data, request=self.request) self.assertTrue(form.is_valid()) form.save() self.user.refresh_from_db() review = self.user.application.review self.assertIsNone(review.decision_sent_date)
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 create_ticketreview(request): if request.method == 'GET': form = TicketReviewForm() return render(request, 'review/addticketreview.html', {'form': form}) elif request.method == 'POST': data = request.POST ticket_form = TicketForm({ 'title': data['ticket_title'], 'user': request.user, 'description': data['ticket_description'], 'image': data['ticket_image'] }) if ticket_form.is_valid(): ticket = ticket_form.save() review_form = ReviewForm({ 'ticket': ticket, 'rating': data['review_rating'], 'headline': data['review_headline'], 'body': data['review_body'], 'user': request.user }) if review_form.is_valid(): review_form.save() return redirect('flux')
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_form_valid_with_no_changes_decision_sent_not_waitlisted(self): """ When a decision has been sent and the user is rejected or accepted, form submissions with no changed data should be valid. This is necessary for the admin site which submits each form, regardless of whether it is dirty or not. """ self._apply() self._review() data = {} for field in ( "interest", "quality", "experience", "reviewer_comments", "status", ): data[field] = getattr(self.user.application.review, field) form = ReviewForm(instance=self.user.application, data=data, request=self.request) self.assertTrue(form.is_valid())
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 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 page(request): c = get_common_context(request) if request.POST and request.POST['action'] == 'call': call_form = RequestForm(request.POST) if call_form.is_valid(): call_form.save() call_form = RequestForm() messages.success(request, u'Спасибо! В ближайшее время мы Вам перезвоним.') return HttpResponseRedirect('/') else: call_form = RequestForm() if request.POST and request.POST['action'] == 'request': reg_form = RegisterForm(request.POST) if reg_form.is_valid(): reg_form.save() reg_form = RegisterForm() messages.success(request, u'Спасибо! Ваша заявка отправлена.') return HttpResponseRedirect('/') else: reg_form = RegisterForm() if request.POST and request.POST['action'] == 'review': review_form = ReviewForm(request.POST) if review_form.is_valid(): review_form.save() review_form = ReviewForm() messages.success(request, u'Спасибо! Ваш отзыв отправлен.') return HttpResponseRedirect('/') else: review_form = ReviewForm() c['call_form'] = call_form c['reg_form'] = reg_form c['review_form'] = review_form c['photos'] = Photo.objects.all() c['reviews'] = Review.objects.all() return render_to_response('base.html', c, context_instance=RequestContext(request))
def review_detail(request, pk): proposals = Proposal.objects.select_related("result") proposal = get_object_or_404(proposals, pk=pk) admin = request.user.groups.filter(name="reviewers-admins").exists() speakers = [s.user for s in proposal.speakers()] if proposal.session_type == Proposal.SESSION_TYPE_TUTORIAL: if not request.user.groups.filter(name="reviewers-tutorials").exists(): return access_not_permitted(request) else: if not request.user.groups.filter(name="reviewers").exists(): return access_not_permitted(request) if not admin and request.user in speakers: return access_not_permitted(request) try: latest_vote = LatestVote.objects.get(proposal=proposal, user=request.user) except LatestVote.DoesNotExist: latest_vote = None if request.method == "POST": if request.user in speakers: return access_not_permitted(request) if proposal.invited: return access_not_permitted(request) if "vote_submit" in request.POST: review_form = ReviewForm(request.POST) if review_form.is_valid(): review = review_form.save(commit=False) review.user = request.user review.proposal = proposal review.save() return redirect(request.path) else: message_form = SpeakerCommentForm() elif "message_submit" in request.POST: message_form = SpeakerCommentForm(request.POST) if message_form.is_valid(): message = message_form.save(commit=False) message.user = request.user message.proposal = proposal message.save() for speaker in speakers: if speaker and speaker.email: ctx = { "proposal": proposal, "message": message, "reviewer": False, } send_email( [speaker.email], "proposal_new_message", context = ctx ) return redirect(request.path) elif "result_submit" in request.POST: if admin: result = request.POST["result_submit"] if result == "accept": proposal.result.accepted = True proposal.result.save() elif result == "reject": proposal.result.accepted = False proposal.result.save() elif result == "undecide": proposal.result.accepted = None proposal.result.save() return redirect(request.path) else: initial = {} if latest_vote: initial["vote"] = latest_vote.vote review_form = ReviewForm(initial=initial) message_form = SpeakerCommentForm() proposal.comment_count = proposal.result.comment_count proposal.total_votes = proposal.result.vote_count proposal.plus_one = proposal.result.plus_one proposal.plus_zero = proposal.result.plus_zero proposal.minus_zero = proposal.result.minus_zero proposal.minus_one = proposal.result.minus_one reviews = Review.objects.filter(proposal=proposal).order_by("-submitted_at") return render_to_response("reviews/review_detail.html", { "proposal": proposal, "latest_vote": latest_vote, "reviews": reviews, "review_form": review_form, "message_form": message_form }, context_instance=RequestContext(request))