def add_movie_to_favorite(user_id, movie_id):
movie = Movie.query.get(movie_id)
user = User.query.get(user_id)
if movie is None or user is None:
return create_response(400, "Invalid request")
favorite = Favorite.query.filter_by(
user_id=user_id, movie_id=movie.id).first()
if favorite is None:
f = Favorite(user_id=user_id, movie_id=movie.id)
db.session.add(f)
logger = Logger(user_id=user_id, action_type_id=8, movie_id=movie_id)
logger.create_log()
else:
db.session.delete(favorite)
logger = Logger(user_id=user_id, action_type_id=9, movie_id=movie_id)
logger.create_log()
db.session.commit()
return create_response(200, "Success")
def auth_register():
data = request.get_json()
email = data.get("email", "")
password = data.get("password", "")
valid_email = re.search(
"^(([^<>()[\]\\.,;:\s@“]+(\.[^<>()[\]\\.,;:\s@“]+)*)|(“.+“))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$",
email)
valid_password = len(password) >= 6 and len(password) <= 15
if valid_password and valid_email:
if not user_existed(email):
u = User(email=email)
u.hash_password(password)
db.session.add(u)
db.session.flush()
db.session.commit()
data = create_token(u)
logger = Logger(user_id=u.id, action_type_id=1)
logger.create_log()
return create_response(201,
"Create account successfully",
data=data)
else:
return create_response(400, "Email is already taken")
else:
return create_response(400, "Request info is not valid")
def actor_get_movies(id, page, user_id):
page_size = app.config['PAGE_SIZE']
user = User.query.get(user_id)
if user is None:
return create_response(400, 'Invalid request!')
cast = Cast.query.get(id)
movie_ids = CreditCasts.query\
.filter_by(cast_id=id)\
.paginate(page, page_size, error_out=False)
total = CreditCasts.query.filter_by(cast_id=id).count()
has_more = True if total > page * page_size else False
movies = []
for movie in movie_ids.items:
res = get_movie(movie.movie_id, user_id)
movies.append(res)
response = {'name': cast.name, 'has_more': has_more, 'list': movies}
return create_response(200, 'Success.', response)
def movie_rating(id, user_id, rated):
# query from request info
movie = Movie.query.get(id)
if movie is None:
return create_response(400, "Movie is not exist")
rating = Rating.query.filter_by(movie_id=movie.id, user_id=user_id).first()
logger = Logger(user_id=user_id,
action_type_id=5,
movie_id=id,
rating=rated)
logger.create_log()
if rating is None:
r = Rating(rating=rated, user_id=user_id, movie_id=movie.id)
db.session.add(r)
else:
rating.rating = rated
rating.timestamp = datetime.datetime.utcnow()
db.session.add(rating)
db.session.flush()
new_rating = calc_rating(id)
movie.rating = new_rating
db.session.add(movie)
db.session.commit()
return create_response(200, "Rate film successfully")
def movie_get_similar(id):
movie = Movie.query.get(id)
if movie is None:
return create_response(400, 'Movie is not exist')
movies = get_recommendations(movie.title)
similars = []
for index, row in movies.iterrows():
movie_id = row['id']
mov = Movie.query.get(movie_id)
genres = Genre.query\
.join(MovieGenres, MovieGenres.genre_id == Genre.id)\
.filter(MovieGenres.movie_id == movie_id)\
.limit(3).all()
mov_genres = [gen.name for gen in genres]
similars.append({
'id': movie_id,
'title': mov.title,
'img': mov.poster_path,
'rating': round(mov.rating, 1),
'certification': mov.certification,
'overview': mov.overview,
'genres': mov_genres
})
return create_response(200, 'Get similar movie success', similars)
def movie_get_review(id, user_id, page):
movie = Movie.query.get(id)
user = User.query.get(user_id)
if movie is None or user is None:
return create_response(400, 'Invalid request!')
reviews = Review.query.order_by(Review.timestamp.desc()).paginate(
page, app.config['PAGE_SIZE'], error_out=False)
count = Review.query.filter_by(movie_id=id).count()
user_rate = Rating.query.filter_by(user_id=user_id, movie_id=id).first()
user_rating = user_rate.rating if user_rate is not None else 0
if len(reviews.items) == 0:
return create_response(
200, 'Success.', {
'total': 0,
'has_more': False,
'list': [],
'avatar': movie.poster_path,
'name': movie.title
})
review_list = []
for review in reviews.items:
rating = Rating.query\
.filter(Rating.movie_id == id)\
.filter(Rating.user_id == review.user_id)\
.first()
u = User.query.get(review.user_id)
review_list.append({
'headline': review.headline,
'body': review.body,
'timestamp': review.timestamp,
'rating': rating.rating,
'user': u.email
})
has_more = True if count > app.config['PAGE_SIZE'] * page else False
response = {
'total': count,
'has_more': has_more,
'list': review_list,
'avatar': movie.poster_path,
'title': movie.title,
'release_date': movie.release_date,
'runtime': movie.runtime,
'certification': movie.certification,
'user_rate': user_rating
}
return create_response(200, 'Success.', response)
def movie_get_by_id(id, user_id):
if not valid_user(user_id):
return create_response(400, "Invalid user")
if not valid_movie(id):
return create_response(404, "Movie's not existed")
res = get_movie(id, user_id)
logger = Logger(user_id=user_id, action_type_id=4, movie_id=id)
logger.create_log()
mes = "Get movie's info with id = " + str(id) + " successfully."
return create_response(200, mes, data=res)
def get_popular_movies(user_id):
page_size = app.config['PAGE_SIZE']
# get trending now
trendings = get_most_popular(user_id)
trending_now = {'rowId': 3, 'title': 'Trending Now', 'list': trendings}
return create_response(200, 'Success.', trending_now)
def refresh(id, email):
identity = Token(id, email).to_json()
expires = datetime.timedelta(hours=1)
res = {
'token': create_access_token(identity=identity, expires_delta=expires)
}
return create_response(200, "Refreshed token", data=res)
def remove_rating(id, user_id):
# query from request info
movie = Movie.query.get(id)
if movie is None:
return create_response(400, "Movie is not exist")
rating = Rating.query.filter_by(movie_id=movie.id, user_id=user_id).first()
if rating is not None:
db.session.delete(rating)
logger = Logger(user_id=user_id, action_type_id=6, movie_id=id)
logger.create_log()
db.session.commit()
return create_response(200, "Delete movie's rating successfully")
def get_user_review(id, user_id):
# query from request info
movie = Movie.query.get(id)
user = User.query.get(user_id)
if movie is None or user is None:
return create_response(400, "Invalid request")
review = Review.query.filter_by(movie_id=id, user_id=user_id).first()
res = {}
if review is not None:
res = {"headline": review.headline, "body": review.body}
else:
res = {"headline": "", "body": ""}
return create_response(200, "Success", data=res)
def genre_get_movies(id, page, user_id):
page_size = app.config['PAGE_SIZE']
user = User.query.get(user_id)
if user is None:
return create_response(400, 'Invalid request!')
if id == 0:
movie_ids = Movie.query.order_by(Movie.rating.desc(),
Movie.vote_average.desc()).paginate(
page, page_size, error_out=False)
total = Movie.query.count()
has_more = True if total > page * page_size else False
movies = []
for movie in movie_ids.items:
res = get_movie(movie.id, user_id)
movies.append(res)
response = {'has_more': has_more, 'list': movies}
return create_response(200, 'Success.', response)
elif id > 0:
movie_ids = MovieGenres.query\
.join(Movie, Movie.id == MovieGenres.movie_id)\
.filter(MovieGenres.genre_id == id)\
.order_by(Movie.rating.desc(), Movie.vote_average.desc())\
.paginate(page, page_size, error_out=False)
total = MovieGenres.query\
.join(Movie, Movie.id == MovieGenres.movie_id)\
.filter(MovieGenres.genre_id == id)\
.order_by(Movie.rating.desc(), Movie.vote_average.desc()).count()
has_more = True if total > page * page_size else False
movies = []
for movie in movie_ids.items:
res = get_movie(movie.movie_id, user_id)
movies.append(res)
response = {'has_more': has_more, 'list': movies}
return create_response(200, 'Success.', response)
def recommend(id):
user = User.query.get(id)
if user is None:
return create_response(400, "Tài khoản không tồn tại")
recommends = Recommend.query.filter_by(user_id=id).all()
if recommends is None:
return create_response(200, "Lấy danh sách thành công", [])
response = []
for rec in recommends:
data = get_movie_by_id(rec.movie_id, id)
response.append(data)
return create_response(200, "Lấy danh sách thành công", data=response)
def auth_login():
data = request.get_json()
email = data.get("email", "")
password = data.get("password", "")
user = User.query.filter_by(email=email).first()
if user is None:
return create_response(401, "Email or password is not correct")
else:
if user.check_password(password):
data = create_token(user)
logger = Logger(user_id=user.id, action_type_id=2)
logger.create_log()
return create_response(200, "Login successfully", data=data)
else:
return create_response(401, "Email or password is not correct")
def get_top_rated_movies(user_id):
page_size = app.config['PAGE_SIZE']
# get top rated movies
list_top_rated = Movie.query.order_by(Movie.rating.desc()).paginate(
1, page_size, error_out=False)
top_rateds = []
for movie in list_top_rated.items:
res = get_movie(movie.id, user_id)
top_rateds.append(res)
top_rated = {'rowId': 2, 'title': 'Top Rated', 'list': top_rateds}
return create_response(200, 'Success.', top_rated)
def get_favorite_movies(user_id):
user = User.query.get(user_id)
page_size = app.config['PAGE_SIZE']
page = 1
if user is None:
return create_response(400, "Invalid request")
favorites = Favorite.query.filter_by(
user_id=user_id).paginate(page, page_size, error_out=False)
count = Favorite.query.filter_by(user_id=user_id).count()
response = []
for favorite in favorites.items:
res = get_movie(favorite.movie_id, user_id)
response.append(res)
has_more = True if count > page_size * page else False
return create_response(200, 'Success.', { 'has_more': has_more, 'list': response })
def user_review(user_id, id, headline, body, rated):
# query from request info
movie = Movie.query.get(id)
if movie is None:
return create_response(400, "Movie is not exist")
review = Review.query.filter_by(movie_id=movie.id, user_id=user_id).first()
if review is not None:
review.headline = headline
review.body = body
db.session.add(review)
else:
r = Review(headline=headline,
body=body,
user_id=user_id,
movie_id=movie.id)
db.session.add(r)
rating = Rating.query.filter_by(movie_id=movie.id, user_id=user_id).first()
if rating is None:
r = Rating(rating=rated, user_id=user_id, movie_id=movie.id)
db.session.add(r)
else:
rating.rating = rated
rating.timestamp = datetime.datetime.utcnow()
db.session.add(rating)
logger = Logger(user_id=user_id,
action_type_id=7,
movie_id=id,
headline=headline,
body=body)
logger.create_log()
db.session.commit()
return create_response(200, "Update review for movie successfully")
def search_movie(key, page, searchType, short, user_id):
newKey = unidecode(key)
response = {'query': key}
if searchType == 'All' or searchType == 'Titles':
movies = query_movie(newKey, page, short, user_id)
response['title'] = movies
if searchType == 'Celebs' or searchType == 'All':
casts = query_cast(newKey, page, short)
response['celebs'] = casts
return create_response(200, 'Success', data=response)
def protected():
id, email = get_authorization()
return create_response(200, 'Token is valid', {'id': id, 'email': email})
def get_all_genres():
genres = Genre.query.all()
response = [{'id': genre.id, 'name': genre.name} for genre in genres]
return create_response(200, 'Success.', response)
