[auf_rh_dae.git] / project / dae / models.py

# -=- encoding: utf-8 -=-

import os
from django.conf import settings
from django.core.files.storage import FileSystemStorage
from django.db import models
import reversion
from workflow import PosteWorkflow, DossierWorkflow
from workflow import DOSSIER_ETAT_DRH_FINALISATION
from managers import DossierManager, PosteManager
import datamaster_modeles.models as ref
from rh_v1 import models as rh


# Constantes
HELP_TEXT_DATE = "format: aaaa-mm-jj"
REGIME_TRAVAIL_DEFAULT=100.00
REGIME_TRAVAIL_NB_HEURE_SEMAINE_DEFAULT=35.00

# Upload de fichiers
UPLOAD_STORAGE = FileSystemStorage(settings.PRIVE_MEDIA_ROOT)


### POSTE

POSTE_APPEL_CHOICES = (
    ('interne', 'Interne'),
    ('externe', 'Externe'),
)
POSTE_ACTION = (
    ('N', u"Nouveau poste"),
    ('M', u"Poste existant"),
    ('E', u"Évolution de poste"),
)


class DeviseException(Exception):
  silent_variable_failure = True


class Poste(PosteWorkflow, models.Model):

    type_intervention = models.CharField(max_length=1, choices=POSTE_ACTION, default='N')

    # Modèle existant
    id_rh = models.ForeignKey(rh.Poste, null=True, related_name='+',
                            editable=False,
                            verbose_name="Mise à jour du poste")
    nom = models.CharField(verbose_name="Titre du poste", max_length=255)
    implantation = models.ForeignKey(ref.Implantation)
    type_poste = models.ForeignKey(rh.TypePoste, null=True, related_name='+')
    service = models.ForeignKey(rh.Service, related_name='+',
                            verbose_name=u"Direction/Service/Pôle support")
    responsable = models.ForeignKey(rh.Poste, related_name='+',
                            verbose_name="Poste du responsable")

    # Contrat
    regime_travail = models.DecimalField(max_digits=12, decimal_places=2,
                            default=REGIME_TRAVAIL_DEFAULT, 
                            verbose_name="Temps de travail", 
                            help_text="% du temps complet")
    regime_travail_nb_heure_semaine = models.DecimalField(max_digits=12,
                            decimal_places=2,
                            default=REGIME_TRAVAIL_NB_HEURE_SEMAINE_DEFAULT,
                            verbose_name="Nb. heures par semaine")

    # Recrutement
    local = models.BooleanField(verbose_name="Local", default=True, blank=True)
    expatrie = models.BooleanField(verbose_name="Expatrié", default=False, 
                            blank=True)
    mise_a_disposition = models.BooleanField(verbose_name="Mise à disposition")
    appel = models.CharField(max_length=10, default='interne',
                            verbose_name="Appel à candidature",
                            choices=POSTE_APPEL_CHOICES)

    # Rémunération
    classement_min = models.ForeignKey(rh.Classement, related_name='+',
                            blank=True, null=True)
    classement_max = models.ForeignKey(rh.Classement, related_name='+',
                            blank=True, null=True)
    valeur_point_min = models.ForeignKey(rh.ValeurPoint, related_name='+', 
                            blank=True, null=True)
    valeur_point_max = models.ForeignKey(rh.ValeurPoint, related_name='+', 
                            blank=True, null=True)
    devise_min = models.ForeignKey(rh.Devise, default=5, related_name='+')
    devise_max = models.ForeignKey(rh.Devise, default=5, related_name='+')
    salaire_min = models.DecimalField(max_digits=12, decimal_places=2,
                                      default=0)
    salaire_max = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    indemn_expat_min = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    indemn_expat_max = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    indemn_fct_min = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    indemn_fct_max = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    charges_patronales_min = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    charges_patronales_max = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    autre_min = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    autre_max = models.DecimalField(max_digits=12, decimal_places=2, default=0)

    # Comparatifs de rémunération
    devise_comparaison = models.ForeignKey(rh.Devise, related_name='+',
                                           default=5)
    comp_locale_min = models.DecimalField(max_digits=12, decimal_places=2,
                                          null=True, blank=True)
    comp_locale_max = models.DecimalField(max_digits=12, decimal_places=2,
                                          null=True, blank=True)
    comp_universite_min = models.DecimalField(max_digits=12, decimal_places=2,
                                              null=True, blank=True)
    comp_universite_max = models.DecimalField(max_digits=12, decimal_places=2,
                                              null=True, blank=True)
    comp_fonctionpub_min = models.DecimalField(max_digits=12, decimal_places=2,
                                               null=True, blank=True)
    comp_fonctionpub_max = models.DecimalField(max_digits=12, decimal_places=2,
                                               null=True, blank=True)
    comp_ong_min = models.DecimalField(max_digits=12, decimal_places=2,
                                       null=True, blank=True)
    comp_ong_max = models.DecimalField(max_digits=12, decimal_places=2,
                                       null=True, blank=True)
    comp_autre_min = models.DecimalField(max_digits=12, decimal_places=2,
                                         null=True, blank=True)
    comp_autre_max = models.DecimalField(max_digits=12, decimal_places=2,
                                         null=True, blank=True)

    # Justification
    justification = models.TextField()

    # Méta
    date_creation = models.DateTimeField(auto_now_add=True)
    date_modification = models.DateTimeField(auto_now=True)
    date_debut = models.DateField(verbose_name="Date de début",
                                    help_text=HELP_TEXT_DATE,
                                    null=True, blank=True)
    date_fin = models.DateField(null=True, blank=True,
                                    verbose_name="Date de fin",
                                    help_text=HELP_TEXT_DATE)
    actif = models.BooleanField(default=True)

    # Managers
    objects = PosteManager()

    def _get_key(self):
        """
        Les vues sont montées selon une clef spéciale 
        pour identifier la provenance du poste.
        Cette méthode fournit un moyen de reconstruire cette clef 
        afin de générer les URLs.
        """
        return "dae-%s" % self.id
    key = property(_get_key)

    def get_dossiers(self):
        """
        Liste tous les anciens dossiers liés à ce poste.
        (Le nom de la relation sur le rh.Poste est mal choisi 
        poste1 au lieu de dossier1)
        Note1 : seulement le dosssier principal fait l'objet de la recherche.
        Note2 : les dossiers sont retournés du plus récent au plus vieux. 
        (Ce test est fait en fonction du id, 
        car les dates de création sont absentes de rh v1).
        """
        if self.id_rh is None:
            return []
        postes = [p for p in self.id_rh.poste1.all()]
        return sorted(postes, key=lambda poste: poste.id, reverse=True)
            
    def get_complement_nom(self):
        """
        Inspecte les modèles rh v1 pour trouver dans le dernier dossier 
        un complément de titre de poste.
        """
        dossiers = self.get_dossiers()
        if len(dossiers) > 0:
            nom = dossiers[0].complement1
        else:
            nom = ""
        return nom

    def get_employe(self):
        """
        Inspecte les modèles rh v1 pour trouver l'employé du dernier dossier.
        """
        dossiers = self.get_dossiers()
        if len(dossiers) > 0:
            return dossiers[0].employe
        else:
            return None

    def get_default_devise(self):
        """Récupère la devise par défaut en fonction de l'implantation 
        (EUR autrement)
        """
        try:
            implantation_devise = rh.TauxChange.objects \
                            .filter(implantation=self.implantation)[0].devise
        except:
            implantation_devise = 5 # EUR
        return implantation_devise

    #####################
    # Classement de poste
    #####################

    def get_couts_minimum(self):
        return self.salaire_min + self.indemn_expat_min + self.indemn_fct_min + self.charges_patronales_min + self.autre_min

    def get_salaire_minimum(self):
        return self.get_couts_minimum() - self.charges_patronales_min

    def get_taux_minimum(self):
        if self.devise_min.code == 'EUR':
          return 1
        liste_taux = self.devise_min.tauxchange_set.order_by('-annee').filter(implantation=self.implantation)
        if len(liste_taux) == 0:
            raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise_min, self.implantation))
        else:
            return liste_taux[0].taux

    def get_couts_minimum_euros(self):
        return float(self.get_couts_minimum()) * self.get_taux_minimum()

    def get_salaire_minimum_euros(self):
        return float(self.get_salaire_minimum()) * self.get_taux_minimum()

    def get_couts_maximum(self):
        return self.salaire_max + self.indemn_expat_max + self.indemn_fct_max + self.charges_patronales_max + self.autre_max

    def get_salaire_maximum(self):
        return self.get_couts_maximum() - self.charges_patronales_max

    def get_taux_maximum(self):
        if self.devise_max.code == 'EUR':
          return 1
        liste_taux = self.devise_max.tauxchange_set.order_by('-annee').filter(implantation=self.implantation)
        if len(liste_taux) == 0:
            raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise_max, self.implantation))
        else:
            return liste_taux[0].taux

    def get_couts_maximum_euros(self):
        return float(self.get_couts_maximum()) * self.get_taux_maximum()

    def get_salaire_maximum_euros(self):
        return float(self.get_salaire_maximum()) * self.get_taux_maximum()

    def show_taux_minimum(self):
        try:
            return self.get_taux_minimum()
        except DeviseException, e:
            return e

    def show_couts_minimum_euros(self):
        try:
            return self.get_couts_minimum_euros()
        except DeviseException, e:
            return e

    def show_salaire_minimum_euros(self):
        try:
            return self.get_salaire_minimum_euros()
        except DeviseException, e:
            return e

    def show_taux_maximum(self):
        try:
            return self.get_taux_maximum()
        except DeviseException, e:
            return e

    def show_couts_maximum_euros(self):
        try:
            return self.get_couts_maximum_euros()
        except DeviseException, e:
            return e

    def show_salaire_maximum_euros(self):
        try:
            return self.get_salaire_maximum_euros()
        except DeviseException, e:
            return e


    ######################
    # Comparaison de poste
    ######################

    def est_comparable(self):
        """
        Si on a au moins une valeur de saisie dans les comparaisons, alors le poste
        est comparable.
        """
        if self.comp_universite_min is None and \
           self.comp_fonctionpub_min is None and \
           self.comp_locale_min is None and \
           self.comp_ong_min is None and \
           self.comp_autre_min is None and \
           self.comp_universite_max is None and \
           self.comp_fonctionpub_max is None and \
           self.comp_locale_max is None and \
           self.comp_ong_max is None and \
           self.comp_autre_max is None:
            return False
        else:
            return True
    

    def get_taux_comparaison(self):
        try:
            return rh.TauxChange.objects.filter(implantation=self.implantation, devise=self.devise_comparaison)[0].taux
        except:
            return 1

    def get_comp_universite_min_euros(self):
        return (float)(self.comp_universite_min) * self.get_taux_comparaison()

    def get_comp_fonctionpub_min_euros(self):
        return (float)(self.comp_fonctionpub_min) * self.get_taux_comparaison()

    def get_comp_locale_min_euros(self):
        return (float)(self.comp_locale_min) * self.get_taux_comparaison()

    def get_comp_ong_min_euros(self):
        return (float)(self.comp_ong_min) * self.get_taux_comparaison()

    def get_comp_autre_min_euros(self):
        return (float)(self.comp_autre_min) * self.get_taux_comparaison()

    def get_comp_universite_max_euros(self):
        return (float)(self.comp_universite_max) * self.get_taux_comparaison()

    def get_comp_fonctionpub_max_euros(self):
        return (float)(self.comp_fonctionpub_max) * self.get_taux_comparaison()

    def get_comp_locale_max_euros(self):
        return (float)(self.comp_locale_max) * self.get_taux_comparaison()

    def get_comp_ong_max_euros(self):
        return (float)(self.comp_ong_max) * self.get_taux_comparaison()

    def get_comp_autre_max_euros(self):
        return (float)(self.comp_autre_max) * self.get_taux_comparaison()


    def __unicode__(self):
        """
        Cette fonction est consommatrice SQL car elle cherche les dossiers 
        qui ont été liés à celui-ci.
        """
        complement_nom_poste = self.get_complement_nom()
        if complement_nom_poste is None:
            complement_nom_poste = ""
        data = (
            self.implantation,
            self.type_poste.nom,
            self.nom,
        )
        return u'%s - %s (%s)' % data


