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

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

import os
from django.conf import settings
from django.core.files.storage import FileSystemStorage
from django.db import models
import reversion
from rh import models as rh
from workflow import PosteWorkflow, DossierWorkflow
from workflow import DOSSIER_ETAT_DRH_FINALISATION, DOSSIER_ETAT_REGION_FINALISATION, \
                     DOSSIER_ETAT_FINALISE
import auf.django.references.models as ref
from auf.django.metadata.models import AUFMetadata
from managers import *
from rh.models import HELP_TEXT_DATE


# Upload de fichiers
UPLOAD_STORAGE = FileSystemStorage(settings.PRIVE_MEDIA_ROOT)


### POSTE

POSTE_APPEL_CHOICES = (
    ('interne', 'Interne'),
    ('externe', 'Externe'),
)
POSTE_ACTION = (
    ('N', u"Nouveau poste"),
    ('M', u"Poste existant"),
    ('E', u"Évolution de poste"),
)


class DeviseException(Exception):
  silent_variable_failure = True


class Poste(PosteWorkflow, rh.Poste_):

    type_intervention = models.CharField(max_length=1, choices=POSTE_ACTION, default='N')

    # Modèle existant
    id_rh = models.ForeignKey(rh.Poste, null=True, related_name='+',
                            editable=False,
                            verbose_name=u"Mise à jour du poste")

    # Rémunération
    indemn_expat_min = models.DecimalField(max_digits=13, decimal_places=2, default=0)
    indemn_expat_max = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    indemn_fct_min = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    indemn_fct_max = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    charges_patronales_min = models.DecimalField(max_digits=12, decimal_places=2, default=0)
    charges_patronales_max = models.DecimalField(max_digits=12, decimal_places=2, default=0)

    # Managers
    objects = PosteManager()


    def est_importe(self):
        """Test si le poste a déjà été importé"""
        return ImportPoste.objects.filter(dae=self).exists()

    def importer(self):
        from django.db.models import AutoField
        if self.est_importe():
            return ImportPoste.objects.get(dae=self)
        rh_poste = rh.Poste()
        # Faire une copie profonde de l'objet.
        # PosteFinancement, PosteComparaison, Remun modele a ajuster...

        def copy_model(src, dst, exclude=[]):
            keys = [f.name for f in src._meta.fields if f.name not in ['id', ] + exclude]
            for k in keys:
                setattr(dst, k, getattr(src, k))
            return dst
        
        rh_poste = copy_model(self, rh_poste)
        rh_poste.save()
        print rh_poste.id

        for o in self.dae_financements.all():
            rh_financement = rh.PosteFinancement()
            rh_financement = copy_model(o, rh_financement, exclude=['poste',])
            rh_financement.poste = rh_poste
            rh_financement.save()

        for o in self.dae_pieces.all():
            rh_piece = rh.PostePiece()
            rh_piece = copy_model(o, rh_piece, exclude=['poste',])
            rh_piece.poste = rh_poste
            rh_piece.save()

        for o in self.dae_comparaisons_internes.all():
            rh_comp = rh.PosteComparaison()
            rh_comp = copy_model(o, rh_financement, exclude=['poste',])
            rh_comp.poste = rh_poste
            rh_comp.save()

        return rh_poste

    def _get_key(self):
        """
        Les vues sont montées selon une clef spéciale
        pour identifier la provenance du poste.
        Cette méthode fournit un moyen de reconstruire cette clef
        afin de générer les URLs.
        """
        return "dae-%s" % self.id
    key = property(_get_key)

    def get_dossiers(self):
        """
        Liste tous les anciens dossiers liés à ce poste.
        (Le nom de la relation sur le rh.Poste est mal choisi
        poste1 au lieu de dossier1)
        Note1 : seulement le dosssier principal fait l'objet de la recherche.
        Note2 : les dossiers sont retournés du plus récent au plus vieux.
        (Ce test est fait en fonction du id,
        car les dates de création sont absentes de rh v1).
        """
        if self.id_rh is None:
            return []
        return self.id_rh.rh_dossiers.all()


    def get_employe(self):
        """
        Inspecte les modèles rh v1 pour trouver l'employé du dernier dossier.
        """
        dossiers = self.get_dossiers()
        if len(dossiers) > 0:
            return dossiers[0].employe
        else:
            return None

    def get_default_devise(self):
        """Récupère la devise par défaut en fonction de l'implantation
        (EUR autrement)
        """
        try:
            implantation_devise = rh.TauxChange.objects \
                            .filter(implantation=self.implantation)[0].devise
        except:
            implantation_devise = 5 # EUR
        return implantation_devise

    #####################
    # Classement de poste
    #####################

    def get_couts_minimum(self):
        return self.salaire_min + self.indemn_expat_min + self.indemn_fct_min + self.charges_patronales_min + self.autre_min

    def get_salaire_minimum(self):
        return self.get_couts_minimum() - self.charges_patronales_min

    def get_taux_minimum(self):
        if self.devise_min.code == 'EUR':
          return 1
        liste_taux = self.devise_min.tauxchange_set.order_by('-annee')
        if len(liste_taux) == 0:
            raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise_min, self.implantation))
        else:
            return liste_taux[0].taux

    def get_couts_minimum_euros(self):
        return float(self.get_couts_minimum()) * self.get_taux_minimum()

    def get_salaire_minimum_euros(self):
        return float(self.get_salaire_minimum()) * self.get_taux_minimum()

    def get_couts_maximum(self):
        return self.salaire_max + self.indemn_expat_max + self.indemn_fct_max + self.charges_patronales_max + self.autre_max

    def get_salaire_maximum(self):
        return self.get_couts_maximum() - self.charges_patronales_max

    def get_taux_maximum(self):
        if self.devise_max.code == 'EUR':
          return 1
        liste_taux = self.devise_max.tauxchange_set.order_by('-annee')
        if len(liste_taux) == 0:
            raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise_max, self.implantation))
        else:
            return liste_taux[0].taux

    def get_couts_maximum_euros(self):
        return float(self.get_couts_maximum()) * self.get_taux_maximum()

    def get_salaire_maximum_euros(self):
        return float(self.get_salaire_maximum()) * self.get_taux_maximum()

    def show_taux_minimum(self):
        try:
            return self.get_taux_minimum()
        except DeviseException, e:
            return e

    def show_couts_minimum_euros(self):
        try:
            return self.get_couts_minimum_euros()
        except DeviseException, e:
            return e

    def show_salaire_minimum_euros(self):
        try:
            return self.get_salaire_minimum_euros()
        except DeviseException, e:
            return e

    def show_taux_maximum(self):
        try:
            return self.get_taux_maximum()
        except DeviseException, e:
            return e

    def show_couts_maximum_euros(self):
        try:
            return self.get_couts_maximum_euros()
        except DeviseException, e:
            return e

    def show_salaire_maximum_euros(self):
        try:
            return self.get_salaire_maximum_euros()
        except DeviseException, e:
            return e


    ######################
    # Comparaison de poste
    ######################

    def est_comparable(self):
        """
        Si on a au moins une valeur de saisie dans les comparaisons, alors le poste
        est comparable.
        """
        if self.comp_universite_min is None and \
           self.comp_fonctionpub_min is None and \
           self.comp_locale_min is None and \
           self.comp_ong_min is None and \
           self.comp_autre_min is None and \
           self.comp_universite_max is None and \
           self.comp_fonctionpub_max is None and \
           self.comp_locale_max is None and \
           self.comp_ong_max is None and \
           self.comp_autre_max is None:
            return False
        else:
            return True


    def get_taux_comparaison(self):
        try:
            return rh.TauxChange.objects.filter(devise=self.devise_comparaison)[0].taux
        except:
            return 1

    def get_comp_universite_min_euros(self):
        return (float)(self.comp_universite_min) * self.get_taux_comparaison()

    def get_comp_fonctionpub_min_euros(self):
        return (float)(self.comp_fonctionpub_min) * self.get_taux_comparaison()

    def get_comp_locale_min_euros(self):
        return (float)(self.comp_locale_min) * self.get_taux_comparaison()

    def get_comp_ong_min_euros(self):
        return (float)(self.comp_ong_min) * self.get_taux_comparaison()

    def get_comp_autre_min_euros(self):
        return (float)(self.comp_autre_min) * self.get_taux_comparaison()

    def get_comp_universite_max_euros(self):
        return (float)(self.comp_universite_max) * self.get_taux_comparaison()

    def get_comp_fonctionpub_max_euros(self):
        return (float)(self.comp_fonctionpub_max) * self.get_taux_comparaison()

    def get_comp_locale_max_euros(self):
        return (float)(self.comp_locale_max) * self.get_taux_comparaison()

    def get_comp_ong_max_euros(self):
        return (float)(self.comp_ong_max) * self.get_taux_comparaison()

    def get_comp_autre_max_euros(self):
        return (float)(self.comp_autre_max) * self.get_taux_comparaison()


    def __unicode__(self):
        """
        Cette fonction est consommatrice SQL car elle cherche les dossiers
        qui ont été liés à celui-ci.
        """
        data = (
            self.implantation,
            self.type_poste.nom,
            self.nom,
        )
        return u'%s - %s (%s)' % data


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


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

