def get_people_names(request,
enseignement='all',
people_type='all',
formatting='json',
check_access=False):
people = []
query = request.GET.get('query', '')
if people_type == 'responsible' or people_type == 'all':
people += People().get_responsibles_by_name(query, [enseignement])
if people_type == 'teacher':
people += People().get_teachers_by_name(query, [enseignement])
if people_type == 'educator':
people += People().get_educators_by_name(query, [enseignement])
if people_type == 'student' or people_type == 'all':
classe_years = get_classes([enseignement],
check_access=True,
user=request.user) if check_access else None
people += People().get_students_by_name(query, [enseignement],
classes=classe_years)
if formatting == 'json':
return format_name_to_json(people, people_type)
return people
def get_pdf(request, all_year=False, matricule=None, classe=None, infos=None, sanctions=None):
response = None
classe_access = get_classes(get_settings().teachings.all(), True, request.user)
if matricule:
# student = StudentLDAP.objects.get(matricule=matricule)
student = People().get_student_by_id(matricule)
# if not int(student.classe[0]) in year_access:
if student.classe not in classe_access:
return HttpResponse("Vous n'avez pas les accès nécessaire.", status=401)
pdf = create_pdf(student, all_year, infos, sanctions)
if not pdf:
return render(request, 'dossier_eleve/no_student.html')
pdf_name = str(matricule) + '.pdf'
response = HttpResponse(content_type='application/pdf')
response['Content-Disposition'] = 'filename; filename="' + pdf_name + '"'
response.write(pdf.read())
return response
if classe:
# if not int(classe[0]) in year_access:
classes = classe_access.filter(year=int(classe[0]), letter=classe[1].lower(), teaching__name="secondaire")
if not classes.exists():
return HttpResponse("Vous n'avez pas les accès nécessaire.", status=401)
students = []
for c in classes:
students += People().get_students_by_classe(c.compact_str)
merger = PdfFileMerger()
added = False
for s in students:
pdf = create_pdf(s, all_year, infos, sanctions)
if not pdf:
continue
merger.append(pdf)
added = True
if not added:
return render(request, 'dossier_eleve/no_student.html')
output_stream = BytesIO()
merger.write(output_stream)
response = HttpResponse(content_type='application/pdf')
response['Content-Disposition'] = 'filename; filename="' + classe + '"'
response.write(output_stream.getvalue())
return response
return response
def get_list(request):
# Récuparation des variables GET
ens = request.GET.get("ens", "all").lower()
search = request.GET.get("search", "")
matricule = request.GET.get("mat", "")
classe = request.GET.get("classe", "")
people_type = request.GET.get("type", "student")
if people_type == 'teacher' and request.user.groups.filter(name__in=[
settings.SYSADMIN_GROUP, settings.DIRECTION_GROUP,
settings.RECEPTION_GROUP
]).exists():
return get_teacher_list(request, ens, search)
students = []
if matricule:
students = [People().get_student_by_id(int(matricule), [ens])]
# students = [student_man.get_person(int(matricule))]
elif classe:
an = classe[0]
classe_letter = classe[1]
classe = ClasseModel.objects.get(year=int(an),
letter=classe_letter.lower(),
teaching__name=ens)
students = StudentModel.objects.filter(classe=classe)
else:
if search.isdigit() and len(search) == 4:
# We are looking for a matricule
students = People().get_student_by_id(int(matricule))
elif search[0].isdigit():
# We are looking for a class
classes = ClasseModel.objects.filter(year=int(search[0]))
if ens != "all":
classes = classes.filter(teaching__name=ens)
if len(search) > 1:
classes = classes.filter(letter=search[1])
students = StudentModel.objects.filters(classe=classes)
else:
students = People().get_students_by_name(search, [ens])
# students = student_man.get_people_by_names(ens, search)
context = {}
if classe:
context['classe'] = classe.letter
context['year'] = classe.year
context['enseignement'] = ens
students = sorted(students,
key=lambda s: unidecode(s.last_name.lower()))
context['eleves'] = students
return render(request, 'annuaire/list.html', context=context)
def get_pdf_retenues(request, date=None, date2=None):
if not date2:
date2 = date
rows = filter_and_order(request, column="datetime_sanction", retenues=True,
data1=date.replace("-", "/"), data2=date2.replace("-", "/"),
order_by="classe")
retenues = []
for r in rows:
dic = model_to_dict(r)
# student = student_man.get_person(dic['matricule'])
student = People().get_student_by_id(dic['matricule'])
dic['classe'] = student.classe.compact_str
dic['full_name'] = student.fullname
dic['sanction_decision'] = SanctionDecisionDisciplinaire.objects.get(pk=dic['sanction_decision'])
retenues.append(dic)
context = {'date': date, 'list': retenues}
t = get_template('dossier_eleve/discip_retenues.rml')
rml_str = t.render(context)
pdf = rml2pdf.parseString(rml_str)
if not pdf:
return render(request, 'dossier_eleve/no_student.html')
pdf_name = 'retenues_' + date + '.pdf'
response = HttpResponse(content_type='application/pdf')
response['Content-Disposition'] = 'filename; filename="' + pdf_name + '"'
response.write(pdf.read())
return response
def get_pdf_council(request, date_from=None, date_to=None):
rows = filter_and_order(request, only_actives=True, retenues=False,
column='datetime_council', data1=date_from.replace("-", "/"), data2=date_to.replace("-", "/"),
order_by='classe')
discip_council = []
for r in rows:
dic = model_to_dict(r)
# student = student_man.get_person(dic['matricule'])
student = People().get_student_by_id(dic['matricule'])
dic['classe'] = student.classe.compact_str
dic['full_name'] = student.fullname
dic['sanction_decision'] = SanctionDecisionDisciplinaire.objects.get(pk=dic['sanction_decision'])
discip_council.append(dic)
context = {'date_from': date_from, 'date_to': date_to,
'list': discip_council}
t = get_template('dossier_eleve/discip_council.rml')
rml_str = t.render(context)
pdf = rml2pdf.parseString(rml_str)
if not pdf:
return render(request, 'dossier_eleve/no_student.html')
pdf_name = 'council_' + date_from + '_' + date_to + '.pdf'
response = HttpResponse(content_type='application/pdf')
response['Content-Disposition'] = 'filename; filename="' + pdf_name + '"'
response.write(pdf.read())
return response
def nouveau(request):
form = NouvelAppelForm(request.POST)
if form.is_valid():
a = Appel()
a.objet = form.cleaned_data['objet']
a.motif = form.cleaned_data['motif']
a.commentaire = form.cleaned_data['commentaires']
a.datetime_motif_start = form.cleaned_data['datetime_motif_start']
a.datetime_motif_end = form.cleaned_data['datetime_motif_end']
a.datetime_appel = form.cleaned_data['datetime_appel']
a.traitement = ""
a.is_traiter = False
a.user = request.user.username
# Check if we have a student or someone else.
matricule = int(form.cleaned_data['matricule'])
if matricule > 999 and matricule < 10000:
student = People().get_student_by_id(matricule, ['all'])
# studentLDAP = StudentLDAP.objects.get(matricule=matricule)
a.name = student.fullname
a.matricule = student
else:
a.name = form.cleaned_data['name']
a.is_student = False
a.save()
return True
else:
print("wrong form")
return False
def send_emails(appel):
context = {'appel': appel}
image = []
name = appel.name
if appel.is_student:
student = People().get_student_by_id(appel.matricule.matricule)
name = str(student)
context['etudiant'] = student
if check_student_photo(student, copy=False):
image = [
static("/photos/" + str(appel.matricule.matricule) + ".jpg")
]
else:
image = [static("/photos/unknown.jpg")]
sent_to = list(
filter(lambda e: e != '*****@*****.**',
map(lambda e: e.email, appel.emails.all())))
if appel.custom_email:
sent_to.append(appel.custom_email)
if not settings.DEBUG:
email.send_email(to=sent_to,
subject="[Appel] %s" % name,
email_template="appels/email.html",
context=context,
images=image)
else:
print(sent_to)
email.send_email(to=[settings.EMAIL_ADMIN],
subject="[Appel] %s" % name,
email_template="appels/email.html",
context=context,
images=image)
def summary(request, matricule):
# eleve = student_man.get_person(matricule)
eleve = People().get_student_by_id(matricule)
if not eleve:
raise Http404("Matricule inexistant : " + str(matricule))
context = {'eleve': eleve.__dict__}
#TODO: infirmerie, appels, dossier_eleve
if 'infirmerie' in settings.INSTALLED_APPS:
from infirmerie.views import filter_and_order
context['infirmerie'] = filter_and_order(request,
column="matricule",
data1=eleve.matricule,
order_by="datetime_encodage",
order_asc="desc")[:5]
if 'appels' in settings.INSTALLED_APPS:
from appels.views import filter_and_order
context['appels'] = filter_and_order(request,
column="matricule",
data1=eleve.matricule,
order_by="datetime_encodage",
order_asc="desc")[:5]
if 'dossier_eleve' in settings.INSTALLED_APPS:
from dossier_eleve.views import filter_and_order
context['dossier_eleve'] = filter_and_order(
request,
column="matricule",
data1=eleve.matricule,
order_by="datetime_encodage",
order_asc="desc")[:5]
return render(request, 'annuaire/eleve.html', context)
def send_emails(passage, template, subject):
eleve = People().get_student_by_id(passage.matricule.matricule)
if check_student_photo(eleve, copy=False):
image = static("/photos/" + str(passage.matricule.matricule) + ".jpg")
else:
image = static("/photos/unknown.jpg")
context = {
'eleve': eleve,
'heure_arrive': passage.datetime_arrive,
'commentaire': passage.motifs_admission,
'passage': passage,
'phone_number': get_settings().phone_number
}
recipients = email.get_resp_emails(eleve)
recipients_emails = []
for r in recipients.items():
recipients_emails.append(r[0])
if not settings.DEBUG:
email.send_email(to=recipients,
subject="[Infirmerie] %s %s %s" %
(subject, eleve.fullname, eleve.classe.compact_str),
email_template="infirmerie/" + template + ".html",
context=context,
images=[image])
else:
print("Sending to: " + str(recipients_emails))
email.send_email(to=[settings.EMAIL_ADMIN],
subject="[Infirmerie] %s %s %s" %
(subject, eleve.fullname, eleve.classe.compact_str),
email_template="infirmerie/" + template + ".html",
context=context,
images=[image])
def traiter(request):
# Add informations/modifications.
is_traiter = 'traiter' in request.POST
form = TraiterAppelForm(request.POST)
if form.is_valid():
a = Appel.objects.get(pk=request.POST['id'])
a.objet = form.cleaned_data['objet']
a.motif = form.cleaned_data['motif']
a.commentaire = form.cleaned_data['commentaires']
a.datetime_appel = form.cleaned_data['datetime_appel']
a.traitement = form.cleaned_data['remarques']
a.custom_email = form.cleaned_data['custom_email']
if is_traiter:
a.datetime_traitement = form.cleaned_data['datetime_traitement']
a.is_traiter = True
# Add emails
a.emails.clear()
for e in form.cleaned_data['emails']:
a.emails.add(e)
a.save()
# Send emails
if is_traiter:
context = {'appel': a}
image = []
name = a.name
if a.is_student:
# etudiant = student_man.get_person(a.matricule.matricule)
etudiant = People().get_student_by_id(a.matricule.matricule,
['all'])
name = str(etudiant)
context['etudiant'] = etudiant
image = [
static("/photos/" + str(a.matricule.matricule) + ".jpg")
]
sent_to = list(
filter(lambda e: e != '*****@*****.**',
map(lambda e: e.email, a.emails.all())))
if a.custom_email:
sent_to.append(a.custom_email)
if not settings.DEBUG:
email.send_email(to=sent_to,
subject="[Appel] %s" % name,
email_template="appels/email.html",
context=context,
images=image)
else:
print(sent_to)
email.send_email(to=[settings.EMAIL_ADMIN],
subject="[Appel] %s" % name,
email_template="appels/email.html",
context=context,
images=image)
else:
print(form.errors)
def is_valid(self):
valid = super(ArriveForm, self).is_valid()
if not valid:
return valid
return not People().get_student_by_id(
self.cleaned_data['matricule']) is None
def get_teacher_list(request, ens, search):
teachers = []
if search != "":
# teachers = teacher_man.get_people_by_names(ens, search)
teachers = People().get_teachers_by_name(search, [ens])
return render(request, 'annuaire/list_teacher.html',
{'teachers': teachers})
def get_teachers_emails(request, enseignement='secondaire'):
query = request.GET.get('query', '')
if query == '':
return JsonResponse([], safe=False)
teachers = People().get_teachers_by_name(query, [enseignement])
# teachers = teacher_man.get_people_by_names(enseignement, search_string=query)
teachers = list(map(lambda t: t.gen_email, teachers))
return JsonResponse(teachers, safe=False)
def summary_teacher(request, id):
if not request.user.groups.filter(name__in=[
settings.SYSADMIN_GROUP, settings.DIRECTION_GROUP,
settings.RECEPTION_GROUP
]).exists():
raise Http404("ID inexistant : " + str(id))
# teacher = teacher_man.get_person(id, ens)
teacher = People().get_teacher_by_id(id)
if not teacher:
raise Http404("ID inexistant : " + str(id))
context = {'teacher': teacher}
return render(request, 'annuaire/professeur.html', context)
def info(request, matricule, medical_info='1', user_info='1'):
try:
# student = student_man.get_person(matricule)
student = People().get_student_by_id(matricule)
except StopIteration:
raise Http404("Matricule inexistant : " + str(matricule))
context = {
'student': student,
'medical_info': medical_info,
'user_info': user_info
}
return render(request, 'annuaire/eleve_info.html', context=context)
def search_people(query, people_type, teachings, check_access, user):
def serialize_people(person):
if type(person) == StudentModel:
return StudentSerializer(person).data
elif type(person) == ResponsibleModel:
return ResponsibleSensitiveSerializer(person).data
if len(query) < 1:
return []
truncate_limit = 50
people = []
if people_type == 'responsible' or people_type == 'all':
people += ResponsibleSensitiveSerializer(
People().get_responsibles_by_name(query,
teachings)[:truncate_limit],
many=True).data
if people_type == 'teacher':
people += ResponsibleSensitiveSerializer(People().get_teachers_by_name(
query, teachings)[:truncate_limit],
many=True).data
if people_type == 'educator':
people += ResponsibleSensitiveSerializer(
People().get_educators_by_name(query, teachings)[:truncate_limit],
many=True).data
if people_type == 'student' or people_type == 'all':
classe_years = get_classes(teachings, check_access=True,
user=user) if check_access else None
people += StudentSerializer(People().get_students_by_name(
query, teachings, classes=classe_years)[:truncate_limit],
many=True).data
return people[:truncate_limit]
def get(self, request, format=None):
if request.GET.get('matricule_id'):
pdf = self.create_pdf(request)
if not pdf:
return render(request, 'dossier_eleve/no_student.html')
pdf_name = str(request.GET['matricule_id']) + '.pdf'
response = HttpResponse(content_type='application/pdf')
response[
'Content-Disposition'] = 'filename; filename="' + pdf_name + '"'
response.write(pdf.read())
return response
if request.GET.get('classe'):
classe_access = get_classes(get_settings().teachings.all(), True,
request.user)
try:
classe = classe_access.get(id=request.GET['classe'])
except ObjectDoesNotExist:
return HttpResponse("Vous n'avez pas les accès nécessaire.",
status=401)
students = People().get_students_by_classe(classe)
merger = PdfFileMerger()
added = False
for s in students:
request._request.GET = request.GET.copy()
request._request.GET['matricule_id'] = s.matricule
pdf = self.create_pdf(request)
if not pdf:
continue
merger.append(pdf)
added = True
if not added:
return render(request, 'dossier_eleve/no_student.html')
output_stream = BytesIO()
merger.write(output_stream)
response = HttpResponse(content_type='application/pdf')
response[
'Content-Disposition'] = 'filename; filename="' + classe.compact_str + '.pdf"'
response.write(output_stream.getvalue())
return response
return render(request, 'dossier_eleve/no_student.html')
def info_teacher(request, matricule):
if not request.user.groups.filter(name__in=[
settings.SYSADMIN_GROUP, settings.DIRECTION_GROUP,
settings.RECEPTION_GROUP
]).exists():
raise Http404("ID inexistant : " + str(id))
# teacher = teacher_man.get_person(matricule, ens)
teacher = People().get_teacher_by_id(matricule)
if not teacher:
raise Http404("Matricule inexistant : " + str(matricule))
context = {'teacher': teacher}
if request.user.groups.filter(
name__in=[settings.SYSADMIN_GROUP, settings.DIRECTION_GROUP
]).exists():
context['username_info'] = True
return render(request, 'annuaire/professeur_info.html', context)
def nouveau(request):
form = ArriveForm(request.POST)
if form.is_valid():
student = People().get_student_by_id(form.cleaned_data['matricule'],
teaching=teachings)
if not student:
return False
p = Passage(matricule=student,
datetime_arrive=form.cleaned_data['datetime_arrive'],
motifs_admission=form.cleaned_data['admission'],
remarques_sortie="",
name=student.fullname)
send_emails(p, "nouveau_email", "Arrivée de")
p.save()
return True
else:
return False
def filter_and_order(request,
only_actives=False,
column=None,
data1=None,
data2=None,
order_by=None,
order_asc=False,
ens='all'):
rows = Appel.objects.exclude(matricule__isnull=True, is_student=True)
# First we filter and order at the query level
# Filtering
if only_actives:
rows = rows.filter(datetime_traitement__isnull=True)
if ens != 'all':
rows = rows.filter(matricule__enseignement=ens, is_student=True)
if column and data1 != '':
if column == 'name':
# people = People().get_people_by_name(data1, teaching=[ens])
rows = rows.filter(name__icontains=data1)
if column == 'matricule':
rows = rows.filter(matricule__matricule=int(data1))
if column == 'classe':
students = People().get_students_by_classe(data1, [ens])
rows = rows.filter(matricule__in=students)
if column == 'objet':
rows = rows.filter(objet__icontains=data1)
if column == 'motif':
rows = rows.filter(motif__icontains=data1)
if column == 'commentaire':
rows = rows.filter(commentaire__icontains=data1)
if column == 'traitement':
rows = rows.filter(traitement__icontains=data1)
# if column == 'sanction_faite':
# rows = rows.filter(sanction_faite='oui'.startswith(data1.lower()))
if column.startswith('datetime') and data2 != '':
date_1 = timezone.datetime.strptime(
data1, '%d/%m/%Y') if type(data1) == str else data1
date_2 = timezone.datetime.strptime(
data2, '%d/%m/%Y') if type(data2) == str else data2
date_2 = date_2.replace(hour=23, minute=59)
date_1 = timezone.make_aware(date_1) if timezone.is_naive(
date_1) else date_1
date_2 = timezone.make_aware(date_2) if timezone.is_naive(
date_2) else date_2
if column == 'datetime_appel':
rows = rows.filter(datetime_appel__range=[date_1, date_2])
if column == 'datetime_motif_start':
rows = rows.filter(
datetime_motif_start__range=[date_1, date_2])
if column == 'datetime_motif_end':
rows = rows.filter(datetime_motif_end__range=[date_1, date_2])
if column == 'datetime_traitement':
rows = rows.filter(datetime_traitement__range=[date_1, date_2])
# Check access
if not request.user.groups.filter(name__in=[
settings.SYSADMIN_GROUP, settings.DIRECTION_GROUP,
settings.RECEPTION_GROUP
]).exists():
auth_classes = get_classes([ens], check_access=True, user=request.user)
rows = rows.filter(matricule__classe__in=auth_classes)
# Ordering
asc = ''
if order_asc:
asc = '-'
if order_by in [
'datetime_appel', 'datetime_motif_start', 'datetime_motif_end'
]:
rows = rows.order_by(asc + order_by)
if order_by in ['classe']:
rows = rows.order_by(asc + 'matricule__' + order_by)
if order_by in ['name']:
rows = rows.order_by(asc + 'matricule__lastname')
if order_by in ['datetime_traitement']:
rows = rows.annotate(**{
'null_' + order_by: Count(order_by)
}).order_by('-null_' + order_by, asc + order_by)
# Transform query into a list and thus make the actual query on the database
return list(rows)
def search_people(query,
people_type,
teachings,
check_access,
user,
tenure_class_only=True,
educ_by_years=True,
active=True):
if len(query) < 1:
return []
truncate_limit = 50
people = []
if people_type == 'all':
classe_years = get_classes(teachings, check_access=True,
user=user) if check_access else None
result = People().get_people_by_name(query,
teachings,
classes=classe_years,
active=active)
# Check quality.
if result['student'][1] > result['responsible'][1]:
people = StudentSerializer(result['student'][0][:truncate_limit],
many=True).data
elif result['responsible'][1] > result['student'][1]:
people = ResponsibleSerializer(
result['responsible'][0][:truncate_limit], many=True).data
else:
people = StudentSerializer(
result['student'][0][:truncate_limit / 2],
many=True).data + ResponsibleSerializer(
result['responsible'][0][:truncate_limit / 2],
many=True).data
if people_type == 'student':
classe_years = get_classes(
teachings,
check_access=True,
user=user,
tenure_class_only=tenure_class_only,
educ_by_years=educ_by_years) if check_access else None
if query == 'everybody':
students = StudentModel.objects.all()
if active:
students = students.filter(inactive_from__isnull=True,
classe__isnull=False)
if classe_years:
students = students.filter(classe__in=classe_years)
if teachings and 'all' not in teachings:
if type(teachings[0]) == TeachingModel:
students = students.filter(teaching__in=teachings)
else:
students = students.filter(teaching__name__in=teachings)
truncate_limit = len(students)
else:
students = People().get_students_by_name(
query, teachings, classes=classe_years,
active=active)[:truncate_limit]
people = StudentSerializer(students, many=True).data
if people_type == 'responsible':
people = ResponsibleSerializer(People().get_responsibles_by_name(
query, teachings, active=active)[:truncate_limit],
many=True).data
if people_type == 'teacher':
people = ResponsibleSerializer(People().get_teachers_by_name(
query, teachings, active=active)[:truncate_limit],
many=True).data
if people_type == 'educator':
people = ResponsibleSerializer(People().get_educators_by_name(
query, teachings, active=active)[:truncate_limit],
many=True).data
return people[:truncate_limit]
def filter_and_order(request, only_actives=False, retenues=False, year=None,
column=None, data1=None, data2=None,
column2=None, data3=None, data4=None,
order_by=None, order_asc=False):
rows = CasEleve.objects.filter(matricule__isnull=False)
# Filter the rows from the user teaching.
try:
teachings = ResponsibleModel.objects.get(user=request.user).teaching.all()
except ObjectDoesNotExist:
# Responsible doesn't exist return null result.
return []
rows = rows.filter(matricule__teaching__in=teachings)
# First we filter and order at the query level
# Filtering
if only_actives:
rows = rows.filter(datetime_conseil__isnull=False)
if year:
date_1 = timezone.datetime.strptime(str(year) + "-08-20", '%Y-%m-%d')
date_2 = timezone.datetime.strptime(str(year + 1) + "-08-19", '%Y-%m-%d')
rows = rows.filter(datetime_encodage__range=[date_1, date_2])
if retenues:
rows = rows.filter(sanction_decision__pk__in=SANCTIONS_RETENUE)
if column and data1 != '':
if column == 'name':
rows = rows.filter(name__unaccent__icontains=data1)
if column == 'matricule':
rows = rows.filter(matricule__matricule=int(data1))
if column == 'classe':
students = People().get_students_by_classe(data1, ['secondaire'])
rows = rows.filter(matricule__in=students)
if column == 'info':
rows = rows.filter(info__info__icontains=data1)
if column == 'sanction':
# Filter sanction by id
sanctions = list(map(lambda s: s.pk,
SanctionDecisionDisciplinaire.objects.filter(sanction_decision__icontains=data1)))
# Filter Cas by info_id
rows = rows.filter(sanction_decision__in=sanctions)
if column == 'demandeur':
rows = rows.filter(demandeur__icontains=data1)
if column == 'comment':
rows = rows.filter(explication_commentaire__icontains=data1)
if column == 'sanction_faite':
rows = rows.filter(sanction_faite='oui'.startswith(data1.lower()))
# Check if entries are valids
if column.startswith('datetime') and data2 != '':
date_1 = timezone.datetime.strptime(data1, '%d/%m/%Y') if type(data1) == str else data1
date_2 = timezone.datetime.strptime(data2, '%d/%m/%Y') if type(data2) == str else data2
date_1 = timezone.make_aware(date_1) if timezone.is_naive(date_1) else date_1
date_2 = timezone.make_aware(date_2) if timezone.is_naive(date_2) else date_2
date_1 = date_1.replace(hour=1)
date_2 = date_2.replace(hour=23)
if column == 'datetime_encodage':
rows = rows.filter(datetime_encodage__range=[date_1, date_2])
if column == 'datetime_council':
rows = rows.filter(datetime_conseil__range=[date_1, date_2])
if column == 'datetime_sanction':
rows = rows.filter(datetime_sanction__range=[date_1, date_2])
# Check access
if not request.user.groups.filter(name__in=[settings.SYSADMIN_GROUP, settings.DIRECTION_GROUP]).exists():
auth_classes = get_classes(['secondaire'], check_access=True, user=request.user)
if request.user.groups.filter(name__istartswith='coord').exists():
if retenues:
rows = rows.filter(Q(matricule__classe__in=auth_classes)
| Q(sanction_decision__pk__in=SANCTIONS_RETENUE))
else:
rows = rows.filter(matricule__classe__in=auth_classes)
elif request.user.groups.filter(name='educateur'):
if retenues:
rows = rows.filter(Q(matricule__classe__in=auth_classes, visible_by_educ=True)
| Q(sanction_decision__pk__in=SANCTIONS_RETENUE))
else:
rows = rows.filter(matricule__classe__in=auth_classes, visible_by_educ=True)
elif request.user.groups.filter(name=settings.TEACHER_GROUP):
# teacher = teacher_man.get_people(filters=['uid=' + request.user.username])[0]
classes = ResponsibleModel.objects.get(user=request.user).tenure.all()
rows = rows.filter(matricule__classe__in=classes, visible_by_tenure=True)
# Ordering
asc = ''
if order_asc:
asc = '-'
if order_by in ['datetime_encodage', 'demandeur']:
rows = rows.order_by(asc + order_by)
if order_by in ['classe']:
rows = rows.order_by(
asc + 'matricule__' + order_by + '__year',
asc + 'matricule__' + order_by + '__letter',
asc + 'matricule__last_name',
)
if order_by in ['name']:
rows = rows.order_by(asc + 'matricule__last_name')
if order_by in ['datetime_sanction', 'datetime_conseil', 'sanction_faite']:
rows = rows.annotate(**{'null_' + order_by: Count(order_by)}).order_by('-null_' + order_by,
asc + order_by)
# Transform query into a list and thus make the actual query on the database
return list(rows)
def filter_and_order(request,
only_actives=False,
column=None,
data1=None,
data2=None,
order_by=None,
order_asc=False,
ens='all'):
rows = Passage.objects.filter(matricule__isnull=False)
# First we filter and order at the query level
# Filtering
if only_actives:
rows = rows.filter(datetime_sortie__isnull=only_actives)
if ens != 'all':
rows = rows.filter(matricule__teaching__name=ens)
if column and data1 != '':
if column == 'name':
students = People().get_students_by_name(data1, teaching=[ens])
rows = rows.filter(matricule__in=students)
if column == 'matricule':
rows = rows.filter(matricule__matricule=int(data1))
if column == 'classe':
students = People().get_students_by_classe(data1, [ens])
rows = rows.filter(matricule__in=students)
if column == 'motif':
rows = rows.filter(motifs_admission__icontains=data1)
if column == 'comment':
rows = rows.filter(remarques_sortie__icontains=data1)
# Check if entries are valids
if column.startswith('datetime') and data2 != '':
date_1 = timezone.datetime.strptime(
data1, '%d/%m/%Y') if type(data1) == str else data1
date_2 = timezone.datetime.strptime(
data2, '%d/%m/%Y') if type(data2) == str else data2
date_1 = timezone.make_aware(date_1) if timezone.is_naive(
date_1) else date_1
date_2 = date_2.replace(hour=23, minute=59)
date_2 = timezone.make_aware(date_2) if timezone.is_naive(
date_2) else date_2
if column == 'datetime_arrive':
rows = rows.filter(datetime_arrive__range=[date_1, date_2])
if column == 'datetime_sortie':
rows = rows.filter(datetime_sortie__range=[date_1, date_2])
# Check access
if not request.user.groups.filter(name__in=[
settings.SYSADMIN_GROUP, settings.DIRECTION_GROUP,
settings.RECEPTION_GROUP
]).exists():
auth_classes = get_classes([ens], check_access=True, user=request.user)
rows = rows.filter(matricule__classe__in=auth_classes)
# Ordering
asc = ''
if order_asc:
asc = '-'
if order_by in ['datetime_arrive']:
rows = rows.order_by(asc + order_by)
if order_by in ['classe']:
rows = rows.order_by(asc + 'matricule__' + order_by)
if order_by in ['name']:
rows = rows.order_by(asc + 'matricule__last_name')
if order_by in ['datetime_sortie']:
rows = rows.annotate(**{
'null_' + order_by: Count(order_by)
}).order_by('-null_' + order_by, asc + order_by)
return list(rows)
def nouveau(request):
form = NouveauCasForm(request.POST)
if form.is_valid():
explication_commentaire = demandeur = ""
info = sanction_decision = datetime_sanction = datetime_conseil = None
sanction_faite = False
visible_by_educ = visible_by_tenure = True
if form.cleaned_data['est_disciplinaire'] == 'non_disciplinaire':
info = InfoEleve.objects.get(pk=form.cleaned_data['info'])
explication_commentaire = form.cleaned_data['commentaire_info']
visible_by_educ = form.cleaned_data['visible_by_educ']
visible_by_tenure = form.cleaned_data['visible_by_tenure']
else:
sanction_decision = SanctionDecisionDisciplinaire.objects.get(pk=form.cleaned_data['sanction_decision'])
datetime_sanction = form.cleaned_data['datetime_sanction']
explication_commentaire = form.cleaned_data['explication_sanction']
sanction_faite = form.cleaned_data['sanction_faite']
if form.cleaned_data['conseil_discipline']:
datetime_conseil = form.cleaned_data['datetime_conseil']
c = None
if int(request.POST['id']) < 0:
# Create a new entry.
matricule = form.cleaned_data['matricule']
try:
student = People().get_student_by_id(matricule, ['secondaire'])
except ObjectDoesNotExist:
print(ObjectDoesNotExist("Student matricule %s does not exist" % matricule))
return
# Check authorizations.
classes = get_classes(teaching=['secondaire'], check_access=True, user=request.user)
if student.classe not in classes:
return
c = CasEleve(matricule=student, name=student.fullname)
c.datetime_encodage = timezone.now()
c.user = request.user.username
else:
c = CasEleve.objects.get(pk=request.POST['id'])
# Check authorizations.
classes = get_classes(teaching=['secondaire'], check_access=True, user=request.user)
if c.matricule.classe not in classes:
return
c.info = info
c.demandeur = form.cleaned_data['demandeur']
c.important = form.cleaned_data['important']
c.sanction_decision = sanction_decision
c.explication_commentaire = explication_commentaire
c.datetime_sanction = datetime_sanction
c.datetime_conseil = datetime_conseil
c.sanction_faite = sanction_faite
c.visible_by_educ = visible_by_educ
c.visible_by_tenure = visible_by_tenure
# Check if we need to send info to the related teachers
if info and form.cleaned_data['send_to_teachers']:
student = People().get_student_by_id(c.matricule.matricule)
teachers_obj = ResponsibleModel.objects.filter(classe=student.classe)
# student = student_man.get_person(c.matricule.matricule)
# teachers_obj = teacher_man.get_people(filters=['classe=' + student.classe, 'enseignement=secondaire'])
teachers = []
for t in teachers_obj:
if not t.email_alias:
send_email(to=[settings.EMAIL_ADMIN],
subject='ISLN : À propos de ' + student.fullname + " non envoyé à %s" % t.full_name,
email_template="dossier_eleve/email_info.html",
context={'student': student, 'info': model_to_dict(c), 'info_type': info}
)
else:
teachers.append(t.email_alias)
# Add coord and educs to email list
teachers += map(lambda e: e.email, EmailModel.objects.filter(teaching=student.teaching, years=student.classe.year))
teachers += list(map(lambda e: e.email, EmailModel.objects.filter(is_pms=True)))
if not settings.DEBUG:
try:
send_email(to=teachers,
subject='ISLN : À propos de ' + student.fullname,
email_template="dossier_eleve/email_info.html",
context={'student': student, 'info': model_to_dict(c), 'info_type': info}
)
except Exception as err:
send_email(to=teachers,
subject='ISLN : À propos de ' + student.fullname,
email_template="dossier_eleve/email_info.html",
context={'student': student, 'info': model_to_dict(c), 'info_type': info}
)
else:
print(teachers)
send_email(to=[settings.EMAIL_ADMIN],
subject='ISLN : À propos de ' + student.fullname,
email_template="dossier_eleve/email_info.html",
context={'student': student, 'info': model_to_dict(c), 'info_type': info}
)
for t in teachers:
print("Sending email to : " + t)
c.save()
else:
print("ERROR !!!!!")
print(form.errors)
