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"