def make_comments():
"""发表评论接口，post请求中携带的data为：
phone_num:电话号。代表学生
course_id：课程的id
content：评论的内容
url: http://www.xiaochengxueeg.xyz:8888/make_comment
:return 所增增加评论的详细信息
"""
phone_num = request.values.get("phone_num")
course_id = request.values.get("course_id")
content = request.values.get("content")
try:
course_entry = CoursesEntry.query.filter_by(phone_num=phone_num, course_id=course_id).first()
except Exception as e:
msg = "获取用户%s/课程%s 信息失败，error:%s" % (phone_num, course_id, str(e))
current_app.logger.info(msg)
return utils.make_resp(msg=json.dumps(msg), status=500)
if not course_entry:
# 没有权限 status=201 msg=Can't Make Comment, Permission Denied
msg = "Can't Make Comment, Permission Denied"
current_app.logger.error(msg)
return utils.make_resp(msg=json.dumps(msg), status=201)
current = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
user = db.session.query(Users).filter_by(phone_num=phone_num).first()
comment_info = {
"user_id": user.id,
"course_id": course_id,
"content": content,
"comment_time": current
}
comment = Comments(**comment_info)
db.session.add(comment)
try:
db.session.commit()
current_app.logger.info("<%s>评论课程<%s>成功, 评论内容：%s" % (phone_num, course_id, content))
except Exception as e:
msg = "用户<%s>评论 课程<%s>失败, error:%s" % (phone_num, course_id, str(e))
current_app.logger.error(msg)
return utils.make_resp(msg=json.dumps(msg), status=500)
comment_info['nickName'] = user.nickName
comment_info['phone_num'] = phone_num
comment_info['msg'] = "success"
return jsonify(comment_info)
def get_user_info():
"""获取用户信息，get请求中参数携带nickName + user_type
此接口中角色必须绑定了微信名才可查询
url: http://39.108.166.132:8888/get_user_info? nickName=xxx & user_type=xxx
:return 查询到的用户信息, 如果没信息则时空列表
"""
current_app.logger.info("get user info")
nickName = request.values.get("nickName")
user_type = request.values.get("user_type")
user = db.session.query(Users).filter_by(nickName=nickName, user_type=user_type).first()
if not user:
errmsg = "用户%s不存在" % nickName
resp = utils.make_resp(msg=json.dumps(errmsg), status=201)
return resp
user_info = {
"nickName": nickName,
"user_type": user_type,
"phone_num": user.phone_num,
"intro": user.intro,
'photo': user.photo
}
if user_type == "students":
# user_info["waves"] = user.students.waves
pass
elif user_type == "teachers":
# user_info["courses"] = user.teachers.courses
user_info["school_id"] = user.teacher.school_id
else:
user_info["principal"] = user.school.principal
user_info["building"] = user.school.building
current_app.logger.info("get <%s>'s info ok, data-->%s" % (nickName, user_info))
return jsonify(user_info)
def get(self, tid):
task = g.current_task
students = task.students
key = "task_finished:" + str(task.id)
stu_list = []
for student in students:
score = 0
task_answer = set(student.answers).intersection(
set(g.current_task.answers))
if task_answer:
score = task_answer.pop().score
if not r.sismember(key, student.id):
finished = False
else:
finished = True
data = {
"name": student.name,
"student_id": student.student_id,
"finished": finished,
"score": score
}
stu_list.append(data)
return make_resp(stu_list)
def put(self, cid):
# make a commit
user = g.current_user
key = "commits:" + str(g.current_course.id)
commit_recent = r.lindex(key, 0)
if commit_recent is None:
return api_abort(400, "there do not exist commit now")
commit_recent = pickle.loads(commit_recent)
time_now = time()
if time_now < strptime(commit_recent['begin']) or time_now > strptime(commit_recent['end']):
return api_abort(400, "there do not exist commit now")
unfinished = commit_recent['unfinished']
finished = commit_recent['finished']
stu_data = dict()
stu_data['id'] = user.id
stu_data['name'] = user.name
for value in unfinished:
if value['id'] == user.id:
unfinished.remove(value)
finished.append(stu_data)
commit_recent['unfinished'] = unfinished
commit_recent['finished'] = finished
r.lset(key, 0, pickle.dumps(commit_recent))
return make_resp("OK")
def get(self, cid):
students = g.current_course.students
page = request.args.get("page", 1)
per_page = request.args.get("per_page", 20)
students = students[(page-1)*per_page:page*per_page]
data = User.list_to_json(students)
return make_resp(data)
def post(self):
if not g.current_user.is_teacher(g.current_task_answer.task.course):
return api_abort(403, "not the teacher")
# 要是想以另一种形式返回也行
check_res_list = check_answer_reqparser.parse_args()['check_res']
check_res_list = eval(check_res_list)
answers = dict()
answer = g.current_task_answer.answers
for ans in answer:
answers[int(ans.order)] = ans
for check_res in check_res_list:
order = check_res['order']
ans = answers[order]
score = check_res['score'] if check_res[
'score'] is not None else ans.score
if score > ans.problem.max_score:
return api_abort(
400,
"the score of answer ordered {} is too high".format(order))
ans.score = score
ans.comment = check_res.get("comment", None)
g.current_task_answer.judge_score()
db.session.commit()
return make_resp("OK")
def post(self, cid):
course = g.current_course
data = task_create_reqparser.parse_args()
new_task = Task(data['type'], data['name'], data['t_begin'], data['t_end'],
int(data['ans_visible']), data['introduce'], data['expires'])
probs = eval(data['problems'])
prob_list = []
for v in probs.values():
prob_list.append(v)
prob_order_set = set()
for prob in prob_list:
prob = prob_parser(prob)
if not prob:
return api_abort(400, 'bad prob param')
if prob['order'] in prob_order_set:
return api_abort(400, 'duplicate of order')
prob_order_set.add(prob['order'])
new_prob = create_prob(prob)
new_task.problems.append(new_prob)
new_task.judge_max_score()
[new_task.students.append(student) for student in course.students]
r.sadd("task_finished:"+str(new_task.id), g.current_user.id)
course.tasks.append(new_task)
db.session.commit()
resp = new_task.to_json(g.current_user, detail=True)
return make_resp(resp)
def post(self):
data = user_create_reqparser.parse_args()
if not validate_verify_code(data['telephone'], 'signup', data['code']):
return api_abort(401, 'wrong verify code')
user = User(data['nickname'], data['telephone'], data['password'])
db.session.add(user)
db.session.commit()
return make_resp(user.to_json(detail=True))
def delete(self):
code = user_del_reqparser.parse_args()['code']
if validate_verify_code(g.current_user.telephone, 'delAccount', code):
db.session.delete(g.current_user)
else:
return api_abort(401, 'wrong code')
db.session.commit()
return make_resp({})
def get(self):
courses = Course.query.filter_by(public=True)
teacher_id = request.args.get('teacher_id', None)
if teacher_id is not None:
courses = courses.filter_by(teacher_id=teacher_id)
courses = courses.all()
data = Course.list_to_json(courses)
return make_resp(data)
def post(self, cid):
# post a discussion
data = discussion_reqparser.parse_args()
new_discussion = Discussion(data['content'])
new_discussion.master = g.current_user
new_discussion.course = g.current_course
db.session.add(new_discussion)
db.session.commit()
return make_resp(new_discussion.to_json(detail=True))
def get(self):
student = g.current_user
tasks = student.tasks
time_now = time()
time_latest = time_now - 3600 * 24 * 7
task_list = []
for task in tasks:
if task.create_at > time_latest:
task_list.append(task)
return make_resp(Task.list_to_json(task_list, g.current_user))
def post(self, cid):
# submit a commit
data = commit_create_reqparser.parse_args()
status, message = validate_commit_time(g.current_course.id, data['expires']*60)
if not status:
return api_abort(400, message)
new_commit = create_commit(g.current_course, data['expires']*60)
r.lpush("commits:" + str(g.current_course.id), pickle.dumps(new_commit))
return make_resp(new_commit)
def get(self, cid):
# get commit status and it's info
data = dict()
data['exist'] = 0
data['finish'] = 0
commit_recent = r.lindex("commits:" + str(g.current_course.id), 0)
if commit_recent is None:
return make_resp(data)
commit_recent = pickle.loads(commit_recent)
time_now = time()
if strptime(commit_recent['end'])> time_now > strptime(commit_recent['begin']):
data['exist'] = 1
data['finished'] = len(commit_recent['finished'])
data['unfinished'] = len(commit_recent['unfinished'])
for value in commit_recent['finished']:
if value['id'] == g.current_user.id:
data['finish'] = 1
return make_resp(data)
def get(self, tid, order):
task = g.current_task
problem = None
for prob in task.problems:
if prob.order == order:
problem = prob
break
if problem is None:
return api_abort(404, "problem order {} not found".format(order))
return make_resp(problem.to_json())
def get(self):
courses = Course.query.filter_by(teacher_id=g.current_user.id).all()
task_list = []
for course in courses:
tasks = course.tasks
for task in tasks:
task_list.append(task)
data = Task.list_to_json(task_list, g.current_user)
return make_resp(data)
def get(self):
courses = g.current_user.courses
public = request.args.get("public")
if public is not None:
public = int(public)
course_list = []
for course in courses:
if course.public == public:
course_list.append(course)
courses = course_list
return make_resp(Course.list_to_json(courses))
def post(self, cid):
course = g.current_course
user = g.current_user
if course in user.courses:
return api_abort(400, "you already in the course")
if user.is_teacher(course):
return api_abort(403, "you are the teacher!")
if not course.public:
return api_abort(403, "can only join the public course")
course.students.append(user)
db.session.commit()
return make_resp(course.to_json())
def get(self, cid):
# course = g.current_course
# return make_resp(Task.list_to_json(course.tasks, g.current_user))
task_query = Task.query.filter_by(course_id=cid)
task_type = request.args.get("type")
if task_type is not None:
task_query = task_query.filter_by(type=task_type)
per_page = int(request.args.get("per_page", 20))
page = int(request.args.get("page", 1))
tasks_pagination = task_query.paginate(page, per_page=per_page, error_out=False)
data = Task.page_to_json(tasks_pagination, g.current_user, cid)
return make_resp(data)
def post(self):
data = course_create_reqparser.parse_args()
new_course = Course(data['name'], data['public'], g.current_user.id,
data['start_at'], data['end_at'], data['introduce'])
new_media = request.files.get("avatar")
if new_media is None:
return api_abort(400, "file missing")
new_media_uuid = Media.save_media(new_media, "avatars/course", commit=False)
new_course.avatar = new_media_uuid
db.session.add(new_course)
db.session.commit()
return make_resp(new_course.to_json(detail=True))
def post(self, cid):
course = g.current_course
data = parse_excel(request, 'excel_file') # it's a list
for item in data:
item = deal_import_data(item)
user = User.query.filter_by(school=item['school'], student_id=item['student_id']).first()
if user is None:
key = item['school'] + ":" + item['student_id']
item['courses'].append(course.id)
r.set(key, pickle.dumps(item))
else:
user.courses.append(course)
user.name = item['name']
db.session.commit()
return make_resp(course.to_json(detail=True))
def post(self, cid):
data = notice_create_reqparser.parse_args()
new_notice = Notice(data['title'], data['content'])
new_notice.course = g.current_course
try:
students = new_notice.course.students
for student in students:
send_notice(student, new_notice)
except:
pass
db.session.add(new_notice)
db.session.commit()
return make_resp(new_notice.to_json(detail=True))
def post(self, discus_id):
# post a comment
data = comment_reqparser.parse_args()
new_comment = Comment(data['content'], data['reply'])
new_comment.author = g.current_user
new_comment.discussion = g.current_discussion
db.session.add(new_comment)
if data['reply'] is not None:
comment_reply = Comment.query.get(data['reply'])
if comment_reply is None:
return api_abort(404, "comment reply is not exist")
replies = pickle.loads(comment_reply.replies)
replies.append(new_comment.id)
comment_reply.replies = pickle.dumps(replies)
db.session.commit()
return make_resp(g.current_discussion.to_json(detail=True))
def get(self, tid, order):
task = g.current_task
user = g.current_user
task_answer = set(task.answers).intersection(set(user.answers))
if not task_answer:
return api_abort(404, "you have not finished the problem")
task_answer = task_answer.pop()
answers = task_answer.answers
answer_return = None
for answer in answers:
if answer.problem.order == order:
answer_return = answer
break
if answer_return is None:
return api_abort(404, "answer order {} not found".format(order))
return make_resp(answer_return.to_json())
def put(self):
base_info = ['nickname', 'gender', 'introduce']
data = user_put_reqparser.parse_args()
for info in base_info:
if data[info] is not None:
setattr(g.current_user, info, data[info])
for info in secure_info_map:
if data[info] is not None:
if not validate_and_change_info(
info, data[info],
data["code_" + secure_info_map[info]]):
return api_abort(400, "wrong code")
db.session.commit()
return make_resp(g.current_user.to_json(detail=True))
def get(self, tid):
order = request.args.get("order", None)
if order is None:
return api_abort(400, "param order is needed")
order = int(order)
problem = None
for prob in g.current_task.problems:
if prob.order == order:
problem = prob
break
if problem is None:
return api_abort(400,
"problem order {} is not found".format(order))
detail = request.args.get("detail", False)
data = problem.statistic(detail)
return make_resp(data)
def get(self, tid):
task = g.current_task
user = g.current_user
uncheck = request.args.get('uncheck', 0)
task_answer = None
if uncheck:
if not user.is_teacher(task.course):
return api_abort(403, 'not the teacher')
for answer in task.answers:
if not answer.status:
task_answer = answer
break
if task_answer is None:
return api_abort(404, "all answers checked")
else:
task_answer = set(user.answers).intersection(set(task.answers))
if not task_answer:
return api_abort(404, "have not finished the task")
task_answer = task_answer.pop()
return make_resp(task_answer.to_json(detail=True))
def post(self, cid):
# expected str chapter and file document, if chapter not exist, create it.
data = upload_reqparser.parse_args()
chapter_name = data['chapter']
name = data['name']
chapter = Chapter.query.filter_by(name=chapter_name, course_id=g.current_course.id).first()
if chapter is None:
chapter = Chapter(chapter_name)
chapter.course = g.current_course
db.session.add(chapter)
course = g.current_course
movie = request.files.get('movie')
if movie is None:
return api_abort(400, "movie is None")
new_media_uuid = Media.save_media(movie, 'course/{}/movie'.format(course.id), name=name)
media_uuid_list = pickle.loads(chapter.movies)
media_uuid_list.append(new_media_uuid)
chapter.movies = pickle.dumps(media_uuid_list)
db.session.commit()
return make_resp(chapter.to_json(with_movies=True))
def get(self, cid):
key = "commits:" + str(g.current_course.id)
commits = r.lrange(key, 0, r.llen(key))
# find commit by commit id
commit_id = request.args.get("commit_id")
if commit_id is not None:
status = 0
for commit in commits:
if commit['id'] == commit_id:
commits = [commit]
status = 1
break
if not status:
return api_abort(404, "resource commit not found")
commit_list = []
for commit in commits:
commit_list.append(pickle.loads(commit))
data = {
"count": len(commits),
"commits": commit_list
}
return make_resp(data)
def post(self):
data = stu_certificate_reqparser.parse_args()
school = data['school']
student_id = data['student_id']
code = data['certificate_code']
data_string = r.get((school + ":" + student_id))
if data_string is None:
return api_abort(401, "certificate info not exist")
data = pickle.loads(data_string)
print(data)
if not data['certificate_code'] == code:
print(str(data['certificate_code']))
return api_abort(403, 'wrong certificate code')
user = g.current_user
courses = data['courses']
data.pop('courses')
data.pop("certificate_code")
edit_module(user, data)
for cid in courses:
course = Course.query.get(cid)
if not user.is_teacher(course):
user.courses.append(course)
db.session.commit()
return make_resp(user.to_json(detail=True))
