Python shortcuts.error_response函数代码示例

 def post(self, request):
     """
     用户注册json api接口
     ---
     request_serializer: UserRegisterSerializer
     """
     serializer = UserRegisterSerializer(data=request.data)
     if serializer.is_valid():
         data = serializer.data
         captcha = Captcha(request)
         if not captcha.check(data["captcha"]):
             return error_response(u"验证码错误")
         try:
             User.objects.get(username=data["username"])
             return error_response(u"用户名已存在")
         except User.DoesNotExist:
             pass
         try:
             User.objects.get(email=data["email"])
             return error_response(u"该邮箱已被注册，请换其他邮箱进行注册")
         except User.DoesNotExist:
             user = User.objects.create(username=data["username"], real_name=data["real_name"],
                                        email=data["email"])
             user.set_password(data["password"])
             user.save()
             return success_response(u"注册成功！")
     else:
         return serializer_invalid_response(serializer)

 def post(self, request):
     problem_id = request.data.get("problem_id", -1)
     try:
         problem = ContestProblem.objects.get(id=problem_id, is_public=False)
         problem.is_public = True
         problem.save()
     except ContestProblem.DoesNotExist:
         return error_response(u"比赛不存在")
     if problem.contest.status != CONTEST_ENDED:
         return error_response(u"比赛还没有结束，不能公开题目")
     Problem.objects.create(
         title=problem.title,
         description=problem.description,
         input_description=problem.input_description,
         output_description=problem.output_description,
         samples=problem.samples,
         test_case_id=problem.test_case_id,
         hint=problem.hint,
         created_by=problem.created_by,
         time_limit=problem.time_limit,
         memory_limit=problem.memory_limit,
         visible=False,
         difficulty=-1,
         source=problem.contest.title,
     )
     problem.is_public = True
     problem.save()
     return success_response(u"创建成功")

