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 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, 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 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 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 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):
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 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, 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 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 get(self):
return ok(
"ok",
data={
"count":
g.current_user.notifications_received.filter_by(
is_read=False).count()
},
)
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 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 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, 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 get(self):
return ok(
message="ok",
data={
"roles": [
role[0] for role in Role.query.with_entities(
Role.role_name).distinct().all()
],
"count":
Role.query.with_entities(Role.role_name).distinct().count(),
},
)
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 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 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 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 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 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)
