round

[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.forms.models import BaseInlineFormSet

from reversion.admin import VersionAdmin
from datamaster_modeles.models import Region, Bureau
from project.rh import models as rh

from project.dae.utils import get_employe_from_user as get_emp
from recrutement.models import *
from recrutement.workflow import grp_drh_recrutement, grp_directeurs_bureau_recrutement, \
                    grp_administrateurs_recrutement, \
                    grp_correspondants_rh_recrutement

from recrutement.forms import *

### CONSTANTES
IMPLANTATIONS_CENTRALES = [15, 19]

class OffreEmploiAdmin(VersionAdmin):
    date_hierarchy = 'date_creation'
    list_display = ('nom', 'date_limite', 'region',  'statut', 
                    'est_affiche', '_candidatsList', )
    exclude = ('actif', 'poste_nom', 'resume',)
    list_filter = ('statut',)
    actions = ['affecter_evaluateurs_offre_emploi', ]
    form = OffreEmploiForm

    ### Actions à afficher
    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"

    ### Formulaire
    def get_form(self, request, obj=None, **kwargs):
        form = super(OffreEmploiAdmin, self).get_form(request, obj, **kwargs)
        employe = get_emp(request.user)
        user_groupes = request.user.groups.all()
        
    
        # Region
        if form.declared_fields.has_key('region'):
            region_field = form.declared_fields['region']
        else:
            region_field = form.base_fields['region']

        if grp_drh_recrutement in user_groupes:
            region_field.queryset = Region.objects.all()
        else:
            region_field.queryset = Region.objects.\
                                    filter(id=employe.implantation.region.id)
        
        # Poste
        if form.declared_fields.has_key('poste'):
            poste_field = form.declared_fields['poste']
        else:
            poste_field = form.base_fields['poste']

        if grp_drh_recrutement in user_groupes:
            poste_field.queryset = rh.Poste.objects.all()
        else:
            poste_field.queryset = rh.Poste.objects.\
                    filter(implantation__region=employe.implantation.region).\
                    exclude(implantation__in=IMPLANTATIONS_CENTRALES)
        
        # Bureau
        if form.declared_fields.has_key('bureau'):
            bureau_field = form.declared_fields['bureau']
        else:
            bureau_field = form.base_fields['bureau']

        if grp_drh_recrutement in user_groupes:
            bureau_field.queryset = Bureau.objects.all()
        else:
            bureau_field.queryset = Bureau.objects.\
                                    filter(region=employe.implantation.region)   
         
        return form
        
    ### Queryset
    def queryset(self, request):
        qs = self.model._default_manager.get_query_set().select_related('offre_emploi')
        user_groupes = request.user.groups.all()
        if grp_drh_recrutement in user_groupes:
            return qs

        if grp_directeurs_bureau_recrutement in user_groupes or \
            grp_correspondants_rh_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes:
            employe = get_emp(request.user)
            return qs.filter(region=employe.implantation.region)

        if  Evaluateur.objects.filter(user=request.user).exists():
            evaluateur = Evaluateur.objects.get(user=request.user)
            offre_ids = [e.candidat.offre_emploi_id for e in
                    CandidatEvaluation.objects.select_related('candidat').filter(evaluateur=evaluateur)]
            return qs.filter(id__in=offre_ids)

        return qs.none()

    ### Permission add, delete, change
    def has_add_permission(self, request):
        user_groupes = request.user.groups.all()
        if request.user.is_superuser is True or \
            grp_drh_recrutement in user_groupes or \
            grp_directeurs_bureau_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes:
            return True
        return False  

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

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

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


    ### Lieu de redirection après le change 
    def response_change(self, request, obj):
        return HttpResponseRedirect(reverse\
                            ('admin:recrutement_proxyoffreemploi_changelist'))

    ### Formulaire
    def get_form(self, request, obj=None, **kwargs):
        form = super(OffreEmploiAdmin, self).get_form(request, obj, **kwargs)
        return form

    ### Permissions add, delete, change
    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):
        return True

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

class ReadOnlyCandidatPieceInline(CandidatPieceInline):
    readonly_fields = ('candidat', 'nom', 'path', )
    cand_delete = False


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

    ### Fields readonly    
    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):
    search_fields = ('nom', 'prenom' )
    exclude = ('actif', )
    list_editable = ('statut', )
    list_display = ('nom', 'prenom', 'offre_emploi',
                    'voir_offre_emploi', 'calculer_moyenne',
                    'afficher_candidat', '_date_creation', 'statut', )
    list_filter = ('offre_emploi', 'offre_emploi__region', 'statut', )

    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 _date_creation(self, obj):
        return obj.date_creation
    _date_creation.order_field = "date_creation"
    _date_creation.short_description = "Date de création"

    ### Actions à afficher
    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)

        notes = [evaluation.note for evaluation in evaluations \
                    if evaluation.note is not None]
 
        if len(notes) > 0:
            moyenne_votes = round(float(sum(notes)) / len(notes), 2)
        else:
            moyenne_votes = "Non disponible"

        totales = len(evaluations)
        faites = len(notes)

        if obj.statut  == 'REC':
            if totales == faites:
                color = "green"
            elif faites > 0 and float(totales) / float(faites) >= 2:
                color = "orange"
            else:
                color = "red"
        else:
            color = "black"

        return """<span style="color: %s;">%s (%s/%s)</span>""" % (color, moyenne_votes, faites, totales)
    calculer_moyenne.allow_tags = True
    calculer_moyenne.short_description = "Notation"
    calculer_moyenne.admin_order_field = ""

    ### Permissions add, delete, change
    def has_add_permission(self, request):
        user_groupes = request.user.groups.all()
        if request.user.is_superuser is True or \
            grp_drh_recrutement in user_groupes or \
            grp_directeurs_bureau_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes:
            return True
        return False   

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

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

    ### Queryset
    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().select_related('offre_emploi')
        user_groupes = request.user.groups.all()
        if grp_drh_recrutement in user_groupes:
            return qs

        if grp_directeurs_bureau_recrutement in user_groupes or \
            grp_correspondants_rh_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes:
            employe = get_emp(request.user)
            return qs.filter(offre_emploi__region=employe.implantation.region)

        if  Evaluateur.objects.filter(user=request.user).exists():
            evaluateur = Evaluateur.objects.get(user=request.user)
            candidat_ids = [e.candidat.id for e in
                    CandidatEvaluation.objects.filter(evaluateur=evaluateur)]
            return qs.filter(id__in=candidat_ids)
        return qs.none()    