def _submit_code(user, problem_id, language, code):
    controller = BucketController(user_id=user.id,
                                  redis_conn=redis.Redis(host=settings.REDIS_CACHE["host"],
                                                         port=settings.REDIS_CACHE["port"],
                                                         db=settings.REDIS_CACHE["db"]),
                                  default_capacity=settings.TOKEN_BUCKET_DEFAULT_CAPACITY)
    bucket = TokenBucket(fill_rate=settings.TOKEN_BUCKET_FILL_RATE,
                         capacity=settings.TOKEN_BUCKET_DEFAULT_CAPACITY,
                         last_capacity=controller.last_capacity,
                         last_timestamp=controller.last_timestamp)
    if bucket.consume():
        controller.last_capacity -= 1
    else:
        return error_response(u"您提交的频率过快, 请等待%d秒" % int(bucket.expected_time() + 1))

    try:
        problem = Problem.objects.get(id=problem_id)
    except Problem.DoesNotExist:
        return error_response(u"题目不存在")
    submission = Submission.objects.create(user_id=user.id,
                                           language=language,
                                           code=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})

    def get(self, request):
        """
        比赛题目分页json api接口
        ---
        response_serializer: ContestProblemSerializer
        """
        contest_problem_id = request.GET.get("contest_problem_id", None)
        if contest_problem_id:
            try:
                contest_problem = ContestProblem.objects.get(id=contest_problem_id)
                if request.user.admin_type != SUPER_ADMIN and contest_problem.created_by != request.user:
                    return error_response(u"比赛题目不存在")
                return success_response(ContestProblemSerializer(contest_problem).data)
            except ContestProblem.DoesNotExist:
                return error_response(u"比赛题目不存在")

        contest_problems = ContestProblem.objects.all().order_by("sort_index")
        if request.user.admin_type != SUPER_ADMIN:
            contest_problems = contest_problems.filter(created_by=request.user).order_by("sort_index")
        visible = request.GET.get("visible", None)
        if visible:
            contest_problems = contest_problems.filter(visible=(visible == "true"))
        keyword = request.GET.get("keyword", None)
        if keyword:
            contest_problems = contest_problems.filter(Q(title__contains=keyword) |
                                                       Q(description__contains=keyword))
        contest_id = request.GET.get("contest_id", None)
        if contest_id:
            contest_problems = contest_problems.filter(contest__id=contest_id).order_by("sort_index")

        return paginate(request, contest_problems, ContestProblemSerializer)

 def get(self, request):
     """
     查询比赛提交,单个比赛题目提交的adminAPI
     ---
     response_serializer: SubmissionSerializer
     """
     problem_id = request.GET.get("problem_id", None)
     contest_id = request.GET.get("contest_id", None)
     if contest_id:
         try:
             contest = Contest.objects.get(pk=contest_id)
         except Contest.DoesNotExist:
             return error_response(u"比赛不存在!")
         if request.user.admin_type != SUPER_ADMIN and contest.created_by != request.user:
             return error_response(u"您无权查看该信息!")
         submissions = Submission.objects.filter(contest_id=contest_id).order_by("-create_time")
     else:
         if problem_id:
             try:
                 contest_problem = ContestProblem.objects.get(pk=problem_id)
             except ContestProblem.DoesNotExist:
                 return error_response(u"问题不存在!")
             if request.user.admin_type != SUPER_ADMIN and contest_problem.contest.created_by != request.user:
                 return error_response(u"您无权查看该信息!")
             submissions = Submission.objects.filter(contest_id=contest_problem.contest_id).order_by("-create_time")
         else:
             return error_response(u"参数错误!")
     if problem_id:
         submissions = submissions.filter(problem_id=problem_id)
     return paginate(request, submissions, SubmissionSerializer)

    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):
        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 get(self, request):
        """
        题目分页json api接口
        ---
        response_serializer: ProblemSerializer
        """
        problem_id = request.GET.get("problem_id", None)
        if problem_id:
            try:
                # 普通管理员只能获取自己创建的题目
                # 超级管理员可以获取全部的题目
                problem = Problem.objects.get(id=problem_id)
                if request.user.admin_type != SUPER_ADMIN and problem.created_by != request.user:
                    return error_response(u"题目不存在")
                return success_response(ProblemSerializer(problem).data)
            except Problem.DoesNotExist:
                return error_response(u"题目不存在")

        # 获取问题列表
        problems = Problem.objects.all().order_by("-create_time")

        if request.user.admin_type != SUPER_ADMIN:
            problems = problems.filter(created_by=request.user)

        visible = request.GET.get("visible", None)
        if visible:
            problems = problems.filter(visible=(visible == "true"))
        keyword = request.GET.get("keyword", None)
        if keyword:
            problems = problems.filter(Q(title__contains=keyword) |
                                       Q(description__contains=keyword))

        return paginate(request, problems, ProblemSerializer)

    def post(self, request):
        """
        提交请求重置密码
        ---
        request_serializer: ApplyResetPasswordSerializer
        """
        serializer = ApplyResetPasswordSerializer(data=request.data)
        if serializer.is_valid():
            data = serializer.data
            captcha = Captcha(request)
            if not captcha.check(data["captcha"]):
                return error_response(u"验证码错误")
            try:
                user = User.objects.get(email=data["email"])
            except User.DoesNotExist:
                return error_response(u"用户不存在")
            if user.reset_password_token_create_time and (now() - user.reset_password_token_create_time).total_seconds() < 20 * 60:
                return error_response(u"20分钟内只能找回一次密码")
            user.reset_password_token = rand_str()
            user.reset_password_token_create_time = now()
            user.save()
            email_template = codecs.open(settings.TEMPLATES[0]["DIRS"][0] + "utils/reset_password_email.html", "r", "utf-8").read()

            email_template = email_template.replace("{{ username }}", user.username).\
                replace("{{ website_name }}", settings.WEBSITE_INFO["website_name"]).\
                replace("{{ link }}", request.scheme + "://" + request.META['HTTP_HOST'] + "/reset_password/t/" + user.reset_password_token)

            send_email(settings.WEBSITE_INFO["website_name"],
                       user.email,
                       user.username,
                       settings.WEBSITE_INFO["website_name"] + u" 登录信息找回邮件",
                       email_template)
            return success_response(u"邮件发送成功,请前往您的邮箱查收")
        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):
        """
        公告发布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 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 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 get(self, request):
        test_case_id = request.GET.get("test_case_id", None)
        if not test_case_id:
            return error_response(u"参数错误")
        # 防止URL./../../.上层目录遍历
        if not re.compile(r"^[0-9a-zA-Z]+$").match(test_case_id):
            return error_response(u"参数错误")

        try:
            # 超级管理员可以下载全部的题目的测试数据
            # 普通管理员只能下载自己创建的题目的测试数据
            if request.user.admin_type != SUPER_ADMIN:
                ContestProblem.objects.get(test_case_id=test_case_id, created_by=request.user)

            test_case_dir = os.path.join(settings.TEST_CASE_DIR, test_case_id)
            if not os.path.exists(test_case_dir):
                return error_response(u"测试用例不存在")

            # 压缩测试用例,命名规则为 "test_case" + test_case_id + ".zip"
            test_case_zip = os.path.join("/tmp", "test_case-" + test_case_id + ".zip")

            zf = zipfile.ZipFile(test_case_zip, "w", zipfile.ZIP_DEFLATED)
            for filename in os.listdir(test_case_dir):
                if self._is_legal_test_case_file_name(filename):
                    zf.write(os.path.join(test_case_dir, filename), filename)
            zf.close()

            # 大文件传输
            response = StreamingHttpResponse(self.file_iterator(test_case_zip))
            response['Content-Type'] = 'application/octet-stream'
            response['Content-Disposition'] = 'attachment;filename=test_case-%s.zip' % test_case_id
            return response
        except ContestProblem.DoesNotExist:
            return error_response(u"题目不存在")