1750: Un évaluateur doit être assignés à des offres d'emploi et non à des candidats.

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

# -*- encoding: utf-8 -*-

from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect
from django.contrib import admin
from django.shortcuts import get_object_or_404
from django.core.files.storage import default_storage

from reversion.admin import VersionAdmin
from datamaster_modeles.models import Employe, Implantation, Region
from django.forms.models import BaseInlineFormSet

from recrutement.models import *
from recrutement.workflow import grp_administrateurs_recrutement,\
                            grp_evaluateurs_recrutement, grp_drh_recrutement

"""
class MetaAdmin(VersionAdmin):
    def get_actions(self, request):
    
Pour refactoring
"""
class OffreEmploiAdmin(VersionAdmin):
    date_hierarchy = 'date_creation'
    list_display = ('nom', 'resume', 'date_limite', 'region',  'statut', 
                    'est_affiche', '_candidatsList')
    list_filter = ('statut', 'est_affiche', )
    actions = ['affecter_evaluateurs_offre_emploi', ]

    def get_actions(self, request):
        actions = super(OffreEmploiAdmin, self).get_actions(request)
        del actions['delete_selected']
        return actions

    # Affecter un évaluateurs à des offres d'emploi
    def affecter_evaluateurs_offre_emploi(modeladmin, obj, candidats):   
        selected = obj.POST.getlist(admin.ACTION_CHECKBOX_NAME)

        return HttpResponseRedirect(reverse('affecter_evaluateurs_offre_emploi')+
                "?ids=%s" % (",".join(selected)))
    affecter_evaluateurs_offre_emploi.short_description = u'Affecter évaluateur(s)'

    # Afficher la liste des candidats pour l'offre d'emploi
    def _candidatsList(self, obj):     
        return "<a href='%s?offre_emploi__id__exact=%s'>Voir les candidats \
            </a>" % (reverse('admin:recrutement_candidat_changelist'), obj.id)
    _candidatsList.allow_tags = True 
    _candidatsList.short_description = "Afficher la liste des candidats"


    def queryset(self, request):
        qs = self.model._default_manager.get_query_set()
        # Si user est superuser afficher toutes les offres d'emploi  
        user_groupes = request.user.groups.all()
        if not grp_drh_recrutement in user_groupes and \
            not request.user.is_superuser:
            """
            Si le user n'est ni un évaluateur ni un administrateur régional,
            retourner none
            Vérifier groupes
            """
            if grp_evaluateurs_recrutement in user_groupes:
                try:
                    user = Evaluateur.objects.get(user=request.user)               
                except Evaluateur.DoesNotExist:       
                    return qs.none()     
            elif grp_administrateurs_recrutement in user_groupes: 
                try:
                    user = AdministrateurRegional.objects.get(user=request.user)
                except AdministrateurRegional.DoesNotExist:       
                    return qs.none()     
            else:
                return qs.none()   
                      
            if type(user) is AdministrateurRegional:
                region_ids = [g.id for g in user.regions.all()]
                return qs.select_related('offre_emploi').\
                        filter(region__in=region_ids)
            if type(user) is Evaluateur:        
                candidats = [g for g in user.candidats.all()]
                offre_emploi_ids = [c.offre_emploi.id for c in candidats]
                return qs.select_related('offre_emploi').\
                        filter(id__in=offre_emploi_ids)            
            return qs.none()
        return qs.select_related('offre_emploi')

    def has_change_permission(self, request, obj=None):
        user_groupes = request.user.groups.all()
        if grp_drh_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes or \
            request.user.is_superuser:
            return True
        return False   

class ProxyOffreEmploiAdmin(OffreEmploiAdmin):
    list_display = ('nom', 'resume', 'date_limite', 'region', 'statut', 
                    'est_affiche')
    readonly_fields = ('description', 'bureau',
                        'duree_affectation', 'renumeration',
                        'debut_affectation', 'lieu_affectation', 'nom',
                        'resume', 'date_limite', 'region')
    fieldsets = (
        ('Nom', {
            'fields': ('nom', )        
        }),
        ('Description générale', {
            'fields': ('resume','description', 'date_limite', )        
        }),
        ('Coordonnées', {
            'fields': ('lieu_affectation', 'bureau', 'region', )
        }),
        ('Autre', {
            'fields': ('debut_affectation', 'duree_affectation',
                        'renumeration', )
        }),
    )        

    def response_change(self, request, obj):
        response = super(ProxyOffreEmploiAdmin, self).response_change(request, obj)
        user_groupes = request.user.groups.all()
        if grp_drh_recrutement in user_groupes or \
            request.user.is_superuser:
            return HttpResponseRedirect(reverse('admin:recrutement_offreemploi_changelist'))
        return HttpResponseRedirect(reverse('admin:recrutement_proxyoffreemploi_changelist'))

    def has_add_permission(self, request):
        return False

    def has_delete_permission(self, request, obj=None):
        return False

    def has_change_permission(self, request, obj=None):
        user_groupes = request.user.groups.all()
        if grp_evaluateurs_recrutement in user_groupes or \
            grp_drh_recrutement in user_groupes or \
            request.user.is_superuser:
            return True
        return False   

    """class ProxyEvaluateur(Evaluateur.candidats.through):

    Ce proxy sert uniquement dans l'admin à disposer d'un libellé
    plus ergonomique.

    class Meta:
        proxy = True
        verbose_name = "évaluateur"
    """