class ProxyCandidatAdmin(CandidatAdmin):
    list_editable = ()
    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 = (CandidatEvaluationInline, )

    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):
        return True

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

    ### Queryset
    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',)
        }),
    )

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

    ### Permissions add, delete, change
    def has_add_permission(self, request):
        user_groupes = request.user.groups.all()
        if request.user.is_superuser is True or \
            grp_drh_recrutement in user_groupes or \
            grp_directeurs_bureau_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes:
            return True
        return False   

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

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

class CandidatEvaluationAdmin(admin.ModelAdmin):
    search_fields = ('candidat__nom', 'candidat__prenom' )
    list_display = ('_candidat', '_statut', '_offre_emploi', 'evaluateur', '_note', 
                    '_commentaire', )
    readonly_fields = ('candidat', 'evaluateur')
    list_filter = ('candidat__statut', 'candidat__offre_emploi',)
    fieldsets = (
        ('Évaluation du candidat', {
            'fields': ('candidat', 'evaluateur', 'note', 'commentaire', )        
        }),
    )

    def get_actions(self, request):
        # on stocke l'evaluateur connecté (pas forcément la meilleure place...)
        try:
            self.evaluateur = Evaluateur.objects.get(user=request.user)
        except:
            self.evaluateur = None

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

    ### Afficher la note
    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.
        """
        page = self.model.__name__.lower()
        redirect_url = 'admin:recrutement_%s_change' % page
        
        if obj.note is None:
            label = "Candidat non évalué"
        else:
            label = obj.note

        if self.evaluateur == obj.evaluateur:
            return "<a href='%s'>%s</a>" % (reverse(redirect_url,  args=(obj.id,)), label)
        else:
            return label
    _note.allow_tags = True
    _note.short_description = "Note"    
    _note.admin_order_field = 'note'    

    def _statut(self, obj):
        return obj.candidat.get_statut_display()
    _statut.order_field = 'candidat__statut'
    _statut.short_description = 'Statut'


    ### Lien en lecture seule vers le candidat
    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'

    ### Afficher commentaire
    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"   

    ### Afficher offre d'emploi
    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_add_permission(self, request):
        return False

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

    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
        """
        user_groupes = request.user.groups.all()

        if request.user.is_superuser or \
            grp_drh_recrutement in user_groupes or \
            grp_correspondants_rh_recrutement in user_groupes or \
            grp_directeurs_bureau_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes:
            is_recrutement = True
        else:
            is_recrutement = False

        try:
            Evaluateur.objects.get(user=request.user)
            is_evaluateur = True
        except:
            is_evaluateur = False

        if obj is None and (is_recrutement or is_evaluateur):
            return True
        
        if request.user.is_superuser is True:
            return True

        try:
            return request.user == obj.evaluateur.user
        except:
            return False

    ### Queryset
    def queryset(self, request):
        """
        Afficher uniquement les évaluations de l'évaluateur, sauf si 
        l'utilisateur est dans les groupes suivants.
        """
        qs = self.model._default_manager.get_query_set().select_related('offre_emploi')
        user_groupes = request.user.groups.all()

        if grp_drh_recrutement in user_groupes or \
            grp_correspondants_rh_recrutement in user_groupes or \
            grp_directeurs_bureau_recrutement in user_groupes or \
            grp_administrateurs_recrutement in user_groupes:
            return qs

        evaluateur = Evaluateur.objects.get(user=request.user) 
        candidats_evaluations = \
            CandidatEvaluation.objects.filter(evaluateur=evaluateur,
                    candidat__statut__in=('REC', ))
        candidats_evaluations_ids = [ce.id for ce in candidats_evaluations]
        return qs.filter(id__in=candidats_evaluations_ids)


class MesCandidatEvaluationAdmin(CandidatEvaluationAdmin):

    def has_change_permission(self, request, obj=None):
        try:
            Evaluateur.objects.get(user=request.user)
            is_evaluateur = True
        except:
            is_evaluateur = False

        if obj is None and is_evaluateur:
            return True

        try:
            return request.user == obj.evaluateur.user
        except:
            return False

    def queryset(self, request):
        qs = self.model._default_manager.get_query_set().select_related('offre_emploi')
        evaluateur = Evaluateur.objects.get(user=request.user) 
        candidats_evaluations = \
            CandidatEvaluation.objects.filter(evaluateur=evaluateur,
                    candidat__statut__in=('REC', ))
        candidats_evaluations_ids = [ce.id for ce in candidats_evaluations]
        return qs.filter(id__in=candidats_evaluations_ids)


class CourrielTemplateAdmin(VersionAdmin):
    ### Actions à afficher
    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(MesCandidatEvaluation, MesCandidatEvaluationAdmin)
admin.site.register(Evaluateur, EvaluateurAdmin)
admin.site.register(CourrielTemplate, CourrielTemplateAdmin)