# Tester l'enregistrement car les models.py sont importés au complet
if not reversion.is_registered(Poste):
    reversion.register(Poste)


POSTE_FINANCEMENT_CHOICES = (
    ('A', 'A - Frais de personnel'),
    ('B', 'B - Projet(s)-Titre(s)'),
    ('C', 'C - Autre')
)

class PosteFinancement(models.Model):
    poste = models.ForeignKey('Poste', related_name='financements')
    type = models.CharField(max_length=1, choices=POSTE_FINANCEMENT_CHOICES)
    pourcentage = models.DecimalField(max_digits=12, decimal_places=2,
            help_text="ex.: 33.33 % (décimale avec point)")
    commentaire = models.TextField(
            help_text="Spécifiez la source de financement.")

    class Meta:
        ordering = ['type']

    def __unicode__(self):
        return u"%s %s %s" % (self.get_type_display(), self.pourcentage, self.commentaire)


class PostePiece(models.Model):
    """Documents relatifs au Poste
    Ex.: Description de poste
    """
    poste = models.ForeignKey("Poste")
    nom = models.CharField(verbose_name="Nom", max_length=255)
    fichier = models.FileField(verbose_name="Fichier", upload_to='dae/poste', storage=UPLOAD_STORAGE)

class PosteComparaison(models.Model):
    poste = models.ForeignKey('Poste', related_name='comparaisons_internes')
    statut = models.ForeignKey(rh.Statut, related_name='+', verbose_name='Statut', null=True, blank=True, )
    classement = models.ForeignKey(rh.Classement, related_name='+', verbose_name='Classement', null=True, blank=True, )
    implantation = models.ForeignKey(ref.Implantation, null=True, blank=True)
    nom = models.CharField(verbose_name="Poste", max_length=255, null=True, blank=True)
    montant = models.IntegerField(null=True)
    devise = models.ForeignKey(rh.Devise, default=5, related_name='+', null=True, blank=True)

    def taux_devise(self):
        if self.devise.code == 'EUR':
          return 1
        liste_taux = self.devise.tauxchange_set.order_by('-annee').filter(implantation=self.implantation)
        if len(liste_taux) == 0:
            raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise, self.implantation))
        else:
            return liste_taux[0].taux

    def montant_euros(self):
        return round(float(self.montant) * float(self.taux_devise()), 2)


