def admin_get_question():
question_index = int(request.form.get("questionId")) # todo: change api and param name
questions = QuestionModel.objects(index=question_index)
if len(questions) == 0:
resp = {"needDisplay": True, "tip": "没有此题号"}
return jsonify(errors.error(resp))
question = questions[0]
if question["q_type"] != 2:
resp = {"needDisplay": True, "tip": "暂时只支持题型2"}
return jsonify(errors.error(resp))
# 生成测试
test = CurrentTestModel()
test.user_id = str(current_user.id)
test.test_start_time = datetime.datetime.utcnow()
q_current = CurrentQuestionEmbed(q_id=str(question.id), q_type=question.q_type, q_text=question.text,
wav_upload_url='', wav_temp_url='')
test.questions = {"1": q_current}
test.save()
# 保存test id
# print("[DEBUG] save test id in session when admin get question, test id: %s" % test.id.__str__())
current_app.logger.debug("save test id in session when admin get question, test id: %s" % test.id.__str__())
session["test_id"] = test.id.__str__()
# wrap question
context = {"questionType": question.q_type,
"questionNumber": 1,
"questionLimitTime": ExamConfig.question_limit_time[question.q_type],
"lastQuestion": True,
"readLimitTime": ExamConfig.question_prepare_time[question.q_type],
"questionInfo": QuestionConfig.question_type_tip[question.q_type],
"questionContent": question.text
}
return jsonify(errors.success(json.dumps(context)))
def wxapp_login():
if current_user.is_authenticated:
return jsonify(errors.Already_logged_in)
code = request.form.get('code')
nick_name = request.form.get('nick_name')
if not code:
return jsonify(errors.Params_error)
resp = user_client.authenticateWechatUser(
user_thrift.AuthenticateWechatUserRequest(code=code,
nickName=nick_name))
if resp is None:
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
token = resp.token
payload = jwt.decode(token, "secret", algorithms="HS256")
return jsonify(
errors.success({
'msg': '登录成功',
"token": token,
'name': payload["nick_name"],
}))
def get_result():
last_test_id = ExamSession.get(current_user.id, "last_test_id", DefaultValue.test_id)
if not last_test_id:
return jsonify(errors.Check_history_results)
resp = exam_client.getExamResult(exam_thrift.GetExamResultRequest(
examId=last_test_id
))
if resp is None:
current_app.logger.error("[get_result] exam_client.getExamResult failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
# 正在处理
if resp.statusCode == errors.WIP['code']:
try_times = int(ExamSession.get(current_user.id, "tryTimes", 0)) + 1
ExamSession.set(current_user.id, 'tryTimes', str(try_times))
current_app.logger.info("[get_result] handling!!! try times: %s, test_id: %s, user name: %s" %
(str(try_times), last_test_id, current_user.name))
return jsonify(errors.error({'code': resp.statusCode, 'msg': resp.statusMsg}))
return jsonify(errors.success({
"status": "Success",
"totalScore": format(resp.score.total, ScoreConfig.DEFAULT_NUM_FORMAT),
"data": exam_score_convert_to_json(resp.score), # 这个表示成绩信息，为兼容旧系统就不改了...
"report": exam_report_convert_to_json(resp.report)
}))
def wx_get_questions():
"""
请求参数： nickname, code
无session,需要返回testID(current记录的id)给前端,之后前端带此testID请求(wx/upload-success)
"""
nickname = request.args.get("nickname")
code = request.args.get("code")
if nickname in ['', None] or code in ['', None]:
return jsonify(errors.Params_error)
current_app.logger.info('wx_get_questions: nickname: %s, code: %s, ' %
(nickname, code))
# 使用 code 获取用户的 openid
err_code, _, openid = wxlp_get_sessionkey_openid(code,
appid=WxConfig.appid,
secret=WxConfig.secret)
# err_code, openid = 0, 'xxx'
if err_code:
d = {'err_code': err_code, 'msg': '获取openid出错'}
return jsonify(errors.error(d))
current_app.logger.info('wx_get_questions: openid: %s, nickname: %s' %
(openid, nickname))
the_exam = CurrentTestModel.objects(openid=openid).first() # 因为可能是重复请求
if the_exam is None or the_exam.questions['9'].status in [
'handling', 'finished', 'error'
]:
# 创建新的current记录(新的考试)
current_app.logger.info('wx_get_questions: init exam...')
the_exam = wx_init_question(openid)
if not the_exam:
return jsonify(errors.Init_exam_failed)
# 按格式包装题目并返回
context = question_dealer(the_exam)
return jsonify(errors.success(context))
def get_all_questions():
"""获取所有第二种类型的题目
:return: 所有第二种类型的题目题目，可直接展示
"""
(page, size) = __get_page_and_size_from_request_args(request.args)
question_type = request.args.get('type')
resp = question_client.getQuestionList(
question_thrift.GetQuestionListRequest(
questionType=int(question_type)
if question_type is not None else None,
page=page,
pageSize=size))
if resp is None:
current_app.logger.error(
"[get_all_questions] question_client.getQuestionInfo failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
data = []
for question in resp.questions:
data.append(question_item_convert_to_json(question))
return jsonify(errors.success({"count": resp.total, "questions": data}))
def generate_wordbase_by_text():
"""根据原文重新生成关键词和细节词
:return: 分析后的关键词和细节词
"""
text = request.form.get('text')
resp = question_client.generateWordbase(
question_thrift.GenerateWordbaseRequest(text=text))
if resp is None:
current_app.logger.error(
"[generate_wordbase_by_text] question_client.generateWordbase failed"
)
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
return jsonify(
errors.success({
"keywords": resp.keywords,
"detailwords": resp.detailwords
}))
def modify_question():
"""修改一个问题
:return:
"""
index = request.form.get(
'id') # todo: change to REST api and change name 'id' to 'index'
question_data_raw_text = request.form.get('data[rawText]')
resp = question_client.saveRetellingQuestion(
question_thrift.SaveRetellingQuestionRequest(
newQuestion=question_thrift.RetellingQuestion(
questionIndex=int(index),
rawText=question_data_raw_text,
keywords=json.loads(request.form.get('data[keywords]')),
detailwords=json.loads(request.form.get('data[detailwords]')),
)))
if resp is None:
current_app.logger.error(
"[modify_question] question_client.SaveRetellingQuestion failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
return jsonify(errors.success())
def wx_get_result():
"""
请求参数： questionNums(list), testID(str) （json格式）
获取指定current记录的音频题打分
"""
questions_nums = [str(s) for s in request.json.get("questionNums")]
test_id = str(request.json.get("testID"))
if test_id is None:
return jsonify(errors.Params_error)
current_app.logger.info("wx:get_result:current_id: %s" % test_id)
current_test = CurrentTestModel.objects(id=test_id).first()
if current_test is None:
current_app.logger.error(
"upload_success: ERROR: Test Not Exists!! - test_id: %s" % test_id)
return jsonify(errors.Exam_not_exist)
ret = {'questions': {}}
for q_num in questions_nums:
try:
q = current_test.questions.get(q_num)
status = q.get("status")
except Exception as e:
current_app.logger.error(e)
return jsonify(errors.error({'msg': '题号无效: %s' % q_num}))
ret['scores'].update({'q_num': {'status': status, 'scores': q.score}})
return jsonify(errors.success(ret))
def get_history_scores(tpl_id="0"):
resp = exam_client.getExamRecord(
exam_thrift.GetExamRecordRequest(
userId=str(current_user.id),
templateId=tpl_id if tpl_id != "0" else ""))
if resp is None:
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
history_scores = []
for exam_item in resp.examList:
history_scores.append({
"test_start_time":
exam_item.examStartTime,
"paper_tpl_id":
exam_item.templateId,
"test_id":
exam_item.examId,
"score_info":
exam_score_convert_to_json(exam_item.scoreInfo)
})
if len(history_scores) == 0:
return jsonify(errors.No_history)
return jsonify(errors.success({"history": history_scores}))
def next_question_v2(question_num):
"""
获取下一题
:param question_num: 完成的题号(原nowQuestionNum),获取第1题时为0
:return: json格式包装的question，如：
{
"code": 0,
"data": {
"examLeftTime": 1752.312776,
"examTime": 1800,
"lastQuestion": false,
"questionContent": "表达能力是一种非常有用的技能",
"questionDbId": "5bcdea7df9438b6e56a32999",
"questionInfo": {
"detail": "声音质量测试。点击 “显示题目” 按钮后请先熟悉屏幕上的文字，然后按下 “开始回答” 按钮朗读该段文字。",
"tip": "为了保证测试准确性，请选择安静环境，并对准麦克风。"
},
"questionLimitTime": 60,
"questionNumber": 1,
"questionType": 1,
"readLimitTime": 5
},
"msg": "success"
}
"""
# 验证参数
next_question_num = int(question_num) + 1
if next_question_num <= 0: # db中题号从1开始
return jsonify(errors.Params_error)
# todo: nowQuestionNum: 限制只能获取当前题目
ExamSession.set(current_user.id, 'question_num', next_question_num)
test_id = ExamSession.get(current_user.id, "test_id", default=DefaultValue.test_id) # for production
resp = exam_client.getQuestionInfo(exam_thrift.GetQuestionInfoRequest(
examId=test_id,
questionNum=next_question_num
))
if resp is None:
current_app.logger.error("[next_question_v2] exam_client.getQuestionInfo failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
if resp.statusCode == errors.Exam_finished["code"]:
ExamSession.set(current_user.id, 'question_num', 0)
return jsonify(errors.error({'code': resp.statusCode, 'msg': resp.statusMsg}))
if not resp.question:
return jsonify(errors.Get_question_failed)
# log question id to user's historical questions todo: change to rpc
user = UserModel.objects(id=str(current_user.id)).first()
user.questions_history.update({resp.question.id: datetime.datetime.utcnow()})
user.save()
# 判断考试是否超时，若超时则返回错误
if resp.question.examLeftTime <= 0:
return jsonify(errors.Test_time_out)
return jsonify(errors.success(question_info_convert_to_json(resp.question)))
def post_new_question():
"""新建一个问题
:return:
"""
# 提取参数
is_from_pool = request.form.get('isFromPool')
id_in_pool = request.form.get('idInPool')
question_data_raw_text = request.form.get('data[rawText]')
if util.str_to_bool(is_from_pool):
# 题库导入时，需要删除原项，即从 origin_questions 中删除
resp = question_client.delOriginalQuestion(
question_thrift.DelOriginalQuestionRequest(id=id_in_pool))
if resp is None:
current_app.logger.error(
"[post_new_question] question_client.delOriginalQuestion failed"
)
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
resp = question_client.saveRetellingQuestion(
question_thrift.SaveRetellingQuestionRequest(
newQuestion=question_thrift.RetellingQuestion(
rawText=question_data_raw_text,
keywords=json.loads(request.form.get('data[keywords]')),
detailwords=json.loads(request.form.get('data[detailwords]')),
)))
if resp is None:
current_app.logger.error(
"[post_new_question] question_client.SaveRetellingQuestion failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
return jsonify(errors.success())
def accounts_invite():
"""批量创建邀请码
Form-data Args:
vipStartTime: 评测权限开始时间（时间戳）
vipEndTime: 评测权限结束时间（时间戳）
remainingExamNum: 邀请码包含的评测考试权限
remainingExerciseNum: 邀请码包含的评测练习权限（暂未使用）
availableTimes: 邀请码可用人数
codeNum: 创建邀请码个数
Returns:
jsonify(errors.success({'msg': '生成邀请码成功', 'invitationCode': [...]}))
"""
current_app.logger.info('create invitation request: %s' %
request.form.__str__())
# 检验是否有权限申请邀请码
form = request.form
try:
vip_start_time = form.get('vipStartTime').strip()
vip_end_time = form.get('vipEndTime').strip()
remaining_exam_num = int(form.get('remainingExamNum').strip())
remaining_exercise_num = int(form.get('remainingExerciseNum').strip())
available_times = int(form.get('availableTimes').strip())
code_num = int(form.get('codeNum').strip())
except Exception as e:
current_app.logger.error(
'Params_error:POST admin/accounts/invite: %s' % e)
return jsonify(errors.Params_error)
resp = user_client.createInvitationCode(
user_thrift.CreateInvitationCodeRequest(
creator=current_user.name,
availableTimes=available_times,
vipStartTime=vip_start_time,
vipEndTime=vip_end_time,
remainingExamNum=remaining_exam_num,
remainingExerciseNum=remaining_exercise_num,
codeNum=code_num,
))
if resp is None:
current_app.logger.error(
"[accounts_invite] user_client.createInvitationCode failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
return jsonify(
errors.success({
'msg': '生成邀请码成功',
'invitationCode': resp.codeList
}))
def wechat_bind():
"""
前端展示用户的微信头像和名称，引导用户填写账号和密码进行绑定，将来可能直接绑定手机号
:return:
"""
wx_union_id = session.get('wx_union_id')
if not wx_union_id:
return jsonify(errors.error())
username = request.form.get('username')
password = request.form.get('password')
resp = user_client.authenticate(
user_thrift.AuthenticateRequest(username=username, password=password))
if resp is None:
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
token = resp.token
payload = jwt.decode(token, "secret", algorithms="HS256")
check_user = UserModel.objects(pk=payload["uuid"]).first()
if check_user.wx_id:
return jsonify(errors.Wechat_already_bind)
current_app.logger.info(
'Bind wechat union id -\n user: %s, union id: %s' %
(check_user.email, wx_union_id))
check_user.wx_id = wx_union_id
check_user.last_login_time = datetime.datetime.utcnow()
check_user.save()
return jsonify(
errors.success({
'msg': '绑定成功',
'token': token,
'name': payload["nick_name"],
}))
def get_question_num_of_tpl(paper_tpl_id):
resp = exam_client.getPaperTemplate(exam_thrift.GetPaperTemplateRequest(
templateId=paper_tpl_id
))
if resp is None:
current_app.logger.error("[get_question_num_of_tpl] exam_client.getPaperTemplate failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(errors.error({'code': resp.statusCode, 'msg': resp.statusMsg}))
return jsonify(errors.success({'total': resp.templateList[0].questionCount}))
def create_app(timeout, db_host, db_name, db_port, db_user, db_password):
app = web.Application()
conf = namedtuple('conf', [
'db_host',
'db_name',
'db_port',
'db_user',
'db_password',
])
conf.db_host = db_host
conf.db_name = db_name
conf.db_port = db_port
conf.db_user = db_user
conf.db_password = db_password
app[CONF] = conf
# Signal handlers
app.on_startup.extend([
connect_db,
])
app.on_cleanup.extend([
disconnect_db,
])
# Middleware
app.middlewares.extend([
error_middleware({
404: lambda req, resp: error(404),
500: lambda req, resp: error(500),
504: lambda req, resp: error(504),
}),
timeout_middleware(timeout),
])
# Routes
app.router.add_get('/{%s}' % URL_ID_PARAM, get_url)
app.router.add_put('/', put_url)
return app
def get_info():
resp = user_client.getUserInfo(
user_thrift.GetUserInfoRequest(userId=str(current_user.id)))
if resp is None:
current_app.logger.error("[get_info] user_client.getUserInfo failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
return jsonify(errors.success(user_info_convert_to_json(resp.userInfo)))
def init_exam_v2(paper_tpl_id):
"""
创建试卷
TODO: 使用redis锁避免短时重复创建(如网络原因导致请求重复到达)
:param paper_tpl_id: 模板在数据库的 _id
:return: json格式状态
"""
# 判断是否有剩余考试次数
if Setting.LIMIT_EXAM_TIMES:
resp = user_client.checkExamPermission(user_thrift.CheckExamPermissionRequest(
userId=str(current_user.id)
))
if resp is None:
current_app.logger.error("[init_exam_v2] user_client.checkExamPermission failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(errors.error({'code': resp.statusCode, 'msg': resp.statusMsg}))
# 生成当前题目
resp = exam_client.initNewExam(exam_thrift.InitNewExamRequest(
userId=str(current_user.id),
templateId=paper_tpl_id
))
if resp is None:
current_app.logger.error("[init_exam_v2] exam_client.initNewExam failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(errors.error({'code': resp.statusCode, 'msg': resp.statusMsg}))
# todo: change to rpc
if Setting.LIMIT_EXAM_TIMES:
current_user.remaining_exam_num -= 1
current_user.save()
ExamSession.set(current_user.id, 'test_id', resp.examId)
ExamSession.set(current_user.id, 'testing', 'True') # for find-left-exam
return jsonify(errors.success())
def wxbt_upload_success():
"""
请求参数：questionNum, testID （json）
上传音频完成，告知后端可以进行处理
"""
q_num = str(request.json.get("questionNum"))
test_id = str(request.json.get("testID"))
if q_num is None or test_id is None:
return jsonify(errors.Params_error)
current_app.logger.info(
"wx:upload_success:question_num: %s, current_id: %s" %
(str(q_num), test_id))
current_test = BtCurrentTestModel.objects(id=test_id).first()
if current_test is None:
current_app.logger.error(
"upload_success: ERROR: Test Not Exists!! - test_id: %s" % test_id)
return jsonify(errors.Exam_not_exist)
q = current_test.questions.get(q_num)
if q is None:
return jsonify(errors.error({'msg': '题号无效'}))
upload_url = q['wav_upload_url']
current_app.logger.info("upload_success: upload_url: " + upload_url)
# change question status to handling
q.status = 'handling'
q['analysis_start_time'] = datetime.datetime.utcnow()
current_test.save()
task_id, err = MyCelery.put_task(q.q_type,
current_test.id,
q_num,
use_lock=False)
if err:
current_app.logger.error(
'[PutTaskException][wxbt_upload_success]q_type:%s, test_id:%s,'
'exception:\n%s' %
(q.q_type, current_test.id, traceback.format_exc()))
return jsonify(errors.exception({'Exception': str(err)}))
current_app.logger.info("[PutTaskSuccess][wxbt_upload_success]dataID: %s" %
str(current_test.id))
resp = {
"status": "Success",
"desc": "添加任务成功，等待服务器处理",
"dataID": str(current_test.id),
"taskID": task_id
}
return jsonify(errors.success(resp))
def get_test_wav_url():
resp = exam_client.getFileUploadPath(exam_thrift.GetFileUploadPathRequest(
userId=str(current_user.id),
type=exam_thrift.ExamType.AudioTest
))
if resp is None:
current_app.logger.error("[get_test_wav_url] exam_client.getFileUploadPath failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(errors.error({'code': resp.statusCode, 'msg': resp.statusMsg}))
return jsonify(errors.success({
"fileLocation": "BOS",
"url": resp.path,
}))
def get_test_wav_info():
resp = exam_client.initNewAudioTest(exam_thrift.InitNewAudioTestRequest(
userId=str(current_user.id)
))
if resp is None:
current_app.logger.error("[get_test_wav_info] exam_client.initNewAudioTest failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(errors.error({'code': resp.statusCode, 'msg': resp.statusMsg}))
return jsonify(errors.success({
"questionLimitTime": resp.question.answerLimitTime,
"readLimitTime": resp.question.readLimitTime,
"questionContent": resp.question.content,
"questionInfo": resp.question.questionTip,
}))
def update_privilege(code):
resp = user_client.updateUserInfo(
user_thrift.UpdateUserInfoRequest(userId=str(current_user.id),
invitationCode=code))
if resp is None:
current_app.logger.error(
"[update_privilege] user_client.updateUserInfo failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
return jsonify(errors.success())
def get_paper_templates():
resp = exam_client.getPaperTemplate(exam_thrift.GetPaperTemplateRequest())
if resp is None:
current_app.logger.error("[get_paper_templates] exam_client.getPaperTemplate failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(errors.error({'code': resp.statusCode, 'msg': resp.statusMsg}))
tpl_lst = []
for item in resp.templateList:
if not item.isDeprecated:
tpl_lst.append({
'tpl_id': item.id,
'name': item.name
})
return jsonify(errors.success({'paperTemplates': tpl_lst}))
def get_upload_url_v2(question_num):
test_id = ExamSession.get(current_user.id, "test_id", default=DefaultValue.test_id) # for production
resp = exam_client.getFileUploadPath(exam_thrift.GetFileUploadPathRequest(
examId=test_id,
userId=str(current_user.id),
type=exam_thrift.ExamType.RealExam,
questionNum=int(question_num)
))
if resp is None:
current_app.logger.error("[get_upload_url_v2] exam_client.getFileUploadPath failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(errors.error({'code': resp.statusCode, 'msg': resp.statusMsg}))
context = {"fileLocation": "BOS", "url": resp.path}
return jsonify(errors.success(context))
def login():
authorization = request.headers.get("Authorization", None)
token = ""
is_login = False
# already login
if authorization:
try:
token = authorization.split(' ')[1]
payload = jwt.decode(token, "secret", algorithms="HS256")
if payload:
current_app.logger.info("re-login")
is_login = True
# current_app.logger.info('re-login user: %s, id: %s' % (check_user.name, check_user.id))
except Exception as e:
current_app.logger.error(e)
if not is_login:
username = request.form.get('username')
password = request.form.get('password')
if not (username and password):
return jsonify(errors.Params_error)
resp = user_client.authenticate(
user_thrift.AuthenticateRequest(username=username,
password=password))
if resp is None:
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
token = resp.token
payload = jwt.decode(token, "secret", algorithms="HS256")
return jsonify(
errors.success({
'msg': '登录成功',
"token": token,
'uuid': payload["uuid"],
'name': payload["nick_name"],
'role': payload["role"]
}))
def register():
current_app.logger.info('register request: %s' % request.form.__str__())
if current_user.is_authenticated:
return jsonify(errors.Already_logged_in)
if not current_app.config.get('ALLOW_REGISTER'):
return jsonify(errors.Register_not_allowed)
username = request.form.get('username').strip().lower()
password = request.form.get('password').strip()
name = request.form.get('name').strip()
code = request.form.get('code').strip()
"""
校验form，规则
1. email符合规范
2. 各项不为空
"""
if not (username and password and name):
return jsonify(errors.Params_error)
if current_app.config.get('NEED_INVITATION') and not code:
return jsonify(errors.Params_error)
invitation_code = None
if current_app.config.get('NEED_INVITATION'):
invitation_code = code
resp = user_client.createUser(
user_thrift.CreateUserRequest(username=username,
password=password,
name=name,
invitationCode=invitation_code))
if resp is None:
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
return jsonify(
errors.success({
'msg': '注册成功',
'username': username,
'nickname': name
}))
def cancel_up(question_id):
resp = question_client.saveQuestionFeedback(
question_thrift.SaveQuestionFeedbackRequest(questionId=question_id,
userId=str(
current_user.id),
upChange=-1))
if resp is None:
current_app.logger.error(
"[cancel_up] question_client.saveQuestionFeedback failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
return jsonify(errors.success())
def wechat_login():
if current_user.is_authenticated:
return jsonify(errors.Already_logged_in)
code = request.form.get('code')
if not code:
return jsonify(errors.Params_error)
err_code, user_info = wx_get_user_info(code,
current_app.config['WX_APPID'],
current_app.config['WX_SECRET'])
if err_code:
return jsonify(
errors.error({
'code': int(err_code),
'msg': 'invalid wechat code'
}))
wx_union_id = user_info.get('unionid')
check_user = UserModel.objects(wx_id=wx_union_id).first()
if not check_user:
session['wx_union_id'] = wx_union_id
# data = {'msg': '用户尚未绑定微信，前端请指引用户补充填写信息，进行绑定'}
# data.update({'userInfo': user_info})
# return jsonify(errors.error(data))
headimgurl = user_info.get('headimgurl')
nickname = user_info.get('nickname').encode('ISO-8859-1').decode(
'utf-8') # 要转码
return jsonify(
errors.success({
'msg': '未绑定用户',
'headimgurl': headimgurl,
'nickname': nickname,
}))
session['wx_nickname'] = user_info.get('nickname')
login_user(check_user)
check_user.last_login_time = datetime.datetime.utcnow()
check_user.save()
current_app.logger.info('login from wechat: %s, id: %s' %
(check_user.name, check_user.id))
return jsonify(
errors.success({
'msg': '已绑定用户，自动登录',
'uuid': str(check_user.id),
'name': str(check_user.name),
}))
def get_history_report(test_id):
resp = exam_client.getExamReport(
exam_thrift.GetExamReportRequest(examId=test_id))
if resp is None:
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
report = resp.report
score = resp.score
result = {
"report": exam_report_convert_to_json(report),
"data": exam_score_convert_to_json(score)
}
return jsonify(errors.success(result))
def delete_specific_question_from_pool():
"""
删除题库中题目
"""
resp = question_client.delOriginalQuestion(
question_thrift.DelOriginalQuestionRequest(
id=int(request.form.get('idInPool'))))
if resp is None:
current_app.logger.error(
"[delete_specific_question_from_pool] question_client.delOriginalQuestion failed"
)
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
return jsonify(errors.success())
def enable_paper_template():
template_id = request.form.get('id')
resp = exam_client.savePaperTemplate(
exam_thrift.SavePaperTemplateRequest(
newTemplate=exam_thrift.ExamTemplate(
id=template_id,
isDeprecated=False,
)))
if resp is None:
current_app.logger.error(
"[enable_paper_template] exam_client.savePaperTemplate failed")
return jsonify(errors.Internal_error)
if resp.statusCode != 0:
return jsonify(
errors.error({
'code': resp.statusCode,
'msg': resp.statusMsg
}))
return jsonify(errors.success())
