def mark_as_watched():
movie_id = request.args.get('movieId')
house_id = request.args.get('houseId')
if not movie_id or not house_id:
raise CustomError("Movie ID or House ID not provided")
user = current_user()
user_movie_to_patch = next(
filter(lambda m: m.movie_id == int(movie_id), user.watchlist), None)
movie = Movie.query.get(movie_id)
house = House.query.get(house_id)
turns = house.get_current_and_next_turns()
# Check if it's actually the current user's turn
if turns['current_turn']['id'] != user.id:
raise CustomError(f"It is not {user.username}'s turn to choose")
if user_movie_to_patch is None:
raise CustomError("Movie could not be found", 404)
try:
user_movie_to_patch.watched_at = db.func.current_timestamp()
db.session.add(HouseTurns(user=user, movie=movie, house=house))
db.session.commit()
data = {'message': 'Movie marked as watched'}
return make_response(jsonify(data), 201)
except Exception as e:
payload = {'meta': str(e)}
raise CustomError("Unable to update movie as watched", 500, payload)
def create_house():
request_body = request.get_json()
if request_body is None:
raise CustomError("No house name provided in body")
user = current_user()
try:
# Only create house if one of that name doesn't already exist
if House.query.filter_by(name=request_body.get('name')).count() < 1:
new_house = House(name=request_body.get('name'))
db.session.add(new_house)
user.houses.append(UserHouses(house=new_house, user_role="admin"))
db.session.commit()
return make_response(new_house.serialize()), 201
else:
data = {'message': 'House has already been created'}
return make_response(jsonify(data), 200)
except Exception as e:
payload = {'meta': str(e)}
raise CustomError("Failed to search houses", 500, payload)
def get_movies():
api_key = current_app.config['OMDB_API_KEY']
omdb_url = f"http://www.omdbapi.com/?apikey={api_key}&type=movie"
search_params = request.args.get('search')
if not search_params:
raise CustomError("No search params provided")
try:
response = requests.get(f"{omdb_url}&s={search_params}").json()
return response
except requests.exceptions.RequestException as e:
payload = {'meta': str(e)}
raise CustomError("Failed to query OMDB api", 503, payload)
def add_to_watchlist():
user = current_user()
request_body = request.get_json()
if not request_body:
raise CustomError("No movie provided in request body")
try:
# Only add the movie to db if it doesn't already exist
request_omdb_id = request_body.get('omdb_id')
if Movie.query.filter_by(omdb_id=request_omdb_id).count() < 1:
new_movie = Movie(
name=request_body.get('name'),
omdb_id=request_body.get('omdb_id'),
poster_url=request_body.get('poster_url'),
)
db.session.add(new_movie)
# Check before adding movie to user's watchlist
movie = Movie.query.filter_by(omdb_id=request_omdb_id).first()
filtered = filter(lambda x: x.movie.omdb_id == movie.omdb_id,
user.watchlist)
movie_to_add = next(filtered, None)
# If watchlist does not contain movie, add to watchlist
if movie_to_add is None:
user.watchlist.append(UserMovies(movie))
db.session.commit()
data = {'message': 'Movie added to watchlist'}
return make_response(jsonify(data), 201)
# If it IS in watchlist, but marked as watched, then nullify watched_at
elif movie_to_add.watched_at is not None:
movie_to_add.watched_at = None
db.session.commit()
data = {'message': 'Movie added to watchlist'}
return make_response(jsonify(data), 201)
# Otherwise, movie is already in watchlist
data = {'message': 'Movie already added to watchlist'}
return make_response(jsonify(data), 200)
# Generic error handler
except Exception as e:
payload = {'meta': str(e)}
raise CustomError("Unable to add movie to watchlist", 500, payload)
def get_joined_houses():
try:
user = current_user()
joined_houses = list(h.house.serialize() for h in user.houses)
return jsonify(joined_houses)
except Exception as e:
u = user.username or 'unknown user'
payload = {'meta': str(e)}
raise CustomError(f"Failed to return houses for {u}", 500, payload)
def search_houses():
search_params = request.args.get('search')
try:
search_results = House.query.filter(
House.name.ilike(f'%{search_params}%')).all()
houses = list(h.serialize() for h in search_results)
return jsonify(houses)
except Exception as e:
payload = {'meta': str(e)}
raise CustomError("Failed to search houses", 500, payload)
def delete_from_watchlist(movie_id):
user = current_user()
movie_to_delete = next(
filter(lambda m: m.movie_id == int(movie_id), user.watchlist), None)
if movie_to_delete is None:
return '', 204
try:
user.watchlist.remove(movie_to_delete)
db.session.commit()
return '', 204
except Exception as e:
payload = {'meta': str(e)}
raise CustomError("Unable to remove movie from watchlist", 500,
payload)
def leave_house(house_id):
user = current_user()
try:
house_to_leave = House.query.get(house_id)
user_with_role = next(
filter(lambda u: u.user.id == user.id, house_to_leave.users), None)
if user_with_role is None:
raise Exception("User is not in house.")
data = {}
# If the user is the last person, delete the house
if len(house_to_leave.users) <= 1:
house_to_leave.users.remove(user_with_role)
db.session.delete(house_to_leave)
data[
'message'] = f'Successfully left and deleted {house_to_leave.name}'
# If the user is an admin, make someone else admin
elif user_with_role.user_role == 'admin':
house_to_leave.users.remove(user_with_role)
filtered = filter(lambda u: u.user.id != user.id,
house_to_leave.users)
next_user = next(filtered, None)
next_user.set_role('admin')
data[
'message'] = f'Successfully left {house_to_leave.name}. {next_user.user.username} is now admin'
# Otherwise, just leave the house
else:
house_to_leave.users.remove(user_with_role)
data['message'] = f'Successfully left {house_to_leave.name}'
db.session.commit()
updated_house = House.query.get(house_id)
if updated_house:
data['houseDetail'] = updated_house.serialize()
return make_response(jsonify(data), 200)
except Exception as e:
payload = {'meta': str(e)}
raise CustomError("Failed to leave house", 500, payload)
def join_house(house_id):
user = current_user()
try:
house_to_join = House.query.get(house_id)
filtered = filter(lambda u: u.user.id == user.id, house_to_join.users)
user_in_house = next(filtered, None)
if user_in_house:
raise Exception("User has already joined house")
house_to_join.users.append(UserHouses(user=user))
db.session.commit()
return make_response(house_to_join.serialize()), 201
except Exception as e:
payload = {'meta': str(e)}
raise CustomError("Failed to join house", 500, payload)