def post(self, id):
'''
Leave a movie review
'''
TokenAuthenticator(request.headers.get('Authorization')).authenticate()
is_valid_integer(id)
validate_rating(request.json['rating'])
validate_review(request.json['review'])
session = Session()
movie = session.query(Movie).filter(Movie.movieID == id).one_or_none()
if not movie:
raise NotFound
query = session.query(MovieReview).filter(
MovieReview.movieID == id,
MovieReview.userID == g.userID).one_or_none()
if query:
# We disallow a user from leaving more than one review for the same movie.
raise Forbidden
query = session.query(Watchlist).filter(
Watchlist.movieID == id,
Watchlist.userID == g.userID).one_or_none()
if not query:
# When a user leaves a review for a film, we add that
# film to his Watchlist if it isn't there already.
session.add(Watchlist(id, g.userID))
request.json['rating'] = float(request.json['rating'])
session.add(
MovieReview(id, g.userID, request.json['rating'],
request.json['review']))
movie.ratings_sum += request.json['rating']
movie.review_count += 1
session.commit()
session.close()
return {'message': 'Review saved.'}, 201
def post(self):
# Get params
username = request.json.get('username')
username = cleanString(username)
yob = request.json.get('yob')
email = request.json['email']
email = cleanString(email)
isValidEmail(email)
password = request.json['password']
session = Session()
if session.query(User).filter(User.email == email).first():
raise BadRequest
hashed_password = HashGenerator(password).generate()
new_user = User(username, email, hashed_password, yob)
session.add(new_user)
session.commit()
session.close()
response = {'message': 'Registration successful.'}
return response, 201
def post(self):
'''
Add a FilmFinder to your Banned List.
'''
TokenAuthenticator(request.headers.get('Authorization')).authenticate()
is_valid_integer(request.json['userID'])
session = Session()
query = session.query(User).filter(
User.userID == request.json['userID']).one_or_none()
if not query:
raise NotFound
query = session.query(BannedList).filter(
BannedList.userID == g.userID,
BannedList.bannedUserID == request.json['userID']).one_or_none()
if query or g.userID == request.json['userID']:
# If the FilmFinder being banned is already in the user's Banned List,
# or if a user is attempting to ban himself, raise an Exception.
raise Forbidden
# Remove a user's subscription to a FilmFinder when banning that FilmFinder.
session.query(Subscription).filter(
Subscription.userID == g.userID,
Subscription.subscribedUserID == request.json['userID']).delete()
session.add(BannedList(g.userID, request.json['userID']))
session.commit()
session.close()
return {'message': 'Reviewer banned.'}, 201
def post(self, userID):
TokenAuthenticator(request.headers.get('Authorization')).authenticate()
session = Session()
is_valid_integer(userID)
# User not Found
if not session.query(User).filter(User.userID == userID).first():
raise NotFound
cID = g.userID
# Can't subscribe to oneself.
if cID == userID:
raise BadRequest
new = set(session.query(Wishlist.movieID).filter(Wishlist.userID == userID))
cur = set(session.query(Wishlist.movieID).filter(Wishlist.userID == cID))
# Add only absent movies
toAdd = new.difference(cur)
if toAdd:
for movie in toAdd:
for m in movie:
wl = Wishlist(m, cID)
session.add(wl)
session.commit()
session.close()
response = {'message': 'Wishlisted Movies imported'}
return response, 201
else:
response = {'message': 'No Movies were imported'}
return response, 200
def readWriteComputeGenrePred():
session = Session()
genreoffilm = pd.read_sql('genreOfFilm', session.bind)
genre = pd.read_sql('genres', session.bind)
gen = pd.merge(genreoffilm, genre, on = 'genreID')
recoDir = 'RecSystem'
dataDir = 'RecoData'
location = path.join(recoDir, dataDir)
movie_movie = pd.read_csv(path.join(location, 'movie_movie.csv'), header = 0) #load the movie-movie file
session.close()
return getPerdictionsOfGenres(gen, movie_movie)
def readWriteComputeMoviePred():
session = Session()
fc = pd.read_sql('filmCast', session.bind)
fd = pd.read_sql('filmDirectors', session.bind)
person = pd.read_sql('persons', session.bind)
genre = pd.read_sql('genreOfFilm', session.bind)
genlist = pd.read_sql('genres', session.bind)
movies = pd.read_sql('movies', session.bind)
review = pd.read_sql('movieReviews', session.bind)
session.close()
return getPerdictionsOfMovies(fc, fd, person, genre, genlist, movies,
review)
def readWriteComputeDirectorPred():
session = Session()
fd = pd.read_sql('filmDirectors', session.bind)
person = pd.read_sql('persons', session.bind)
final = pd.merge(person, fd, on='personID')
final = final.drop(columns=['personID'])
recoDir = 'RecSystem'
dataDir = 'RecoData'
location = path.join(recoDir, dataDir)
movie_movie = pd.read_csv(path.join(location, 'movie_movie.csv'),
header=0) # load the movie-movie file
session.close()
return getPredictionsOfDirectors(final, movie_movie)
def delete(self, id):
'''
Remove a FilmFinder from your Banned List.
'''
TokenAuthenticator(request.headers.get('Authorization')).authenticate()
is_valid_integer(id)
session = Session()
if not session.query(BannedList).filter(BannedList.userID == g.userID,
BannedList.bannedUserID
== id).delete():
# If the FilmFinder being unbanned is not in
# the user's Banned List, raise an Exception.
session.commit()
raise NotFound
session.commit()
session.close()
return {'message': 'Reviewer unbanned.'}, 200
def delete(self, movieID):
'''
Removes said movie from current user's Wishlist.
'''
TokenAuthenticator(request.headers.get('Authorization')).authenticate()
session = Session()
is_valid_integer(movieID)
affectedRows = session.query(Wishlist).filter(Wishlist.movieID == movieID)\
.filter(Wishlist.userID == g.userID).delete()
# When 0, it means either of movieID or userID are not present in database.
if affectedRows == 0:
raise NotFound
else:
session.commit()
session.close()
return 204
def readWriteComputeUserPred():
session = Session()
dataset = pd.read_sql('movieReviews', session.bind)
recoDir = 'RecSystem'
dataDir = 'RecoData'
location = path.join(recoDir, dataDir)
movie_movie = pd.read_csv(path.join(location, 'movie_movie.csv'),
header=0) # load the movie-movie file
sub_dict = {
userID: list(map(int, subscribedUserIDs.split(',')))
for userID, subscribedUserIDs in session.query(
Subscription.userID,
func.group_concat(Subscription.subscribedUserID)).group_by(
Subscription.userID)
}
session.close()
return getPerdictionsOfUsers(dataset, sub_dict, movie_movie)
def post(self):
'''
Adds a movie to the users' Watchlist.
'''
TokenAuthenticator(request.headers.get('Authorization')).authenticate()
movieID = request.json.get('movieID')
is_valid_integer(movieID)
new_watchlist = Watchlist(movieID, g.userID)
session = Session()
session.add(new_watchlist)
try:
session.commit()
session.close()
except IntegrityError: #If Watchlist already present
session.rollback()
raise BadRequest
response = {'message': 'Movie added to Watchlist.'}
return response, 201
def get(self, userID):
'''
View said user's Wishlist of movies.
'''
TokenAuthenticator(request.headers.get('Authorization')).authenticate()
session = Session()
is_valid_integer(userID)
results = session.query(Movie.movieID, Movie.title, Movie.year, Movie.ratings_sum, \
Movie.review_count).filter(Wishlist.userID == userID)\
.filter(Wishlist.movieID == Movie.movieID)
username = session.query(User.username).filter(User.userID == userID).first()
if not username:
raise NotFound
movies = list()
for movieID, title, year, ratings_sum, review_count in results:
movies.append({'movieID': movieID, 'title': title, 'year': year,
'rating': str(compute(movieID, g.userID, ratings_sum, review_count))
})
# Check if current user is subscribed to said user
res = session.query(Subscription).filter(Subscription.userID == g.userID) \
.filter(Subscription.subscribedUserID == userID).first()
session.close()
isSubscribed = False
if res:
isSubscribed = True
response = {'username': username, 'wishlist': movies, 'isSubscribed': isSubscribed}
return response, 200
