def actor_search():
q = request.args.get('q', '')
try:
page = int(max(0, request.args.get('page', 1)))
except:
page = 1
pagination = Actor.query.search(q).paginate(page=page,
per_page=SEARCH_PAGE_SIZE,
error_out=False)
response = {
'items': [{
'name': actor.name,
'poster_path': actor.profile_path
} for actor in pagination.items],
'page_size':
SEARCH_PAGE_SIZE,
'current_page':
pagination.page,
'total_pages':
pagination.pages,
'total_results':
pagination.total
}
return success_response(**response)
def post_movie_review(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
movie = Movie.query.get(args['movie_id'])
if not movie:
return error_response(400, 'Movie does not exist')
# Check user hasn't already submitted a review for that movie
existing_review = Review.query.filter_by(author_id=user_id).filter_by(
movie_id=args['movie_id']).first()
if existing_review:
return error_response(
400, 'User has already submitted a review for this movie')
review = Review(author_id=user_id,
movie_id=args['movie_id'],
body=args['body'])
db.session.add(review)
db.session.commit()
return success_response(review_id=review.id)
def remove_friend(args):
user_id = get_jwt_identity()
friendee_id = args['user_id']
user = User.query.get(user_id)
friendee = User.query.get(friendee_id)
if not user:
return error_response(400, "User does not exist")
elif not friendee:
return error_response(400, "Friend does not exist")
to_friendship = db.session.query(Friendship) \
.filter(Friendship.user_id == user_id) \
.filter(Friendship.friend_id == friendee_id) \
.filter(Friendship.active == 1) \
.first()
from_friendship = db.session.query(Friendship) \
.filter(Friendship.user_id == friendee_id) \
.filter(Friendship.friend_id == user_id) \
.filter(Friendship.active == 1) \
.first()
if not to_friendship or not from_friendship:
return error_response(400, "Friendship doesn't exist")
db.session.delete(to_friendship)
db.session.delete(from_friendship)
db.session.commit()
return success_response()
def movie_search():
q = request.args.get('q', '')
try:
page = int(max(0, request.args.get('page', 1)))
except:
page = 1
pagination = Movie.query.search(q).paginate(page=page,
per_page=SEARCH_PAGE_SIZE,
error_out=False)
response = {
'items': [{
'title': movie.title,
'poster_path': movie.poster_path
} for movie in pagination.items],
'page_size':
SEARCH_PAGE_SIZE,
'current_page':
pagination.page,
'total_pages':
pagination.pages,
'total_results':
pagination.total
}
return success_response(**response)
def remove_flicks_list_item(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
list_item_movie = db.session.query(FlicksList, FlicksListItem, Movie) \
.join(FlicksListItem) \
.join(Movie) \
.filter(FlicksList.owner_id == user_id) \
.filter(FlicksListItem.id == args['list_item_id']).first()
if not list_item_movie:
return error_response(400, 'Item does not exist')
flickslist, list_item, movie = list_item_movie
if list_item.completed:
movie.remove_completed_member(rating=list_item.rating)
else:
movie.remove_ptw_member()
db.session.delete(list_item)
db.session.commit()
return success_response()
def post_recommendation(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
recommendation_from = Movie.query.get(args['recommendation_from'])
if not recommendation_from:
return error_response(400, '1st movie does not exist')
recommendation_to = Movie.query.get(args['recommendation_to'])
if not recommendation_to:
return error_response(400, '2nd movie does not exist')
existing_rec = Recommendation.query.filter_by(recommendation_from=args['recommendation_from']) \
.filter_by(recommendation_to=args['recommendation_to']) \
.filter_by(author_id=user_id).first()
if existing_rec:
return error_response(400, 'Recommendation pairing already exists')
recommendation = Recommendation(
author_id=user_id,
body=args['body'],
recommendation_from=args['recommendation_from'],
recommendation_to=args['recommendation_to'])
db.session.add(recommendation)
db.session.commit()
return success_response(recommendation_id=recommendation.id)
def get_movie_recommendations(args):
movie = Movie.query.get(args['movie_id'])
if not movie:
return error_response(400, 'Movie does not exist')
query = db.session.query(Recommendation, User, Movie) \
.join(User, Recommendation.author_id == User.id) \
.join(Movie, Recommendation.recommendation_to == Movie.id) \
.filter(Recommendation.recommendation_from == movie.id) \
.order_by(Recommendation.timestamp)
pagination = paginate(query, page=args['page'], per_page=10)
response = {
'items': [{
'author': user.username,
'body': recommendation.body,
'movie_title': movie.title,
'poster_path': movie.poster_path,
'movie_id': movie.id
} for recommendation, user, movie in pagination.items],
'page_size':
10,
'current_page':
pagination.page,
'total_pages':
pagination.pages,
'total_results':
pagination.total
}
return success_response(**response)
def get_user_recommendations(args):
user = User.query.get(args['user_id'])
if not user:
return error_response(400, 'User does not exist')
movie_from = aliased(Movie)
movie_to = aliased(Movie)
query = db.session.query(Recommendation, movie_from, movie_to) \
.join(movie_from, Recommendation.recommendation_from == movie_from.id) \
.join(movie_to, Recommendation.recommendation_to == movie_to.id) \
.filter(Recommendation.author_id == user.id) \
.order_by(Recommendation.timestamp)
pagination = paginate(query, page=args['page'], per_page=10)
response = {
'items': [{'body': recommendation.body, 'movie_from_title': movie_from.title,
'movie_from_poster_path': movie_from.poster_path, 'movie_from_id': movie_from.id,
'movie_to_title': movie_to.title, 'movie_to_poster_path': movie_to.poster_path,
'movie_to_id': movie_to.id} for recommendation, movie_from, movie_to in pagination.items],
'page_size': 10,
'current_page': pagination.page,
'total_pages': pagination.pages,
'total_results': pagination.total
}
return success_response(**response)
def get_movie_reviews(args):
movie = Movie.query.get(args['movie_id'])
if not movie:
return error_response(400, 'Movie does not exist')
query = db.session.query(Review, User) \
.join(User) \
.filter(Review.movie_id == args['movie_id']) \
.order_by(Review.timestamp)
pagination = paginate(query, page=args['page'], per_page=10)
response = {
'items': [{
'author': user.username,
'body': review.body,
'timestamp': review.timestamp
} for review, user in pagination.items],
'page_size':
10,
'current_page':
pagination.page,
'total_pages':
pagination.pages,
'total_results':
pagination.total
}
return success_response(**response)
def add_custom_list_item(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
movie = Movie.query.get(args['movie_id'])
if not movie:
return error_response(400, 'Movie does not exist')
custom_list = CustomList.query.get(args['list_id'])
if not custom_list:
return error_response(400, 'List does not exist')
elif custom_list.owner_id != user_id:
return error_response(400, 'List does not belong to user')
elif movie.id in [item.movie_id for item in custom_list.items]:
return error_response(400, 'Movie already exists in custom list')
list_item = CustomListItem(list_id=custom_list.id,
movie_id=movie.id,
notes=args['notes'])
movie.num_custom += 1
db.session.add(list_item)
db.session.add(movie)
db.session.commit()
return success_response(list_item_id=list_item.id)
def accept_friend_request(args):
user_id = get_jwt_identity()
friendee_id = args['user_id']
user = User.query.get(user_id)
friendee = User.query.get(friendee_id)
if not user:
return error_response(400, "User does not exist")
elif not friendee:
return error_response(400, "Friend does not exist")
from_friendship = db.session.query(Friendship) \
.filter(Friendship.user_id == friendee_id) \
.filter(Friendship.friend_id == user_id) \
.filter(Friendship.active == 0).first()
if not from_friendship:
return error_response(400, "Friendship request doesn't exist")
to_friendship = Friendship(user_id=user_id, friend_id=friendee_id, active=1)
from_friendship.active = 1
db.session.add(to_friendship)
db.session.add(from_friendship)
db.session.commit()
return success_response()
def set_new_password(args):
user = User.verify_reset_password_token(args['reset_token'])
if user:
user.set_password(args['password'])
db.session.add(user)
db.session.commit()
return success_response()
return error_response(400, 'Invalid token')
def verify_account(args):
user = User.verify_confirmation_token(args['verify_token'])
if user:
user.verified = True
db.session.add(user)
db.session.commit()
return success_response()
else:
return error_response(400, 'Invalid token')
def login(args):
user = User.query.filter_by(email=args['email']).first()
if user and user.verify_password(args['password']):
token = create_access_token(identity=user.id)
response = {'token': token, 'verified': user.verified}
return success_response(**response)
return error_response(403, 'Invalid credentials')
def update_account_password(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
user.set_password(args['password'])
db.session.add(user)
db.session.commit()
return success_response()
def get_actor_details(args):
actor = Actor.query.get(args['actor_id'])
if not actor:
return error_response(400, 'Actor does not exist')
response = {}
for k, v in actor.get_actor_metadata().items():
response[k] = v
return success_response(**response)
def update_profile_info(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
user.fav_genre = args['fav_genre']
user.gender = args['gender']
user.location = args['location']
user.website = args['website']
user.about = args['about']
db.session.add(user)
db.session.commit()
return success_response()
def get_custom_list_details(args):
custom_list = db.session.query(CustomList) \
.options(joinedload('items').joinedload('movie')) \
.filter(CustomList.id == args['list_id']).first()
if not custom_list:
return error_response(400, 'List does not exist')
elif custom_list.private and custom_list.owner_id != get_jwt_identity():
return error_response(400, 'List does not exist')
response = custom_list.get_list_details()
return success_response(**response)
def create_custom_list(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
custom_list = CustomList(name=args['name'],
description=args['description'],
private=args['private'],
owner_id=user_id)
db.session.add(custom_list)
db.session.commit()
return success_response(list_id=custom_list.id)
def update_account_email(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
if not User.query.filter(User.email == args['email']).first():
user.email = args['email']
db.session.add(user)
db.session.commit()
else:
return error_response(400, 'User already exists with that email')
return success_response()
def remove_comment(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
comment_id = args['comment_id']
comment = Comment.query.filter_by(id=comment_id).filter_by(host_id=user_id).first()
if not comment:
return error_response(400, 'Comment does not exist')
db.session.delete(comment)
db.session.commit()
return success_response()
def get_flicks_list_details(args):
user = User.query.get(args['user_id'])
if not user:
return error_response(400, 'User does not exist')
flickslist = db.session.query(FlicksList) \
.options(joinedload('items').joinedload('movie')) \
.filter(FlicksList.owner_id == user.id).first()
response = {}
for k, v in flickslist.get_list_details().iteritems():
response[k] = v
return success_response(results=response)
def register(args):
if User.query.filter_by(email=args['email']).first():
return error_response(400, 'User with that email already exists')
elif User.query.filter_by(username=args['username']).first():
return error_response(400, 'User with that username already exists')
user = User(email=args['email'], username=args['username'])
user.set_password(password=args['password'])
db.session.add(user)
db.session.commit()
send_welcome_email(recipient=args['email'],
username=user.username,
token=user.generate_confirm_token())
return success_response()
def remove_recommendation(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
recommendation = Recommendation.query.get(args['recommendation_id'])
if not recommendation:
return error_response(400, 'Recommendation does not exist')
elif recommendation.author_id != user_id:
return error_response(400, 'Recommendation does not belong to user')
db.session.delete(recommendation)
db.session.commit()
return success_response()
def remove_movie_review(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
review = Review.query.get(args['review_id'])
if not review:
return error_response(400, 'Review does not exist')
elif review.author_id != user_id:
return error_response(400, 'Review does not belong to user')
db.session.delete(review)
db.session.commit()
return success_response()
def post_comment(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
host = User.query.get(args['host_id'])
if not host:
return error_response(400, 'User does not exist')
comment = Comment(author_id=user_id, host_id=args['host_id'], body=args['body'])
db.session.add(comment)
db.session.commit()
return success_response(comment_id=comment.id)
def get_custom_lists(args):
user = User.query.get(args['user_id'])
if not user:
return error_response(400, 'User does not exist')
custom_lists = db.session.query(CustomList.name, func.count(CustomListItem.id).label('num_items')) \
.outerjoin(CustomListItem) \
.filter(CustomList.owner_id == user.id) \
.group_by(CustomList.name).all()
response = {
'items': [{
'name': l.name,
'num_items': l.num_items
} for l in custom_lists]
}
return success_response(**response)
def get_movie_details(args):
movie = Movie.query.get(args['movie_id'])
if not movie:
return error_response(400, 'Movie does not exist')
response = {}
# Add movie related data
for k, v in movie.get_movie_metadata().items():
response[k] = v
# Add 2 most recent reviews
reviews = db.session.query(Review, User) \
.join(User) \
.filter(Review.movie_id == args['movie_id']) \
.order_by(Review.timestamp).limit(2)
response['reviews'] = [{
'author': user.username,
'body': review.body,
'timestamp': review.timestamp
} for review, user in reviews]
# Add 2 most recent recommendations
recommendations = db.session.query(Recommendation, User, Movie) \
.join(User, Recommendation.author_id == User.id) \
.join(Movie, Recommendation.recommendation_to == Movie.id) \
.filter(Recommendation.recommendation_from == movie.id) \
.order_by(Recommendation.timestamp).limit(2)
response['recommendations'] = [{
'author': user.username,
'body': recommendation.body,
'movie_title': movie.title,
'poster_path': movie.poster_path,
'movie_id': movie.id
} for recommendation, user, movie in recommendations]
# Add movie metadata
response['metadata'] = movie.get_movie_statistics()
return success_response(**response)
def send_friend_request(args):
user_id = get_jwt_identity()
friendee_id = args['user_id']
user = User.query.get(user_id)
friendee = User.query.get(friendee_id)
if not user:
return error_response(400, "User does not exist")
elif not friendee:
return error_response(400, "Friend does not exist")
elif user_id == friendee_id:
return error_response(400, "Cannot befriend self")
to_friendship = db.session.query(Friendship) \
.filter(Friendship.user_id == user_id) \
.filter(Friendship.friend_id == friendee_id) \
.first()
if to_friendship and not to_friendship.active:
return error_response(400, "Request already sent")
elif to_friendship and to_friendship.active:
return error_response(400, "Friendship already exists")
from_friendship = db.session.query(Friendship) \
.filter(Friendship.user_id == friendee_id) \
.filter(Friendship.friend_id == user_id) \
.filter(Friendship.active == 0) \
.first()
# They've already sent us an invite, create friendship
if from_friendship:
from_friendship.active = 1
to_friendship = Friendship(user_id=user_id, friend_id=friendee_id, active=1)
db.session.add(from_friendship)
db.session.add(to_friendship)
# Otherwise, send invite
else:
invite = Friendship(user_id=user_id, friend_id=friendee_id, active=0)
db.session.add(invite)
db.session.commit()
return success_response()
def edit_custom_list(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
custom_list = CustomList.query.get(args['list_id'])
if not custom_list:
return error_response(400, 'List does not exist')
elif custom_list.owner_id != user_id:
return error_response(400, 'List does not belong to user')
custom_list.private = args['private']
custom_list.description = args['description']
db.session.add(custom_list)
db.session.commit()
return success_response()