class CandidatPieceInline(admin.TabularInline):
    model = CandidatPiece
    fields = ('candidat', 'nom', 'path',)
    extra = 1
    max_num = 3

class CandidatEvaluationInlineFormSet(BaseInlineFormSet):
    """
    Empêche la suppression d'une évaluation pour le CandidatEvaluationInline
    """
    def __init__(self, *args, **kwargs):
        super(CandidatEvaluationInlineFormSet, self).__init__(*args, **kwargs)
        self.can_delete = False 

class CandidatEvaluationInline(admin.TabularInline):
    model = CandidatEvaluation
    fields = ('evaluateur', 'note', 'commentaire')
    max_num = 0
    extra = 0
    formset = CandidatEvaluationInlineFormSet
    
    def get_readonly_fields(self, request, obj=None):
        """
        Empêche la modification des évaluations
        """
        if obj:
            return self.readonly_fields+('evaluateur', 'note', 'commentaire')
        return self.readonly_fields


class CandidatAdmin(VersionAdmin):
    date_hierarchy = 'date_creation'
    list_display = ('nom', 'prenom', 'offre_emploi','statut',
                    'voir_offre_emploi', 'calculer_moyenne', 
                    'afficher_candidat',)
    list_filter = ('offre_emploi', )
    fieldsets = (
        ("Offre d'emploi", {
            'fields': ('offre_emploi', )
        }),
        ('Informations personnelles', {
            'fields': ('prenom','nom','genre', 'nationalite',
                        'situation_famille', 'nombre_dependant',)        
        }),
        ('Coordonnées', {
            'fields': ('telephone', 'email', 'adresse', 'ville', 
                        'etat_province', 'code_postal', 'pays', )
        }),
        ('Informations professionnelles', {
            'fields': ('niveau_diplome','employeur_actuel', 
                        'poste_actuel', 'domaine_professionnel',)
        }),  
        ('Traitement', {
            'fields': ('statut', )
        }),
    )
    inlines = [
        CandidatPieceInline,
        CandidatEvaluationInline,
    ]

    actions = ['envoyer_courriel_candidats']

    def get_actions(self, request):
        actions = super(CandidatAdmin, self).get_actions(request)
        del actions['delete_selected']
        return actions

    # Envoyer un courriel à des candidats
    def envoyer_courriel_candidats(modeladmin, obj, candidats):   
        selected = obj.POST.getlist(admin.ACTION_CHECKBOX_NAME)

        return HttpResponseRedirect(reverse('selectionner_template')+
                "?ids=%s" % (",".join(selected)))
    envoyer_courriel_candidats.short_description = u'Envoyer courriel'

    # Évaluer un candidat
    def evaluer_candidat(self, obj):
        return "<a href='%s?candidat__id__exact=%s'>Évaluer le candidat</a>" % \
            (reverse('admin:recrutement_candidatevaluation_changelist'), 
            obj.id)
    evaluer_candidat.allow_tags = True    
    evaluer_candidat.short_description = 'Évaluation'

    # Afficher un candidat
    def afficher_candidat(self, obj):
        return "<a href='%s'>Voir le candidat</a>" % \
            (reverse('admin:recrutement_proxycandidat_change', args=(obj.id,)))
    afficher_candidat.allow_tags = True    
    afficher_candidat.short_description = u'Détails du candidat'

    # Voir l'offre d'emploi
    def voir_offre_emploi(self, obj):
        return "<a href='%s'>Voir l'offre d'emploi</a>" % \
        (reverse('admin:recrutement_proxyoffreemploi_change', 
                    args=(obj.offre_emploi.id,)))
    voir_offre_emploi.allow_tags = True
    voir_offre_emploi.short_description = "Afficher l'offre d'emploi"

    # Calculer la moyenne des notes
    def calculer_moyenne(self, obj):
        evaluations = CandidatEvaluation.objects.filter(candidat=obj)
        offre_emploi = obj.offre_emploi

        notes = [evaluation.note for evaluation in evaluations.all() \
                    if evaluation.note is not None]
 
        if len(notes) > 0 and offre_emploi.date_limite <= datetime.date.today():
            moyenne_votes = float(sum(notes)) / len(notes)
        else:
            moyenne_votes = "Non disponible"
        return moyenne_votes
    calculer_moyenne.allow_tags = True
    calculer_moyenne.short_description = "Moyenne des notes"

    def add_delete_permission(self, request, obj=None) :
        user_groupes = request.user.groups.all()
        if grp_drh_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes or \
            request.user.is_superuser:
            return True
        return False    

    def has_add_permission(self, request):
        return self.add_delete_permission(request, request)

    def has_delete_permission(self, request, obj=None):
        return self.add_delete_permission(request, request)

    def has_change_permission(self, request, obj=None):
        user_groupes = request.user.groups.all()
        if grp_drh_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes or \
            request.user.is_superuser:
            return True
        return False   

    def queryset(self, request):
        """
        Spécifie un queryset limité, autrement Django exécute un 
        select_related() sans paramètre, ce qui a pour effet de charger tous 
        les objets FK, sans limite de profondeur. Dès qu'on arrive, dans les 
        modèles de Region, il existe plusieurs boucles, ce qui conduit à la 
        génération d'une requête infinie.
        
        """
        qs = self.model._default_manager.get_query_set() 
        # Si user est superuser afficher tous les candidats       
        user_groupes = request.user.groups.all()
        if not grp_drh_recrutement in user_groupes and \
            not request.user.is_superuser:
            # Si le user n'est ni un évaluateur ni un administrateur régional,
            # retourner none

            # Vérifier groupes
            if grp_evaluateurs_recrutement in user_groupes:
                try:
                    user = Evaluateur.objects.get(user=request.user)
                except Evaluateur.DoesNotExist:       
                    return qs.none()       
                """
                elif grp_administrateurs_recrutement in user_groupes: 
                    try:
                        user = AdministrateurRegional.objects.get(user=obj.user)
                    except AdministrateurRegional.DoesNotExist:       
                        return qs.none()    
                """
            else:
                return qs.none()   
            ids = [c.id for c in user.candidats.all()]
            return qs.select_related('candidats').filter(id__in=ids)               
        return qs.select_related('candidats')         

