1447 lines
55 KiB
Python
1447 lines
55 KiB
Python
from collections import OrderedDict, namedtuple
|
||
from datetime import date, timedelta
|
||
from operator import attrgetter
|
||
from pathlib import Path
|
||
|
||
from django.contrib.auth.models import AbstractUser, Group, UserManager
|
||
from django.contrib.postgres.aggregates import StringAgg
|
||
from django.core.validators import MaxValueValidator
|
||
from django.db import models
|
||
from django.db.models import Count, F, OuterRef, Q, Subquery, Sum
|
||
from django.db.models.functions import Coalesce, ExtractMonth, ExtractYear
|
||
from django.db.utils import IntegrityError
|
||
from django.urls import reverse
|
||
from django.utils import timezone
|
||
from django.utils.functional import cached_property
|
||
|
||
from django_countries.fields import CountryField
|
||
|
||
from common import choices
|
||
from common.fields import ChoiceArrayField
|
||
|
||
from .utils import format_adresse, format_contact, format_d_m_Y, random_string_generator
|
||
|
||
|
||
class CercleScolaire(models.Model):
|
||
""" Les 7 cercles scolaires du canton"""
|
||
|
||
nom = models.CharField(max_length=50, unique=True)
|
||
telephone = models.CharField('tél.', max_length=35, blank=True)
|
||
|
||
class Meta:
|
||
verbose_name = 'Cercle scolaire'
|
||
verbose_name_plural = 'Cercles scolaires'
|
||
ordering = ('nom',)
|
||
|
||
def __str__(self):
|
||
return self.nom
|
||
|
||
|
||
class Service(models.Model):
|
||
""" Services sociaux en lien avec la Fondation Transit """
|
||
|
||
sigle = models.CharField('Sigle', max_length=20, unique=True)
|
||
nom_complet = models.CharField('Nom complet', max_length=80, blank=True)
|
||
|
||
class Meta:
|
||
ordering = ('sigle',)
|
||
|
||
def __str__(self):
|
||
return self.sigle
|
||
|
||
def save(self, *args, **kwargs):
|
||
self.sigle = self.sigle.upper()
|
||
super().save(*args, **kwargs)
|
||
|
||
|
||
class RoleManager(models.Manager):
|
||
def get_by_natural_key(self, nom):
|
||
return self.get(nom=nom)
|
||
|
||
|
||
class Role(models.Model):
|
||
NON_EDITABLE = ['Père', 'Mère', 'Enfant suivi', 'Enfant non-suivi']
|
||
ROLES_PARENTS = ['Père', 'Mère']
|
||
|
||
nom = models.CharField("Nom", max_length=50, unique=True)
|
||
est_famille = models.BooleanField("Famille", default=False)
|
||
est_intervenant = models.BooleanField("Intervenant", default=False)
|
||
est_editeur = models.BooleanField("Éditeur", default=False, help_text=(
|
||
"Un rôle éditeur donne le droit de modification des dossiers familles si "
|
||
"la personne est intervenante."
|
||
))
|
||
|
||
objects = RoleManager()
|
||
|
||
class Meta:
|
||
ordering = ('nom',)
|
||
|
||
def __str__(self):
|
||
return self.nom
|
||
|
||
@property
|
||
def editable(self):
|
||
return self.nom not in self.NON_EDITABLE
|
||
|
||
def natural_key(self):
|
||
return (self.nom,)
|
||
|
||
|
||
class Contact(models.Model):
|
||
prenom = models.CharField('Prénom', max_length=30)
|
||
nom = models.CharField('Nom', max_length=30)
|
||
rue = models.CharField('Rue', max_length=30, blank=True)
|
||
npa = models.CharField('NPA', max_length=4, blank=True)
|
||
localite = models.CharField('Localité', max_length=30, blank=True)
|
||
tel_prive = models.CharField('Tél. privé', max_length=30, blank=True)
|
||
tel_prof = models.CharField('Tél. prof.', max_length=30, blank=True)
|
||
email = models.EmailField(max_length=100, blank=True)
|
||
service = models.ForeignKey(Service, null=True, blank=True, on_delete=models.PROTECT)
|
||
roles = models.ManyToManyField(Role, related_name='contacts', blank=True, verbose_name='Rôles')
|
||
profession = models.CharField('Activité/prof.', max_length=100, blank=True)
|
||
remarque = models.TextField("Remarque", blank=True)
|
||
est_actif = models.BooleanField('actif', default=True)
|
||
|
||
class Meta:
|
||
verbose_name = 'Contact'
|
||
ordering = ('nom', 'prenom')
|
||
unique_together = ('nom', 'prenom', 'service')
|
||
|
||
def __str__(self):
|
||
sigle = self.service.sigle if self.service else ''
|
||
return '{} ({})'.format(self.nom_prenom, sigle) if self.service else self.nom_prenom
|
||
|
||
@property
|
||
def nom_prenom(self):
|
||
return '{} {}'.format(self.nom, self.prenom)
|
||
|
||
@property
|
||
def adresse(self):
|
||
return format_adresse(self.rue, self.npa, self.localite)
|
||
|
||
@cached_property
|
||
def all_roles(self):
|
||
return self.roles.all()
|
||
|
||
def has_role(self, roles=()):
|
||
"""Return True if user has at least one of the `roles` name."""
|
||
return bool(set(r.nom for r in self.all_roles).intersection(set(roles)))
|
||
|
||
def roles_str(self, sep=', '):
|
||
return sep.join([role.nom for role in self.all_roles])
|
||
|
||
@property
|
||
def contact(self):
|
||
return format_contact(self.tel_prof, self.email)
|
||
|
||
@classmethod
|
||
def membres_ope(cls):
|
||
return cls.objects.filter(service__sigle__startswith='OPE', est_actif=True).select_related('service')
|
||
|
||
|
||
class EquipeChoices(models.TextChoices):
|
||
MONTAGNES = 'montagnes', 'Montagnes et V-d-T'
|
||
LITTORAL = 'littoral', 'Littoral et V-d-R'
|
||
|
||
|
||
class Utilisateur(Contact, AbstractUser):
|
||
sigle = models.CharField(max_length=5, blank=True)
|
||
equipe = models.CharField("Équipe", max_length=10, choices=EquipeChoices.choices, blank=True)
|
||
date_desactivation = models.DateField('Date désactivation', null=True, blank=True)
|
||
taux_activite = models.PositiveSmallIntegerField(
|
||
"Taux d’activité (en %)", blank=True, default=0, validators=[MaxValueValidator(100)]
|
||
)
|
||
decharge = models.PositiveSmallIntegerField("Heures de décharge", blank=True, null=True)
|
||
|
||
objects = UserManager()
|
||
|
||
def __str__(self):
|
||
return self.nom_prenom
|
||
|
||
@property
|
||
def groupes(self):
|
||
return [item.name for item in self.groups.all()]
|
||
|
||
@property
|
||
def is_psy_or_educ(self):
|
||
return self.has_role({'Psy', 'Educ'})
|
||
|
||
@property
|
||
def is_responsable(self):
|
||
return self.has_role({'Responsable/coordinateur'})
|
||
|
||
@property
|
||
def is_admin_ipe(self):
|
||
return 'admin ipe' in self.groupes
|
||
|
||
@property
|
||
def initiales(self):
|
||
return self.sigle if self.sigle else f'{self.prenom[0]}{self.nom[0]}'
|
||
|
||
@property
|
||
def charge_max(self):
|
||
"""
|
||
Renvoie la charge maximale d'heures hebodmadaires de charge dossier en
|
||
fonction du taux d'activité.
|
||
"""
|
||
charge_map = {
|
||
100: 32, 90: 28, 80: 24, 75: 22, 70: 20, 60: 16, 0: 0,
|
||
}
|
||
charge = charge_map.get(self.taux_activite, int(32 * self.taux_activite / 100))
|
||
if self.decharge:
|
||
charge -= self.decharge
|
||
return charge
|
||
|
||
def prestations_gen(self):
|
||
"""Renvoie les prestations générales de l’utilisateur."""
|
||
return self.prestations.filter(famille__isnull=True)
|
||
|
||
def temps_total_prestations(self, unite):
|
||
return self.prestations.model.temps_total(self.prestations, tous_utilisateurs=False)
|
||
|
||
def total_mensuel(self, unite, month, year):
|
||
prestations = self.prestations.filter(
|
||
date_prestation__year=year, date_prestation__month=month
|
||
)
|
||
return self.prestations.model.temps_total(prestations, tous_utilisateurs=False)
|
||
|
||
def totaux_mensuels(self, unite, year):
|
||
return [self.total_mensuel(unite, m, year) for m in range(1, 13)]
|
||
|
||
def total_annuel(self, unite, year):
|
||
prestations = self.prestations.filter(date_prestation__year=year)
|
||
return self.prestations.model.temps_total(prestations, tous_utilisateurs=False)
|
||
|
||
@classmethod
|
||
def _intervenants(cls, groupes=(), annee=None):
|
||
if annee is None:
|
||
# Utilisateurs actuellement actifs
|
||
utils = Utilisateur.objects.filter(date_desactivation__isnull=True)
|
||
else:
|
||
utils = Utilisateur.objects.filter(
|
||
Q(date_desactivation__isnull=True) | Q(date_desactivation__year__gte=annee)
|
||
)
|
||
return utils.filter(
|
||
groups__name__in=groupes,
|
||
is_superuser=False
|
||
).exclude(
|
||
groups__name__in=['direction']
|
||
).distinct()
|
||
|
||
@classmethod
|
||
def intervenants(cls, annee=None):
|
||
return cls._intervenants(
|
||
groupes=['aemo'],
|
||
annee=annee
|
||
)
|
||
|
||
|
||
class GroupInfo(models.Model):
|
||
group = models.OneToOneField(Group, on_delete=models.CASCADE)
|
||
description = models.TextField(blank=True)
|
||
|
||
def __str__(self):
|
||
return f"Description of group {self.group.name}"
|
||
|
||
|
||
class Region(models.Model):
|
||
nom = models.CharField(max_length=30, unique=True)
|
||
rue = models.CharField("Rue", max_length=100, blank=True)
|
||
|
||
def __str__(self):
|
||
return self.nom
|
||
|
||
def __lt__(self, other):
|
||
return self.nom < (other.nom if other else '')
|
||
|
||
|
||
class FamilleQuerySet(models.QuerySet):
|
||
def with_duos(self):
|
||
"""
|
||
Renvoie une liste des groupes Psy/Educ différents, sous forme de chaînes
|
||
de sigles séparées par "/".
|
||
Peut aussi renvoyer 1 ou 3 intervenants, le cas échéant.
|
||
"""
|
||
return self.annotate(
|
||
duo=StringAgg(
|
||
F('suivi__intervenant__intervenant__sigle'),
|
||
delimiter='/',
|
||
filter=(
|
||
Q(suivi__intervenant__date_fin__isnull=True) &
|
||
Q(suivi__intervenant__role__nom__in=['Educ', 'Psy'])
|
||
),
|
||
ordering='suivi__intervenant__intervenant__sigle',
|
||
)
|
||
)
|
||
|
||
def with_niveau_interv(self):
|
||
"""
|
||
Annote les familles avec le niveau d’intervention le plus récent.
|
||
"""
|
||
return self.annotate(
|
||
niveau_interv=Subquery(
|
||
Niveau.objects.filter(
|
||
famille=OuterRef('pk')
|
||
).order_by('-date_debut').values('niveau_interv')[:1]
|
||
)
|
||
)
|
||
|
||
|
||
class FamilleManager(models.Manager):
|
||
def get_queryset(self):
|
||
return FamilleQuerySet(self.model, using=self._db).filter(
|
||
suivi__isnull=False
|
||
).prefetch_related(
|
||
models.Prefetch('membres', queryset=Personne.objects.select_related('role'))
|
||
)
|
||
|
||
def create_famille(self, equipe='', **kwargs):
|
||
kwargs.pop('_state', None)
|
||
famille = self.create(**kwargs)
|
||
Suivi.objects.create(
|
||
famille=famille,
|
||
equipe=equipe
|
||
)
|
||
famille.suivi.date_demande = date.today()
|
||
famille.suivi.save()
|
||
return famille
|
||
|
||
|
||
class Famille(models.Model):
|
||
created_at = models.DateTimeField(auto_now_add=True, editable=False)
|
||
archived_at = models.DateTimeField('Archivée le', blank=True, null=True)
|
||
nom = models.CharField('Nom de famille', max_length=40)
|
||
rue = models.CharField('Rue', max_length=60, blank=True)
|
||
npa = models.CharField('NPA', max_length=4, blank=True)
|
||
localite = models.CharField('Localité', max_length=30, blank=True)
|
||
region = models.ForeignKey(to=Region, null=True, blank=True, default=None, on_delete=models.SET_NULL)
|
||
telephone = models.CharField('Tél.', max_length=60, blank=True)
|
||
autorite_parentale = models.CharField("Autorité parentale", max_length=20,
|
||
choices=choices.AUTORITE_PARENTALE_CHOICES, blank=True)
|
||
monoparentale = models.BooleanField('Famille monoparent.', default=None, blank=True, null=True)
|
||
statut_marital = models.CharField("Statut marital", max_length=20, choices=choices.STATUT_MARITAL_CHOICES,
|
||
blank=True)
|
||
connue = models.BooleanField("famille déjà suivie", default=False)
|
||
accueil = models.BooleanField("famille d'accueil", default=False)
|
||
# Pour CIPE
|
||
besoins_part = models.BooleanField("famille à besoins particuliers", default=False)
|
||
sap = models.BooleanField(default=False, verbose_name="famille s@p")
|
||
garde = models.CharField(
|
||
'Type de garde', max_length=20, choices=choices.TYPE_GARDE_CHOICES, blank=True
|
||
)
|
||
provenance = models.CharField(
|
||
'Provenance', max_length=30, choices=choices.PROVENANCE_DESTINATION_CHOICES, blank=True)
|
||
destination = models.CharField(
|
||
'Destination', max_length=30, choices=choices.PROVENANCE_DESTINATION_CHOICES, blank=True)
|
||
statut_financier = models.CharField(
|
||
'Statut financier', max_length=30, choices=choices.STATUT_FINANCIER_CHOICES, blank=True)
|
||
remarques = models.TextField(blank=True)
|
||
|
||
objects = FamilleManager()
|
||
|
||
class Meta:
|
||
ordering = ('nom', 'npa')
|
||
permissions = (
|
||
("can_manage_waiting_list", "Gérer la liste d'attente"),
|
||
("can_archive", "Archiver les dossiers AEMO"),
|
||
('export_stats', 'Exporter les statistiques'),
|
||
)
|
||
|
||
def __str__(self):
|
||
return '{} - {}'.format(self.nom, self.adresse)
|
||
|
||
@property
|
||
def adresse(self):
|
||
return format_adresse(self.rue, self.npa, self.localite)
|
||
|
||
@property
|
||
def suivi(self):
|
||
return getattr(self, self.suivi_name) if self.suivi_name else None
|
||
|
||
@property
|
||
def suivi_url(self):
|
||
return reverse('famille-suivi', args=[self.pk])
|
||
|
||
@property
|
||
def edit_url(self):
|
||
return reverse('famille-edit', args=[self.pk])
|
||
|
||
@property
|
||
def add_person_url(self):
|
||
return reverse('personne-add', args=[self.pk])
|
||
|
||
def redirect_after_personne_creation(self, personne):
|
||
return self.edit_url
|
||
|
||
@property
|
||
def print_coords_url(self):
|
||
return reverse('print-coord-famille', args=[self.pk])
|
||
|
||
@classmethod
|
||
def actives(cls, date=None):
|
||
qs = Famille.objects.filter(suivi__isnull=False).order_by('nom', 'npa')
|
||
if date is not None:
|
||
return qs.filter(suivi__date_demande__lte=date).filter(
|
||
models.Q(suivi__date_fin_suivi__isnull=True) |
|
||
models.Q(suivi__date_fin_suivi__gte=date)
|
||
)
|
||
else:
|
||
return qs.filter(suivi__date_fin_suivi__isnull=True)
|
||
|
||
def interventions_actives(self, dt=None):
|
||
dt = dt or date.today()
|
||
return self.suivi.intervenant_set.filter(
|
||
Q(date_debut__lte=dt) & (
|
||
Q(date_fin__isnull=True) | Q(date_fin__gte=dt)
|
||
)
|
||
).select_related('intervenant', 'role')
|
||
|
||
def niveau_actuel(self):
|
||
try:
|
||
return [
|
||
niv.niveau_interv for niv in sorted(
|
||
self.niveaux.all(), key=attrgetter('date_debut')
|
||
)
|
||
][-1]
|
||
except IndexError:
|
||
return None
|
||
|
||
def membres_suivis(self):
|
||
if 'membres' in getattr(self, '_prefetched_objects_cache', {}):
|
||
return sorted([
|
||
pers for pers in self._prefetched_objects_cache['membres'] if pers.role.nom == "Enfant suivi"
|
||
], key=lambda p: p.date_naissance or date(1950, 1, 1))
|
||
else:
|
||
return self.membres.filter(role__nom="Enfant suivi").order_by('date_naissance')
|
||
|
||
def enfants_non_suivis(self):
|
||
if 'membres' in getattr(self, '_prefetched_objects_cache', {}):
|
||
return sorted([
|
||
pers for pers in self._prefetched_objects_cache['membres'] if pers.role.nom == "Enfant non-suivi"
|
||
], key=lambda p: p.date_naissance or date(1950, 1, 1))
|
||
else:
|
||
return self.membres.filter(role__nom='Enfant non-suivi').order_by('date_naissance')
|
||
|
||
def parents(self):
|
||
if 'membres' in getattr(self, '_prefetched_objects_cache', {}):
|
||
parents = [
|
||
pers for pers in self._prefetched_objects_cache['membres']
|
||
if pers.role.nom in Role.ROLES_PARENTS
|
||
]
|
||
else:
|
||
parents = [
|
||
pers for pers in self.membres.filter(role__nom__in=Role.ROLES_PARENTS)
|
||
]
|
||
return sorted(parents, key=lambda p: p.role.nom) # Mère avant Père
|
||
|
||
def autres_parents(self):
|
||
excluded_roles = Role.ROLES_PARENTS + ['Enfant suivi', 'Enfant non-suivi']
|
||
if 'membres' in getattr(self, '_prefetched_objects_cache', {}):
|
||
return [
|
||
pers for pers in self._prefetched_objects_cache['membres']
|
||
if pers.role.nom not in excluded_roles
|
||
]
|
||
else:
|
||
return self.membres.exclude(role__nom__in=excluded_roles)
|
||
|
||
def access_ok(self, user):
|
||
if user.has_perm('aemo.change_famille') or user.is_responsable:
|
||
return True
|
||
intervs = self.interventions_actives()
|
||
return not intervs or user in [interv.intervenant for interv in intervs]
|
||
|
||
def can_view(self, user):
|
||
return user.has_perm('aemo.view_famille')
|
||
|
||
def can_edit(self, user):
|
||
if user.has_perm('aemo.change_famille') or user.is_responsable:
|
||
return True
|
||
if not self.suivi.date_fin_suivi or self.suivi.date_fin_suivi >= date.today():
|
||
intervs = self.interventions_actives()
|
||
if (
|
||
self.can_view(user) and
|
||
(not intervs or user in [
|
||
interv.intervenant for interv in intervs if interv.role.est_editeur
|
||
])
|
||
):
|
||
return True
|
||
return False
|
||
|
||
def can_be_deleted(self, user):
|
||
if not user.has_perm('aemo.change_famille'):
|
||
return False
|
||
if self.suivi.motif_fin_suivi == 'erreur':
|
||
return True
|
||
return False
|
||
|
||
def can_be_archived(self, user):
|
||
if self.archived_at:
|
||
return False
|
||
closed_since = date.today() - self.suivi.date_fin_suivi
|
||
return (
|
||
user.has_perm('aemo.can_archive') and
|
||
self.suivi.date_fin_suivi is not None and
|
||
closed_since.days > 180 and
|
||
self.suivi.date_fin_suivi.year < date.today().year and
|
||
(date.today().month > 1 or closed_since.days > 400)
|
||
)
|
||
|
||
def temps_total_prestations(self, interv=None):
|
||
"""
|
||
Temps total des prestations liées à la famille, quel que soit le nombre
|
||
de membres suivis.
|
||
Filtré facultativement par intervenant.
|
||
"""
|
||
prest = self.prestations if interv is None else self.prestations.filter(intervenant=interv)
|
||
return prest.annotate(num_util=Count('intervenants')).aggregate(
|
||
total=Sum(F('duree') * F('num_util'), output_field=models.DurationField())
|
||
)['total'] or timedelta()
|
||
|
||
def temps_total_prestations_reparti(self):
|
||
"""
|
||
Temps total des prestations liées à la famille, divisé par le nombre d'enfants suivis.
|
||
"""
|
||
duree = self.temps_total_prestations()
|
||
duree //= (len(self.membres_suivis()) or 1)
|
||
return duree
|
||
|
||
def total_mensuel(self, date_debut_mois):
|
||
"""
|
||
Temps total de prestations sur un mois donné
|
||
"""
|
||
return self.prestations.filter(
|
||
date_prestation__month=date_debut_mois.month,
|
||
date_prestation__year=date_debut_mois.year
|
||
).aggregate(total=Sum('duree'))['total'] or timedelta()
|
||
|
||
def total_mensuel_par_prestation(self, prest_codes, date_debut_mois):
|
||
"""
|
||
Temps total d'évaluation sur un mois donné par prestation.
|
||
"""
|
||
return self.prestations.annotate(
|
||
num_util=Count('intervenants')
|
||
).filter(
|
||
lib_prestation__code__in=prest_codes,
|
||
date_prestation__month=date_debut_mois.month,
|
||
date_prestation__year=date_debut_mois.year
|
||
).aggregate(
|
||
total=Sum(F('duree') * F('num_util'), output_field=models.DurationField())
|
||
)['total'] or timedelta()
|
||
|
||
def total_mensuel_evaluation(self, date_debut_mois):
|
||
return self.total_mensuel_par_prestation(['aemo01'], date_debut_mois)
|
||
|
||
def total_mensuel_suivi(self, date_debut_mois):
|
||
return self.total_mensuel_par_prestation(['aemo02', 'aemo04', 'aemo05', 'aemo06', 'aemo07'], date_debut_mois)
|
||
|
||
def prestations_historiques(self):
|
||
return Prestation.prestations_historiques(self.prestations.all())
|
||
|
||
def prestations_du_mois(self):
|
||
"""
|
||
Retourne le détail des prestations pour cette famille
|
||
à partir du mois courant
|
||
"""
|
||
date_ref = date(date.today().year, date.today().month, 1)
|
||
return self.prestations.filter(date_prestation__gte=date_ref)
|
||
|
||
@classmethod
|
||
def suivis_en_cours(cls, debut, fin):
|
||
base = cls.objects.annotate(
|
||
date_deb=Coalesce(
|
||
'suivi__date_demande',
|
||
'suivi__date_debut_evaluation', 'suivi__date_debut_suivi'
|
||
),
|
||
).prefetch_related('membres')
|
||
return base.filter(
|
||
date_deb__lte=fin
|
||
).filter(
|
||
Q(**{'suivi__date_fin_suivi__isnull': True}) |
|
||
Q(**{'suivi__date_fin_suivi__gte': debut})
|
||
).exclude(**{'suivi__motif_fin_suivi': 'erreur'})
|
||
|
||
@classmethod
|
||
def suivis_nouveaux(cls, annee, mois):
|
||
base = cls.objects.annotate(
|
||
date_dem=F('suivi__date_demande')
|
||
).prefetch_related('membres')
|
||
return base.filter(**{
|
||
'date_dem__year': annee, 'date_dem__month': mois,
|
||
}).exclude(**{'suivi__motif_fin_suivi': 'erreur'})
|
||
|
||
@classmethod
|
||
def suivis_termines(cls, annee, mois):
|
||
base = cls.objects.all().prefetch_related('membres')
|
||
return base.filter(**{
|
||
'suivi__date_fin_suivi__year': annee,
|
||
'suivi__date_fin_suivi__month': mois,
|
||
}).exclude(**{'suivi__motif_fin_suivi': 'erreur'})
|
||
|
||
def can_be_reactivated(self, user):
|
||
return user.has_perm("aemo.change_famille") and self.suivi.date_fin_suivi is not None
|
||
|
||
def anonymiser(self):
|
||
# Famille
|
||
self.nom = random_string_generator()
|
||
self.rue = ''
|
||
self.telephone = ''
|
||
self.remarques = ''
|
||
self.archived_at = timezone.now()
|
||
self.save()
|
||
|
||
# Personne
|
||
for personne in self.membres.all().select_related('role'):
|
||
if personne.role.nom == 'Enfant suivi':
|
||
personne.nom = random_string_generator()
|
||
personne.prenom = random_string_generator()
|
||
personne.validite = None
|
||
personne.contractant = False
|
||
fields = ['rue', 'npa', 'localite', 'telephone', 'email', 'remarque', 'remarque_privee',
|
||
'profession', 'filiation', 'allergies', 'employeur', 'permis', 'animaux']
|
||
[setattr(personne, field, '') for field in fields]
|
||
personne.save()
|
||
personne.reseaux.clear()
|
||
if hasattr(personne, 'formation'):
|
||
personne.formation.cercle_scolaire = None
|
||
fields = ['college', 'classe', 'enseignant', 'creche', 'creche_resp', 'entreprise',
|
||
'maitre_apprentissage', 'remarque']
|
||
[setattr(personne.formation, field, '') for field in fields]
|
||
personne.formation.save()
|
||
else:
|
||
personne.delete()
|
||
# Suivi
|
||
fields = ['difficultes', 'aides', 'competences', 'autres_contacts', 'disponibilites', 'remarque',
|
||
'remarque_privee', 'motif_detail', 'referent_note', 'collaboration', 'ressources', 'crise',
|
||
'pers_famille_presentes', 'ref_presents', 'autres_pers_presentes']
|
||
[setattr(self.suivi, field, '') for field in fields]
|
||
self.suivi.save()
|
||
|
||
# Related
|
||
for doc in self.documents.all():
|
||
doc.delete()
|
||
for bilan in self.bilans.all():
|
||
bilan.delete()
|
||
for rapport in self.rapports.all():
|
||
rapport.delete()
|
||
self.prestations.all().update(texte='')
|
||
for prestation in self.prestations.exclude(fichier=''):
|
||
prestation.fichier.delete()
|
||
prestation.save()
|
||
|
||
|
||
class PersonneManager(models.Manager):
|
||
|
||
def create_personne(self, **kwargs):
|
||
kwargs.pop('_state', None)
|
||
pers = self.create(**kwargs)
|
||
return self.add_formation(pers)
|
||
|
||
def add_formation(self, pers):
|
||
if pers.role.nom == 'Enfant suivi' and not hasattr(pers, 'formation'):
|
||
moins_de_4ans = bool(pers.age and pers.age < 4)
|
||
Formation.objects.create(
|
||
personne=pers, statut='pre_scol' if moins_de_4ans else ''
|
||
)
|
||
if moins_de_4ans:
|
||
try:
|
||
pers.famille.suivi.demande_prioritaire = True
|
||
pers.famille.suivi.save()
|
||
except AttributeError:
|
||
pass
|
||
return pers
|
||
|
||
|
||
class Personne(models.Model):
|
||
""" Classe de base des personnes """
|
||
created_at = models.DateTimeField(auto_now_add=True, editable=False, null=True)
|
||
|
||
nom = models.CharField('Nom', max_length=30)
|
||
prenom = models.CharField('Prénom', max_length=30, blank=True)
|
||
date_naissance = models.DateField('Date de naissance', null=True, blank=True)
|
||
genre = models.CharField('Genre', max_length=1, choices=(('M', 'M'), ('F', 'F')), default='M')
|
||
rue = models.CharField('Rue', max_length=60, blank=True)
|
||
npa = models.CharField('NPA', max_length=4, blank=True)
|
||
localite = models.CharField('Localité', max_length=30, blank=True)
|
||
telephone = models.CharField('Tél.', max_length=60, blank=True)
|
||
email = models.EmailField('Courriel', blank=True)
|
||
pays_origine = CountryField('Nationalité', blank=True)
|
||
remarque = models.TextField(blank=True)
|
||
remarque_privee = models.TextField('Remarque privée', blank=True)
|
||
famille = models.ForeignKey(Famille, on_delete=models.CASCADE, related_name='membres')
|
||
role = models.ForeignKey('Role', on_delete=models.PROTECT)
|
||
profession = models.CharField('Profession', max_length=50, blank=True)
|
||
filiation = models.CharField('Filiation', max_length=80, blank=True)
|
||
decedee = models.BooleanField('Cette personne est décédée', default=False)
|
||
reseaux = models.ManyToManyField(Contact, blank=True)
|
||
allergies = models.TextField('Allergies', blank=True)
|
||
# Champs spécifiques SIFP
|
||
employeur = models.CharField('Adresse empl.', max_length=50, blank=True)
|
||
permis = models.CharField('Permis/séjour', max_length=30, blank=True)
|
||
validite = models.DateField('Date validité', blank=True, null=True)
|
||
animaux = models.BooleanField('Animaux', default=None, null=True)
|
||
|
||
objects = PersonneManager()
|
||
|
||
class Meta:
|
||
verbose_name = 'Personne'
|
||
ordering = ('nom', 'prenom')
|
||
|
||
def __str__(self):
|
||
return '{} {}'.format(self.nom, self.prenom)
|
||
|
||
@property
|
||
def nom_prenom(self):
|
||
return str(self)
|
||
|
||
@property
|
||
def adresse(self):
|
||
return format_adresse(self.rue, self.npa, self.localite)
|
||
|
||
@property
|
||
def age(self):
|
||
return self.age_a(date.today())
|
||
|
||
def age_str(self, date_=None, format_='auto'):
|
||
"""Renvoie '2 ans, 4 mois', '5 ans', '8 mois'.
|
||
Param:
|
||
'auto': application du format
|
||
- 'jour' si l'âge < 30 jours
|
||
- 'sem_jour' si l'âge < 77 jours (11 semaines)
|
||
- 'mois_sem' si l'âge < 690 jours (23 mois)
|
||
- 'an_mois': autres cas
|
||
'jour': âge en jours
|
||
'sem_jour': âge en semaines et jours
|
||
'mois_sem': âge en mois et semaines
|
||
"""
|
||
if not self.date_naissance:
|
||
# Pourrait disparaître si date_naissance devient non null
|
||
return ''
|
||
if format_ not in ['auto', 'jour', 'sem_jour', 'mois_sem', 'an_mois']:
|
||
raise ValueError('Paramètre erroné')
|
||
age_jours = self.age_jours(date_)
|
||
|
||
if (age_jours < 30 and format_ == 'auto') or format_ == 'jour':
|
||
age_str = f"{age_jours} jour{'s' if age_jours > 1 else ''}"
|
||
elif (age_jours < 77 and format_ == 'auto') or format_ == 'sem_jour':
|
||
sem, jours = age_jours // 7, age_jours % 7
|
||
age_str = f"{sem} sem."
|
||
age_str += f" {jours} jour{'s' if jours > 1 else ''}" if jours > 0 else ''
|
||
elif (age_jours < 690 and format_ == 'auto') or format_ == 'mois_sem':
|
||
mois, sem = age_jours // 30, int((age_jours % 30)/7)
|
||
age_str = f"{mois} mois"
|
||
age_str += f" {sem} sem." if sem > 0 else ''
|
||
else:
|
||
ans, mois = int(age_jours / 365.25), int((age_jours % 365.25) / 30)
|
||
age_str = f"{ans} an{'s' if ans > 1 else ''}"
|
||
age_str += " %d mois" % mois if mois > 0 else ''
|
||
return age_str
|
||
|
||
def age_a(self, date_):
|
||
if not self.date_naissance:
|
||
# Pourrait disparaître si date_naissance devient non null
|
||
return None
|
||
age = (date_ - self.date_naissance).days / 365.25
|
||
return int(age * 10) / 10 # 1 décimale arrondi vers le bas
|
||
|
||
def age_jours(self, date_=None):
|
||
if date_ is None:
|
||
date_ = date.today()
|
||
return (date_ - self.date_naissance).days
|
||
|
||
def age_mois(self, date_=None):
|
||
"""Âge en mois à la date_"""
|
||
if date_ is None:
|
||
date_ = date.today()
|
||
if not self.date_naissance or date_ < self.date_naissance:
|
||
return None
|
||
return self.age_jours(date_) / (365 / 12)
|
||
|
||
@property
|
||
def localite_display(self):
|
||
return '{} {}'.format(self.npa, self.localite)
|
||
|
||
@property
|
||
def edit_url(self):
|
||
return reverse('personne-edit', args=[self.famille_id, self.pk])
|
||
|
||
def can_edit(self, user):
|
||
return self.famille.can_edit(user)
|
||
|
||
def can_be_deleted(self, user):
|
||
return self.famille.can_be_deleted(user)
|
||
|
||
|
||
class Formation(models.Model):
|
||
|
||
FORMATION_CHOICES = (
|
||
('pre_scol', 'Pré-scolaire'),
|
||
('cycle1', 'Cycle 1'),
|
||
('cycle2', 'Cycle 2'),
|
||
('cycle3', 'Cycle 3'),
|
||
('apprenti', 'Apprentissage'),
|
||
('etudiant', 'Etudiant'),
|
||
('en_emploi', 'En emploi'),
|
||
('sans_emploi', 'Sans emploi'),
|
||
('sans_occupation', 'Sans occupation'),
|
||
)
|
||
|
||
personne = models.OneToOneField(Personne, on_delete=models.CASCADE)
|
||
|
||
statut = models.CharField('Scolarité', max_length=20, choices=FORMATION_CHOICES, blank=True)
|
||
cercle_scolaire = models.ForeignKey(
|
||
CercleScolaire, blank=True, null=True, on_delete=models.SET_NULL,
|
||
related_name='+', verbose_name='Cercle scolaire'
|
||
)
|
||
college = models.CharField('Collège', max_length=50, blank=True)
|
||
classe = models.CharField('Classe', max_length=50, blank=True)
|
||
enseignant = models.CharField('Enseignant', max_length=50, blank=True)
|
||
|
||
creche = models.CharField('Crèche', max_length=50, blank=True)
|
||
creche_resp = models.CharField('Resp.crèche', max_length=50, blank=True)
|
||
|
||
entreprise = models.CharField('Entreprise', max_length=50, blank=True)
|
||
maitre_apprentissage = models.CharField("Maître d'appr.", max_length=50, blank=True)
|
||
|
||
remarque = models.TextField(blank=True)
|
||
|
||
class Meta:
|
||
verbose_name = 'Scolarité'
|
||
|
||
def __str__(self):
|
||
return 'Scolarité de {}'.format(self.personne)
|
||
|
||
def can_edit(self, user):
|
||
return self.personne.famille.can_edit(user)
|
||
|
||
def delete(self, **kwargs):
|
||
if self.personne:
|
||
raise IntegrityError
|
||
else:
|
||
super().delete(**kwargs)
|
||
|
||
@property
|
||
def sse(self):
|
||
return "Champ à définir"
|
||
|
||
def pdf_data(self):
|
||
if self.personne.formation.statut == 'pre_scol':
|
||
data = [
|
||
['Crèche: {}'.format(self.creche), 'responsable: {}'.format(self.creche_resp)],
|
||
]
|
||
elif self.personne.formation.statut in ['cycle1', 'cycle2', 'cycle3', 'etudiant']:
|
||
data = [
|
||
['Cercle: {}'.format(self.cercle_scolaire), 'collège: {}'.format(self.college)],
|
||
['Classe: {}'.format(self.classe), 'Enseignant-e: {}'.format(self.enseignant)]
|
||
]
|
||
|
||
elif self.personne.formation.statut == 'apprenti':
|
||
data = [
|
||
['Employeur: {}'.format(self.entreprise), 'resp. apprenti-e: {}'.format(self.maitre_apprentissage)],
|
||
]
|
||
else:
|
||
data = [self.personne.formation.statut]
|
||
return data
|
||
|
||
def info_scol(self):
|
||
if self.statut == 'pre_scol':
|
||
creche = f"Crèche: {self.creche}" if self.creche else ''
|
||
resp = f" - resp.: {self.creche_resp}" if self.creche_resp else ''
|
||
data = ''.join([creche, resp])
|
||
elif self.statut in ['cycle1', 'cycle2', 'cycle3', 'etudiant']:
|
||
college = f"Collège: {self.college}" if self.college else ''
|
||
classe = f" - classe: {self.classe}" if self.classe else ''
|
||
ens = f" - ens.: {self.enseignant}" if self.enseignant else ''
|
||
data = ''.join([college, classe, ens])
|
||
elif self.statut == 'apprenti':
|
||
emp = f"Employeur: {self.entreprise}" if self.entreprise else ''
|
||
resp = f" - resp.: {self.maitre_apprentissage}" if self.maitre_apprentissage else ''
|
||
data = ''.join([emp, resp])
|
||
elif self.statut:
|
||
data = self.get_statut_display() if self.statut else ''
|
||
else:
|
||
data = "Formation: aucune info. saisie"
|
||
return data
|
||
|
||
|
||
class Document(models.Model):
|
||
famille = models.ForeignKey(Famille, related_name='documents', on_delete=models.CASCADE)
|
||
fichier = models.FileField("Nouveau fichier", upload_to='doc')
|
||
titre = models.CharField(max_length=100)
|
||
|
||
class Meta:
|
||
unique_together = ('famille', 'titre')
|
||
|
||
def __str__(self):
|
||
return self.titre
|
||
|
||
def delete(self):
|
||
Path(self.fichier.path).unlink(missing_ok=True)
|
||
return super().delete()
|
||
|
||
def can_edit(self, user):
|
||
return self.famille.can_edit(user)
|
||
|
||
def can_be_deleted(self, user):
|
||
return self.famille.can_be_deleted(user)
|
||
|
||
|
||
class Bilan(models.Model):
|
||
famille = models.ForeignKey(Famille, related_name='bilans', on_delete=models.CASCADE)
|
||
date = models.DateField("Date du bilan")
|
||
auteur = models.ForeignKey(
|
||
Utilisateur, related_name='bilans', on_delete=models.PROTECT, null=True,
|
||
)
|
||
objectifs = models.TextField("Objectifs")
|
||
rythme = models.TextField("Rythme et fréquence")
|
||
sig_famille = models.BooleanField("Apposer signature de la famille", default=True)
|
||
sig_interv = models.ManyToManyField(Utilisateur, blank=True, verbose_name="Signature des intervenants")
|
||
fichier = models.FileField("Fichier/image", blank=True, upload_to='bilans')
|
||
|
||
delete_urlname = 'famille-bilan-delete'
|
||
|
||
def __str__(self):
|
||
return "Bilan du {} pour la famille {}".format(self.date, self.famille)
|
||
|
||
def get_absolute_url(self):
|
||
return reverse('famille-bilan-view', args=[self.famille_id, self.pk])
|
||
|
||
def get_print_url(self):
|
||
return reverse('print-bilan', args=[self.pk])
|
||
|
||
def edit_url(self):
|
||
return reverse('famille-bilan-edit', args=[self.famille_id, self.pk])
|
||
|
||
def can_edit(self, user):
|
||
return self.famille.can_edit(user) or user in self.famille.suivi.intervenants.all()
|
||
|
||
def title(self):
|
||
return f"Bilan du {format_d_m_Y(self.date)}"
|
||
|
||
|
||
class Rapport(models.Model):
|
||
"""
|
||
Rapport est l'appellation historique, Résumé étant l'appellation moderne (dès février 2023).
|
||
Les champs «techniques» n'ont pas été renommés.
|
||
"""
|
||
famille = models.ForeignKey(Famille, related_name='rapports', on_delete=models.CASCADE)
|
||
date = models.DateField("Date du résumé")
|
||
auteur = models.ForeignKey(Utilisateur, on_delete=models.PROTECT)
|
||
pres_interv = models.ManyToManyField(
|
||
Utilisateur, blank=True, verbose_name="Intervenants cités dans le résumé", related_name='+'
|
||
)
|
||
sig_interv = models.ManyToManyField(
|
||
Utilisateur, blank=True, verbose_name="Signature des intervenants", related_name='+'
|
||
)
|
||
situation = models.TextField("Situation / contexte familial", blank=True)
|
||
observations = models.TextField("Observations, évolution et hypothèses", blank=True)
|
||
projet = models.TextField("Perspectives d’avenir", blank=True)
|
||
|
||
def __str__(self):
|
||
return "Résumé du {} pour la famille {}".format(format_d_m_Y(self.date), self.famille)
|
||
|
||
def get_absolute_url(self):
|
||
return reverse('famille-rapport-view', args=[self.famille.pk, self.pk])
|
||
|
||
def edit_url(self):
|
||
return reverse('famille-rapport-edit', args=[self.famille.pk, self.pk])
|
||
|
||
def get_print_url(self):
|
||
return reverse('famille-rapport-print', args=[self.famille.pk, self.pk])
|
||
|
||
def can_edit(self, user):
|
||
return self.famille.can_edit(user) or user in self.famille.suivi.intervenants.all()
|
||
|
||
def can_delete(self, user):
|
||
return self.famille.can_edit(user)
|
||
|
||
def title(self):
|
||
return f"Résumé du {format_d_m_Y(self.date)}"
|
||
|
||
def intervenants(self):
|
||
return [i.intervenant for i in self.famille.interventions_actives(self.date)]
|
||
|
||
|
||
class Niveau(models.Model):
|
||
INTERV_CHOICES = [(0, '0'), (1, '1'), (2, '2'), (3, '3')]
|
||
famille = models.ForeignKey(
|
||
Famille, related_name='niveaux', on_delete=models.CASCADE, verbose_name="Famille"
|
||
)
|
||
niveau_interv = models.PositiveSmallIntegerField("Niveau d’intervention", choices=INTERV_CHOICES)
|
||
date_debut = models.DateField('Date début', blank=True, null=True)
|
||
date_fin = models.DateField('Date fin', blank=True, null=True)
|
||
|
||
def __str__(self):
|
||
return (
|
||
f"{self.famille.nom} - {self.niveau_interv} - du {format_d_m_Y(self.date_debut)} au "
|
||
f"{format_d_m_Y(self.date_fin)}"
|
||
)
|
||
|
||
|
||
class LibellePrestation(models.Model):
|
||
code = models.CharField('Code', max_length=6, unique=True)
|
||
nom = models.CharField('Nom', max_length=30)
|
||
actes = models.TextField('Actes à prester', blank=True)
|
||
|
||
class Meta:
|
||
ordering = ('code',)
|
||
|
||
def __str__(self):
|
||
return self.nom
|
||
|
||
|
||
class Prestation(models.Model):
|
||
famille = models.ForeignKey(Famille, related_name='prestations', null=True, blank=True,
|
||
on_delete=models.SET_NULL, verbose_name="Famille")
|
||
auteur = models.ForeignKey(Utilisateur, on_delete=models.PROTECT, verbose_name='auteur')
|
||
intervenants = models.ManyToManyField(Utilisateur, related_name='prestations')
|
||
date_prestation = models.DateField("date de l’intervention")
|
||
duree = models.DurationField("durée")
|
||
lib_prestation = models.ForeignKey(
|
||
LibellePrestation, on_delete=models.SET_NULL, null=True, default=None,
|
||
related_name='prestations_%(app_label)s'
|
||
)
|
||
# Nombre de familles actives au moment de la prestation, utilisé pour ventiler les heures
|
||
# dans les statistiques.
|
||
familles_actives = models.PositiveSmallIntegerField(blank=True, default=0)
|
||
texte = models.TextField('Contenu', blank=True)
|
||
manque = models.BooleanField('Rendez-vous manqué', default=False)
|
||
fichier = models.FileField('Fichier/image', upload_to='prestations', blank=True)
|
||
|
||
# Nbre de jours maximum après fin d'un mois où il est encore possible de saisir
|
||
# des données du mois précédent.
|
||
DELAI_SAISIE_SUPPL = 14
|
||
|
||
class Meta:
|
||
ordering = ('-date_prestation',)
|
||
permissions = (
|
||
('edit_prest_prev_month', 'Modifier prestations du mois précédent'),
|
||
)
|
||
|
||
def __str__(self):
|
||
if self.famille:
|
||
return f'Prestation pour la famille {self.famille} le {self.date_prestation} : {self.duree}'
|
||
return f'Prestation générale le {self.date_prestation} : {self.duree}'
|
||
|
||
def can_edit(self, user):
|
||
return (
|
||
(user == self.auteur or user in self.intervenants.all() or
|
||
user.has_perm('aemo.edit_prest_prev_month')
|
||
) and self.check_date_allowed(user, self.date_prestation)
|
||
)
|
||
|
||
def edit_url(self):
|
||
return reverse('prestation-edit', args=[self.famille.pk if self.famille else 0, self.pk])
|
||
|
||
def save(self, *args, **kwargs):
|
||
if self.famille is None:
|
||
self.familles_actives = Famille.actives(self.date_prestation).count()
|
||
super().save(*args, **kwargs)
|
||
|
||
@classmethod
|
||
def check_date_allowed(cls, user, dt):
|
||
"""Contrôle si la date `dt` est située dans le mois courant + DELAI_SAISIE_SUPPL."""
|
||
today = date.today()
|
||
delai = cls.DELAI_SAISIE_SUPPL
|
||
if user.has_perm('aemo.edit_prest_prev_month'):
|
||
delai += 31
|
||
if today.day <= delai:
|
||
return dt >= (today - timedelta(days=delai + 1)).replace(day=1)
|
||
else:
|
||
return dt.year == today.year and dt.month == today.month
|
||
|
||
@classmethod
|
||
def prestations_historiques(cls, prestations):
|
||
"""
|
||
Renvoie un queryset avec toutes les prestations regroupées par annee/mois
|
||
et le total correspondant.
|
||
"""
|
||
return prestations.annotate(
|
||
annee=ExtractYear('date_prestation'),
|
||
mois=ExtractMonth('date_prestation')
|
||
).values('annee', 'mois').order_by('-annee', '-mois').annotate(total=Sum('duree'))
|
||
|
||
@classmethod
|
||
def temps_total(cls, prestations, tous_utilisateurs=False):
|
||
"""
|
||
Renvoie le temps total des `prestations` (QuerySet) sous forme de chaîne '12:30'.
|
||
Si tous_utilisateurs = True, multiplie le temps de chaque prestation par son
|
||
nombre d'intervenants.
|
||
"""
|
||
if prestations.count() > 0:
|
||
if tous_utilisateurs:
|
||
duree = prestations.annotate(num_util=Count('intervenants')).aggregate(
|
||
total=Sum(F('duree') * F('num_util'), output_field=models.DurationField())
|
||
)['total'] or timedelta()
|
||
else:
|
||
duree = prestations.aggregate(total=Sum('duree'))['total'] or timedelta()
|
||
else:
|
||
duree = timedelta()
|
||
return duree
|
||
|
||
@classmethod
|
||
def temps_total_general(cls, annee, familles=True):
|
||
"""
|
||
Renvoie le temps total des prestations (familiales ou générales selon
|
||
familles) pour l'année civile `annee`.
|
||
"""
|
||
prest_tot = cls.objects.filter(
|
||
famille__isnull=not familles,
|
||
date_prestation__year=annee
|
||
).aggregate(total=Sum('duree'))['total'] or timedelta()
|
||
return prest_tot
|
||
|
||
@classmethod
|
||
def temps_total_general_fam_gen(cls, annee):
|
||
"""
|
||
Renvoie le temps total des prestations familiales ET générales pour l'année civile `annee`.
|
||
"""
|
||
prest_tot = cls.objects.filter(
|
||
date_prestation__year=annee
|
||
).aggregate(total=Sum('duree'))['total'] or timedelta()
|
||
return prest_tot
|
||
|
||
@classmethod
|
||
def temps_totaux_mensuels(cls, annee):
|
||
"""
|
||
Renvoie une liste du total mensuel de toutes les prestations familiales
|
||
(sans prestations générales) pour l'année en cours (de janv. à déc.).
|
||
"""
|
||
data = []
|
||
for month in range(1, 13):
|
||
tot = cls.objects.filter(
|
||
famille__isnull=False,
|
||
date_prestation__year=annee, date_prestation__month=month,
|
||
).aggregate(total=Sum('duree'))['total'] or timedelta()
|
||
data.append(tot)
|
||
return data
|
||
|
||
|
||
class JournalAcces(models.Model):
|
||
"""Journalisation des accès aux familles."""
|
||
famille = models.ForeignKey(Famille, on_delete=models.CASCADE, related_name='+')
|
||
utilisateur = models.ForeignKey(Utilisateur, on_delete=models.CASCADE, related_name='+')
|
||
ordinaire = models.BooleanField(default=True)
|
||
quand = models.DateTimeField(auto_now_add=True)
|
||
|
||
def __str__(self):
|
||
return f"Accès de «{self.utilisateur}» à la famille «{self.famille}», le {self.quand}"
|
||
|
||
|
||
class Etape:
|
||
"""
|
||
1. Numéro d'ordre pour tri dans la vue
|
||
2. Code
|
||
3. Affichage dans tableau
|
||
4. Nom visible de l'étape
|
||
5. Code de l'étape suivante
|
||
6. Délai jusqu'à l'échéance (en jours)
|
||
7. Code de l'étape précédente
|
||
8. Date obligatoire précédente
|
||
9. Saisie obligatoire ou non (True / False)
|
||
"""
|
||
|
||
def __init__(self, num, code, abrev, nom, suivante, delai, precedente, preced_oblig, oblig):
|
||
self.num = num
|
||
self.code = code
|
||
self.abrev = abrev
|
||
self.nom = nom
|
||
self.suivante = suivante
|
||
self.delai = delai
|
||
self.precedente = precedente
|
||
self.preced_oblig = preced_oblig
|
||
self.oblig = oblig
|
||
|
||
def __str__(self):
|
||
return self.nom
|
||
|
||
def __repr__(self):
|
||
return '<Etape - {}/{}>'.format(self.num, self.code)
|
||
|
||
def date(self, suivi):
|
||
return getattr(suivi, 'date_{}'.format(self.code))
|
||
|
||
def delai_depuis(self, suivi, date_base):
|
||
"""Délai de cette étape à partir de la date date_base (en général date précédente étape)."""
|
||
if not date_base:
|
||
return None
|
||
return date_base + timedelta(days=self.delai)
|
||
|
||
def date_nom(self):
|
||
return 'date_{}'.format(self.code)
|
||
|
||
def etape_suivante(self, suivi):
|
||
return Suivi.WORKFLOW[self.suivante] if self.suivante else None
|
||
|
||
def etape_precedente(self):
|
||
return Suivi.WORKFLOW[self.precedente] if self.precedente else None
|
||
|
||
|
||
class EtapeDebutSuivi(Etape):
|
||
def date(self, suivi):
|
||
return suivi.debut_suivi_selon_niveau
|
||
|
||
|
||
class EtapeBilan(Etape):
|
||
delai_standard = 3 * 30 # 3 mois
|
||
delai_niveau3 = 30 # 1 mois
|
||
|
||
def date(self, suivi):
|
||
"""Date du dernier bilan"""
|
||
if self.etape_suivante(suivi).code == 'bilan_suivant':
|
||
return None
|
||
return suivi.date_dernier_bilan()
|
||
|
||
def etape_suivante(self, suivi):
|
||
# Soit bilan suivant, soit rapport
|
||
if suivi.date_dernier_rapport():
|
||
return Suivi.WORKFLOW['resume']
|
||
date_bilan = suivi.date_dernier_bilan()
|
||
prochain_rapport = suivi.date_prochain_rapport()
|
||
if date_bilan and prochain_rapport and (prochain_rapport - date_bilan) < timedelta(days=4 * 30):
|
||
return Suivi.WORKFLOW['resume']
|
||
else:
|
||
return Suivi.WORKFLOW['bilan_suivant']
|
||
|
||
def delai_depuis(self, suivi, date_base):
|
||
"""Délai de cette étape à partir de la date date_base (en général date précédente étape)."""
|
||
if not date_base:
|
||
return None
|
||
base = suivi.date_dernier_bilan() or date_base
|
||
delai = self.delai_niveau3 if suivi.famille.niveau_actuel() == 3 else self.delai_standard
|
||
return base + timedelta(days=delai)
|
||
|
||
|
||
class EtapeResume(Etape):
|
||
def date(self, suivi):
|
||
"""Date du dernier rapport"""
|
||
return suivi.date_dernier_rapport()
|
||
|
||
|
||
class EtapeFin(Etape):
|
||
delai_standard = 365 + 180 # 18 mois
|
||
delai_niveau3 = 270 # 9 mois
|
||
|
||
def delai_depuis(self, suivi, *args):
|
||
if not suivi.date_debut_suivi:
|
||
return None
|
||
debut_suivi = suivi.debut_suivi_selon_niveau
|
||
delai = self.delai_niveau3 if suivi.famille.niveau_actuel() == 3 else self.delai_standard
|
||
return debut_suivi + timedelta(days=delai)
|
||
|
||
|
||
Equipe = namedtuple("Equipe", ['code', 'nom', 'perm'])
|
||
|
||
EQUIPES = [
|
||
Equipe(code='montagnes', nom='Montagnes et V-d-T', perm=None),
|
||
Equipe(code='littoral', nom='Littoral et V-d-R', perm=None),
|
||
# Anciennes équipes, conservées pour anciens dossiers
|
||
Equipe(code='neuch_ville', nom='Neuchâtel-ville (archives)', perm=None),
|
||
Equipe(code='litt_est', nom='Littoral Est (archives)', perm=None),
|
||
Equipe(code='litt_ouest', nom='Littoral Ouest (archives)', perm=None),
|
||
]
|
||
|
||
|
||
class Suivi(models.Model):
|
||
WORKFLOW = OrderedDict([
|
||
('demande', Etape(
|
||
1, 'demande', 'dem', 'Demande déposée', 'debut_evaluation', 0, 'demande', 'demande', True
|
||
)),
|
||
('debut_evaluation', Etape(
|
||
2, 'debut_evaluation', 'deb_eva', "Début de l’évaluation", 'fin_evaluation', 40, 'demande', 'demande', True
|
||
)),
|
||
('fin_evaluation', Etape(
|
||
3, 'fin_evaluation', "fin_eva", "Fin de l’évaluation", 'debut_suivi', 40,
|
||
'debut_evaluation', 'debut_evaluation', True
|
||
)),
|
||
('debut_suivi', EtapeDebutSuivi(
|
||
4, 'debut_suivi', "dsuiv", 'Début du suivi', 'bilan_suivant', 40, 'fin_evaluation', 'fin_evaluation', False
|
||
)),
|
||
('bilan_suivant', EtapeBilan(
|
||
5, 'bilan_suivant', "bil", 'Bilan suivant', 'resume', 90, 'debut_suivi', 'fin_evaluation', False
|
||
)),
|
||
('resume', EtapeResume(
|
||
6, 'resume', 'rés', 'Résumé', 'fin_suivi', 90, 'bilan_suivant', 'fin_evaluation', False
|
||
)),
|
||
('fin_suivi', EtapeFin(
|
||
7, 'fin_suivi', "fsuiv", 'Fin du suivi', 'archivage', 365 + 180, 'resume', 'fin_evaluation', True
|
||
)),
|
||
('archivage', Etape(
|
||
8, 'arch_dossier', 'arch', 'Archivage du dossier', None, 0, 'fin_suivi', 'fin_suivi', False
|
||
)),
|
||
])
|
||
|
||
EQUIPES_CHOICES = [(equ.code, equ.nom) for equ in EQUIPES]
|
||
|
||
famille = models.OneToOneField(Famille, on_delete=models.CASCADE)
|
||
equipe = models.CharField('Équipe', max_length=15, choices=EQUIPES_CHOICES)
|
||
heure_coord = models.BooleanField("Heure de coordination", default=False)
|
||
difficultes = models.TextField("Difficultés", blank=True)
|
||
aides = models.TextField("Aides souhaitées", blank=True)
|
||
competences = models.TextField('Ressources/Compétences', blank=True)
|
||
dates_demande = models.CharField('Dates', max_length=128, blank=True)
|
||
autres_contacts = models.TextField("Autres services contactés", blank=True)
|
||
disponibilites = models.TextField('Disponibilités', blank=True)
|
||
remarque = models.TextField(blank=True)
|
||
remarque_privee = models.TextField('Remarque privée', blank=True)
|
||
service_orienteur = models.CharField(
|
||
"Orienté vers l’AEMO par", max_length=15, choices=choices.SERVICE_ORIENTEUR_CHOICES, blank=True
|
||
)
|
||
service_annonceur = models.CharField('Service annonceur', max_length=60, blank=True)
|
||
motif_demande = ChoiceArrayField(
|
||
models.CharField(max_length=60, choices=choices.MOTIF_DEMANDE_CHOICES),
|
||
verbose_name="Motif de la demande", blank=True, null=True)
|
||
motif_detail = models.TextField('Motif', blank=True)
|
||
|
||
# Référents
|
||
intervenants = models.ManyToManyField(
|
||
Utilisateur, through='Intervenant', related_name='interventions', blank=True
|
||
)
|
||
ope_referent = models.ForeignKey(Contact, blank=True, null=True, related_name='+',
|
||
on_delete=models.SET_NULL, verbose_name='as. OPE')
|
||
ope_referent_2 = models.ForeignKey(
|
||
Contact, blank=True, null=True, related_name='+', on_delete=models.SET_NULL,
|
||
verbose_name='as. OPE 2'
|
||
)
|
||
mandat_ope = ChoiceArrayField(
|
||
models.CharField(max_length=65, choices=choices.MANDATS_OPE_CHOICES, blank=True),
|
||
verbose_name="Mandat OPE", blank=True, null=True,
|
||
)
|
||
sse_referent = models.ForeignKey(Contact, blank=True, null=True, related_name='+',
|
||
on_delete=models.SET_NULL, verbose_name='SSE')
|
||
referent_note = models.TextField('Autres contacts', blank=True)
|
||
collaboration = models.TextField('Collaboration', blank=True)
|
||
ressource = models.TextField('Ressource', blank=True)
|
||
crise = models.TextField('Gestion de crise', blank=True)
|
||
|
||
date_demande = models.DateField("Demande déposée le", blank=True, null=True, default=None)
|
||
date_debut_evaluation = models.DateField("Début de l’évaluation le", blank=True, null=True, default=None)
|
||
date_fin_evaluation = models.DateField("Fin de l’évaluation le", blank=True, null=True, default=None)
|
||
date_debut_suivi = models.DateField("Début du suivi le", blank=True, null=True, default=None)
|
||
date_fin_suivi = models.DateField("Fin du suivi le", blank=True, null=True, default=None)
|
||
|
||
demande_prioritaire = models.BooleanField("Demande prioritaire", default=False)
|
||
demarche = ChoiceArrayField(models.CharField(max_length=60, choices=choices.DEMARCHE_CHOICES, blank=True),
|
||
verbose_name="Démarche", blank=True, null=True)
|
||
|
||
pers_famille_presentes = models.CharField('Membres famille présents', max_length=200, blank=True)
|
||
ref_presents = models.CharField('Intervenants présents', max_length=250, blank=True)
|
||
autres_pers_presentes = models.CharField('Autres pers. présentes', max_length=100, blank=True)
|
||
motif_fin_suivi = models.CharField('Motif de fin de suivi', max_length=20,
|
||
choices=choices.MOTIFS_FIN_SUIVI_CHOICES, blank=True)
|
||
|
||
def __str__(self):
|
||
return 'Suivi pour la famille {} '.format(self.famille)
|
||
|
||
@property
|
||
def date_fin_theorique(self):
|
||
if self.date_fin_suivi:
|
||
return self.date_fin_suivi
|
||
if self.date_debut_suivi is None:
|
||
return None
|
||
return self.debut_suivi_selon_niveau + timedelta(days=548) # env. 18 mois
|
||
|
||
@cached_property
|
||
def debut_suivi_selon_niveau(self):
|
||
"""
|
||
Date de début de suivi tenant compte d'éventuel changement de niveau entre 2 et 3.
|
||
"""
|
||
debut = self.date_debut_suivi
|
||
if debut is None:
|
||
return debut
|
||
niv_prec = None
|
||
for niv in sorted(self.famille.niveaux.all(), key=lambda niv: niv.date_debut):
|
||
if (
|
||
(niv_prec in [1, 2] and niv.niveau_interv == 3) or
|
||
(niv_prec == 3 and niv.niveau_interv in [1, 2])
|
||
):
|
||
debut = niv.date_debut
|
||
niv_prec = niv.niveau_interv
|
||
return debut
|
||
|
||
def date_prochain_rapport(self):
|
||
if self.date_debut_suivi is None or self.date_fin_suivi is not None:
|
||
return None
|
||
date_dernier_rapport = self.date_dernier_rapport()
|
||
niveau = self.famille.niveau_actuel()
|
||
if date_dernier_rapport is None:
|
||
# Premier à 9 ou 18 mois, selon niveau
|
||
delai = 30 * 9 if niveau == 3 else 365 + 182
|
||
return self.date_debut_suivi + timedelta(days=delai)
|
||
else:
|
||
# Suivants tous les 9 ou 12 mois, selon niveau
|
||
delai = 30 * 9 if niveau == 3 else 365
|
||
return date_dernier_rapport + timedelta(days=delai)
|
||
|
||
def date_dernier_rapport(self):
|
||
# Using rapports.all() to leverage prefetchs
|
||
debut_suivi = self.debut_suivi_selon_niveau
|
||
return max([
|
||
rapp.date for rapp in self.famille.rapports.all() if rapp.date > debut_suivi
|
||
], default=None)
|
||
|
||
def date_dernier_bilan(self):
|
||
debut_suivi = self.debut_suivi_selon_niveau
|
||
# Using bilans.all() to leverage prefetchs
|
||
return max([
|
||
bilan.date for bilan in self.famille.bilans.all() if bilan.date > debut_suivi
|
||
], default=None)
|
||
|
||
@property
|
||
def ope_referent_display(self):
|
||
return self.ope_referent.nom_prenom if self.ope_referent else '-'
|
||
|
||
@cached_property
|
||
def etape(self):
|
||
"""L’étape *terminée* du suivi."""
|
||
for key, etape in reversed(self.WORKFLOW.items()):
|
||
if key != 'archivage':
|
||
if etape.date(self):
|
||
return etape
|
||
|
||
@cached_property
|
||
def etape_suivante(self):
|
||
return self.etape.etape_suivante(self) if self.etape else None
|
||
|
||
def date_suivante(self):
|
||
etape_date = self.etape.date(self)
|
||
if not self.etape_suivante or not etape_date:
|
||
return None
|
||
return self.etape_suivante.delai_depuis(self, etape_date)
|
||
|
||
def get_mandat_ope_display(self):
|
||
dic = dict(choices.MANDATS_OPE_CHOICES)
|
||
return '; '.join([dic[value] for value in self.mandat_ope]) if self.mandat_ope else '-'
|
||
|
||
def get_motif_demande_display(self):
|
||
dic = dict(choices.MOTIF_DEMANDE_CHOICES)
|
||
return '; '.join([dic[value] for value in self.motif_demande]) if self.motif_demande else ''
|
||
|
||
@property
|
||
def ope_referents(self):
|
||
return [ope for ope in [self.ope_referent, self.ope_referent_2] if ope]
|
||
|
||
|
||
class IntervenantManager(models.Manager):
|
||
def actifs(self, _date=None):
|
||
return self.filter(Q(date_fin__isnull=True) | Q(date_fin__gt=_date or date.today()))
|
||
|
||
|
||
class Intervenant(models.Model):
|
||
"""
|
||
Modèle M2M entre Suivi et Utilisateur (utilisé par through de Suivi.intervenants).
|
||
"""
|
||
suivi = models.ForeignKey(Suivi, on_delete=models.CASCADE)
|
||
intervenant = models.ForeignKey(Utilisateur, on_delete=models.CASCADE)
|
||
role = models.ForeignKey(Role, on_delete=models.CASCADE)
|
||
date_debut = models.DateField('Date début', default=timezone.now)
|
||
# date_fin est utilisé pour les interventions s'arrêtant avant la fin du suivi.
|
||
date_fin = models.DateField('Date fin', null=True, blank=True)
|
||
|
||
objects = IntervenantManager()
|
||
|
||
def __str__(self):
|
||
return '{}, {} pour {}'.format(self.intervenant, self.role, self.suivi)
|
||
|
||
def can_edit(self, user):
|
||
return self.suivi.famille.can_edit(user)
|