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

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

import os
from datetime import date, timedelta

import reversion
from auf.django.metadata.models import AUFMetadata
from django.conf import settings
from django.core.files.storage import FileSystemStorage
from django.db import models
from django.db.models import Q

from project.dae.exporter import DossierCopier, PosteCopier
from project.dae.managers import \
        PosteManager, DossierManager, DossierFinaliseManager, \
        PosteFinaliseManager
from project.dae.workflow import PosteWorkflow, DossierWorkflow
from project.dae.workflow import \
        DOSSIER_ETAT_DRH_FINALISATION, DOSSIER_ETAT_REGION_FINALISATION, \
        DOSSIER_ETAT_FINALISE

# XXX: Saloperie, il faut importer rh.models à partir d'un autre namespace
# à cause du hack app_context() dans project.rh.models. Très fragile. Il
# faut régler ça aussi vite que possible.
from rh import models as rh
from 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='+',
                            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
    )

    # 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 []
        return self.id_rh.rh_dossiers.all()

    def rh_importation(self):
        if ImportPoste.objects.filter(dae=self).exists():
            return ImportPoste.objects.get(dae=self).rh
        else:
            return None

    def importer(self, verbosity=0, dry_run=False):
        copieur = PosteCopier(verbosity=verbosity, dry_run=dry_run)
        return copieur.copy(self)

    def importer_dans_rh(self):
        poste_rh = self.id_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_min
        poste_rh.indemn_max = self.indemn_max
        poste_rh.autre_min = self.autre_min
        poste_rh.autre_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
        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
            )
            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
            )

        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.
        """
        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(rh.PosteFinancement_):
    pass


class PostePiece(rh.PostePiece_):
    pass


class PosteComparaison(rh.PosteComparaison_):
    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
    )

### EMPLOYÉ/PERSONNE

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

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


class Employe(AUFMetadata):

    # 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 importer_dans_rh(self):
        return self.id_rh or rh.Employe.objects.create(
            nom=self.nom,
            prenom=self.prenom,
            genre=self.genre
        )


### DOSSIER

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

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


class Dossier(DossierWorkflow, rh.Dossier_):
    poste = models.ForeignKey(
        'Poste', db_column='poste', related_name='%(app_label)s_dossiers'
    )
    employe = models.ForeignKey(
        'Employe', db_column='employe',
        related_name='%(app_label)s_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,)

    # 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
    )

    # Comptes
    compte_compta = models.CharField(max_length=10, default='aucun',
                                    verbose_name=u'Compte comptabilité',
                                    choices=COMPTE_COMPTA_CHOICES)
    compte_courriel = models.BooleanField()

    # 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 importer(self, verbosity=0, dry_run=False):
        copieur = DossierCopier(verbosity=verbosity, dry_run=dry_run)
        return copieur.copy(self)

    def importer_dans_rh(self):
        today = date.today()
        poste_rh = self.poste.importer_dans_rh()
        employe_rh = self.employe.importer_dans_rh()
        try:
            dossier_rh = 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:
            dossier_rh = 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.regime_travail_nb_heure_semaine = \
                self.regime_travail_nb_heure_semaine
        dossier_rh.date_debut = self.date_debut
        dossier_rh.date_fin = self.date_fin
        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
            )

        if not dossier_rh.rh_contrats.filter(
            type_contrat=self.type_contrat,
            date_debut=self.contrat_date_debut,
            date_fin=self.contrat_date_fin
        ).exists():
            dossier_rh.rh_contrats.create(
                type_contrat=self.type_contrat,
                date_debut=self.contrat_date_debut,
                date_fin=self.contrat_date_fin,
            )

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

        # 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
            )

        return dossier_rh

    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)


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


class DossierPiece(rh.DossierPiece_):
    """Documents relatifs au Dossier (à l'occupation de ce poste par employé).
    Ex.: Lettre de motivation.
    """
    pass


class DossierComparaison(rh.DossierComparaison_):
    """
    Photo d'une comparaison salariale au moment de l'embauche.
    """
    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
    )


### RÉMUNÉRATION

class Remuneration(rh.Remuneration_):
    pass


### CONTRATS

class Contrat(rh.Contrat_):
    pass


class DossierFinalise(Dossier):

    objects = DossierFinaliseManager()

    class Meta:
        proxy = True
        verbose_name = "Import d'un dossier dans RH"
        verbose_name_plural = "Import des dossiers dans RH"


class PosteFinalise(Poste):

    objects = PosteFinaliseManager()

    class Meta:
        proxy = True
        verbose_name = "Import d'un poste dans RH"
        verbose_name_plural = "Import des postes dans RH"


# modèle de liaison entre les systèmes

class ImportDossier(models.Model):
    dae = models.ForeignKey('dae.Dossier', related_name='+')
    rh = models.ForeignKey('rh.Dossier', related_name='+')


class ImportPoste(models.Model):
    dae = models.ForeignKey('dae.Poste', related_name='+')
    rh = models.ForeignKey('rh.Poste', related_name='+')