class ProxyCandidatAdmin(CandidatAdmin):
    readonly_fields = ('statut', 'offre_emploi', 'prenom', 'nom',
                        'genre', 'nationalite', 'situation_famille', 
                        'nombre_dependant', 'telephone', 'email', 'adresse', 
                        'ville', 'etat_province', 'code_postal', 'pays', 
                        'niveau_diplome', 'employeur_actuel', 'poste_actuel',
                        'domaine_professionnel', 'pieces_jointes',)
    fieldsets = (
        ("Offre d'emploi", {
            'fields': ('offre_emploi', )
        }),
        ('Informations personnelles', {
            'fields': ('prenom','nom','genre', 'nationalite',
                        'situation_famille', 'nombre_dependant',)        
        }),
        ('Coordonnées', {
            'fields': ('telephone', 'email', 'adresse', 'ville', 
                        'etat_province', 'code_postal', 'pays', )
        }),
        ('Informations professionnelles', {
            'fields': ('niveau_diplome','employeur_actuel', 
                        'poste_actuel', 'domaine_professionnel',)
        }),   
    )
    inlines = []

    def response_change(self, request, obj):
        response = super(ProxyCandidatAdmin, self).response_change(request, obj)
        user_groupes = request.user.groups.all()
        if grp_drh_recrutement in user_groupes or \
            request.user.is_superuser:
            return HttpResponseRedirect(reverse('admin:recrutement_candidat_changelist'))
        return HttpResponseRedirect(reverse('admin:recrutement_proxycandidat_changelist'))

    def has_add_permission(self, request):
        return False

    def has_delete_permission(self, request, obj=None):
        return False

    def has_change_permission(self, request, obj=None):
        user_groupes = request.user.groups.all()
        if grp_drh_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes or \
            grp_evaluateurs_recrutement in user_groupes or \
            request.user.is_superuser:
            return True
        return False   

class CandidatPieceAdmin(admin.ModelAdmin):
    list_display = ('nom', 'candidat', )

    def queryset(self, request):
        """
        Spécifie un queryset limité, autrement Django exécute un 
        select_related() sans paramètre, ce qui a pour effet de charger tous 
        les objets FK, sans limite de profondeur. Dès qu'on arrive, dans les 
        modèles de Region, il existe plusieurs boucles, ce qui conduit à la 
        génération d'une requête infinie.
        Affiche la liste de candidats que si le user connecté 
        possède un Evaluateur
        """
        qs = self.model._default_manager.get_query_set()
        return qs.select_related('candidat')

