def post(self): data = request.get_json() # moge to tez w funkcji zamknac np checkPermission i raise custom error ktory zlapie na poziomie app grade_create_schema = GradeCreateSchema() grade = grade_create_schema.load(data) lecture_student = LectureStudents.query.filter_by( lecture_id=grade["lecture_id"], student_id=grade["student_id"]).first() if lecture_student is None: return {"mesage": "This student is not assigned to this lecture"} current_user_id = get_jwt_identity() #current_user = UserModel.query.get(current_user_id) teacher_id = lecture_student.lecture.teacher_id if current_user_id != teacher_id: return {"You have no permission to do that"} new_grade = Grade() new_grade.lecture_student = lecture_student new_grade.grade = grade['grade'] db.session.add(new_grade) db.session.commit() return {"data": self.grade_schema.dump(new_grade)}
def setUp(self): student = Student('test', 1) course = Course(1, 'test_course') datetime_format = '%Y-%m-%dT%H:%M:%SZ' assignment = Assignment(1, 'hw1', '2018-01-02T23:59:00Z', course, datetime_format) self.grade = Grade(student, course, assignment, 0.85)
def create(): user = get_jwt_identity params = request.json user = User.get_or_none(User.identity_card == get_jwt_identity()) new_grade = Grade(student_id=params.get("student_id"), subject_id=params.get("subject_id"), grade=params.get("grade"), year=params.get("year")) if user.roles == "staff": if new_grade.save(): response = [] for grade in Grade.select(): response.append({ "message": "Grade successfully updated", "status": "Success", "post_id": grade.subject_id, "staff_name": grade.grade, "title": grade.year, "post": grade.student_id }) else: response = { "error": new_grade.errors, "message": "Update failed, please try again", "status": "Failed" } else: response = {"message": "You are not allowed to perform this action!"} return jsonify(response)
def delete(self, uid): """ @apiDescription 删除评分 @api {delete} /shop/([0-9]+)/foods/grades/? 删除评分 @apiGroup grade @apiPermission user """ gid = int(self.get_argument("gid")) uid = self.get_current_user() Grade.delete(self.orm_session, uid, gid) self.write({})
def edit(id): params = request.json user = User.get_or_none(User.identity_card == get_jwt_identity()) edit_grade = Grade.get_or_none(Grade.id == id) edit_grade.subject = params.get("subject_id") edit_grade.grade = params.get("grade") edit_grade.student = params.get("student_id") edit_grade.year = params.get("year") if user.roles == "staff": if edit_grade.save(): response = { "message": "Grade successfully edited", "status": "Success", "subject_id": edit_grade.subject_id, "grade": edit_grade.grade, "year": edit_grade.year, "student_id": edit_grade.student_id } else: response = { "error": edit_grade.errors, "message": "Edit failed, please try again", "status": "Failed" } else: response = {"message": "You are not allowed to perform this action!"} return jsonify(response)
def _get_grade_info(self, fid, num=30): """获取食品评论和评分 @apiDescription 评分 @api {get} / 评分的字段 @apiGroup grade @apiSuccess {Number} gid 评分id @apiSuccess {Number} fid 食品id @apiSuccess {Number} uid 评论者 @apiSuccess {Number} seller 商家 @apiSuccess {Number} score 评分 @apiSuccess {String} score_at 评论时间 @apiSuccess {String} comment 评论内容 @apiSuccess {Number} speed 配送速度 """ grades = Grade.get_last_n_items(self.orm_session, fid, num) result = [] for grade in grades: result.append(dict( gid=grade.id, fid=fid, uid=grade.uid, seller=grade.seller, score=grade.score, score_at=str(grade.score_at), comment=grade.comment.decode("utf-8"), speed=grade.speed, )) return result
def delete(self, grade_id): validator = Validator(grade_id, "delete", GradeHandler.valid_model) grade = Grade.get_by_id(int(grade_id)) if grade: grade.key.delete() self.response.write(json.dumps(validator.success_message())) else: self.response.write(json.dumps(validator.error_message()))
def show(self, grade_id): grade = Grade.get_by_id(int(grade_id)) if grade: self.response.write(json.dumps(grade.dict())) else: """ Interesting thing here is validator doesn't really need to be called... """ validator = Validator(grade_id, "show", GradeHandler.valid_model) self.response.write(json.dumps(validator.error_message()))
def create(self): params = self.request.body validator = Validator(params, "create", GradeHandler.valid_model) new_grade_data = validator.good_create_request() if new_grade_data: # grade = Grade.create(new_grade_data) # if grade: # return ... new_grade = Grade(score=new_grade_data["score"]) s_key = new_grade_data.get("student_key") if s_key: student = Student.get_by_id(s_key) if student: new_grade.student = student.key new_grade.put() self.response.write(json.dumps(new_grade.dict())) else: self.response.write(json.dumps(validator.error_message()))
def setUp(self): student = Student('test', 1) course = Course(1, 'test_course') datetime_format = '%Y-%m-%dT%H:%M:%SZ' assignment1 = Assignment(1, 'hw1', '2018-01-02T23:59:00Z', course, datetime_format) assignment2 = Assignment(2, 'hw2', '2018-01-02T23:59:00Z', course, datetime_format) assignment3 = Assignment(3, 'hw3', '2018-01-02T23:59:00Z', course, datetime_format) assignment4 = Assignment(4, 'hw4', '2018-01-02T23:59:00Z', course, datetime_format) self.grade1 = Grade(student, course, assignment1, 0.85) self.grade2 = Grade(student, course, assignment2, 0.75) self.grade3 = Grade(student, course, assignment3, 0.65) self.grade4 = Grade(student, course, assignment4, 0.55) self.enrollment = Enrollment(student, course, [self.grade1], 0.75)
def parse_grade(grades_page): try: disciplines_raw = [ [cell.text for cell in row("td")] for row in BeautifulSoup(grades_page.content, features="lxml")("tr") ][1:] disciplines = Grade(disciplines_raw).__dict__ except: disciplines = None return disciplines
class GradeModelCase(unittest.TestCase): def setUp(self): student = Student('test', 1) course = Course(1, 'test_course') datetime_format = '%Y-%m-%dT%H:%M:%SZ' assignment = Assignment(1, 'hw1', '2018-01-02T23:59:00Z', course, datetime_format) self.grade = Grade(student, course, assignment, 0.85) def test_is_outlier(self): # Not an outlier result = self.grade.is_outlier(0.5, 1) self.assertFalse(result) # Low outlier result = self.grade.is_outlier(0.9, 1) self.assertTrue(result) # High outlier result = self.grade.is_outlier(0.5, 0.6) self.assertTrue(result)
def update(self, grade_id): grade = Grade.get_by_id(int(grade_id)) params = self.request.body validator = Validator(params, "update", GradeHandler.valid_model) grade_update_data = validator.good_update_request() if grade and grade_update_data: if "score" in grade_update_data.keys(): grade.score = grade_update_data["score"] grade.put() self.response.write(json.dumps(grade.dict())) else: self.response.write(json.dumps(validator.error_message()))
def insertGrade(): if request.method == 'POST': grade = request.form['grade'] student_id = request.form['student_id'] course_id = request.form['course_id'] grade = Grade(grade, student_id, course_id) if insertGrade(grade): return redirect(url_for('home')) else: error = 'ERROR' return render_template('insert-grade.html', error=error) else: return render_template('insert-grade.html')
def show(): user = User.get_or_none(User.identity_card == get_jwt_identity()) check_user = Grade.get_or_none(Grade.student == user.id) if user: if check_user or user.roles == "staff": grade_list = [] for grades in Grade: grade_list.append({ "full_name": grades.student.full_name, "identity_card": grades.student.identity_card, "subject_name": grades.subject.name, "grade": grades.grade }) return jsonify(grade_list)
def delete(): params = request.json user = User.get_or_none(User.identity_card == get_jwt_identity()) check_grade = params.get("id") if user.roles == "staff": grade = Grade.get_or_none(Grade.id == check_grade) if grade.delete_instance(): response = { "message": "Grade successfully deleted", "status": "Success", "grade_id_deleted": grade.id } else: response = { "message": "Delete failed, pkease try again", "status": "Failed" } else: response = {"message": "You are not allowed to perform this action!"} return jsonify(response)
def show(course_name, user_id, post_id): user = User.get_or_none(User.id == user_id) current_course = Course.get_or_none(Course.title == course_name) thread = Thread.get_or_none(Thread.course_id == current_course.id) if user.role.role == 'Teacher': submitted_assignments = [] for assignment in Assignment.select().where(Assignment.post_id == post_id): submitted_assignments.append(assignment) if user.role.role == 'Student': info = StudentCourse.get_or_none(StudentCourse.student_id == user.id, StudentCourse.course_name_id == current_course.id) submitted_assignments = Assignment.get_or_none(Assignment.info_id == info.id) assignment_post = [] week_num = [] i = 1 for post in Post.select().where(Post.thread_id == thread.id): if post.file_path: assignment_post.append(post) week_num.append(i) i += 1 grades = [] for grade in Grade.select(): grades.append(grade) assignment_week = dict(zip(week_num, assignment_post)) print(str(assignment_week)) # for assignment in Assignment.select().where() return render_template('posts/show.html', course_title=course_name, user_id=user_id, post_id=post_id, assignment_week=assignment_week, submitted_assignments=submitted_assignments, grades=grades) # is_student= user.role == "student"
from config.routes import routes from modules.linechart_module import LineChartModule from modules.fcq_card_module import FcqCardModule from models.fcq import Fcq from models.grade import Grade from models.course import Course from models.instructor import Instructor from models.department import Department from handlers.not_found_handler import NotFoundHandler import logging settings = { 'cookie_secret': 'PqITv9b7QUyoAUUcgfRtReoZIXjQrEKKk9fpQpGu6MU=', 'template_path': 'templates/', 'static_path': 'static/', 'grade': Grade(), 'fcq': Fcq(), 'course': Course(), 'instructor': Instructor(), 'department': Department(), 'default_handler_class': NotFoundHandler, 'ui_modules': { 'chart_overtime': LineChartModule, 'fcq_card': FcqCardModule } } def initialize_settings(): settings['debug'] = options.debug settings['autoreload'] = options.debug
def digest_grades(db, conn): data = dataSet('data/grades/grades.csv') grade_data = list(map(Grade().sanitize_from_raw, data.raw_data)) dci_from_data(grade_data, db, conn) batch_insert(db, conn, grade_data, 'Grade')
def grades(self): return Grade.query().filter(Grade.student == self.key)
def seed_grades(): for grade in grades: new_grade = Grade(**grade) db.session.add(new_grade) db.session.commit()
def index(self): grades = Grade.query() grade_arr = [] for grade in grades: grade_arr.append(grade.dict()) self.response.write(json.dumps(grade_arr))
enrollment = Enrollment( student, course, current_score=current_scores_dict.get( student.lms_id)) student_grades = [] for assignment in assignments: # Find the entry in grades_dict corresponding to this assignment assignment_score = [ s for s in grades_dict.get( str(student.lms_id), []) if str(s['lms_id']) == str(assignment.lms_id) ] if assignment_score: student_grades.append( Grade(student, course, assignment, assignment_score[0].get('score'))) enrollment.add_grades(student_grades) student.add_enrollments(enrollment) # Context dictionaries are used by Jinja to create the emails course_context_dicts = [] for course in instructor.courses: logger.info(f'Finding outliers for {course.short_name}...') course_outliers = defaultdict(list) if course.students is not None: for student in course.students: # Create CI's for each student -> floats enrollment = student.get_enrollment_by_course(course) # Look for new good/bad results -> Assignments if ref_date is not None:
def rowToGrade(row): grade = row[0] student_id = row[1] course_id = row[2] return Grade(grade, student_id, course_id)
def deleteAll(): ndb.delete_multi(Assignment.query().fetch(keys_only=True)) ndb.delete_multi(Course.query().fetch(keys_only=True)) ndb.delete_multi(Grade.query().fetch(keys_only=True)) ndb.delete_multi(Student.query().fetch(keys_only=True))
def createGrades(student,assignments): for assignment in assignments: g = Grade(score=int(random()*100)) g.student = student.key g.assignment = assignment.key g.put()
def seedGrades(): for i in range(0,10): g = Grade( score = int(random()*100) ) g.put()