### EMPLOYÉ/PERSONNE

# TODO : migration pour m -> M, f -> F

GENRE_CHOICES = (
    ('m', 'Homme'),
    ('f', 'Femme'),
)

class Employe(models.Model):

    # Modèle existant
    id_rh = models.ForeignKey(rh.Employe, null=True, related_name='+', 
                            verbose_name='Employé')
    nom = models.CharField(max_length=255)
    prenom = models.CharField(max_length=255, verbose_name='Prénom')
    genre = models.CharField(max_length=1, choices=GENRE_CHOICES)

    def __unicode__(self):
        return u'%s %s' % (self.prenom, self.nom.upper())


### DOSSIER

STATUT_RESIDENCE_CHOICES = (
    ('local', 'Local'),
    ('expat', 'Expatrié'),
)

COMPTE_COMPTA_CHOICES = (
    ('coda', 'CODA'),
    ('scs', 'SCS'),
    ('aucun', 'Aucun'),
)

class Dossier(DossierWorkflow, models.Model):

    # Modèle existant
    employe = models.ForeignKey('Employe', related_name='+', editable=False)
    poste = models.ForeignKey('Poste', related_name='dossiers', editable=False)
    statut = models.ForeignKey(rh.Statut, related_name='+')
    organisme_bstg = models.ForeignKey(rh.OrganismeBstg, 
            null=True, blank=True,
            verbose_name="Organisme", 
            help_text="Si détaché (DET) ou mis à disposition (MAD), \
                    préciser l'organisme.",
            related_name='+')
    organisme_bstg_autre = models.CharField(max_length=255,
        verbose_name="Autre organisme",
        help_text="indiquer l'organisme ici s'il n'est pas dans la liste",
        null=True,
        blank=True,)

    # Données antérieures de l'employé
    statut_anterieur = models.ForeignKey(
            rh.Statut, related_name='+', null=True, blank=True,
            verbose_name='Statut antérieur')
    classement_anterieur = models.ForeignKey(
            rh.Classement, related_name='+', null=True, blank=True,
            verbose_name='Classement précédent')
    salaire_anterieur = models.DecimalField(
            max_digits=12, decimal_places=2, null=True, default=None,
            blank=True, verbose_name='Salaire précédent')
    devise_anterieur = models.ForeignKey(rh.Devise, related_name='+', null=True, blank=True)
    type_contrat_anterieur = models.ForeignKey(rh.TypeContrat, related_name='+', null=True, blank=True, verbose_name=u'Type contrat antérieur', )

    # Données du titulaire précédent
    employe_anterieur = models.ForeignKey(
            rh.Employe, related_name='+', null=True, blank=True,
            verbose_name='Employé précédent')
    statut_titulaire_anterieur = models.ForeignKey(
            rh.Statut, related_name='+', null=True, blank=True,
            verbose_name='Statut titulaire précédent')
    classement_titulaire_anterieur = models.ForeignKey(
            rh.Classement, related_name='+', null=True, blank=True,
            verbose_name='Classement titulaire précédent')
    salaire_titulaire_anterieur = models.DecimalField(
            max_digits=12, decimal_places=2, default=None, null=True,
            blank=True, verbose_name='Salaire titulaire précédent')
    devise_titulaire_anterieur = models.ForeignKey(rh.Devise, related_name='+', null=True, blank=True)

    # Recrutement
    remplacement = models.BooleanField()
    statut_residence = models.CharField(max_length=10, default='local', 
                            verbose_name="Statut",
                            choices=STATUT_RESIDENCE_CHOICES)

    # Rémunération
    classement = models.ForeignKey(rh.Classement, related_name='+',
                            null=True, blank=True,
                            verbose_name='Classement proposé')
    salaire = models.DecimalField(max_digits=12, decimal_places=2,
                            verbose_name='Salaire de base',
                            null=True, default=None)
    devise = models.ForeignKey(rh.Devise, default=5, related_name='+')
    regime_travail = models.DecimalField(max_digits=12, 
                            decimal_places=2,
                            default=REGIME_TRAVAIL_DEFAULT,
                            verbose_name="Régime de travail",
                            help_text="% du temps complet")
    regime_travail_nb_heure_semaine = models.DecimalField(max_digits=12,
                            decimal_places=2, 
                            default=REGIME_TRAVAIL_NB_HEURE_SEMAINE_DEFAULT,
                            verbose_name="Nb. heures par semaine")

    # Contrat
    type_contrat = models.ForeignKey(rh.TypeContrat, related_name='+')
    contrat_date_debut = models.DateField(help_text="format: aaaa-mm-jj")
    contrat_date_fin = models.DateField(null=True, blank=True,
                                        help_text="format: aaaa-mm-jj")

    # Justifications
    justif_nouveau_statut_label = u'Justifier le statut que ce type de poste nécessite (national, expatrié, màd ou détachement)'
    justif_nouveau_statut = models.TextField(verbose_name=justif_nouveau_statut_label, null=True, blank=True)
    justif_nouveau_tmp_remplacement_label = u"Si l'employé effectue un remplacement temporaire, préciser"
    justif_nouveau_tmp_remplacement = models.TextField(verbose_name=justif_nouveau_tmp_remplacement_label, null=True, blank=True)
    justif_nouveau_salaire_label = u"Si le salaire de l'employé ne correspond pas au classement du poste ou est différent du salaire antérieur, justifier "
    justif_nouveau_salaire = models.TextField(verbose_name=justif_nouveau_salaire_label, null=True, blank=True)
    justif_nouveau_commentaire_label = u"COMMENTAIRES ADDITIONNELS"
    justif_nouveau_commentaire = models.TextField(verbose_name=justif_nouveau_commentaire_label, null=True, blank=True)
    justif_rempl_type_contrat_label = u"Changement de type de contrat, ex : d'un CDD en CDI"
    justif_rempl_type_contrat = models.TextField(verbose_name=justif_rempl_type_contrat_label, null=True, blank=True)
    justif_rempl_statut_employe_label = u"Si le statut de l'employé a été modifié pour ce poste ; ex :national, expatrié, màd, détachement ? Si oui, justifier"
    justif_rempl_statut_employe = models.TextField(verbose_name=justif_rempl_statut_employe_label, null=True, blank=True)
    justif_rempl_evaluation_label = u"L'évaluation de l'employé est-elle favorable? Préciser"
    justif_rempl_evaluation = models.TextField(verbose_name=justif_rempl_evaluation_label, null=True, blank=True)
    justif_rempl_salaire_label = u"Si le salaire de l'employé est modifié et/ou ne correspond pas à son classement, justifier"
    justif_rempl_salaire = models.TextField(verbose_name=justif_rempl_salaire_label, null=True, blank=True)
    justif_rempl_commentaire_label = u"COMMENTAIRES ADDITIONNELS"
    justif_rempl_commentaire = models.TextField(verbose_name=justif_rempl_commentaire_label, null=True, blank=True)

    # Comptes
    compte_compta = models.CharField(max_length=10, default='aucun',
                                    verbose_name=u'Compte comptabilité',
                                    choices=COMPTE_COMPTA_CHOICES)
    compte_courriel = models.BooleanField()
    
    # Méta
    date_creation = models.DateTimeField(auto_now_add=True)
 
    # Managers
    objects = DossierManager()
   
    def __unicode__(self):
        return u'[%s] %s - %s' % (self.poste.implantation, self.poste.nom, self.employe)

    def taux_devise(self):
        if self.devise.code == 'EUR':
          return 1
        liste_taux = self.devise.tauxchange_set.order_by('-annee').filter(implantation=self.poste.implantation)
        if len(liste_taux) == 0:
            raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise, self.poste.implantation))
        else:
            return liste_taux[0].taux

    def get_salaire_anterieur_euros(self):
        if self.devise_anterieur.code == 'EUR':
          tx = 1
        else:
            liste_taux = self.devise_anterieur.tauxchange_set.order_by('-annee').filter(implantation=self.poste.implantation)
            if len(liste_taux) == 0:
                raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise_anterieur, self.poste.implantation))
            tx = liste_taux[0].taux
        return (float)(tx) * (float)(self.salaire_anterieur)

    def get_salaire_titulaire_anterieur_euros(self):
        if self.devise_titulaire_anterieur.code == 'EUR':
          tx = 1
        else:
            liste_taux = self.devise_titulaire_anterieur.tauxchange_set.order_by('-annee').filter(implantation=self.poste.implantation)
            if len(liste_taux) == 0:
                raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise_titulaire_anterieur, self.poste.implantation))
            tx = liste_taux[0].taux
        return (float)(tx) * (float)(self.salaire_titulaire_anterieur)

    def get_salaire_euros(self):
        tx = self.taux_devise()
        return (float)(tx) * (float)(self.salaire)

    def get_remunerations_brutes(self):
        """
        1   Salaire de base
        3   Indemnité de base
        4   Indemnité d'expatriation
        5   Indemnité pour frais
        6   Indemnité de logement
        7   Indemnité de fonction
        8   Indemnité de responsabilité
        9   Indemnité de transport
        10  Indemnité compensatrice
        11  Indemnité de subsistance
        12  Indemnité différentielle
        13  Prime d'installation
        14  Billet d'avion
        15  Déménagement
        16  Indemnité de départ
        18  Prime de 13ième mois
        19  Prime d'intérim
        """
        ids = [1,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,19]
        return [r for r in self.remuneration_set.all() if r.type_id in ids]

    def get_charges_salariales(self):
        """
        20 Charges salariales ?
        """
        ids = [20, ]
        return [r for r in self.remuneration_set.all() if r.type_id in ids]

    def get_total_charges_salariales(self):
        total = 0.0
        for r in self.get_charges_salariales():
            total += r.montant_euro()
        return total

    def get_charges_patronales(self):
        """
        17  Charges patronales
        """
        ids = [17, ]
        return [r for r in self.remuneration_set.all() if r.type_id in ids]

    def get_total_charges_patronales(self):
        total = 0.0
        for r in self.get_charges_patronales():
            total += r.montant_euro()
        return total

    def get_salaire_brut(self):
        """
        somme des rémuérations brutes
        """
        total = 0.0
        for r in self.get_remunerations_brutes():
            total += r.montant_euro()
        return total

    def get_salaire_net(self):
        """
        salaire brut - charges salariales
        """
        total_charges = 0.0
        for r in self.get_charges_salariales():
            total_charges += r.montant_euro()
        return self.get_salaire_brut() - total_charges

    def get_couts_auf(self):
        """
        salaire net + charges patronales
        """
        total_charges = 0.0
        for r in self.get_charges_patronales():
            total_charges += r.montant_euro()
        return self.get_salaire_net() + total_charges

    def get_remunerations_tierces(self):
        """
        2   Salaire MAD
        """
        return [r for r in self.remuneration_set.all() if r.type_id in (2, )]

    def get_total_remunerations_tierces(self):
        total = 0.0
        for r in self.get_remunerations_tierces():    
            total += r.montant_euro()
        return total


