1702: Un administrateur ne devrait pas être en mesure de modifier la note d'un évaluateur

[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 reversion.admin import VersionAdmin
from datamaster_modeles.models import Employe, Implantation, Region

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

class OffreEmploiAdmin(VersionAdmin):
    date_hierarchy = 'date_creation'
    list_display = ('nom', 'resume', 'date_limite', 'statut', 'est_affiche', 
                    'region', '_candidatsList')
    list_filter = ('statut', 'est_affiche', )
    actions = ['affecter_evaluateurs_offre_emploi', ]
    # 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:
            """
            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:
            return True
        return False   

class ProxyOffreEmploiAdmin(OffreEmploiAdmin):
    list_display = ('nom', 'resume', 'date_limite', 'region', )
    readonly_fields = ('description', 'poste', 'bureau',
                        'duree_affectation', 'renumeration',
                        'debut_affectation', 'lieu_affectation', 'nom',
                        'resume', 'date_limite', 'region')
    fieldsets = (
        ('Nom', {
            'fields': ('nom', )        
        }),
        ('Description générale', {
            'fields': ('poste', 'resume','description', 'date_limite', )        
        }),
        ('Coordonnées', {
            'fields': ('lieu_affectation', 'bureau', 'region', )
        }),
        ('Autre', {
            'fields': ('debut_affectation', 'duree_affectation',
                        'renumeration', )
        }),
    )        
    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:
            return True
        return False   

class ProxyCandidatPiece(CandidatPiece):
    """
    Ce proxy sert uniquement dans l'admin à disposer d'un libellé
    plus ergonomique.
    """
    class Meta:
        proxy = True
        verbose_name = "pièce jointe"
        verbose_name_plural = "pièces jointes"

class CandidatPieceInline(admin.TabularInline):
    model = ProxyCandidatPiece
    fields = ('candidat', 'nom', 'path', )
    extra = 1

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 EvaluateurInline(admin.TabularInline):
    model = ProxyEvaluateur
    fields = ('evaluateur',)
    extra = 1

class CandidatAdmin(VersionAdmin):
    date_hierarchy = 'date_creation'
    list_display = ('nom', 'prenom', 'offre_emploi','statut',
                    'voir_offre_emploi', #'note_evaluateur',
                    'calculer_moyenne', 'afficher_candidat',)
    list_filter = ('offre_emploi', )
    fieldsets = (
        ("Offre d'emploi", {
            'fields': ('offre_emploi', )
        }),
        ('Informations personnelles', {
            'fields': ('prenom','nom','genre', 'nationalite', 'date_naissance',
                        '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,
        EvaluateurInline,
    ]

    actions = ['affecter_candidats_evaluateur', 'envoyer_courriel_candidats']
    # Affecter un évaluateurs à des candidats
    def affecter_candidats_evaluateur(modeladmin, obj, candidats):   
        selected = obj.POST.getlist(admin.ACTION_CHECKBOX_NAME)

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

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

        return HttpResponseRedirect(reverse('envoyer_courriel_candidats')+
                "?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'Afficher les 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:
            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:
            return True
        return False   

    def queryset(self, obj):
        """
        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 = obj.user.groups.all()
        if not grp_drh_recrutement in user_groupes:
            # 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=obj.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', 'date_naissance',
                        'situation_famille', 'nombre_dependant', 'telephone',
                        'email', 'adresse', 'ville', 'etat_province', 
                        'code_postal', 'pays', 'niveau_diplome',
                        'employeur_actuel', 'poste_actuel',
                        'domaine_professionnel',)
    fieldsets = (
        ("Offre d'emploi", {
            'fields': ('offre_emploi', )
        }),
        ('Informations personnelles', {
            'fields': ('prenom','nom','genre', 'nationalite', 'date_naissance',
                        '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 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:
            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 = (
        (None, {'fields': ('user', )}),
        #(None, {'fields': ('candidats',)}),
    )

class AdministrateurRegionalAdmin(VersionAdmin):
    pass

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

    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"
    _offre_emploi.admin_order_field = 'offre_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:
            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):
    pass

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)