def post(self, request):
     """
     比赛题目发布json api接口
     ---
     request_serializer: CreateContestProblemSerializer
     response_serializer: ContestProblemSerializer
     """
     serializer = CreateContestProblemSerializer(data=request.data)
     if serializer.is_valid():
         data = serializer.data
         try:
             contest = Contest.objects.get(id=data["contest_id"])
             if request.user.admin_type != SUPER_ADMIN:
                 contest_set = Contest.objects.filter(groups__in=request.user.managed_groups.all())
                 if contest not in contest_set:
                     return error_response(u"比赛不存在")
         except Contest.DoesNotExist:
             return error_response(u"比赛不存在")
         contest_problem = ContestProblem.objects.create(title=data["title"],
                                                         description=data["description"],
                                                         input_description=data["input_description"],
                                                         output_description=data["output_description"],
                                                         test_case_id=data["test_case_id"],
                                                         samples=json.dumps(data["samples"]),
                                                         time_limit=data["time_limit"],
                                                         memory_limit=data["memory_limit"],
                                                         created_by=request.user,
                                                         hint=data["hint"],
                                                         contest=contest,
                                                         sort_index=data["sort_index"])
         return success_response(ContestProblemSerializer(contest_problem).data)
     else:
         return serializer_invalid_response(serializer)

    def put(self, request):
        """
        比赛题目编辑json api接口
        ---
        request_serializer: EditContestProblemSerializer
        response_serializer: ContestProblemSerializer
        """
        serializer = EditContestProblemSerializer(data=request.data)
        if serializer.is_valid():
            data = serializer.data

            try:
                contest_problem = ContestProblem.objects.get(id=data["id"])
            except ContestProblem.DoesNotExist:
                return error_response(u"该比赛题目不存在！")
            contest = Contest.objects.get(id=contest_problem.contest_id)
            if request.user.admin_type != SUPER_ADMIN and contest.created_by != request.user:
                return error_response(u"比赛不存在")
            contest_problem.title = data["title"]
            contest_problem.description = data["description"]
            contest_problem.input_description = data["input_description"]
            contest_problem.output_description = data["output_description"]
            contest_problem.test_case_id = data["test_case_id"]
            contest_problem.time_limit = data["time_limit"]
            contest_problem.memory_limit = data["memory_limit"]
            contest_problem.samples = json.dumps(data["samples"])
            contest_problem.hint = data["hint"]
            contest_problem.visible = data["visible"]
            contest_problem.sort_index = data["sort_index"]
            contest_problem.last_update_time = now()
            contest_problem.save()
            return success_response(ContestProblemSerializer(contest_problem).data)
        else:
            return serializer_invalid_response(serializer)

 def post(self, request):
     """
     加入某个小组的api
     ---
     request_serializer: CreateJoinGroupRequestSerializer
     """
     serializer = CreateJoinGroupRequestSerializer(data=request.data)
     if serializer.is_valid():
         data = serializer.data
         try:
             group = Group.objects.get(id=data["group_id"])
         except Group.DoesNotExist:
             return error_response(u"小组不存在")
         if group.join_group_setting == 0:
             if join_group(request.user, group):
                 return success_response(u"你已经成功的加入该小组")
             else:
                 return error_response(u"你已经是小组成员了")
         elif group.join_group_setting == 1:
             if not data["message"]:
                 return error_response(u"message : 该字段是必填项。")
             try:
                 JoinGroupRequest.objects.get(user=request.user, group=group, status=False)
                 return error_response(u"你已经提交过申请了，请等待审核")
             except JoinGroupRequest.DoesNotExist:
                 JoinGroupRequest.objects.create(user=request.user, group=group, message=data["message"])
             return success_response(u"申请提交成功，请等待审核")
         elif group.join_group_setting == 2:
             return error_response(u"该小组不允许任何人加入")
     else:
         return serializer_invalid_response(serializer)

 def post(self, request):
     """
     创建比赛的提交
     ---
     request_serializer: CreateContestSubmissionSerializer
     """
     serializer = CreateContestSubmissionSerializer(data=request.data)
     if serializer.is_valid():
         data = serializer.data
         contest = Contest.objects.get(id=data["contest_id"])
         try:
             problem = ContestProblem.objects.get(contest=contest, id=data["problem_id"])
         except ContestProblem.DoesNotExist:
             return error_response(u"题目不存在")
         submission = Submission.objects.create(user_id=request.user.id,
                                                language=int(data["language"]),
                                                contest_id=contest.id,
                                                code=data["code"],
                                                problem_id=problem.id)
         try:
             _judge.delay(submission.id, problem.time_limit, problem.memory_limit, problem.test_case_id,
                          problem.spj, problem.spj_language, problem.spj_code, problem.spj_version)
         except Exception as e:
             logger.error(e)
             return error_response(u"提交判题任务失败")
         return success_response({"submission_id": submission.id})
     else:
         return serializer_invalid_response(serializer)

    def post(self, request):
        """
        用户登录json api接口
        ---
        request_serializer: UserLoginSerializer
        """
        serializer = UserLoginSerializer(data=request.data)
        if serializer.is_valid():
            data = serializer.data
            user = auth.authenticate(username=data["username"], password=data["password"])
            # 用户名或密码错误的话 返回None
            if user:
                if not user.two_factor_auth:
                    auth.login(request, user)
                    return success_response(u"登录成功")

                # 没有输入两步验证的验证码
                if user.two_factor_auth and "tfa_code" not in data:
                    return success_response("tfa_required")

                if OtpAuth(user.tfa_token).valid_totp(data["tfa_code"]):
                    auth.login(request, user)
                    return success_response(u"登录成功")
                else:
                    return error_response(u"验证码错误")
            else:
                return error_response(u"用户名或密码错误")
        else:
            return serializer_invalid_response(serializer)

    def put(self, request):
        """
        同意或者拒绝加入小组请求
        ---
        request_serializer: PutJoinGroupRequestSerializer
        """
        serializer = PutJoinGroupRequestSerializer(data=request.data)
        if serializer.is_valid():
            data = serializer.data
            try:
                join_request = JoinGroupRequest.objects.get(id=data["request_id"], group__admin=request.user,
                                                            status=False)
            except JoinGroupRequest.DoesNotExist:
                return error_response(u"请求不存在")

            join_request.status = True
            join_request.save()
            if data["status"]:
                if join_group(join_request.user, join_request.group):
                    join_request.accepted = True
                    join_request.save()
                    return success_response(u"加入成功")
                else:
                    return error_response(u"加入失败，已经在本小组内")
            else:
                return success_response(u"已拒绝")

        else:
            return serializer_invalid_response(serializer)

    def post(self, request):
        """
        用户登录json api接口
        ---
        request_serializer: UserLoginSerializer
        """
        serializer = UserLoginSerializer(data=request.data)
        if serializer.is_valid():
            data = serializer.data

            if "captcha" not in data:
                return error_response(u"请填写验证码！")
            captcha = Captcha(request)
            if not captcha.check(data["captcha"]):
                return error_response(u"验证码错误")

            user = auth.authenticate(username=data["username"], password=data["password"])
            # 用户名或密码错误的话 返回None
            if user:
                auth.login(request, user)
                return success_response(u"登录成功")
            else:
                return error_response(u"用户名或密码错误")
        else:
            return serializer_invalid_response(serializer)

 def post(self, request):
     """
     创建比赛的提交
     ---
     request_serializer: CreateContestSubmissionSerializer
     """
     serializer = CreateContestSubmissionSerializer(data=request.data)
     if serializer.is_valid():
         data = serializer.data
         contest = Contest.objects.get(id=data["contest_id"])
         try:
             problem = ContestProblem.objects.get(contest=contest, id=data["problem_id"])
             # 更新题目提交计数器
             problem.total_submit_number += 1
             problem.save()
         except ContestProblem.DoesNotExist:
             return error_response(u"题目不存在")
         submission = Submission.objects.create(user_id=request.user.id, language=int(data["language"]),
                                                contest_id=contest.id, code=data["code"], problem_id=problem.id)
         try:
             judge.delay(submission.id, problem.time_limit, problem.memory_limit, problem.test_case_id)
         except Exception:
             return error_response(u"提交判题任务失败")
         # 增加redis 中判题队列长度的计数器
         r = redis.Redis(host=redis_config["host"], port=redis_config["port"], db=redis_config["db"])
         r.incr("judge_queue_length")
         return success_response({"submission_id": submission.id})
     else:
         return serializer_invalid_response(serializer)

 def put(self, request):
     """
     用户编辑json api接口
     ---
     request_serializer: EditUserSerializer
     response_serializer: UserSerializer
     """
     serializer = EditUserSerializer(data=request.data)
     if serializer.is_valid():
         data = serializer.data
         try:
             user = User.objects.get(id=data["id"])
         except User.DoesNotExist:
             return error_response(u"该用户不存在！")
         try:
             user = User.objects.get(username=data["username"])
             if user.id != data["id"]:
                 return error_response(u"昵称已经存在")
         except User.DoesNotExist:
             pass
         user.username = data["username"]
         user.real_name = data["real_name"]
         user.email = data["email"]
         user.admin_type = data["admin_type"]
         if data["password"]:
             user.set_password(data["password"])
         user.save()
         return success_response(UserSerializer(user).data)
     else:
         return serializer_invalid_response(serializer)

 def post(self, request):
     """
     题目发布json api接口
     ---
     request_serializer: CreateProblemSerializer
     response_serializer: ProblemSerializer
     """
     serializer = CreateProblemSerializer(data=request.data)
     if serializer.is_valid():
         data = serializer.data
         problem = Problem.objects.create(title=data["title"],
                                          description=data["description"],
                                          input_description=data["input_description"],
                                          output_description=data["output_description"],
                                          test_case_id=data["test_case_id"],
                                          source=data["source"],
                                          samples=json.dumps(data["samples"]),
                                          time_limit=data["time_limit"],
                                          memory_limit=data["memory_limit"],
                                          difficulty=data["difficulty"],
                                          created_by=request.user,
                                          hint=data["hint"],
                                          visible=data["visible"])
         for tag in data["tags"]:
             try:
                 tag = ProblemTag.objects.get(name=tag)
             except ProblemTag.DoesNotExist:
                 tag = ProblemTag.objects.create(name=tag)
             problem.tags.add(tag)
         return success_response(ProblemSerializer(problem).data)
     else:
         return serializer_invalid_response(serializer)

    def post(self, request):
        serializer = SubmissionRejudgeSerializer(data=request.data)
        if serializer.is_valid():
            submission_id = serializer.data["submission_id"]
            try:
                submission = Submission.objects.get(id=submission_id)
            except Submission.DoesNotExist:
                return error_response(u"提交不存在")
            # 目前只考虑前台公开题目的重新判题
            try:
                problem = Problem.objects.get(id=submission.problem_id)
            except Problem.DoesNotExist:
                return error_response(u"题目不存在")
            try:
                judge.delay(submission_id, problem.time_limit, problem.memory_limit, problem.test_case_id)
            except Exception as e:
                logger.error(e)
                return error_response(u"提交判题任务失败")

            # 增加redis 中判题队列长度的计数器
            r = redis.Redis(host=redis_config["host"], port=redis_config["port"], db=redis_config["db"])
            r.incr("judge_queue_length")
            return success_response(u"任务提交成功")
        else:
            return serializer_invalid_response(serializer)

    def post(self, request):
        """
        公告发布json api接口
        ---
        request_serializer: CreateAnnouncementSerializer
        """
        serializer = CreateAnnouncementSerializer(data=request.data)
        if serializer.is_valid():
            data = serializer.data
            groups = []
            # 如果不是全局公告，就去查询一下小组的id 列表中的内容，注意用户身份
            if not data["is_global"]:
                if request.user.admin_type == SUPER_ADMIN:
                    groups = Group.objects.filter(id__in=data["groups"])
                else:
                    groups = Group.objects.filter(id__in=data["groups"], admin=request.user)
                if not groups.count():
                    return error_response(u"至少选择一个小组")
            else:
                if request.user.admin_type != SUPER_ADMIN:
                    return error_response(u"只有超级管理员可以创建全局公告")

            announcement = Announcement.objects.create(title=data["title"],
                                                       content=data["content"],
                                                       created_by=request.user,
                                                       is_global=data["is_global"])

            announcement.groups.add(*groups)
            return success_response(u"公告发布成功！")
        else:
            return serializer_invalid_response(serializer)

 def put(self, request):
     serializer = TwoFactorAuthCodeSerializer(data=request.data)
     if serializer.is_valid():
         user = request.user
         code = serializer.data["code"]
         if OtpAuth(user.tfa_token).valid_totp(code):
             user.two_factor_auth = False
             user.save()
         else:
             return error_response(u"验证码错误")
     else:
         return serializer_invalid_response(serializer)

 def post(self, request):
     serializer = SSOSerializer(data=request.data)
     if serializer.is_valid():
         try:
             user = User.objects.get(auth_token=serializer.data["token"])
             user.auth_token = None
             user.save()
             return success_response(
                 {"username": user.username, "admin_type": user.admin_type, "avatar": user.userprofile.avatar})
         except User.DoesNotExist:
             return error_response(u"用户不存在")
     else:
         return serializer_invalid_response(serializer)

    def post(self, request):
        """
        比赛发布json api接口
        ---
        request_serializer: CreateContestSerializer
        response_serializer: ContestSerializer
        """
        serializer = CreateContestSerializer(data=request.data)
        if serializer.is_valid():
            data = serializer.data
            groups = []
            # 首先判断比赛的类型： 0 即为是小组赛(GROUP_CONTEST)，1 即为是无密码的公开赛(PUBLIC_CONTEST)，
            # 2 即为是有密码的公开赛(PASSWORD_PUBLIC_CONTEST)
            # 此时为有密码的公开赛，并且此时只能超级管理员才有权限此创建比赛
            if data["contest_type"] in [PUBLIC_CONTEST, PASSWORD_PROTECTED_CONTEST]:
                if request.user.admin_type != SUPER_ADMIN:
                    return error_response(u"只有超级管理员才可创建公开赛")

            if data["contest_type"] == PASSWORD_PROTECTED_CONTEST:
                if not data["password"]:
                    return error_response(u"此比赛为有密码的公开赛，密码不可为空")
            # 没有密码的公开赛 没有密码的小组赛
            elif data["contest_type"] == GROUP_CONTEST:
                if request.user.admin_type == SUPER_ADMIN:
                    groups = Group.objects.filter(id__in=data["groups"])
                else:
                    groups = Group.objects.filter(id__in=data["groups"], admin=request.user)
                if not groups.count():
                    return error_response(u"请至少选择一个小组")
            if data["start_time"] >= data["end_time"]:
                return error_response(u"比赛的开始时间必须早于比赛结束的时间")
            try:
                contest = Contest.objects.create(
                    title=data["title"],
                    description=data["description"],
                    contest_type=data["contest_type"],
                    real_time_rank=data["real_time_rank"],
                    password=data["password"],
                    start_time=dateparse.parse_datetime(data["start_time"]),
                    end_time=dateparse.parse_datetime(data["end_time"]),
                    created_by=request.user,
                    visible=data["visible"],
                )
            except IntegrityError:
                return error_response(u"比赛名已经存在")
            contest.groups.add(*groups)
            return success_response(ContestSerializer(contest).data)
        else:
            return serializer_invalid_response(serializer)