Merge branch 'gen_cal' of https://scodoc.org/git/iziram/ScoDoc into gen_cal

This commit is contained in:
Emmanuel Viennet 2024-05-17 12:02:23 +02:00
commit d20ada1797
6 changed files with 527 additions and 297 deletions

View File

@ -25,8 +25,8 @@
#
##############################################################################
"""Evaluations
"""
"""Evaluations"""
import collections
import datetime
import operator
@ -50,6 +50,7 @@ from app.scodoc import sco_cal
from app.scodoc import sco_evaluation_db
from app.scodoc import sco_formsemestre_inscriptions
from app.scodoc import sco_groups
from app.scodoc import sco_gen_cal
from app.scodoc import sco_moduleimpl
from app.scodoc import sco_preferences
from app.scodoc import sco_users
@ -360,6 +361,103 @@ def do_evaluation_etat_in_mod(nt, modimpl: ModuleImpl):
return etat
class JourEval(sco_gen_cal.Jour):
"""
Représentation d'un jour dans un calendrier d'évaluations
"""
COLOR_INCOMPLETE = "#FF6060"
COLOR_COMPLETE = "#A0FFA0"
COLOR_FUTUR = "#70E0FF"
def __init__(
self,
date: datetime.date,
evaluations: list[Evaluation],
parent: "CalendrierEval",
):
super().__init__(date)
self.evaluations: list[Evaluation] = evaluations
self.evaluations.sort(key=lambda e: e.date_debut)
self.parent: "CalendrierEval" = parent
def get_html(self) -> str:
html: str = ""
for e in self.evaluations:
url: str = url_for(
"notes.moduleimpl_status",
scodoc_dept=g.scodoc_dept,
moduleimpl_id=e.moduleimpl_id,
)
title: str = (
e.moduleimpl.module.code or e.moduleimpl.module.abbrev or "éval."
)
html += f"""<a
href="{url}"
style="{self._get_eval_style(e)}"
title="{self._get_eval_title(e)}"
>
{title}</a><br>"""
return html
def _get_eval_style(self, e: Evaluation) -> str:
color: str = ""
# Etat (notes completes) de l'évaluation:
modimpl_result = self.parent.nt.modimpls_results[e.moduleimpl.id]
if modimpl_result.evaluations_etat[e.id].is_complete:
color = JourEval.COLOR_COMPLETE
else:
color = JourEval.COLOR_INCOMPLETE
if e.date_debut > datetime.datetime.now(scu.TIME_ZONE):
color = JourEval.COLOR_FUTUR
return f"background-color: {color};"
def _get_eval_title(self, e: Evaluation) -> str:
heure_debut_txt, heure_fin_txt = "", ""
if e.date_debut != e.date_fin:
heure_debut_txt = (
e.date_debut.strftime(scu.TIME_FMT) if e.date_debut else ""
)
heure_fin_txt = e.date_fin.strftime(scu.TIME_FMT) if e.date_fin else ""
title = f"{e.description or e.moduleimpl.module.titre_str()}"
if heure_debut_txt:
title += f" de {heure_debut_txt} à {heure_fin_txt}"
return title
class CalendrierEval(sco_gen_cal.Calendrier):
"""
Représentation des évaluations d'un semestre dans un calendrier
"""
def __init__(self, year: int, evals: list[Evaluation], nt: NotesTableCompat):
# On prend du 01/09 au 31/08
date_debut: datetime.datetime = datetime.datetime(year, 9, 1, 0, 0)
date_fin: datetime.datetime = datetime.datetime(year + 1, 8, 31, 23, 59)
super().__init__(date_debut, date_fin)
# évalutions du semestre
self.evals: dict[datetime.date, list[Evaluation]] = {}
for e in evals:
if e.date_debut is not None:
day = e.date_debut.date()
if day not in self.evals:
self.evals[day] = []
self.evals[day].append(e)
self.nt: NotesTableCompat = nt
def instanciate_jour(self, date: datetime.date) -> JourEval:
return JourEval(date, self.evals.get(date, []), parent=self)
# View
def formsemestre_evaluations_cal(formsemestre_id):
"""Page avec calendrier de toutes les evaluations de ce semestre"""
@ -369,52 +467,9 @@ def formsemestre_evaluations_cal(formsemestre_id):
evaluations = formsemestre.get_evaluations()
nb_evals = len(evaluations)
color_incomplete = "#FF6060"
color_complete = "#A0FFA0"
color_futur = "#70E0FF"
year = formsemestre.annee_scolaire()
events_by_day = collections.defaultdict(list) # date_iso : event
for e in evaluations:
if e.date_debut is None:
continue # éval. sans date
if e.date_debut == e.date_fin:
heure_debut_txt, heure_fin_txt = "", ""
else:
heure_debut_txt = (
e.date_debut.strftime(scu.TIME_FMT) if e.date_debut else ""
)
heure_fin_txt = e.date_fin.strftime(scu.TIME_FMT) if e.date_fin else ""
# Etat (notes completes) de l'évaluation:
modimpl_result = nt.modimpls_results[e.moduleimpl.id]
if modimpl_result.evaluations_etat[e.id].is_complete:
color = color_complete
else:
color = color_incomplete
if e.date_debut > datetime.datetime.now(scu.TIME_ZONE):
color = color_futur
day = e.date_debut.date().isoformat() # yyyy-mm-dd
event = {
"color": color,
"date_iso": day,
"title": e.moduleimpl.module.code or e.moduleimpl.module.abbrev or "éval.",
"description": f"""{e.description or e.moduleimpl.module.titre_str()}"""
+ (
f""" de {heure_debut_txt} à {heure_fin_txt}"""
if heure_debut_txt
else ""
),
"href": url_for(
"notes.moduleimpl_status",
scodoc_dept=g.scodoc_dept,
moduleimpl_id=e.moduleimpl_id,
),
"modimpl": e.moduleimpl,
}
events_by_day[day].append(event)
cal_html = sco_cal.YearTable(year, events_by_day=events_by_day)
cal = CalendrierEval(year, evaluations, nt)
cal_html = cal.get_html()
return f"""
{
@ -430,15 +485,15 @@ def formsemestre_evaluations_cal(formsemestre_id):
</p>
<ul>
<li>en <span style=
"background-color: {color_incomplete}">rouge</span>
"background-color: {JourEval.COLOR_INCOMPLETE}">rouge</span>
les évaluations passées auxquelles il manque des notes
</li>
<li>en <span style=
"background-color: {color_complete}">vert</span>
"background-color: {JourEval.COLOR_COMPLETE}">vert</span>
les évaluations déjà notées
</li>
<li>en <span style=
"background-color: {color_futur}">bleu</span>
"background-color: {JourEval.COLOR_FUTUR}">bleu</span>
les évaluations futures
</li>
</ul>

153
app/scodoc/sco_gen_cal.py Normal file
View File

@ -0,0 +1,153 @@
"""
Génération d'un calendrier
(Classe abstraite à implémenter dans les classes filles)
"""
import datetime
from flask import render_template
import app.scodoc.sco_utils as scu
from app import g
class Jour:
"""
Représente un jour dans le calendrier
Permet d'obtenir les informations sur le jour
et générer une représentation html
"""
def __init__(self, date: datetime.date):
self.date = date
self.class_list: list[str] = []
if self.is_non_work():
self.class_list.append("non-travail")
if self.is_current_week():
self.class_list.append("sem-courante")
def get_nom(self, short=True):
"""
Renvoie le nom du jour
"M19" ou "Mer 19"
par défaut en version courte
"""
str_jour: str = scu.DAY_NAMES[self.date.weekday()].capitalize()
return (
f"{str_jour[0] if short or self.is_non_work() else str_jour[:3]+' '}"
+ f"{self.date.day}"
)
def is_non_work(self):
"""
Renvoie True si le jour est un jour non travaillé
(en fonction de la préférence du département)
"""
return self.date.weekday() in scu.NonWorkDays.get_all_non_work_days(
dept_id=g.scodoc_dept_id
)
def is_current_week(self):
"""
Renvoie True si le jour est dans la semaine courante
"""
return self.date.isocalendar()[0:2] == datetime.date.today().isocalendar()[0:2]
def get_date(self) -> str:
"""
Renvoie la date du jour au format "dd/mm/yyyy"
"""
return self.date.strftime(scu.DATE_FMT)
def get_html(self):
"""
Renvoie le code html du jour
à surcharger dans les classes filles
l'html final ressemblera à :
<div class="jour {{jour.get_class()}}">
<span class="nom">{{jour.get_nom()}}</span>
<div class="contenu">
{{jour.get_html() | safe}}
</div>
</div>
"""
raise NotImplementedError("Méthode à implémenter dans les classes filles")
def get_class(self):
"""
Renvoie la classe css du jour
utilise self.class_list
-> fait un join de la liste
"""
return " ".join(self.class_list)
class Calendrier:
"""
Représente un calendrier
Permet d'obtenir les informations sur les jours
et générer une représentation html
"""
def __init__(self, date_debut: datetime.date, date_fin: datetime.date):
self.date_debut = date_debut
self.date_fin = date_fin
self.jours: dict[str, list[Jour]] = {}
def _get_dates_between(self) -> list[datetime.date]:
"""
get_dates_between Renvoie la liste des dates entre date_debut et date_fin
Returns:
list[datetime.date]: liste des dates entre date_debut et date_fin
"""
resultat = []
date_actuelle: datetime.date = self.date_debut
while date_actuelle <= self.date_fin:
if isinstance(date_actuelle, datetime.datetime):
resultat.append(date_actuelle.date())
elif isinstance(date_actuelle, datetime.date):
resultat.append(date_actuelle)
date_actuelle += datetime.timedelta(days=1)
return resultat
def organize_by_month(self):
"""
Organise les jours par mois
Instancie un objet Jour pour chaque jour
met à jour self.jours
"""
organized = {}
for date in self._get_dates_between():
# Récupérer le mois en français
month = scu.MONTH_NAMES_ABBREV[date.month - 1]
# Ajouter le jour à la liste correspondante au mois
if month not in organized:
organized[month] = []
jour: Jour = self.instanciate_jour(date)
organized[month].append(jour)
self.jours = organized
def instanciate_jour(self, date: datetime.date) -> Jour:
"""
Instancie un objet Jour pour chaque jour
A surcharger dans les classes filles si besoin
"""
raise NotImplementedError("Méthode à implémenter dans les classes filles")
def get_html(self):
"""
get_html Renvoie le code html du calendrier
"""
self.organize_by_month()
return render_template("calendrier.j2", calendrier=self.jours)

View File

@ -1,19 +1,21 @@
.day .dayline {
.jour .dayline {
position: absolute;
display: none;
top: 100%;
z-index: 50;
width: max-content;
height: 75px;
background-color: #dedede;
border-radius: 15px;
padding: 5px;
border-radius: 8px;
padding: 5px 5px 15px 5px;
transform: translateX(-50%);
border: 2px solid #333;
}
.day:hover .dayline {
.jour:hover .dayline {
display: block;
}
.dayline .mini-timeline {
margin-top: 10%;
}

View File

@ -23,47 +23,8 @@ Calendrier de l'assiduité
for="mode_demi">mode demi journée</label>
</div>
<div class="calendrier">
{% for mois,jours in calendrier.items() %}
<div class="month">
<h3>{{mois}}</h3>
<div class="days {{'demi' if mode_demi else ''}}">
{% for jour in jours %}
{% if jour.is_non_work() %}
<div class="day {{jour.get_class()}}">
<span>{{jour.get_nom()}}</span>
{% else %}
<div class="day {{jour.get_class(show_pres, show_reta) if not mode_demi else ''}}">
{% endif %}
{% if mode_demi %}
{% if not jour.is_non_work() %}
<span>{{jour.get_nom()}}</span>
<span class="{{jour.get_demi_class(True, show_pres,show_reta)}}"></span>
<span class="{{jour.get_demi_class(False, show_pres,show_reta)}}"></span>
{% endif %}
{% else %}
{% if not jour.is_non_work() %}
<span>{{jour.get_nom(False)}}</span>
{% endif %}
{% endif %}
{% if not jour.is_non_work() and jour.has_assiduites()%}
<div class="dayline">
<div class="dayline-title">
<span>{{jour.get_date()}}</span>
{{jour.generate_minitimeline() | safe}}
</div>
</div>
{% endif %}
</div>
{% endfor %}
</div>
</div>
{% endfor %}
</div>
<div class="cal">
{{calendrier|safe}}
<div class="annee">
<span id="label-annee">Année scolaire</span><span id="label-changer" style="margin-left: 5px;">Changer
année: </span>
@ -134,36 +95,26 @@ Calendrier de l'assiduité
margin-bottom: 12px;
}
.month h3 {
text-align: center;
}
.day,
.demi .day.color.nonwork {
text-align: left;
margin: 2px;
cursor: default;
font-size: 13px;
position: relative;
font-weight: normal;
min-width: 6em;
.assi_case {
display: flex;
justify-content: start;
width: 100%;
height: 100%;
}
.demi .day.nonwork>span {
flex: none;
border: none;
.assi_case > span {
flex: 1;
}
.demi .day {
border-radius: 0;
.assi_case>span:last-of-type {
border-left: #d5d5d5 solid 1px;
}
.assi_case>span:first-of-type {
border-right: #d5d5d5 solid 1px;
}
.dayline{
display: none;
}
@media print {
@ -294,7 +245,5 @@ Calendrier de l'assiduité
window.open(`${SCO_URL}Assiduites/tableau_assiduite_actions?type=assiduite&action=details&obj_id=${assi_id}`);
})
});
</script>
{% endblock app_content %}

View File

@ -0,0 +1,79 @@
<div class="calendrier">
{% for mois,jours in calendrier.items() %}
<div class="mois">
<h3>{{mois}}</h3>
<div class="jours">
{% for jour in jours %}
<div class="jour {{jour.get_class()}}">
<span class="nom">{{jour.get_nom()}}</span>
<div class="contenu">
{{jour.get_html() | safe}}
</div>
</div>
{% endfor %}
</div>
</div>
{% endfor %}
</div>
<style>
.calendrier {
display: flex;
justify-content: center;
overflow-x: scroll;
border: 1px solid #444;
border-radius: 12px;
margin-bottom: 12px;
}
.mois h3 {
text-align: center;
}
.jour {
text-align: left;
margin: 2px;
cursor: default;
font-size: 13px;
position: relative;
font-weight: normal;
min-width: 6em;
display: flex;
justify-content: start;
}
.jour>.contenu {
background-color: white;
width: 100%;
}
.jour.jour.non-travail>.nom,
.jour.jour.non-travail>.contenu {
border: 0;
background-color: #badfff;
}
.jour>.nom {
width: 3em;
min-width: 3em;
display: flex;
justify-content: center;
align-items: center;
flex-direction: column;
}
.jour>.contenu,
.jour>.nom {
text-align: center;
border: 1px solid #d5d5d5;
position: relative;
}
.sem-courante{
--couleur : #ee752c;
border-left: solid 3px var(--couleur);
border-right: solid 3px var(--couleur);
}
</style>

View File

@ -63,6 +63,7 @@ from app.models import (
Scolog,
)
from app.scodoc.codes_cursus import UE_STANDARD
from app.auth.models import User
from app.models.assiduites import get_assiduites_justif
from app.tables.list_etuds import RowEtud, TableEtud
@ -82,6 +83,7 @@ from app.scodoc import sco_find_etud
from app.scodoc import sco_assiduites as scass
from app.scodoc import sco_utils as scu
from app.scodoc.sco_exceptions import ScoValueError
from app.scodoc import sco_gen_cal
from app.tables.visu_assiduites import TableAssi, etuds_sorted_from_ids
@ -757,8 +759,6 @@ def _verif_date_form_justif(
deb = deb.replace(hour=0, minute=0)
fin = fin.replace(hour=23, minute=59)
print(f"DEBUG {cas=}")
return deb, fin
@ -925,7 +925,14 @@ def calendrier_assi_etud():
# (sera utilisé pour générer le selecteur d'année)
annees_str: str = json.dumps(annees)
calendrier: dict[str, list["Jour"]] = generate_calendar(etud, annee)
cal = CalendrierAssi(
annee,
etud,
mode_demi=mode_demi,
show_pres=show_pres,
show_reta=show_reta,
)
calendrier: str = cal.get_html()
# Peuplement du template jinja
return render_template(
@ -2517,79 +2524,74 @@ def _get_etuds_dem_def(formsemestre) -> str:
# --- Gestion du calendrier ---
def generate_calendar(
etudiant: Identite,
annee: int = None,
) -> dict[str, list["Jour"]]:
class JourAssi(sco_gen_cal.Jour):
"""
Génère le calendrier d'assiduité de l'étudiant pour une année scolaire donnée
"""
# Si pas d'année alors on prend l'année scolaire en cours
if annee is None:
annee = scu.annee_scolaire()
# On prend du 01/09 au 31/08
date_debut: datetime.datetime = datetime.datetime(annee, 9, 1, 0, 0)
date_fin: datetime.datetime = datetime.datetime(annee + 1, 8, 31, 23, 59)
# Filtrage des assiduités et des justificatifs en fonction de la periode / année
etud_assiduites: Query = scass.filter_by_date(
etudiant.assiduites,
Assiduite,
date_deb=date_debut,
date_fin=date_fin,
)
etud_justificatifs: Query = scass.filter_by_date(
etudiant.justificatifs,
Justificatif,
date_deb=date_debut,
date_fin=date_fin,
)
# Récupération des jours de l'année et de leurs assiduités/justificatifs
annee_par_mois: dict[str, list[Jour]] = _organize_by_month(
_get_dates_between(
deb=date_debut.date(),
fin=date_fin.date(),
),
etud_assiduites,
etud_justificatifs,
)
return annee_par_mois
class Jour:
"""Jour
Jour du calendrier
get_nom : retourne le numéro et le nom du Jour (ex: M19 / Mer 19)
Représente un jour d'assiduité
"""
def __init__(self, date: datetime.date, assiduites: Query, justificatifs: Query):
self.date = date
def __init__(
self,
date: datetime.date,
assiduites: Query,
justificatifs: Query,
parent: "CalendrierAssi",
):
super().__init__(date)
# assiduités et justificatifs du jour
self.assiduites = assiduites
self.justificatifs = justificatifs
def get_nom(self, mode_demi: bool = True) -> str:
"""
Renvoie le nom du jour
"M19" ou "Mer 19"
"""
str_jour: str = scu.DAY_NAMES[self.date.weekday()].capitalize()
return (
f"{str_jour[0] if mode_demi or self.is_non_work() else str_jour[:3]+' '}"
+ f"{self.date.day}"
self.parent = parent
def get_html(self) -> str:
# si non travaillé on renvoie une case vide
if self.is_non_work():
return ""
html: str = (
self._get_html_demi() if self.parent.mode_demi else self._get_html_normal()
)
html = f'<div class="assi_case">{html}</div>'
def get_date(self) -> str:
if self.has_assiduite():
minitimeline: str = f"""
<div class="dayline">
<div class="dayline-title">
<span>{self.get_date()}</span>
{self._generate_minitimeline()}
</div>
</div>
"""
Renvoie la date du jour au format "dd/mm/yyyy"
"""
return self.date.strftime(scu.DATE_FMT)
html += minitimeline
def get_class(self, show_pres: bool = False, show_reta: bool = False) -> str:
return html
def has_assiduite(self) -> bool:
"""Renvoie True si le jour a une assiduité"""
return self.assiduites.count() > 0
def _get_html_normal(self) -> str:
"""
Retourne la classe css du jour (mode normal)
Renvoie l'html de la case du calendrier
(version journee normale (donc une couleur))
"""
class_name = self._get_color_normal()
return f'<span class="{class_name}"></span>'
def _get_html_demi(self) -> str:
"""
Renvoie l'html de la case du calendrier
(version journee divisée en demi-journées (donc 2 couleurs))
"""
matin = self._get_color_demi(True)
aprem = self._get_color_demi(False)
return f'<span class="{matin}"></span><span class="{aprem}"></span>'
def _get_color_normal(self) -> str:
"""renvoie la classe css correspondant
à la case du calendrier
(version journee normale)
"""
etat = ""
est_just = ""
@ -2599,8 +2601,8 @@ class Jour:
etat = self._get_color_assiduites_cascade(
self._get_etats_from_assiduites(self.assiduites),
show_pres=show_pres,
show_reta=show_reta,
show_pres=self.parent.show_pres,
show_reta=self.parent.show_reta,
)
est_just = self._get_color_justificatifs_cascade(
@ -2609,13 +2611,11 @@ class Jour:
return f"color {etat} {est_just}"
def get_demi_class(
self, matin: bool, show_pres: bool = False, show_reta: bool = False
) -> str:
def _get_color_demi(self, matin: bool) -> str:
"""renvoie la classe css correspondant
à la case du calendrier
(version journee divisée en demi-journees)
"""
Renvoie la class css de la demi journée
"""
heure_midi = scass.str_to_time(ScoDocSiteConfig.get("assi_lunch_time", "13:00"))
if matin:
@ -2647,8 +2647,8 @@ class Jour:
etat = self._get_color_assiduites_cascade(
self._get_etats_from_assiduites(assiduites_matin),
show_pres=show_pres,
show_reta=show_reta,
show_pres=self.parent.show_pres,
show_reta=self.parent.show_reta,
)
est_just = self._get_color_justificatifs_cascade(
@ -2687,8 +2687,8 @@ class Jour:
etat = self._get_color_assiduites_cascade(
self._get_etats_from_assiduites(assiduites_aprem),
show_pres=show_pres,
show_reta=show_reta,
show_pres=self.parent.show_pres,
show_reta=self.parent.show_reta,
)
est_just = self._get_color_justificatifs_cascade(
@ -2697,77 +2697,6 @@ class Jour:
return f"color {etat} {est_just}"
def has_assiduites(self) -> bool:
"""
Renverra True si le jour a des assiduités
"""
return self.assiduites.count() > 0
def generate_minitimeline(self) -> str:
"""
Génère la minitimeline du jour
"""
# Récupérer le référenciel de la timeline
heure_matin: datetime.timedelta = _time_to_timedelta(
scass.str_to_time(ScoDocSiteConfig.get("assi_morning_time", "08:00"))
)
heure_soir: datetime.timedelta = _time_to_timedelta(
scass.str_to_time(ScoDocSiteConfig.get("assi_afternoon_time", "17:00"))
)
# longueur_timeline = heure_soir - heure_matin
longueur_timeline: datetime.timedelta = heure_soir - heure_matin
# chaque block d'assiduité est défini par:
# longueur = ( (fin-deb) / longueur_timeline ) * 100
# emplacement = ( (deb - heure_matin) / longueur_timeline ) * 100
# longueur + emplacement = 100% sinon on réduit longueur
assiduite_blocks: list[dict[str, float | str]] = []
for assi in self.assiduites:
deb: datetime.timedelta = _time_to_timedelta(
assi.date_debut.time()
if assi.date_debut.date() == self.date
else heure_matin
)
fin: datetime.timedelta = _time_to_timedelta(
assi.date_fin.time()
if assi.date_fin.date() == self.date
else heure_soir
)
emplacement: float = max(((deb - heure_matin) / longueur_timeline) * 100, 0)
longueur: float = ((fin - deb) / longueur_timeline) * 100
if longueur + emplacement > 100:
longueur = 100 - emplacement
etat: str = scu.EtatAssiduite(assi.etat).name.lower()
est_just: str = "est_just" if assi.est_just else ""
assiduite_blocks.append(
{
"longueur": longueur,
"emplacement": emplacement,
"etat": etat,
"est_just": est_just,
"bubble": _generate_assiduite_bubble(assi),
"id": assi.assiduite_id,
}
)
return render_template(
"assiduites/widgets/minitimeline_simple.j2",
assi_blocks=assiduite_blocks,
)
def is_non_work(self):
"""
Renvoie True si le jour est un jour non travaillé
(en fonction de la préférence du département)
"""
return self.date.weekday() in scu.NonWorkDays.get_all_non_work_days(
dept_id=g.scodoc_dept_id
)
def _get_etats_from_assiduites(self, assiduites: Query) -> list[scu.EtatAssiduite]:
return list(set(scu.EtatAssiduite(assi.etat) for assi in assiduites))
@ -2806,47 +2735,110 @@ class Jour:
return ""
def _get_dates_between(deb: datetime.date, fin: datetime.date) -> list[datetime.date]:
resultat = []
date_actuelle = deb
while date_actuelle <= fin:
resultat.append(date_actuelle)
date_actuelle += datetime.timedelta(days=1)
return resultat
def _organize_by_month(days, assiduites, justificatifs) -> dict[str, list[Jour]]:
def _generate_minitimeline(self) -> str:
"""
Organiser les dates par mois.
Génère la minitimeline du jour
"""
organized = {}
for date in days:
# Récupérer le mois en français
month = scu.MONTH_NAMES_ABBREV[date.month - 1]
# Ajouter le jour à la liste correspondante au mois
if month not in organized:
organized[month] = []
# Récupérer le référenciel de la timeline
heure_matin: datetime.timedelta = _time_to_timedelta(
scass.str_to_time(ScoDocSiteConfig.get("assi_morning_time", "08:00"))
)
heure_soir: datetime.timedelta = _time_to_timedelta(
scass.str_to_time(ScoDocSiteConfig.get("assi_afternoon_time", "17:00"))
)
# longueur_timeline = heure_soir - heure_matin
longueur_timeline: datetime.timedelta = heure_soir - heure_matin
date_assiduites: Query = scass.filter_by_date(
assiduites,
# chaque block d'assiduité est défini par:
# longueur = ( (fin-deb) / longueur_timeline ) * 100
# emplacement = ( (deb - heure_matin) / longueur_timeline ) * 100
# longueur + emplacement = 100% sinon on réduit longueur
assiduite_blocks: list[dict[str, float | str]] = []
for assi in self.assiduites:
deb: datetime.timedelta = _time_to_timedelta(
assi.date_debut.time()
if assi.date_debut.date() == self.date
else heure_matin
)
fin: datetime.timedelta = _time_to_timedelta(
assi.date_fin.time()
if assi.date_fin.date() == self.date
else heure_soir
)
emplacement: float = max(((deb - heure_matin) / longueur_timeline) * 100, 0)
longueur: float = ((fin - deb) / longueur_timeline) * 100
if longueur + emplacement > 100:
longueur = 100 - emplacement
etat: str = scu.EtatAssiduite(assi.etat).name.lower()
est_just: str = "est_just" if assi.est_just else ""
assiduite_blocks.append(
{
"longueur": longueur,
"emplacement": emplacement,
"etat": etat,
"est_just": est_just,
"bubble": _generate_assiduite_bubble(assi),
"id": assi.assiduite_id,
}
)
return render_template(
"assiduites/widgets/minitimeline_simple.j2",
assi_blocks=assiduite_blocks,
)
class CalendrierAssi(sco_gen_cal.Calendrier):
"""
Représente un calendrier d'assiduité d'un étudiant
"""
def __init__(self, annee: int, etudiant: Identite, **options):
# On prend du 01/09 au 31/08
date_debut: datetime.datetime = datetime.datetime(annee, 9, 1, 0, 0)
date_fin: datetime.datetime = datetime.datetime(annee + 1, 8, 31, 23, 59)
super().__init__(date_debut, date_fin)
# On récupère les assiduités et les justificatifs
self.etud_assiduites: Query = scass.filter_by_date(
etudiant.assiduites,
Assiduite,
date_deb=date_debut,
date_fin=date_fin,
)
self.etud_justificatifs: Query = scass.filter_by_date(
etudiant.justificatifs,
Justificatif,
date_deb=date_debut,
date_fin=date_fin,
)
# Ajout des options (exemple : mode_demi, show_pres, show_reta, ...)
for key, value in options.items():
setattr(self, key, value)
def instanciate_jour(self, date: datetime.date) -> JourAssi:
"""
Instancie un jour d'assiduité
"""
assiduites: Query = scass.filter_by_date(
self.etud_assiduites,
Assiduite,
date_deb=datetime.datetime.combine(date, datetime.time(0, 0)),
date_fin=datetime.datetime.combine(date, datetime.time(23, 59, 59)),
)
date_justificatifs: Query = scass.filter_by_date(
justificatifs,
justificatifs: Query = scass.filter_by_date(
self.etud_justificatifs,
Justificatif,
date_deb=datetime.datetime.combine(date, datetime.time(0, 0)),
date_fin=datetime.datetime.combine(date, datetime.time(23, 59, 59)),
)
# On génère un `Jour` composé d'une date, et des assiduités/justificatifs du jour
jour: Jour = Jour(date, date_assiduites, date_justificatifs)
organized[month].append(jour)
return organized
return JourAssi(date, assiduites, justificatifs, parent=self)
def _time_to_timedelta(t: datetime.time) -> datetime.timedelta: