Fix a bug and add a new thing

- Add support for logging Arcaea's errors
- Fix a bug when world maps' data don't have some unnecessary parts the client of iOS may break down

latest version/server/score.py

@@ -1,7 +1,7 @@
 from time import time
 from core.course import CoursePlay
 
-from core.error import ArcError, InputError
+from core.error import InputError
 from core.rank import RankList
 from core.score import UserPlay
 from core.sql import Connect
@@ -9,7 +9,7 @@ from core.user import UserOnline
 from flask import Blueprint, request
 
 from .auth import auth_required
-from .func import error_return, success_return
+from .func import arc_try, success_return
 
 bp = Blueprint('score', __name__, url_prefix='/score')
 
@@ -21,6 +21,7 @@ def score_token():
 
 @bp.route('/token/world', methods=['GET'])  # 世界模式成绩上传所需的token
 @auth_required(request)
+@arc_try
 def score_token_world(user_id):
 
     stamina_multiply = int(
@@ -30,127 +31,108 @@ def score_token_world(user_id):
     prog_boost_multiply = int(
         request.args['prog_boost_multiply']) if 'prog_boost_multiply' in request.args else 0
     with Connect() as c:
-        try:
-            x = UserPlay(c, UserOnline(c, user_id))
-            x.song.set_chart(request.args['song_id'], int(
-                request.args['difficulty']))
-            x.set_play_state_for_world(stamina_multiply,
-                                       fragment_multiply, prog_boost_multiply)
-            return success_return({
-                "stamina": x.user.stamina.stamina,
-                "max_stamina_ts": x.user.stamina.max_stamina_ts,
-                "token": x.song_token
-            }
-            )
-        except ArcError as e:
-            return error_return(e)
-    return error_return()
+        x = UserPlay(c, UserOnline(c, user_id))
+        x.song.set_chart(request.args['song_id'], int(
+            request.args['difficulty']))
+        x.set_play_state_for_world(stamina_multiply,
+                                   fragment_multiply, prog_boost_multiply)
+        return success_return({
+            "stamina": x.user.stamina.stamina,
+            "max_stamina_ts": x.user.stamina.max_stamina_ts,
+            "token": x.song_token
+        }
+        )
 
 
 @bp.route('/token/course', methods=['GET'])  # 课题模式成绩上传所需的token
 @auth_required(request)
+@arc_try
 def score_token_course(user_id):
     with Connect() as c:
-        try:
-            use_course_skip_purchase = request.args.get(
-                'use_course_skip_purchase', 'false') == 'true'
+        use_course_skip_purchase = request.args.get(
+            'use_course_skip_purchase', 'false') == 'true'
 
-            user = UserOnline(c, user_id)
-            user_play = UserPlay(c, user)
-            user_play.song_token = request.args.get('previous_token', None)
-            user_play.get_play_state()
+        user = UserOnline(c, user_id)
+        user_play = UserPlay(c, user)
+        user_play.song_token = request.args.get('previous_token', None)
+        user_play.get_play_state()
 
-            status = 'created'
-            if user_play.course_play_state == -1:
-                # 没有token，课题模式刚开始
-                course_play = CoursePlay(c, user, user_play)
-                course_play.course_id = request.args['course_id']
-                user_play.course_play = course_play
-                user_play.set_play_state_for_course(
-                    use_course_skip_purchase)
-            elif 0 <= user_play.course_play_state <= 3:
-                # 验证token
-                user_play.update_token_for_course()
-            else:
-                # 课题模式已经结束
-                user_play.clear_play_state()
-                user.select_user_about_stamina()
-                status = 'cleared' if user_play.course_play_state == 4 else 'failed'
+        status = 'created'
+        if user_play.course_play_state == -1:
+            # 没有token，课题模式刚开始
+            course_play = CoursePlay(c, user, user_play)
+            course_play.course_id = request.args['course_id']
+            user_play.course_play = course_play
+            user_play.set_play_state_for_course(
+                use_course_skip_purchase)
+        elif 0 <= user_play.course_play_state <= 3:
+            # 验证token
+            user_play.update_token_for_course()
+        else:
+            # 课题模式已经结束
+            user_play.clear_play_state()
+            user.select_user_about_stamina()
+            status = 'cleared' if user_play.course_play_state == 4 else 'failed'
 
-            return success_return({
-                "stamina": user.stamina.stamina,
-                "max_stamina_ts": user.stamina.max_stamina_ts,
-                "token": user_play.song_token,
-                'status': status
-            })
-        except ArcError as e:
-            return error_return(e)
-    return error_return()
+        return success_return({
+            "stamina": user.stamina.stamina,
+            "max_stamina_ts": user.stamina.max_stamina_ts,
+            "token": user_play.song_token,
+            'status': status
+        })
 
 
 @bp.route('/song', methods=['POST'])  # 成绩上传
 @auth_required(request)
+@arc_try
 def song_score_post(user_id):
     with Connect() as c:
-        try:
-            x = UserPlay(c, UserOnline(c, user_id))
-            x.song_token = request.form['song_token']
-            x.song_hash = request.form['song_hash']
-            x.song.set_chart(
-                request.form['song_id'], request.form['difficulty'])
-            x.set_score(request.form['score'], request.form['shiny_perfect_count'], request.form['perfect_count'], request.form['near_count'],
-                        request.form['miss_count'], request.form['health'], request.form['modifier'], int(time() * 1000), request.form['clear_type'])
-            x.beyond_gauge = int(request.form['beyond_gauge'])
-            x.submission_hash = request.form['submission_hash']
-            if not x.is_valid:
-                raise InputError('Invalid score.', 107)
-            x.upload_score()
-            return success_return(x.to_dict())
-        except ArcError as e:
-            return error_return(e)
-    return error_return()
+        x = UserPlay(c, UserOnline(c, user_id))
+        x.song_token = request.form['song_token']
+        x.song_hash = request.form['song_hash']
+        x.song.set_chart(
+            request.form['song_id'], request.form['difficulty'])
+        x.set_score(request.form['score'], request.form['shiny_perfect_count'], request.form['perfect_count'], request.form['near_count'],
+                    request.form['miss_count'], request.form['health'], request.form['modifier'], int(time() * 1000), request.form['clear_type'])
+        x.beyond_gauge = int(request.form['beyond_gauge'])
+        x.submission_hash = request.form['submission_hash']
+        if not x.is_valid:
+            raise InputError('Invalid score.', 107)
+        x.upload_score()
+        return success_return(x.to_dict())
 
 
 @bp.route('/song', methods=['GET'])  # TOP20
 @auth_required(request)
+@arc_try
 def song_score_top(user_id):
     with Connect() as c:
-        try:
-            rank_list = RankList(c)
-            rank_list.song.set_chart(request.args.get(
-                'song_id'), request.args.get('difficulty'))
-            rank_list.select_top()
-            return success_return(rank_list.to_dict_list())
-        except ArcError as e:
-            return error_return(e)
-    return error_return()
+        rank_list = RankList(c)
+        rank_list.song.set_chart(request.args.get(
+            'song_id'), request.args.get('difficulty'))
+        rank_list.select_top()
+        return success_return(rank_list.to_dict_list())
 
 
 @bp.route('/song/me', methods=['GET'])  # 我的排名，默认最多20
 @auth_required(request)
+@arc_try
 def song_score_me(user_id):
     with Connect() as c:
-        try:
-            rank_list = RankList(c)
-            rank_list.song.set_chart(request.args.get(
-                'song_id'), request.args.get('difficulty'))
-            rank_list.select_me(UserOnline(c, user_id))
-            return success_return(rank_list.to_dict_list())
-        except ArcError as e:
-            return error_return(e)
-    return error_return()
+        rank_list = RankList(c)
+        rank_list.song.set_chart(request.args.get(
+            'song_id'), request.args.get('difficulty'))
+        rank_list.select_me(UserOnline(c, user_id))
+        return success_return(rank_list.to_dict_list())
 
 
 @bp.route('/song/friend', methods=['GET'])  # 好友排名，默认最多50
 @auth_required(request)
+@arc_try
 def song_score_friend(user_id):
     with Connect() as c:
-        try:
-            rank_list = RankList(c)
-            rank_list.song.set_chart(request.args.get(
-                'song_id'), request.args.get('difficulty'))
-            rank_list.select_friend(UserOnline(c, user_id))
-            return success_return(rank_list.to_dict_list())
-        except ArcError as e:
-            return error_return(e)
-    return error_return()
+        rank_list = RankList(c)
+        rank_list.song.set_chart(request.args.get(
+            'song_id'), request.args.get('difficulty'))
+        rank_list.select_friend(UserOnline(c, user_id))
+        return success_return(rank_list.to_dict_list())