class SchoolyearFilter(FlaskForm):
def __init__(self, *args, **kwargs):
super(SchoolyearFilter, self).__init__(*args, **kwargs)
sys = db_schedule.db_schedule_academic_year_list()
sys = [''] + sys
self.academic_year.choices = list(zip(sys, sys))
academic_year = SelectField(default=db_utils.academic_year(),
label='Schooljaar')
default_academic_year = db_utils.academic_year()
def add(action_done=False):
try:
if action_done:
absent_teacher_ids = request.form.getlist('my-select[]')
replaced_by_teacher_id = request.form['replaced_by']
school = db_utils.school()
academic_year = db_utils.academic_year()
if absent_teacher_ids:
for t_id in absent_teacher_ids:
r = ReplacementTeacher(
replacing_id=t_id,
replaced_by_id=replaced_by_teacher_id,
school=school,
academic_year=academic_year)
db.session.add(r)
r.first_replacement_teacher = True
db.session.commit()
else:
form = forms.AddForm()
teachers = [(i, t, '')
for i, t in db_teacher.db_teacher_list(select=True,
full_name=True)]
return render_template('settings/replacements/replacement.html',
form=form,
all_teachers=teachers,
title='Voeg een vervanger toe',
action='add',
role='add',
subject='settings.replacements')
except Exception as e:
log.error(u'Could not add replacement {}'.format(e))
utils.flash_plus(u'Kan vervanger niet toevoegen', e)
db.session.rollback()
return redirect(url_for('settings.replacements.show'))
def edit(action_done=False, id=-1):
try:
if action_done:
absent_teacher_ids = request.form.getlist('my-select[]')
replaced_by_teacher_id = request.form['replaced_by']
school = db_utils.school()
academic_year = db_utils.academic_year()
for r in db_replacement.replacement_list(
id=replaced_by_teacher_id):
db.session.delete(r)
if absent_teacher_ids:
for t_id in absent_teacher_ids:
r = ReplacementTeacher(
replacing_id=t_id,
replaced_by_id=replaced_by_teacher_id,
school=school,
academic_year=academic_year)
db.session.add(r)
r.first_replacement_teacher = True
db.session.commit()
else:
chbx_id_list = request.form.getlist('chbx')
if chbx_id_list:
id = int(chbx_id_list[0]) # only the first one can be edited
absent_teacher_ids = db_replacement.replacement_list(
id=id, ids_only=True)
# absent_teachers = db_teacher.db_teacher_list(select=True, full=True, id_list=replacements)
all_teachers = db_teacher.db_teacher_list(select=True,
full_name=True)
filtered_teachers = []
for i, t in all_teachers:
if i in absent_teacher_ids:
filtered_teachers.append((i, t, 'selected'))
else:
filtered_teachers.append((i, t, ''))
form = forms.EditForm()
form.replaced_by.choices = [
(id, db_teacher.db_teacher(id=id, full_name=True))
]
return render_template(
'settings/replacements/replacement.html',
form=form,
all_teachers=filtered_teachers,
title='Wijzig een vervanger toe',
action='edit',
role='edit',
subject='settings.replacements')
except Exception as e:
log.error(u'Could not edit replacement {}'.format(e))
utils.flash_plus(u'Kan vervanger niet wijzigen', e)
db.session.rollback()
return redirect(url_for('settings.replacements.show'))
def action_done(action=None, id=-1):
try:
if utils.button_pressed('save'):
if action == 'add':
teacher_id, day_hour, grade_id, lesson_id, changed_item = db_user.session_get_grade_filter()
if current_user.teacher and current_user.is_strict_user:
teacher = current_user.teacher
else:
teacher = Teacher.query.filter(Teacher.id == teacher_id, Teacher.school == db_utils.school()).first()
lesson = db_lesson.db_lesson(lesson_id)
measure_note = request.form['measure_note']
subject_note = request.form['subject_note']
extra_attention = 'chkb_extra_attention' in request.form
subjects = request.form.getlist('subject')
measures = request.form.getlist('measure')
timestamp = datetime.datetime.strptime('{} {}:{}:{}'.format(request.form['txt-date'], 23, 59, int(request.form['hour'])), '%d-%m-%Y %H:%M:%S')
duplicate_remarks = False
# iterate over all students involved. Create an remark per student.
# link the measures and remark-subjects to the remark
for s in request.form.getlist('student_id'):
student = Student.query.get(int(s))
if student:
if db_remark.check_if_duplicate(student, timestamp, measure_note, subject_note, extra_attention, measures, subjects):
duplicate_remarks = True
else:
# save new remark
remark = Remark(student=student, lesson=lesson, teacher=teacher, timestamp=timestamp,
measure_note=measure_note, subject_note=subject_note,
grade=student.classgroup.grade, extra_attention=extra_attention,
school=db_utils.school(), academic_year=db_utils.academic_year())
for s in subjects:
subject = RemarkSubject(topic=SubjectTopic.query.get(int(s)), remark=remark)
db.session.add(subject)
for m in measures:
measure = RemarkMeasure(topic=MeasureTopic.query.get(int(m)), remark=remark)
db.session.add(measure)
db.session.add(remark)
db.session.commit()
if duplicate_remarks:
utils.flash_plus('Er bestaat al een opmerking voor deze leerling(en) op dit tijdstip.<br>De opmerkingen worden samengevoegd')
return redirect(url_for('grade.show'))
if utils.button_pressed('hide'):
for s in request.form.getlist('student_id'):
student = Student.query.get(int(s))
if student:
student.hidden = True
db.session.commit()
except Exception as e:
utils.flash_plus(u'Kan opmerking niet opslaan', e)
log.error(u'Cannot save remarks {}'.format(e))
return redirect(url_for('grade.show'))
def get_settings_and_show():
settings = {}
try:
academic_year_list = db_schedule.db_schedule_academic_year_list()
academic_year_list = academic_year_list if academic_year_list else [
db_utils.academic_year()
]
last = academic_year_list[-1]
academic_year_list.append(last + 101)
topics = []
measure_topics = db_measure_topic.db_measure_topic_list(all=True)
mt_list = [{
'id': i.id,
'enabled': i.enabled,
'topic': i.topic
} for i in measure_topics]
topics.append(('measure_topic', 'Maatregelen', mt_list))
subject_topics = db_subject_topic.db_subject_topic_list(all=True)
st_list = [{
'id': i.id,
'enabled': i.enabled,
'topic': i.topic
} for i in subject_topics]
topics.append(('subject_topic', 'Opmerkingen', st_list))
sim_day_hour = db_setting.get_global_setting_sim_dayhour()
settings['sim_day'] = sim_day_hour.split(' ')[0]
settings['sim_hour'] = sim_day_hour.split(' ')[1]
settings[
'sim_dayhour_state'] = db_setting.get_global_setting_sim_dayhour_state(
)
settings['help_url'] = db_setting.get_global_setting_help_url()
except Exception as e:
log.error(
u'Could not check the database for students or timetables, error {}'
.format(e))
utils.flash_plus(
u'Er is een fout opgetreden bij het ophalen van de instellingen',
e)
return settings, academic_year_list, topics
return render_template(u'settings/topics.html',
settings=settings,
academic_year_list=academic_year_list,
topics=topics,
title='settings')
def query_filter(query_in):
now = datetime.datetime.now()
if db_setting.get_global_setting_sim_dayhour_state():
try:
now = datetime.datetime.strptime(
db_setting.get_global_setting_sim_dayhour(), '%d-%m-%Y %H:%M')
except Exception as e:
pass
schedule = Schedule.query.filter(
Schedule.valid_from <= now).distinct().order_by(
desc(Schedule.valid_from)).first()
if not schedule:
return query_in
return query_in.filter(Schedule.school == db_utils.school(),
Schedule.academic_year == db_utils.academic_year(),
Schedule.valid_from == schedule.valid_from)
def delete_test_remarks():
academic_year = request.form['selected_academic_year']
try:
remarks = Remark.query.filter(
Remark.school == db_utils.school(),
Remark.academic_year == db_utils.academic_year(),
Remark.test == True).all()
for r in remarks:
if r.extra_measure and r.first_remark:
db.session.delete(r.extra_measure)
db.session.delete(r)
db.session.commit()
log.info(u'Removed test remarks')
utils.flash_plus(
u'Test opmerkingen verwijderd voor jaar {} '.format(academic_year))
except Exception as e:
log.error(u'Could not delete test remarks error {}'.format(e))
utils.flash_plus(
u'Kan test opmerkingen voor jaar {} niet verwijderen'.format(
academic_year), e)
return redirect(url_for('settings.show_tests'))
def db_filter_grade(teacher_id, dayhour_str, grade_id, lesson_id, changed_item=None):
#filter on teacher, timeslot , grade and lesson
#priority is as follows:
#- if teacher is changed: determine timeslot from current time and find grade and lesson from timetable
#- if timeslot is changed: from teacher and timeslot determine grade and lesson from timetable
# If this does not work, pick first grade for that teacher
#- if grade is changed : from teacher, timeslot and grade, try to determine lesson from timetable.
# If this does not work, pick first available lesson for that grade
#- if lesson is changed : go with the flow... :-)
teacher = None
grade = None
lesson = None
d = 0
h = 0
teacher = Teacher.query.get(teacher_id)
if changed_item == 'teacher':
d, h = time_to_timeslot()
#try to find the classmoment, equal to or earlier than the given day and hour
schedules_found = db_schedule.query_filter(Schedule.query.join(Teacher)).filter(Schedule.teacher == teacher)\
.order_by(Schedule.day.desc(), Schedule.hour.desc()).all()
dh = d * 10 + h
for schedule in schedules_found:
if dh >= schedule.day * 10 + schedule.hour: break
else: schedule = None
if not schedule:
schedule = db_schedule.query_filter(Schedule.query.join(Teacher)).filter(Schedule.teacher == teacher).order_by(Schedule.day, Schedule.hour).first()
if schedule:
d = schedule.day
h = schedule.hour
changed_item = 'dayhour'
else:
d, h = Schedule.decode_dayhour(dayhour_str)
if changed_item == 'dayhour':
#fetch classgroups from timetable
schedules = db_schedule.query_filter(Schedule.query.join(Teacher)).filter(Schedule.day == d, Schedule.hour == h, Schedule.teacher == teacher)\
.order_by(Schedule.day, Schedule.hour).all()
if schedules:
#the classmoment points to a single teacher, grade and lesson
return schedules
#just pick the first grade from all grades
grade = Grade.query.distinct(Grade.code).order_by(Grade.code).first()
changed_item = 'grade'
else:
grade = Grade.query.get(grade_id)
if changed_item == 'grade':
#find the first lesson, taken by given grade
lesson = db_schedule.query_filter(Lesson.query.join(Schedule, Lesson.id == Schedule.lesson_id)
.join(Classgroup, Classgroup.id == Schedule.classgroup_id).join(Grade, Grade.id == Classgroup.grade_id)
.join(Teacher, Teacher.id == Schedule.teacher_id))\
.filter(Grade.id == grade.id, Schedule.teacher == teacher).distinct(Lesson.code).order_by(Lesson.code).first()
if not lesson:
#just pick the first lesson
lesson = Lesson.query.filter(Lesson.school == db_utils.school()).distinct(Lesson.code).order_by(Lesson.code).first()
else:
lesson = Lesson.query.get(lesson_id)
#create a dummy classmoment
schedules = []
classgroups = Classgroup.query.filter(Classgroup.grade == grade).all()
for c in classgroups:
schedules.append(Schedule(day=d, hour=h, school=db_utils.school(), academic_year=db_utils.academic_year(), teacher=teacher
, lesson=lesson, classgroup=c))
return schedules
def add_test_remarks():
academic_year = request.form['selected_academic_year']
nbr_test_students = int(request.form['nbr-test-students'])
add_extra_measure = 'chkb-extra-measure' in request.form
random.seed()
try:
classmoments = db_schedule.query_filter(
Schedule.query.join(Classgroup, Grade, Lesson, Teacher)).all()
students = db_schedule.query_filter(
Student.query.join(Classgroup, Grade, Schedule)).all()
for i in range(nbr_test_students):
student = random.choice(students)
dates = remark_dates[i % len(remark_dates)]
for d in dates:
classmoment = random.choice(classmoments)
h = random.randint(1, 9)
timestamp = datetime.datetime.strptime(
'{}/20{} {}:{}:{}'.format(d, academic_year[2:4], 23, 59,
h), '%d/%m/%Y %H:%M:%S')
remark = Remark(student=student,
grade=student.classgroup.grade,
timestamp=timestamp,
lesson=classmoment.lesson,
teacher=classmoment.teacher,
measure_note='',
subject_note='TESTOPMERKING',
school=db_utils.school(),
academic_year=db_utils.academic_year(),
test=True,
extra_attention=random.choice(
[True, False, False, False]))
s = random.choice(db_subject_topic.db_subject_topic_list())
m = random.choice(db_measure_topic.db_measure_topic_list())
subject = RemarkSubject(topic=s, remark=remark)
measure = RemarkMeasure(topic=m, remark=remark)
db.session.add(subject)
db.session.add(measure)
db.session.add(remark)
if add_extra_measure:
matched_remarks, non_matched_remarks = db_remark.db_filter_remarks_to_be_reviewed(
academic_year, test=True, commit=False)
for s, rll in matched_remarks:
for id, extra_measure, rl in rll:
rids = [i.id for i in rl]
db_remark.db_add_extra_measure(
rids,
'TEST: extra sanctie voor {} {}'.format(
s.first_name, s.last_name),
commit=False)
db_remark.db_tag_remarks_as_reviewed()
log.info(u'Added test remarks')
utils.flash_plus(
u'Test opmerkingen toegevoegd voor jaar {} '.format(academic_year))
except Exception as e:
log.error(u'Could not add test remarks error {}'.format(e))
utils.flash_plus(
u'Kan test opmerkingen voor jaar {} niet toevoegen'.format(
academic_year), e)
return redirect(url_for('settings.show_tests'))
