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))