def put(self):
args = self.reqparse.parse_args()
token, regex_id, mark = args['token'], args['regex_id'], args['mark']
user_id = int(r[token])
if user_id == 1:
abort(403)
re = Regex.query.filter(Regex.id == regex_id).first()
post = Rating.query.filter(Rating.regex_id == regex_id,
Rating.user_id == user_id).first()
if not user_id == re.author_id:
if post:
if not post.mark:
post.mark = mark
db.session.add(post)
db.session.commit()
return {'message': {'status': 'Changed'}}, 200
else:
if mark:
post = Rating(user_id=user_id,
regex_id=regex_id,
mark=mark)
else:
post = Rating(user_id=user_id, regex_id=regex_id)
db.session.add(post)
db.session.commit()
return {'message': {'status': 'Created'}}, 200
return {'message': {'status': 'Not modified'}}, 200
def addrating(product_id):
if request.method == 'POST':
rating = request.form.get('rating')
comment = request.form.get('comment')
rating = float(rating)
if rating > 5 or rating < 0:
return redirect(url_for('product', product_id=product_id))
checker = Rating.query.filter_by(user_id=current_user.id).filter_by(
product_id=product_id).first()
if checker:
return redirect(url_for('product', product_id=product_id))
r = Rating(user_id=current_user.id,
product_id=product_id,
rating=rating,
comment=comment)
product = Product.query.filter_by(id=product_id).first()
product.rating_count += 1
db.session.add(r)
db.session.commit()
return redirect(url_for('product', product_id=product_id))
def add_rating(form_data, yelp_id, user_id, rating_id=None):
"""adds a rating form data and business_id"""
print 'yelp_id in add_rating:', yelp_id
if Business.query.filter_by(yelp_id=yelp_id).first() is None:
validate_db(yelp_by_id(yelp_id))
score = int(form_data.get("score"))
review = form_data.get("review")
# if a rating already existed, updates the score and the review
print yelp_id
if rating_id:
rating = Rating.query.get(rating_id)
rating.score = score
if review:
rating.review = review
db.session.commit()
return "Your rating has been updated"
else:
business = Business.query.filter_by(yelp_id=yelp_id).first()
print 'business in add_rating:', business
business_id = business.business_id
created_at = datetime.now()
rating = Rating(business_id=business_id,
user_id=user_id,
score=score,
created_at=created_at)
if review:
rating.review = review
db.session.add(rating)
db.session.commit()
return "Your rating has been added!"
def company(id):
form = RateCoForm()
user = g.user
values = Value.query.all()
company = Company.query.filter_by(id = id).first()
if form.validate_on_submit():
for v in form.value_ratings:
print v.value_id.data, v.value_rating.data
corating = db.session.query(Rating).filter_by(author=user, reader=company, value_id = v.value_id.data).first()
print "Got the rating from the db", corating
if not corating:
corating = Rating(author=user, reader=company, value_id = v.value_id.data)
db.session.add(corating)
print "ORIGINAL, NEW", corating.rating, v.value_rating.data
corating.rating = v.value_rating.data
db.session.commit()
flash('Rating has been added.')
return redirect(url_for('colist'))
if request.method == "GET":
for v in values:
form.value_ratings.append_entry({"value_id": v.id,
"value_name": v.name})
return render_template('company_rate.html',
form = form,
user = user,
values = values,
company = company)
def add_rating(request):
target_model = request.POST.get('model', '').lower()
target_name = request.POST.get('id', '').lower()
rating = request.POST.get('rating', '').lower()
errors = []
if target_model.strip() and target_name.strip():
try:
cleaned_rating = int(rating)
rating_object = Rating(target_model=target_model,
target_name=target_name,
rating=cleaned_rating)
rating_object.save()
try:
total_rating_object = TotalRating.objects.get(
target_model=target_model, target_name=target_name)
except ObjectDoesNotExist:
total_rating_object = TotalRating(target_model=target_model,
target_name=target_name)
total_rating_object.save()
total_rating_object.total_rating = total_rating_object.total_rating + cleaned_rating
total_rating_object.rating_count += 1
total_rating_object.save()
except Exception:
errors.append('INVALID_RATING')
response = {'success': True, 'errors': errors}
return shortcuts.render_to_response(
'json.html', {'response': json.dumps(response)},
context_instance=RequestContext(request),
mimetype="application/json")
def ratingMessage(demand_id, recipient):
"""
The '/bid/<demand_id>/rating/<recipient>/message' route directs the user to explain their
rating if it is below a certain amount.
"""
if 'username' not in session:
return redirect(url_for('login'))
if 'username' in session and ('rating' + demand_id) in session:
form = RatingMessageForm()
if request.method == "GET":
return render_template("ratingMessage.html",
form=form,
demand_id=demand_id,
recipient=recipient)
elif request.method == "POST":
if form.message.validate(form):
Rating(demand_id, recipient, session['username'],
session['rating' + demand_id], form.message.data)
del session['rating' + demand_id]
return render_template('ratingFinished.html',
recipient=recipient)
else:
return render_template("ratingMessage.html",
form=form,
demand_id=demand_id,
recipient=recipient)
return render_template('access_denied.html')
def sqlite_save(self):
with app.app_context() as context:
db.init_app(context.app)
now = datetime.utcnow()
#fill table with scrapped data
for y in range(0, len(self.results)):
coin = Coins(self.results[y][1], self.results[y][2])
#add coin if necessary
result = Coins.query.filter_by(symbol = coin.symbol)
if result.count() == 0:
db.session.add(coin)
db.session.commit()
else:
coin = result[0]
#add rating
rate = Rating(self.results[y][0], coin, self.results[y][3],
self.results[y][4], self.results[y][5], self.results[y][6],
self.results[y][7], self.results[y][8], self.results[y][9], now )
db.session.add(rate)
db.session.commit()
print('SQLite saved!!!')
def post(self):
"""
Rate a post
"""
data = api.payload
rating_value = data.get("value")
if rating_value > 5 or rating_value < 0:
abort(400,
{"Value": "la valeur d\'évaluation doit être entre 0 et 5!"})
post_id = data.get("post_id")
user_id = g.user.id
post = Post.query.get(post_id)
if not post:
abort(404)
rating = Rating.query.filter_by(user_id=user_id,
post_id=post.id).first()
if rating:
rating.value = rating_value
else:
rating = Rating(value=rating_value,
user_id=user_id,
post_id=post_id)
db.session.add(rating)
db.session.commit()
return {"element": post.to_json()}, 201
def add_instructor_rating(instid):
inst = Instructor.query.get(instid)
if inst == None:
flash('Invalid instructor id or unauthorized')
return 'Invalid instructor id or unauthorized', 401
rate = Rating.query.get((current_user.id, instid))
if rate != None:
flash('Already rated this insructor')
return 'Already rated this insructor', 403
data = request.get_json()
rating = Rating(userid=current_user.id,
instructorid=instid,
rating1=data["rating1"],
rating2=data["rating2"],
rating3=data["rating3"],
rating4=data["rating4"],
rating5=data["rating5"],
rating6=data["rating6"],
rating7=data["rating7"],
rating8=data["rating8"],
rating9=data["rating9"],
rating10=data["rating10"],
rating11=data["rating11"])
db.session.add(rating)
db.session.commit()
flash('Instructor rated')
return "Instructor rated", 201
def create_rating(session, user, note, rating):
"""Creates a rating based on a unique owner, note, and the value of the rating """
check_permission(session, PermissionType.READ, user, note)
rating = Rating(owner_id=user.id, note_id=note.id, value=rating)
session.add(rating)
return rating
def feedback():
form_rating = RatingForm()
if form_rating.is_submitted():
new_review = Rating(id_reviewer=form_rating.id_reviewer.data.upper(), type=form_rating.type.data,
review=form_rating.review.data)
db.session.add(new_review)
db.session.commit()
return redirect('home')
return render_template('feedback.html', form_rating=form_rating)
def dislikepost(postid):
user = User.query.get(g.user.id)
post = Post.query.get(postid)
newrating = Rating(dislike=1, user_idd=user.id, post_idd=post.id)
db.session.add(newrating)
db.session.commit()
return redirect(f'/{user.id}')
def likepost(postid):
user = User.query.get(g.user.id)
post = Post.query.get(postid)
newrating = Rating(like=1, user_idd=user.id, post_idd=post.id)
db.session.add(newrating)
db.session.commit()
#user likes then it goes to match route and then to matches will redirect if not
return redirect(f'/{user.id}/match')
def get_drink(drink_id):
"""Shows drink info page, handles creating/deleting ratings"""
try:
user_id = session['user']
except KeyError:
flash('Log in to rate/favorite drinks', 'warning')
pass
drink = Drink.query.get(drink_id)
if request.method == 'POST':
rating = request.json['rating']
if float(rating) < 0 or float(rating) > 5:
flash('Please enter a rating between 0 and 5', 'danger')
return redirect(f'/drinks/{drink_id}')
rating_check = Rating.query.filter(Rating.user_id == user_id).filter(
Rating.drink_id == drink_id).first()
if rating_check is None:
new_rating = Rating(rating=rating,
user_id=user_id,
drink_id=drink_id)
db.session.add(new_rating)
db.session.commit()
else:
update_rating = Rating.query.get(rating_check.id)
update_rating.rating = rating
db.session.commit()
return redirect(f'/drinks/{drink_id}')
else:
drink = Drink.query.get(drink_id)
if 'user' not in session:
rating = None
fav_check = None
else:
rating = Rating.query.filter(Rating.user_id == user_id).filter(
Rating.drink_id == drink_id).first()
fav_check = Favorite.query.filter(
Favorite.drink_id == drink_id).filter(
Favorite.user_id == user_id).first()
ingredients = Drinks_Ingredients.query.filter(
Drinks_Ingredients.drink_id == drink.id).all()
names = []
for ingredient in ingredients:
ingredient_name = Ingredients.query.get(ingredient.ingredient_id)
names.append(ingredient_name)
return render_template('drink.html',
drink=drink,
ingredients=ingredients,
fav_check=fav_check,
rating=rating,
names=names)
def rate_recipe(recipe_id,rating):
"""Rate the recipe only for registered and athenticated users"""
rated_query = Rating.query.filter((Rating.recipe_id == recipe_id) & (Rating.user_id==g.user.id)).first()
if rated_query:
rated_query.rating = rating
else:
rating = Rating(recipe_id=recipe_id,user_id=g.user.id,rating=rating)
db.session.add(rating)
db.session.commit()
def RatingDetailApi(rating_id):
url = '/rating/detail/'
values = {'rating_id': rating_id}
raw = request_get(url, values)
raw_obj = json.loads(raw)
if raw_obj.get('rating') == None:
return None
rating = Rating(raw_obj['rating'])
return rating
def rate_coffee(payload, coffee_id):
body = request.get_json()
value = body['value']
rating = Rating(value=value, coffee_id=coffee_id, user_id=payload['sub'])
try:
Rating.insert(rating)
except:
abort(500)
return jsonify(success=True, rating=rating.value)
def load_urm(self):
self._run("load('urmFull.mat')")
self._run("A=full(urm)")
urm = self._get("A")
#force matlab to close and free memory
self._close_matlab()
print 'Out of matlab!'
for (row,col),value in numpy.ndenumerate(urm):
print 'processing rating %i for user %i and item %i' % (value, row, col)
if value is not 0:
self.db.add(Rating(user_id=row+1, item_id=col+1, rating=value))
self.db.flush()
self.db.commit()
def app_fixtures():
u1 = User(username='******')
u2 = User(username='******')
u3 = User(username='******')
ecv.session.add(u1)
ecv.session.add(u2)
ecv.session.add(u3)
hours = 6
time_ready = datetime.datetime.utcnow() + datetime.timedelta(hours=hours)
o1 = Offer(host=u1,
portions=2,
price=3.50,
info="spaghetti gambanero, non-vegetarian",
time_ready=time_ready)
ecv.session.add(o1)
res1 = Reservation(user=u2, offer=o1, portions=1)
res2 = Reservation(user=u3, offer=o1, portions=1)
ecv.session.add(res1)
ecv.session.add(res2)
rat1 = Rating(
user=u2,
host=u1,
stars=2,
comment=
"I liked the sauce, but the company was terrible! I think his father was drunk..."
)
rat2 = Rating(user=u3,
host=u1,
stars=5,
comment="had a good time =) his dad is a fun guy")
ecv.session.add(rat1)
ecv.session.add(rat2)
# commit changes
ecv.session.commit()
def GlobalFeedListApi(offset):
url = '/global/feed/list/'
count = 20
values = {'offset': offset, 'count': count}
raw = request_get(url, values)
raw_obj = json.loads(raw)
ratings = []
for rating_obj in raw_obj['ratings']:
rating = Rating(rating_obj)
ratings.append(rating)
return ratings
def editrating(jokeid, rating):
userid = session['profile']["sub"]
userid = userid[userid.index('|') + 1:len(userid)]
rows = Rating.query.filter_by(jokeid=jokeid, userid=userid).count()
print(rows)
print('what i clicked is %s' % rating)
if rows == 0:
if rating == '1':
print('clicked 1')
new_rating = Rating(int(rating), jokeid, userid)
db.session.add(new_rating)
db.session.commit()
elif rating == '-1':
print('clicked -1')
new_rating = Rating(int(rating), jokeid, userid)
db.session.add(new_rating)
db.session.commit()
return redirect('/dashboard')
else:
return render_template('error_voted.html',
user=session['profile'],
const=const)
def UserRatingListApi(user_id, offset):
url = '/user/rating/list/'
count = 20
values = {'user_id': user_id, 'offset': offset, 'count': count}
raw = request_get(url, values)
raw_obj = json.loads(raw)
ratings = []
for rating_obj in raw_obj['ratings']:
rating = Rating(rating_obj)
ratings.append(rating)
return ratings
def ProductRatingListApi(product_id, offset):
url = '/product/rating/list/'
count = 20
values = {'product_id': product_id, 'offset': offset, 'count': count}
raw = request_get(url, values)
raw_obj = json.loads(raw)
ratings = []
for rating_obj in raw_obj['ratings']:
rating = Rating(rating_obj)
ratings.append(rating)
return ratings
def likert():
form = forms.LikertRatingForm(csrf_enabled=False)
# store the rating submitted
if request.method == 'POST':
score = request.form['rating']
data_ID = request.form['data-id']
rating = Rating('likert', data_ID, score)
mongo.db['ratings'].insert(rating.__dict__)
# Get the next idea to rate
idea = mongo.db.ideas.find_one()
idea = task_manager.get_random(mongo.db, 'ideas')
logger.debug(idea)
data = idea
return flask.render_template('rating.html', form=form, data=data)
def save_rating(id):
rat = request.form['score']
u_name = session['username']
u = db.session.query(User.id).filter(User.username == u_name).scalar()
old_rating = db.session.query(Rating.id).filter(Rating.user_id == u, Rating.record_id == id).scalar()
rating = Rating(rate=rat, user_id=u, record_id=id)
if old_rating is None:
db.session.add(rating)
db.session.commit()
else:
db.session.query(Rating).update({Rating.rate: rat})
db.session.commit()
return redirect(url_for('get_record', id=id))
def vote(id):
cookieId = request.headers.get('Authorization')
#cookieId = '18baab70-ef36-11e9-af39-f94d7c840094'
checkUser(cookieId)
json_data = request.get_json(force=True)
vote = json_data['vote']
row = Rating.query.filter_by(session_id=cookieId, movie_id=id).first()
hasVoted = (row != None)
if hasVoted:
row.rating = vote
db.session.commit()
else:
rating = Rating(cookieId, id, vote)
db.session.add(rating)
db.session.commit()
return ""
def submit_new_rating(uid, r1, r2, r3, r4, r5):
# check if user has already submitted
# ignore the submission in case of repeat
r1 = none_if_zero(r1)
r2 = none_if_zero(r2)
r3 = none_if_zero(r3)
r4 = none_if_zero(r4)
r5 = none_if_zero(r5)
row = Rating(user_id=uid,
rating1=r1,
rating2=r2,
rating3=r3,
rating4=r4,
rating5=r5)
db.session.add(row)
db.session.commit()
display_all_tables()
def add_rate():
user_id = request.form['userId']
book_id = request.form['bookId']
score = request.form['score']
rating = Rating.query.filter_by(user_id=user_id, book_id=book_id).first()
if rating is not None:
rating.score = score
else:
db.session.add(Rating(user_id=user_id, book_id=book_id, score=score))
db.session.commit()
response = {'ok': True}
return json.dumps(response)
def newRating():
try:
user_id = request.get_json()["user_id"]
address_id = request.get_json()["address_id"]
restaurant_name = request.get_json()["restaurant_name"]
cost_rating = request.get_json()["cost_rating"]
food_rating = request.get_json()["food_rating"]
cleanliness_rating = request.get_json()["cleanliness_rating"]
service_rating = request.get_json()["service_rating"]
total_score = (cost_rating + food_rating + cleanliness_rating + service_rating)/4
user_ratings = list(session.query(Rating).filter (Rating.user_id == user_id).filter (Rating.address_id == address_id).all())
if cost_rating > 5 or cost_rating < 1 or food_rating > 5 or food_rating < 1 or cleanliness_rating > 5 or cleanliness_rating < 1 or service_rating > 5 or service_rating < 1:
return "Please Give Rating in Range 1 to 5"
if len(user_ratings) > 0:
return "Rating for this location already Exists, Try Updating it"
else:
user_exists = session.query(User).filter(User.user_id == user_id).scalar() is not None
address_exists = session.query(Address).filter(Address.address_id == address_id).scalar() is not None
if user_exists and address_exists:
newRating = Rating(user_id=user_id, address_id=address_id,restaurant_name=restaurant_name, cost_rating=cost_rating,
food_rating=food_rating, cleanliness_rating=cleanliness_rating,service_rating=service_rating,total_score=total_score )
else:
return "Either user or address doesn't exist"
except:
return "Wrong Input"
try:
session.add(newRating)
session.commit()
return "New Rating Added"
except:
session.rollback()
session.flush()
return "New Rating not added"
def rate():
'''Adds rating to the movie'''
data = flask.request.form
rating = data.get("rating")
comment = data.get("comment")
movie_id = data.get("movie_id")
new_rating = Rating(
username=current_user.username,
rating=rating,
comment=comment,
movie_id=movie_id,
)
db.session.add(new_rating)
db.session.commit()
return flask.redirect("comments")