def post_review(request, reviewId):
context = RequestContext(request)
user = request.user
user_profile = UserProfile.objects.get(user=user.pk)
review = Review.objects.get(pk=reviewId, user=user.pk)
user_is_owner(user, review)
project = Project.objects.get(pk=review.project.pk)
rfp = RfpCampaign.objects.get(id=project.rfp.id)
questions = rfp.get_review_questions()
is_p = is_pi(user)
is_rev = is_reviewer(user)
review_item = Review.objects.get(user=user.pk, project=project.pk)
review_model_dict = model_to_dict(review_item)
redirect_url = get_redirect_url(request) + str("#yourreview")
if request.method == "POST":
form = ReviewForm(request.POST, request.FILES, questions=questions)
if len(request.POST.get("next")) > 0:
if form.is_valid():
form_data = form.cleaned_data
updated_review = Review.objects.update_or_create(user=user.pk, project=project.pk, defaults=form_data)
up_rev = updated_review[0]
up_rev.save()
return HttpResponseRedirect(request.POST.get("next"))
else:
if form.is_valid():
form_data = form.cleaned_data
updated_review = Review.objects.update_or_create(user=user.pk, project=project.pk, defaults=form_data)
up_rev = updated_review[0]
up_rev.send_confirmation_email_to_reviewer()
up_rev.status = "completed"
up_rev.save()
return HttpResponseRedirect(redirect_url)
else:
form = ReviewForm(initial=review_model_dict, questions=questions)
return render_to_response(
"rfp/post_review.html",
{
"is_pi": is_p,
"is_rev": is_rev,
"form": form,
"project": project,
"user": user,
"up": user_profile,
"review": review,
},
context,
)
def add_review(request, profID):
if request.method == 'POST':
form = ReviewForm(request.POST)
if form.is_valid():
review = Review()
review.professor = Professor.objects.get(id=profID)
review.poster = request.user
review.course = form.cleaned_data['course']
review.year_taken = form.cleaned_data['year_taken']
review.review = form.cleaned_data['review']
if Review.objects.filter(poster=request.user).filter(professor=review.professor).count > 0:
params = {
'message': 'You cannot review the same professor multiple times',
}
return render(request, 'message.html', params)
review.save()
return HttpResponseRedirect('/accounts/profs/profID/' + profID + '/')
else:
form = ReviewForm()
prof = Professor.objects.get(id=profID)
params = {
'form': form,
'formTitle': 'Add a review for ' + str(prof.firstName) + ' ' + str(prof.lastName),
}
return render(request, 'profSearch.html', params)
def review(request):
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = ReviewForm(request.POST)
# check whether it's valid:
if form.is_valid():
campus_audience = form.cleaned_data['campus_audience']
campus_need = form.cleaned_data['campus_need']
sponsor_name = form.cleaned_data['sponsor_name']
sponsor_netid = form.cleaned_data['sponsor_netid']
sponsor_email = form.cleaned_data['sponsor_email']
dev_name = form.cleaned_data['dev_name']
dev_email = form.cleaned_data['dev_email']
support_name = form.cleaned_data['support_name']
support_email = form.cleaned_data['support_email']
support_contact = form.cleaned_data['support_contact']
ats_review = form.cleaned_data['ats_review']
ux_review = form.cleaned_data['ux_review']
brand_review = form.cleaned_data['brand_review']
app_documentation = form.cleaned_data['app_documentation']
app_code = form.cleaned_data['app_code']
anything_else = form.cleaned_data['anything_else']
email_context = Context({
'campus_audience': campus_audience,
'campus_need': campus_need,
'sponsor_name': sponsor_name,
'sponsor_netid': sponsor_netid,
'sponsor_email': sponsor_email,
'dev_name': dev_name,
'dev_email': dev_email,
'support_name': support_name,
'support_email': support_email,
'support_contact': support_contact,
'ats_review': ats_review,
'ux_review': ux_review,
'brand_review': brand_review,
'app_documentation': app_documentation,
'app_code': app_code,
'anything_else': anything_else
})
try:
send_mail(
sponsor_name,
get_template(
'mdotdevs/email_plain.html').render(email_context),
sponsor_email, ['*****@*****.**'],
html_message=get_template('mdotdevs/email_html.html')
.render(email_context),
),
except BadHeaderError:
return HttpResponse('Invalid header found.')
return render_to_response(
'mdotdevs/thanks.html',
context_instance=RequestContext(request))
# if a GET (or any other method) we'll create a blank form
else:
form = ReviewForm()
return render(request, 'mdotdevs/review.html', {'form': form})
def single_product(request, slug):
product = get_object_or_404(Product, slug=slug)
prod = Product.objects.get(slug=slug)
reviews = Review.objects.get(product=prod.id)
reviewmatrix = {}
user = request.user
i = 0
try:
for rev in reviews:
reviewmatrix[str(i)] = [[review.review_text]]
u = User.objects.get(username=rev.user)
i = i + 1
except:
u = User.objects.get(username=reviews.user)
reviewmatrix[str(i)] = [[reviews.review_text]]
if request.method=="POST":
form = ReviewForm(request.POST)
if form.is_valid():
user2 = get_object_or_404(User, pk=user.id)
response = form.save(user=user2.id, product=prod.id)
msg = 'Obrigado por avaliar ' + prod.name
else:
msg = 'Houve algum erro no servidor :('
return render(request, 'product_detail.html', {'prod':prod, 'reviews':reviews, 'user':u.first_name, 'msg':msg})
else:
form = ReviewForm()
args = {}
args.update(csrf(request))
return render(request, 'product_detail.html', {'prod':prod, 'reviews':reviews, 'user':u.first_name, 'form':form})
def show_book(request, id_book):
authenticated = False
if request.user.is_authenticated():
authenticated = True
book = Book.objects.get(id_book=id_book)
if request.method == 'POST':
review_form = ReviewForm(request.POST)
if review_form.is_valid():
new_review = review_form.save(commit=False)
new_review.book = book
new_review.user = request.user
new_review.save()
# TODO: Get reviews by ISBN not by book
reviews = Review.objects.filter(book=book)
review_form = ReviewForm()
if len(reviews):
rating = round(sum([float(review.rating) for review in reviews]) / len(reviews), 2)
else:
rating = "No reviews yet"
return render_to_response("book.html", context_instance=RequestContext(request,
{'authenticated': authenticated,
'book': book, 'reviews': reviews,
'review_form': review_form,
'rating': rating}))
def review(request):
saved = False
review = ''
if request.method == 'POST':
form = ReviewForm(request.POST)
if form.is_valid():
user_sender = User.objects.get(pk=request.POST['id_sender'])
user_receiver = User.objects.get(pk=request.POST['id_receiver'])
content = request.POST['content']
sent = True
re = Review()
re.id_sender = user_sender
re.id_receiver = user_receiver
re.content = content
re.save()
mail_data = {}
mail_data['subject'] = 'You have a new review.'
mail_data['message'] = '''
%s %s, <br> %s %s wrote a review about you. Here are the details<br>
<h3>Details: </h3><br>
%s
''' % (user_receiver.first_name, user_receiver.last_name, user_sender.first_name, user_sender.last_name, content)
mail_data['from'] = '*****@*****.**'
mail_data['sender'] = user_sender.email
mail_data['receiver'] = user_receiver.email
sent = utils.send_mail(mail_data)
saved = True
return HttpResponseRedirect('/trainer/%d' % (user_receiver.id))
else:
return HttpResponseRedirect('/')
def add_review(request, bbl=None):
lot = get_object_or_404(Lot, bbl=bbl)
if request.method == 'POST':
form = ReviewForm(request.POST)
if form.is_valid():
form.save()
return redirect('lots.views.details', bbl=bbl)
else:
initial_data = {
'reviewer': request.user,
'lot': lot,
'in_use': not lot.is_vacant,
'actual_use': lot.actual_use,
}
reviews = Review.objects.filter(lot=lot).order_by('-added')
fields = ('in_use', 'actual_use', 'accessible', 'needs_further_review',
'nearby_lots', 'hpd_plans', 'hpd_plans_details')
if reviews:
last_review = reviews[0]
for field in fields:
initial_data[field] = last_review.__dict__[field]
form = ReviewForm(initial=initial_data)
return render_to_response('lots/add_review.html', {
'form': form,
'lot': lot,
}, context_instance=RequestContext(request))
def add_review(request, bbl=None):
lot = get_object_or_404(Lot, bbl=bbl)
if request.method == 'POST':
form = ReviewForm(request.POST)
if form.is_valid():
form.save()
return redirect('lots.views.details', bbl=bbl)
else:
initial_data = {
'reviewer': request.user,
'lot': lot,
'in_use': not lot.is_vacant,
'actual_use': lot.actual_use,
}
reviews = Review.objects.filter(lot=lot).order_by('-added')
fields = ('in_use', 'actual_use', 'accessible', 'needs_further_review',
'nearby_lots', 'hpd_plans', 'hpd_plans_details')
if reviews:
last_review = reviews[0]
for field in fields:
initial_data[field] = last_review.__dict__[field]
form = ReviewForm(initial=initial_data)
return render_to_response('lots/add_review.html', {
'form': form,
'lot': lot,
},
context_instance=RequestContext(request))
def show_book(request, id_book):
authenticated = False
if request.user.is_authenticated():
authenticated = True
book = Book.objects.get(id_book=id_book)
if request.method == 'POST':
review_form = ReviewForm(request.POST)
if review_form.is_valid():
new_review = review_form.save(commit=False)
new_review.book = book
new_review.user = request.user
new_review.save()
# TODO: Get reviews by ISBN not by book
reviews = Review.objects.filter(book=book)
review_form = ReviewForm()
if len(reviews):
rating = round(
sum([float(review.rating) for review in reviews]) / len(reviews),
2)
else:
rating = "No reviews yet"
return render_to_response("book.html",
context_instance=RequestContext(
request, {
'authenticated': authenticated,
'book': book,
'reviews': reviews,
'review_form': review_form,
'rating': rating
}))
def post_review(request,reviewId):
context = RequestContext(request)
user = request.user
user_profile = UserProfile.objects.get(user = user.pk)
review = Review.objects.get(pk = reviewId, user=user.pk)
user_is_owner(user,review)
project = Project.objects.get(pk = review.project.pk)
rfp = RfpCampaign.objects.get(id = project.rfp.id)
questions = rfp.get_review_questions()
is_p = is_pi(user)
is_rev = is_reviewer(user)
review_item = Review.objects.get(user = user.pk, project = project.pk)
review_model_dict = model_to_dict(review_item)
redirect_url = get_redirect_url(request) + str('#yourreview')
if request.method == 'POST':
form = ReviewForm(request.POST,request.FILES,questions=questions)
if len(request.POST.get('next')) > 0:
if form.is_valid():
form_data = form.cleaned_data
updated_review = Review.objects.update_or_create(user = user.pk, project = project.pk, defaults=form_data)
up_rev = updated_review[0]
up_rev.save()
return HttpResponseRedirect(request.POST.get('next'))
else:
if form.is_valid():
form_data = form.cleaned_data
updated_review = Review.objects.update_or_create(user = user.pk, project = project.pk, defaults=form_data)
up_rev = updated_review[0]
up_rev.send_confirmation_email_to_reviewer()
up_rev.status = 'completed'
up_rev.save()
return HttpResponseRedirect(redirect_url)
else:
form = ReviewForm(initial= review_model_dict,questions = questions)
return render_to_response('rfp/post_review.html',{'is_pi' : is_p, 'is_rev': is_rev,
'form' : form, 'project' : project, 'user' : user, 'up' : user_profile,'review' : review}, context)
def post(self, request):
form = ReviewForm(request.POST)
if form.is_valid():
review = form.data['review']
y, prob = classify(review)
return render(request, 'result.html', {
'review': review,
'y': y,
'prob': prob
})
def adicionar(request):
form = ReviewForm()
if request.method == 'POST':
form = ReviewForm(request.POST)
if form.is_valid():
review = Review(user = request.user)
form = ReviewForm(request.POST, instance=review)
form.save()
return redirect('/review/')
return render(request, 'review/adicionar.html', locals())
def sign(request):
form = ReviewForm(request.POST)
if form.is_valid():
post = Post(
author=form.clean_data["author"],
review=form.clean_data["review"],
rating=form.clean_data["rating"],
appid=form.clean_data["appid"],
appname=form.clean_data["appname"],
)
# if users.GetCurrentUser():
# post.author = users.GetCurrentUser()
post.put()
return HttpResponseRedirect("/")
def create_review(request, series_id):
if request.POST:
form = ReviewForm(request.POST, series_id)
if form.is_valid():
form.save()
return HttpResponseRedirect('/genre/all/') #stuck this here, trying to get past it
else:
form = ReviewForm()
args = {}
args.update(csrf(request))
args['form'] = form
args['series_id'] = series_id
return render_to_response('create_review.html', args)
def add_review(request, id):
product = get_object_or_404(models.Product, pk=id)
form = ReviewForm(request.POST)
if form.is_valid():
review_text = form.cleaned_data['review_text']
review = form.save(commit=False)
review.review_text = review_text
review.user = request.user
review.product = product
review.date_published = timezone.now()
review.save()
return HttpResponseRedirect(reverse('details', args=(product.id,)))
else:
form = ReviewForm()
return render(request, 'store/product-details.html', {'product': product, 'form': form})
return render(request, 'store/')
def add_review(request, id):
product = get_object_or_404(models.Product, pk=id)
form = ReviewForm(request.POST)
if form.is_valid():
review_text = form.cleaned_data['review_text']
review = form.save(commit=False)
review.review_text = review_text
review.user = request.user
review.product = product
review.date_published = timezone.now()
review.save()
return HttpResponseRedirect(reverse('details', args=(product.id, )))
else:
form = ReviewForm()
return render(request, 'store/product-details.html', {
'product': product,
'form': form
})
return render(request, 'store/')
def review(request):
import ep2Site.models
plugin = ep2Site.plugins.reviewType.get_plugin(plugin)
if request.method == 'POST':
form = ReviewForm(request.POST)
if form.is_valid():
review = form.save(commit=False)
review.plugin = plugin.get_model()
review.save()
return HttpResponseRedirect(review.get_absolute_url())
else:
return "[ERROR] from views: {0}".format(form.errors)
else:
form = ep2Site.forms.ReviewForm()
return render_to_response('ep2Site/review.html',
{'form': form}, context_instance=RequestContext(request))
def product_review(request):
id = request.GET.get('id')
next = request.GET.get('next')
product = get_object_or_404(Product.active, id=id)
user = request.user
if request.POST:
form = ReviewForm(request.POST)
if form.is_valid():
score = form.cleaned_data['score']
review = form.cleaned_data['review']
if not ProductReview.objects.filter(user=user, product=product).exists():
productreview = ProductReview.objects.create(user=user, product=product, score=score, review=review)
else:
print('gafgafg')
print request.GET
print request.POST
return HttpResponseRedirect(next)
def book_details(request, book_id):
book = Book.objects.get(pk=book_id)
context = {
'book': book,
}
if request.user.is_authenticated():
if request.method == "POST":
form = ReviewForm(request.POST)
if form.is_valid():
new_review = Review.objects.create(
user=request.user,
book=context['book'],
text=form.cleaned_data.get('text'))
new_review.save()
else:
if Review.objects.filter(user=request.user,
book=context['book']).count() == 0:
form = ReviewForm()
context['form'] = form
context['reviews'] = book.review_set.all()
return render(request, 'store/detail.html', context)
def add_review(request,movie_id):
rm=Movie.objects.get(id=movie_id)
if request.method == "POST":
f=ReviewForm(request.POST)
if f.is_valid():
r=f.save(commit=False)
r.user=request.session['user']
r.post_date = timezone.now()
r.movie =rm
r.save()
return HttpResponseRedirect('/movies/get/%s' % movie_id)
else:
f=ReviewForm()
args={}
args.update(csrf(request))
args['movie']=rm
args['form']=f;
if 'user' in request.session:
args['result']=request.session['user']
return render_to_response('add_review.html',args)
def add_review(request, movie_id):
rm = Movie.objects.get(id=movie_id)
if request.method == "POST":
f = ReviewForm(request.POST)
if f.is_valid():
r = f.save(commit=False)
r.user = request.session['user']
r.post_date = timezone.now()
r.movie = rm
r.save()
return HttpResponseRedirect('/movies/get/%s' % movie_id)
else:
f = ReviewForm()
args = {}
args.update(csrf(request))
args['movie'] = rm
args['form'] = f
if 'user' in request.session:
args['result'] = request.session['user']
return render_to_response('add_review.html', args)
def test_can_create_an_review_with_rating_and_comment(self):
form = ReviewForm({'rating': 5, 'comment': 'a comment'})
self.assertTrue(form.is_valid())
