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, template="reviews/post_review.html"):
"""
View used to post a new review
"""
if request.method == 'POST':
form = ReviewForm(request.POST)
# get values
s = request.GET.get('s', '')
t = request.POST['title']
c = request.POST['content']
r = request.POST['rating']
# get product
item = get_object_or_404(Product, slug=s)
# new review
rev = Review(title=t,
content=c,
product=item,
sender=request.user,
slug=slugify(t))
rev.save()
# add rating for the product
item.votes = item.votes + 1
item.total_rating = item.total_rating + int(r)
item.save()
# done!
return HttpResponseRedirect("/")
else:
form = ReviewForm()
return render_to_response(template, {'form': form},
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 render_scheduled_page():
if not current_user.is_authenticated:
return redirect("/login")
outstanding_ride_id = get_outstanding_payment_ride_id(
current_user.username)
if outstanding_ride_id:
return redirect("/payment/{}".format(int(outstanding_ride_id[0])))
# Review ----------------------------------------
passenger_review_form = ReviewForm()
driver_review_form = ReviewForm()
if request.method == "POST":
if request.form['hidden_type'] == 'passenger':
ride_id = passenger_review_form.hidden_rid.data
rating = passenger_review_form.rating.data
comment = passenger_review_form.comment.data
insert_passenger_review_query = "UPDATE Ride SET d_rating = '{}', d_comment = '{}' WHERE ride_id = '{}'".format(
rating, comment, ride_id)
db.session.execute(insert_passenger_review_query)
db.session.commit()
elif request.form['hidden_type'] == 'driver':
ride_id = driver_review_form.hidden_rid.data
rating = driver_review_form.rating.data
comment = driver_review_form.comment.data
insert_driver_review_form = "UPDATE Ride SET p_rating = '{}', p_comment = '{}' WHERE ride_id = '{}'".format(
rating, comment, ride_id)
db.session.execute(insert_driver_review_form)
db.session.commit()
# Review ----------------------------------------
upcoming_rides_query = "SELECT r.ride_id, r.time_posted, a.departure_time, a.from_place, a.to_place, " \
"r.driver_id, o.plate_number, a_u.phone_number, r.status, r.is_paid, r.d_rating FROM Ride r" \
" INNER JOIN " \
"Advertisement a " \
"ON r.time_posted = a.time_posted and r.driver_id = a.driver_id" \
" INNER JOIN " \
"Owns o " \
"ON r.driver_id = o.driver_id " \
" INNER JOIN " \
"app_user a_u " \
"ON r.driver_id = a_u.username " \
"WHERE r.passenger_id = '{}'".format(current_user.username)
upcoming_rides = db.session.execute(upcoming_rides_query).fetchall()
return render_template("scheduled.html",
current_user=current_user,
upcoming_rides=upcoming_rides,
upcoming_pickups=getUpcomingPickups(
current_user.username),
is_driver=isDriver(current_user.username),
passenger_review_form=passenger_review_form,
driver_review_form=driver_review_form)
def book(isbn_id):
form = ReviewForm()
book = db.execute("SELECT * FROM books WHERE isbn_id = :isbn_id", {
"isbn_id": isbn_id
}).fetchone()
goodreadsData = requests.get(
"https://www.goodreads.com/book/review_counts.json",
params={
"isbns": isbn_id,
"key": "VzAR63bf45MBzRSC1o1A"
})
if goodreadsData.status_code != 200:
raise Exception("ERROR: API REQUEST UNSUCCESSFUL, {}".format(
res.status_code))
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()
if user_review is not None:
user_review = user_review.review
return render_template("book.html",
book=book,
form=form,
data=goodreadsData,
user_review=user_review)
def review_edit_page(review_id):
searchform = SearchForm()
db = current_app.config["db"]
review = db.get_review(review_id)
if review is None:
abort(404)
if not current_user.id == review.author:
abort(401)
form = ReviewForm()
if form.validate_on_submit():
score = form.data["score"]
comment = form.data["comment"]
author = review.author
book_id = review.book
review_id = review.id
review_ = Review(score=score,
comment=comment,
author=author,
book=book_id,
id=review_id)
db.update_review(review_)
flash("Review updated successfully.")
return redirect(url_for("book_page", book_id=book_id))
form.score.data = str(review.score)
form.comment.data = review.comment
return render_template("review_edit.html",
form=form,
searchform=searchform)
def add_review():
"""
Add review functionality
"""
form = ReviewForm()
if form.validate_on_submit():
# Assign all parts of the form to variables and add review to mongoDB
review = {
"material_name": form.material_name.data,
"brand": form.brand.data,
"filament_name": form.filament_name.data,
"author": session["user"],
"rating": int(form.rating.data),
"temperature": form.temp.data,
"finish": form.finish.data,
"colour": form.colour.data,
"review_text": form.review.data,
"image_url": form.image.data,
"cost": int(form.cost.data),
"likes": 0
}
mongo.db.reviews.insert_one(review)
flash("Thanks for your review!")
return redirect(url_for("add_review"))
return render_template("add_review.html", 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 worksheet(week_id=None):
"""Main route of the one-page site."""
week = ''
week_list = Week.query.all()
interruption = ''
goals = ''
tasks = ''
review = ''
task_form = TaskForm()
goal_form = GoalForm()
interruption_form = InterruptionForm()
review_form = ReviewForm()
if week_id:
interruption = Interruption.query.filter_by(week_id=week_id).all()
goals = Goal.query.filter_by(week_id=week_id).all()
tasks = Tasks.query.filter_by(week_id=week_id).all()
review = Review.query.filter_by(week_id=week_id).all()
week = Week.query.get(week_id)
return render_template('base.html',
week=week,
week_list=week_list,
interruptions=interruption,
interruption_form=interruption_form,
goals=goals,
goal_form=goal_form,
tasks=tasks,
task_form=task_form,
review=review,
review_form=review_form)
def handle_review_page(beer_id):
"""Page with form to fill out review of beer and submit"""
if CURR_USER_KEY in session:
form = ReviewForm()
response = requests.get(f"{API_BASE_URL}/beers",
params={
'key': API_KEY,
'ids': beer_id
})
beer = response.json()["data"][0]
user_id = session[CURR_USER_KEY]
if form.validate_on_submit():
new_review = Review(beer_name=beer["name"],
user_id=user_id,
beer_id=beer_id,
rating=form.rating.data,
text=form.text.data)
db.session.add(new_review)
db.session.commit()
flash("Review submitted!", "success")
return redirect(f"/user/{user_id}/reviews")
else:
return render_template("beer/review.html", form=form, beer=beer)
else:
flash("Please Log-In First", "danger")
return redirect("/")
def edit_review(review_id):
"""Returns and processess form to edit a review"""
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
review=Review.query.get(review_id)
form=ReviewForm(obj=review)
drink_name=review.drink.name
if form.image.data:
display_img=form.image.data
else:
display_img="https://banner2.cleanpng.com/20190714/uvh/kisspng-martini-cocktail-glass-clip-art-vector-graphics-home-forty-two-peterborough-5d2b093a9f6130.8579484215631014986528.jpg"
if form.validate_on_submit():
review.rating=round(float(form.rating.data),2)
review.review=form.review.data
review.image=display_img
db.session.commit()
flash("Your changes have been saved", 'success')
return redirect("/")
return render_template("edit_review.html", form=form, drink=drink_name)
def review_for(saved_drink_id):
"""Returns and processes form to make a review for a drink"""
if not g.user:
flash("Access unauthorized.", "danger")
return redirect("/")
form = ReviewForm()
saved_drink=Saved_recipe.query.get(saved_drink_id)
if form.validate_on_submit():
if form.image.data:
display_img=form.image.data
else:
display_img="https://banner2.cleanpng.com/20190714/uvh/kisspng-martini-cocktail-glass-clip-art-vector-graphics-home-forty-two-peterborough-5d2b093a9f6130.8579484215631014986528.jpg"
review = Review(
drink_id= saved_drink.drink.id,
rating=round(float(form.rating.data),2),
review=form.review.data,
image=display_img,
user_id=g.user.id
)
db.session.add(review)
db.session.commit()
return redirect("/")
return render_template("single_review.html", saved_drink=saved_drink, form=form)
def book_page(book_id):
searchform = SearchForm()
db = current_app.config["db"]
book, author_id = db.get_book(book_id)
reviews, users = db.get_reviews(book_id)
if book is None:
abort(404)
form = ReviewForm()
if form.validate_on_submit():
score = form.data["score"]
comment = form.data["comment"]
author = db.get_user_id(current_user.username)
review = Review(author=author,
book=book_id,
score=score,
comment=comment)
review_id = db.add_review(review)
review.id = review_id
return redirect(url_for("book_page", book_id=book_id))
return render_template("book.html",
book=book,
author_id=author_id,
form=form,
reviews=reviews,
users=users,
searchform=searchform)
def barbers(id=None):
if request.args.get('neighborhood') == 'choose':
neighborhood_code = "ga"
else:
neighborhood_code = request.args.get('neighborhood')
neighborhood = neighborhoods_by_key.get(neighborhood_code)
form = forms.PostForm()
if id == None:
barbers = models.Barber.select().limit(100)
return render_template('barbers.html',
barbers=barbers,
form=form,
neighborhood=neighborhood)
else:
barber_param = int(id)
barber = models.Barber.get(models.Barber.id == barber_param)
reviews = barber.reviews
form = ReviewForm()
if form.validate_on_submit():
models.Review.create(barber=barber_param,
user_id=g.user._get_current_object(),
text=form.text.data.strip(),
rating=form.rating.data.strip())
flash("You created a review")
return render_template("barber.html",
barber=barber,
reviews=reviews,
form=form,
pub_key=pub_key)
def edit_review(review_id):
if 'student_id' in session:
id = session['student_id']
review = Reviews.query.get(review_id)
if review.author.username != Student.query.filter_by(
student_id=id).first().username:
abort(403)
form = ReviewForm()
if form.validate_on_submit():
if form.post.data:
review.title = form.title.data
review.message = form.message.data
db.session.commit()
flash('Review updated!', 'success')
return redirect(url_for('home'))
elif form.delete.data:
db.session.delete(review)
db.session.commit()
flash('Review deleted!', 'danger')
return redirect(url_for('home'))
else:
form.message.data = review.message
form.title.data = review.title
return render_template('review.html',
form=form,
program=review.author.program)
flash('You must be logged first!', 'danger')
return redirect(url_for('home'))
def search_movies():
"""
Search for movies in the movie database
"""
form = ReviewForm()
# Workaround to pop movie results from session on page reload
if session.get('results') is not None:
session.pop('results', None)
if form.search.data and request.method == 'POST':
# Setting user input to string
string = request.form["search"]
# Search for movie with user input from html form
movies = search.movie(query=string)
# Put movie search results in session
session['results'] = movies['results']
if movies['total_results'] == 0:
# Clear search field on submit
form.search.data = ""
# Message that movie cannot be not found
flash(f"No results found for {string}", "error")
else:
# Clear search field on submit
form.search.data = ""
# Message that results are displayed for movie
flash(f"Display results for {string}", "success")
return render_template('movies.html', form=form)
def book(bid):
# Information about the book
book = db.get_book(bid)
uid = db.get_uid(session['user'])
# Book rating and reviews
avg_rating = db.get_avg_rating(bid)
reviews = db.get_reviews(bid)
# Book rating on GoodReads
gr_rating = goodreads_rating(book['isbn'])
form = ReviewForm()
if form.validate_on_submit():
# Checks whether the user has reviewed this book
review_counter = db.get_review(bid, uid)
if review_counter == 0:
review = form.review.data
rating = int(form.rating.data)
db.add_review(uid, bid, review, rating)
else:
flash("You have already left a review")
return redirect(url_for('book', bid=bid))
return render_template('book.html',
title=book['title'],
book=book,
form=form,
reviews=reviews,
rating=avg_rating,
gr_rating=gr_rating)
def view_review(request,reviewId):
context = RequestContext(request)
user = request.user
review = Review.objects.get(pk = reviewId)
project = Project.objects.get(id = review.project.id)
questions = project.rfp.get_review_questions()
review_data = ReviewForm(data=model_to_dict(review),questions=questions)
if request.method == 'POST':
form = ReviewRankForm(request.POST)
print(request.POST)
if form.is_valid():
review.dropped = form.cleaned_data['rank']
review.save()
#n = review.user.userprofile.num_rated_review + 1
#avg = ((review.user.userprofile.rated_review_avg * review.user.userprofile.num_rated_review) + review.note)/n
#review.user.userprofile.num_rated_review = n
#review.user.userprofile.rated_review_avg = avg
#review.user.userprofile.save()
return HttpResponseRedirect(reverse('view_review', args=(reviewId,))+str('?r=')+str(review.note))
else:
form = ReviewRankForm()
context_dict={'project' : project,'review_data' : review_data, 'form':form,'review' : review}
return render_to_response('rfp/view_review.html',context_dict,context)
def show(id):
form = ReviewForm()
if "username" in session:
if request.method == "POST":
if form.validate_on_submit():
controller.add_review(id, form.reviews.data, form.rating.data)
book = controller.get_book_by_id(id)
if book:
res = requests.get(
"https://www.goodreads.com/book/review_counts.json",
params={
"key": f"{KEY}",
"isbns": f"{book.isbn}"
})
ratings = res.json()["books"][0]
return render_template('pages/book.html',
book=book,
ratings=ratings,
form=form,
reviews={
"all_reviews":
controller.get_reviews_by_id(book.id),
"current_user_submitted":
controller.is_review_submitted(book.id)
})
return render_template('pages/book.html')
return redirect(url_for("login"))
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 user(username):
if 'username' in session:
form = ReviewForm(request.form)
userFire = firebase.FirebaseApplication('https://oopproject-f5214.firebaseio.com')
allUser = userFire.get('userInfo', None)
bioList = []
titleList = []
timeList = []
reviewList = []
posterList = []
allList = []
bio = root.child('userInfo').get()
for key in bio:
if username == bio[key]['username']:
bioList.append(bio[key]['about_me'])
print(bioList)
review = root.child('review').get()
if review != None:
for reviews in review:
if username == review[reviews]['username']:
titleList.append(review[reviews]['title'])
timeList.append(review[reviews]['time'])
reviewList.append(review[reviews]['review'])
posterList.append(review[reviews]['poster'])
allList.append(titleList)
allList.append(reviewList)
allList.append(posterList)
allList.append(timeList)
if request.method == 'POST' and form.validate():
title = form.title.data
review = form.review.data
review = Review(title, review)
review_db = root.child('review')
review_db.push({
'username' : username,
'title' : review.get_title(),
'review' : review.get_review(),
'time' : review.get_date(),
'poster' : session['username']
})
return redirect(url_for('user',username=username))
'''
titleList = []
reviewList = []
bio = root.child('userInfo').get()
for key in bio:
print(allUser[key]['about_me'])
if username == bio[key]['username']:
bioList.append(bio[key]['review'])
usernameList.append((bio[key])[''])
return redirect(url_for('user'))
'''
return render_template('userProfile.html', form=form, username=username, bioList=bioList,allList=allList)
def details():
try:
form = ReviewForm(request.form)
selected = request.args.get('selected')
details = db.execute(
"SELECT * FROM books "
"JOIN authors USING(author_id) "
"WHERE isbn=:selected ", {
"selected": selected
}).fetchall()
reviewed_user = db.execute(
"SELECT user_id, book, rating "
"FROM reviews "
"WHERE user_id="
":user_id and book=:book;", {
"user_id": session["user_id"],
"book": details[0][2]
}).fetchone()
api_key = os.getenv("API_KEY")
response = requests.get(
"https://www.goodreads.com/book/review_counts."
"json",
params={
"key": api_key,
"isbns": details[0][1]
})
output = response.json()['books'][0]
if request.method == "POST":
if reviewed_user:
flash("You can't review the same book twice!", "error")
else:
rating = form.rating.data
review = form.review.data
db.execute(
"Insert INTO reviews (user_id, book, "
"rating, review) VALUES (:user_id, :book, "
":rating, :review);", {
"user_id": session["user_id"],
"book": details[0][2],
"rating": rating,
"review": review
})
db.commit()
flash("Review submitted successfully!", "success")
return render_template(
"details.html",
details=details,
average_rating=output['average_rating'],
work_ratings_count=output['work_ratings_count'])
return render_template("details.html",
details=details,
form=form,
average_rating=output['average_rating'],
work_ratings_count=output['work_ratings_count'],
reviewed_user=reviewed_user)
except Exception:
return redirect("/")
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 review(isbn):
book = get_books_search(isbn)
reviewform = ReviewForm()
searchform = SearchForm()
return render_template("bootstrap-pages/review.html",
reviewform=reviewform,
searchform=searchform,
book=book[0])
def about():
form = ReviewForm()
if request.method == 'POST':
imdb_id = request.form['imdbid']
url = 'http://www.omdbapi.com/?apikey=34035a0a&i=' + str(imdb_id)
json_obj = urllib.request.urlopen(url)
data = json.load(json_obj)
return render_template('info.html', data=data, form=form)
def edit_review(id):
'''
Function to display a page which displays
a form to edit a review for logged in user
'''
if 'logged' not in session:
# if a user trys to go to edit review without been logged in
flash('You need to log in to edit a review', 'warning')
return redirect(url_for('login')) # sending to log in
one_review = mongo.db.reviews.find_one({'_id': ObjectId(id)})
# retrieving record from db
# if a user trys to go to edit review that they don't own
if one_review['username'] != session['username']:
flash('You do not own this review and cannot edit it. ', 'warning')
return redirect(url_for('login')) # sending to log in
form = ReviewForm(data=one_review)
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.update_one({'_id': ObjectId(id)}, {
'$set': {
'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,
}
})
flash('Review Updated ', 'success')
# send to my review template on successful addupdate
return redirect(url_for('review', id=id))
return render_template('editreview.html',
form=form,
title='Edit a Review')
def book_details(id):
book = Book.query.get(id)
if book is None:
try:
book = get_book_details(id)
db.session.add(book)
db.session.commit()
except Exception as e:
flash('Error fetching the book')
db.session.rollback()
print('exception: ', e)
abort(404)
if session.get('profile'):
name = session.get('profile')['name']
else:
name = 'Login'
if book is None:
abort(404)
reviews = book.reviews
posted = False
my_review = None
book_id = None
if session.get('profile'):
user_id = session.get('profile')['user_id'][
session.get('profile')['user_id'].index('|') + 1:]
user = User.query.filter(User.id == user_id).first()
for review in reviews:
if user == review.user:
posted = True
my_review = review
form = ReviewForm()
if posted:
form.title.data = my_review.title
form.review.data = my_review.comment
form.rating.data = my_review.rating
book_id = book.id
print(book_id)
# db.session.close()
return render_template('book_detail.html',
book_id=book_id,
my_review=my_review,
posted=posted,
reviews=reviews,
id=id,
name=name,
title=book.title,
author=book.author,
category=book.category,
image_link=book.image_link,
summary=book.summary,
form=form)
def review(filename):
if 'logged_in' and 'reviewer' not in session:
flash("You Are Not Authorized To Access This Page..!!")
return redirect(url_for('login'))
form = ReviewForm(request.form)
if form.validate():
review_result = reviewArticle(form, filename)
flash(review_result)
return redirect(request.referrer)
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 outcomes():
form = ReviewForm()
if request.method == 'POST' and form.validate():
review = form.review.data
y, proba = classify(review)
return render_template('outcomes.html',
content=review,
prediction=y,
probability=round(proba * 100, 2),
form=form)
return render_template('outcomes.html', form=form)
