def add(self):
if not request.is_json:
return jsonify({"msg": "missing json request"}), 400
first_name = request.json.get('first_name', None)
last_name = request.json.get('last_name', None)
expire_date = datetime.datetime.strptime(
request.json.get('expire_date', None), '%Y-%m-%d')
national_id = request.json.get('national_id', None)
advisor = request.json.get('advisor', None)
student_id = request.json.get(
'student_id', None) #TODO: generate a unique vlaue instead of None
user_id = get_current_user().id
exams = []
workbooks = []
classes = []
try:
session = db_session()
student = Student(first_name, last_name, expire_date, national_id,
advisor, student_id, user_id, classes, exams,
workbooks)
session.add(student)
session.commit()
return jsonify(success=True), 201
except Exception as e:
session.rollback()
Logger.debug("could not create student")
Logger.error(e.message)
print e.message
return jsonify(success=False), 400
def _update_db(self, presents_id, all_results):
session = db_session()
try:
workbooks = session.query(Workbook).filter(
Workbook.exam_id == self.exam.id).all()
for workbook in workbooks:
student_id = session.query(Student).filter(
Student.id == workbook.student_id).first().student_id
if student_id in presents_id:
workbook.presence = True
workbook.answers = all_results[student_id]
else:
workbook.presence = False
session.add(workbook)
session.commit()
session.close()
except Exception as e:
Logger.debug("could not update the presents in database")
Logger.error(e.message)
finally:
session.close()
def registration(self):
if not request.is_json:
return jsonify({"msg": "Missing JSON in request"}), 400
username = request.json.get('username', None) #TODO: hash the password
password = request.json.get('password')
first_name = request.json.get('first_name')
last_name = request.json.get('last_name')
email = request.json.get('email')
national_id = request.json.get('national_id')
classes = []
students = []
exams = []
account_activated = True
# roles = [Role('holder')]
session = db_session()
try:
user = User(first_name, last_name, email, national_id, username,
password, account_activated, classes, students, exams)
session.add(user)
session.commit()
#TODO: redirect and provide JWT token and return it
return jsonify(success=True), 201
except Exception as e:
session.rollback()
Logger.debug("registration: Could not add new user to database")
Logger.error(e.message)
return jsonify(success=False), 400
def post(self):
if not request.is_json:
return jsonify({"msg": "missing json request"}), 400
name = request.json.get('name', None)
answers_key = request.json.get('answers_key', dict())
date = datetime.datetime.strptime(request.json.get('date', None),
'%Y-%m-%d')
description = request.json.get('description', None)
lessons = request.json.get('lessons', dict())
setting = request.json.get('setting', dict())
marks = dict()
ranks = dict()
percentage_of_responses_to_questions = dict()
user_id = get_current_user().id
students = list()
workbooks = list()
classes = list()
try:
session = db_session()
exam = Exam(name, answers_key, date, description, lessons, setting,
marks, ranks, percentage_of_responses_to_questions,
user_id, students, classes, workbooks)
session.add(exam)
session.commit()
return jsonify(success=True), 201
except Exception as e:
session.rollback()
Logger.debug("could not create new exam")
Logger.error(e.message)
return jsonify(success=False), 400
def generate_workbook_for_students(self):
session = db_session()
for student in self.exam.students:
workbook = Workbook(datetime.datetime.now(), {}, {}, False,
student.id, self.exam.id)
student.workbooks.append(workbook)
# session = session.object_session(student)
session.add(student)
session.commit()
session.close()
def run_correction(self):
#calculate true or false answers
workbooks_evaluated_answers_dic = self.__corrector.evaluate_answers_for_all(
)
#calculate and write percentages to database
workbooks_percentages_dic = self.__corrector.calculate_percentage_for_all_students(
workbooks_evaluated_answers_dic)
#calculate balance to each lesson and for all students
workbooks_balances_dic = self.__corrector.calculate_lessons_balance_for_all(
workbooks_percentages_dic)
#calculate ranks for each lesson for all students
workbooks_lessons_ranks_dic = self.__corrector.calculate_lessons_ranks_for_all(
workbooks_balances_dic)
#calculate total balance for each student
workbooks_total_balances_dic = self.__corrector.calculate_total_balance_for_all(
workbooks_balances_dic)
#calculate ranks
sorted_by_balance_tuple = sorted(workbooks_total_balances_dic.items(),
key=operator.itemgetter(1),
reverse=True)
session = db_session()
#write data to database
try:
for index, workbook_balance_tuple in enumerate(
sorted_by_balance_tuple):
workbook_id, balance = workbook_balance_tuple
result = {}
workbook = session.query(Workbook).filter(
Workbook.id == workbook_id).first()
workbook.answers = workbooks_evaluated_answers_dic[workbook]
result["percentages"] = workbooks_percentages_dic[workbook_id]
result["rank"] = index + 1
result["balance"] = balance
result["total_growth"] = None
result["lessons_rank"] = workbooks_lessons_ranks_dic[
workbook_id]
result["lessons_growth"] = {}
workbook.results = result
session.add(workbook)
session.commit()
except Exception as e:
Logger.debug("could not write results to database")
Logger.error(e.message)
raise
finally:
session.close()
def decorated_function(*args, **kwargs):
user = "******"
try:
user = g.user.id
except:
pass
log = Log(log_date=str(datetime.datetime.now()), log_desc=_("go to :") + title, log_user=user)
session = db_session()
session._model_changes = {}
session.add(log)
session.commit()
g.page_title = title
return f(*args, **kwargs)
def decorated_function(*args, **kwargs):
user = '******'
try:
user = g.user.id
except:
pass
log = Log(log_date=str(datetime.datetime.now()),
log_desc=_('go to :') + title,
log_user=user)
session = db_session()
session._model_changes = {}
session.add(log)
session.commit()
g.page_title = title
return f(*args, **kwargs)
def add(self):
if not request.is_json:
return jsonify({"msg": "missing json request"}), 400
name = request.json.get("name", None)
desciption = request.json.get("description", None)
students = []
user_id = get_current_user().id
exams = []
try:
session = db_session()
new_class = Class(name, desciption, students, user_id, exams)
session.add(new_class)
session.commit()
return jsonify(success=True), 201
except Exception as e:
session.rollback()
Logger.debug("could not create new class")
Logger.error(e.message)
return jsonify(success=False), 400
def add_exams(self, class_id):
try:
session = db_session()
if not request.is_json:
return jsonify({"msg": "missing json request"}), 400
exams = request.json.get('exams', None)
the_class = Class.query.filter_by(id=class_id).first()
for exam_id in exams:
exam = Exam.query.filter_by(id=exam_id).first()
exam.students += the_class.students
the_class.exams.append(exam)
exam.classes.append(the_class)
session.add(the_class)
session.add(exam)
session.commit()
return jsonify(success=True), 200
except Exception as e:
session.rollback()
Logger.debug("could not assign exams to class")
Logger.error(e.message)
return jsonify(success=False), 400
def patch(self, id):
exam = Exam.query.filter_by(id=id).first()
if not request.is_json:
return jsonify({"msg": "missing json request"}), 400
exam.name = request.json.get('name', exam.name)
exam.answers_key = request.json.get('answers_key', exam.answers_key)
# exam.date = datetime.datetime.strptime(request.json.get('date', str(exam.date)),'%Y-%m-%d')
exam.description = request.json.get('description', exam.description)
exam.lessons = request.json.get('lessons', exam.lessons)
exam.setting = request.json.get('setting', exam.setting)
try:
session = db_session()
session.add(exam)
session.commit()
return jsonify(success=True), 200
except Exception as e:
session.rollback()
Logger.debug("could not update exam")
Logger.error(e.message)
return jsonify(success=False), 400
def add_students(self, class_id):
try:
if not request.is_json:
return jsonify({"msg": "missing json request"}), 400
students = request.json.get('students', None)
the_class = Class.query.filter_by(id=class_id).first()
session = db_session()
for student_id in students:
student = Student.query.filter_by(id=student_id).first()
student.classes.append(the_class)
the_class.students.append(student)
if the_class.exams:
for exam in the_class.exams:
exam.students.append(student)
session.add(exam)
session.add(the_class)
session.add(student)
session.commit()
return jsonify(success=True), 200
except Exception as e:
session.rollback()
Logger.debug("could not assign students to class")
Logger.error(e.message)
return jsonify(success=False), 400
def get_user(identity):
session = db_session()
return session.query(User).filter(User.username == identity).first()
