def query(self):
id = request.args.get("id") or request.form.get("id")
#判断参数是否存在
if not id:
return error.error_1001()
row = Question.QueryJoinCategory().filter(Question.id == id).first()
question = {}
if row:
opts = Option.Query().filter_by(question_id=row.Question.id).all()
options = []
for op in opts:
option = {
"id": op.id,
"label": op.label,
"content": op.content,
"created_time": datetime.timestamp(op.created_time)
}
options.append(option)
question = {
"id": row.Question.id,
"content": row.Question.content,
"type": row.Question.type,
"category_id": row.Question.category_id,
"category_name": row.Category.name,
"subject": row.Category.subject,
"right_answer": row.Question.right_answer,
"answer_analyze": row.Question.answer_analyze,
"options": options,
"created_time": datetime.timestamp(row.Question.created_time)
}
return error.success(question)
def post(self):
form = request.form
id = form.get("id")
if not id:
return error.error_1001()
user = User.Query().filter_by(id=id).first()
# 可以修改的信息：real_name, password, phone
real_name = form.get("real_name")
password = form.get("password")
phone = form.get("phone")
# 判断real_name是否存在
if real_name:
user.real_name = real_name
# 判断password是否存在
if password:
user.password = bcrypt.generate_password_hash(password).decode("utf-8")
# 判断phone是否存在
if phone:
phone_count = User.Query().filter(and_(User.phone == phone, User.id != id)).count()
if phone_count:
return error.error_1002("此手机号已存在")
user.phone = phone
# 提交到数据库
db.session.add(user)
try:
db.session.commit()
except:
return error.error_1003()
return error.success()
def post(self):
print(request.headers)
form = request.form
username = form.get("username")
password = form.get("password")
print(form)
print(request.get_data())
#username 和 password不能为空
if not username or not password:
return error.error_1001()
user = User.Query().filter(or_(User.name==username, User.phone==username)).first()
#判断user是否存在
if not user:
return error.error_1004()
#判断密码是否正确
if not bcrypt.check_password_hash(user.password, password):
return error.error_1004()
#获取uid
uid = user.id
#生成token
token_str = "{0}{1}{2}".format(user.name, uid, time()).encode("utf-8")
token = hashlib.sha1(token_str).hexdigest()
redisClient.set(token, uid)
redisClient.expire(token, config.redis_expireTime)
return error.success({"token": token, "uid": uid})
def post(self):
id = request.form.get("id")
if not id:
return error.error_1001()
user = User.Query().filter_by(id=id).first()
# 判断user是否存在
if user:
user.is_valid = False
db.session.add(user)
db.session.commit()
return error.success()
def query(self):
id = request.args.get("id") or request.form.get("id")
if not id:
return error.error_1001()
# 查询数据库
row = Paper.Query().filter_by(id=id).first()
paper = {}
if row:
paper = {"id": row.id, "name": row.name, "subject": row.subject}
return error.success(paper)
def post(self):
id = request.form.get("id")
if not id:
return error.error_1001()
# 查询数据库
question = Question.Query().filter_by(id=id).first()
if question:
question.is_valid = False
db.session.add(question)
db.session.commit()
# 返回结果
return error.success()
def query(self):
name = request.args.get("name") or request.form.get("name")
print(name)
if not name:
return error.error_1001()
row = Category.Query().filter_by(name=name).first()
category = {}
if row:
category = {
"id": row.id,
"name": row.name,
"subject": row.subject
}
return error.success(category)
def post(self):
form = request.form
print(form)
content = form.get("content")
category_id = form.get("category_id")
right_answer = form.get("right_answer")
options = form.get("options")
# 判断参数是否为空
if not content or not right_answer or not category_id:
return error.error_1001()
# 判断right_answer是否合法
answers_lst = right_answer.split(",")
for answer in answers_lst:
if answer not in ["A", "B", "C", "D", "E"]:
return error.error_1007()
# 判断题目是否重复
content_count = Question.Query().filter_by(content=content).count()
if content_count:
return error.error_1002("题目不能重重")
# 将题目添加到到数据库
question = Question(form)
db.session.add(question)
db.session.flush()
# 获取题目的临时id
question_id = question.id
# 解析选项
options = json.loads(options)
for r in options:
r["question_id"] = question_id
# 判断label是否合法
if not r.get("label") or r.get("label") not in [
"A", "B", "C", "D", "E"
]:
return error.error_1007()
# 同一题目A,B,C,D,E出现两次
label_count = Option.Query().filter_by(question_id=question_id,
label=r["label"]).count()
print("label_count ", label_count)
if label_count:
return error.error_1002(r["label"] + "重复")
option = Option(r)
db.session.add(option)
db.session.commit()
return error.success()
def post(self):
id = request.form.get("id")
if not id:
return error.error_1001()
# 查询该考试中是否有题目
question_count = Question.Query().filter_by(paper_id=id).count()
if question_count:
return error.error_1008("此考试中有题目，不能被删除！")
# 查询数据库
paper = Paper.Query().filter_by(id=id).first()
if paper:
paper.is_valid = False
db.session.add(paper)
db.session.commit()
return error.success()
def post(self):
form = request.form
# 获取参数
id = form.get("id")
content = form.get("content")
category_id = form.get("category_id")
right_answer = form.get("right_answer")
options = form.get("options")
answer_analyze = form.get("answer_analyze")
print(answer_analyze)
#判断参数是否为空
if not id:
return error.error_1001()
# 查询数据库
question = Question.Query().filter_by(id=id).first()
# 判断需要修改的数据
# 修改题目标题
if content:
question.content = content
# 修改题目分类
if category_id:
question.category_id = category_id
# 修改正确答案
if right_answer:
question.right_answer = right_answer
answers_lst = right_answer.split(",")
length = len(answers_lst)
type = "single"
if length > 1:
type = "double"
question.type = type
# 修改题目选项
if options:
options = json.loads(options)
for op in options:
option = Option.Query().filter_by(id=op.get("id")).first()
option.content = op.get("content")
option.label = op.get("label")
db.session.add(option)
# 修改题目答案解析
if answer_analyze:
question.answer_analyze = answer_analyze
# 提交到数据库
db.session.add(question)
db.session.commit()
return error.success()
def query(self):
id = request.args.get("id") or request.form.get("id")
# 判断id是否为空
if not id:
return error.error_1001()
# 查询数据库
row = Category.Query().filter_by(id=id).first()
category = {}
if row:
category = {
"id": row.id,
"name": row.name,
"subject": row.subject,
"chapter": row.chapter,
"created_time": datetime.timestamp(row.created_time)
}
return error.success(category)
def query(self):
subject = request.args.get("subject") or request.form.get("subject")
# 判断是否选择学科
if not subject:
return error.error_1001()
# 查询用户已答题
user_id = g.uid
user_answered = Answer.Query().filter_by(user_id=user_id).all()
user_answered_ids = []
for r in user_answered:
user_answered_ids.append(r.question_id)
print(user_answered_ids)
user_answered_ids_t = tuple(user_answered_ids)
# 查出没有答过的题目
res = Question.QueryJoinCategory().filter(
Category.subject == subject).filter(
not_(Question.id.in_(user_answered_ids_t))).order_by(
func.rand()).first()
count = Question.QueryJoinCategory().filter(
Category.subject == subject).filter(
not_(Question.id.in_(user_answered_ids_t))).count()
print(count)
question = {}
if res:
# 获取题目选项
rows = Option.Query().filter_by(question_id=res.Question.id).all()
options = []
for r in rows:
option = {"id": r.id, "label": r.label, "content": r.content}
options.append(option)
question = {
"id": res.Question.id,
"type": res.Question.type,
"content": res.Question.content,
"category_name": res.Category.name,
"category_id": res.Category.id,
"options": options
}
return error.success(question)
def post(self):
id = request.form.get("id")
name = request.form.get("name")
# 判断id和name是否为空
if not id or not name:
return error.error_1001()
# 查询数据库
paper = Paper.Query().filter_by(id=id).first()
if paper:
# 判断name是否重复
name_count = Paper.Query().filter(
and_(Paper.name == name, Paper.id != id)).count()
if name_count:
return error.error_1002("此考试名称已存在")
# 提交到数据库
paper.name = name
db.session.add(paper)
db.session.commit()
return error.success()
def post(self):
id = request.form.get("id")
# 判断id是否为空
if not id:
return error.error_1001()
# 查看该分类下是否有题目
question_count = Question.Query().filter_by(category_id=id).count()
if question_count:
return error.error_1008("该分类中有题目，不能被删除");
# 查询数据库
category = Category.Query().filter_by(id=id).first()
# 判断category是否存在
if category:
# 修改并提交到数据库
category.is_valid = False
db.session.add(category)
db.session.commit()
return error.success()
def query(self):
subject = request.args.get("subject") or request.form.get("subject")
# 判断subject是否为空
if not subject:
return error.error_1001()
# 判断subject值是否有效
if subject not in config.subjects:
return error.error_1006()
# 查询数据库
rows = Paper.Query().filter_by(subject=subject).all()
papers = []
for r in rows:
paper = {
"id": r.id,
"name": r.name,
"subject": r.subject,
"created_time": datetime.timestamp(r.created_time)
}
papers.append(paper)
return error.success(papers)
def post(self):
form = request.form
name = form.get("name")
subject = form.get("subject")
# 判断name和subject是否为空
if not name or not subject:
return error.error_1001()
# 判断sucject是否合法
if subject not in config.subjects:
return error.error_1006()
# 判断name是否存在
paper_count = Paper.Query().filter_by(name=name).count()
if paper_count:
return error.error_1002("此考试名称已经存在")
# 提交到数据库
paper = Paper(form)
try:
db.session.add(paper)
db.session.commit()
except:
return error.error_1003()
return error.success()
def post(self):
id = request.form.get("id")
name = request.form.get("name")
chapter = request.form.get("chapter")
# 判断id是否为空
if not id or not name:
return error.error_1001()
# 获取category
category = Category.Query().filter_by(id=id).first()
# 判处category是否存在
if category:
# 判断name是否存在
category_count = Category.Query().filter(and_(Category.name == name, Category.id != id)).count()
if category_count:
return error.error_1002("此分类已存在")
category.name = name
if chapter:
category.chapter = chapter
db.session.add(category)
db.session.commit()
return error.success()
def post(self):
form = request.form
# 获取参数
question_id = form.get("question_id")
user_answer = form.get("user_answer")
# 判断参数是否存在
if not question_id or not user_answer:
return error.error_1001()
# 判断用户是否重复回答
answer_count = Answer.Query().filter_by(
user_id=g.uid, question_id=question_id).count()
if answer_count:
return error.error_1002("此题已经回答")
# 查询数据库
question = Question.Query().filter_by(id=question_id).first()
if not question:
return error.error_1009("题目不存在")
is_right = user_answer == question.right_answer
postData = {
"question_id": question_id,
"user_answer": user_answer,
"user_id": g.uid,
"is_right": is_right
}
answer = Answer(postData)
db.session.add(answer)
db.session.commit()
result = {
"id": answer.id,
"is_right": is_right,
"right_answer": question.right_answer,
"user_answer": user_answer
}
return error.success(result)
def post(self):
form = request.form
name = form.get("name")
phone = form.get("phone")
print(form)
print(request.get_data())
print(type(request.get_data()))
password = form.get("password")
openid = form.get("openid")
#phone,password不可以为空,username可以为空
if not phone or (not password):
return error.error_1001()
# 判断phone手机号是否存在
phone_count = User.Query().filter_by(phone=phone).count()
if phone_count:
return error.error_1002("此手机号已存在")
# 判断name用户名是否存在
name_count = User.Query().filter_by(name=name).count()
if name_count:
return error.error_1002("此用户已存在")
# 判断openid是否存在
if openid:
openid_count = User.Query().filter_by(openid=openid).count()
if openid_count:
return error.error_1002("此微信号已存在")
# 提交数据到数据库
user = User(form)
try:
db.session.add(user)
db.session.commit()
except:
return error.error_1003()
return error.success()
def query(self):
subject = request.args.get("subject") or request.form.get("subject")
# 判断subject是否存在
if not subject:
return error.error_1001()
# 判断subject值是否正确
if subject not in config.subjects:
return error.error_1006()
# 查询数据库
rows = Category.Query().filter_by(subject=subject).all()
print(rows)
categories = []
for r in rows:
question_count = Question.Query().filter_by(category_id=r.id).count()
category = {
"id": r.id,
"name": r.name,
"subject": r.subject,
"chapter": r.chapter,
"question_count": question_count,
"created_time": datetime.timestamp(r.created_time)
}
categories.append(category)
return error.success(categories)
def post(self):
form = request.form
name = form.get("name")
subject = form.get("subject")
print(form)
# 判断name和subject是否为空
if not name or not subject:
return error.error_1001()
# 同一科目下分类名称不能重复
name_count = Category.Query().filter_by(name=name, subject=subject).count()
if name_count:
return error.error_1002("此分类已存在")
# 判断subject是否合法
if subject not in config.subjects:
return error.error_1006()
# 提交到数据库
category = Category(form)
try:
db.session.add(category)
db.session.commit()
except:
return error.error_1003()
return error.success()