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

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

import datetime
from datetime import date
from decimal import Decimal

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

from auf.django.emploi.models import GENRE_CHOICES, SITUATION_CHOICES # devrait plutot être dans references
from auf.django.metadata.models import AUFMetadata
from auf.django.metadata.managers import NoDeleteManager
import auf.django.references.models as ref
from validators import validate_date_passee
from managers import PosteManager, DossierManager, DossierComparaisonManager, PosteComparaisonManager, DeviseManager


# Gruick hack pour déterminer d'ou provient l'instanciation d'une classe pour l'héritage.
# Cela permet de faire du dynamic loading par app sans avoir à redéfinir dans DAE la FK
def app_context():
    import inspect;
    models_stack = [s[1].split('/')[-2] for s in inspect.stack() if s[1].endswith('models.py')]
    return models_stack[-1]


# Constantes
HELP_TEXT_DATE = "format: jj-mm-aaaa"
REGIME_TRAVAIL_DEFAULT = Decimal('100.00')
REGIME_TRAVAIL_NB_HEURE_SEMAINE_DEFAULT = Decimal('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 = "%s/poste/%s/%s" % (instance._meta.app_label, instance.poste_id, filename)
    return path

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

def employe_piece_dispatch(instance, filename):
    path = "%s/employe/%s/%s" % (instance._meta.app_label, instance.employe_id, filename)
    return path

def contrat_dispatch(instance, filename):
    path = "%s/contrat/%s/%s" % (instance._meta.app_label, instance.dossier_id, filename)
    return path


class Commentaire(AUFMetadata):
    texte = models.TextField()
    owner = models.ForeignKey('auth.User', db_column='owner', related_name='+', verbose_name=u"Commentaire de")

    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_(AUFMetadata):
    """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.
    """

    objects = PosteManager()

    # 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, help_text=u"Taper le nom de l'implantation ou sa région", 
                            db_column='implantation', related_name='+')
    type_poste = models.ForeignKey('TypePoste', db_column='type_poste', help_text=u"Taper le nom du type de poste",
                            related_name='+',
                            null=True,
                            verbose_name=u"type de poste")
    service = models.ForeignKey('Service', db_column='service',
                            related_name='+',
                            verbose_name = u"direction/service/pôle support",
                            null=True,)
    responsable = models.ForeignKey('Poste', db_column='responsable', 
                            related_name='+',
                            null=True,
                            help_text=u"Taper le nom du poste ou du type de poste", 
                            verbose_name = u"Poste du responsable", )
                                
    # Contrat
    regime_travail = models.DecimalField(max_digits=12, decimal_places=2,
                            default=REGIME_TRAVAIL_DEFAULT, null=True,
                            verbose_name = u"Temps de travail",
                            help_text="% du temps complet")
    regime_travail_nb_heure_semaine = models.DecimalField(max_digits=12,
                            decimal_places=2, null=True,
                            default=REGIME_TRAVAIL_NB_HEURE_SEMAINE_DEFAULT,
                            verbose_name = u"Nb. heures par semaine")

    # Recrutement
    local = models.NullBooleanField(verbose_name = u"Local", default=True,
                            null=True, blank=True)
    expatrie = models.NullBooleanField(verbose_name = u"Expatrié", default=False,
                            null=True, blank=True)
    mise_a_disposition = models.NullBooleanField(
                            verbose_name = u"Mise à disposition",
                            null=True, default=False)
    appel = models.CharField(max_length=10, null=True,
                            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', help_text=u"Taper le code ou le nom de l'implantation",
                            db_column='valeur_point_min', related_name='+',
                            null=True, blank=True)
    valeur_point_max = models.ForeignKey('ValeurPoint', help_text=u"Taper le code ou le nom de l'implantation",
                            db_column='valeur_point_max', related_name='+',
                            null=True, blank=True)
    devise_min = models.ForeignKey('Devise', db_column='devise_min', null=True,
                            related_name='+',)
    devise_max = models.ForeignKey('Devise', db_column='devise_max', null=True,
                            related_name='+',)
    salaire_min = models.DecimalField(max_digits=12, decimal_places=2,
                            null=True, default=0)
    salaire_max = models.DecimalField(max_digits=12, decimal_places=2,
                            null=True, default=0)
    indemn_min = models.DecimalField(max_digits=12, decimal_places=2,
                            null=True, default=0)
    indemn_max = models.DecimalField(max_digits=12, decimal_places=2,
                            null=True, default=0)
    autre_min = models.DecimalField(max_digits=12, decimal_places=2,
                            null=True, default=0)
    autre_max = models.DecimalField(max_digits=12, decimal_places=2,
                            null=True, default=0)

    # Comparatifs de rémunération
    devise_comparaison = models.ForeignKey('Devise', null=True, blank=True,
                            db_column='devise_comparaison',
                            related_name='+', )
    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_debut = models.DateField(verbose_name=u"Date de début", help_text=HELP_TEXT_DATE,
                            null=True, blank=True)
    date_fin = models.DateField(verbose_name=u"Date de fin", help_text=HELP_TEXT_DATE,
                            null=True, blank=True)

    class Meta:
        abstract = True
        ordering = ['implantation__nom', 'nom']
        verbose_name = u"Poste"
        verbose_name_plural = u"Postes"
        ordering = ["nom"]

    def __unicode__(self):
        representation = u'%s - %s [%s]' % (self.implantation, self.nom,
                            self.id)
        return representation


    prefix_implantation = "implantation__region"
    def get_regions(self):
        return [self.implantation.region]


