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 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 put(self):
"""reset password"""
parser = reqparse.RequestParser()
parser.add_argument(
"email",
type=inputs.regex("[^@]+@[^@]+\.[^@]+"),
required=True,
location="form",
)
args = parser.parse_args()
this_user = UserModel.query.filter_by(email=args.email).first()
if not this_user:
return error(ErrorCode.USER_NOT_FOUND, 404)
s = test_limit_of_send_email(this_user,
AccountOperations.RESET_PASSWORD)
if s == -2:
token = generate_email_confirm_token(
this_user.username, AccountOperations.RESET_PASSWORD)
send_reset_password_email.delay(token, this_user.email,
this_user.username)
return ok(message="请到 %s 查收邮件!" % this_user.email)
else:
return error(ErrorCode.SENDING_EMAIL_FREQUENTLY,
http_status_code=403,
second=s)
def delete(self, username, follower_or_following):
if follower_or_following.lower() != "unfollow":
return error(ErrorCode.INVALID_PARAMS, 400)
this_user = UserModel.query.filter_by(username=username).first()
if not this_user:
return error(ErrorCode.USER_NOT_FOUND, 404)
if g.current_user.unfollow(this_user):
sql_db.session.commit()
return ok(message="取消关注成功")
else:
return error(ErrorCode.FOLLOW_NOT_EXISTS, 403)
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 post(self, username, follower_or_following):
"""follow someone"""
if follower_or_following.lower() != "follow":
return error(ErrorCode.INVALID_PARAMS, 400)
this_user = UserModel.query.filter_by(username=username).first()
if not this_user:
return error(ErrorCode.USER_NOT_FOUND, 404)
if g.current_user.follow(this_user):
sql_db.session.commit()
return ok(message="关注成功", http_status_code=201)
else:
return error(ErrorCode.FOLLOW_ALREADY_EXISTS, 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 patch(self, username):
current_app.logger.info(
"modify profile of {username}".format(username=username))
parser = reqparse.RequestParser(trim=True)
parser.add_argument(
"username",
required=False,
type=inputs.regex("^[a-zA-Z0-9\_]{6,16}$"),
location="form",
)
parser.add_argument("city_id", location="form")
parser.add_argument("signature",
type=inputs.regex("^.{1,64}$"),
location="form")
parser.add_argument("avatar_file", type=FileStorage, location="files")
args = parser.parse_args()
user = g.current_user
if args.username and args.username != g.current_user.username:
if not user.change_username(args.username):
return error(ErrorCode.USER_ALREADY_EXISTS, 403)
if args.city_id:
user.city_id = args.city_id
if args.signature:
user.signature = args.signature
if args.avatar_file:
avatar = Image.create_one(args.avatar_file)
user.avatar = avatar
sql_db.session.commit()
return ok("ok", username=user.username, signature=user.signature)
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, 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 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 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, username_or_email):
parser = reqparse.RequestParser()
parser.add_argument("value", required=True, location="args")
args = parser.parse_args()
if username_or_email not in ["username", "email"]:
return error(ErrorCode.INVALID_PARAMS, 400)
if username_or_email == "username":
if UserModel.query.filter_by(username=args.value).first():
return ok("this username already existed")
else:
return error(ErrorCode.USER_NOT_FOUND, 404)
if username_or_email == "email":
if UserModel.query.filter_by(email=args.value).first():
return ok("this username already existed")
else:
return error(ErrorCode.USER_NOT_FOUND, 404)
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 post(self, operation):
parser = reqparse.RequestParser()
parser.add_argument("token", type=str, required=True, location="form")
if operation == AccountOperations.CONFIRM:
args = parser.parse_args()
f = validate_email_confirm_token(args.token,
AccountOperations.CONFIRM)
if f:
return ok("您的邮箱已确认!")
else:
return error(ErrorCode.INVALID_TOKEN, 403)
elif operation == AccountOperations.RESET_PASSWORD:
parser.add_argument(
"password",
type=inputs.regex("^[0-9a-zA-Z\_\.\!\@\#\$\%\^\&\*]{6,20}$"),
required=True,
location="form",
)
args = parser.parse_args()
if validate_email_confirm_token(args.token,
AccountOperations.RESET_PASSWORD,
new_password=args.password):
return ok("您的密码已重置")
else:
return error(ErrorCode.INVALID_TOKEN, 403)
elif operation == AccountOperations.CHANGE_EMAIL:
parser.add_argument(
"new_email",
type=inputs.regex("[^@]+@[^@]+\.[^@]+"),
required=True,
location="form",
)
args = parser.parse_args()
if UserModel.query.filter_by(email=args.new_email).first():
return error(ErrorCode.EMAIL_ALREADY_EXISTS, 403)
if validate_email_confirm_token(args.token,
AccountOperations.CHANGE_EMAIL,
new_email=args.new_email):
return ok("您的邮箱已修改, 请到新邮箱查看确认邮件！")
else:
return error(ErrorCode.INVALID_TOKEN, 403)
else:
return error(ErrorCode.INVALID_PARAMS, 403)
def get(self, username):
user = UserModel.query.filter_by(username=username).first()
if user:
return ok(
"ok",
data=marshal(user, user_resource_fields),
followed=user.is_following(g.current_user),
follow=user.is_followed_by(g.current_user),
)
else:
return error(ErrorCode.USER_NOT_FOUND, 404)
def post(self):
parser = reqparse.RequestParser(trim=True)
parser.add_argument(
"grant_type",
type=str,
choices=["password"],
help="grant_type must be in ['password'] ",
required=True,
location="form",
)
parser.add_argument(
"username",
type=inputs.regex("^[a-zA-Z0-9\_]{6,16}$"),
required=True,
help="username cannot be blank!",
location="form",
)
parser.add_argument(
"password",
type=inputs.regex("^[0-9a-zA-Z\_\.\!\@\#\$\%\^\&\*]{6,20}$"),
required=True,
help="password cannot be blank!",
location="form",
)
args = parser.parse_args()
user = UserModel.query.filter_by(username=args["username"]).first()
if not user or not user.validate_password(args["password"]):
return error(ErrorCode.USERNAME_OR_PASSWORD_ERROR, 400)
if user.is_locked:
return error(ErrorCode.ACCOUNT_IS_LOCKED, 403)
if not user.email_confirmed:
return error(ErrorCode.EMAIL_NOT_CONFIRMED, 403)
expire_in = 60 * 60 * 24
data = {
"access_token": user.generate_token(expire_in),
"token_type": "bearer",
"expires_in": expire_in,
"role": user.role_name,
}
return data, 201, {"Cache-Control": "no-store", "Pragma": "no-cache"}
def post(self):
"""resent email for confirm"""
parser = reqparse.RequestParser()
parser.add_argument(
"username",
type=inputs.regex("^[a-zA-Z0-9\_]{6,16}$"),
required=True,
location="form",
)
parser.add_argument(
"password",
type=inputs.regex("^[0-9a-zA-Z\_\.\!\@\#\$\%\^\&\*]{6,20}$"),
required=True,
location="form",
)
args = parser.parse_args()
this_user = UserModel.query.filter_by(username=args.username).first()
if not this_user:
return error(ErrorCode.USER_NOT_FOUND, 404)
if not this_user.validate_password(args.password):
return error(ErrorCode.PASSWORD_VALIDATE_ERROR, 403)
if this_user.email_confirmed:
return error(ErrorCode.EMAIL_ALREADY_CONFIRMED, 403)
s = test_limit_of_send_email(g.current_user,
AccountOperations.RESET_PASSWORD)
if s == -2:
token = generate_email_confirm_token(
g.current_user.username,
AccountOperations.CONFIRM,
email=this_user.email,
)
send_change_email_email.delay(token, g.current_user.email,
g.current_user.username)
return ok(message="请到 %s 查收邮件!" % g.current_user.email)
else:
return error(ErrorCode.SENDING_EMAIL_FREQUENTLY,
http_status_code=403,
second=s)
def put(self):
"""change email"""
s = test_limit_of_send_email(g.current_user,
AccountOperations.CHANGE_EMAIL)
if s == -2:
token = generate_email_confirm_token(
g.current_user.username, AccountOperations.CHANGE_EMAIL)
send_change_email_email.delay(token, g.current_user.email,
g.current_user.username)
return ok(message="请到 %s 查收邮件!" % g.current_user.email)
else:
return error(ErrorCode.SENDING_EMAIL_FREQUENTLY,
http_status_code=403,
second=s)
def post(self):
parser = reqparse.RequestParser()
parser.add_argument("douban_id",
type=inputs.regex("^[0-9]{0,10}$"),
location="form")
parser.add_argument("image",
required=True,
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.split("/")
if args.aka_en:
args.aka_en = args.aka_en.split("/")
if args.gender == "male":
args.gender = GenderType.MALE
else:
args.gender = GenderType.FEMALE
image = Image.create_one(args.image)
celebrity = CelebrityModel.create_one(
args.name,
args.gender,
image=image,
douban_id=args.douban_id,
born_place=args.born_place,
name_en=args.name_en,
aka_list=args.aka,
aka_en_list=args.aka_en,
)
if not celebrity:
return error(ErrorCode.CELEBRITY_ALREADY_EXISTS, 403)
else:
sql_db.session.add(celebrity)
sql_db.session.commit()
return ok("ok", http_status_code=201)
def delete(self, username):
current_app.logger.info(
"delete account of {username}".format(username=username))
parser = reqparse.RequestParser(trim=True)
parser.add_argument(
"password",
type=inputs.regex("^[0-9a-zA-Z\_\.\!\@\#\$\%\^\&\*]{6,20}$"),
required=True,
help="password cannot be blank!",
location="form",
)
args = parser.parse_args()
if not g.current_user.validate_password(args.password):
return error(ErrorCode.FORBIDDEN, 403)
sql_db.session.delete(g.current_user)
sql_db.session.commit()
return ok("删除用户成功")
def put(self, username):
this_user = UserModel.query.filter_by(username=username).first()
if not this_user:
return error(ErrorCode.USER_NOT_FOUND, 404)
parse = reqparse.RequestParser(trim=True)
parse.add_argument(
"role_name",
required=True,
choices=[
role[0] for role in Role.query.with_entities(
Role.role_name).distinct().all()
],
type=str,
location="form",
)
args = parse.parse_args()
this_user.change_role(args.role_name)
sql_db.session.commit()
return ok(message="修改权限成功")
def post(self):
parser = reqparse.RequestParser(trim=True)
parser.add_argument(
"username",
type=inputs.regex("^[a-zA-Z0-9\_]{6,16}$"),
required=True,
help="username is not formatted",
location="form",
)
parser.add_argument(
"password",
type=inputs.regex("^[0-9a-zA-Z\_\.\!\@\#\$\%\^\&\*]{6,20}$"),
required=True,
help="password is not formatted",
location="form",
)
parser.add_argument(
"email",
type=inputs.regex("[^@]+@[^@]+\.[^@]+"),
required=True,
help="email is not formatted",
location="form",
)
args = parser.parse_args()
user = UserModel.create_one(args["username"], args["email"],
args["password"])
if not user:
return error(ErrorCode.USER_ALREADY_EXISTS, 403)
sql_db.session.add(user)
sql_db.session.commit()
token = generate_email_confirm_token(user.username,
AccountOperations.CONFIRM,
email=user.email)
send_confirm_email.delay(token, user.email, user.username)
return ok(
"register user succeed",
http_status_code=201,
username=user.username,
role_name=user.role_name,
)
def patch(self):
"""change password"""
parser = reqparse.RequestParser()
parser.add_argument(
"old_password",
type=inputs.regex("^[0-9a-zA-Z\_\.\!\@\#\$\%\^\&\*]{6,20}$"),
required=True,
location="form",
)
parser.add_argument(
"new_password",
type=inputs.regex("^[0-9a-zA-Z\_\.\!\@\#\$\%\^\&\*]{6,20}$"),
required=True,
location="form",
)
args = parser.parse_args()
current_user = g.current_user
if current_user.validate_password(args.old_password):
current_user.change_password(args.old_password)
sql_db.session.commit()
return ok("密码修改成功")
else:
return error(ErrorCode.PASSWORD_VALIDATE_ERROR, 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 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)
