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