[#2518] Scripts de migration du RH en PHP vers le nouveau système RH

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

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

import datetime
from django.db import models
from auf.django.references.models import Pays, Implantation
from dae.managers import SecurityManager

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

class Employe(models.Model):   
    # Identification
    id = models.IntegerField(primary_key=True)
    nom = models.CharField(max_length=255)
    prenom = models.CharField(max_length=255)
    nationalite = models.ForeignKey(Pays, to_field='code', 
                            related_name='nationalite', 
                            db_column='nationalite')
    date_naissance = models.DateField(null=True, blank=True)
    # Infos personnelles
    genre = models.CharField(max_length=1, null=True, blank=True,
                            choices=GENRE_CHOICES)
    situation_famille = models.CharField(max_length=1, null=True, blank=True,
                            choices=SITUATION_CHOICES)
    date_entree = models.DateField(null=True, blank=True) #devrait pas être là
    # 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)
    no_rue = 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(Pays, to_field='code', 
                            null=True, blank=True, 
                            related_name='pays', db_column='pays')
    # Métas
    date_creation = models.DateField(auto_now_add=True)
    date_maj = models.DateField(auto_now=True)
    commentaire = models.TextField(null=True, blank=True)

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


TYPE_DOSSIER_CHOICES = (
    ('2', 'Local'),
    ('1', 'Expatrié'),
)

class DossierManager(models.Manager):
    """
    Chargement de tous les objets FK existants sur chaque QuerySet.
    """
    prefixe_service = "poste1__service"
    prefixe_implantation = "poste1__implantation__region"

    def get_query_set(self):
        fkeys = (
            'employe',
            'poste1',
            'implantation1',
            'poste2',
            'implantation2',
            'service',
            'responsable',
            'remplacement_de',
            'statut',
            'organisme_bstg',
            'classement',
            'type_contrat',
        )
        return super(DossierManager, self).get_query_set().select_related(*fkeys).all()

class Dossier(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    code = models.CharField(max_length=10, unique=True)
    employe = models.ForeignKey('Employe', db_column='employe')
    # Postes
    poste1 = models.ForeignKey('Poste', db_column='poste1', 
                            related_name='poste1')
    implantation1 = models.ForeignKey(Implantation, 
                            db_column='implantation1', 
                            related_name='implantation1', 
                            blank=True, null=True)
    complement1 = models.TextField(null=True, blank=True)
    responsable_implantation1 = models.IntegerField()
    poste2 = models.ForeignKey('Poste', db_column='poste2', 
                            related_name='poste2', 
                            blank=True, null=True)
    implantation2 = models.ForeignKey(Implantation, 
                            db_column='implantation2', 
                            related_name='implantation2', 
                            null=True, blank=True)
    complement2 = models.TextField(null=True, blank=True)
    responsable_implantation2 = models.IntegerField() 
    # Relations
    service = models.ForeignKey('Service', db_column='service', 
                            blank=True, null=True)
    responsable = models.ForeignKey('Employe', db_column='responsable', 
                            related_name='responsable', 
                            blank=True, null=True)
    remplacement_de = models.ForeignKey('Employe', db_column='remplacement_de', 
                            related_name='remplacement_de', 
                            blank=True, null=True)
    type = models.CharField(max_length=1, choices=TYPE_DOSSIER_CHOICES)
    statut = models.ForeignKey('Statut', db_column='statut', 
                            blank=True, null=True)
    organisme_bstg = models.ForeignKey('OrganismeBstg', 
                            db_column='organisme_bstg', 
                            blank=True, null=True)
    # Rémunération
    classement = models.ForeignKey('Classement', db_column='classement', 
                            blank=True, null=True)
    regime_travail = models.IntegerField()
    # Mandat
    mandat_date_debut = models.DateField()
    mandat_date_fin = models.DateField(null=True, blank=True)
    # Contrat
    contrat_date_debut = models.DateField()
    contrat_date_fin = models.DateField()
    type_contrat = models.ForeignKey('TypeContrat', db_column='type_contrat', 
                            blank=True, null=True)
    # Meta
    date_creation = models.DateField(auto_now_add=True)
    date_maj = models.DateField(auto_now=True)
    commentaire = models.TextField(null=True, blank=True) 

    # Managers
    objects = DossierManager()
    
    def __unicode__(self):
        return u'%s : %s %s' % (self.employe, self.poste1, self.complement1)

    def get_dernier_salaire_remun(self):
        remun = [r for r in self.remuneration_set.all().order_by('-id') if r.type_id == 1] # type salaire de base
        if len(remun) == 0:
            return None
        else:
            return remun[0]

    def get_salaire(self):
        remun = self.get_dernier_salaire_remun()
        if remun is not None:
            return int(remun.montant)
        else:
            return None

    def get_salaire_display(self):
        """
        Moyen rapide de récupérer le salaire correspodant à un dossier. Par contre,
        toutes les rémuérations n'ont pas de devise associées, c'est pourquoi on récupère
        les anciennes rémunérations pour rechercher si elle existait auparavant.
        """
        if self.dernier_salaire_remun() is not None:
            devise_code = self.dernier_salaire_remun().devise.code
        else:
            devise_code = '???'
        return "%s %s" % (self.get_salaire(), devise_code, )

    def get_salaire_euro_display(self):
        """
        Moyen rapide de récupérer le salaire correspodant à un dossier. Par contre,
        toutes les rémuérations n'ont pas de devise associées, c'est pourquoi on récupère
        les anciennes rémunérations pour rechercher si elle existait auparavant.
        La valeur est est affichée en Euros en se servant du taux actuel.
        """
        return "%s EUR" % (self.get_dernier_salaire_remun().en_euros())

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

class AyantDroit(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    nom = models.CharField(max_length=255)
    prenom = models.CharField(max_length=255)
    # Relation
    employe = models.ForeignKey('Employe', db_column='employe', 
                            related_name='employe')
    lien_parente = models.CharField(max_length=10, null=True, blank=True, 
                            choices=LIEN_PARENTE_CHOICES)
    # Méta
    commentaire = models.TextField(null=True, blank=True) 
    actif = models.BooleanField()
    
    
class Remuneration(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    dossier = models.ForeignKey('Dossier', db_column='dossier')
    type = models.ForeignKey('TypeRemuneration', db_column='type')
    type_revalorisation = models.ForeignKey('TypeRevalorisation', 
                            db_column='type_revalorisation', 
                            null=True, blank=True)
    montant = models.FloatField(null=True, blank=True)
    devise = models.ForeignKey('Devise', to_field='id', db_column='devise', null=True, blank=True)
    date_effective = models.DateField(null=True, blank=True)
    pourcentage = models.IntegerField(null=True, blank=True)
    # Méta
    date_creation = models.DateField(auto_now_add=True)
    user_creation = models.IntegerField(null=True, blank=True) #User ou employé
    desactivation = models.NullBooleanField(null=True, blank=True) #
    date_desactivation = models.DateField(null=True, blank=True)
    user_desactivation = models.IntegerField(null=True, blank=True) #User ou employé
    annulation = models.NullBooleanField(null=True, blank=True)
    date_annulation = models.DateField(null=True, blank=True)
    user_annulation = models.IntegerField(null=True, blank=True) #User ou employé
    
    def __unicode__(self):
        try:
            devise = self.devise.code
        except:
            devise = "???"
        return "%s %s (%s EUR - %s)" % (self.montant, devise, self.en_euros(), self.get_taux_historique(), )

    def get_taux_historique(self):
        """
        Retourne le taux en vigueur durant l'année considérée. Un taux de 0 est crée, si le taux de change
        n'existe pas.
        """
        taux = TauxChange.objects.filter(devise=self.devise, annee=self.date_creation.year)
        if len(taux) > 0:
            return taux[0]
        else:   
            return None

    def en_euros(self):
        tauxchange = self.get_taux_historique()
        if tauxchange is not None:
            return int(self.montant * tauxchange.taux)
        else:
            return 0

class FamilleEmploi(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    nom = models.CharField(max_length=255)
    # Méta
    actif = models.BooleanField()

class TypePoste(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    nom = models.CharField(max_length=255)
    nom_feminin = models.CharField(max_length=255)
    description = models.CharField(max_length=255)
    is_responsable = models.BooleanField()
    famille_emploi = models.ForeignKey('FamilleEmploi', 
                            db_column='famille_emploi')
    # Méta
    date_modification = models.DateField(auto_now=True)
    actif = models.BooleanField()

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


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

NATURE_REMUNERATION_CHOICES = (
    ('Accessoire', 'Accessoire'),
    ('Charges', 'Charges'),
    ('Indemnité', 'Indemnité'),
    ('RAS', 'RAS'),
    ('Traitement', 'Traitement'),
)

class TypeRemuneration(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    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)
    # Méta
    actif = models.BooleanField()

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


class TypeRevalorisation(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    nom = models.CharField(max_length=255)
    # Méta
    actif = models.BooleanField()
    
PROPORTION_CHOICES = (
    ('0.5', '0.5'),
    ('1', '1'),
)

class PosteManager(SecurityManager):
    """
    Chargement de tous les objets FK existants sur chaque QuerySet.
    """
    prefixe_implantation = "implantation__region"

    def get_query_set(self):
        fkeys = (
            'implantation',
            'type_poste',
        )
        return super(PosteManager, self).get_query_set().select_related(*fkeys).all()

class Poste(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    implantation = models.ForeignKey(Implantation,
                            db_column='implantation', related_name='+')
    type_poste = models.ForeignKey('TypePoste', db_column='type_poste')
    proportion = models.CharField(max_length=10, choices=PROPORTION_CHOICES)
    #(sert à quoi?) renommer "regime_travail" ou autre?    convertir data en % (data * 100; ex: 1 = 100%)
    # Méta
    date_modification = models.DateField(auto_now=True)
    actif = models.BooleanField()

    # Managers
    objects = PosteManager()

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


class Service(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    nom = models.CharField(max_length=255)
    # Méta
    actif = models.BooleanField()

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


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

class OrganismeBstg(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    nom = models.CharField(max_length=255)
    type = models.CharField(max_length=10, choices=TYPE_ORGANISME_CHOICES)
    # Méta
    actif = models.BooleanField()

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

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


CONTRAT_CATEGORIE_CHOICES= (
    ('A', 'A'),
    ('C', 'C'),
)
class Statut(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    code = models.CharField(max_length=25, unique=True)
    nom = models.CharField(max_length=255)
    type_contrat_categorie = models.CharField(max_length=10, 
                            choices=CONTRAT_CATEGORIE_CHOICES)
    #CHOICES A, C (veut dire quoi?) voir TypeContrat.categorie
    # Méta
    actif = models.BooleanField()

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

TYPE_CLASSEMENT_CHOICES = (
    ('S', 'S'),
    ('T', 'T'),
)

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', ))
        return qs.all()


class Classement(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    type = models.CharField(max_length=10, choices=TYPE_CLASSEMENT_CHOICES)
    echelon = models.IntegerField()
    degre = models.IntegerField()
    coefficient = models.FloatField()
    # Méta
    commentaire = models.TextField(null=True, blank=True) 
    date_modification = models.DateField(auto_now=True)
    actif = models.BooleanField()

    # managers
    objects = ClassementManager()

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

    class Meta:
        ordering = ['type','echelon','degre','coefficient']

class TauxChange(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    devise = models.ForeignKey('Devise', to_field='id', db_column='devise')
    annee = models.IntegerField()
    taux = models.FloatField()
    # Relations
    implantation = models.ForeignKey(Implantation, 
                            db_column='implantation',
                            related_name='taux_change')

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

class ValeurPointManager(models.Manager):
    """
    Manager qui travaille uniquement sur les valeurs du point de l'année en cours.
    """
    mois = datetime.datetime.now().month
    annee_courante = datetime.datetime.now().year

    # Pour le mois de janvier et décembre on mets les 2 années pour faire la transition
    if mois == 1:
        filtre_annee = (annee_courante-1, annee_courante)
    elif mois == 12:
        filtre_annee = (annee_courante, annee_courante+1)
    else:
        filtre_annee = (annee_courante,)

    def get_query_set(self):
        return super(ValeurPointManager, self).get_query_set().select_related('implantation').filter(annee__in=self.filtre_annee)


class ValeurPoint(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    valeur = models.FloatField()
    implantation = models.ForeignKey(Implantation, 
                            db_column='implantation', 
                            related_name='valeurs_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)
    
    def get_tauxchange_courant(self):
        """
        Recherche le taux courant associé à la valeur d'un point.
        Tous les taux de l'année courante sont chargés, pour optimiser un affichage en liste.
        (On pourrait probablement améliorer le manager pour lui greffer le taux courant sous forme de JOIN)
        """
        for tauxchange in self.tauxchange:
            if tauxchange.implantation_id == self.implantation_id:
                return tauxchange
        return None

    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.nom, self.annee)
        
    class Meta:
        ordering = ['valeur']

    objects = models.Manager()
    actuelles = ValeurPointManager()

class DeviseManager(models.Manager):
    """
    On oublie le US et le CAN
    """
    def get_query_set(self):
        return super(DeviseManager, self).get_query_set().exclude(id__in=(3, 15))

class Devise(models.Model):

    objects = DeviseManager()

    id = models.IntegerField(primary_key=True)
    code =  models.CharField(max_length=10, unique=True)
    nom = models.CharField(max_length=255)

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


class TypeContrat(models.Model):
    # Identification
    id = models.IntegerField(primary_key=True)
    nom = models.CharField(max_length=255)
    nom_long = models.CharField(max_length=255) #description
    categorie = models.CharField(max_length=10, 
                            choices=CONTRAT_CATEGORIE_CHOICES)
    # Méta
    actif = models.BooleanField()

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