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('/')