def post(self, *args, **kwargs):
movie_ratings = Ratings(
user_id=self.get_argument('user_id'),
olympus_has_fallen=self.get_argument('olympus_has_fallen'),
m300=self.get_argument('m300'),
expendables=self.get_argument('expendables'),
lord_of_the_rings=self.get_argument('lord_of_the_rings'),
pirates_of_the_carribbean=self.get_argument(
'pirates_of_the_caribbean'),
harry_potter=self.get_argument('harry_potter'),
grown_ups=self.get_argument('grown_ups'),
hangover=self.get_argument('hangover'),
pacific_rim=self.get_argument('pacific_rim'),
transformers=self.get_argument('transformers'),
man_of_steel=self.get_argument('man_of_steel'),
now_you_see_me=self.get_argument('now_you_see_me'),
django_unchained=self.get_argument('django_unchained'),
pain_and_gain=self.get_argument('pain_and_gain'),
madagascar=self.get_argument('madagascar'),
despicable_me=self.get_argument('despicable_me'),
smurfs=self.get_argument('smurfs'))
if movie_ratings.save_ratings():
self.write(json_encode("User's Movie Ratings successfully saved"))
else:
self.write(json_encode("User already rated movies"))
def import_ratings(request):
f = open('/home/chao-fu/mov-rec/movrec/data/ratings.csv',"r")
next(f)
for lines in f:
line = lines.strip().split(",")
rating = Ratings(userId = int(line[0]), movieId = int(line[1]), rating = int(line[2]))
rating.save()
return HttpResponse("Done")
def get(self, user_id):
user_data = {}
for user_rating in Ratings(user_id=user_id).retrieve_user_ratings():
user_data = {
'olympus_has_fallen': user_rating.olympus_has_fallen,
'm300': user_rating.m300,
'expendables': user_rating.expendables,
'lord_of_the_rings': user_rating.lord_of_the_rings,
'pirates_of_the_carribbean':
user_rating.pirates_of_the_carribbean,
'harry_potter': user_rating.harry_potter,
'grown_ups': user_rating.grown_ups,
'hangover': user_rating.hangover,
'pacific_rim': user_rating.pacific_rim,
'transformers': user_rating.transformers,
'man_of_steel': user_rating.man_of_steel,
'now_you_see_me': user_rating.now_you_see_me,
'django_unchained': user_rating.django_unchained,
'pain_and_gain': user_rating.pain_and_gain,
'madagascar': user_rating.madagascar,
'despicable_me': user_rating.despicable_me,
'smurfs': user_rating.smurfs
}
self.write(json_encode(user_data))
self.render("user_ratings.html",
title="User Ratings",
user_id=user_id,
user_ratings=user_data)
def rate_movie(request):
movieId = request.GET['movieId']
rating = request.GET['rating']
userId = request.GET['userId']
is_existed = Ratings.objects.filter(userId=userId,movieId=movieId).exists()
if is_existed:
return HttpResponse("Duplicated")
else:
rating_record = Ratings(userId = userId, movieId = movieId, rating = rating)
rating_record.save()
#update movie table (movieId,num_stars,num_users)
movie = Movies.objects.get(id=movieId)
movie.num_stars = movie.num_stars + int(rating)
movie.num_users = movie.num_users + 1
movie.avg_rating = float(movie.num_stars)/float(movie.num_users)
movie.save()
return HttpResponse("Added")
def get(self, user_id):
self.render('view_recommendations.html',
title="View Recommendations",
user_id=user_id,
user_name=User(user_id=user_id).retrieve_user_name(),
recommendations=Recommender(
Ratings().retrieve_all_user_ratings()).recommend(
int(user_id)))
def save_ratings(self, place_id, gg_reviews, gg_ratings, ta_reviews, ta_ratings):
session = Session()
if not self.get_ratings(place_id):
rate = Ratings(place_id = place_id, gg_reviews = gg_reviews, gg_ratings = gg_ratings,
ta_reviews = ta_reviews, ta_ratings = ta_ratings)
session.add(rate)
session.commit()
print '<RATING>', place_id, 'saved successfully!'
session.close()
def post(self, *args, **kwargs):
movie_ratings = Ratings(user_id=self.get_argument('user_id'),
olympus_has_fallen=self.get_argument('olympus_has_fallen'),
m300=self.get_argument('m300'),
expendables=self.get_argument('expendables'),
lord_of_the_rings=self.get_argument('lord_of_the_rings'),
pirates_of_the_carribbean=self.get_argument('pirates_of_the_caribbean'),
harry_potter=self.get_argument('harry_potter'),
grown_ups=self.get_argument('grown_ups'),
hangover=self.get_argument('hangover'),
pacific_rim=self.get_argument('pacific_rim'),
transformers=self.get_argument('transformers'),
man_of_steel=self.get_argument('man_of_steel'),
now_you_see_me=self.get_argument('now_you_see_me'),
django_unchained=self.get_argument('django_unchained'),
pain_and_gain=self.get_argument('pain_and_gain'),
madagascar=self.get_argument('madagascar'),
despicable_me=self.get_argument('despicable_me'),
smurfs=self.get_argument('smurfs'))
if movie_ratings.save_ratings():
self.write(json_encode("User's Movie Ratings successfully saved"))
else:
self.write(json_encode("User already rated movies"))
def get(self, user_id):
user_ratings = Ratings().retrieve_all_user_ratings()
neighbors = Recommender(user_ratings).compute_nearest_neighbor(
int(user_id))
neighbors_list = []
for nearest_neighbor in neighbors:
for user in User(
user_id=nearest_neighbor[0]).retrieve_user_information():
neighbors_list.append((str(user.user_name).capitalize(),
(nearest_neighbor[1] * 100)))
self.render('view_neighbors.html',
user_id=user_id,
title="View User Neighbors",
neighbors=neighbors_list,
user_name=User(user_id=user_id).retrieve_user_name())
def insert_rating(rate, task_id, from_user, to_user):
rating = get_task_rating(task_id)
if rating is not None:
rating.value = rate
db.session.commit()
return jsonify({"status": 203, "msg": "Rate guardado"})
rate = Ratings(rate, from_user, to_user, task_id)
try:
db.session.add(rate)
db.session.commit()
return jsonify({"status": 203, "msg": "Rate guardado"})
except Exception as e:
print(e)
db.session.rollback()
return jsonify({"status": 400, "msg": "Erro ao guardar rate"})
def get_ratings():
if request.method == "POST":
rating = Ratings()
rating.id = request.json.get("id")
rating.rating = request.json.get("rating")
db.session.add(rating)
db.session.commit()
return jsonify(rating.serialize_all_fields()), 200
if request.method == "GET":
ratings = Ratings.query.all()
ratings = list(map(lambda rating: rating.serialize_strict(), ratings))
return jsonify(ratings), 200
def create():
if request.form["dest_id"] is None or request.form[
"source_id"] is None or request.form[
"rating"] is None or request.form["transaction_id"] is None:
return build_error_response(
"Invalid Parameters", 400,
"Destination ID, Source ID, Rating or Transaction ID not present in the request"
)
if int(request.form["rating"]) < 1 or int(request.form["rating"]) > 5:
return build_error_response("Invalid Rating Values", 400,
"Rating value should be between 1 and 5")
dest_id = request.form["dest_id"]
source_id = request.form["source_id"]
rate_value = int(request.form["rating"])
transaction_id = request.form["transaction_id"]
rate_id = uuid.uuid4()
if UsersRating.query.filter_by(uid=source_id).first() is None:
user_dest = UsersRating(uid=source_id)
db_session.add(user_dest)
try:
db_session.commit()
except:
db_session.rollback()
if UsersRating.query.filter_by(uid=dest_id).first() is None:
user_dest = UsersRating(uid=dest_id)
db_session.add(user_dest)
try:
db_session.commit()
except:
db_session.rollback()
if Ratings.query.filter_by(
transaction_id=transaction_id).first() is not None:
return build_error_response("Invalid transaction ID", 400,
"Transaction ID is already in use.")
if request.form["message"] is not None:
message = request.form["message"]
rate = Ratings(uid=rate_id,
user_id_source=source_id,
user_id_destination=dest_id,
rating=rate_value,
transaction_id=transaction_id,
message=message)
else:
rate = Ratings(uid=rate_id,
user_id_source=source_id,
user_id_destination=dest_id,
rating=rate_value,
transaction_id=transaction_id)
db_session.add(rate)
db_session.commit()
if UsersRating.query.filter_by(uid=dest_id).count() < 1:
rating_received = (rate_value * 100) / 5
rating_received_count = 1
user_dest = UsersRating(uid=dest_id,
rating_received=rating_received,
rating_received_count=rating_received_count,
rating_total=rating_received)
db_session.add(user_dest)
db_session.commit()
else:
user = UsersRating.query.filter_by(uid=dest_id).first()
rating_received = (rate_value * 100) / 5
user.rating_received = ((user.rating_received*user.rating_received_count) + rating_received) / \
(user.rating_received_count + 1)
user.rating_total = (((user.rating_received*user.rating_received_count) + rating_received) +
(user.rating_given*user.rating_given_count)) / \
(user.rating_given_count + user.rating_received_count + 1)
user.rating_received_count += 1
db_session.commit()
if UsersRating.query.filter_by(uid=source_id).count() < 1:
rating_given = (rate_value * 100) / 5
rating_given_count = 1
user_source = UsersRating(uid=source_id,
rating_given=rating_given,
rating_given_count=rating_given_count,
rating_total=rating_received)
db_session.add(user_source)
db_session.commit()
else:
user = UsersRating.query.filter_by(uid=source_id).first()
rating_given = (rate_value * 100) / 5
user.rating_given = ((user.rating_given * user.rating_given_count) + rating_given) / \
(user.rating_given_count + 1)
user.rating_total = (((user.rating_given * user.rating_given_count) + rating_given) +
(user.rating_received * user.rating_received_count)) / \
(user.rating_given_count + user.rating_received_count + 1)
user.rating_given_count += 1
db_session.commit()
return build_response("Rate Done", 200, "Rate has been done successfully")
def book(request,isbn):
q = Books.objects.filter(isbn=isbn)
p = Feedbacks.objects.filter(isbn=isbn)
#default values for the bookform and the feedbackform
bookdefault = {'qty':1}
feedbackdefault = {'feedback':1,'comment':''}
viewdefault = {'num':1}
num = 0
#if it's a post request
if request.method == 'POST':
#If it's a feedbackform request
if 'feedback' in request.POST:
feedbackform = FeedbackForm(request.POST)
bookform = BookForm(bookdefault)
viewform = ViewForm(bookdefault)
if feedbackform.is_valid():
if "loginid" in request.session:
review = feedbackform.cleaned_data['feedback']
comment = feedbackform.cleaned_data['comment']
customer = Customers.objects.get(loginid=request.session["loginid"])
book = Books.objects.get(isbn=isbn)
f = Feedbacks(loginid=customer,isbn=book,review=review,optionalcomment=comment,feedback_date=str(datetime.now()))
f.save()
print ('Feedback posted!')
else:
print ('Login to give feedback')
elif 'num' in request.POST:
feedbackform = FeedbackForm(feedbackdefault)
bookform = BookForm(bookdefault)
viewform = ViewForm(request.POST)
if viewform.is_valid():
num = viewform.cleaned_data['num']
#If it's a bookform request
elif 'qty' in request.POST:
bookform = BookForm(request.POST)
feedbackform = FeedbackForm(feedbackdefault)
feedbackform = FeedbackForm(feedbackdefault)
if bookform.is_valid():
if "loginid" in request.session and "login" in request.session:
qty = bookform.cleaned_data['qty']
book = Books.objects.get(isbn=isbn)
print ('Processing order')
temp = request.session["orders"]
if isbn in temp:
temp[isbn] = temp[isbn]+qty
else:
temp[isbn]= qty
if temp[isbn] > book.stock:
print 'Insufficient Stock!'
else:
print temp
request.session["orders"] = temp
return HttpResponseRedirect('/homepage/checkout')
else:
return HttpResponseRedirect('/homepage/login')
#Else if it's a rating request
else:
bookform = BookForm(bookdefault)
feedbackform = FeedbackForm(feedbackdefault)
if "loginid" in request.session and request.session['loginid'] != request.POST['loginid']:
rating = request.POST['rating']
ratingid = Customers.objects.get(loginid=request.session['loginid'])
feedbackid = Customers.objects.get(loginid=request.POST['loginid'])
book = Books.objects.get(isbn=isbn)
p = Ratings(isbn=book,feedbackid=feedbackid,ratingid=ratingid,rating=rating)
p.save()
print 'Ratings posted!'
return HttpResponseRedirect('/homepage/')
elif request.session['loginid'] == request.POST['loginid']:
print 'You cannot review yourself!'
else:
print 'Please login first'
#If it's not a post request
else:
#create the default forms
bookform = BookForm(bookdefault)
feedbackform = FeedbackForm(feedbackdefault)
viewform = ViewForm(viewdefault)
#If user is logged in render the page with the Welcome ___! and signout options
if "login" in request.session and "loginid" in request.session:
login = request.session["login"]
loginid = request.session["loginid"]
user = Customers.objects.filter(loginid=loginid).values()[0]
cursor = connection.cursor()
print isbn
viewform = ViewForm(viewdefault)
cursor.execute("SELECT feedbacks.loginID, feedbacks.review, feedbacks.optionalComment from feedbacks where (feedbacks.ISBN = %s) AND feedbacks.loginID IN (select feedbackID from (select * from ratings where ratings.ISBN=%s) group by feedbackID ORDER BY avg(rating) DESC LIMIT %s)",[isbn,isbn,num])
views = cursor.fetchall()
cursor.close()
return render(request,'book.html',{'bookform':bookform, 'feedbackform':feedbackform, 'viewform': viewform,'login':login,'loginid':loginid, 'book':q[0], 'feedbacks':p, 'views':views})
#Else rendeer the page with the register and login options
return render(request,'book.html',{'bookform':bookform, 'feedbackform':feedbackform, 'book':q[0], 'feedbacks':p})