def delete(self, movie_hash_id):
movie = MovieModel.query.get(decode_str_to_id(movie_hash_id))
if not movie:
return error(ErrorCode.MOVIE_NOT_FOUND, 404)
sql_db.session.delete(movie)
sql_db.session.commit()
return ok("Deleted This Movie Successfully!")
def post(self, rating_hash_id):
this_rating = RatingModel.query.get(decode_str_to_id(rating_hash_id))
if not this_rating:
return error(ErrorCode.RATING_NOT_FOUND, 404)
parser = reqparse.RequestParser()
parser.add_argument(
"cate",
choices=["like", "unlike", "report"],
required=True,
location="form",
type=str,
)
args = parser.parse_args()
if args.cate == "like":
f = this_rating.like_by(g.current_user)
if f:
sql_db.session.commit()
return ok("点赞成功", http_status_code=201)
else:
return error(ErrorCode.RATING_LIKE_ALREADY_EXISTS, 403)
if args.cate == "unlike":
f = this_rating.unlike_by(g.current_user)
if f:
sql_db.session.commit()
return ok("取消点赞成功", http_status_code=201)
else:
return error(ErrorCode.RATING_LIKE_NOT_FOUND, 403)
if args.cate == "report":
f = this_rating.report_by(g.current_user)
if f:
sql_db.session.commit()
return ok("举报评论成功", http_status_code=201)
else:
return error(ErrorCode.RATING_REPORT_FORBIDDEN, 403)
def delete(self, celebrity_hash_id):
celebrity = CelebrityModel.query.get(
decode_str_to_id(celebrity_hash_id))
if not celebrity:
return error(ErrorCode.CELEBRITY_NOT_FOUND, 404)
sql_db.session.delete(celebrity)
sql_db.session.commit()
return ok("已删除该艺人")
def delete(self, movie_hash_id):
this_movie = MovieModel.query.get(decode_str_to_id(movie_hash_id))
this_user = g.current_user
if not this_movie:
return error(ErrorCode.MOVIE_NOT_FOUND, 404)
this_user.delete_rating_on(this_movie)
sql_db.session.commit()
return ok("Deleted This Rating Successfully!")
def delete(self, rating_hash_id):
this_rating = RatingModel.query.get(decode_str_to_id(rating_hash_id))
if not this_rating:
return error(ErrorCode.RATING_NOT_FOUND, 404)
this_user = g.current_user
if this_rating == this_rating.user or this_user.check_permission(
"HANDLE_REPORT"):
sql_db.session.delete(this_rating)
sql_db.session.commit()
return ok("删除成功")
else:
return error(ErrorCode.RATING_DELETE_FORBIDDEN, 403)
def patch(self, celebrity_hash_id):
celebrity = CelebrityModel.query.get(
decode_str_to_id(celebrity_hash_id))
if not celebrity:
return error(ErrorCode.CELEBRITY_NOT_FOUND, 404)
parser = reqparse.RequestParser()
parser.add_argument("douban_id",
type=inputs.regex("^[0-9]{0,10}$"),
location="form")
parser.add_argument("image",
required=False,
type=FileStorage,
location="files")
parser.add_argument("name", required=True, location="form")
parser.add_argument("gender",
required=True,
choices=["male", "female"],
location="form")
parser.add_argument("name_en", default="", type=str, location="form")
parser.add_argument("born_place",
default="",
type=str,
location="form")
parser.add_argument("aka", location="form")
parser.add_argument("aka_en", location="form")
args = parser.parse_args()
if args.aka:
args.aka = args.aka.strip()[:len(args.aka.strip()) - 1].split("/")
if args.aka_en:
args.aka_en = args.aka_en.strip()[:len(args.aka_en.strip()) -
1].split("/")
if args.gender == "male":
args.gender = GenderType.MALE
else:
args.gender = GenderType.FEMALE
if args.image:
image = Image.create_one(args.image)
celebrity.image = image
celebrity.name = args.name
celebrity.gender = args.gender
celebrity.douban_id = args.douban_id
if args.born_place:
celebrity.born_place = args.born_place
celebrity.name_en = args.name_en
celebrity.aka_list = ("/".join(args.aka), )
celebrity.aka_en_list = ("/".join(args.aka_en), )
try:
sql_db.session.commit()
except IntegrityError:
return error(ErrorCode.CELEBRITY_ALREADY_EXISTS, 403)
return ok("Celebrity Updated", http_status_code=200)
def post(self, movie_hash_id):
parser = reqparse.RequestParser()
parser.add_argument(
"interest",
type=int,
choices=[RatingType.COLLECT, RatingType.WISH, RatingType.DO],
required=True,
location="form",
)
parser.add_argument(
"score",
type=inputs.positive,
choices=[i for i in range(0, 11)],
default=0,
location="form",
)
parser.add_argument("tags",
type=inputs.regex("^.{0,512}$"),
location="form")
parser.add_argument("comment",
type=inputs.regex("^.{0,128}$"),
location="form")
args = parser.parse_args()
this_movie = MovieModel.query.get(decode_str_to_id(movie_hash_id))
this_user = g.current_user
if not this_movie:
return error(ErrorCode.MOVIE_NOT_FOUND, 404)
f = False
if args.interest == RatingType.WISH:
f = this_user.wish_movie(this_movie,
comment=args.comment,
tags_name=args.tags.split(" "))
if args.interest == RatingType.DO:
f = this_user.do_movie(
this_movie,
score=args.score,
comment=args.comment,
tags_name=args.tags.split(" "),
)
if args.interest == RatingType.COLLECT:
f = this_user.collect_movie(
this_movie,
score=args.score,
comment=args.comment,
tags_name=args.tags.split(" "),
)
if f:
print(1)
sql_db.session.commit()
return ok("Rating This Movie Successfully")
return error(ErrorCode.RATING_ALREADY_EXISTS, 403)
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):
celebrity = CelebrityModel.query.get(
decode_str_to_id(celebrity_hash_id))
if not celebrity:
return error(ErrorCode.CELEBRITY_NOT_FOUND, 404)
return ok("ok", data=marshal(celebrity, celebrity_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, image_hash_id):
image = Image.query.get(decode_str_to_id(image_hash_id))
if not image:
abort(404)
image_file = base64.b64decode(image.image)
return Response(image_file, mimetype="image/jpeg")
def patch(self):
parser = reqparse.RequestParser()
parser.add_argument("movie_id",
type=str,
location="form",
required=True)
parser.add_argument("douban_id",
type=inputs.regex("^[0-9]{0,10}$"),
location="form")
parser.add_argument("title", type=str, required=True, location="form")
parser.add_argument("subtype",
choices=["movie", "tv"],
required=True,
location="form")
parser.add_argument("year", type=int, required=True, location="form")
parser.add_argument("image",
required=False,
type=FileStorage,
location="files")
parser.add_argument("countries",
required=True,
type=str,
location="form")
parser.add_argument("genres_name",
required=True,
type=str,
location="form")
parser.add_argument("original_title", type=str, location="form")
parser.add_argument("summary",
required=True,
type=str,
location="form")
parser.add_argument("aka", type=str, location="form")
parser.add_argument(
"cinema_status",
default=MovieCinemaStatus.FINISHED,
type=int,
choices=[
MovieCinemaStatus.FINISHED,
MovieCinemaStatus.COMING,
MovieCinemaStatus.SHOWING,
],
)
parser.add_argument("director_ids",
required=True,
type=str,
location="form")
parser.add_argument("celebrities_ids",
required=True,
type=str,
location="form")
parser.add_argument("seasons_count", type=int, location="form")
parser.add_argument("episodes_count", type=int, location="form")
parser.add_argument("current_season", type=int, location="form")
args = parser.parse_args()
movie = MovieModel.query.get(decode_str_to_id(args.movie_id))
if not movie:
return error(ErrorCode.MOVIE_NOT_FOUND, 404)
if args.subtype == "movie":
args.seasons_count = args.episodes_count = args.current_season = None
if args.aka:
args.aka = args.aka.strip().split("/")
if args.genres_name:
args.genres_name = args.genres_name.strip().split(" ")
if args.countries:
args.countries = args.countries.strip().split(" ")
directors_obj = Celebrity.query.filter(
Celebrity.id.in_([
decode_str_to_id(hash_id)
for hash_id in args.director_ids.split(" ")
if args.director_ids
]))
celebrities_obj = Celebrity.query.filter(
Celebrity.id.in_([
decode_str_to_id(hash_id)
for hash_id in args.celebrities_ids.split(" ")
if args.celebrities_ids
]))
if args.image:
image = Image.create_one(args.image)
movie.title = args.title
movie.subtype = args.subtype
if args.image:
movie.image = image
movie.year = args.year
movie.douban_id = args.douban_id
movie.original_title = args.original_title
movie.seasons_count = args.seasons_count
movie.episodes_count = args.episodes_count
movie.current_season = args.current_season
movie.summary = args.summary
movie.cinema_status = args.cinema_status
movie.aka_list = "/".join(args.aka)
movie.genres.clear()
movie.countries.clear()
movie.directors.clear()
movie.celebrities.clear()
for genre_name in args.genres_name:
genre_obj = Genre.create_one(genre_name)
movie.genres.append(genre_obj)
for country_name in args.countries:
country_obj = Country.create_one(country_name)
movie.countries.append(country_obj)
movie.directors += directors_obj
movie.celebrities += celebrities_obj
try:
sql_db.session.commit()
except IntegrityError:
return error(ErrorCode.MOVIE_ALREADY_EXISTS, 403)
return ok("Movie Updated!", http_status_code=200)
def post(self):
parser = reqparse.RequestParser()
parser.add_argument("douban_id",
type=inputs.regex("^[0-9]{0,10}$"),
location="form")
parser.add_argument("title", type=str, required=True, location="form")
parser.add_argument("subtype",
choices=["movie", "tv"],
required=True,
location="form")
parser.add_argument("year", type=int, required=True, location="form")
parser.add_argument("image",
required=True,
type=FileStorage,
location="files")
parser.add_argument("countries",
required=True,
type=str,
location="form")
parser.add_argument("genres_name",
required=True,
type=str,
location="form")
parser.add_argument("original_title", type=str, location="form")
parser.add_argument("summary",
required=True,
type=str,
location="form")
parser.add_argument("aka", type=str, location="form")
parser.add_argument(
"cinema_status",
default=MovieCinemaStatus.FINISHED,
type=int,
choices=[
MovieCinemaStatus.FINISHED,
MovieCinemaStatus.COMING,
MovieCinemaStatus.SHOWING,
],
)
parser.add_argument("director_ids",
required=True,
type=str,
location="form")
parser.add_argument("celebrities_ids",
required=True,
type=str,
location="form")
parser.add_argument("seasons_count", type=int, location="form")
parser.add_argument("episodes_count", type=int, location="form")
parser.add_argument("current_season", type=int, location="form")
args = parser.parse_args()
if args.subtype == "movie":
args.seasons_count = args.episodes_count = args.current_season = None
if args.aka:
args.aka = args.aka.split("/")
if args.genres_name:
args.genres_name = args.genres_name.split(" ")
if args.countries:
args.countries = args.countries.split(" ")
directors_obj = Celebrity.query.filter(
Celebrity.id.in_([
decode_str_to_id(hash_id)
for hash_id in args.director_ids.split(" ")
if args.director_ids
]))
celebrities_obj = Celebrity.query.filter(
Celebrity.id.in_([
decode_str_to_id(hash_id)
for hash_id in args.celebrities_ids.split(" ")
if args.celebrities_ids
]))
image = Image.create_one(args.image)
movie = MovieModel.create_one(
title=args.title,
subtype=args.subtype,
image=image,
year=args.year,
douban_id=args.douban_id,
original_title=args.original_title,
seasons_count=args.seasons_count,
episodes_count=args.episodes_count,
current_season=args.current_season,
summary=args.summary,
cinema_status=args.cinema_status,
aka_list=args.aka,
genres_name=args.genres_name,
countries_name=args.countries,
directors_obj=directors_obj,
celebrities_obj=celebrities_obj,
)
if movie:
sql_db.session.add(movie)
sql_db.session.commit()
return ok("Movie Created!", http_status_code=201)
else:
return error(ErrorCode.MOVIE_ALREADY_EXISTS, 403)
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, movie_hash_id):
movie = MovieModel.query.get(decode_str_to_id(movie_hash_id))
if not movie:
return error(ErrorCode.MOVIE_NOT_FOUND, 404)
return ok("ok", data=marshal(movie, movie_resource_fields))
