addition

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

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

import os
from django.core.files.storage import FileSystemStorage
from django.db import models
import reversion
from workflow import PosteWorkflow
import datamaster_modeles.models as ref
from rh_v1 import models as rh
import settings

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

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

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

# 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


class PostePiece(models.Model):
    poste = models.ForeignKey("Poste")
    nom = models.CharField(verbose_name="Nom", max_length=255)
    fichier = models.FileField(verbose_name="Fichier", upload_to=poste_piece_dispatch, storage=storage_prive)

class PosteManager(models.Manager):
    """
    Chargement de tous les objets FK existants sur chaque QuerySet.
    """
    def get_query_set(self):
        fkeys = (
            'id_rh',
            'responsable',
            'implantation',
            'type_poste',
            'service',
            'classement_min',
            'classement_max',
            'valeur_point_min',
            'valeur_point_max',
        )
        return super(PosteManager, self).get_query_set() \
                                        .select_related(*fkeys).all()


class Poste(PosteWorkflow, models.Model):
    # Modèle existant
    id_rh = models.ForeignKey(rh.Poste, null=True, related_name='+',
                              editable=False,
                              verbose_name="Mise à jour du poste")
    nom = models.CharField(verbose_name="Titre du poste", max_length=255)
    implantation = models.ForeignKey(ref.Implantation)
    type_poste = models.ForeignKey(rh.TypePoste, null=True, related_name='+')
    service = models.ForeignKey(rh.Service, related_name='+',
                                verbose_name=u"Direction/Service/Pôle support")
    responsable = models.ForeignKey(rh.Poste, related_name='+',
                                verbose_name="Poste du responsable")

    regime_travail = models.DecimalField(max_digits=12, decimal_places=2,
                                default=100, 
                                verbose_name="Temps de travail", 
                                help_text="% du temps complet")
    regime_travail_nb_heure_semaine = models.DecimalField(max_digits=12,
                                decimal_places=2,
                                default=35,
                                verbose_name="Nb. heures par semaine")

    # Recrutement
    local = models.BooleanField(verbose_name="Local", default=True, blank=True)
    expatrie = models.BooleanField(verbose_name="Expatrié", default=False, blank=True)

    # TODO null?
    mise_a_disposition = models.BooleanField(verbose_name="Mise à disposition")
    appel = models.CharField(max_length=10, default='interne',
                             verbose_name="Appel à candidature",
                             choices=POSTE_APPEL_CHOICES)

    # Rémunération
    classement_min = models.ForeignKey(rh.Classement, related_name='+')
    classement_max = models.ForeignKey(rh.Classement, related_name='+')

    # En fait, les coefficient n'ont pas de valeur dans ces cas, les couts sont calculés
    # et mis dans les coûts globals
    #coefficient_min = models.FloatField(null=True) # pour classement "hors grille"
    #coefficient_max = models.FloatField(null=True) # pour classement "hors grille"

    valeur_point_min = models.ForeignKey(rh.ValeurPoint, related_name='+', blank=True, null=True)
    valeur_point_max = models.ForeignKey(rh.ValeurPoint, related_name='+', blank=True, null=True)
    devise_min = models.ForeignKey(rh.Devise, default=5, related_name='+')
    devise_max = models.ForeignKey(rh.Devise, default=5, related_name='+')
    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(rh.Devise, 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()

    # Validations
    validation_bureau_regional = models.BooleanField(verbose_name="Validation bureau régional")
    validation_bureau_regional_date = models.DateField(blank=True, null=True)
    validation_drh = models.BooleanField(verbose_name="Validation DRH")
    validation_drh_date = models.DateField(blank=True, null=True)
    validation_secretaire_general = models.BooleanField(verbose_name="Validation secrétaire général")
    validation_secretaire_general_date = models.DateField(blank=True, null=True)
    validation_recteur = models.BooleanField(verbose_name="Validation recteur")
    validation_recteur_date = models.DateField(blank=True, null=True)

    # Méta
    date_creation = models.DateTimeField(auto_now_add=True)
    date_modification = models.DateTimeField(auto_now=True)
    date_debut = models.DateField(verbose_name="Date de début",
                                    help_text="format: aaaa-mm-jj")
    date_fin = models.DateField(null=True, blank=True,
                                    verbose_name="Date de fin",
                                    help_text="format: aaaa-mm-jj")
    actif = models.BooleanField(default=True)

    # Managers
    objects = PosteManager()

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

    def get_dossiers(self):
        """
        Liste tous les anciens dossiers liés à ce poste.
        (Le nom de la relation sur le rh.Poste est mal choisi poste1 au lieu de dossier1)
        Note1 : seulement le dosssier principal fait l'objet de la recherche.
        Note2 : les dossiers sont retournés du plus récent au plus vieux. (Ce test est fait
        en fonction du id, car les dates de création sont absentes de rh v1).
        """
        if self.id_rh is None:
            return []
        postes = [p for p in self.id_rh.poste1.all()]
        return sorted(postes, key=lambda poste: poste.id, reverse=True)
            
    def get_complement_nom(self):
        """
        Inspecte les modèles rh v1 pour trouver dans le dernier  dossier un complément de titre de poste.
        """
        dossiers = self.get_dossiers()
        if len(dossiers) > 0:
            nom = dossiers[0].complement1
        else:
            nom = ""
        return nom

    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

    def __unicode__(self):
        """
        Cette fonction est consommatrice SQL car elle cherche les dossiers qui ont été liés à celui-ci.
        """
        complement_nom_poste = self.get_complement_nom()
        if complement_nom_poste is None:
            complement_nom_poste = ""
        employe = self.get_employe()
        if employe is None:
            employe = "VACANT"
        data = (
            self.implantation,
            self.type_poste.nom,
            self.nom,
            self.id,
            complement_nom_poste,
            employe,
        )
        return u'%s - %s (%s) [dae-%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(models.Model):
    poste = models.ForeignKey('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="ex.: 33.33 % (décimale avec point)")
    commentaire = models.TextField(
            help_text="Spécifiez la source de financement.")

    class Meta:
        ordering = ['type']

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


class Employe(models.Model):

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

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


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

class DossierPiece(models.Model):
    dossier = models.ForeignKey("Dossier")
    nom = models.CharField(verbose_name="Nom", max_length=255)
    fichier = models.FileField(verbose_name="Fichier", upload_to=dossier_piece_dispatch, storage=storage_prive)

class Dossier(models.Model):

    # Modèle existant
    employe = models.ForeignKey('Employe', related_name='+', editable=False)
    poste = models.ForeignKey('Poste', related_name='+', editable=False)
    statut = models.ForeignKey(rh.Statut, related_name='+')
    organisme_bstg = models.ForeignKey(rh.OrganismeBstg, 
            null=True, blank=True,
            verbose_name="Organisme", 
            help_text="Si détaché (DET) ou mis à disposition (MAD), \
                    préciser l'organisme.",
            related_name='+')
    organisme_bstg_autre = models.CharField(max_length=255,
        verbose_name="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='Statut antérieur')
    classement_anterieur = models.ForeignKey(
            rh.Classement, related_name='+', null=True, blank=True,
            verbose_name='Classement précédent')
    salaire_anterieur = models.DecimalField(
            max_digits=12, decimal_places=2, null=True, default=None,
            blank=True, verbose_name='Salaire précédent')

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

    # Recrutement
    remplacement = models.BooleanField()
    statut_residence = models.CharField(max_length=10, default='local', 
                                        verbose_name="Statut",
                                        choices=STATUT_RESIDENCE_CHOICES)

    # Rémunération
    classement = models.ForeignKey(rh.Classement, related_name='+',
                                   verbose_name='Classement proposé')
    salaire = models.DecimalField(max_digits=12, decimal_places=2,
                                  verbose_name='Salaire de base',
                                  null=True, default=None)
    devise = models.ForeignKey(rh.Devise, default=5, related_name='+')
    regime_travail = models.DecimalField(max_digits=12, decimal_places=2,
                                         verbose_name="Régime de travail",
                                         help_text="% du temps complet")
    regime_travail_nb_heure_semaine = models.DecimalField(max_digits=12,
            decimal_places=2, verbose_name="Nb. heures par semaine")

    # Contrat
    type_contrat = models.ForeignKey(rh.TypeContrat, related_name='+')
    contrat_date_debut = models.DateField(help_text="format: aaaa-mm-jj")
    contrat_date_fin = models.DateField(null=True, blank=True,
                                        help_text="format: aaaa-mm-jj")

    # Comptes
    compte_compta = models.CharField(max_length=10, default='aucun',
                                    verbose_name=u'Compte comptabilité',
                                    choices=COMPTE_COMPTA_CHOICES)
    compte_courriel = models.BooleanField()
    
    # Méta
    date_creation = models.DateTimeField(auto_now_add=True)
    
    def __unicode__(self):
        return u'%s - %s' % (self.poste.nom, self.employe)

    def get_couts_auf(self):
        """
        On retire les MAD BSTG
        """
        return [r for r in self.remuneration_set.all() if r.type_id not in (2, )]

    def get_aides_auf(self):
        """
        On récupère les MAD BSTG
        """
        return [r for r in self.remuneration_set.all() if r.type_id in (2, )]

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

class Remuneration(models.Model):
    # Identification
    dossier = models.ForeignKey('Dossier', db_column='dossier')
    type = models.ForeignKey(rh.TypeRemuneration, db_column='type',
                             related_name='+')
    # TODO: what's that?
    # type_revalorisation = models.ForeignKey('TypeRevalorisation',
                                            # db_column='type_revalorisation')
    montant = models.DecimalField(max_digits=12, decimal_places=2,
                                  null=True)  # Annuel
    devise = models.ForeignKey(rh.Devise, to_field='code',
                               db_column='devise', related_name='+')
    precision = models.CharField(max_length=255, 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)
    # desactivation = models.BooleanField(default=False, blank=True)
    # date_desactivation = models.DateField(null=True, blank=True)
    # user_desactivation = models.IntegerField(null=True, blank=True)
    # annulation = models.BooleanField(default=False, blank=True)
    # date_annulation = models.DateField(null=True, blank=True)
    # user_annulation = models.IntegerField(null=True, blank=True)

    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)


TYPE_JUSTIFICATIONS = (
    ('N', 'Nouvel employé'),
    ('R', 'Renouvellement employé'),
)

class JustificationQuestion(models.Model):
    question = models.CharField(max_length=255)
    type = models.CharField(max_length=255, choices=TYPE_JUSTIFICATIONS)
    
    def __unicode__(self,):
        return self.question

class JustificationNouvelEmploye(models.Model):
    dossier = models.ForeignKey("Dossier")
    question = models.ForeignKey("JustificationQuestion")
    reponse = models.TextField()

class JustificationAutreEmploye(models.Model):
    dossier = models.ForeignKey("Dossier")
    question = models.ForeignKey("JustificationQuestion")
    reponse = models.TextField()


class Validation(models.Model):
    # user
    date = models.DateField()

    # avis = ? (CHOICES?)


class ValidationPoste(models.Model):
    poste = models.ForeignKey('Poste')


class ValidationEmploye(models.Model):
    employe = models.ForeignKey('Employe')