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))