class Poste(Poste_):
    __doc__ = Poste_.__doc__

    # meta dématérialisation :  pour permettre le filtrage
    vacant = models.NullBooleanField(verbose_name = u"vacant", null=True, blank=True)

    def is_vacant(self):
        vacant = True
        if self.occupe_par():
            vacant = False
        return vacant

    def occupe_par(self):
        """Retourne la liste d'employé occupant ce poste.
        Généralement, retourne une liste d'un élément.
        Si poste inoccupé, retourne liste vide.
        UTILISE pour mettre a jour le flag vacant
        """
        return [d.employe for d in self.rh_dossiers.filter(supprime=False).exclude(date_fin__lt=date.today())]


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('%s.Poste' % app_context(), db_column='poste', related_name='%(app_label)s_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:
        abstract = True
        ordering = ['type']

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

    def choix(self):
        return u"%s" % dict(POSTE_FINANCEMENT_CHOICES)[self.type]


class PosteFinancement(PosteFinancement_):
    pass


class PostePiece_(models.Model):
    """Documents relatifs au Poste.
    Ex.: Description de poste
    """
    poste = models.ForeignKey('%s.Poste' % app_context(), db_column='poste', related_name='%(app_label)s_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:
        abstract = True
        ordering = ['nom']

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

class PostePiece(PostePiece_):
    pass

class PosteComparaison_(AUFMetadata):
    """
    De la même manière qu'un dossier, un poste peut-être comparé à un autre poste.
    """
    poste = models.ForeignKey('%s.Poste' % app_context(), related_name='%(app_label)s_comparaisons_internes')
    objects = PosteComparaisonManager()

    implantation = models.ForeignKey(ref.Implantation, null=True, blank=True, related_name="+")
    nom = models.CharField(verbose_name = u"Poste", max_length=255, null=True, blank=True)
    montant = models.IntegerField(null=True)
    devise = models.ForeignKey("Devise", related_name='+', null=True, blank=True)

    class Meta:
        abstract = True

    def taux_devise(self):
        if self.devise is None:
            return None
        if self.devise.code == "EUR":
            return 1
        annee = self.poste.date_debut.year
        taux = [tc.taux for tc in TauxChange.objects.filter(devise=self.devise, annee=annee)]
        taux = set(taux)
        if len(taux) != 1:
            raise Exception(u"Le taux de la devise %s n'a pas n'existe pas pour %s ou il existe plusieurs taux pour la même année" % (self.devise.id, annee))
        else:
            return list(taux)[0]

    def montant_euros(self):
        taux = self.taux_devise()
        if not taux:
            return None
        return round(float(self.montant) * float(taux), 2)

    def __unicode__(self):
        return self.nom

class PosteComparaison(PosteComparaison_):
    pass

class PosteCommentaire_(Commentaire):
    poste = models.ForeignKey('%s.Poste' % app_context(), db_column='poste', related_name='+')

    class Meta:
        abstract = True

class PosteCommentaire(PosteCommentaire_):
    pass

### EMPLOYÉ/PERSONNE

class Employe(AUFMetadata):
    """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")
    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',
                            verbose_name = u"Nationalité",
                            blank=True, null=True)
    date_naissance = models.DateField(verbose_name = u"Date de naissance",
                            help_text=HELP_TEXT_DATE,
                            validators=[validate_date_passee],
                            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,
                            verbose_name = u"Situation familiale",
                            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,
                            verbose_name = u"Tél. domicile",
                            null=True, blank=True)
    tel_cellulaire = models.CharField(max_length=255,
                            verbose_name = u"Tél. cellulaire",
                            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)

    # meta dématérialisation :  pour permettre le filtrage
    nb_postes = models.IntegerField(verbose_name = u"nombre de postes", null=True, blank=True)

    class Meta:
        ordering = ['nom','prenom']
        verbose_name = u"Employé"
        verbose_name_plural = u"Employés"

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

    def civilite(self):
        civilite = u''
        if self.genre.upper() == u'M':
            civilite = u'M.'
        elif self.genre.upper() == u'F':
            civilite = u'Mme'
        return civilite

    def url_photo(self):
        """Retourne l'URL du service retournant la photo de l'Employe.
        Équivalent reverse url 'rh_photo' avec id en param.
        """
        from django.core.urlresolvers import reverse
        return reverse('rh_photo', kwargs={'id':self.id})

    def dossiers_passes(self):
        today = date.today()
        dossiers_passes = self.dossiers.filter(date_fin__lt=today).order_by('-date_fin')
        for d in dossiers_passes:
            d.archive = True
        return dossiers_passes

    def dossiers_futurs(self):
        today = date.today()
        return self.dossiers.filter(date_debut__gt=today).order_by('-date_fin')

    def dossiers_encours(self):
        dossiers_p_f = self.dossiers_passes() | self.dossiers_futurs()
        ids_dossiers_p_f = [d.id for d in dossiers_p_f]
        dossiers_encours = self.dossiers.exclude(id__in=ids_dossiers_p_f).order_by('-date_fin')

        # TODO : supprimer ce code quand related_name fonctionnera ou d.remuneration_set
        for d in dossiers_encours:
            d.remunerations = Remuneration.objects.filter(dossier=d.id).order_by('-id')
        return dossiers_encours

    def postes_encours(self):
        postes_encours = set()
        for d in self.dossiers_encours():
            postes_encours.add(d.poste)
        return postes_encours

    def poste_principal(self):
        """
        Retourne le Poste du premier Dossier créé parmi les Dossiers en cours.
        Idée derrière :
        si on ajout d'autre Dossiers, c'est pour des Postes secondaires.
        """
        poste = Poste.objects.none()
        try:
            poste = self.dossiers_encours().order_by('date_debut')[0].poste
        except:
            pass
        return poste

    prefix_implantation = "rh_dossiers__poste__implantation__region"
    def get_regions(self):
        regions = []
        for d in self.dossiers.all():
            regions.append(d.poste.implantation.region)
        return regions


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

    class Meta:
        ordering = ['nom']
        verbose_name = u"Employé pièce"
        verbose_name_plural = u"Employé pièces"

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

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

    class Meta:
        verbose_name = u"Employé commentaire"
        verbose_name_plural = u"Employé commentaires"


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

class AyantDroit(AUFMetadata):
    """Personne en relation avec un Employe.
    """
    # Identification
    nom = models.CharField(max_length=255)
    prenom = models.CharField(max_length=255,
                            verbose_name = u"Prénom",)
    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',
                            verbose_name = u"Nationalité",
                            null=True, blank=True)
    date_naissance = models.DateField(verbose_name = u"Date de naissance",
                            help_text=HELP_TEXT_DATE,
                            validators=[validate_date_passee],
                            null=True, blank=True)
    genre = models.CharField(max_length=1, choices=GENRE_CHOICES)

    # Relation
    employe = models.ForeignKey('Employe', db_column='employe',
                            related_name='ayantdroits',
                            verbose_name = u"Employé")
    lien_parente = models.CharField(max_length=10,
                            choices=LIEN_PARENTE_CHOICES,
                            verbose_name = u"Lien de parenté",
                            null=True, blank=True)

    class Meta:
        ordering = ['nom', ]
        verbose_name = u"Ayant droit"
        verbose_name_plural = u"Ayants droit"

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

    prefix_implantation = "employe__dossiers__poste__implantation__region"
    def get_regions(self):
        regions = []
        for d in self.employe.dossiers.all():
            regions.append(d.poste.implantation.region)
        return regions


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_(AUFMetadata):
    """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.
    """

    objects = DossierManager()

    # TODO: OneToOne ??
    statut = models.ForeignKey('Statut', related_name='+', null=True)
    organisme_bstg = models.ForeignKey('OrganismeBstg',
                            db_column='organisme_bstg',
                            related_name='+',
                            verbose_name = u"Organisme",
                            help_text="Si détaché (DET) ou \
                                    mis à disposition (MAD), \
                                    préciser l'organisme.",
                            null=True, blank=True)

    # Recrutement
    remplacement = models.BooleanField(default=False)
    remplacement_de = models.ForeignKey('self', related_name='+',
                            help_text=u"Taper le nom de l'employé",
                            null=True, blank=True)
    statut_residence = models.CharField(max_length=10, default='local',
                            verbose_name = u"Statut", null=True,
                            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, null=True,
                            decimal_places=2,
                            default=REGIME_TRAVAIL_DEFAULT,
                            verbose_name = u"Régime de travail",
                            help_text="% du temps complet")
    regime_travail_nb_heure_semaine = models.DecimalField(max_digits=12,
                            decimal_places=2, null=True,
                            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",)
    date_fin = models.DateField(verbose_name = u"Date de fin d'occupation \
                            de poste",
                            null=True, blank=True)

    # Comptes
    # TODO?

    class Meta:
        abstract = True
        ordering = ['employe__nom', ]
        verbose_name = u"Dossier"
        verbose_name_plural = "Dossiers"

    def salaire_theorique(self):
        annee = date.today().year
        coeff = self.classement.coefficient
        implantation = self.poste.implantation
        point = ValeurPoint.objects.get(implantation=implantation, annee=annee)

        montant = coeff * point.valeur
        devise = point.devise
        return {'montant':montant, 'devise':devise}

    def __unicode__(self):
        poste = self.poste.nom
        if self.employe.genre == 'F':
            poste = self.poste.nom_feminin
        return u'%s - %s' % (self.employe, poste)

    prefix_implantation = "poste__implantation__region"
    def get_regions(self):
        return [self.poste.implantation.region]


    def remunerations(self):
        return self.rh_remunerations.all().order_by('date_debut')

    def remunerations_en_cours(self):
        return self.rh_remunerations.all().filter(date_fin__exact=None).order_by('date_debut')

    def get_salaire(self):
        try:
            return [r for r in self.remunerations().order_by('-date_debut') if r.type_id == 1][0]
        except:
            return None


class Dossier(Dossier_):
    __doc__ = Dossier_.__doc__
    poste = models.ForeignKey('%s.Poste' % app_context(),
        db_column='poste',
        related_name='%(app_label)s_dossiers',
        help_text=u"Taper le nom du poste ou du type de poste",
        )
    employe = models.ForeignKey('Employe', db_column='employe',
                            help_text=u"Taper le nom de l'employé",
                            related_name='%(app_label)s_dossiers',
                            verbose_name=u"Employé")


class DossierPiece_(models.Model):
    """Documents relatifs au Dossier (à l'occupation de ce poste par employé).
    Ex.: Lettre de motivation.
    """
    dossier = models.ForeignKey('%s.Dossier' % app_context(), db_column='dossier', related_name='%(app_label)s_dossierpieces')
    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:
        abstract = True
        ordering = ['nom']

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

class DossierPiece(DossierPiece_):
    pass

class DossierCommentaire_(Commentaire):
    dossier = models.ForeignKey('%s.Dossier' % app_context(), db_column='dossier', related_name='+')
    class Meta:
        abstract = True

class DossierCommentaire(DossierCommentaire_):
    pass

class DossierComparaison_(models.Model):
    """
    Photo d'une comparaison salariale au moment de l'embauche.
    """
    dossier = models.ForeignKey('%s.Dossier' % app_context(), related_name='%(app_label)s_comparaisons')
    objects = DossierComparaisonManager()

    implantation = models.ForeignKey(ref.Implantation, related_name="+", 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('Devise', related_name='+', null=True, blank=True)

    class Meta:
        abstract = True

    def taux_devise(self):
        if self.devise is None:
            return None
        annee = self.dossier.contrat_date_debut.year
        taux = [tc.taux for tc in TauxChange.objects.filter(devise=self.devise, annee=annee)]
        taux = set(taux)
        if len(taux) != 1:
            raise Exception(u"Le taux de la devise %s n'a pas n'existe pas pour %s ou il existe plusieurs taux pour la même année" % (self.devise.id, annee))
        else:
            return list(taux)[0]

    def montant_euros(self):
        taux = self.taux_devise()
        if not taux:
            return None
        return round(float(self.montant) * float(taux), 2)

class DossierComparaison(DossierComparaison_):
    pass

### RÉMUNÉRATION

class RemunerationMixin(AUFMetadata):
    dossier = models.ForeignKey('%s.Dossier' % app_context(), db_column='dossier', related_name='%(app_label)s_remunerations')
    # Identification
    type = models.ForeignKey('TypeRemuneration', db_column='type', 
                            related_name='+',
                            verbose_name = u"Type de rémunération")
    type_revalorisation = models.ForeignKey('TypeRevalorisation',
                            db_column='type_revalorisation',
                            related_name='+',
                            verbose_name = u"Type de revalorisation",
                            null=True, blank=True)
    montant = models.DecimalField(null=True, blank=True,
                            default=0, max_digits=12, decimal_places=2)
                            # Annuel (12 mois, 52 semaines, 364 jours?)
    devise = models.ForeignKey('Devise', db_column='devise', related_name='+',)
    # commentaire = precision
    commentaire = models.CharField(max_length=255, null=True, blank=True)
    # date_debut = anciennement date_effectif
    date_debut = models.DateField(verbose_name = u"Date de début",
                            null=True, blank=True)
    date_fin = models.DateField(verbose_name = u"Date de fin",
                            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 montant_avec_regime(self):
        return round(self.montant * (self.dossier.regime_travail/100), 2)

    def taux_devise(self):
        if self.devise.code == "EUR":
            return 1

        annee = datetime.datetime.now().year
        if self.dossier.poste.date_debut is not None:
            annee = self.dossier.poste.date_debut.year
        if self.dossier.date_debut is not None:
            annee = self.dossier.date_debut.year
        if self.date_debut is not None:
            annee = self.date_debut.year

        taux = [tc.taux for tc in TauxChange.objects.filter(devise=self.devise_id, annee=annee)]
        taux = set(taux)
        if len(taux) != 1:
            raise Exception(u"Le taux de la devise %s n'a pas n'existe pas pour %s ou il existe plusieurs taux pour la même année %s (%s)" % (self.devise.code, annee, taux, self.dossier))
        else:
            return list(taux)[0]

    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)

    class Meta:
        abstract = True
        verbose_name = u"Rémunération"
        verbose_name_plural = u"Rémunérations"


class Remuneration(Remuneration_):
    pass


### CONTRATS

class ContratManager(NoDeleteManager):
    def get_query_set(self):
        return super(ContratManager, self).get_query_set().select_related('dossier', 'dossier__poste')

        
class Contrat_(AUFMetadata):
    """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.
    """
    objects = ContratManager()
    dossier = models.ForeignKey('%s.Dossier' % app_context(), db_column='dossier', related_name='%(app_label)s_contrats')
    type_contrat = models.ForeignKey('TypeContrat', db_column='type_contrat', 
                            related_name='+',
                            verbose_name = u"type de contrat")
    date_debut = models.DateField(verbose_name = u"Date de début")
    date_fin = models.DateField(verbose_name = u"Date de fin",
                            null=True, blank=True)
    fichier = models.FileField(verbose_name = u"Fichier",
                            upload_to=contrat_dispatch,
                            storage=storage_prive,
                            null=True, blank=True)

    class Meta:
        abstract = True
        ordering = ['dossier__employe__nom']
        verbose_name = u"Contrat"
        verbose_name_plural = u"Contrats"

    def __unicode__(self):
        return u'%s - %s' % (self.dossier, self.id)

class Contrat(Contrat_):
    pass
        

### ÉVÉNEMENTS

#class Evenement_(AUFMetadata):
#    """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('%s.Dossier' % app_context(), db_column='dossier', 
#                            related_name='+')
#    nom = models.CharField(max_length=255)
#    date_debut = models.DateField(verbose_name = u"Date de début")
#    date_fin = models.DateField(verbose_name = u"Date de fin",
#                            null=True, blank=True)
#
#    class Meta:
#        abstract = True
#        ordering = ['nom']
#        verbose_name = u"Évènement"
#        verbose_name_plural = u"Évènements"
#                            
#    def __unicode__(self):
#        return u'%s' % (self.nom)
#
#
#class Evenement(Evenement_):
#    __doc__ = Evenement_.__doc__
#
#    
#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='+',
#                            verbose_name = u"Évènement")
#    # TODO : le champ dossier hérité de Remuneration doit être dérivé
#    # de l'Evenement associé
#
#    class Meta:
#        abstract = True
#        ordering = ['evenement', 'type__nom', '-date_fin']
#        verbose_name = u"Évènement - rémunération"
#        verbose_name_plural = u"Évènements - rémunérations"
#
#
#class EvenementRemuneration(EvenementRemuneration_):
#    __doc__ = EvenementRemuneration_.__doc__
#
#    class Meta:
#        abstract = True
#
#
#class EvenementRemuneration(EvenementRemuneration_):
#    __doc__ = EvenementRemuneration_.__doc__
# TODO? class ContratPiece(models.Model):


### RÉFÉRENCES RH

class FamilleEmploi(AUFMetadata):
    """Catégorie utilisée dans la gestion des Postes.
    Catégorie supérieure à TypePoste.
    """
    nom = models.CharField(max_length=255)

    class Meta:
        ordering = ['nom']
        verbose_name = u"Famille d'emploi"
        verbose_name_plural = u"Familles d'emploi"

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

class TypePoste(AUFMetadata):
    """Catégorie de Poste.
    """
    nom = models.CharField(max_length=255)
    nom_feminin = models.CharField(max_length=255,
                            verbose_name = u"Nom féminin")

    is_responsable = models.BooleanField(default=False,
                            verbose_name = u"Poste de responsabilité")
    famille_emploi = models.ForeignKey('FamilleEmploi',
                            db_column='famille_emploi',
                            related_name='+',
                            verbose_name = u"famille d'emploi")

    class Meta:
        ordering = ['nom']
        verbose_name = u"Type de poste"
        verbose_name_plural = u"Types de poste"

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


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

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

class TypeRemuneration(AUFMetadata):
    """Catégorie de Remuneration.
    """
    nom = models.CharField(max_length=255)
    type_paiement = models.CharField(max_length=30,
                            choices=TYPE_PAIEMENT_CHOICES,
                            verbose_name = u"Type de paiement")
    nature_remuneration = models.CharField(max_length=30,
                            choices=NATURE_REMUNERATION_CHOICES,
                            verbose_name = u"Nature de la rémunération")

    class Meta:
        ordering = ['nom']
        verbose_name = u"Type de rémunération"
        verbose_name_plural = u"Types de rémunération"

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

class TypeRevalorisation(AUFMetadata):
    """Justification du changement de la Remuneration.
    (Actuellement utilisé dans aucun traitement informatique.)
    """
    nom = models.CharField(max_length=255)

    class Meta:
        ordering = ['nom']
        verbose_name = u"Type de revalorisation"
        verbose_name_plural = u"Types de revalorisation"

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

class Service(AUFMetadata):
    """Unité administrative où les Postes sont rattachés.
    """
    archive = models.BooleanField(verbose_name=u"Archivé", default=False)
    nom = models.CharField(max_length=255)

    class Meta:
        ordering = ['nom']
        verbose_name = u"Service"
        verbose_name_plural = u"Services"

    def __unicode__(self):
        if self.archive:
            archive = u"(archivé)"
        else:
            archive = "" 
        return u'%s %s' % (self.nom, archive)


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

class OrganismeBstg(AUFMetadata):
    """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']
        verbose_name = u"Organisme BSTG"
        verbose_name_plural = u"Organismes BSTG"

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

    prefix_implantation = "pays__region"
    def get_regions(self):
        return [self.pays.region]


class Statut(AUFMetadata):
    """Statut de l'Employe dans le cadre d'un Dossier particulier.
    """
    # Identification
    code = models.CharField(max_length=25, unique=True, help_text="Saisir un code court mais lisible pour ce statut : le code est utilisé pour associer les statuts aux autres données tout en demeurant plus lisible qu'un identifiant numérique.")
    nom = models.CharField(max_length=255)

    class Meta:
        ordering = ['code']
        verbose_name = u"Statut d'employé"
        verbose_name_plural = u"Statuts d'employé"

    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 ClassementManager(models.Manager):
    """
    Ordonner les spcéfiquement les classements.
    """
    def get_query_set(self):
        qs = super(self.__class__, self).get_query_set()
        qs = qs.extra(select={'ponderation': 'FIND_IN_SET(type,"SO,HG,S,T,P,C,D")'})
        qs = qs.extra(order_by=('ponderation', 'echelon',  'degre', ))
        return qs.all()


class Classement_(AUFMetadata):
    """É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
    """
    objects = ClassementManager()

    # Identification
    type = models.CharField(max_length=10, choices=TYPE_CLASSEMENT_CHOICES)
    echelon = models.IntegerField(verbose_name=u"Échelon", blank=True, default=0)
    degre = models.IntegerField(verbose_name=u"Degré", blank=True, default=0)
    coefficient = models.FloatField(default=0, verbose_name=u"Coefficient",
                                    null=True)
    # Méta
    # annee # au lieu de date_debut et date_fin
    commentaire = models.TextField(null=True, blank=True)

    class Meta:
        abstract = True
        ordering = ['type','echelon','degre','coefficient']
        verbose_name = u"Classement"
        verbose_name_plural = u"Classements"

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

class Classement(Classement_):
    __doc__ = Classement_.__doc__


class TauxChange_(AUFMetadata):
    """Taux de change de la devise vers l'euro (EUR)
    pour chaque année budgétaire.
    """
    # Identification
    devise = models.ForeignKey('Devise', db_column='devise')
    annee = models.IntegerField(verbose_name = u"Année")
    taux = models.FloatField(verbose_name = u"Taux vers l'euro")

    class Meta:
        abstract = True
        ordering = ['-annee', 'devise__code']
        verbose_name = u"Taux de change"
        verbose_name_plural = u"Taux de change"

    def __unicode__(self):
        return u'%s : %s € (%s)' % (self.devise, self.taux, self.annee)


class TauxChange(TauxChange_):
    __doc__ = TauxChange_.__doc__

class ValeurPointManager(NoDeleteManager):

    def get_query_set(self):
        return super(ValeurPointManager, self).get_query_set().select_related('devise', 'implantation')


class ValeurPoint_(AUFMetadata):
    """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
    """

    actuelles = ValeurPointManager()

    valeur = models.FloatField(null=True)
    devise = models.ForeignKey('Devise', db_column='devise', related_name='+',)
    implantation = models.ForeignKey(ref.Implantation,
                            db_column='implantation',
                            related_name='%(app_label)s_valeur_point')
    # Méta
    annee = models.IntegerField()

    class Meta:
        ordering = ['-annee', 'implantation__nom']
        abstract = True
        verbose_name = u"Valeur du point"
        verbose_name_plural = u"Valeurs du point"

    def __unicode__(self):
        return u'%s %s %s [%s] %s' % (self.devise.code, self.annee, self.valeur, self.implantation.nom_court, self.devise.nom)


class ValeurPoint(ValeurPoint_):
    __doc__ = ValeurPoint_.__doc__


class Devise(AUFMetadata):
    """Devise monétaire.
    """
    
    objects = DeviseManager()

    archive = models.BooleanField(verbose_name=u"Archivé", default=False)
    code =  models.CharField(max_length=10, unique=True)
    nom = models.CharField(max_length=255)

    class Meta:
        ordering = ['code']
        verbose_name = u"Devise"
        verbose_name_plural = u"Devises"

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

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

    class Meta:
        ordering = ['nom']
        verbose_name = u"Type de contrat"
        verbose_name_plural = u"Types de contrat"

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


### AUTRES

class ResponsableImplantation(AUFMetadata):
    """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']
        verbose_name = "Responsable d'implantation"
        verbose_name_plural = "Responsables d'implantation"