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, 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, 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( "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): 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)