# Tester l'enregistrement car les models.py sont importés au complet
if not reversion.is_registered(Dossier):
    reversion.register(Dossier)

class DossierPiece(models.Model):
    """Documents relatifs au Dossier (à l'occupation de ce poste par employé).
    Ex.: Lettre de motivation.
    """
    dossier = models.ForeignKey("Dossier")
    nom = models.CharField(verbose_name="Nom", max_length=255)
    fichier = models.FileField(verbose_name="Fichier", upload_to='dae/dossier', storage=UPLOAD_STORAGE)


class DossierComparaison(models.Model):
    """
    Photo d'une comparaison salariale au moment de l'embauche.
    """
    dossier = models.ForeignKey('Dossier', related_name='comparaisons')
    statut = models.ForeignKey(rh.Statut, related_name='+', verbose_name='Statut', null=True, blank=True, )
    classement = models.ForeignKey(rh.Classement, related_name='+', verbose_name='Classement', null=True, blank=True, )
    implantation = models.ForeignKey(ref.Implantation, null=True, blank=True)
    poste = models.CharField(max_length=255, null=True, blank=True)
    personne = models.CharField(max_length=255, null=True, blank=True)
    montant = models.IntegerField(null=True)
    devise = models.ForeignKey(rh.Devise, default=5, related_name='+', null=True, blank=True)

    def taux_devise(self):
        if self.devise.code == 'EUR':
          return 1
        liste_taux = self.devise.tauxchange_set.order_by('-annee').filter(implantation=self.implantation)
        if len(liste_taux) == 0:
            raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise, self.implantation))
        else:
            return liste_taux[0].taux

    def montant_euros(self):
        return round(float(self.montant) * float(self.taux_devise()), 2)


