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

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

import datetime

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

import datamaster_modeles.models as ref


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


# Upload de fichiers
storage_prive = FileSystemStorage(settings.PRIVE_MEDIA_ROOT, 
                            base_url=settings.PRIVE_MEDIA_URL)

def poste_piece_dispatch(instance, filename):
    path = "poste/%s/%s" % (instance.poste_id, filename)
    return path

def dossier_piece_dispatch(instance, filename):
    path = "dossier/%s/%s" % (instance.dossier_id, filename)
    return path

# Abstracts
class Metadata(models.Model):
    """Méta-données AUF.
    Metadata.actif = flag remplaçant la suppression.
    actif == False : objet réputé supprimé.
    """
    actif = models.BooleanField(default=True)
    date_creation = models.DateField(auto_now_add=True)
    user_creation = models.ForeignKey('auth.User', 
                            db_column='user_creation', related_name='+',
                            null=True, blank=True, default=True)
    date_modification = models.DateField(auto_now=True)
    user_modification = models.ForeignKey('auth.User', 
                            db_column='user_modification', related_name='+',
                            null=True, blank=True, default=True)
    date_desactivation = models.DateField(null=True, blank=True, default=True)
    user_desactivation = models.ForeignKey('auth.User', 
                            db_column='user_desactivation', related_name='+',
                            null=True, blank=True, default=True)
    
    class Meta:
        abstract = True

class Commentaire(Metadata):
    texte = models.TextField()
    owner = models.ForeignKey('auth.User', db_column='owner', related_name='+')
    
    class Meta:
        abstract = True
        ordering = ['-date_creation']
        
    def __unicode__(self):
        return u'%s' % (self.texte)


### POSTE

POSTE_APPEL_CHOICES = (
    ('interne', 'Interne'),
    ('externe', 'Externe'),
)