class PosteFinancement(rh.PosteFinancement_):
    pass

class PostePiece(rh.PostePiece_):
    pass

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

### EMPLOYÉ/PERSONNE

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

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

class Employe(AUFMetadata):

    # Modèle existant
    id_rh = models.ForeignKey(rh.Employe, null=True, related_name='+',
                            verbose_name=u'Employé')
    nom = models.CharField(max_length=255)
    prenom = models.CharField(max_length=255, verbose_name=u'Prénom')
    genre = models.CharField(max_length=1, choices=GENRE_CHOICES)

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


### DOSSIER

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

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

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

    # Données antérieures de l'employé
    statut_anterieur = models.ForeignKey(
            rh.Statut, related_name='+', null=True, blank=True,
            verbose_name=u'Statut antérieur')
    classement_anterieur = models.ForeignKey(
            rh.Classement, related_name='+', null=True, blank=True,
            verbose_name=u'Classement précédent')
    salaire_anterieur = models.DecimalField(
            max_digits=12, decimal_places=2, null=True, default=None,
            blank=True, verbose_name=u'Salaire précédent')
    devise_anterieur = models.ForeignKey(rh.Devise, related_name='+', 
            null=True, blank=True)
    type_contrat_anterieur = models.ForeignKey(rh.TypeContrat, 
            related_name='+', null=True, blank=True, 
            verbose_name=u'Type contrat antérieur', )

    # Données du titulaire précédent
    employe_anterieur = models.ForeignKey(
            rh.Employe, related_name='+', null=True, blank=True,
            verbose_name=u'Employé précédent')
    statut_titulaire_anterieur = models.ForeignKey(
            rh.Statut, related_name='+', null=True, blank=True,
            verbose_name=u'Statut titulaire précédent')
    classement_titulaire_anterieur = models.ForeignKey(
            rh.Classement, related_name='+', null=True, blank=True,
            verbose_name=u'Classement titulaire précédent')
    salaire_titulaire_anterieur = models.DecimalField(
            max_digits=12, decimal_places=2, default=None, null=True,
            blank=True, verbose_name=u'Salaire titulaire précédent')
    devise_titulaire_anterieur = models.ForeignKey(rh.Devise, related_name='+', null=True, blank=True)

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

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

    # Justifications
    justif_nouveau_statut_label = u'Justifier le statut que ce type de poste nécessite (national, expatrié, màd ou détachement)'
    justif_nouveau_statut = models.TextField(verbose_name=justif_nouveau_statut_label, null=True, blank=True)
    justif_nouveau_tmp_remplacement_label = u"Si l'employé effectue un remplacement temporaire, préciser"
    justif_nouveau_tmp_remplacement = models.TextField(verbose_name=justif_nouveau_tmp_remplacement_label, null=True, blank=True)
    justif_nouveau_salaire_label = u"Si le salaire de l'employé ne correspond pas au classement du poste ou est différent du salaire antérieur, justifier "
    justif_nouveau_salaire = models.TextField(verbose_name=justif_nouveau_salaire_label, null=True, blank=True)
    justif_nouveau_commentaire_label = u"COMMENTAIRES ADDITIONNELS"
    justif_nouveau_commentaire = models.TextField(verbose_name=justif_nouveau_commentaire_label, null=True, blank=True)
    justif_rempl_type_contrat_label = u"Changement de type de contrat, ex : d'un CDD en CDI"
    justif_rempl_type_contrat = models.TextField(verbose_name=justif_rempl_type_contrat_label, null=True, blank=True)
    justif_rempl_statut_employe_label = u"Si le statut de l'employé a été modifié pour ce poste ; ex :national, expatrié, màd, détachement ? Si oui, justifier"
    justif_rempl_statut_employe = models.TextField(verbose_name=justif_rempl_statut_employe_label, null=True, blank=True)
    justif_rempl_evaluation_label = u"L'évaluation de l'employé est-elle favorable? Préciser"
    justif_rempl_evaluation = models.TextField(verbose_name=justif_rempl_evaluation_label, null=True, blank=True)
    justif_rempl_salaire_label = u"Si le salaire de l'employé est modifié et/ou ne correspond pas à son classement, justifier"
    justif_rempl_salaire = models.TextField(verbose_name=justif_rempl_salaire_label, null=True, blank=True)
    justif_rempl_commentaire_label = u"COMMENTAIRES ADDITIONNELS"
    justif_rempl_commentaire = models.TextField(verbose_name=justif_rempl_commentaire_label, null=True, blank=True)

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

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

    # Managers
    objects = DossierManager()

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

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

    def est_importe(self):
        """Test si le dossier a déjà été importé"""
        return dae.ImportDossier.objects.filter(dae=self).exists()

    def importer(self):
        if not self.poste.est_importe():
            raise Exception('Le poste de cette DAE doît être importé')
        return True

    def taux_devise(self):
        if self.devise.code == 'EUR':
          return 1
        liste_taux = self.devise.tauxchange_set.order_by('-annee')
        if len(liste_taux) == 0:
            raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise, self.poste.implantation))
        else:
            return liste_taux[0].taux

    def get_salaire_anterieur_euros(self):
        if self.devise_anterieur.code == 'EUR':
          tx = 1
        else:
            liste_taux = self.devise_anterieur.tauxchange_set.order_by('-annee')
            if len(liste_taux) == 0:
                raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise_anterieur, self.poste.implantation))
            tx = liste_taux[0].taux
        return (float)(tx) * (float)(self.salaire_anterieur)

    def get_salaire_titulaire_anterieur_euros(self):
        if self.devise_titulaire_anterieur is None:
            return None
        if self.devise_titulaire_anterieur.code == 'EUR':
          tx = 1
        else:
            liste_taux = self.devise_titulaire_anterieur.tauxchange_set.order_by('-annee')
            if len(liste_taux) == 0:
                raise DeviseException(u"La devise %s n'a pas de taux pour l'implantation %s" % (self.devise_titulaire_anterieur, self.poste.implantation))
            tx = liste_taux[0].taux
        return (float)(tx) * (float)(self.salaire_titulaire_anterieur)

    def get_salaire_euros(self):
        tx = self.taux_devise()
        return (float)(tx) * (float)(self.salaire)

    def get_remunerations_brutes(self):
        """
        1   Salaire de base
        3   Indemnité de base
        4   Indemnité d'expatriation
        5   Indemnité pour frais
        6   Indemnité de logement
        7   Indemnité de fonction
        8   Indemnité de responsabilité
        9   Indemnité de transport
        10  Indemnité compensatrice
        11  Indemnité de subsistance
        12  Indemnité différentielle
        13  Prime d'installation
        14  Billet d'avion
        15  Déménagement
        16  Indemnité de départ
        18  Prime de 13ième mois
        19  Prime d'intérim
        """
        ids = [1,3,4,5,6,7,8,9,10,11,12,13,14,15,16,18,19]
        return [r for r in self.dae_remunerations.all() if r.type_id in ids]

    def get_charges_salariales(self):
        """
        20 Charges salariales ?
        """
        ids = [20, ]
        return [r for r in self.dae_remunerations.all() if r.type_id in ids]

    def get_total_charges_salariales(self):
        total = 0.0
        for r in self.get_charges_salariales():
            total += r.montant_euro()
        return total

    def get_charges_patronales(self):
        """
        17  Charges patronales
        """
        ids = [17, ]
        return [r for r in self.dae_remunerations.all() if r.type_id in ids]

    def get_total_charges_patronales(self):
        total = 0.0
        for r in self.get_charges_patronales():
            total += r.montant_euro()
        return total

    def get_salaire_brut(self):
        """
        somme des rémuérations brutes
        """
        total = 0.0
        for r in self.get_remunerations_brutes():
            total += r.montant_euro()
        return total

    def get_salaire_net(self):
        """
        salaire brut - charges salariales
        """
        total_charges = 0.0
        for r in self.get_charges_salariales():
            total_charges += r.montant_euro()
        return self.get_salaire_brut() - total_charges

    def get_couts_auf(self):
        """
        salaire net + charges patronales
        """
        total_charges = 0.0
        for r in self.get_charges_patronales():
            total_charges += r.montant_euro()
        return self.get_salaire_net() + total_charges

    def get_remunerations_tierces(self):
        """
        2   Salaire MAD
        """
        return [r for r in self.dae_remunerations.all() if r.type_id in (2, )]

    def get_total_remunerations_tierces(self):
        total = 0.0
        for r in self.get_remunerations_tierces():
            total += r.montant_euro()
        return total

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


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

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

class DossierComparaison(rh.DossierComparaison_):
    """
    Photo d'une comparaison salariale au moment de l'embauche.
    """
    statut = models.ForeignKey(rh.Statut, related_name='+', verbose_name='Statut', null=True, blank=True, )
    classement = models.ForeignKey(rh.Classement, related_name='+', verbose_name='Classement', null=True, blank=True, )


### RÉMUNÉRATION

class Remuneration(rh.Remuneration_):
    pass

### CONTRATS

class Contrat(rh.Contrat_):
    pass

# modèle de liaison entre les systèmes

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

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