### RÉMUNÉRATION

class Remuneration(models.Model):
    # Identification
    dossier = models.ForeignKey('Dossier', db_column='dossier')
    type = models.ForeignKey(rh.TypeRemuneration, db_column='type',
                             related_name='+')
    montant = models.DecimalField(max_digits=12, decimal_places=2,
                                  null=True)  # Annuel
    devise = models.ForeignKey(rh.Devise, to_field='code',
                               db_column='devise', related_name='+')
    precision = models.CharField(max_length=255, null=True, blank=True)

    # Méta
    date_creation = models.DateField(auto_now_add=True)
    user_creation = models.IntegerField(null=True, blank=True)  # TODO : user

    def montant_mois(self):
        return round(self.montant / 12, 2)

    def taux_devise(self):
        if self.devise.code == 'EUR':
          return 1
        liste_taux = self.devise.tauxchange_set.order_by('-annee').filter(implantation=self.dossier.poste.implantation)
        if len(liste_taux) == 0:
            raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise, self.dossier.poste.implantation))
        else:
            return liste_taux[0].taux

    def montant_euro(self):
        return round(float(self.montant) * float(self.taux_devise()), 2)

    def montant_euro_mois(self):
        return round(self.montant_euro() / 12, 2)


### CONTRATS

class Contrat(models.Model):
    dossier = models.ForeignKey(Dossier)
    type = models.ForeignKey(rh.TypeContrat, related_name='+')
    fichier = models.FileField(upload_to='dae/contrats', storage=UPLOAD_STORAGE)