def test_review_likes(self):
"""Test liking a review"""
r1 = Review(
drink_id=self.d1id,
rating=3.5,
review="Test Review",
user_id=self.uid,
image=
"https://images.unsplash.com/photo-1561150169-371f366b828a?ixid=MXwxMjA3fDB8MHxzZWFyY2h8MXx8YWxjb2hvbHxlbnwwfHwwfA%3D%3D&ixlib=rb-1.2.1&w=1000&q=80"
)
r2 = Review(
drink_id=self.d1id,
rating=4.2,
review="Another Test Review of same drink",
user_id=self.uid,
image="https://images.financialexpress.com/2018/03/beer-reuters.jpg"
)
u = User.signup("yetanothertest", "*****@*****.**", "password", None)
uid = 888
u.id = uid
db.session.add_all([r1, r2, u])
db.session.commit()
u.likes.append(r1)
db.session.commit()
l = Likes.query.filter(Likes.user_id == uid).all()
self.assertEqual(len(l), 1)
self.assertEqual(l[0].reviews_id, r1.id)
self.assertNotEqual(l[0].reviews_id, r2.id)
def test_review_comments(self):
"""Test commenting on a review"""
r1 = Review(
drink_id=self.d1id,
rating=3.5,
review="Test Review",
user_id=self.uid,
image=
"https://images.unsplash.com/photo-1561150169-371f366b828a?ixid=MXwxMjA3fDB8MHxzZWFyY2h8MXx8YWxjb2hvbHxlbnwwfHwwfA%3D%3D&ixlib=rb-1.2.1&w=1000&q=80"
)
r2 = Review(
drink_id=self.d1id,
rating=3.3,
review="Another review",
user_id=self.uid,
image=
"https://images.unsplash.com/photo-1561150169-371f366b828a?ixid=MXwxMjA3fDB8MHxzZWFyY2h8MXx8YWxjb2hvbHxlbnwwfHwwfA%3D%3D&ixlib=rb-1.2.1&w=1000&q=80"
)
r1.id = 8888
r2.id = 5599
db.session.add(r1)
db.session.add(r2)
db.session.commit()
c1 = Comment(user_id=self.uid, reviews_id=r1.id, text="Comment on r1")
c2 = Comment(user_id=self.uid, reviews_id=r2.id, text="Comment on r2")
db.session.add(c1)
db.session.add(c2)
db.session.commit()
comments = Comment.query.filter(Comment.user_id == self.uid).all()
self.assertEqual(len(comments), 2)
comment1 = Comment.query.filter(Comment.reviews_id == r1.id).all()
self.assertEqual(len(comment1), 1)
self.assertEqual(comment1[0].reviews_id, r1.id)
self.assertEqual(comment1[0].text, "Comment on r1")
self.assertNotEqual(comment1[0].text, "Comment on r2")
# self.assertNotEqual(l[0].reviews_id, r2.id)
comment2 = Comment.query.filter(Comment.reviews_id == r2.id).all()
self.assertEqual(len(comment2), 1)
self.assertEqual(comment2[0].reviews_id, r2.id)
self.assertEqual(comment2[0].text, "Comment on r2")
self.assertNotEqual(comment2[0].text, "Comment on r1")
def review():
if request.method == 'POST':
rating = request.form.get('review_tags')
review = request.form.get('review_value')
name = session['username']
print(name)
temp = list(request.form.items())
print(temp)
# print(temp[2][0])
if rating is None:
detail = Book.query.filter(Book.isbn == temp[1][0]).all()
isbn = temp[1][0]
else:
detail = Book.query.filter(Book.isbn == temp[2][0]).all()
isbn = temp[2][0]
total_reviews = db.session.query(Review).filter(Review.isbn == isbn)
# if rating is None:
# return render_template('bookpage.html',message = 'Please rate this book',sel_book = detail,total_reviews=total_reviews,isbn = isbn)
flag = review_present(name,isbn)
if flag:
data = Review(username = name, isbn = isbn, rating = rating, review = review)
print(data)
db.session.add(data)
db.session.commit()
else:
return render_template('bookpage.html',message = 'You have already given review',sel_book = detail,total_reviews=total_reviews,isbn = isbn)
return render_template('bookpage.html',name = session['username'], message1 = 'Review submitted succesfully.',total_reviews=total_reviews,sel_book = detail,isbn = isbn)
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 setUp(self):
"""Create test client, add sample data."""
db.drop_all()
db.create_all()
self.app = create_app('testing')
self.client = self.app.test_client()
self.testuser = User.signup('test',
'dummy',
'test123',
'*****@*****.**',
'password',
None,
"Texas",
None,
None)
self.uid = 1111
self.testuser.id = self.uid
db.session.commit()
self.testreview = Review(location='9191 S Polk Street Dallas', description='Just testing this out', user_id=self.testuser.id)
self.rid = 2222
self.testreview.id = self.rid
db.session.commit()
def create_review(place_id):
"""Creates a new review"""
req = request.get_json()
place = storage.get("Place", place_id)
if place is None:
abort(404)
if req is None:
return (jsonify("Not a JSON"), 400)
try:
req['user_id']
except:
return (jsonify("Missing user_id"), 400)
try:
req['text']
except:
return (jsonify("Missing text"), 400)
req['place_id'] = place_id
review_data = Review(**req)
for key, value in req.items():
setattr(review_data, key, value)
review_data.save()
return (jsonify(review_data.to_json()), 201)
def myreviews(request):
reviews = Review.objects.filter(
user=request.user).order_by('-date_started')
context = {'reviews': reviews, 'alert_message': None}
if request.method == "POST":
new_title = request.POST.get('review', "")
new_title = new_title.strip()
if new_title != "":
if not any(c in '!@#$%^&*\"\'' for c in new_title):
if not reviews.filter(slug=slugify(new_title)).exists():
review = Review(user=request.user,
title=new_title,
date_started=datetime.datetime.now())
review.save()
reviews = Review.objects.filter(
user=request.user).order_by('-date_started')
context['reviews'] = reviews
context[
'alert_message'] = "A review was created with name: " + new_title
else:
context[
'alert_message'] = "A review with this name already exists."
else:
context['alert_message'] = "Title cannot contain !@#$%^&*\"\'"
elif request.POST.get('delete_review', "") != "":
review_to_delete = reviews.get(
slug=request.POST.get('delete_review'))
if review_to_delete != None:
review_to_delete.delete()
context[
'alert_message'] = "Review deleted: " + review_to_delete.title
else:
context['alert_message'] = "You must give your new review a title."
return render(request, 'ultimatereview/myreviews.html', context)
def add_review(user: User, submission: Submission,
category: ReviewCategory) -> Review:
if user == submission.user:
raise Exception("Review and submission user cannot be the same")
review = Review(
user=user,
submission=submission,
review_type=category,
mwe=submission.mwe,
created=datetime.now()
)
if category == ReviewCategory.LIKE:
if submission.language == Language.ENGLISH:
submission.user.score_today_en += submission.points
elif submission.language == Language.TURKISH:
submission.user.score_today_tr += submission.points
elif submission.language == Language.ITALIAN:
submission.user.score_today_it += submission.points
submission.user.score += submission.points
submission.score += submission.points
user.score += submission_scores.get_review_score()
if submission.language == Language.ENGLISH:
user.score_today_en += submission_scores.get_review_score()
elif submission.language == Language.TURKISH:
user.score_today_tr += submission_scores.get_review_score()
elif submission.language == Language.ITALIAN:
user.score_today_it += submission_scores.get_review_score()
session = database.get_session()
session.add(review)
database.commit(session)
return review
def create_review(place_id):
"""
Creates new review. If request body not valid JSON, raises 400
If dict does not contain 'name' key, raise 400
Returns review object with status 201
"""
if not request.get_json():
abort(400, "Not a JSON")
kwargs = request.get_json()
a = storage.get("Place", place_id)
if a is None:
abort(404)
if not kwargs.get('user_id'):
abort(400, "Missing user_id")
if not kwargs.get('text'):
abort(400, 'Missing text')
a = storage.get("User", kwargs["user_id"])
if a is None:
abort(404)
my_review = Review(place_id=place_id, **kwargs)
storage.new(my_review)
storage.save()
return jsonify(my_review.to_dict()), 201
def parse_r8_rev(payload, fk):
for key,values in payload.items():
if key == "data":
data = json.dumps(values)
data = json.loads(data)
count = 0
while (count < 5 and count < len(data["beerReviews"]["items"])):
score = ""
comment = ""
comment_date = ""
comment = (data["beerReviews"]["items"][count]['comment'])
score = (data["beerReviews"]["items"][count]['score'])
# Only grab the first portion of the date.
comment_date = (data["beerReviews"]["items"][count]['createdAt'])[0:10]
if "The honey really comes out nicely." in comment or "A very nice BIPA" in comment:
count += 1
continue
# Regex to find hex characters that would break database population.
t = re.match(r'\\x[0-9a-fA-F]+', comment)
first = re.findall(r'[\x80-\xff]', comment)
second = re.findall('[\\x80-\\xff]', comment)
if first or second or t:
count += 1
continue
count += 1
# Creating the actual review in the database.
brew_id = db.session.query(Beer).get(fk).brewery_id
rev = Review(date=comment_date, rating=float(score), comment=comment, beer_name=fk, brewery_name=brew_id)
db.session.add(rev)
db.session.commit()
return 1
def createMultiple(self):
b = Beer(name="Trough",
organic="Y",
abv=11.2,
ibu=9.0,
brewery_id=None,
style_id=None,
images="http://www.placeholder.com/image.jpg")
b2 = Beer(name="Kipp",
organic="N",
abv=13.1,
ibu=9.1,
brewery_id=None,
style_id=None,
images="http://www.placeholder.com/image.jpg")
db.session.add(b)
db.session.add(b2)
db.session.commit()
rev = Review(date="1996-11-11",
rating=2.2,
comment="Kipp was nasty.",
beer_name=b2.id,
brewery_name=None)
db.session.add(rev)
db.session.commit()
self.assertNotEqual(rev.id, b.id)
self.assertEqual(rev.id, b2.id)
def createReviewFK(self):
b = Beer(name="Miller",
organic="Y",
abv=9.2,
ibu=10.0,
brewery_id=None,
style_id=None,
images="http://www.placeholder.com/image.jpg")
brw = Brewery(
name="BrewMe",
city="Dallas",
state="Texas",
country="USA",
established=2009,
description="BrewMe is a IPA brewer.",
images="https://www.drinkbritain.com/sites/default/files/image.png"
)
db.session.add(b)
db.session.add(brw)
db.session.commit()
rev = Review(date="2009-08-09",
rating=3.2,
comment="Miller was meh.",
beer_name=b.id,
brewery_name=brw.id)
db.session.add(rev)
db.session.commit()
self.assertEqual(rev.beer_name, b.id)
self.assertEqual(rev.brewery_name, brw.id)
def create_postreview():
reviewer = request.json["reviewer"]
pname = request.json["pname"]
cname = request.json["cname"]
score1 = request.json["score1"]
score2 = request.json["score2"]
score3 = request.json["score3"]
try:
year = request.json["year"]
except:
year = None
try:
school = request.json["school"]
except:
school = None
try:
comment = request.json["comment"]
except:
comment = None
try:
advice = request.json["advice"]
except:
advice = None
new_review = Review(reviewer=reviewer, pname=pname, cname=cname, score1=score1,
score2=score2, score3=score3, year=year, school=school, comment=comment, advice=advice)
db.session.add(new_review)
db.session.commit()
return jsonify("{} was created".format(new_review))
def create_review(place_id):
'''
Creates a new Review object and saves it to storage
'''
place = storage.get("Place", place_id)
if not place:
abort(404)
if not request.json:
abort(400)
return jsonify({"error": "Not a JSON"})
review_dict = request.get_json()
if "user_id" not in review_dict:
abort(400)
return jsonify({"error": "Missing user_id"})
elif "text" not in review_dict:
abort(400)
return jsonify({"error": "Missing text"})
# Check that user_id is linked to actual User object
user_check = storage.get("User", review_dict["user_id"])
if not user_check:
abort(404)
review_text = review_dict["text"]
user_id = review_dict["user_id"]
review = Review(text=review_text, user_id=user_id, place_id=place_id)
for k, v in review_dict.items():
setattr(review, k, v)
review.save()
return jsonify(review.to_dict()), 201
def create_review_submission(id):
error = False
body = {}
try:
form = request.form
review = Review(
restaurant_id = id,
name = form['name'],
date = datetime.now(),
rating = form['rating'],
comments = form['comments']
)
review.insert()
body['name'] = form['name']
except:
error = True
db.session.rollback()
print(sys.exc_info())
finally:
db.session.close()
if not error:
# on successful db insert, flash success
flash('Thank you ' + body['name'] + ' for your review.', 'success')
else:
flash('An error occurred. Review could not be listed.', 'error')
return redirect('/restaurants/'+str(id)+'/new_reviews')
def create_review(place_id):
content = request.get_json()
if content is None:
return (jsonify({"error": "Not a JSON"}), 400)
my_place = storage.get("Place", place_id)
if my_place is None:
abort(404)
user_id = content.get("user_id")
if user_id is None:
return (jsonify({"error": "Missing user_id"}), 400)
my_user = storage.get("User", user_id)
if my_user is None:
abort(404)
text = content.get("text")
if text is None:
return (jsonify({"error": "Missing text"}), 400)
new_review = Review()
new_review.place_id = my_place.id
for key, val in content.items():
setattr(new_review, key, val)
new_review.save()
return (jsonify(new_review.to_dict()), 201)
def reviews_of_a_place(place_id):
'''
GET: list all reviews in a specific place
POST: add a review to a specific place
'''
my_place = storage.get('Place', place_id)
if my_place is None:
abort(404)
if request.method == 'POST':
review_dict = request.get_json()
if review_dict is None:
return 'Not a JSON', 400
if 'user_id' not in review_dict.keys():
return 'Missing user_id', 400
if 'text' not in review_dict.keys():
return 'Missing text', 400
if storage.get('User', review_dict['user_id']) is None:
abort(404)
review_dict['place_id'] = place_id
my_review = Review(**review_dict)
my_review.save()
return jsonify(my_review.to_dict()), 201
my_reviews = [review.to_dict() for review in storage.all('Review').values()
if review.place_id == place_id]
return jsonify(my_reviews)
def post_review(place_id):
"""Creates a Review object
Args:
place_id: id of the place in uuid format
Returns:
jsonified version of created review object
"""
if storage.get("Place", place_id) is None:
abort(404)
if not request.json:
return jsonify({"error": "Not a JSON"}), 400
review_dict = request.get_json()
if "user_id" not in review_dict:
return jsonify({"error": "Missing user_id"}), 400
if storage.get("User", review_dict["user_id"]) is None:
abort(404)
if "text" not in review_dict:
return jsonify({"error": "Missing text"}), 400
else:
r_user_id = review_dict["user_id"]
r_text = review_dict["text"]
review = Review(user_id=r_user_id, text=r_text, place_id=place_id)
for key, value in review_dict.items():
setattr(review, key, value)
review.save()
return jsonify(review.to_dict()), 201
def reviews():
if 'username' in session and request.method == 'POST':
Comment = request.form['Comment']
Stars = request.form["Stars"]
HouseId = request.form["House"]
StudentEmail = session["username"]
student = Student.query.filter_by(Email=StudentEmail).first()
house = House.query.filter_by(Id=HouseId).first()
if student == None:
return jsonify({
"status":
404,
"message":
"User is not a student so unauthorized to write revew."
})
else:
review = Review(house.Id, student.Id, Stars, Comment,
datetime.now(), datetime.now())
db.session.add(review)
try:
db.session.commit()
except exc.IntegrityError:
db.session.rollback()
return jsonify([{
'status': 400,
'message': "Opps you can't post that!"
}])
return jsonify({"status": 200})
else:
return jsonify({"status": 404})
def add_review(request, wine_id):
wine = get_object_or_404(Wine, pk=wine_id)
form = ReviewForm(request.POST)
if form.is_valid():
rating = form.cleaned_data['rating']
comment = form.cleaned_data['comment']
user_name = request.user.username
review = Review()
review.wine = wine
review.user_name = user_name
review.rating = rating
review.comment = comment
review.pub_date = datetime.datetime.now()
review.save()
update_clusters()
# Always return an HttpResponseRedirect after successfully dealing
# with POST data. This prevents data from being posted twice if a
# user hits the Back button.
return HttpResponseRedirect(
reverse('reviews:wine_detail', args=(wine.id, )))
return render(request, 'reviews/wine_detail.html', {
'wine': wine,
'form': form
})
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 build_db(filename):
# Delete existing DB
if os.path.exists(f"{filename}.sqlite3"):
os.remove(f"{filename}.sqlite3")
# Create DB structure
db.create_all()
# Add data to the DB
with open(f"{filename}.csv") as f:
content = csv.reader(f)
next(content)
for line in content:
# add book info to my database and then commit it
book = Book(
bookID = line[0],
bookName = line[1],
bookAuthor = line[2],
)
# add user info to my database and then commit it
review = Review(
isbnID = line[5],
averageReview = line[3],
ratingsCount = line[8],
)
# add student to my database and then commit it
publisher = Publisher(
bookID = line[0],
isbnID = line[5],
bookPublisher = line[11],
)
db.session.add(review)
db.session.add(publisher)
db.session.add(book)
db.session.commit()
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 show(course_id):
course = Course.query.get(course_id)
if request.method == "POST":
review = Review(**review_params())
db.session.add(review)
db.session.commit()
course.rating_num = course.rating_num + 1
course.rating_sum = course.rating_sum + int(request.form.get('rating'))
db.session.add(course)
db.session.commit()
flash("Отзыв успешно оставлен", "success")
return redirect(
url_for('courses.show', course_id=course_id, course=course))
ncur = []
cur = None
for review in course.reviews:
if current_user.is_authenticated:
if current_user.id != review.user_id:
ncur.append(review)
else:
cur = review
else:
ncur = course.reviews
return render_template('courses/show.html',
course=course,
ncur=ncur,
cur=cur)
def get_place_rev(place_id):
"""
Retrieves list of all Review objects and creates an instance as well
"""
place = storage.get("Place", place_id)
if place is None:
abort(404)
if request.method == 'GET':
return jsonify([
obj.to_dict() for obj in storage.all("Review").values()
if obj.place_id == place_id
])
if request.method == 'POST':
if not request.json:
abort(400, 'Not a JSON')
if 'user_id' not in request.json:
abort(400, 'Missing user_id')
if 'text' not in request.json:
abort(400, 'Missing text')
data = request.get_json().get('text')
user_id = request.get_json().get('user_id')
user = storage.get('User', user_id)
if user is None:
abort(404)
new_review = Review(user_id=user_id, text=data, place_id=place_id)
new_review.save()
return make_response(jsonify(new_review.to_dict()), 201)
def show(course_id):
course = Course.query.get(course_id)
checker = False
if request.method == "POST":
review = Review(**review_params())
db.session.add(review)
db.session.commit()
course.rating_num = course.rating_num + 1
course.rating_sum = course.rating_sum + int(request.form.get('rating'))
db.session.add(course)
db.session.commit()
flash('Ваш комментарий был успешно добавлен!', 'success')
return redirect(
url_for("courses.show", course_id=course_id, course=course))
reviews = Review.query.filter(Review.course_id == course_id)
users = User.query
if current_user.is_authenticated:
for review in reviews:
if review.user_id == current_user.id:
checker = True
reviews = reviews.order_by(Review.created_at.desc()).limit(5)
return render_template('courses/show.html',
course=course,
reviews=reviews,
users=users,
checker=checker)
def test_child_review(self):
""" Tests if the class User is a child class """
review = Review()
self.assertIsInstance(Review, BaseModel)
self.assertTrue(hasattr(review, "id"))
self.assertTrue(hasattr(review, "created_at"))
self.assertTrue(hasattr(review, "updated_at"))
def post(self):
person = None
if self.request.get("email").lower() != "":
if not getPersonObjectByEmail(self.request.get("email").lower()):
person = Person()
person.firstName = self.request.get("first_name").lower()
person.lastName = self.request.get("last_name").lower()
person.email = self.request.get("email").lower()
person.put()
else:
person = getPersonObjectByEmail(
self.request.get("email").lower())
review = None
if not getReviewObject(
person.key): # person hasn't submitted a review.
review = Review(parent=person.key)
review.rating = int(self.request.get("rating").lower())
review.subject = "no subject"
review.message = self.request.get("message_body")
review.visitFrequency = self.request.get("visit_frequency")
putReviewObject(review)
else:
pass
review_template = jinja_env.get_template("templates/reviews.html")
self.response.headers['Content-Type'] = 'text/html'
self.response.out.write(review_template.render(renderAllReviews()))
def submit_review_view(request):
import forms
user = UserProfile.objects.get(username=request.user.username)
try:
if request.method == 'GET':
paper_id = int(request.GET['id'])
elif request.method == 'POST':
paper_id = int(request.POST['id'])
paper = Paper.objects.filter(id=paper_id).get()
review = Review()
review.paper = paper
review.reviewer = user
if request.method == 'POST':
form = forms.SubmitReviewForm(request.POST, instance=review)
if form.is_valid():
form.save(paper)
return HttpResponseRedirect("paper?id=%s" % paper_id)
else:
form = forms.SubmitReviewForm()
except (ValueError, KeyError, Paper.DoesNotExist):
paper = None
form = None
return render(request, "submit_review.html", {
'form': form,
'paper': paper,
'which_page': "submit_review",
})
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))
