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 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 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 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 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 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 make_reservation(request):
ruslan_user = get_ruslan_user(request)
if not ruslan_user:
return api_responses.errors_response(u'Вы не являетесь читателем')
if request.method == 'POST':
make_reservation_form = forms.MakeReservationForm(request.POST)
if make_reservation_form.is_valid():
ncip_message = {
"RequestItem": {
"UserId": {
"AgencyId": {
"value": ORG_CODES[make_reservation_form.cleaned_data['org']]
},
"UserIdentifierValue": ruslan_user.username
},
"BibliographicId": {
"BibliographicRecordId": {
"BibliographicRecordIdentifier": make_reservation_form.cleaned_data['record_id'],
"AgencyId": {
"value": ORG_CODES[make_reservation_form.cleaned_data['org']]
}
}
},
"RequestType": {
"value": u"Hold",
"Scheme": u"http://www.niso.org/ncip/v1_0/imp1/schemes/requesttype/requesttype.scm"
},
"RequestScopeType": {
"value": u"Bibliographic Item",
"Scheme": u"http://www.niso.org/ncip/v1_0/imp1/schemes/requestscopetype/requestscopetype.scm"
},
"PickupLocation": {
"value": u'%s/%s' % (make_reservation_form.cleaned_data['org'], make_reservation_form.cleaned_data['branch'])
}
}
}
response = ruslan_client.send_ncip_message(ncip_message)
response_dict = response.json()
problem = response_dict.get('RequestItemResponse', {}).get('Problem', {})
if problem:
message = u'Ошибка при бронировании'
problem_detail = response_dict.get('RequestItemResponse', {}).get('Problem', {}).get('ProblemDetail', '');
if problem_detail.startswith('220'):
message = u'Превышен лимит заказов. Посмотреть текущие заказы можно в разделе "Мои заказы"'
return api_responses.error_response(api_errors.Error(code='220', message=message))
return api_responses.error_response(api_errors.Error(code='0', message=message))
return api_responses.response({
'status': 'ok',
})
else:
return api_responses.error_response(api_errors.FormError.from_form(name='make_reservation_form', django_form=make_reservation_form))
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 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 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 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_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 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 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 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 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 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 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_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 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()
def remove_favourites_item(args):
user_id = get_jwt_identity()
user = User.query.get(user_id)
if not user:
return error_response(400, 'User does not exist')
fav_movie = db.session.query(Favourite, Movie).join(Movie) \
.filter(Favourite.user_id == user_id) \
.filter(Favourite.movie_id == args['movie_id']).first()
if not fav_movie:
return error_response(400, 'Favourite does not exist')
favourite, movie = fav_movie
movie.num_favourites -= 1
db.session.delete(favourite)
db.session.commit()
return success_response()
def delete_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')
list_item = CustomListItem.query.get(args['list_item_id'])
if not list_item:
return error_response(400, 'List item does not exist')
elif list_item.list.owner_id != user_id:
return error_response(400, 'Item does not belong to user')
movie = Movie.query.get(list_item.movie_id)
movie.num_custom -= 1
db.session.delete(list_item)
db.session.add(movie)
db.session.commit()
return success_response()
def add_favourite_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')
elif args['movie_id'] in [fav.movie_id for fav in user.favourites]:
return error_response(400, 'Movie already exists in favourites')
elif len(user.favourites) >= 4:
return error_response(
400, 'Maximum allowable number of favourites reached (4)')
movie.num_favourites += 1
fav = Favourite(movie_id=args['movie_id'], user_id=user_id)
db.session.add(fav)
db.session.commit()
return success_response()
def delete_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')
movies = db.session.query(Movie).join(CustomListItem).filter_by(
list_id=custom_list.id).all()
# Decrement num_custom for each movie in the list
for movie in movies:
movie.num_custom -= 1
db.session.delete(custom_list)
db.session.commit()
return success_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 add_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')
movie = Movie.query.get(args['movie_id'])
if not movie:
return error_response(400, 'Movie does not exist')
flicks_list = FlicksList.query.filter_by(owner_id=user_id).options(
joinedload('items')).first()
if movie.id in [i.movie_id for i in flicks_list.items]:
return error_response(400, 'Item already present in user list')
if args['completed']:
list_item = FlicksListItem(list_id=flicks_list.id,
movie_id=movie.id,
rating=args['rating'],
completed=True,
notes=args['notes'],
completion_date=args['completion_date'])
movie.add_completed_member(rating=args['rating'])
else:
list_item = FlicksListItem(list_id=flicks_list.id,
movie_id=movie.id,
notes=args['notes'])
movie.add_ptw_member()
db.session.add(list_item)
db.session.commit()
return success_response(list_item_id=list_item.id)
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)
