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 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, 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 post(self, cid):
if not g.current_user.is_teacher(g.current_course):
return api_abort(403, "permission denied")
old_media = Media.load_media_from_uuid(g.current_course.avatar, return_model=True)
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)
old_media.delete() if old_media is not None else 1
g.current_course.avatar = new_media_uuid
db.session.commit()
return "OK"
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 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, 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 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, 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, 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):
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):
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))
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 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 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, tid):
user = g.current_user
task = g.current_task
if user.is_teacher(task.course):
return api_abort(403, "you are the teacher")
time_now = time()
if not task.time_begin <= time_now <= task.time_end:
return api_abort(403, "not in the time")
# delete existed answer
exist_task_answer = set(task.answers).intersection(set(user.answers))
if exist_task_answer:
exist_task_answer = exist_task_answer.pop()
for answer in exist_task_answer.answers:
if answer.media is not None:
medias = Media.load_medias_from_uuid_list(
pickle.loads(answer.media), return_model=True)
for media in medias:
media.delete()
db.session.delete(exist_task_answer)
new_task_answer = TaskAnswer()
answers = answer_submit_reqparser.parse_args()['answers']
if not isinstance(answers, list):
answers = eval(answers)
problems = dict()
prob_order_set = set()
for prob in task.problems:
problems[prob.order] = prob
prob_order_set.add(prob.order)
answer_order_set = set()
for answer in answers:
if not isinstance(answer, dict):
answer = eval(answer)
content = answer.get('content', None)
if content == 'undefined':
content = None
order = answer.get("order", None)
if order is None:
return api_abort(400, "order is needed")
answer_order_set.add(order)
medias = request.files.getlist('answer' + str(order))
media_uuid_list = Media.save_medias(
medias, 'answer') if len(medias) is not 0 else None
new_answer = Answer(order, content, media_uuid_list)
new_answer.student = user
new_answer.problem = problems[order]
if new_answer.problem.type is not "subjective":
new_answer.judge_score()
new_task_answer.answers.append(new_answer)
if answer_order_set.difference(prob_order_set):
return api_abort(400, "answer order over the max order")
for order in prob_order_set.difference(answer_order_set):
medias = request.files.getlist('answer' + str(order), None)
media_uuid_list = Media.save_medias(
medias, 'answer') if len(medias) is not 0 else None
new_answer = Answer(order, medias=media_uuid_list)
new_answer.student = user
new_answer.problem = problems[order]
new_task_answer.answers.append(new_answer)
new_task_answer.student = user
new_task_answer.task = task
new_task_answer.judge_score()
r.sadd("task_finished:" + task.id, user.id)
db.session.add(new_task_answer)
db.session.commit()
data = new_task_answer.to_json(detail=True)
return make_resp(data)
def decorator(*args, **kws):
user = g.current_user
task = g.current_task
if not user.is_teacher(task.course):
return api_abort(403, "not the teacher")
return f(*args, **kws)
def decorator(cid):
if not g.current_user.is_teacher(g.current_course):
return api_abort(403, 'not the teacher')
return f(cid)
def decorator(*args, **kws):
user = g.current_user
course = g.current_task.course
if user not in course.students and not user.is_teacher(course):
return api_abort(403, "not the student ot teacher")
return f(*args, **kws)
def post(self, cid, comment_id):
if g.current_user.liked(comment_id, "comment"):
return api_abort(400, "already liked")
g.current_user.like(comment_id, "comment")
return "OK"
