chmod

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

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

import datetime
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from tinymce import models as tinymce_models
from django.db import models
import settings

from south.modelsinspector import add_introspection_rules
add_introspection_rules([], ["^tinymce.models.HTMLField"])
import datamaster_modeles.models as ref

from project.rh import models as rh
from recrutement.workflow import grp_evaluateurs_recrutement
from auf.django.emploi import models as emploi
from auf.django.emploi.models import TYPE_PIECE_CHOICES

from recrutement.workflow import grp_evaluateurs_recrutement

### CONSTANTES
#NOTES
NOTE_MIN = 1
NOTE_RANGE = 1
NOTE_MAX = 11
NOTES = [(i, i) for i in range(NOTE_MIN, NOTE_MAX, NOTE_RANGE)]

#HELP_TEXT
HELP_TEXT_NB_DEPENDANT = "Le nombre de personnes à charge"
HELP_TEXT_TAGS_ACCEPTES = "Pour le texte, les variables disponibles sont : \
                            {{ nom_candidat }} {{ prenom_candidat }} \
                            {{ offre_emploi }} et {{ genre_candidat }} \
                            (Pour Monsieur/Madame). Ces champs seront \
                            automatiquement remplacés par les informations de \
                            chaque candidat."

# Abstracts
class Metadata(models.Model):
    """Méta-données AUF.
    Metadata.actif = flag remplaçant la suppression.
    actif == False : objet réputé supprimé.
    """
    actif = models.BooleanField(default=True)
    date_creation = models.DateField(auto_now_add=True, )
    
    class Meta:
        abstract = True

class Candidat(emploi.Candidat):
    class Meta:
        proxy = True

    def moyenne_notes(self):
        evaluations = CandidatEvaluation.objects.filter(candidat=self)
        notes = [evaluation.note for evaluation in evaluations.all() \
                    if evaluation.note is not None]

        if len(notes) > 0:
            moyenne_votes = float(sum(notes)) / len(notes)
        else:
            moyenne_votes = "Non disponible"
        return moyenne_votes

class OffreEmploi(emploi.OffreEmploi):
    class Meta:
        proxy = True


class CandidatPiece(emploi.CandidatPiece):
    class Meta:
        proxy = True

class OffreEmploiManager(models.Manager):
    def get_query_set(self):
        fkeys = ('region',)
        return super(OffreEmploiManager, self).get_query_set().\
                    select_related(*fkeys).all()

class ProxyOffreEmploi(emploi.OffreEmploi):
    class Meta:
        proxy = True
        verbose_name = u"Offre d'emploi (visualisation)"
        verbose_name_plural = u"Offres d'emploi (visualisation)"

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

class ProxyCandidat(emploi.Candidat):
    class Meta:
        proxy = True
        verbose_name = u"Candidat (visualisation)"
        verbose_name_plural = u"Candidats (visualisation)"

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

class Evaluateur(models.Model):
    user = models.ForeignKey(User, unique=True, verbose_name=u"Évaluateur")
    offres_emploi = models.ManyToManyField(emploi.OffreEmploi, 
                related_name="evaluateurs", blank=True)

    def save(self, *args, **kwargs):
        """
        Assigner automatiquement l'évaluateurs d'une offre d'emploi à un 
        nouveau candidat.
        """
        self.user.groups.add(grp_evaluateurs_recrutement)
        super(Evaluateur, self).save(*args, **kwargs)
    
    class Meta:
        verbose_name = u"évaluateur"

    def __unicode__(self):
        return '%s %s' % (self.user.first_name, self.user.last_name)

class CandidatEvaluation(models.Model):
    candidat = models.ForeignKey(emploi.Candidat, db_column='candidat', 
                related_name='+',) 
    evaluateur = models.ForeignKey(Evaluateur, db_column='evaluateur', 
                    related_name='+', verbose_name=u'Évaluateur') 
    note = models.IntegerField(choices=NOTES, blank=True, null=True)
    commentaire = models.TextField(null=True, blank=True, default='Aucun')
    date = models.DateField(auto_now_add=True,)  

    class Meta:
        verbose_name = u'évaluation du candidat'
        verbose_name_plural = u'évaluations des candidats'

    def __unicode__(self):
        return u"Évaluation de %s" % self.candidat

#### TEMPLATE COURRIEL
TEMPLATE_CHOICES = (
    ('SEL', 'Sélectionné'),
    ('REF', 'Refusé'),
)

class CourrielTemplate(models.Model):
    nom_modele = models.CharField(max_length=100, verbose_name=u'Nom du modèle',)
    sujet = models.CharField(max_length=100, verbose_name=u'Sujet du courriel')
    plain_text = models.TextField(verbose_name=u'Texte', 
                                    help_text=HELP_TEXT_TAGS_ACCEPTES,  )
    html = tinymce_models.HTMLField(verbose_name=u'Texte en HTML', 
                                    help_text=HELP_TEXT_TAGS_ACCEPTES,  )


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

    class Meta:
        ordering = ['nom_modele',]
        verbose_name = "Modèle de courriel"
        verbose_name_plural = "Modèles de courriel"

class CandidatCourriel(models.Model):
    candidats = models.ManyToManyField(Candidat, verbose_name=u"Candidats", )
    template = models.ForeignKey(CourrielTemplate, db_column='template', 
                related_name='+', verbose_name=u"Modèle de courriel", )
    sujet = models.CharField(max_length=255, blank=True, 
                                help_text=HELP_TEXT_TAGS_ACCEPTES, )
    plain_text = models.TextField(verbose_name=u'Texte', blank=True,
                                    help_text=HELP_TEXT_TAGS_ACCEPTES,  )
    html = tinymce_models.HTMLField(verbose_name=u'Texte en HTML', null=True, 
                                blank=True, help_text=HELP_TEXT_TAGS_ACCEPTES, )

    def __unicode__(self):
        return '%s' % (self.titre)

    class Meta:
        verbose_name = u"modèle de courriel"
        verbose_name_plural = u"modèles de courriel"