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 gen_stats(self, user_from, matricule, only_sanctions=False, all_years=False):
all_access = get_settings().all_access.all()
queryset = CasEleve.objects.all()
if not user_from.groups.intersection(all_access).exists():
teachings = ResponsibleModel.objects.get(user=user_from).teaching.all()
classes = get_classes(list(map(lambda t: t.name, teachings)), True, user_from)
queryset = queryset.filter(matricule__classe__in=classes)
cas_discip = queryset.filter(info=None, matricule=matricule)\
.filter(Q(sanction_faite=True) | Q(sanction_faite__isnull=True))
cas_info = queryset.filter(sanction_decision=None, matricule=matricule)
if not all_years:
current_scolar_year = get_scholar_year()
limit_date = timezone.make_aware(timezone.datetime(current_scolar_year, 8, 15))
cas_discip = cas_discip.filter(datetime_encodage__gte=limit_date)
cas_info = cas_info.filter(datetime_encodage__gte=limit_date)
sanctions = SanctionStatisticsModel.objects.all()
stats = []
for s in sanctions:
stat = {
'display': s.display,
'value': len(cas_discip.filter(sanction_decision__in=s.sanctions_decisions.all()))
}
stats.append(stat)
if not only_sanctions:
stats.append({'display': 'Non disciplinaire', 'value': len(cas_info)})
stats.append({'display': 'Total disciplinaire', 'value': len(cas_discip)})
return stats
def get(self, request, matricule, format=None):
all_access = get_settings().all_access.all()
queryset = CasEleve.objects.all()
only_sanctions = request.GET.get('only_sanctions', 1) == 1
if not request.user.groups.intersection(all_access).exists():
teachings = ResponsibleModel.objects.get(user=self.request.user).teaching.all()
classes = get_classes(list(map(lambda t: t.name, teachings)), True, self.request.user)
queryset = queryset.filter(matricule__classe__in=classes)
current_scolar_year = get_scolar_year()
limit_date = timezone.make_aware(timezone.datetime(current_scolar_year, 8, 15))
cas_discip = queryset.filter(info=None, matricule=matricule).filter(Q(sanction_faite=True)
| Q(sanction_faite__isnull=True))
cas_info = queryset.filter(sanction_decision=None, matricule=matricule,
datetime_encodage__gte=limit_date)
sanctions = SanctionStatisticsModel.objects.all()
stats = []
for s in sanctions:
stat = {
'display': s.display,
'value': len(cas_discip.filter(sanction_decision__in=s.sanctions_decisions.all()))
}
stats.append(stat)
if not only_sanctions:
stats.append({'display': 'Non disciplinaire', 'value': len(cas_info)})
stats.append({'display': 'Total disciplinaire', 'value': len(cas_discip)})
return Response(json.dumps(stats))
def get(self, request, format=None):
teachings = ResponsibleModel.objects.get(
user=self.request.user).teaching.all()
classes = get_classes(list(map(lambda t: t.name, teachings)), True,
self.request.user)
students = StudentModel.objects.filter(classe__in=classes)
absences = self._filter_scholar_year(
StudentAbsenceModel.objects.filter(
student=OuterRef('matricule'))).values('student').annotate(
half_days=Sum(
Case(When(morning=True, afternoon=True, then=2),
When(Q(morning=True) | Q(afternoon=True), then=1),
When(morning=False, afternoon=False, then=0),
output_field=IntegerField()))).values('half_days')
justif = JustificationModel.objects.filter(
student=OuterRef('matricule')).values('student').annotate(
total=Sum('half_days')).values('total')
half_days = students.annotate(half_day_miss=Subquery(absences), half_day_just=Coalesce(Subquery(justif), 0))\
.exclude(half_day_miss__isnull=True).annotate(half_day_diff=F('half_day_miss') - F('half_day_just'))\
.values('matricule', 'half_day_miss', 'half_day_just', 'half_day_diff').order_by('-half_day_diff')
# Keep only the first 15 students.
half_days = list(
map(
lambda s: {
**s, 'student':
StudentModel.objects.get(matricule=s['matricule']).
fullname_classe
}, half_days[:15]))
return Response(half_days)
def get_queryset(self):
filtering = get_settings().filter_students_for_educ
force_all_access = self.request.query_params.get('forceAllAccess', "false")
force_all_access = json.loads(force_all_access) if force_all_access else False
if filtering == "none" or force_all_access:
return self.queryset
classes = get_classes(check_access=True, user=self.request.user, educ_by_years=filtering == "year")
return self.queryset.filter(student__classe__in=classes)
def get_queryset(self):
filtering = get_settings().filter_students_for_educ
if filtering == "none" or self.request.query_params.get(
'forceAllAccess', False):
return self.queryset
classes = get_classes(check_access=True,
user=self.request.user,
educ_by_years=filtering == "year")
return self.queryset.filter(student__classe__in=classes)
def get_queryset(self):
if not self.filter_access and self.request.user.groups.intersection(
self.all_access).exists():
return self.queryset
else:
teachings = ResponsibleModel.objects.get(
user=self.request.user).teaching.all()
classes = get_classes(list(map(lambda t: t.name, teachings)), True,
self.request.user)
return self.queryset.filter(matricule__classe__in=classes)
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 create_classes_list(request,
enseignement="all",
check_access=False,
annees="",
letters=""):
classes = get_classes([enseignement], check_access, request.user)
if annees:
classes = classes.filter(year=annees)
if letters:
classes = classes.filter(letter=letters.lower())
return list(map(lambda c: str(c), classes))
def classe_by(self, queryset, name, value):
if not value[0].isdigit():
return queryset
all_access = get_settings().all_access.all()
if not self.request.user.groups.intersection(all_access).exists():
teachings = ResponsibleModel.objects.get(user=self.request.user).teaching.all()
classes = get_classes(list(map(lambda t: t.name, teachings)), True, self.request.user)
queryset = queryset.filter(matricule__classe__in=classes)
if len(value) > 0:
queryset = queryset.filter(matricule__classe__year=value[0])
if len(value) > 1:
queryset = queryset.filter(matricule__classe__letter=value[1].lower())
return queryset
def get_queryset(self):
if self.request.user.groups.intersection(self.get_group_all_access()).exists():
return self.queryset
else:
try:
teachings = ResponsibleModel.objects.get(user=self.request.user).teaching.all()
classes = get_classes(list(map(lambda t: t.name, teachings)), True, self.request.user,
tenure_class_only=self.is_only_tenure())
try:
queryset = self.queryset.filter(student__classe__in=classes)
except FieldError:
queryset = self.queryset.filter(matricule__classe__in=classes)
warnings.warn("Use *student* as field name instead of matricule", DeprecationWarning)
return queryset
except ObjectDoesNotExist:
return self.queryset.none()
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 search_years(query, teachings, check_access, user):
if len(query) == 0:
return []
if not query[0].isdigit():
return []
if len(query) > 1:
if query[1] != "é" or query[1] != "e":
return []
years = get_classes(teaching=teachings,
check_access=check_access,
user=user).distinct('year', 'teaching')
return YearSerializer(years.filter(year=query[0]).order_by('year'),
many=True,
show_teaching=len(teachings) > 1).data
def search_classes(query, teachings, check_access, user):
if len(query) == 0:
return []
if not query[0].isdigit():
return []
truncate = True
classes = get_classes(teaching=teachings,
check_access=check_access,
user=user)
classes = classes.filter(year=query[0]).order_by('year', 'letter')
if len(query) > 1:
classes = classes.filter(letter=query[1].lower())
if truncate:
classes = classes[:100]
return ClasseSerializer(classes, many=True).data
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 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,
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 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 has_object_permission(self, request, view, obj):
teachings = ResponsibleModel.objects.get(
user=self.request.user).teaching.all()
classes = get_classes(list(map(lambda t: t.name, teachings)), True,
self.request.user)
return obj.matricule.classe in classes
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)
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)
