ef30820c39
La colonne Cible affichait un horaire seulement pour les demi-journées
avec du rattrapage à faire ; les demi-journées au rythme normal
n'affichaient rien. Désormais chaque demi-journée restante (matin et
après-midi) propose sa plage entrée → sortie, qu'il y ait du retard ou
non, pour donner un planning complet à l'utilisateur.
💘 Generated with Crush
Assisted-by: Crush:glm-5.2
232 lines
11 KiB
Python
232 lines
11 KiB
Python
"""Business logic: compute worked hours and expected hours per day/week."""
|
|
from datetime import datetime
|
|
|
|
DEFAULT_PLAGES = {
|
|
"matin_debut": "09:00", # présence obligatoire à partir de cette heure le matin
|
|
"matin_fin": "12:00", # présence obligatoire jusqu'à cette heure le matin
|
|
"aprem_debut": "14:00", # présence obligatoire à partir de cette heure l'après-midi
|
|
"aprem_fin": "17:00", # présence obligatoire jusqu'à cette heure l'après-midi (plancher de sortie)
|
|
"pause_dejeuner_fin": "13:30", # reprise par défaut projetée tant que l'entrée aprem n'est pas saisie
|
|
"arrivee_visee": "", # arrivée du matin visée pour les préconisations (vide = matin_debut)
|
|
"depart_vise": "", # départ du soir visé, plafond souple des cibles aprem (vide = aucun)
|
|
}
|
|
|
|
|
|
def hhmm_to_minutes(val: str | None) -> int:
|
|
if not val:
|
|
return 0
|
|
h, m = val.split(":")
|
|
return int(h) * 60 + int(m)
|
|
|
|
|
|
def minutes_to_hhmm(minutes: int) -> str:
|
|
sign = "-" if minutes < 0 else ""
|
|
minutes = abs(minutes)
|
|
return f"{sign}{minutes // 60}h{minutes % 60:02d}"
|
|
|
|
|
|
def heures_travaillees(p: dict) -> int:
|
|
"""Return worked minutes for a pointage row.
|
|
|
|
If a half-day has started but has no exit time yet, count elapsed time up to now
|
|
(today only — past dates with missing exits are treated as 0).
|
|
"""
|
|
today = datetime.today().strftime("%Y-%m-%d")
|
|
now_min = datetime.today().hour * 60 + datetime.today().minute
|
|
|
|
matin = 0
|
|
if p["matin_entree"] and p["matin_sortie"]:
|
|
matin = max(0, hhmm_to_minutes(p["matin_sortie"]) - hhmm_to_minutes(p["matin_entree"]))
|
|
elif p["matin_entree"] and p.get("date") == today:
|
|
matin = max(0, now_min - hhmm_to_minutes(p["matin_entree"]))
|
|
|
|
aprem = 0
|
|
if p["aprem_entree"] and p["aprem_sortie"]:
|
|
aprem = max(0, hhmm_to_minutes(p["aprem_sortie"]) - hhmm_to_minutes(p["aprem_entree"]))
|
|
elif p["aprem_entree"] and p.get("date") == today:
|
|
aprem = max(0, now_min - hhmm_to_minutes(p["aprem_entree"]))
|
|
|
|
return matin + aprem
|
|
|
|
|
|
def heures_dues(date_str: str, conges: list[dict], heures_jour_min: int) -> int:
|
|
"""Return expected minutes for a date, accounting for vacations."""
|
|
d = datetime.strptime(date_str, "%Y-%m-%d").date()
|
|
# Weekend = no hours due
|
|
if d.weekday() >= 5:
|
|
return 0
|
|
|
|
conges_date = {c["type"] for c in conges if c["date"] == date_str}
|
|
|
|
if "jour" in conges_date:
|
|
return 0
|
|
if "matin" in conges_date and "aprem" in conges_date:
|
|
return 0
|
|
|
|
half = heures_jour_min // 2
|
|
if "matin" in conges_date or "aprem" in conges_date:
|
|
return half
|
|
|
|
return heures_jour_min
|
|
|
|
|
|
def compute_week(pointages: list[dict], conges: list[dict], heures_jour_min: int, plages: dict | None = None) -> dict:
|
|
"""Compute totals for a list of pointages (one week)."""
|
|
plages = {**DEFAULT_PLAGES, **(plages or {})}
|
|
matin_debut_min = hhmm_to_minutes(plages["matin_debut"])
|
|
matin_fin_min = hhmm_to_minutes(plages["matin_fin"])
|
|
aprem_fin_min = hhmm_to_minutes(plages["aprem_fin"])
|
|
pause_dejeuner_fin_min = hhmm_to_minutes(plages["pause_dejeuner_fin"])
|
|
arrivee_visee_min = hhmm_to_minutes(plages["arrivee_visee"]) if plages.get("arrivee_visee") else matin_debut_min
|
|
depart_vise_min = hhmm_to_minutes(plages["depart_vise"]) if plages.get("depart_vise") else None
|
|
|
|
total_travaille = 0
|
|
total_du = 0
|
|
jours = []
|
|
|
|
for p in pointages:
|
|
travaille = heures_travaillees(p)
|
|
du = heures_dues(p["date"], conges, heures_jour_min)
|
|
delta = travaille - du
|
|
total_travaille += travaille
|
|
total_du += du
|
|
jours.append({
|
|
**p,
|
|
"travaille_min": travaille,
|
|
"du_min": du,
|
|
"delta_min": delta,
|
|
"travaille": minutes_to_hhmm(travaille),
|
|
"du": minutes_to_hhmm(du),
|
|
"delta": minutes_to_hhmm(delta),
|
|
"conge": {c["type"] for c in conges if c["date"] == p["date"]},
|
|
})
|
|
|
|
# Mark each day as complete (all non-congé slots filled, or day is a congé/weekend)
|
|
for jour in jours:
|
|
cg = jour["conge"]
|
|
matin_done = bool(jour.get("matin_entree") and jour.get("matin_sortie")) or "matin" in cg or "jour" in cg
|
|
aprem_done = bool(jour.get("aprem_entree") and jour.get("aprem_sortie")) or "aprem" in cg or "jour" in cg
|
|
jour["is_complete"] = (jour["du_min"] == 0) or (matin_done and aprem_done)
|
|
|
|
# Cumulative weekly delta — accumulated for all days, but visible only when chain is unbroken
|
|
cumul = 0
|
|
cumul_chain_ok = True
|
|
for jour in jours:
|
|
cumul += jour["delta_min"]
|
|
jour["delta_cumul_min"] = cumul
|
|
jour["delta_cumul"] = minutes_to_hhmm(abs(cumul))
|
|
# Chain breaks on the first incomplete workday — subsequent days don't show cumul
|
|
if not jour["is_complete"] and jour["du_min"] > 0:
|
|
cumul_chain_ok = False
|
|
jour["cumul_visible"] = jour["is_complete"] and cumul_chain_ok
|
|
|
|
# Préconisations : répartit le manque restant à parts égales sur les demi-journées
|
|
# restantes, dans la limite de la capacité de chaque créneau. La pause de midi
|
|
# (matin_fin → reprise, 12:00 → 13:30 par défaut) est intouchable : la cible
|
|
# matin ne dépasse jamais matin_fin, et le nominal matin qui n'y tient pas
|
|
# bascule sur l'après-midi du même jour. Le matin démarre à l'arrivée visée
|
|
# (sinon matin_debut) ; l'après-midi vise le départ du soir configuré (plafond
|
|
# souple : dépassé seulement si le rattrapage ne tient nulle part avant), avec
|
|
# minuit comme limite dure.
|
|
for jour in jours:
|
|
jour["cible_matin"] = None
|
|
jour["cible_aprem"] = None
|
|
jour["cible_matin_entree"] = None
|
|
jour["cible_aprem_entree"] = None
|
|
|
|
restant = total_du - total_travaille
|
|
|
|
# Une demi-journée en cours (entrée pointée sans sortie, aujourd'hui) est comptée
|
|
# ci-dessous comme un créneau entier à faire depuis son heure d'entrée ; son temps
|
|
# déjà écoulé, inclus dans total_travaille, doit donc être réintégré au besoin,
|
|
# sinon la même période compte à la fois comme travaillée et comme à venir.
|
|
today = datetime.today().strftime("%Y-%m-%d")
|
|
now_min = datetime.today().hour * 60 + datetime.today().minute
|
|
restant_planif = restant
|
|
for jour in jours:
|
|
if jour["date"] != today:
|
|
continue
|
|
if jour.get("matin_entree") and not jour.get("matin_sortie"):
|
|
restant_planif += max(0, now_min - hhmm_to_minutes(jour["matin_entree"]))
|
|
if jour.get("aprem_entree") and not jour.get("aprem_sortie"):
|
|
restant_planif += max(0, now_min - hhmm_to_minutes(jour["aprem_entree"]))
|
|
|
|
slots = [] # {jour, half, nominal, debut, cap} — cap = durée maximale du créneau
|
|
for jour in jours:
|
|
# Un jour passé non renseigné n'est pas exclu : cette appli permet de saisir
|
|
# ses heures après coup, donc une demi-journée vide reste "à faire" quelle
|
|
# que soit sa date.
|
|
cg = jour["conge"]
|
|
du = jour["du_min"]
|
|
if du == 0:
|
|
continue
|
|
matin_nominal = 0 if "matin" in cg else (du if "aprem" in cg else du // 2)
|
|
aprem_nominal = 0 if "aprem" in cg else (du if "matin" in cg else du - du // 2)
|
|
matin_done = bool(jour.get("matin_entree") and jour.get("matin_sortie")) or "matin" in cg or "jour" in cg
|
|
aprem_done = bool(jour.get("aprem_entree") and jour.get("aprem_sortie")) or "aprem" in cg or "jour" in cg
|
|
if not matin_done:
|
|
debut = hhmm_to_minutes(jour["matin_entree"]) if jour.get("matin_entree") else arrivee_visee_min
|
|
reprise = hhmm_to_minutes(jour["aprem_entree"]) if jour.get("aprem_entree") else pause_dejeuner_fin_min
|
|
cap = max(0, min(matin_fin_min, reprise) - debut)
|
|
# Le nominal matin qui ne tient pas avant la pause bascule sur l'après-midi
|
|
# du même jour (s'il est encore ouvert), sinon dans le rattrapage global.
|
|
surplus = max(0, matin_nominal - cap)
|
|
if surplus and not aprem_done:
|
|
aprem_nominal += surplus
|
|
slots.append({"jour": jour, "half": "matin", "nominal": min(matin_nominal, cap),
|
|
"debut": debut, "cap": cap, "cap_pref": cap})
|
|
if not aprem_done:
|
|
debut = hhmm_to_minutes(jour["aprem_entree"]) if jour.get("aprem_entree") else pause_dejeuner_fin_min
|
|
cap = max(0, 23 * 60 + 59 - debut)
|
|
cap_pref = min(cap, max(0, depart_vise_min - debut)) if depart_vise_min else cap
|
|
slots.append({"jour": jour, "half": "aprem", "nominal": aprem_nominal,
|
|
"debut": debut, "cap": cap, "cap_pref": cap_pref})
|
|
|
|
extra_total = max(0, restant_planif - sum(s["nominal"] for s in slots)) if slots else 0
|
|
slots_restants = len(slots)
|
|
|
|
# Répartition équitable du rattrapage, plafonnée par la capacité de chaque créneau,
|
|
# en deux passes : d'abord dans le cadre visé (avant le départ du soir), puis
|
|
# au-delà si ça ne tient pas. Le surplus d'un créneau saturé se reporte sur les autres.
|
|
adjs = [0] * slots_restants
|
|
left = extra_total
|
|
for cap_key in ("cap_pref", "cap"):
|
|
while left > 0:
|
|
open_idx = [i for i, s in enumerate(slots) if adjs[i] < s[cap_key] - s["nominal"]]
|
|
if not open_idx:
|
|
break # tous les créneaux saturés à ce plafond : passe suivante, ou rattrapage impossible
|
|
base, rem = divmod(left, len(open_idx))
|
|
for k, i in enumerate(open_idx):
|
|
give = min(slots[i][cap_key] - slots[i]["nominal"] - adjs[i], base + (1 if k < rem else 0))
|
|
adjs[i] += give
|
|
left -= give
|
|
|
|
for i, s in enumerate(slots):
|
|
sortie_min = s["debut"] + s["nominal"] + adjs[i]
|
|
sortie_min = max(sortie_min, matin_fin_min if s["half"] == "matin" else aprem_fin_min)
|
|
entree = f"{s['debut'] // 60:02d}:{s['debut'] % 60:02d}"
|
|
sortie = f"{sortie_min // 60:02d}:{sortie_min % 60:02d}"
|
|
if s["half"] == "matin":
|
|
s["jour"]["cible_matin_entree"] = entree
|
|
s["jour"]["cible_matin"] = sortie
|
|
else:
|
|
s["jour"]["cible_aprem_entree"] = entree
|
|
s["jour"]["cible_aprem"] = sortie
|
|
|
|
reste_min = max(0, restant)
|
|
|
|
return {
|
|
"jours": jours,
|
|
"total_travaille": minutes_to_hhmm(total_travaille),
|
|
"total_du": minutes_to_hhmm(total_du),
|
|
"solde": minutes_to_hhmm(total_travaille - total_du),
|
|
"solde_min": total_travaille - total_du,
|
|
"reste_min": reste_min,
|
|
"reste": minutes_to_hhmm(reste_min),
|
|
"extra_min": extra_total,
|
|
"extra": minutes_to_hhmm(extra_total),
|
|
"slots_restants": slots_restants,
|
|
"moyenne_extra_min": (extra_total // slots_restants) if slots_restants else 0,
|
|
"moyenne_extra": minutes_to_hhmm((extra_total // slots_restants) if slots_restants else 0),
|
|
}
|