def seed_reviews():
review1 = Review(
writer_id=2,
reviewee_id=1,
application_id=7,
response_id=3,
content="Did a great job! Would recommend for any manual task!",
score=5)
review2 = Review(writer_id=2,
reviewee_id=1,
application_id=9,
content="Was energetic and helpful!",
score=4)
review3 = Review(
writer_id=1,
reviewee_id=2,
application_id=7,
content="Was a top-notch volunteer experience! Great for all ages.",
score=5)
db.session.add(review1)
db.session.add(review2)
db.session.add(review3)
db.session.commit()
def setUp(self):
self.user_James = User(username = '******',password = '******', email = '*****@*****.**')
self.new_review = Review(movie_id=12345,movie_title='Review for movies',image_path="https://image.tmdb.org/t/p/w500/jdjdjdjn",movie_review='This movie is the best thing since sliced bread',user = self.user_James )
self.new_review = Review('movie_id','title','imageurl','review')
def add(tasting_id):
form = ReviewForm(tasting_id=tasting_id)
current_time = datetime.utcnow()
if form.validate_on_submit():
filename = secure_filename(form.image.data.filename)
# set age to 0 if it has not been entered
if form.age.data == "":
age = 0
else:
age = int(form.age.data)
if form.brand_id.data is '0':
brand = Brand(name=form.brand_name.data)
db.session.add(brand)
db.session.flush()
review = Review(order=form.order.data,
notes=form.notes.data,
tasting_note=form.tasting_note.data,
img_name=filename,
name=form.name.data,
age=age,
max_rating=form.max_rating.data,
avg_rating=form.avg_rating.data,
min_rating=form.min_rating.data,
author=current_user,
brand_id=brand.id,
tasting_id=form.tasting_id.data)
else:
review = Review(order=form.order.data,
notes=form.notes.data,
tasting_note=form.tasting_note.data,
img_name=filename,
name=form.name.data,
age=form.age.data,
max_rating=form.max_rating.data,
avg_rating=form.avg_rating.data,
min_rating=form.min_rating.data,
author=current_user,
brand_id=form.brand_id.data,
tasting_id=form.tasting_id.data)
db.session.add(review)
db.session.commit()
pathlib.Path(current_app.config['UPLOAD_FOLDER'] + '/' +
str(review.id)).mkdir(parents=True, exist_ok=True)
form.image.data.save(current_app.config['UPLOAD_FOLDER'] + '/' +
str(review.id) + '/' + filename)
rotateImage(
current_app.config['UPLOAD_FOLDER'] + '/' + str(review.id) + '/',
filename)
flash('Your review is now live!')
return redirect(
url_for('main.tasting', tasting_id=form.tasting_id.data))
return render_template(
'add_review.html',
title='Add Review',
form=form,
)
def review():
form = ReviewForm()
if form.validate_on_submit():
review = Review(body=form.review.data, author=current_user)
headline = Review(body=form.headline.data, author=current_user)
db.session.add(review)
db.session.add(headline)
db.session.commit()
flash('Your review is now live!')
return render_template('review.html', title='Review', form=form)
def test_get_review_avg_score(self):
""" Get average score for a list of reviews """
watch_review_list = [Review(username="******", score="4", detail="OK"),
Review(username="******",
score="4", detail="As expected"),
Review(username="******", score="3", detail="So So")]
watch = Product(name="I Watch", price=329, id="2",
image_id="001", review_list=watch_review_list)
avg_score = float(4 + 4 + 3) / 3
watch.set_review_list(watch_review_list)
self.assertEquals(watch.avg_score(), avg_score)
def test_relation_user_review(self):
review = Review()
user = User()
user.reviews.append(review)
self.assertEqual(review, user.reviews[0])
self.assertEqual(user, review.user)
def add_review():
"""添加审查要素.
:return:
"""
req_dict = request.get_json()
step_id = req_dict.get('step_id')
name = req_dict.get('name')
requ = req_dict.get('requ')
need = req_dict.get('need')
permit = req_dict.get('permit')
print("++++添加要素++++",req_dict)
# order = req_dict.get('order')
# 校验数据
param_keys = ["step_id","name","requ","need","permit"]
param_dict = dict()
for i in param_keys:
param_dict.__setitem__(i,req_dict.get(i,''))
for key,value in param_dict.items():
if not value:
return jsonify(errno=RET.PARAMERR, errmsg="数据不完整,缺少%s"%key)
try:
exist = Review.query.filter_by(name=name,step_id=step_id).all()
if exist:
return jsonify(errno=RET.DBERR,errmsg="数据有重复")
review = Review(name=name,requ=requ,need=need,permit=permit,step_id=step_id)
db.session.add(review)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="添加失败")
return jsonify(errno=RET.OK, errmsg="成功")
def product(product_id):
product = Product.query.get_or_404(product_id)
reviews = product.reviews.all()
if len(reviews) > 0:
rating = int(
round(sum([review.rating for review in reviews]) / len(reviews)))
else:
rating = 0
form = ReviewForm()
if form.validate_on_submit():
if current_user.is_authenticated:
review = Review(title=form.title.data,
rating=form.rating.data,
body=form.body.data,
reviewer=current_user._get_current_object(),
product=product)
database.session.add(review)
database.session.commit()
flash("Your review has been posted!", "success")
return redirect(url_for('products.product', product_id=product_id))
else:
flash("You must be logged in to leave a review!", "danger")
abort(Constants.FORBIDDEN_PAGE_ERROR_PAGE)
return render_template("product.html",
product=product,
reviews=reviews,
form=form,
rating=rating)
def write_review(request):
context_dict = {}
# Check if the request is of post type
if request.method == 'POST':
# Get the informationg from the form in required format
donor_id = request.POST["donor"]
hospital_id = request.POST["hospital"]
data = {
'donor': Donor.objects.get(pk=donor_id),
'hospital': Hospital.objects.get(pk=hospital_id),
'date': request.POST["time"],
'review': request.POST["review_text"]
}
# Try to create a new review with given data
try:
review = Review()
review.new_review(data)
return JsonResponse({
'success':
True,
'message':
"The review has been succesfully published!"
})
except:
return JsonResponse({
'success':
False,
'message':
"The provided login details are incorrect!"
})
else:
return redirect("app:app")
def review_add(asin=None):
if request.method == 'PUT':
product = Product.query.filter(Product.asin == asin).first()
if not product:
return jsonify(status='error', errors=[{'message': ['No such product asin found']}])
try:
title = request.json.get('title')
review = request.json.get('review')
except AttributeError:
return jsonify(status='error', errors=[{'validation': ['Check out your JSON and headers']}])
if not title or not review:
return jsonify(status='error', errors=[{'validation': ['Fill title & review fields']}])
new_review = Review()
new_review.title = title
new_review.review = review
product.reviews.append(new_review)
db.session.add(new_review)
db.session.commit()
# TODO :)
cache.clear()
return jsonify(status='success')
return jsonify(status='error', errors=[{'message': 'Wrong request format'}])
def event(id):
event = Event.query.get(id) #Get event with respective ID
form = ReviewForm()
temp = db.session.query(func.avg(
Review.rating).label('average')).filter(Review.event_id == id)
if temp[0].average: #If it has one or more reviews, find the average
avg = round(temp[0].average, 2)
else: #If no reviews are posted set it to 0 stars
avg = 0
if form.validate_on_submit(): #If user submits a form, check validity
rev = Review.query.filter_by(event_id=id,
user_id=current_user.get_id()).count(
) #set rev to previous review of event
#will be 0 if no previous review is posted
if rev != 0: #if rev is not equal to 0 a reviews has already been posted. Promt user to edit current review
flash(
"Can't review an event twice. Please edit/update your previous review",
"warning")
else: #otherwise create new instance of Review, assigning it data from the form
review = Review(rating=round(form.rating.data, 2),
text=form.text.data,
user_id=current_user.get_id(),
event_id=id)
flash("Review has been added", "success")
db.session.add(
review) #add the review to the current session and commit it
db.session.commit()
return redirect(url_for(
'events.event', id=id)) #redirect user back to the event's page
return render_template('events/event.html',
name=event.name.title(),
event=event,
form=form,
average=avg)
def put(product_id):
product = db.session.query(Product).get_or_404(product_id)
body = request.get_json()
review = (db.session.query(Review).filter_by(
product_asin=product.asin,
title=body.get("review_title"),
review_text=body.get("review_text"),
).first())
if not review:
review = Review(
product_asin=product.asin,
title=body.get("review_title"),
review_text=body.get("review_text"),
)
db.session.add(review)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
print(f"Exception: {e}")
return jsonify({
"product_asin": review.product_asin,
"title": review.title,
"review_text": review.review_text,
})
def setUp(self):
"""
Set up method that will run before every Test.
"""
self.new_review = Review(
1, 'Python is awesome',
'https://image.tmdb.org/t/p/w500/khsjha27hbs', 'A whole new World')
def addReview():
"""
Posts a New Review
"""
form = ReviewForm()
form['csrf_token'].data = request.cookies['csrf_token']
print('Request', request.json)
print('Form', form.data)
if form.validate_on_submit():
print('Current User', current_user)
review = Review(user_id=(form.data['user']),
restaurant_id=(form.data['restaurant']),
body=form.data['body'],
rating=(form.data['rating']),
bags=form.data['bags'],
utensils=form.data['utensils'],
napkins=form.data['napkins'],
cups=form.data['cups'],
bowls=form.data['bowls'],
straws=form.data['straws'],
created=datetime.datetime.now(),
updated=datetime.datetime.now())
print('Review', review)
db.session.add(review)
db.session.commit()
return review.to_dict()
return {'errors': validation_errors_to_error_messages(form.errors)}
def seed_reviews():
# demoReview = Review(
# user_id=1,
# event_id=1,
# rating=random.randint(1, 5),
# comment=fake.text(),
# )
for _ in range(10):
my_word_list = [
'whiskey', 'bourbon', 'scotch', 'wine', 'Sommelier', 'Mixologist',
'Rum', 'Vodka', 'spirits', 'the', 'absolute', 'best', 'host',
'event', 'party', 'very', 'fun', 'knowledgable',
'knows their stuff', 'will book again', 'not great',
'did not seem to know much', 'will not book again',
'find someone else'
]
r = Review(
user_id=random.randint(1, 10),
event_id=random.randint(1, 10),
rating=random.randint(2, 5),
comment=fake.sentence(ext_word_list=my_word_list),
)
db.session.add(r)
db.session.commit()
def process_reviews(self):
logging.info('Parse reviews')
with open(f'files/reviews.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for row in csv_reader:
line_count += 1
if line_count == 1:
continue
product = Product.query.filter(Product.asin == row[0].strip()).first()
if not product:
logging.error(f"There is no product with such asin code {row[0].strip()}")
continue
review = Review()
review.title = row[1]
review.review = row[2]
product.reviews.append(review)
db.session.add(review)
db.session.commit()
logging.info(f'Processed {line_count} lines of reviews.')
logging.info('End script')
def add_review(id):
businesses = Business.check_business_exists(id)
all_business = []
for business in businesses:
obj = {
"name": business.name
}
all_business.append(obj)
if not all_business:
message = "cannot add review business that does not exist"
response = jsonify({"message": message, "status_code": 404})
# 404 if business does not exist
response.status_code = 404
return response
opinion = str(request.data.get('opinion', ''))
rating = int(request.data.get('rating', ''))
if rating and opinion:
new_review = Review(opinion=opinion, rating=rating, business_main=id)
new_review.save()
message = "succesfully added the review"
response = jsonify({"message": message})
response.status_code = 201
return response
message = "make sure the opinion and rating are included"
response = jsonify({"message": message, "status_code": 400})
response.status_code = 400
return response
def book(id):
book = Book.query.get(id)
form = ReviewForm()
temp = db.session.query(func.avg(
Review.rating).label('average')).filter(Review.book_id == id)
if temp[0].average:
avg = round(temp[0].average, 2)
else:
avg = 0
if form.validate_on_submit():
rev = Review.query.filter_by(book_id=id,
user_id=current_user.get_id()).count()
if rev != 0:
flash(
"Can't review a book twice. Please edit/update your previous review",
"warning")
else:
review = Review(rating=round(form.rating.data, 2),
text=form.text.data,
user_id=current_user.get_id(),
book_id=id)
flash("Review has been added", "success")
db.session.add(review)
db.session.commit()
return redirect(url_for('books.book', id=id))
return render_template('books/book.html',
title=book.title.title(),
book=book,
form=form,
average=avg)
def post_review(artist_id):
old_rating = request.get_json()['old_rating']
new_rating = request.get_json()['new_rating']
user_id = request.get_json()['user_id']
show_id = request.get_json()['show_id']
artist = Artist.query.get(artist_id)
num_reviews = len(artist.reviews)
review = Review.query.filter_by(user_id=user_id, show_id=show_id).first()
if (review):
review.rating = new_rating
# If there is only one review, then the review you are modifying must be that review. So you can just replace the artist rating
# with the new rating
if num_reviews < 2:
artist.rating = new_rating
else:
# Formula for replacing a number in an average
artist.rating = (num_reviews * artist.rating - old_rating +
new_rating) / num_reviews
else:
new_review = Review(rating=new_rating,
user_id=user_id,
artist_id=artist_id,
show_id=show_id)
db.session.add(new_review)
# Formula for adding a number to an average.
artist.rating = artist.rating + (new_rating -
artist.rating) / (num_reviews + 1)
db.session.commit()
user = User.query.get(user_id)
return user.to_dict()
def requestor():
cform = CreateForm()
if cform.validate_on_submit():
print(current_user.first_name)
review = Review(title=cform.title.data,
description=cform.description.data,
biling=cform.biling.data,
status=1,
requestor=current_user.id,
requestor_name=User.get_name(current_user.id),
date=datetime.datetime.now(),
pic=current_user.profile_pic)
db.session.add(review)
db.session.commit()
tags = cform.tags.data
print(tags)
tag_list = tags.split(',')
print('4444444444444444')
print(tag_list)
Review.setTags(tag_list, review.id)
print('333333333333333333')
return redirect(url_for("app.requestor"))
else:
print('bad')
return render_template('requestor.html', cform=cform, user=current_user)
def create_api(app, swagger_host=None, swagger_port=5000):
custom_swagger = {
"info": {"title": "New Title"},
"securityDefinitions": {"ApiKeyAuth": {"type": "apiKey" , "in" : "header", "name": "My-ApiKey"}}
} # Customized swagger will be merged
api = SAFRSAPI(app, host=swagger_host, port=swagger_port, custom_swagger=custom_swagger)
api.expose_object(Thing)
api.expose_object(SubThing)
for i in range(30):
secret = hashlib.sha256(bytes(i)).hexdigest()
reader = Person(name="Reader " + str(i), email="reader_email" + str(i), password=secret)
author = Person(name="Author " + str(i), email="author_email" + str(i))
book = Book(title="book_title" + str(i))
review = Review(
reader_id=reader.id, book_id=book.id, review="review " + str(i)
)
if i % 4 == 0:
publisher = Publisher(name="name" + str(i))
publisher.books.append(book)
reader.books_read.append(book)
author.books_written.append(book)
for obj in [reader, author, book, publisher, review]:
db.session.add(obj)
db.session.commit()
for model in [Person, Book, Review, Publisher]:
# Create an API endpoint
api.expose_object(model)
def create_book_review(ISBN):
form = CreateReviewForm()
book = Book.query.get(ISBN)
if form.validate_on_submit():
review_params = {
'ISBN': book.ISBN,
'username': current_user.get_id(),
'score': form.score.data,
'description': form.description.data,
'date': time.strftime("%Y-%m-%d")
}
if Review.query.filter_by(username=current_user.get_id(),
ISBN=book.ISBN).first() is None:
review = Review(**review_params)
if save(review):
flash("Review created successfully!")
return redirect(url_for('my.show_book', ISBN=book.ISBN))
else:
flash("Failed to create review. Please try again.")
else:
flash("You have already entered a review for this book.")
return render_template('my/book/review/new.html', book=book, form=form)
def test_write_paper(self):
paper = Paper(
title="How to conquer the World",
abstract="just conquer it!",
status=0
)
review = Review()
author = Author()
user_that_authored = User()
user_that_reviews = User()
user_that_authored.authors.append(author)
user_that_reviews.reviews.append(review)
paper.authors.append(author)
paper.reviews.append(review)
db.session.add(paper)
db.session.commit()
paper = Paper.query.all()[0]
self.assertEqual(review, paper.reviews[0])
self.assertEqual(author, paper.authors[0])
self.assertEqual(user_that_authored, paper.authors[0].user)
self.assertEqual(user_that_reviews, paper.reviews[0].user)
def test_relation_review_paper(self):
review = Review()
paper = Paper()
paper.reviews.append(review)
self.assertEqual(review, paper.reviews[0])
self.assertEqual(paper, review.paper)
def add_review(request):
outlet_id = request.POST.get('outlet_id')
rating = request.POST.get('rating')
review = request.POST.get('reviews')
outlet = Outlet.objects.get(pk=outlet_id)
Review(outlet=outlet,rating=rating,review=review).save()
return HttpResponse("done",content_type="application/json")
def create_review():
"""
Creates an review.
"""
form = ReviewForm()
print(request.get_json())
# Get the csrf_token from the request cookie and put it into the
# form manually to validate_on_submit can be used
form['csrf_token'].data = request.cookies['csrf_token']
print('<<<<<<<<<<<< csrf', form['csrf_token'].data)
if form.validate_on_submit():
print('validated form')
app_id = form.data['application_id']
first_rev = Review.query.filter(
Review.application_id == app_id).first()
review = Review(writer_id=form.data['writer_id'],
reviewee_id=form.data['reviewee_id'],
application_id=form.data['application_id'],
content=form.data['content'],
score=form.data['score'])
db.session.add(review)
db.session.commit()
if first_rev:
first_rev.response_id = review.id
db.session.add(first_rev)
db.session.commit()
rev = review.to_dict()
order_id = rev['order_id']
order = Order.query.filter(Order.id == order_id).first()
order.status = "Complete"
db.session.add(order)
db.session.commit()
return review.to_dict()
return 'invalid form'
def movie_details(id):
m = Movie.query.get_or_404(id)
reviews = Review.query\
.with_entities(User.username, Review.grade, Review.feelings, Review.thoughts,
Review.timestamp, Review.user_id, User.image)\
.filter(Review.movie_id == id)\
.join(User)\
.limit(4)\
.all()
form = ReviewForm()
if form.validate_on_submit():
review = Review(grade=form.grade.data,
thoughts=form.thoughts.data,
feelings=form.feelings.data,
user_id=current_user.id,
movie_id=id)
db.session.add(review)
db.session.commit()
flash('Review sent succesfully')
return redirect(url_for('main.movie_details', id=id))
return render_template('movie_details.html',
title='movie_details',
movie=m,
reviews=reviews,
form=form)
def setUp(self):
'''
Set up method that will run before every Test
'''
self.new_review = Review(1234, 'Python Must Be Crazy',
'A thrilling new Python Series',
'/khsjha27hbs', 8.5, 129993)
def add_review(id):
if (Restaurant.query.filter(Restaurant.id == id).count() > 0):
email = get_jwt_identity()
user = User.query.filter(User.email == email).first()
data = request.get_json()
restaurantId = int(id)
reviewerId = int(user.id)
review = data['review']['review']
createdAt = datetime.now()
updatedAt = datetime.now()
db.session.add(
Review(restaurantId, reviewerId, review, createdAt, updatedAt))
db.session.commit()
data = Review.query.filter(Review.restaurantId == id).order_by(
desc(Review.updatedAt)).first()
reviewdata = {
"review": {
"id": data.id,
"restaurantId": data.restaurantId,
"reviewerId": data.reviewerId,
"review": data.review,
"createdAt": data.createdAt,
"updatedAt": data.updatedAt
}
}
return jsonify(reviewdata), 200
else:
return ('No Restaurant found with that ID'), 404
def setUp(self):
self.new_user = User(user_id=3000,
user_name='Sandy',
user_email='sandys@gmail',
user_password='******')
self.new_review = Review(review_id=12300,
comment='Yes Yes',
user=self.new_user)
