def review(self, id):
endpoint = 'https://www.goodreads.com/review/show.xml'
params = {'id': id, 'key': self.key}
r = requests.get(endpoint, params=params)
if r.status_code != 200:
raise GoodReadsError(r.text)
review = Review()
review.raw_content = r.content
review.parse()
review.body = self._review_content(review.url)
return review
def process_review(restaurant_id):
"""Add user's review to database."""
# Get restaurant id, rating, review, and user_id
rating = float(request.form.get("rating"))
body = request.form.get("review-body")
user_id = session["user_id"]
# Get list of user's reviews from database
db_user_reviews = Review.query.filter(Review.user_id == user_id).all()
reviewed_restaurants = []
for d in db_user_reviews:
reviewed_restaurants.append(d.restaurant_id)
restaurant = Restaurant.query.filter(
Restaurant.restaurant_id == restaurant_id).one()
# If current restaurant has not already been reviewed,
# add current review to the database
if restaurant_id not in reviewed_restaurants:
new_review = Review(restaurant_id=restaurant_id,
user_id=user_id,
rating=rating,
body=body)
db.session.add(new_review)
db.session.commit()
flash("Your review of %s has been saved." % restaurant.name, "success")
else:
flash("Oops! Looks like you've already reviewed %s." % restaurant.name,
"error")
return redirect("/home")
def add_review():
"""add review to database"""
user_id = session["current_user"]
play = request.form.get("title")
photo = request.form.get("photo")
# photo = functions.save_photo("photo")
content = request.form.get("quote")
publication = request.form.get("publication")
writer = request.form.get("critic")
link = request.form.get("link")
kwargs = dict(user_id=user_id,
play_id=play,
photo_id=photo,
content=content,
publication=publication,
writer=writer,
link=link)
db.session.add(Review(**kwargs))
db.session.commit()
user = User.query.get(user_id)
for review in user.reviews:
print(review.content)
return redirect("/users/{}/my_press".format(user_id))
def add_user_comment(company_id):
"""Add new user comment to company page."""
form_company = request.form.get("company")
form_rating = request.form.get("rating")
form_emp_status = request.form.get("employee_status")
form_title = request.form.get("title")
form_pros = request.form.get("pros")
form_cons = request.form.get("cons")
form_gender = request.form.get("gender")
form_ethnicity = request.form.get("ethnicity")
form_recommend = request.form.get("recommend")
company = Company.query.filter(Company.name == form_company).one()
id_of_company = company.company_id
review = Review(company_id=id_of_company,
rating=form_rating,
gender=form_gender,
ethnicity=form_ethnicity,
employee_status=form_emp_status,
review_title=form_title,
pros=form_pros,
cons=form_cons,
recommended=form_recommend)
db.session.add(review)
db.session.commit()
# reviews = Review.query.all()
flash("Your review has been received!")
return redirect("/company/" + str(id_of_company))
def review(ctx, words):
for index, word in enumerate(words):
click.echo(f"{index+1}/{len(words)} {word.en} {word.ch}")
click.echo(f"{word.ch}")
error_count = 0
while click.prompt("") != word.en:
error_count += 1
click.prompt("not correct! try again!")
new_review = Review.create()
new_review.word_id = word.id
new_review.review_at = datetime.now()
new_review.stage_before = word.stage
word.stage += (not error_count)
new_review.stage_after = word.stage
new_review.error_count = error_count
word.save()
new_review.save()
if not error_count:
click.echo(
f"correct! the stage of word `{word.en}` has changed from "
f"stage {new_review.stage_before} to stage {new_review.stage_after}!\n"
)
else:
click.echo(f"Oops! due to the error_count {error_count},"
f"you're still in stage{word.stage} for word `{word}`!"
f"Try to do better at next time!\n")
click.echo("Congrats! You've finished all the review tasks\n!")
def create_a_review(review_object_uri, body, email=None):
try:
with create_session() as s:
r = _get_review_objects(s, [review_object_uri])
if not r:
return 'Invalid review object uri'
o = Review()
o.review_object_uri = review_object_uri
o.body = body
# touch time
o.updated_at_utc = time.time()
s.add(o)
return ''
except:
raise
return 'Failed to post a review, please try again.'
def load_reviews(filename):
"""Load reviews from json-like file into database."""
print "=================="
print "loading reviews"
f = open(filename)
for line in f:
# Each line is a review for one product in the products table
r = eval(line)
review_time = datetime.strptime(r['reviewTime'], '%m %d, %Y')
summary = H.unescape(r['summary'])
review = H.unescape(r['reviewText'])
# Create a new review object and add it to the reviews table
review = Review(review=r['reviewText'],
asin=r['asin'],
score=r['overall'],
summary=summary,
time=review_time)
db.session.add(review)
db.session.commit()
def add_review():
"""Add game/review to database."""
rating = request.form.get('rating')
comment = request.form.get('comment')
if comment == '':
comment = None
start_date = request.form.get('start_date')
end_date = request.form.get('end_date')
if end_date == '':
end_date = None
title = session['title']
logged_user = session['current_user']
#Need user ID from DB
user = User.query.filter_by(username=logged_user).first()
game = Game.query.filter_by(title=title).first()
#Add new review into DB
new_review = Review(rating=rating,
comment=comment,
start_date=start_date,
finish_date=end_date,
game=game)
user.reviews.append(new_review)
db.session.add(new_review)
db.session.commit()
return redirect('/profile/list')
def create_review(event_id):
event_selected = Event.query.filter(Event.id == event_id).first()
create_review_form = CreateReview()
if create_review_form.is_submitted():
review = Review(reviewed_id=create_review_form.reviewed_id.data,
reviewer_id=session['user_id'],
event_id=event_selected.id,
skills=create_review_form.skills.data,
sportsmanship=create_review_form.sportsmanship.data,
willingness=create_review_form.willingness.data,
reliability=create_review_form.reliability.data,
punctuality=create_review_form.punctuality.data,
notes=create_review_form.notes.data,
date_added=datetime.now())
db.session.add(review)
db.session.commit()
return redirect(url_for('event', id=event_selected.id))
joined_events = JoinedEvent.query.filter(
JoinedEvent.event_id == event_id).all()
reviews = Review.query.filter(Review.event_id == event_id).all()
return render_template('create_review.html',
event_selected=event_selected,
create_review_form=create_review_form,
joined_events=joined_events,
reviews=reviews,
now=datetime.now())
def run(self):
if not self.options.user_id:
raise Exception("Need a user to load from!")
review_urls = Review.all_urls()
rss_reviews = Yelp.load_reviews(self.options.user_id)
added = []
for review in rss_reviews:
written = _value_for_key(review, 'pubDate')
title = _value_for_key(review, 'title')
link = _value_for_key(review, 'link')
description = _value_for_key(review, 'description')
geo_long = _value_for_key(review, '{http://www.w3.org/2003/01/geo/wgs84_pos#}long')
geo_lat = _value_for_key(review, '{http://www.w3.org/2003/01/geo/wgs84_pos#}lat')
if link in review_urls:
continue
else:
added.append(review)
business = BIZ_NAME_RE.search(title).groupdict()['biz']
rating = int(RATING_RE.search(title).groupdict()['rating'])
author_time = datetime.datetime.strptime(written, "%a, %d %b %Y %H:%M:%S %Z")
db_review = Review(business, rating, description, geo_long, geo_lat, link, author_time)
meta.session.add(db_review)
meta.session.commit()
if added:
self.log.info("Imported %d new reviews" % len(added))
def load_reviews():
"""Create reviews and load into database."""
# Delete all rows in table to avoid adding duplicates
Review.query.delete()
for i in range(0, 50):
# Set moved_in_at because moved_out_at and created_at depend on moved_in_at
moved_in_at = fake.date_time_between(start_date="-5y", end_date="now")
review = Review(user_id=randint(1, 50),
landlord_id=randint(1, 50),
address_id=randint(1, 44),
moved_in_at=moved_in_at,
moved_out_at=fake.date_time_between_dates(
datetime_start=moved_in_at, datetime_end=None),
created_at=fake.date_time_between_dates(
datetime_start=moved_in_at, datetime_end=None),
rating1=randint(1, 5),
rating2=randint(1, 5),
rating3=randint(1, 5),
rating4=randint(1, 5),
rating5=randint(1, 5),
comment=fake.text(max_nb_chars=500))
# Add the review to the database
db.session.add(review)
# Commit all additions to database
db.session.commit()
def test_find_reviews(self):
"""Test that full-text search works on reviews.
In addition to finding terms in a review's
summary or body, we want to test that
postgres is stemming and lowercasing the queries.
"""
# Check that postgres is stemming
results1 = Review.find_reviews('A1', 'wasted')
self.assertEqual(len(results1), 1)
self.assertIn("waste of money", results1[0][1])
# Check that postgres is dealing with case
results2 = Review.find_reviews('A2', 'trash')
self.assertEqual(len(results2), 1)
self.assertIn("monitor broke", results2[0][1])
def create_new_review(movie_id, user_id, review, rating, date_review):
'''Creates new review row in DB, returns Review object'''
new_review = Review(movie_id=movie_id,
user_id=user_id,
review=review,
rating=rating,
date_review=date_review)
db.session.add(new_review)
db.session.commit()
return new_review
def create_review(user, podcast, review_text, score):
review = Review(user=user,
podcast=podcast,
review_text=review_text,
score=score)
db.session.add(review)
db.session.commit()
return review
def pre_process_request(self, req, handler):
if req.path_info.startswith('/changeset') and 'review' in req.args:
review = Review.get(self.env.get_db_cnx(),req.args['review_rev'],req.args['review_author'])
review.author = req.args['review_author']
review.reviewer = req.authname
review.comment = req.args['review_comment']
review.status = "REJECTED"
if 'review_passed' in req.args:
review.status = "ACCEPTED"
review.save(self.env.get_db_cnx())
return handler;
def create_review(timestamp, user_id, movie_id, review_content):
"""Create and return a review."""
review = Review(timestamp=timestamp,
user_id=user_id,
movie_id=movie_id,
review_content=review_content)
db.session.add(review)
db.session.commit()
return review
def create_review(rating, review_date, comment, reviewer_id, maker_id):
""" create a new review """
review = Review(rating=rating,
review_date=review_date,
comment=comment,
reviewer_id=reviewer_id,
maker_id=maker_id)
db.session.add(review)
db.session.commit()
return review
def process_rating():
# add to Review table:
user_info = User.query.filter_by(user_id=session["user_id"]).first()
add_review = str(request.form.get("review"))
# add to teacher's overall rating
ratings = float(request.form.get("rating"))
class_rate = float(request.form.get("classid"))
print "class_rate: ", type(class_rate), class_rate
print "ratings: ", type(ratings), ratings
class_to_rate = Classroom.query.filter(
Classroom.class_id == class_rate).first()
class_to_rate.rating_count = float(class_to_rate.rating_count)
print class_to_rate.rating_count
rating_update = (class_to_rate.rating * class_to_rate.rating_count +
ratings) / (class_to_rate.rating_count + 1)
up_count = Classroom.rating_count + 1
####################
if len(add_review) > 10:
add_review = Review(review=add_review, class_id=class_rate)
db.session.add(add_review)
db.session.commit()
db.session.query(Classroom).filter(
Classroom.class_id == class_rate).update(
{Classroom.rating_count: Classroom.rating_count + 1})
db.session.commit()
print "class_to_rate, rating_count", class_to_rate.rating_count
db.session.query(Classroom).filter(
Classroom.class_id == class_rate).update(
{Classroom.rating: rating_update})
db.session.commit()
else:
db.session.query(Classroom).filter(
Classroom.class_id == class_rate).update(
{Classroom.rating_count: Classroom.rating_count + 1})
db.session.commit()
print "class_to_rate, rating_count", class_to_rate.rating_count
db.session.query(Classroom).filter(
Classroom.class_id == class_rate).update(
{Classroom.rating: rating_update})
db.session.commit()
print "ADDED: ", add_review, type(add_review)
print "class_to_rate, rating: ", class_to_rate.rating
return "Thanks for rating this class!"
def review_process(biz_name):
"""Processes user review of business."""
score = request.form.get['rating']
comment = request.form.get['review']
rev_type = request.form.get['rev_type']
today = datetime.today()
biz = Business.query.filter_by(biz_name=biz_name).first()
user = User.query.get(session['user_id'])
if rev_type == 'new':
review = Review(user_id=session['user_id'],
biz_id=biz.biz_id,
rating=int(score),
review=comment,
review_date=today)
db.session.add(review)
db.session.commit()
flash('Your review has been received. {} appreciates your feedback.'.format(biz_name), 'info')
elif rev_type == 'revise':
review_id = request.form.get['review-id']
review = Review.query.get(review_id)
review.revise_review = True
review.new_rating = score
review.new_review = comment
db.session.commit()
flash('Your review has been updated. {} appreciates your feedback.'.format(biz_name), 'info')
return render_template('business_profile.html', biz=biz, user=user,
today=today, user_score=int(score))
def add_review(episode_id, series_id):
review_input = request.form.get("review-input")
review=DB.query(Review).filter_by(ep_id=episode_id, user_id=current_user.id).first()
if review == None:
new_review = Review(user_id=current_user.id, ep_id=episode_id, body=review_input)
DB.add(new_review)
DB.commit()
else:
review.body=review_input
DB.add(review)
DB.commit()
return redirect(url_for("display_episode_info",series_id=series_id, episode_id=episode_id))
def add_movie_to_backend(title):
result = rt.reviews(title)
if not result:
raise ValueError('no movie found for {}'.format(title))
if session.query(Movie).filter_by(id=result['id']).count() != 0:
raise ValueError('movie ID {} already exists'.format(result['id']))
movie = Movie(result['id'], result['title'])
if not result.get('reviews', []):
raise KeyError('no reviews for {}'.format(title))
for review in result.get('reviews', []):
dt = parser.parse(review['date']) if review.get('date', None) else None
review_obj = Review(review['freshness'] == 'fresh',
review.get('original_score', None),
review.get('quote', None),
review.get('url', None),
dt)
critic_query = session.query(Critic).filter_by(name=review['critic'])
if review.get('publication', None):
critic_query = critic_query.filter_by(publication=review['publication'])
critic = critic_query.first()
if not critic:
critic = Critic(review['critic'], review.get('publication', None))
review_obj.movie = movie
review_obj.critic = critic
session.add(review_obj)
session.commit()
def post(self, reviews_id):
user = users.get_current_user()
if not user:
self.render_template(
"permissiondenied.html",
params={"login_url": users.create_login_url('/')})
return
review = self.request.get("newreview")
price = int(self.request.get("newprice"))
rating = int(self.request.get("newrating"))
visit = self.request.get("newvisit")
reviews = Review(user=user.email(),
note=review,
price=price,
rating=rating,
visit=visit,
restaurant=reviews_id)
reviews.put()
redetail = Gastro.get_by_id(int(reviews_id))
q = urllib.urlencode({
"query":
(redetail.name + " in " + redetail.place).encode(encoding='ascii',
errors='ignore'),
"key":
"AIzaSyBKdIPR1Q6TzIvjJuJzIyvybo6Mg1JLm64"
})
url = "https://maps.googleapis.com/maps/api/place/textsearch/json?" + q
result = urlfetch.fetch(url)
restaurant_info = json.loads(result.content)
params = {"redetail": redetail, "restaurant_info": restaurant_info}
return self.render_template("rest_details.html", params=params)
def reviews():
"""Load restaurant review data"""
Review.query.delete()
with open('combined_reviews.csv') as csvfile:
readCSV = csv.reader(csvfile, delimiter=',')
for row in readCSV:
biz_id = row[0]
review = row[1]
each_review = Review(biz_id=biz_id, review=review)
db.session.add(each_review)
db.session.commit()
def add_to_board(user_id, recipe_id):
"""Add cooked recipe to Chef Board by creating a new Review"""
user = User.query.filter(User.user_id == user_id).one()
cooked_recipe = UserRecipe.query.filter(
UserRecipe.user_id == user_id,
UserRecipe.recipe_id == recipe_id).one()
cooked_recipe.cooked = True
if not Review.query.filter(Review.user_id == user_id, Review.recipe_id
== recipe_id).all():
new_review = Review(recipe_id=recipe_id, user_id=user_id)
db.session.add(new_review)
db.session.commit()
return jsonify({})
def search_reviews(asin):
search_query = request.args.get('query')
reviews = Review.find_reviews(asin, search_query)
user_id = None
if "user" in session:
user_id = session["user"]["id"]
review_dict_list = format_reviews_to_dicts(reviews, user_id)
return jsonify(review_dict_list[:10])
def submit_review():
text = request.form.get("review")
if text is not None:
country = Country.query.filter_by(
country_name=request.form.get("country")).first()
country_id = request.form.get("country")
score = request.form.get("score")
r = Review(text=text,
score=score,
moderation_status='pending',
country_id=country_id)
db.session.add(r)
db.session.commit()
return redirect('/')
item = db.session.query(Country.id, Country.country_name).all()
return render_template('submitreview.html', item=item)
def load_reviews():
"""Load reviews from mini_reviews into database."""
print 'Reviews'
# Delete all rows in table, so if we need to run this a second time,
# we won't be trying to add duplicate users
Review.query.delete()
# Read user file and insert data
for i, row in enumerate(open('data/test_data/mini_review.csv', 'rU')):
row = row.rstrip()
review_id, user_id, biz_id, rating, review, review_date_str, dispute, response, revise_review, new_rating, new_review, cust_svc = row.split(',')
review_date = datetime.strptime(review_date_str, '%m/%d/%y')
if new_rating:
new_rating = int(new_rating)
else:
new_rating = None
if cust_svc:
cust_svc = int(cust_svc)
else:
cust_svc = None
review = Review(user_id=int(user_id),
biz_id=int(biz_id),
rating=int(rating),
review=review,
review_date=review_date,
dispute=dispute,
response=response,
revise_review=revise_review,
new_rating=new_rating,
new_review=new_review,
cust_svc=cust_svc)
# Add each review to the session
db.session.add(review)
# Commit at end
db.session.commit()
def add_review(id):
content = request.form.get('content')
apartment = Apartment.query.filter_by(id=id).first()
if not content or content == '':
flash('The content is empty', 'warning')
elif not apartment:
flash('The hotel is not exist.', 'warning')
elif not apartment.checkuser(current_user.id):
flash("You can't review it before booking.")
else:
review = Review(content=content,
apartment_id=id,
user_id=current_user.id,
score=request.form.get('rating'))
db.session.add(review)
db.session.commit()
flash('Review added', 'success')
return redirect(url_for('apartment', id=id))
def add_review_process():
"""Get information from review form page"""
campsite_name = request.form["campsite_name"]
campsite = Campsite.query.filter_by(name=campsite_name).first()
campsite_id = campsite.campsite_id
amenities = campsite.amenities
ratings = campsite.ratings
# Get form variables
review = request.form["review"]
noise_level = int(request.form["noiselevel"])
privacy_level = int(request.form["privacylevel"])
risk_level = int(request.form["risklevel"])
#User_id pulled from session
user_id = session.get("user_id")
user = User.query.filter_by(user_id=user_id).first()
new_rating = Rating(noise_level=noise_level,
risk_level=risk_level,
privacy_level=privacy_level,
user_id=user_id,
campsite_id=campsite_id)
new_review = Review(user_id=user_id,
campsite_id=campsite_id,
review_description=review)
db.session.add(new_rating)
db.session.add(new_review)
db.session.commit()
reviews = campsite.reviews
return render_template("campsite-details.html", campsite=campsite,
amenities=amenities,
ratings=ratings,
reviews=reviews,
user=user)
def add_review_db():
"""add a review to db"""
if "user_id" in session:
brand_id = request.form.get("brandid")
review_content = request.form.get("reviewContent")
user = User.query.get(session["user_id"])
review = Review(user=user,
review_content=review_content,
product_id=brand_id)
db.session.add(review)
db.session.commit()
return jsonify({"status": "added review"})
else:
return redirect("/login")
def search_reviews(asin):
"""Perform full-text search within product reviews.
Returns the matching reviews via json to the front end.
"""
search_query = request.args.get('query')
# Run full-text search within a product's reviews
# Return a list of review tuples.
reviews = Review.find_reviews(asin, search_query)
user_id = None
if "user" in session:
user_id = session["user"]["id"]
# Converts list of review tuples into a list of dictionaries
review_dict_list = format_reviews_to_dicts(reviews, user_id)
return jsonify(review_dict_list[:10])
def post(self):
json_data = request.get_json(force=True)
if not json_data:
return {'message': 'No input data provided'}, 400
data, errors = review_schema.load(json_data)
if errors:
return {"status": "error", "data": errors}, 422
product_id = Review.query.filter_by(id=data['product_id']).first()
if not product_id:
return {
'status': 'error',
'message': 'review product not found'
}, 400
review = Review(product_id=data['product_id'], review=data['review'])
db.session.add(review)
db.session.commit()
result = review_schema.dump(review).data
return {'status': "success", 'user_reviews': result}, 201
def _review_attrs(self, req, changeset):
review = Review.get(self.env.get_db_cnx(),changeset.rev, self.author(changeset))
if req.perm.has_permission('CODE_REVIEW'):
comment = tag.textarea(review.comment, name="review_comment", rows=6, cols=100 )
if review.status=="ACCEPTED":
checkbox = tag.input(type="checkbox", name="review_passed", checked="true")
else:
checkbox = tag.input(type="checkbox", name="review_passed")
submit = tag.input(type="hidden", name="review_rev", value=changeset.rev)+ \
tag.input(type="hidden", name="review_author", value=self.author(changeset))+ \
tag.input(type="submit", name="review", value="Review")
else:
comment = tag.span(review.comment)
checkbox = tag.span(review.status)
submit = "";
return tag.form(
tag.dt("Reviewer:",class_="property author"),
tag.dd( req.authname,class_="author"),
tag.dt("Comment:",class_="property author"),
tag.dd( comment ),
tag.dt("Passed:",class_="property author"),
tag.dd(checkbox+submit)
)
def generate_reviews():
print "Reviews"
Review.query.delete()
#query db to get all users
users = User.query.all()
#query db to get all studios
studios = Studio.query.all()
for user in users:
for studio in studios:
review = Review(user_id=user.user_id,
studio_id=studio.studio_id,
amenities_rating=randint(4, 5),
cleanliness_rating=randint(4, 5),
class_size_rating=randint(1, 2),
schedule_rating=randint(4, 5),
pace_rating=randint(2, 3))
db.session.add(review)
db.session.commit()
def add_review():
"""Add a review order to our database."""
score = request.form.get("score")
comment_description = request.form.get("commentText")
comment_title = request.form.get("title")
trail_id = int(request.form["trail_id"])
# getting the user name from the form page, to get the user id and add it to
# reviews
user_name = request.form["name"]
session_user = User.query.filter_by(user_name=user_name).first()
user_id = session_user.user_id
# add an order to our database here
new_review = Review(user_id=user_id, trail_id=trail_id,
comment_title=comment_title,
comment_description=comment_description,
score=score)
db.session.add(new_review)
db.session.commit()
return redirect('/')
