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 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 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 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 review():
form = ReviewForm()
conversation_id = request.form.get('conversation_id')
if request.method == 'POST' and form.validate_on_submit():
rating = request.form.get('rate')
rq = Request.query. \
filter(Request.id == form.request_id.data).first()
# reviewed_user_id = rq.user_id if rq.user_id == current_user.id \
# else rq.from_user_id
reviewed_user_id = rq.from_user_id
new_review = Review(
user_id=current_user.id,
reviewed_user_id=reviewed_user_id,
request_id=rq.id,
comment=form.comment.data,
rating=rating
)
db.session.add(new_review)
db.session.commit()
flash(u"Yorumunuz eklendi :)")
return redirect('/show_stuff/%s' % rq.stuff_id)
flash(u"Mesaj alanını boş bıraktınız.")
return redirect('/conversation/%s' % conversation_id)
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 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 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 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 reviewDetails():
reviews = Reviews.query.all()
form = ReviewForm(request.form)
if request.method == 'POST':
if form.validate():
if form.id.data == '':
r = Reviews(form.doctorID.data, form.description.data, form.username.data)
db_session.add(r)
db_session.commit()
else:
r = Reviews.query.get(int(form.id.data))
r.doctorID = form.doctorID.data
r.description = form.description.data
r.username = form.username.data
db_session.commit()
reviews = Reviews.query.all()
return render_template('review.html', reviews=reviews)
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 add_review():
'''
Function to display a page which displays a form to
add a review for logged in user
'''
if 'logged' not in session:
# if a user trys to go to add review without been logged in
flash('You need to log in to add a review', 'warning')
return redirect(url_for('login')) # sending to log in
form = ReviewForm()
if form.validate_on_submit():
# if form submits successfully
reviews = mongo.db.reviews
# creating amazon link
amazon_link = create_amazon_search(request.form['book_title'])
icon = get_icon_class(request.form['category'])
# creating icon font awesome class
# add form content to db as a new record
reviews.insert_one({
'author': request.form['author'],
'book_title': request.form['book_title'],
'summary': request.form['summary'],
'review': request.form['review'],
'category': request.form['category'],
'amazon': amazon_link,
'icon': icon,
'upvote': 0,
'username': session['username'],
})
flash('Review added ', 'success')
# send to my reviews template on successful add
return redirect(url_for('my_reviews'))
return render_template('addreview.html', form=form,
title='Add Review')
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 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 review(affiliate_id=None):
form = ReviewForm()
a = models.Affiliate.query.get(affiliate_id)
if form.validate_on_submit():
try:
r = models.Review(affiliate_id=a.id, ipaddress=request.remote_addr, rating_overall=form.rating.data, rating_equipment=form.rating_equipment.data, rating_instructor=form.rating_instructor.data, comment=form.comment.data, review_date=datetime.datetime.utcnow())
db.session.add(r)
db.session.commit()
flash("Review for %s has been posted!" % a.name, 'success')
return redirect('/')
except:
db.session.rollback()
flash('You only can post one review!', 'error')
else:
if request.method == "POST":
flash('Please make sure all fields are filled out correctly.', 'error')
return render_template('review.html',
affiliate_info = a,
form = form)
def review():
if 'student_id' in session:
form = ReviewForm()
del form.delete
id = session['student_id']
if form.validate_on_submit():
if form.post.data:
review = Reviews(student_id=id,
title=form.title.data,
message=form.message.data)
db.session.add(review)
db.session.commit()
flash('Thanks for your review!', 'success')
return redirect(url_for('home'))
else:
return render_template('review.html',
form=form,
program=Student.query.get(id).program)
flash('You must be logged first!', 'danger')
return redirect(url_for('home'))
def add_review(subject):
form = ReviewForm()
subject_title = get_title(subject)[0]
if request.method == 'GET':
return render_template('add_review.html',
form=form,
subject=subject,
subject_title=subject_title)
elif request.method == 'POST':
insert_review(None, subject, form.reviewer.data, form.review.data,
form.rating.data)
return redirect(url_for('review', subject=subject))
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 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_feedback(username):
if "user_id" not in session:
return redirect("/login")
else:
form = ReviewForm()
if form.validate_on_submit():
title = form.title.data
content = form.content.data
review = Review(title=title,
content=content,
user_id=session["user_id"])
db.session.add(review)
db.session.commit()
return redirect(f"/feedback/{review.id}")
else:
return render_template("feedback-form.html", form=form)
def review(book_id):
rating = request.form.get("rating")
review = request.form.get("text")
book = db.execute("SELECT * FROM books WHERE id = :book_id", {
"book_id": book_id
}).fetchone()
if db.execute(
"SELECT * FROM reviews WHERE user_id = :user_id AND book_id = :book_id",
{
"user_id": session['user_id'],
"book_id": book_id
}).rowcount != 0:
flash("Only one review allowed")
book = db.execute("SELECT * FROM books WHERE id = :book_id", {
"book_id": book_id
}).fetchone()
form = ReviewForm()
user_review = db.execute(
"SELECT * FROM reviews WHERE user_id = :user_id AND book_id = :book_id",
{
"user_id": session['user_id'],
"book_id": book.id
}).fetchone()
user_review = user_review.review
goodreadsData = requests.get(
"https://www.goodreads.com/book/review_counts.json",
params={
"isbns": book.isbn_id,
"key": "VzAR63bf45MBzRSC1o1A"
})
if goodreadsData.status_code != 200:
raise Exception("ERROR: API REQUEST UNSUCCESSFUL, {}".format(
res.status_code))
return render_template("book.html",
book=book,
form=form,
data=goodreadsData,
user_review=user_review)
else:
db.execute(
"INSERT INTO reviews (user_id, book_id, rating, review) VALUES (:user_id, :book_id, :rating, :review)",
{
"user_id": session['user_id'],
"book_id": book_id,
"rating": rating,
"review": review
})
db.commit()
flash("Review Submitted!")
return redirect(url_for("book", isbn_id=book.isbn_id))
def add(week_id):
"""Add a daily review task."""
f = ReviewForm()
# print(f.data)
if f.validate_on_submit():
review_dt = datetime.combine(f.date.data, time.min)
rev = Review.query.filter_by(review_day=review_dt).first()
if rev is None:
rev = Review()
rev.week_id = week_id
rev.review_day = f.date.data
db.session.add(rev)
db.session.commit()
rev.planning = f.planning.data if f.planning.data else rev.planning
rev.dev = f.dev.data if f.dev.data else rev.dev
rev.tickets = f.tickets.data if f.tickets.data else rev.tickets
rev.cleanup = f.cleanup.data if f.cleanup.data else rev.cleanup
rev.review = f.review.data if f.review.data else rev.review
rev.goals = f.goals.data if f.goals.data else rev.goals
db.session.commit()
# else:
# print('validation failed')
return redirect(url_for('worksheet.worksheet', week_id=week_id))
def update_feedback(review_id):
if "user_id" not in session:
return redirect("/login")
else:
review = Review.query.get_or_404(review_id)
if review.user_id == session["user_id"]:
form = ReviewForm(obj=review)
if form.validate_on_submit():
review.title = form.title.data
review.content = form.content.data
db.session.commit()
return redirect(f"/feedback/{review.id}")
else:
return render_template("feedback-form.html", form=form)
return redirect("/")
def create_review(request, template="create_project.html"):
project_id = request.GET.get("project_id")
print "create application review for project:{}".format(project_id)
project = None
if project_id is not None:
project = get_object_or_404(Project, pk=project_id)
if request.method == "POST":
# Must pass request.FILES to ModelForm so it can handle file upload
form = ReviewForm(request.POST, request.FILES, initial={"project": project})
new_review = form.save()
print new_review
if project_id is None:
project_id = new_review.project.id
event = {"time": datetime.now(), "project_id": int(project_id), "message": _("Create ApplicationReview")}
create_log(event)
return redirect("enterprise.reviews")
else:
form = ReviewForm(initial={"project": project})
context = {"form": form, "title": _("Create ApplicationReview")}
return render(request, template, context)
def displayArticle(filename):
if 'logged_in' not in session:
flash("You Have To Login First To Access This Page..!!")
return redirect(url_for('login'))
details, article, status, comment = viewArticle(filename)
if status == True:
return render_template('view.html',
form=ReviewForm(),
form1=CommentForm(),
details=details,
article=article,
comment=comment)
flash(status)
return redirect(url_for('home'))
def index():
form = ReviewForm()
print(request.method)
if request.method == 'POST':
if form.validate_on_submit():
form_data_list = [form.username.data, form.product_name.data, form.product_review.data]
print(f'User name {form.username.data}')
print(f'Product Name {form.product_name.data}')
print(f'Product Review {form.product_review.data}')
with open('static/data/reviews.csv', 'a+', newline='') as write_obj:
csv_writer = csv.writer(write_obj)
csv_writer.writerow(form_data_list)
form.username.data = ''
form.product_name.data = ''
form.product_review.data = ''
print(f'submitted successfully')
print('hi')
# flash('Review Posted Successfully!', category='info')
return redirect('/')
with open('static/data/reviews.csv') as csv_file:
data = csv.reader(csv_file, delimiter=',')
first_line = True
reviews = []
for row in data:
if first_line:
first_line = False
else:
reviews.append(dict(username=row[0], product_name=row[1], product_review=row[2]))
return render_template('index.html', form=form, reviews=reviews)
def booksearch(isbn):
book = db.execute("SELECT * FROM books WHERE isbn = :isbn",{"isbn":isbn}).first()
review = db.execute("SELECT * FROM reviews WHERE booksisbn = :isbn",{"isbn":isbn}).fetchall()
form = ReviewForm()
if book == None :
flash("Book Does Not Exist")
return redirect(url_for('search'))
if request.method == "POST":
# Check if user is logged in, else return error
if session.get('user_id') != None :
user = db.execute("SELECT * FROM member \
WHERE username = :username"
,{"username": session['user_id'] }).first()
check = db.execute('SELECT * FROM reviews WHERE \
memberusername = :username AND \
booksisbn = :isbn',{'username': user.username, 'isbn':isbn}).first()
if check != None:
flash('You have already submmited a review')
return redirect("/search/" + isbn)
db.execute("INSERT INTO reviews (review, memberid, booksisbn, memberusername, ratings)\
VALUES (:review, :memberid, :booksisbn, :memberusername, :ratings)",
{"review": form.review.data, "memberid": user.id,
"booksisbn": isbn, "memberusername": user.username, "ratings":form.ratings.data })
db.commit()
flash("Review Successfully Posted")
return redirect("/search/" + isbn)
else:
flash("Please Login To Leave a Review")
return redirect("/search/" + isbn)
# get session username, find the username object in db
# add review to database with ISBN & User ID
# Db commit
key = os.getenv("GOODREADS_KEY")
query = requests.get("https://www.goodreads.com/book/review_counts.json",
params={"key": key, "isbns": isbn})
response = query.json()
response = response['books'][0]
return render_template('results.html', book=book, response=response, form=form, review=review)
def make_review():
form = ReviewForm()
form.name.choices = []
for row in fetch_available_items('beer_choices', 'products'):
stock = str(row[0])
form.name.choices += [(stock, stock)]
if request.method == "POST" and form.validate():
username = form.username.data
name = form.name.data
score = form.score.data
post = form.post.data
c, conn = connection()
c.execute("SELECT id FROM users where username LIKE %s",
[thwart(username)])
current_id = c.fetchone()
c.execute("SELECT id FROM beer where name LIKE %s", [thwart(name)])
current_beer = c.fetchone()
c.execute("SELECT CURDATE()")
current_date = c.fetchone()
# print current_id
# print current_beer
c.execute(
"""INSERT INTO Review (user_id, beer_id, userName, score, body, date) VALUES (%s, %s, %s, %s, %s, %s)""",
(current_id, current_beer, thwart(username), thwart(
str(score)), thwart(post), current_date))
conn.commit()
flash("Thanks for submitting your review!")
c.close()
conn.close()
gc.collect()
return redirect(url_for("homepage"))
return render_template("make_review.html", form=form)
def create_movie_review(movie_id):
"""Show a form for a user to create a review for a movie, and add the review to reviews table."""
if not g.user:
flash("You must be signed in to leave a review")
return redirect("/")
movie = get_results(requests.get(f"{api_base}movie/{movie_id}{api_key}"))
if is_movie(movie) == False:
flash("We couldn't find that movie.")
return redirect("/")
in_movies(movie)
form = ReviewForm()
if form.validate_on_submit():
review = Review(title=form.title.data,
body=form.body.data,
rating=form.rating.data,
username=g.user.username,
movie_id=movie_id)
db.session.add(review)
db.session.commit()
return redirect(f"/movie/{movie_id}")
return render_template("movies/review.html", movie=movie, form=form)
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 review(movie_id):
form = ReviewForm()
if session.get('user'):
# Get current user for review info
user = session["user"].capitalize()
# Connection to the movie database
movie = tmdb.Movies(movie_id)
response = movie.info()
# Create veriables for title, overview and post path.
movie_title = movie.title
movie_id = movie.id
movie_overview = movie.overview
poster_path = movie.poster_path
# Information about movies that will be
reviews = list(
mongo.db.reviews.find({}, {
'movie_id': 1,
'movie_title': 1,
'username': 1,
'review_text': 1,
'_id': 1
}))
# Review information to send to the database
review_info = {
"movie_id": movie_id,
"movie_title": movie.title,
"username": user,
"review_text": request.form.get("review")
}
if form.review.data and request.method == 'POST':
mongo.db.reviews.insert_one(review_info)
flash("Successfully posted your review", "success")
return redirect(url_for("movies.review", movie_id=movie_id))
return render_template('review.html',
form=form,
reviews=reviews,
movie_id=movie_id,
movie_title=movie_title,
movie_overview=movie_overview,
poster_path=poster_path,
user=user)
else:
flash("You need to login in order to view reviews", "error")
return redirect(url_for("auth.login"))
def project_detail(request,projectId):
context = RequestContext(request)
user = request.user
project = Project.objects.get(id=projectId)
list_of_review = Review.objects.filter(project = project, status = 'completed', dropped = False)
review = find_user_review_for_project(user,project)
questions = project.rfp.get_review_questions()
if review:
review_data = ReviewForm(data=model_to_dict(review),questions=questions)
else:
review_data= {}
project_data = ProjectForm(data=model_to_dict(project), questions = project.rfp.get_project_questions())
prop_rev_list = ProposedReviewer.objects.filter(project = project, type='USER_PROPOSED')
refused_rev_list = ProposedReviewer.objects.filter(project = project, type='USER_EXCLUDED')
budget_line_list = BudgetLine.objects.filter(project = project)
hr_budget_line_list = BudgetLine.objects.filter(project = project,category = 'HR')
oc_budget_line_list = BudgetLine.objects.filter(project = project,category = 'OC')
eq_budget_line_list = BudgetLine.objects.filter(project = project,category = 'EQ')
is_p = is_pi(user)
is_rev = is_reviewer(user)
oc_total = budget_line_sum(oc_budget_line_list)
hr_total = budget_line_sum(hr_budget_line_list)
eq_total = budget_line_sum(eq_budget_line_list)
total = oc_total + hr_total + eq_total
current_url = reverse('project_budget', args = [project.pk])
project.list_of_reviewers_id()
user_is_owner(user,project)
store_redirect_url(request)
context_dict={'project' : project,'user' : user,
'project_data' : project_data,'is_pi': is_p, 'bl' : budget_line_list,
'is_rev' : is_rev,'review_data' : review_data,
'prop_rev_list' : prop_rev_list,'excluded_rev_list' : refused_rev_list,
'current_url':current_url,
'review' : review,
'hr_budget_lines_list' : hr_budget_line_list, 'oc_budget_lines_list' : oc_budget_line_list,
'eq_budget_lines_list' : eq_budget_line_list,
'oc_total' : oc_total, 'hr_total' : hr_total, 'eq_total' : eq_total, 'total' : total, 'list_of_review' : list_of_review}
return render_to_response('rfp/project_details.html',context_dict,context)
def display_movies():
"""
Get all movies from the database in order to display them in the template.
"""
form = ReviewForm()
# Workaround to pop movie results from session on page reload
if session.get('results') is not None:
session.pop('results', None)
display_movies = mongo.db.movies.find({}, {
'movie_id': 1,
'movie_title': 1,
'movie_overview': 1,
'poster_path': 1,
'_id': 0
})
return render_template('movies.html',
display_movies=list(display_movies),
form=form)
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 project_review(request,projectId):
context = RequestContext(request)
user = request.user
project=Project.objects.get(id=projectId)
review = Review.objects.get(project=projectId,user=user.pk)
questions = project.rfp.get_review_questions()
review_data = ReviewForm(data=model_to_dict(review),questions=questions)
is_p = is_pi(user)
is_rev = is_reviewer(user)
user_is_owner(user,review)
store_redirect_url(request)
context_dict={'project' : project,'user' : user,'review_data' : review_data,
'is_pi': is_p,'is_rev' : is_rev,'review':review}
return render_to_response('rfp/project_review.html',context_dict,context)
def book(isbn):
form = ReviewForm(request.form)
# Because an isbn check has already been performed in profile, no check is required
query = sql_db.execute("Select * From books WHERE isbn = :isbn", {"isbn":isbn}).fetchall()
# Grabs GoodReads review information using their API, gotBookInfo() is in services.py
gr_data = getBookInfo(isbn, query)
userReview = sql_db.execute("SELECT * FROM reviews WHERE username = :username AND isbn = :isbn", {"username": session['username'], "isbn":isbn}).fetchall()
allReviews = sql_db.execute("SELECT * FROM reviews WHERE isbn = :isbn", {"isbn":isbn}).fetchall()
username = session['username']
title = query[0][2]
author = query[0][3]
published = query[0][4]
userscore = 0
user_review = ''
if len(userReview) > 0:
userscore = userReview[0][1]
user_review = userReview[0][2]
else:
if request.method == 'POST':
userscore = form.score.data
user_review = form.review.data
sql_db.execute("INSERT INTO reviews (score, review, username, isbn) VALUES(:score, :review, :username, :isbn)", {"score": str(userscore), "review": user_review, "username": username, "isbn": isbn})
sql_db.commit()
# used for testing purposes only
# print(isbn, username, userscore, user_review);
return render_template('book.html', username = username,
isbn = isbn,
title = title,
author = author,
published = published,
userscore = userscore,
user_review = user_review,
gr_data = gr_data,
allReviews=allReviews,
userReview=userReview)
def create(movie_id):
"""
Let the users create reviews from the search results
"""
form = ReviewForm()
# Connection to the movie database
movie = tmdb.Movies(movie_id)
response = movie.info()
# Create veriables for title, overview and post path.
movie_title = movie.title
movie_id = movie.id
movie_overview = movie.overview
poster_path = movie.poster_path
# Check if how many times the movie id exists in the database
existing_movie = mongo.db.movies.find({
"movie_id": movie_id
}, {
'_id': 0
}).count()
# Information about the movie to send to the database
movie_info = {
"movie_id": movie_id,
"movie_title": movie_title,
"movie_overview": movie_overview,
"poster_path": poster_path
}
if form.create.data and request.method == 'POST':
# If the movie id exists less than 1 one time
if existing_movie >= 1:
flash("Redirected to existing review!", "info")
# If the movie id does not exist in the database
else:
flash("Created Movie!", "success")
# Insert movie information
mongo.db.movies.insert_one(movie_info)
return render_template('review.html',
form=form,
movie_id=movie_id,
movie_title=movie_title,
movie_overview=movie_overview,
poster_path=poster_path)
def delete_review(barberid, id):
if request.args.get('neighborhood') == None:
neighborhood_code = "ga"
else:
neighborhood_code = request.args.get('neighborhood')
neighborhood = neighborhoods_by_key.get(
neighborhood_code) # tab this over if necessary
review_param = int(id)
barber_param = int(barberid)
review = models.Review.get_or_none(review_param)
if str(review.user_id) == str(current_user.id):
review.delete_instance()
form = ReviewForm()
barber = models.Barber.get(models.Barber.id == barber_param)
reviews = barber.reviews
flash('you deleted your review')
return redirect(url_for('barbers', id=barber_param))
else:
flash('you cannot delete a review that is not yours')
return redirect(
url_for('barbers', id=barber_param, neighborhood=neighborhood))
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 stream(username=None):
form = ReviewForm()
form2 = EditReviewForm()
form4 = EditProfileForm()
formData = form2.idNumber.data
user = models.User.select().where(
models.User.username == current_user.username).get()
stream = user.stream.limit(100)
stream2 = user.swipe.limit(100)
if form2.validate_on_submit():
if form2.idNumber.data == None:
print("SAAAAAAAAAD")
else:
intFormData = int(formData)
print(intFormData)
if Review.id == intFormData and 0 < form.rating.data < 6:
plant = Review.get(Review.id == (intFormData))
plant.text = form2.text.data
plant.rating = form2.rating.data
plant.plant = form2.plant.data
plant.save()
else:
flash(
"Could not edit review, please ensure you have filled out all the fields correctly"
)
return render_template('stream.html',
stream=stream,
stream2=stream2,
form=form,
form2=form2,
form4=form4,
username=username,
user=user)
def book(isbn):
form = ReviewForm(csrf_enabled=False)
if request.method == "POST":
review = {
"rating": form.rating.data,
"review": form.review.data,
"user_id": session["id"],
"book_id": form.book_id.data
}
add = add_review(db, review)
if add == True:
flash("your review has been added...")
return redirect(url_for("book", isbn=isbn))
elif add == False:
flash("Database Error..!, please Email: [email protected]")
return redirect(url_for("book", isbn=isbn))
else:
flash(add)
return redirect(url_for("book", isbn=isbn))
if request.method == "GET":
book = find_book(db, isbn)
if book:
reviews = get_reviews(db, book.id)
try:
url = f'https://www.goodreads.com/book/review_counts.json?key=fWW2DdoQzw82qH5DEIe4CQ&isbns={book.isbn}'
h = httplib2.Http()
result = h.request(url, 'GET')[1]
result = json.loads(result)['books'][0]
print(result)
goodreads = result
except:
goodreads = None
return render_template("book.html",
book=book,
reviews=reviews,
goodreads=goodreads,
form=form)
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, 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 sub():
form = ReviewForm()
if form.validate_on_submit():
flash('Review Submitted Successfully')
return render_template('home.html', form=form)
def show_conversation(conversation_id):
conversation = Conversation.query.\
filter(Conversation.id == conversation_id).first()
if current_user not in conversation.users:
redirect('/my_messages')
form = ConversationForm()
if request.method == 'POST' and form.validate_on_submit():
if current_user.id == conversation.request.user.id:
to_user = conversation.request.from_user
else:
to_user = conversation.request.user
print to_user.id
new_message = Message(
from_user=current_user,
to_user=to_user,
conversation=conversation,
txt=form.message.data
)
db.session.add(new_message)
db.session.commit()
msg_body = render_template('email/conversation.txt', user=to_user, from_user=current_user.name,
stuff_title=conversation.title, conversation=new_message)
html_msg = render_template('email/conversation.html', user=to_user, from_user=current_user.name,
stuff_title=conversation.title, conversation=new_message)
# msg_body = u'%s sana mesaj gönderdi. <br><br> esyakutuphanesi.com'\
# % current_user.name
# html_msg = u'%s sana mesaj gönderdi. <br><br> Mesajı okumak için' \
# u' <a href="http://esyakutuphanesi.com/conversation/{{conversation_id}}">tıkla!</a>' \
# % current_user.name
msg_subject = u"Mesajın var"
msg = MailMessage(
body=msg_body,
html=html_msg,
subject=msg_subject,
sender=(u"Eşya Kütüphanesi", "*****@*****.**"),
recipients=[to_user.email]
)
mail.send(msg)
Message.query.filter(
Message.conversation_id == conversation_id,
Message.status == 0,
Message.to_user == current_user
).update({Message.status: 1})
db.session.commit()
form.message.data = None
review_form = ReviewForm()
if request.args.get('status'):
status = int(request.args.get('status'))
else:
status = 0
if status > 0 and \
(conversation.request.stuff.owner == current_user or conversation.request.from_user_id == current_user.id):
if conversation.request.stuff.status == 1:
if status == 1 and conversation.request.status == 0:
flash(u'Eşyayı vermeyi kabul ettiniz.')
conversation.request.stuff.status = 0
conversation.request.status = 1
conversation.request.given_at = datetime.utcnow()
db.session.commit()
elif status == 2 and conversation.request.status == 1:
flash(u'Eşyayı geri aldınız.')
conversation.request.stuff.status = 1
conversation.request.status = 2
conversation.request.returned_at = datetime.utcnow()
db.session.commit()
else:
flash(u'Eşya zaten başkasına verilmiş.')
wanted_stuff = StuffPhoto.query.filter(StuffPhoto.stuff_id == conversation.request.stuff_id).first()
review_form.request_id.data = conversation.request_id
return render_template(
"conversation.html",
user=current_user,
wanted_stuff=wanted_stuff,
form=form,
action='Edit',
conversation=conversation,
review_form=review_form
)
def movie(imdb_id):
#Uses Review Form object from forms.py
form = ReviewForm()
#Update DB when new form is submitted
if form.validate_on_submit():
db.execute(
"INSERT INTO reviews (userid, imdbid, rating, content) VALUES (:un, :ii, :ra, :co);",
{
"un": session['current_user'],
"ii": imdb_id,
"ra": form.select.data,
"co": form.content.data
})
db.commit()
return (redirect(url_for('movie', imdb_id=imdb_id)))
# Ensure that movie exists
movie = db.execute("SELECT * FROM movies WHERE imdbid = :id", {
'id': imdb_id
}).fetchone()
if movie == None:
abort(404)
else:
#Retrieve additional data from omdb
imdb_id = movie[3]
attrlist = [
"Title", "Year", "Rated", "Released", "Runtime", "Genre",
"Director", "Writer", "Actors", "Plot", "Language", "Country",
"Awards", "Poster", "Metascore", "imdbRating", "imdbVotes",
"imdbID", "Type", "DVD", "BoxOffice", "Production", "Website",
"Response"
]
omdbResults = omdb.request(i=imdb_id)
omdbData = omdbResults.json()
temp = {}
for attr in attrlist:
temp[attr] = omdbData[attr]
# Get all reviews
revu = db.execute("SELECT * FROM reviews WHERE imdbid = :imdbid", {
"imdbid": imdb_id
}).fetchall()
attrlist2 = ["Author", "MovieID", "Rating", "ReviewContent"]
reviews = []
temp2 = {}
#Check if user has submitted a review
userRev = False
for i in range(len(revu)):
temp2 = {}
for j in range(len(revu[i])):
temp2[attrlist2[j]] = revu[i][j]
reviews.append(temp2)
if temp2['Author'] == session['current_user']:
userRev = True
#Sets reviews to blank list, not None
if revu == None:
reviews = []
#Get average score from Metascore & imdbRating
try:
avgR = (float(temp['Metascore']) +
float(temp['imdbRating']) * 10) / 2
except:
try:
avgR = temp['imdbRating']
except:
avgR = temp['Metascore']
return render_template("movie.html",
movie=temp,
reviews=reviews,
avgR=avgR,
form=form,
userRev=userRev)