class Poste(Metadata):
    """Un Poste est un emploi (job) à combler dans une implantation. 
    Un Poste peut être comblé par un Employe, auquel cas un Dossier est créé.
    Si on veut recruter 2 jardiniers, 2 Postes distincts existent.
    """
    # Identification
    nom = models.CharField(max_length=255, 
                            verbose_name=u"Titre du poste", )
    nom_feminin = models.CharField(max_length=255,
                            verbose_name=u"Titre du poste (au féminin)"
                            null=True)
    implantation = models.ForeignKey(ref.Implantation, 
                            db_column='implantation', related_name='+')
    type_poste = models.ForeignKey('TypePoste', db_column='type_poste',
                            related_name='+',
                            null=True)
    service = models.ForeignKey('Service', db_column='service', 
                            related_name='+',
                            verbose_name=u"Direction/Service/Pôle support",
                            default=1)  # default = Rectorat
    responsable = models.ForeignKey('Poste', db_column='responsable', 
                            related_name='+',
                            verbose_name=u"Poste du responsable",
                            default=149)    # default = Recteur
                                
    # Contrat
    regime_travail = models.DecimalField(max_digits=12, decimal_places=2,
                            default=REGIME_TRAVAIL_DEFAULT, 
                            verbose_name=u"Temps de travail", 
                            help_text=u"% 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=u"Nb. heures par semaine")

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

    # Rémunération
    classement_min = models.ForeignKey('Classement', 
                            db_column='classement_min', related_name='+',
                            null=True, blank=True)
    classement_max = models.ForeignKey('Classement', 
                            db_column='classement_max', related_name='+',
                            null=True, blank=True)
    valeur_point_min = models.ForeignKey('ValeurPoint', 
                            db_column='valeur_point_min', related_name='+', 
                            null=True, blank=True)
    valeur_point_max = models.ForeignKey('ValeurPoint', 
                            db_column='valeur_point_max', related_name='+', 
                            null=True, blank=True)
    devise_min = models.ForeignKey('Devise', db_column='devise_min', 
                            related_name='+', default=5)
    devise_max = models.ForeignKey('Devise', db_column='devise_max', 
                            related_name='+', default=5)
    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_min = models.DecimalField(max_digits=12, decimal_places=2,
                            default=0)
    indemn_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('Devise', 
                            db_column='devise_comparaison', 
                            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(null=True, blank=True)

    # Autres Metadata
    date_validation = models.DateTimeField(null=True, blank=True)   # de dae
    date_debut = models.DateField(verbose_name=u"Date de début",
                            help_text=HELP_TEXT_DATE)
    date_fin = models.DateField(verbose_name=u"Date de fin",
                            help_text=HELP_TEXT_DATE,
                            null=True, blank=True)

    class Meta:
        ordering = ['implantation__nom', 'nom']

    def __unicode__(self):
        # TODO : gérer si poste est vacant ou non dans affichage
        # TODO : gérer le nom_feminin (autre méthode appelée par __unicode__ ?)
        return u'%s - %s [%s]' % (self.implantation, self.nom, self.id)


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

class PosteFinancement(models.Model):
    """Pour un Poste, structure d'informations décrivant comment on prévoit
    financer ce Poste.
    """
    poste = models.ForeignKey('Poste', db_column='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=u"ex.: 33.33 % (décimale avec point)")
    commentaire = models.TextField(
            help_text=u"Spécifiez la source de financement.")

    class Meta:
        ordering = ['type']
        
    def __unicode__(self):
        return u'%s : %s %' % (self.type, self.pourcentage)

class PostePiece(models.Model):
    """Documents relatifs au Poste.
    Ex.: Description de poste
    """
    poste = models.ForeignKey("Poste", db_column='poste', 
                            related_name='pieces')
    nom = models.CharField(verbose_name=u"Nom", max_length=255)
    fichier = models.FileField(verbose_name=u"Fichier", 
                            upload_to=poste_piece_dispatch, 
                            storage=storage_prive)

    class Meta:
        ordering = ['nom']
        
    def __unicode__(self):
        return u'%s' % (self.nom)

class PosteCommentaire(Commentaire):
    poste = models.ForeignKey("Poste", db_column='poste', related_name='+')


### EMPLOYÉ/PERSONNE

GENRE_CHOICES = (
    ('M', 'Homme'),
    ('F', 'Femme'),
)
SITUATION_CHOICES = (
    ('C', 'Célibataire'),
    ('F', 'Fiancé'),
    ('M', 'Marié'),
)

class Employe(Metadata):
    """Personne occupant ou ayant occupé un Poste. Un Employe aura autant de 
    Dossiers qu'il occupe ou a occupé de Postes.
    
    Cette classe aurait pu avantageusement s'appeler Personne car la notion 
    d'employé n'a pas de sens si aucun Dossier n'existe pour une personne.
    """
    # Identification
    nom = models.CharField(max_length=255)
    prenom = models.CharField(max_length=255, verbose_name=u"Prénom")
    # TODO : nom_affichage doit être obligatoire, pas nom et prenom
    nom_affichage = models.CharField(max_length=255, 
                            verbose_name=u"Nom d'affichage",
                            null=True, blank=True)
    nationalite = models.ForeignKey(ref.Pays, to_field='code', 
                            db_column='nationalite',
                            related_name='employes_nationalite')
    date_naissance = models.DateField(help_text=HELP_TEXT_DATE,
                            null=True, blank=True)
    genre = models.CharField(max_length=1, choices=GENRE_CHOICES)
    
    # Infos personnelles
    situation_famille = models.CharField(max_length=1, 
                            choices=SITUATION_CHOICES,
                            null=True, blank=True)
    date_entree = models.DateField(verbose_name=u"Date d'entrée à l'AUF",
                            help_text=HELP_TEXT_DATE, 
                            null=True, blank=True)
    
    # Coordonnées
    tel_domicile = models.CharField(max_length=255, null=True, blank=True)
    tel_cellulaire = models.CharField(max_length=255, null=True, blank=True)
    adresse = models.CharField(max_length=255, null=True, blank=True)
    ville = models.CharField(max_length=255, null=True, blank=True)
    province = models.CharField(max_length=255, null=True, blank=True)
    code_postal = models.CharField(max_length=255, null=True, blank=True)
    pays = models.ForeignKey(ref.Pays, to_field='code', db_column='pays',
                            related_name='employes', 
                            null=True, blank=True)

    class Meta:
        ordering = ['nom_affichage']
        
    def __unicode__(self):
        # TODO : gérer nom d'affichage
        return u'%s' % (self.nom_affichage)

class EmployePiece(models.Model):
    """Documents relatifs à un employé.
    Ex.: CV...
    """
    employe = models.ForeignKey("Employe", db_column='employe', 
                            related_name='+')
    nom = models.CharField(verbose_name=u"Nom", max_length=255)
    fichier = models.FileField(verbose_name=u"Fichier", 
                            upload_to=dossier_piece_dispatch, 
                            storage=storage_prive)

    class Meta:
        ordering = ['nom']
        
    def __unicode__(self):
        return u'%s' % (self.nom)

class EmployeCommentaire(Commentaire):
    employe = models.ForeignKey("Employe", db_column='employe',
                            related_name='+')


LIEN_PARENTE_CHOICES = (
    ('Conjoint', 'Conjoint'),
    ('Conjointe', 'Conjointe'),
    ('Fille', 'Fille'),
    ('Fils', 'Fils'),
)

class AyantDroit(Metadata):
    """Personne en relation avec un Employe.
    """
    # Identification
    nom = models.CharField(max_length=255)
    prenom = models.CharField(max_length=255)
    # TODO : nom_affichage doit être obligatoire, pas nom et prenom
    nom_affichage = models.CharField(max_length=255, 
                            verbose_name=u"Nom d'affichage",
                            null=True, blank=True)
    nationalite = models.ForeignKey(ref.Pays, to_field='code', 
                            db_column='nationalite',
                            related_name='ayantdroits_nationalite')
    date_naissance = models.DateField(help_text=HELP_TEXT_DATE,
                            null=True, blank=True)
    genre = models.CharField(max_length=1, choices=GENRE_CHOICES)
    
    # Relation
    employe = models.ForeignKey('Employe', db_column='employe', 
                            related_name='ayantdroits')
    lien_parente = models.CharField(max_length=10, 
                            choices=LIEN_PARENTE_CHOICES,
                            null=True, blank=True)

    class Meta:
        ordering = ['nom_affichage']
    def __unicode__(self):
        # TODO : gérer nom d'affichage
        return u'%s %s' % (self.prenom, self.nom.upper())

class AyantDroitCommentaire(Commentaire):
    ayant_droit = models.ForeignKey("AyantDroit", db_column='ayant_droit',
                            related_name='+')


### DOSSIER

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

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

class Dossier(Metadata):
    """Le Dossier regroupe les informations relatives à l'occupation
    d'un Poste par un Employe. Un seul Dossier existe par Poste occupé
    par un Employe.
    
    Plusieurs Contrats peuvent être associés au Dossier.
    Une structure de Remuneration est rattachée au Dossier. Un Poste pour
    lequel aucun Dossier n'existe est un poste vacant.
    """
    # Identification
    employe = models.ForeignKey('Employe', db_column='employe', 
                            related_name='+')
    poste = models.ForeignKey('Poste', db_column='poste', 
                            related_name='+', editable=False)
    statut = models.ForeignKey('Statut', related_name='+', default=3)
    organisme_bstg = models.ForeignKey('OrganismeBstg', 
                            db_column='organisme_bstg',
                            related_name='+',
                            verbose_name=u"Organisme", 
                            help_text=u"Si détaché (DET) ou \
                                    mis à disposition (MAD), \
                                    préciser l'organisme.",
                            null=True, blank=True)
                          
    # Recrutement
    remplacement = models.BooleanField(default=False)
    statut_residence = models.CharField(max_length=10, default='local', 
                            verbose_name=u"Statut",
                            choices=STATUT_RESIDENCE_CHOICES)
   
    # Rémunération
    classement = models.ForeignKey('Classement', db_column='classement', 
                            related_name='+',
                            null=True, blank=True)
    regime_travail = models.DecimalField(max_digits=12, 
                            decimal_places=2,
                            default=REGIME_TRAVAIL_DEFAULT,
                            verbose_name=u"Régime de travail",
                            help_text=u"% 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=u"Nb. heures par semaine")

    # Occupation du Poste par cet Employe (anciennement "mandat")
    date_debut = models.DateField(verbose_name=u"Date de début d'occupation \
                            de poste",
                            help_text=HELP_TEXT_DATE)
    date_fin = models.DateField(verbose_name=u"Date de fin d'occupation \
                            de poste",
                            help_text=HELP_TEXT_DATE,
                            null=True, blank=True)
    
    # Comptes
    # TODO?
    
    class Meta:
        ordering = ['poste__nom', 'employe__nom_affichage']
        
    def __unicode__(self):
        return u'%s - %s' % (self.poste.nom, self.employe)

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

    class Meta:
        ordering = ['nom']
        
    def __unicode__(self):
        return u'%s' % (self.nom)

class DossierCommentaire(Commentaire):
    dossier = models.ForeignKey("Dossier", db_column='dossier', 
                            related_name='+')


### RÉMUNÉRATION
    
class RemunerationMixin(Metadata):
    # Identification
    dossier = models.ForeignKey('Dossier', db_column='dossier')
    type = models.ForeignKey('TypeRemuneration', db_column='type', 
                            related_name='+')
    type_revalorisation = models.ForeignKey('TypeRevalorisation', 
                            db_column='type_revalorisation', 
                            related_name='+',
                            null=True, blank=True)
    montant = models.FloatField(max_digits=12, decimal_places=2, 
                            null=True, blank=True,
                            default=0)
                            # Annuel (12 mois, 52 semaines, 364 jours?)
    devise = models.ForeignKey('Devise', to_field='code',
                            db_column='devise', related_name='+',
                            default=5)
    # commentaire = precision
    commentaire = models.CharField(max_length=255, null=True, blank=True)
    # date_debut = anciennement date_effectif
    date_debut = models.DateField(help_text=HELP_TEXT_DATE, 
                            null=True, blank=True)
    date_fin = models.DateField(help_text=HELP_TEXT_DATE,
                            null=True, blank=True)
    
    class Meta: 
        abstract = True
        ordering = ['type__nom', '-date_fin']
        
    def __unicode__(self):
        return u'%s %s (%s)' % (self.montant, self.devise.code, self.type.nom)
    
class Remuneration(RemunerationMixin):
    """Structure de rémunération (données budgétaires) en situation normale
    pour un Dossier. Si un Evenement existe, utiliser la structure de 
    rémunération EvenementRemuneration de cet événement.    
    """

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

    def taux_devise(self):
        return self.devise.tauxchange_set.order_by('-annee').all()[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)
    
    def __unicode__(self):
        try:
            devise = self.devise.code
        except:
            devise = "???"
        return "%s %s" % (self.montant, devise)


### CONTRATS
        
class Contrat(Metadata):
    """Document juridique qui encadre la relation de travail d'un Employe
    pour un Poste particulier. Pour un Dossier (qui documente cette 
    relation de travail) plusieurs contrats peuvent être associés.
    """
    dossier = models.ForeignKey('Dossier', db_column='dossier', 
                            related_name='+')
    type_contrat = models.ForeignKey('TypeContrat', db_column='type_contrat', 
                            related_name='+')
    date_debut = models.DateField(help_text=HELP_TEXT_DATE)
    date_fin = models.DateField(help_text=HELP_TEXT_DATE,
                            null=True, blank=True)

    class Meta:
        ordering = ['dossier__employe__nom_affichage']
        
    def __unicode__(self):
        return u'%s - %s' % (self.dossier.employe.nom_affichage, self.id)
        
# TODO? class ContratPiece(models.Model):
    

### ÉVÉNEMENTS

class Evenement(Metadata):
    """Un Evenement sert à déclarer une situation temporaire (exceptionnelle) 
    d'un Dossier qui vient altérer des informations normales liées à un Dossier 
    (ex.: la Remuneration).
    
    Ex.: congé de maternité, maladie...
    
    Lors de ces situations exceptionnelles, l'Employe a un régime de travail
    différent et une rémunération en conséquence. On souhaite toutefois
    conserver le Dossier intact afin d'éviter une re-saisie des données lors
    du retour à la normale.
    """
    dossier = models.ForeignKey("Dossier", db_column='dossier', 
                            related_name='+')
    nom = models.CharField(max_length=255)
    date_debut = models.DateField(help_text=HELP_TEXT_DATE)
    date_fin = models.DateField(help_text=HELP_TEXT_DATE, 
                            null=True, blank=True)
    class Meta:
        ordering = ['nom']
                            
    def __unicode__(self):
        return u'%s' % (self.nom)
    
class EvenementRemuneration(RemunerationMixin):
    """Structure de rémunération liée à un Evenement qui remplace 
    temporairement la Remuneration normale d'un Dossier, pour toute la durée
    de l'Evenement.
    """
    evenement = models.ForeignKey("Evenement", db_column='evenement',
                            related_name='+')


### RÉFÉRENCES RH 

class FamilleEmploi(Metadata):
    """Catégorie utilisée dans la gestion des Postes.
    Catégorie supérieure à TypePoste.
    """
    nom = models.CharField(max_length=255)
    
    def __unicode__(self):
        return u'%s' % (self.nom)

class TypePoste(Metadata):
    """Catégorie de Poste.
    """
    nom = models.CharField(max_length=255)
    nom_feminin = models.CharField(max_length=255)
    
    is_responsable = models.BooleanField(default=False)
    famille_emploi = models.ForeignKey('FamilleEmploi', 
                            db_column='famille_emploi',
                            related_name='+')

    class Meta:
        ordering = ['nom']
        
    def __unicode__(self):
        # TODO : gérer nom féminin
        return u'%s' % (self.nom)


TYPE_PAIEMENT_CHOICES = (
    ('Régulier', 'Régulier'),
    ('Ponctuel', 'Ponctuel'),
)

NATURE_REMUNERATION_CHOICES = (
    ('Accessoire', 'Accessoire'),
    ('Charges', 'Charges'),
    ('Indemnité', 'Indemnité'),
    ('RAS', 'Rémunération autre source'),
    ('Traitement', 'Traitement'),
)

class TypeRemuneration(Metadata):
    """Catégorie de Remuneration.
    """
    nom = models.CharField(max_length=255)
    type_paiement = models.CharField(max_length=30, 
                            choices=TYPE_PAIEMENT_CHOICES)
    nature_remuneration = models.CharField(max_length=30, 
                            choices=NATURE_REMUNERATION_CHOICES)

    def __unicode__(self):
        return u'%s' % (self.nom)
        
class TypeRevalorisation(Metadata):
    """Justification du changement de la Remuneration.
    (Actuellement utilisé dans aucun traitement informatique.)
    """
    nom = models.CharField(max_length=255)

    def __unicode__(self):
        return u'%s' % (self.nom)
    
class Service(Metadata):
    """Unité administrative où les Postes sont rattachés.
    """
    nom = models.CharField(max_length=255)
        
    class Meta:
        ordering = ['nom']

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


TYPE_ORGANISME_CHOICES = (
    ('MAD', 'Mise à disposition'),
    ('DET', 'Détachement'),
)

class OrganismeBstg(Metadata):
    """Organisation d'où provient un Employe mis à disposition (MAD) de 
    ou détaché (DET) à l'AUF à titre gratuit.
    
    (BSTG = bien et service à titre gratuit.)
    """
    nom = models.CharField(max_length=255)
    type = models.CharField(max_length=10, choices=TYPE_ORGANISME_CHOICES)
    pays = models.ForeignKey(ref.Pays, to_field='code', 
                            db_column='pays',
                            related_name='organismes_bstg',
                            null=True, blank=True)

    class Meta:
        ordering = ['type', 'nom']

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

class Statut(Metadata):
    """Statut de l'Employe dans le cadre d'un Dossier particulier.
    """
    # Identification
    code = models.CharField(max_length=25, unique=True)
    nom = models.CharField(max_length=255)

    class Meta:
        ordering = ['code']
        
    def __unicode__(self):
        return u'%s : %s' % (self.code, self.nom)


TYPE_CLASSEMENT_CHOICES = (
    ('S', 'S -Soutien'),
    ('T', 'T - Technicien'),
    ('P', 'P - Professionel'),
    ('C', 'C - Cadre'),
    ('D', 'D - Direction'),
    ('SO', 'SO - Sans objet [expatriés]'),
    ('HG', 'HG - Hors grille [direction]'),
)

class Classement(Metadata):
    """Éléments de classement de la 
    "Grille générique de classement hiérarchique".
    
    Utile pour connaître, pour un Dossier, le salaire de base théorique lié au 
    classement dans la grille. Le classement donne le coefficient utilisé dans:

    salaire de base = coefficient * valeur du point de l'Implantation du Poste
    """
    # Identification
    type = models.CharField(max_length=10, choices=TYPE_CLASSEMENT_CHOICES)
    echelon = models.IntegerField()
    degre = models.IntegerField()
    coefficient = models.FloatField(default=0)
    # Méta
    # annee # au lieu de date_debut et date_fin
    commentaire = models.TextField(null=True, blank=True)
    
    class Meta:
        ordering = ['type','echelon','degre','coefficient']

    def __unicode__(self):
        return u'%s.%s.%s (%s)' % (self.type, self.echelon, self.degre,
                                   self.coefficient)

class TauxChange(Metadata):
    """Taux de change de la devise vers l'euro (EUR) 
    pour chaque année budgétaire.
    """
    # Identification
    devise = models.ForeignKey('Devise', to_field='code', db_column='devise',
                            related_name='+')
    annee = models.IntegerField()
    taux = models.FloatField()
    
    class Meta:
        ordering = ['annee', 'devise__code']
    
    def __unicode__(self):
        return u'%s : %s €' % (self.devise.code, self.taux)

class ValeurPoint(Metadata):
    """Utile pour connaître, pour un Dossier, le salaire de base théorique lié 
    au classement dans la grille. La ValeurPoint s'obtient par l'implantation 
    du POste de ce Dossier : dossier.poste.implantation (pseudo code).

    salaire de base = coefficient * valeur du point de l'Implantation du Poste
    """
    valeur = models.FloatField()
    devise = models.ForeignKey('Devise', db_column='devise', 
                            related_name='+', default=5)
    implantation = models.ForeignKey(ref.Implantation, 
                            db_column='implantation', 
                            related_name='valeur_point')
    # Méta
    annee = models.IntegerField()

    # Stockage de tous les taux de change 
    # pour optimiser la recherche de la devise associée
    annee_courante = datetime.datetime.now().year
    tauxchange = TauxChange.objects.select_related('devise')    \
                            .filter(annee=annee_courante)

    class Meta:
        ordering = ['annee', 'implantation__nom']
        
    def __unicode__(self):
        tx = self.get_tauxchange_courant()
        if tx:
            devise_code = tx.devise.code
        else:
            devise_code = "??"
        return u'%s %s (%s-%s)' % (self.valeur, devise_code, 
                            self.implantation_id, self.annee)
        
    class Meta:
        ordering = ['valeur']

class Devise(Metadata):
    """Devise monétaire.
    """
    code =  models.CharField(max_length=10, unique=True)
    nom = models.CharField(max_length=255)

    class Meta:
        ordering = ['code']
        
    def __unicode__(self):
        return u'%s - %s' % (self.code, self.nom)

class TypeContrat(Metadata):
    """Type de contrat.
    """
    nom = models.CharField(max_length=255)
    nom_long = models.CharField(max_length=255)

    def __unicode__(self):
        return u'%s' % (self.nom)
        
        
### AUTRES

class ResponsableImplantation(Metadata):
    """Le responsable d'une implantation. 
    Anciennement géré sur le Dossier du responsable.
    """
    employe = models.ForeignKey('Employe', db_column='employe', 
                            related_name='+',
                            null=True, blank=True)
    implantation = models.ForeignKey(ref.Implantation, 
                            db_column='implantation', related_name='+', 
                            unique=True)

    def __unicode__(self):
        return u'%s : %s' % (self.implantation, self.employe)
        
    class Meta:
        ordering = ['implantation__nom']