def save_generic():
try:
db_setting.set_global_setting_help_url(request.form['txt-help-url'])
except Exception as e:
log.error(u'Cannot save help-website-url: {}'.format(e))
utils.flash_plus(u'Kan de help website URL niet bewaren', e)
return redirect(url_for('settings.show_generic'))
def action():
try:
if utils.button_pressed('add'):
d, h = Schedule.decode_dayhour(request.form['dayhour'])
ts_d, ts_h = db_utils.time_to_timeslot(include_zero_hour=True)
delta_d = ts_d - d
if d * 10 + h > ts_d * 10 + ts_h:
delta_d += 7
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:
log.error('bad sim dayhour string : {}'.format(e))
date = (now - datetime.timedelta(days=delta_d)).strftime('%d-%m-%Y')
students = []
for s in request.form.getlist('student_id'):
student = Student.query.get(s)
if student:
students.append(student)
form = RemarkForm()
prime_data = {}
prime_data['hour'] = h
prime_data['date'] = date
return render_template('remark/remark.html', subject='grade', action='add', form=form, students=students, prime_data=prime_data)
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 edit(action_done=False, id=-1):
try:
if action_done:
user = User.query.get(id)
form = EditForm(id=id)
if form.validate_on_submit():
form.populate_obj(user)
db.session.commit()
return redirect(url_for('user.show'))
else:
return render_template('user/user.html',
form=form,
title='Wijzig een gebruiker',
action='edit',
role='edit',
subject='user')
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
user = User.query.get(id)
form = EditForm(obj=user, formdata=None)
else:
return redirect(url_for('user.show'))
return render_template('user/user.html',
form=form,
title='Wijzig een gebruiker',
action='edit',
role='edit',
subject='user')
except Exception as e:
log.error(u'Could not edit user {}'.format(e))
utils.flash_plus(u'Kan gebruiker niet aanpassen', e)
return redirect(url_for('user.show'))
def prepare_data_for_html(table):
try:
_filters_enabled, _filter_forms, _filtered_list, _total_count, _filtered_count = process_data(table)
_filtered_dict = table['format_data'](_filtered_list)
# order, if required, 2nd stage
_template = table['template']
column_number = check_value_in_form('order[0][column]', request.values)
column_number = int(column_number)
if column_number:
if 'row_detail' in table:
column_number -= 1
if _template[column_number]['order_by'] and callable(_template[column_number]['order_by']):
reverse = False if check_string_in_form('order[0][dir]', request.values) == 'desc' else True
_filtered_dict = sorted(_filtered_dict, key=_template[column_number]['order_by'], reverse=reverse)
except Exception as e:
log.error('could not prepare data for html : {}'.format(e))
utils.flash_plus('Er is een fout opgetreden en de tabel kan niet getoond worden.', e)
_total_count = _filtered_list = _filtered_count = 0
_filtered_dict = []
# prepare for json/ajax
output = {}
output['draw'] = str(int(request.values['draw']))
output['recordsTotal'] = str(_total_count)
output['recordsFiltered'] = str(_filtered_count)
output['data'] = _filtered_dict
# add the (non-standard) flash-tag to display flash-messages via ajax
fml = get_flashed_messages()
if not not fml:
output['flash'] = fml
return jsonify(output)
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 check_date_in_form(date_key, form):
if date_key in form and form[date_key] != '':
try:
time.strptime(form[date_key].strip(), '%d-%M-%Y')
return form[date_key].strip()
except Exception as e:
utils.flash_plus('Verkeerd datumformaat, moet in de vorm zijn : d-m-y', e)
return ''
def check_value_in_form(value_key, form):
if value_key in form and form[value_key] != '':
try:
float(form[value_key])
return form[value_key]
except Exception as e:
utils.flash_plus('Verkeerde getal notatie', e)
return ''
def check_string_in_form(value_key, form):
if value_key in form and form[value_key] != '':
try:
str(form[value_key])
return form[value_key]
except Exception as e:
utils.flash_plus('Verkeerde tekst notatie', e)
return ''
def save_sim_dayhour():
try:
db_setting.set_global_setting_sim_dayhour_state(
'chkb-sim-dayhour' in request.form)
db_setting.set_global_setting_sim_dayhour(request.form['txt-sim-day'] +
' ' +
request.form['txt-sim-hour'])
except Exception as e:
log.error(u'Cannot save simulate dayhour: {}'.format(e))
utils.flash_plus(u'Kan simulatie dag en uur niet bewaren', e)
return redirect(url_for('settings.show_tests'))
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 add_topic(subject, topic):
try:
if subject == 'measure_topic':
topic = MeasureTopic(topic=topic, school=db_utils.school())
elif subject == 'subject_topic':
topic = SubjectTopic(topic=topic, school=db_utils.school())
db.session.add(topic)
db.session.commit()
except Exception as e:
log.error(u'Could not add {}, topic {}: {}'.format(subject, topic, e))
utils.flash_plus(u'Kan onderwerp niet toevoegen', e)
return redirect(url_for('settings.show_topics'))
def delete():
try:
chbx_id_list = request.form.getlist('chbx')
for id in chbx_id_list:
for r in db_replacement.replacement_list(id=id):
db.session.delete(r)
db.session.commit()
except Exception as e:
log.error(u'Could not delete replacement {}'.format(e))
utils.flash_plus(u'Kan vervanger niet verwijderen', e)
db.session.rollback()
return redirect(url_for('settings.replacements.show'))
def view(id):
try:
user = User.query.get(id)
form = ViewForm(obj=user)
except Exception as e:
log.error(u'Could not view user {}'.format(e))
utils.flash_plus(u'Kan gebruiker niet bekijken', e)
return redirect(url_for('user.show'))
return render_template('user/user.html',
form=form,
title='Bekijk een gebruiker',
role='view',
subject='user')
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 delete_schedule():
academic_year = request.form['selected_academic_year']
try:
delete_classmoments(request.form['selected_academic_year'])
log.info(u'Deleted timetable')
utils.flash_plus(
u'Lesrooster van jaar {} is gewist'.format(academic_year))
except Exception as e:
log.error(
u'Could not not delete classmoments from {}, error {}'.format(
academic_year, e))
utils.flash_plus(
u'Kan lesrooster van jaar {} niet wissen'.format(academic_year), e)
return redirect(url_for('settings.show_database'))
def show():
try:
# The following line is required only to build the filter-fields on the page.
_filter, _filter_form, a, b, c = process_data(
tables_configuration['user'])
except Exception as e:
log.error(u'Could not show users {}'.format(e))
utils.flash_plus(u'Kan gebruikers niet tonen', e)
return render_template('base_multiple_items.html',
title='users',
filter=_filter,
filter_form=_filter_form,
config=tables_configuration['user'])
def replacement_add():
try:
if utils.button_save_pushed(): # second pass
pass
else: # first pass
form = forms.AddReplacementForm()
return render_template('settings/replacement.html',
form=form,
title='Voeg een vervanger toe',
role='add',
subject='settings')
except Exception as e:
log.error(u'Could not add replacment {}'.format(e))
utils.flash_plus(u'Kan vervanger niet toevoegen', e)
return redirect(url_for('settings.show_replacements'))
def upload_photos(rfile):
try:
log.info('Upload photos from : {}'.format(rfile))
# students_file=csv.DictReader(request.files['import_filename'], delimiter=';', encoding='utf-8-sig')
filename = documents.get_doc_reference('photo').save(
rfile, name=rfile.filename)
zip_file = os.path.join(documents.get_doc_path('photo'), filename)
zip_ref = zipfile.ZipFile(zip_file, 'r')
zip_ref.extractall(documents.get_doc_path('photo'))
zip_ref.close()
log.info(u'Uploaded photos')
utils.flash_plus(u'Foto\'s zijn geïmporteerd')
except Exception as e:
log.error(u'Cannot import photos : {}'.format(e))
utils.flash_plus(u'Kan bestand niet importeren', e)
return
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 upload_teachers(rfile):
try:
# format csv file :
log.info(u'Import teachers from : {}'.format(rfile))
academic_year = request.form['selected_academic_year']
fieldnames = ['CODE', 'VOORNAAM', 'FAMILIENAAM', 'GROEP', 'GROEP2']
# teachers_file=csv.DictReader(rfile, delimiter=';', encoding='utf-8-sig')
teachers_file = csv.DictReader(rfile,
delimiter=';',
fieldnames=fieldnames,
encoding='latin_1') # ansi encoding
nbr_teachers = 0
for t in teachers_file:
# skip empty and not relevant records
teacher_code = t['CODE'].upper()
group = t['GROEP'] if t['GROEP'] in group_to_school else t['GROEP2']
if group not in group_to_school: continue
if t['VOORNAAM'] != '' and t[
'FAMILIENAAM'] != '' and teacher_code != '':
school = group_to_school[group]
# add teacher, if not already present
find_teacher = Teacher.query.filter(
Teacher.code == teacher_code,
Teacher.school == school).first()
if find_teacher:
find_teacher.first_name = t['VOORNAAM']
find_teacher.last_name = t['FAMILIENAAM']
find_teacher.academic_year = academic_year
if not find_teacher:
teacher = Teacher(first_name=t['VOORNAAM'],
last_name=t['FAMILIENAAM'],
code=teacher_code,
academic_year=academic_year,
school=school)
db.session.add(teacher)
nbr_teachers += 1
db.session.commit()
log.info(u'import: added {} teachers'.format(nbr_teachers))
utils.flash_plus(
u'{} leerkrachten zijn geïmporteerd'.format(nbr_teachers))
except Exception as e:
utils.flash_plus(u'Kan bestand niet importeren', e)
return
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 add(action_done=False):
try:
if action_done:
form = AddForm()
if form.validate_on_submit():
if form.user_type.data == User.USER_TYPE.LOCAL:
password = form.password.data
else:
password = ''
user = User(email=form.email.data,
username=form.username.data,
first_name=form.first_name.data,
last_name=form.last_name.data,
password=password,
level=form.level.data,
user_type=form.user_type.data)
db.session.add(user)
db.session.commit()
log.info('add : {}'.format(user.log()))
return redirect(url_for('user.show'))
else:
return render_template('user/user.html',
form=form,
title='Voeg een gebruiker toe',
action='add',
role='add',
subject='user')
else:
form = AddForm()
return render_template('user/user.html',
form=form,
title='Voeg een gebruiker toe',
action='add',
role='add',
subject='user')
except Exception as e:
log.error(u'Could not add user {}'.format(e))
utils.flash_plus(u'Kan gebruikers niet toevoegen', e)
db.session.rollback()
return redirect(url_for('user.show'))
def truncate_database():
try:
grades = Grade.query.all()
for g in grades:
db.session.delete(g)
lessons = Lesson.query.all()
for l in lessons:
db.session.delete(l)
teachers = Teacher.query.all()
for t in teachers:
db.session.delete(t)
for mt in MeasureTopic.query.all():
db.session.delete(mt)
for st in SubjectTopic.query.all():
db.session.delete(st)
db.session.commit()
log.info('Database truncated')
utils.flash_plus('Database is gewist')
except Exception as e:
log.error('Could not truncate database: error {}'.format(e))
utils.flash_plus('Kan database niet wissen', e)
return redirect(url_for('settings.show_tests'))
def upload_students(rfile):
try:
# format csv file :
log.info(u'Import students from : {}'.format(rfile))
# students_file=csv.DictReader(rfile, delimiter=';', encoding='utf-8-sig') #utf-8 encoding
students_file = csv.DictReader(rfile,
delimiter=';',
encoding='latin_1') # ansi encoding
nbr_students = 0
academic_year = request.form['selected_academic_year']
classgroups = {c.code: c for c in db_classgroup.db_classgroup_list()}
if classgroups:
for s in students_file:
# skip empty records
if s['VOORNAAM'] != '' and s['NAAM'] != '' and s[
'LEERLINGNUMMER'] != '':
# check for grade. If it not exists, skip
if s['KLASGROEP'] in classgroups:
# add student, if not already present
find_student = Student.query.filter(
Student.number == int(
s['LEERLINGNUMMER'])).first()
if find_student:
find_student.photo = s['FOTO']
find_student.classgroup = classgroups[
s['KLASGROEP']]
find_student.academic_year = academic_year
else:
student = Student(
first_name=s['VOORNAAM'],
last_name=s['NAAM'],
number=int(s['LEERLINGNUMMER']),
photo=s['FOTO'],
classgroup=classgroups[s['KLASGROEP']],
academic_year=academic_year)
db.session.add(student)
nbr_students += 1
db.session.commit()
else:
log.error('Error, no classgroups present yet')
utils.flash_plus('Fout, er zijn nog geen klassen ingeladen')
log.info(u'import: added {} students'.format(nbr_students))
utils.flash_plus(
u'{} leerlingen zijn geïmporteerd'.format(nbr_students))
except Exception as e:
utils.flash_plus(u'Kan bestand niet importeren', e)
log.error(u'cannot import : {}'.format(e))
return
def delete():
try:
chbx_id_list = request.form.getlist('chbx')
for id in chbx_id_list:
if int(id) == 1:
log.error(u'cannot delete this user')
utils.flash_plus(u'Kan de gebruiker admin niet verwijderen')
continue
if int(id) == current_user.id:
log.error(u'user cannot delete himself')
utils.flash_plus(
u'Een gebruiker kan niet zichzelf verwijderen.')
continue
user = User.query.get(int(id))
db.session.delete(user)
db.session.commit()
except Exception as e:
log.error(u'Could not delete user : {}'.format(e))
utils.flash_plus(u'Kan de gebruikers niet verwijderen', e)
return redirect(url_for('user.show'))
def change_password(action_done=False, id=-1):
try:
if action_done:
user = User.query.get(id)
form = ChangePasswordForm(id=id)
if form.validate_on_submit():
user.password = form.new_password.data
db.session.commit()
utils.flash_plus(u'Het paswoord is aangepast.')
return redirect(url_for('user.show'))
else:
return render_template('user/user.html',
form=form,
title='Verander paswoord',
action='change-password',
role='change-password',
subject='user')
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
user = User.query.get(id)
if user.is_oauth:
utils.flash_plus(u'Deze gebruiker heeft geen paswoord',
u'Dit is een OAUTH-gebruiker')
return redirect(url_for('user.show'))
form = ChangePasswordForm(obj=user)
return render_template('user/user.html',
form=form,
title='Verander paswoord',
action='change-password',
role='change-password',
subject='user')
except Exception as e:
log.error('Could not change password : {}'.format(e))
utils.flash_plus(u'Kan het paswoord niet aanpassen', e)
return redirect(url_for('user.show'))
def filter_grade():
try:
if not current_user.in_schedule and not current_user.in_replacement and current_user.is_strict_user:
log.error(u'Level 1 user not in schedule')
utils.flash_plus(u'Sorry, u kan op deze pagina niets zien')
return FilterForm(), []
if 'change_id' in request.form: # filters on grade-page are used
teacher_id = int(request.form['teacher'])
day_hour = request.form['dayhour']
changed_item = request.form['change_id']
try:
lesson_id = int(request.form['lesson'])
except:
lesson_id = -1
try:
grade_id = int(request.form['grade'])
except:
grade_id = -1
db_user.session_set_grade_filter(teacher_id, day_hour, grade_id, lesson_id, changed_item)
teacher_id, day_hour, grade_id, lesson_id, changed_item = db_user.session_get_grade_filter()
schedules = db_grade.db_filter_grade(teacher_id, day_hour, grade_id, lesson_id, changed_item)
except Exception as e:
log.error(u'No schedule found {}'.format(e))
utils.flash_plus(u'Er is nog geen lesrooster geladen')
return FilterForm(), []
try:
#put all students in one list and sort on last name
students = []
for s in schedules:
students += db_student.db_student_list(classgroup=s.classgroup)
students = sorted(students, key=lambda i: i.last_name)
teacher_grades = db_grade.db_grade_list(schedules[0].teacher, html_select=True)
is_single_grade, classgroup_codes = db_grade.db_single_grade(schedules)
teacher_lessons = db_lesson.db_lesson_list(schedules[0].teacher, html_select=True)
teacher_schedules = db_schedule.db_schedule_list(schedules[0].teacher, html_select=True)
# create filter
form_filter = FilterForm()
form_filter.teacher.data = str(schedules[0].teacher.id)
if current_user.is_at_least_supervisor:
choices = db_teacher.db_teacher_list(select=True, full_name=True)
elif current_user.teacher_list:
choices = current_user.teacher_list
else:
choices = None
form_filter.teacher.choices = choices
form_filter.dayhour.data = schedules[0].get_data_day_hour()
form_filter.dayhour.choices = utils.filter_duplicates_out(teacher_schedules, Schedule.get_choices_day_hour())
if is_single_grade:
form_filter.grade.data = str(schedules[0].classgroup.grade.id)
else:
teacher_grades.append(('disabled-unused', classgroup_codes))
form_filter.grade.data = 'disabled-unused'
form_filter.grade.choices = utils.filter_duplicates_out(teacher_grades, db_grade.db_grade_list(html_select=True))
form_filter.lesson.data = str(schedules[0].lesson.id)
form_filter.lesson.choices = utils.filter_duplicates_out(teacher_lessons, db_lesson.db_lesson_list(html_select=True))
db_user.session_set_grade_filter(day_hour=schedules[0].get_data_day_hour(), grade_id=schedules[0].classgroup.grade.id,
lesson_id=schedules[0].lesson.id)
except Exception as e:
log.error(u'Cannot filter the grade {}'.format(e))
utils.flash_plus(u'Er is een probleem met de filter', e)
return FilterForm(), []
return form_filter, students
def upload_schedule(rfile):
try:
# format csv file :
log.info(u'Import timetable from : {}'.format(rfile))
academic_year = request.form['selected_academic_year']
valid_from = datetime.datetime.strptime(
request.form['select-date-from'], '%d-%m-%Y')
# first, delete current timetable
delete_classmoments(academic_year, valid_from)
fieldnames = [
'VOLGNUMMER', 'KLAS', 'LEERKRACHT', 'VAK', 'LOKAAL', 'DAG', 'UUR'
]
timetable_file = csv.DictReader(rfile,
fieldnames=fieldnames,
delimiter=',',
encoding='utf-8-sig')
nbr_classmoments = 0
nbr_lessons = 0
error_message = ''
nbr_grades = 0
nbr_classgroups = 0
grades = {g.code: g for g in db_grade.db_grade_list(in_schedule=False)}
classgroups = {c.code: c for c in db_classgroup.db_classgroup_list()}
lessons = {l.code: l for l in db_lesson.db_lesson_list(schedule=False)}
teachers = {
t.code: t
for t in db_teacher.db_teacher_list(schedule=False)
}
for t in timetable_file:
# skip empy records
if t['KLAS'] != '' and t['LEERKRACHT'] != '' and t[
'VAK'] != '' and t['DAG'] != '' and t['UUR'] != '':
if t['LEERKRACHT'] in teachers:
find_teacher = teachers[t['LEERKRACHT']]
classgroup_code = t['KLAS']
if len(classgroup_code.split(' ')) == 1:
grade_code = classgroup_code
else:
grade_code = classgroup_code.split(' ')[0]
lesson_code = t['VAK']
# check for grade. If it not exists, add it first
if grade_code in grades:
find_grade = grades[grade_code]
else:
find_grade = Grade(code=grade_code,
school=db_utils.school())
db.session.add(find_grade)
grades[grade_code] = find_grade
nbr_grades += 1
# check for classgroup, if not present, add
if classgroup_code in classgroups:
find_classgroup = classgroups[classgroup_code]
else:
find_classgroup = Classgroup(code=classgroup_code,
grade=find_grade)
db.session.add(find_classgroup)
classgroups[classgroup_code] = find_classgroup
nbr_classgroups += 1
# add lesson, if not already present
if lesson_code in lessons:
find_lesson = lessons[lesson_code]
else:
find_lesson = Lesson(code=lesson_code,
school=db_utils.school())
db.session.add(find_lesson)
lessons[lesson_code] = find_lesson
nbr_lessons += 1
classmoment = Schedule(day=int(t['DAG']),
hour=int(t['UUR']),
classgroup=find_classgroup,
teacher=find_teacher,
lesson=find_lesson,
school=db_utils.school(),
academic_year=int(academic_year),
valid_from=valid_from)
db.session.add(classmoment)
nbr_classmoments += 1
else:
log.info(u'import timetable: teacher not found: {}'.format(
t['LEERKRACHT']))
error_message += u'{} : niet gevonden<br>'.format(
t['LEERKRACHT'])
# load schedule for teacher XXXX
period = day = 1
teacher = db_teacher.db_teacher(code='XXXX')
lesson = db_lesson.db_lesson_list()[0]
for g in db_grade.db_grade_list():
classgroups = db_classgroup.db_classgroup_list(grade=g)
for cg in classgroups:
classmoment = Schedule(day=day,
hour=period,
classgroup=cg,
teacher=teacher,
lesson=lesson,
school=db_utils.school(),
academic_year=int(academic_year),
valid_from=valid_from)
db.session.add(classmoment)
period += 1
if period > 9:
period = 1
day += 1
db.session.commit()
log.info(
u'import: added {} classmoments, {} grades, {} classgroups and {} lessons'
.format(nbr_classmoments, nbr_grades, nbr_classgroups,
nbr_lessons))
if error_message == '':
utils.flash_plus(
u'Lesrooster is geïmporteerd, {} lestijden, {} klassen, {} klasgroepen en {} lessen toegevoegd'
.format(nbr_classmoments, nbr_grades, nbr_classgroups,
nbr_lessons))
else:
utils.flash_plus(u'Lesrooster kan niet worden geïmporteerd',
format(error_message))
except Exception as e:
utils.flash_plus(u'Kan bestand niet importeren', e)
return
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'))