class EvaluateurAdmin(VersionAdmin):
    fieldsets = (
        ("Utilisateur", {
            'fields': ('user',)
        }),
        ("Offres d'emploi à évaluer", {
            'fields': ('offres_emploi',)
        }),
    )

    def get_actions(self, request):
        actions = super(EvaluateurAdmin, self).get_actions(request)
        del actions['delete_selected']
        return actions

class AdministrateurRegionalAdmin(VersionAdmin):
    pass

class CandidatEvaluationAdmin(VersionAdmin):
    list_display = ('_candidat', '_offre_emploi', 'evaluateur', '_note', 
                    '_commentaire', )
    readonly_fields = ('candidat', 'evaluateur')
    fieldsets = (
        ('Évaluation du candidat', {
            'fields': ('candidat', 'evaluateur', 'note', 'commentaire', )        
        }),
    )

    def get_actions(self, request):
        actions = super(CandidatEvaluationAdmin, self).get_actions(request)
        del actions['delete_selected']
        return actions

    def _note(self, obj):
        """
        Si l'évaluateur n'a pas encore donné de note au candidat, indiquer
        un lien pour Évaluer le candidat.
        Sinon afficher la note.
        """
        evaluateur = obj.evaluateur
        candidat = obj.candidat
        candidat_evaluation = CandidatEvaluation.objects.\
                                get(candidat=candidat, evaluateur=evaluateur)
        if obj.note is None:
            return "<a href='%s'>Candidat non évalué</a>" % \
                (reverse('admin:recrutement_candidatevaluation_change', 
                args=(candidat_evaluation.id,)))
        return "<a href='%s'>%s</a>" % \
            (reverse('admin:recrutement_candidatevaluation_change', 
            args=(candidat_evaluation.id,)), obj.note)
        return 
    _note.allow_tags = True
    _note.short_description = "Votre note"    
    _note.admin_order_field = 'note'    

    def _candidat(self, obj):
        return "<a href='%s'>%s</a>" \
            % (reverse('admin:recrutement_proxycandidat_change', 
                        args=(obj.candidat.id,)), obj.candidat)
    _candidat.allow_tags = True    
    _candidat.short_description = 'Candidat'

    def _commentaire(self, obj):
        """
        Si l'évaluateur n'a pas encore donné de note au candidat, indiquer
        dans le champ commentaire, Aucun au lieu de (None)
        Sinon afficher la note.
        """
        if obj.commentaire is None:
            return "Aucun"
        return obj.commentaire
    _commentaire.allow_tags = True
    _commentaire.short_description = "Commentaire"   


    def _offre_emploi(self, obj):
        return "<a href='%s'>%s</a>" % \
        (reverse('admin:recrutement_proxyoffreemploi_change', 
            args=(obj.candidat.offre_emploi.id,)), obj.candidat.offre_emploi)
    _offre_emploi.allow_tags = True
    _offre_emploi.short_description = "Voir offre d'emploi"
    
    def has_change_permission(self, request, obj=None):
        """
        Permettre la visualisation dans la changelist
        mais interdire l'accès à modifier l'objet si l'évaluateur n'est pas
        le request.user
        """
        return obj is None or request.user == obj.evaluateur.user

    def queryset(self, request):
        """
        Afficher uniquement les évaluations de l'évaluateur, sauf si 
        l'utilisateur est super admin.
        """
        qs = self.model._default_manager.get_query_set()
        user_groupes = request.user.groups.all()
        if grp_drh_recrutement in user_groupes  or \
            request.user.is_superuser:
            return qs.select_related('offre_emploi')

        try:
            evaluateur = Evaluateur.objects.get(user=request.user) 
        except Evaluateur.DoesNotExist:       
            return qs.none()     
        
        candidats_evaluations = CandidatEvaluation.objects.\
                                filter(evaluateur=evaluateur)
        candidats_evaluations_ids = [ce.id for ce in \
                                        candidats_evaluations.all()]
        return qs.select_related('offre_emploi').\
                filter(id__in=candidats_evaluations_ids)

class CourrielTemplateAdmin(VersionAdmin):
    def get_actions(self, request):
        actions = super(CourrielTemplateAdmin, self).get_actions(request)
        del actions['delete_selected']
        return actions

admin.site.register(OffreEmploi, OffreEmploiAdmin)
admin.site.register(ProxyOffreEmploi, ProxyOffreEmploiAdmin)
admin.site.register(Candidat, CandidatAdmin)
admin.site.register(ProxyCandidat, ProxyCandidatAdmin)
admin.site.register(CandidatEvaluation, CandidatEvaluationAdmin)
admin.site.register(Evaluateur, EvaluateurAdmin)
#admin.site.register(AdministrateurRegional, AdministrateurRegionalAdmin)
admin.site.register(CourrielTemplate, CourrielTemplateAdmin)