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)
