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

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

import os
from decimal import Decimal
from dateutil.relativedelta import relativedelta
from datetime import date, timedelta

from django.conf import settings
from django.core.files.storage import FileSystemStorage
from django.db import models
from django.db.models import Q

import reversion

from auf.django.references import models as ref

from project.dae.managers import (
    PosteManager, DossierManager, ImplantationManager)
from project.dae.workflow import PosteWorkflow, DossierWorkflow
from project.dae.workflow import \
        DOSSIER_ETAT_DRH_FINALISATION, DOSSIER_ETAT_REGION_FINALISATION, \
        DOSSIER_ETAT_FINALISE
from project.rh import models as rh
from project.rh.models import HELP_TEXT_DATE

# 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, rh.Poste_):

    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='postes_dae', editable=False,
        verbose_name=u"Mise à jour du poste"
    )

    # Rémunération
    indemn_expat_min = models.DecimalField(
        max_digits=13, 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
    )

    @property
    def total_employe_min(self):
        res = ((self.salaire_min or Decimal('0')) +
               (self.indemn_fct_min or Decimal('0')) +
               (self.indemn_expat_min or Decimal('0'))
               )
        return res
                
    @property
    def total_employe_max(self):
        return ((self.salaire_max or Decimal('0')) +
                (self.indemn_fct_max or Decimal('0')) +
                (self.indemn_expat_max or Decimal('0'))
                )

    # Managers
    objects = PosteManager()

    @property
    def traitement_min_cad(self):
        return ((self.salaire_min or Decimal('0')) +
                (self.indemn_fct_min or Decimal('0')))

    @property
    def traitement_max_cad(self):
        return ((self.salaire_max or Decimal('0')) +
                (self.indemn_fct_max or Decimal('0')))
        
    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 []
        return self.id_rh.rh_dossiers.all()

    def dans_rh(self):
        """
        Retourne le poste RH s'il existe.
        """
        return self.id_rh

    def importer_dans_rh(self):
        """
        Importe le poste DAE dans un poste RH existant ou nouveau.
        """
        dans_rh = self.dans_rh()
        poste_rh = dans_rh or rh.Poste()
        poste_rh.nom = self.nom
        poste_rh.implantation = self.implantation
        poste_rh.type_poste = self.type_poste
        poste_rh.service = self.service
        poste_rh.responsable = self.responsable
        poste_rh.regime_travail = self.regime_travail
        poste_rh.regime_travail_nb_heure_semaine = \
                self.regime_travail_nb_heure_semaine
        poste_rh.local = self.local
        poste_rh.expatrie = self.expatrie
        poste_rh.mise_a_disposition = self.mise_a_disposition
        poste_rh.appel = self.appel
        poste_rh.classement_min = self.classement_min
        poste_rh.classement_max = self.classement_max
        poste_rh.valeur_point_min = self.valeur_point_min
        poste_rh.valeur_point_max = self.valeur_point_max
        poste_rh.devise_min = self.devise_min
        poste_rh.devise_max = self.devise_max
        poste_rh.salaire_min = self.salaire_min
        poste_rh.salaire_max = self.salaire_max
        poste_rh.indemn_min = self.indemn_fct_min
        poste_rh.indemn_max = self.indemn_fct_max
        poste_rh.autre_min = \
                self.indemn_expat_min + self.charges_patronales_min + \
                self.autre_min
        poste_rh.autre_max = \
                self.indemn_expat_max + self.charges_patronales_max + \
                self.autre_max
        poste_rh.devise_comparaison = self.devise_comparaison
        poste_rh.comp_locale_min = self.comp_locale_min
        poste_rh.comp_locale_max = self.comp_locale_max
        poste_rh.comp_universite_min = self.comp_universite_min
        poste_rh.comp_universite_max = self.comp_universite_max
        poste_rh.comp_fonctionpub_min = self.comp_fonctionpub_min
        poste_rh.comp_fonctionpub_max = self.comp_fonctionpub_max
        poste_rh.comp_ong_min = self.comp_ong_min
        poste_rh.comp_ong_max = self.comp_ong_max
        poste_rh.comp_autre_min = self.comp_autre_min
        poste_rh.comp_autre_max = self.comp_autre_max
        poste_rh.justification = self.justification
        if not dans_rh:
            poste_rh.date_debut = self.date_debut
            poste_rh.date_fin = self.date_fin
        poste_rh.save()

        for piece in self.dae_pieces.all():
            piece_rh = poste_rh.rh_pieces.create(
                poste=poste_rh,
                nom=piece.nom
            )
            if not settings.DEBUG:
                piece_rh.fichier.save(
                    os.path.basename(piece.fichier.name), piece.fichier
            )

        rh.PosteComparaison.objects.filter(poste=poste_rh).delete()
        for comp in self.dae_comparaisons_internes.all():
            poste_rh.rh_comparaisons_internes.create(
                implantation=comp.implantation,
                nom=comp.nom,
                montant=comp.montant,
                devise=comp.devise
            )

        rh.PosteFinancement.objects.filter(poste=poste_rh).delete()
        for financement in self.dae_financements.all():
            poste_rh.rh_financements.create(
                type=financement.type,
                pourcentage=financement.pourcentage,
                commentaire=financement.commentaire
            )

        self.id_rh = poste_rh
        self.save()
        return poste_rh

    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')
        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')
        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(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.
        """
        try:
            data = (
                self.implantation,
                self.type_poste.nom,
                self.nom,
            )
        except:
            return self.nom
        return u'%s - %s (%s)' % data

reversion.register(Poste, format='xml', follow=[
    'dae_financements', 'dae_pieces', 'dae_comparaisons_internes'
])

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


class PosteFinancement(rh.PosteFinancement_):
    poste = models.ForeignKey(
        Poste, db_column='poste', related_name='dae_financements'
    )

reversion.register(PosteFinancement, format='xml')


class PostePiece(rh.PostePiece_):
    poste = models.ForeignKey(
        Poste, db_column='poste', related_name='dae_pieces'
    )

reversion.register(PostePiece, format='xml')


class PosteComparaison(rh.PosteComparaison_):
    poste = models.ForeignKey(
        Poste, related_name='dae_comparaisons_internes'
    )
    statut = models.ForeignKey(
        rh.Statut, related_name='+', verbose_name=u'Statut', null=True,
        blank=True
    )
    classement = models.ForeignKey(
        rh.Classement, related_name='+', verbose_name=u'Classement',
        null=True, blank=True
    )

reversion.register(PosteComparaison, format='xml')


class PosteComparaisonRemuneration(rh.Remuneration_):
    poste_comparaison = models.ForeignKey(
        PosteComparaison, related_name='poste_comparaison_remunerations'
    )

reversion.register(PosteComparaisonRemuneration, format='xml')


### 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=u'Employé')
    nom = models.CharField(max_length=255)
    prenom = models.CharField(max_length=255, verbose_name=u'Prénom')
    genre = models.CharField(max_length=1, choices=GENRE_CHOICES)

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

    def dans_rh(self):
        """
        Retourne l'employé RH associé à cet employé DAE.
        """
        return self.id_rh

    def importer_dans_rh(self):
        """
        Importe l'employé DAE dans un employé RH existant ou nouveau.
        """
        employe_rh = self.dans_rh() or rh.Employe.objects.create(
            nom=self.nom,
            prenom=self.prenom,
            genre=self.genre
        )
        self.id_rh = employe_rh
        self.save()
        return employe_rh

reversion.register(Employe, format='xml')


### DOSSIER

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

class Dossier(DossierWorkflow, rh.Dossier_):
    poste = models.ForeignKey(
        'Poste', db_column='poste', related_name='dae_dossiers'
    )
    employe = models.ForeignKey(
        'Employe', db_column='employe',
        related_name='rh_dossiers', verbose_name=u"Employé"
    )
    organisme_bstg_autre = models.CharField(max_length=255,
        verbose_name=u"Autre organisme",
        help_text="indiquer l'organisme ici s'il n'est pas dans la liste",
        null=True,
        blank=True,)

    # Lien avec le dossier
    dossier_rh = models.ForeignKey(
        rh.Dossier, related_name='dossiers_dae', 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=u'Statut antérieur')
    classement_anterieur = models.ForeignKey(
            rh.Classement, related_name='+', null=True, blank=True,
            verbose_name=u'Classement précédent')
    salaire_anterieur = models.DecimalField(
            max_digits=12, decimal_places=2, null=True, default=None,
            blank=True, verbose_name=u'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=u'Employé précédent')
    statut_titulaire_anterieur = models.ForeignKey(
            rh.Statut, related_name='+', null=True, blank=True,
            verbose_name=u'Statut titulaire précédent')
    classement_titulaire_anterieur = models.ForeignKey(
            rh.Classement, related_name='+', null=True, blank=True,
            verbose_name=u'Classement titulaire précédent')
    salaire_titulaire_anterieur = models.DecimalField(
            max_digits=12, decimal_places=2, default=None, null=True,
            blank=True, verbose_name=u'Salaire titulaire précédent')
    devise_titulaire_anterieur = models.ForeignKey(
        rh.Devise, related_name='+', null=True, blank=True
    )

    # Rémunération
    salaire = models.DecimalField(max_digits=13, decimal_places=2,
                            verbose_name=u'Salaire de base',
                            null=True, default=None)
    devise = models.ForeignKey(rh.Devise, default=5, related_name='+')

    # Contrat
    type_contrat = models.ForeignKey(rh.TypeContrat, related_name='+')
    contrat_date_debut = models.DateField(help_text=HELP_TEXT_DATE)
    contrat_date_fin = models.DateField(null=True, blank=True,
                                        help_text=HELP_TEXT_DATE)

    # Justifications
    justif_nouveau_statut_label = u'Justifier le statut que ce type ' \
            u'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 " \
            u"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 " \
            u"correspond pas au classement du poste ou est différent " \
            u"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 ; " \
            u"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 " \
            u"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
    )

    # DAE numérisée
    dae_numerisee = models.FileField(
        upload_to='dae/dae_numerisee', storage=UPLOAD_STORAGE, blank=True,
        null=True, verbose_name="DAE numérisée"
    )

    # Managers
    objects = DossierManager()

    def __init__(self, *args, **kwargs):
        # Bouchon pour créer une date fictive necessaire pour valider un
        # dossier à cause de l'héritage
        super(rh.Dossier_, self).__init__(*args, **kwargs)
        super(DossierWorkflow, self).__init__(*args, **kwargs)
        import datetime
        self.date_debut = datetime.datetime.today()

    def __unicode__(self):
        return u'[%s] %s - %s' % (
            self.poste.implantation, self.poste.nom, self.employe
        )

    def dans_rh(self):
        """
        Retourne le dossier associé dans le système RH ou ``None`` s'il n'y
        en a pas.
        """
        if self.dossier_rh:
            return self.dossier_rh
        today = date.today()
        poste_rh = self.poste.dans_rh()
        if poste_rh is None:
            return None
        employe_rh = self.employe.dans_rh()
        if employe_rh is None:
            return None
        try:
            return rh.Dossier.objects.get(
                Q(date_debut=None) | Q(date_debut__lte=today),
                Q(date_fin=None) | Q(date_fin__gte=today),
                poste=poste_rh,
                employe=employe_rh
            )
        except rh.Dossier.DoesNotExist:
            return None

    def importer_dans_rh(self):
        """
        Importe les données du dossier DAE dans un dossier RH existant ou
        nouveau.
        """
        poste_rh = self.poste.importer_dans_rh()
        employe_rh = self.employe.importer_dans_rh()
        dossier_rh = self.dans_rh() or \
                rh.Dossier(poste=poste_rh, employe=employe_rh)

        dossier_rh.statut = self.statut
        dossier_rh.organisme_bstg = self.organisme_bstg
        dossier_rh.remplacement = self.remplacement
        dossier_rh.remplacement_de = self.remplacement_de
        dossier_rh.statut_residence = self.statut_residence
        dossier_rh.classement = self.classement
        dossier_rh.regime_travail = self.regime_travail
        dossier_rh.est_cadre = self.est_cadre
        dossier_rh.compte_compta = self.compte_compta
        dossier_rh.compte_courriel = self.compte_courriel
        dossier_rh.regime_travail_nb_heure_semaine = \
                self.regime_travail_nb_heure_semaine
        dossier_rh.date_debut = self.contrat_date_debut
        dossier_rh.save()

        rh.DossierComparaison.objects.filter(dossier=dossier_rh).delete()
        for comp in self.dae_comparaisons.all():
            dossier_rh.rh_comparaisons.create(
                implantation=comp.implantation,
                poste=comp.poste,
                personne=comp.personne,
                montant=comp.montant,
                devise=comp.devise
            )

        for contrat in self.dae_contrats.all():
            contrat_rh = dossier_rh.rh_contrats.create(
                type_contrat=self.type_contrat,
                date_debut=self.contrat_date_debut,
                date_fin=self.contrat_date_fin,
            )
            contrat_rh.fichier.save(
                os.path.basename(contrat.fichier.name), contrat.fichier
            )

        for piece in self.dae_dossierpieces.all():
            piece_rh = dossier_rh.rh_dossierpieces.create(
                nom=piece.nom
            )
            if not settings.DEBUG:
                piece_rh.fichier.save(
                    os.path.basename(piece.fichier.name), piece.fichier
                )

        if self.dae_numerisee:
            dae_numerisee_rh = dossier_rh.rh_dossierpieces.create(
                nom=u'DAE numérisée'
            )
            if not settings.DEBUG:
                dae_numerisee_rh.fichier.save(
                    os.path.basename(self.dae_numerisee.name),
                    self.dae_numerisee
                )

        # Fermer les rémunérations qui commencent avant le début du contrat
        dossier_rh.rh_remunerations.filter(
            Q(date_debut=None) | Q(date_debut__lt=self.contrat_date_debut),
            Q(date_fin=None) | Q(date_fin__gte=self.contrat_date_debut)
        ).update(date_fin=self.contrat_date_debut - timedelta(1))

        # Effacer les rémunérations qui commencent à la date du contrat
        dossier_rh.rh_remunerations \
                .filter(date_debut=self.contrat_date_debut) \
                .delete()

        for remun in self.dae_remunerations.all():
            dossier_rh.rh_remunerations.get_or_create(
                type=remun.type,
                type_revalorisation=remun.type_revalorisation,
                montant=remun.montant,
                devise=remun.devise,
                commentaire=remun.commentaire,
                date_debut=self.contrat_date_debut,
                date_fin=self.contrat_date_fin
            )

        # Enregistrer le lien avec le dossier RH
        self.dossier_rh = dossier_rh
        self.save()

        return dossier_rh

    def get_dossier_precedent_titulaire(self):
        try:
            rh_poste = self.poste.id_rh
        except rh.Poste.DoesNotExist:
            return None

        try:
            precedent_employe = self.employe_anterieur
        except rh.Employe.DoesNotExist:
            return None
        
        qs = rh.Dossier.objects.filter(
            poste=rh_poste,
            employe=precedent_employe,
            ).order_by(
            '-principal', 'date_fin')

        if qs.count() == 0:
            return None
        
        # Retourne en le premier du queryset si la date de fin est None
        # Sinon, retourne le plus récent selon la date de fin.
        first = qs[0]
        if first.date_fin == None:
            return first
        else:
            return qs.order_by('-principal', '-date_fin')[0]

    def get_salaire_anterieur_euros(self):
        if self.devise_anterieur is None:
            return None
        try:
            taux = self.taux_devise(self.devise_anterieur)
        except Exception, e:
            return e
        if not taux:
            return None
        return int(round(float(self.salaire_anterieur) * float(taux), 2))

    def get_salaire_titulaire_anterieur_euros(self):
        if self.devise_titulaire_anterieur is None:
            return None
        try:
            taux = self.taux_devise(self.devise_titulaire_anterieur)
        except Exception, e:
            return e
        if not taux:
            return None
        return int(round(
            float(self.salaire_titulaire_anterieur) * float(taux), 2
        ))

    def valide(self):
        return self.etat in (DOSSIER_ETAT_REGION_FINALISATION,
                             DOSSIER_ETAT_DRH_FINALISATION,
                             DOSSIER_ETAT_FINALISE)

reversion.register(Dossier, format='xml', follow=[
    'dae_dossierpieces', 'dae_comparaisons', 'dae_remunerations',
    'dae_contrats'
])


class DossierPiece(rh.DossierPiece_):
    """
    Documents relatifs au Dossier (à l'occupation de ce poste par employé).
    Ex.: Lettre de motivation.
    """
    dossier = models.ForeignKey(
        Dossier, db_column='dossier', related_name='dae_dossierpieces'
    )

reversion.register(DossierPiece, format='xml')


class DossierComparaison(rh.DossierComparaison_):
    """
    Photo d'une comparaison salariale au moment de l'embauche.
    """
    dossier = models.ForeignKey(
        Dossier, related_name='dae_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
    )

reversion.register(DossierComparaison, format='xml')

class DossierComparaisonRemuneration(rh.Remuneration_):
    dossier_comparaison = models.ForeignKey(
        DossierComparaison, related_name='dossier_comparaison_remunerations'
    )

reversion.register(DossierComparaisonRemuneration, format='xml')

### RÉMUNÉRATION

class Remuneration(rh.Remuneration_):
    dossier = models.ForeignKey(
        Dossier, db_column='dossier', related_name='dae_remunerations'
    )

reversion.register(Remuneration, format='xml')


### CONTRATS

class Contrat(rh.Contrat_):
    dossier = models.ForeignKey(
        Dossier, db_column='dossier', related_name='dae_contrats'
    )

reversion.register(Contrat, format='xml')


class ProxyDossierStatut(Dossier):
    class Meta:
        proxy = True
        verbose_name = "Statut du dossier"
        verbose_name_plural = "Statut des dossiers"


class ProxyPosteStatut(Poste):
    class Meta:
        proxy = True
        verbose_name = "Statut du poste"
        verbose_name_plural = "Statut des postes"


class ProxyImplantation(ref.Implantation):

    # Ajout d'un manager pour ref.Implantation
    dae_manager = ImplantationManager()
    
    class Meta:
        proxy = True