Ajout modele OffreEmploiEvaluateur et la mécanique

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

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

from auf.django.emploi import models as emploi
from django.contrib.auth.models import User, Group
from django.db import models
from django.db.models.signals import pre_save, pre_delete
from django.dispatch import receiver
from south.modelsinspector import add_introspection_rules
from tinymce import models as tinymce_models

from project.recrutement import groups as recrutement_groups

### 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."

# Pour South
add_introspection_rules([], ["^tinymce.models.HTMLField"])


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 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")

    class Meta:
        verbose_name = u"évaluateur"

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


# Synchro des objets évaluateurs pour mettre les users Django dans le groupe
# évaluateurs, afin d'y mettre des permissions
@receiver(pre_save, sender=Evaluateur)
def sync_add_groupe_evaluateur(sender, **kwargs):
    instance = kwargs['instance']
    user_groups = [g.name for g in instance.user.groups.all()]
    if recrutement_groups.EVALUATEURS not in user_groups:
        grp_evaluateurs = Group.objects.get(name=recrutement_groups.EVALUATEURS)
        instance.user.groups.add(grp_evaluateurs)
        instance.user.save()


@receiver(pre_delete, sender=Evaluateur)
def sync_delete_groupe_evaluateur(sender, **kwargs):
    instance = kwargs['instance']
    grp_evaluateurs = Group.objects.get(name=recrutement_groups.EVALUATEURS)
    instance.user.groups.remove(grp_evaluateurs)
    instance.user.save()


class OffreEmploiEvaluateur(models.Model):
    offre_emploi = models.ForeignKey(emploi.OffreEmploi, db_column='offre_emploi',
                                     verbose_name=u'offre d\'emploi')
    evaluateur = models.ForeignKey(Evaluateur, db_column='evaluateur',
                                   verbose_name=u'évaluateur')

    class Meta:
        unique_together = ('offre_emploi', 'evaluateur')

    def __unicode__(self):
        return u"%s - %s" % (self.offre_emploi, self.evaluateur)

    def save(self):

        if self.pk is None:
            candidats = Candidat.objects.filter(offre_emploi=self.offre_emploi)
            for candidat in candidats:
                print candidat
                print self.evaluateur
                candidat_evaluation, created = CandidatEvaluation.objects.get_or_create(candidat=candidat, evaluateur=self.evaluateur)

        super(OffreEmploiEvaluateur, self).save()

    def delete(self):
        candidats = Candidat.objects.filter(offre_emploi=self.offre_emploi)
        for candidat in candidats:
            CandidatEvaluation.objects.filter(candidat=candidat, evaluateur=self.evaluateur).delete()

        super(OffreEmploiEvaluateur, self).delete()


class CandidatEvaluation(models.Model):
    candidat = models.ForeignKey(emploi.Candidat, db_column='candidat',
                related_name='evaluations',)
    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

    def get_appreciation(self,):
        if self.note is None:
            return u"non disponible"
        return u"%s %s" % (self.note, self.commentaire,)


class MesCandidatEvaluation(CandidatEvaluation):

    class Meta:
        proxy = True
        verbose_name = u"mon candidat à évaluer"
        verbose_name_plural = u"mes candidats à évaluer"


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


class CourrielTemplate(models.Model):
    nom_modele = models.CharField(u'nom du modèle', max_length=100)
    sujet = models.CharField(u'sujet du courriel', max_length=100)
    plain_text = models.TextField(u'texte', help_text=HELP_TEXT_TAGS_ACCEPTES)

    def __unicode__(self):
        return self.nom_modele

    class Meta:
        ordering = ('nom_modele',)
        verbose_name = u"modèle de courriel"
        verbose_name_plural = u"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(
        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 self.titre

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