def get(self):
parser = reqparse.RequestParser()
parser.add_argument(
"cate",
required=True,
choices=["movie", "people", "celebrity"],
location="args",
)
parser.add_argument("q", required=True, type=str, location="args")
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
if args.cate == "movie":
items, total = Movie.search(args.q, args.page, args.per_page)
elif args.cate == "people":
items, total = User.search(args.q, args.page, args.per_page)
else:
items, total = Celebrity.search(args.q, args.page, args.per_page)
pagination = Pagination("", args.page, args.per_page, total, items)
p = get_item_pagination(pagination,
"api.Search",
cate=args.cate,
q=args.q)
if args.cate == "movie":
return ok(
"ok",
marshal(
p,
get_pagination_resource_fields(
movie_summary_resource_fields)),
)
elif args.cate == "people":
return ok(
"ok",
marshal(p,
get_pagination_resource_fields(user_resource_fields)))
else:
return ok(
"ok",
marshal(
p,
get_pagination_resource_fields(
celebrity_summary_resource_fields)),
)
def get(self, type_name):
parser = reqparse.RequestParser()
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
if type_name == "friendship":
pagination = (g.current_user.notifications_received.filter_by(
category=NotificationType.FOLLOW).order_by(
NotificationModel.created_at.desc()).paginate(
args.page, args.per_page))
elif type_name == "like":
pagination = (g.current_user.notifications_received.filter_by(
category=NotificationType.RATING_ACTION).order_by(
NotificationModel.created_at.desc()).paginate(
args.page, args.per_page))
else:
return error(ErrorCode.INVALID_PARAMS, 403)
for notification in pagination.items:
notification.is_read = True
sql_db.session.commit()
p = get_item_pagination(pagination,
"api.Notification",
type_name=type_name)
return ok(
"ok",
data=marshal(
p,
get_pagination_resource_fields(notification_resource_fields)),
)
def get(self):
parser = reqparse.RequestParser()
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
s = (sql_db.session.query(
rating_reports.c.rating_id,
func.count("*").label("report_count")).group_by(
rating_reports.c.rating_id).subquery())
pagination = (sql_db.session.query(RatingModel).outerjoin(
s, RatingModel.id == s.c.rating_id).order_by(
s.c.report_count.desc()).paginate(args.page, args.per_page))
p = get_item_pagination(pagination, "api.ReportedRating")
return ok(
"ok",
data=marshal(
p,
get_pagination_resource_fields(
rating_with_movie_summary_resource_fields),
),
)
def get(self, coming_or_showing):
parser = reqparse.RequestParser()
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
if coming_or_showing.lower() not in ["coming", "showing"]:
return error(ErrorCode.INVALID_PARAMS, 400)
if coming_or_showing.lower() == "coming":
pagination = (MovieModel.query.filter_by(
cinema_status=MovieCinemaStatus.COMING).order_by(
MovieModel.created_at.desc()).paginate(
page=args["page"], per_page=args.per_page))
elif coming_or_showing.lower() == "showing":
pagination = (MovieModel.query.filter_by(
cinema_status=MovieCinemaStatus.SHOWING).order_by(
MovieModel.created_at.desc()).paginate(
page=args["page"], per_page=args.per_page))
p = get_item_pagination(pagination,
"api.CinemaMovie",
coming_or_showing=coming_or_showing)
return ok(
"ok",
data=marshal(
p,
get_pagination_resource_fields(movie_summary_resource_fields)),
)
def get(self, time_range):
if time_range not in ["week", "month"]:
return error(ErrorCode.INVALID_PARAMS, 400)
parser = reqparse.RequestParser()
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
if time_range == "week":
days = 7
else:
days = 30
movie_ids, total = get_rank_movie_ids_with_range(
days, args.page, args.per_page)
movies = MovieModel.query.filter(MovieModel.id.in_(movie_ids)).all()
pagination = Pagination("", args.page, args.per_page, total, movies)
p = get_item_pagination(pagination,
"api.LeaderBoard",
time_range=time_range)
return ok(
"ok",
data=marshal(
p,
get_pagination_resource_fields(movie_summary_resource_fields)),
)
def get(self, username, follower_or_following):
if follower_or_following.lower() not in ["follower", "following"]:
return error(ErrorCode.INVALID_PARAMS, 400)
parser = reqparse.RequestParser(trim=True)
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
this_user = UserModel.query.filter_by(username=username).first()
if not this_user:
return error(ErrorCode.USER_NOT_FOUND, 404)
if follower_or_following.lower() == "follower":
pagination = this_user.followers.paginate(args.page, args.per_page)
if follower_or_following.lower() == "following":
pagination = this_user.followed.paginate(args.page, args.per_page)
p = get_item_pagination(
pagination,
"api.Follow",
username=username,
follower_or_following=follower_or_following,
)
return ok("ok",
data=marshal(
p, get_pagination_resource_fields(user_resource_fields)))
def get(self):
parser = reqparse.RequestParser()
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
recommend_movies_id = item_cf_recommendation(g.current_user.id, 10)
if (Rating.query.filter_by(user_id=g.current_user.id).count() < 10
or not recommend_movies_id):
score_stmt = (sql_db.session.query(
Rating.movie_id.label("movie_id"),
func.avg(Rating.score).label("avg_score"),
).filter(Rating.category == RatingType.COLLECT).group_by(
Rating.movie_id).order_by(desc("avg_score")).subquery())
watched_movies_id = [
rating.movie_id
for rating in Rating.query.filter_by(user_id=g.current_user.id)
]
pagination = (sql_db.session.query(MovieModel).outerjoin(
score_stmt, MovieModel.id == score_stmt.c.movie_id).filter(
~MovieModel.id.in_(watched_movies_id)).order_by(
score_stmt.c.avg_score.desc()).paginate(
args.page, args.per_page))
else:
movies = MovieModel.query.filter(
MovieModel.id.in_(recommend_movies_id[(args.page - 1) *
args.per_page:args.page *
args.per_page]))
pagination = Pagination("", args.page, args.per_page,
len(recommend_movies_id), movies)
p = get_item_pagination(pagination, "api.MovieRecommend")
return ok(
"ok",
data=marshal(
p,
get_pagination_resource_fields(movie_summary_resource_fields)),
)
def get(self):
parser = reqparse.RequestParser()
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
s = g.current_user.followed.subquery()
pagination = (sql_db.session.query(Rating).join(
s, Rating.user_id == s.c.id).order_by(
Rating.created_at.desc()).paginate(args.page, args.per_page))
p = get_item_pagination(pagination, "api.FollowFeed")
return ok(
"ok",
data=marshal(
p,
get_pagination_resource_fields(
rating_with_movie_resource_fields)),
)
def get(self, genre_hash_id):
parser = reqparse.RequestParser()
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
genre_id = decode_str_to_id(genre_hash_id)
genre = Genre.query.get(genre_id)
if not genre:
return error(ErrorCode.GENRES_NOT_FOUND, 404)
score_stmt = (sql_db.session.query(
Rating.movie_id.label("movie_id"),
func.avg(Rating.score).label("avg_score"),
).filter(Rating.category == RatingType.COLLECT).group_by(
Rating.movie_id).order_by(desc("avg_score")).subquery())
movies = MovieModel.query.filter(
MovieModel.genres.contains(genre)).subquery()
pagination = (sql_db.session.query(MovieModel).outerjoin(
score_stmt, MovieModel.id == score_stmt.c.movie_id).filter(
MovieModel.id == movies.c.id).order_by(
score_stmt.c.avg_score.desc()).paginate(
args.page, args.per_page))
p = get_item_pagination(pagination,
"api.MovieGenresRank",
genre_hash_id=genre_hash_id)
return ok(
"ok",
data=marshal(
p,
get_pagination_resource_fields(movie_summary_resource_fields)),
)
def get(self, celebrity_hash_id):
this_celebrity = CelebrityModel.query.get(
decode_str_to_id(celebrity_hash_id))
if not this_celebrity:
return error(ErrorCode.CELEBRITY_NOT_FOUND, 404)
parser = reqparse.RequestParser()
parser.add_argument("cate",
type=str,
choices=["director", "celebrity"],
location="args")
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
director_pagination = this_celebrity.director_movies.order_by(
Movie.year.desc()).paginate(args.page, args.per_page)
director_p = get_item_pagination(
director_pagination,
"api.CelebrityMovie",
celebrity_hash_id=celebrity_hash_id,
cate=args.cate,
)
celebrity_pagination = this_celebrity.celebrity_movies.order_by(
Movie.year.desc()).paginate(args.page, args.per_page)
celebrity_p = get_item_pagination(
celebrity_pagination,
"api.CelebrityMovie",
celebrity_hash_id=celebrity_hash_id,
cate=args.cate,
)
if args.cate:
if args.cate == "director":
return ok(
"ok",
data=marshal(
director_p,
get_pagination_resource_fields(
movie_summary_resource_fields),
),
)
else:
return ok(
"ok",
data=marshal(
celebrity_p,
get_pagination_resource_fields(
movie_summary_resource_fields),
),
)
else:
return ok(
"ok",
data={
"directed":
marshal(
director_p,
get_pagination_resource_fields(
movie_summary_resource_fields),
),
"celebrity":
marshal(
celebrity_p,
get_pagination_resource_fields(
movie_summary_resource_fields),
),
},
)
def get(self, movie_hash_id):
this_movie = MovieModel.query.get(decode_str_to_id(movie_hash_id))
if not this_movie:
return error(ErrorCode.MOVIE_NOT_FOUND, 404)
parser = reqparse.RequestParser()
parser.add_argument("category", choices=["wish", "do", "collect"])
parser.add_argument("sort",
default="new",
choices=["hot", "new"],
type=str,
location="args")
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
if not args.category:
if args.sort == "new":
pagination = this_movie.ratings.order_by(
Rating.created_at.desc()).paginate(args.page,
args.per_page)
else:
s = (sql_db.session.query(
rating_likes.c.rating_id,
func.count("*").label("like_count")).group_by(
rating_likes.c.rating_id).subquery())
m = this_movie.ratings.subquery()
pagination = (sql_db.session.query(Rating).outerjoin(
s, Rating.id == s.c.rating_id).filter(
Rating.id == m.c.id).order_by(
s.c.like_count.desc()).paginate(
args.page, args.per_page))
p = get_item_pagination(pagination,
"api.MovieUserRating",
movie_hash_id=movie_hash_id)
return ok(
"ok",
data=marshal(
p, get_pagination_resource_fields(rating_resource_fields)),
)
cate = None
if args.category == "wish":
cate = RatingType.WISH
elif args.category == "do":
cate = RatingType.DO
elif args.category == "collect":
cate = RatingType.COLLECT
if args.sort == "new":
pagination = (this_movie.ratings.filter(
Rating.category == cate).order_by(
Rating.created_at.desc()).paginate(args.page,
args.per_page))
else:
s = (sql_db.session.query(
rating_likes.c.rating_id,
func.count("*").label("like_count")).group_by(
rating_likes.c.rating_id).subquery())
m = this_movie.ratings.subquery()
pagination = (sql_db.session.query(Rating).outerjoin(
s,
Rating.id == s.c.rating_id).filter(Rating.id == m.c.id).filter(
Rating.category == cate).order_by(
s.c.like_count.desc()).paginate(
args.page, args.per_page))
p = get_item_pagination(pagination,
"api.MovieUserRating",
movie_hash_id=movie_hash_id)
return ok(
"ok",
data=marshal(
p, get_pagination_resource_fields(rating_resource_fields)),
)
def get(self):
parser = reqparse.RequestParser()
parser.add_argument(
"subtype",
default=None,
type=str,
choices=["tv", "movie", ""],
location="args",
)
parser.add_argument("genre_name",
default=None,
type=str,
location="args")
parser.add_argument("country_name",
default=None,
type=str,
location="args")
parser.add_argument("year", default=None, type=str, location="args")
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
query = MovieModel.query
if args.genre_name:
genre = Genre.query.filter_by(genre_name=args.genre_name).first()
if genre:
query = query.filter(MovieModel.genres.contains(genre))
if args.country_name:
country = Country.query.filter_by(
country_name=args.country_name).first()
if country:
query = query.filter(MovieModel.countries.contains(country))
if args.subtype:
query = query.filter_by(subtype=args.subtype)
if args.year:
query = query.filter_by(year=args.year)
score_stmt = (sql_db.session.query(
Rating.movie_id.label("movie_id"),
func.avg(Rating.score).label("avg_score"),
).filter(Rating.category == RatingType.COLLECT).group_by(
Rating.movie_id).order_by(desc("avg_score")).subquery())
movies = query.subquery()
pagination = (sql_db.session.query(MovieModel).outerjoin(
score_stmt, MovieModel.id == score_stmt.c.movie_id).filter(
MovieModel.id == movies.c.id).order_by(
score_stmt.c.avg_score.desc()).order_by(
MovieModel.year.desc()).paginate(
args.page, args.per_page))
p = get_item_pagination(
pagination,
"api.ChoiceMovie",
subtype=args.subtype,
genre_hash_id=args.genre_name,
country_hash_id=args.country_name,
year=args.year,
)
return ok(
"ok",
data=marshal(
p,
get_pagination_resource_fields(movie_summary_resource_fields)),
)
def get(self, username):
this_user = User.query.filter_by(username=username).first()
if not this_user:
return error(ErrorCode.USER_NOT_FOUND, 404)
parser = reqparse.RequestParser()
parser.add_argument("type_name",
type=str,
choices=["wish", "do", "collect"],
location="args")
parser.add_argument("page",
default=1,
type=inputs.positive,
location="args")
parser.add_argument("per_page",
default=20,
type=inputs.positive,
location="args")
args = parser.parse_args()
if args.type_name:
if args.type_name == "wish":
rating_paginate = this_user.ratings.filter(
Rating.category == RatingType.WISH).paginate(
args.page, args.per_page)
elif args.type_name == "do":
rating_paginate = this_user.ratings.filter(
Rating.category == RatingType.DO).paginate(
args.page, args.per_page)
elif args.type_name == "collect":
rating_paginate = this_user.ratings.filter(
Rating.category == RatingType.COLLECT).paginate(
args.page, args.per_page)
p = get_item_pagination(rating_paginate,
"api.UserMovie",
username=username)
return ok(
"ok",
data=marshal(
p,
get_pagination_resource_fields(
rating_with_movie_resource_fields)),
)
else:
wish_rating_paginate = this_user.ratings.filter(
Rating.category == RatingType.WISH).paginate(
args.page, args.per_page)
do_rating_paginate = this_user.ratings.filter(
Rating.category == RatingType.DO).paginate(
args.page, args.per_page)
collect_rating_paginate = this_user.ratings.filter(
Rating.category == RatingType.COLLECT).paginate(
args.page, args.per_page)
wish_p = get_item_pagination(wish_rating_paginate,
"api.UserMovie",
username=username)
do_p = get_item_pagination(do_rating_paginate,
"api.UserMovie",
username=username)
collect_p = get_item_pagination(collect_rating_paginate,
"api.UserMovie",
username=username)
data = {
"wish_movies":
marshal(
wish_p,
get_pagination_resource_fields(
rating_with_movie_resource_fields),
),
"do_movies":
marshal(
do_p,
get_pagination_resource_fields(
rating_with_movie_resource_fields),
),
"collect_movies":
marshal(
collect_p,
get_pagination_resource_fields(
rating_with_movie_resource_fields),
),
}
return ok("ok", data=data)
