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

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

import textwrap

from django.conf import settings
from django.contrib import admin
from django.core.urlresolvers import reverse
from django.db.models import Avg
from django.shortcuts import render_to_response
from django.template import RequestContext

from auf.django.emploi.models import STATUT_CHOICES
from django.forms.models import BaseInlineFormSet
from django.http import HttpResponseRedirect
from django.shortcuts import redirect
from reversion.admin import VersionAdmin

from auf.django.emploi.models import OffreEmploi, Candidat, CandidatPiece
from auf.django.references.models import Region, Bureau
from auf.django.export.admin import ExportAdmin

from project.groups import get_employe_from_user as get_emp
from project.rh import models as rh

from project.recrutement.forms import OffreEmploiForm
from project.recrutement.groups import \
        grp_drh, grp_drh2, \
        grp_directeurs_bureau, \
        grp_administrateurs, \
        grp_correspondants_rh, \
        grp_haute_direction
from project.recrutement.models import \
        Evaluateur, CandidatEvaluation, \
        ProxyOffreEmploi, ProxyCandidat, MesCandidatEvaluation, \
        CourrielTemplate
        

### CONSTANTES
IMPLANTATIONS_CENTRALES = [15, 19]


class BaseAdmin(admin.ModelAdmin):

    class Media:
        css = {'screen': ('css/admin_custom.css',)}


class OrderedChangeList(admin.views.main.ChangeList):
    """
    Surcharge pour appliquer le order_by d'un annotate
    """
    def get_query_set(self):
        qs = super(OrderedChangeList, self).get_query_set()
        qs = qs.order_by('-moyenne')
        return qs


class OffreEmploiAdmin(BaseAdmin, 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:emploi_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 'region' in form.declared_fields:
            region_field = form.declared_fields['region']
        else:
            region_field = form.base_fields['region']

        if grp_drh in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_haute_direction in user_groupes:
            region_field.queryset = Region.objects.all()
        else:
            region_field.queryset = Region.objects.\
                                    filter(id=employe.implantation.region.id)

        # Poste
        if 'poste' in form.declared_fields:
            poste_field = form.declared_fields['poste']
        else:
            poste_field = form.base_fields['poste']

        if grp_drh in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_haute_direction 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 'bureau' in form.declared_fields:
            bureau_field = form.declared_fields['bureau']
        else:
            bureau_field = form.base_fields['bureau']

        if grp_drh in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_haute_direction 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 in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_haute_direction in user_groupes:
            return qs

        if grp_directeurs_bureau in user_groupes or \
            grp_correspondants_rh in user_groupes or \
            grp_administrateurs 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 in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_directeurs_bureau in user_groupes or \
            grp_administrateurs in user_groupes or \
            grp_haute_direction 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 in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_directeurs_bureau in user_groupes or \
            grp_administrateurs in user_groupes or \
            grp_haute_direction 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 in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_directeurs_bureau in user_groupes or \
            grp_administrateurs in user_groupes or \
            grp_haute_direction 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 redirect('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):
        user_groupes = request.user.groups.all()
        if request.user.is_superuser is True or \
            grp_correspondants_rh in user_groupes or \
            grp_drh in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_directeurs_bureau in user_groupes or \
            grp_administrateurs in user_groupes or \
            grp_haute_direction in user_groupes:
            return True

        if obj is not None:
            return True

        return False


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(BaseAdmin, VersionAdmin, ExportAdmin):
    change_list_template = 'admin/recrutement/candidat/change_list.html'
    search_fields = ('nom', 'prenom')
    exclude = ('actif', )
    list_editable = ('statut', )
    list_display = ('_candidat', 'offre_emploi',
                    'voir_offre_emploi', 'calculer_moyenne',
                    'afficher_candidat', '_date_creation', 'statut', )
    list_filter = ('offre_emploi__nom', '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', 'changer_statut']

    export_fields = ['statut', 'offre_emploi', 'prenom', 'nom', 'genre',
                     'nationalite', 'situation_famille', 'nombre_dependant',
                     'niveau_diplome', 'employeur_actuel', 'poste_actuel',
                     'domaine_professionnel', 'telephone', 'email', 'adresse',
                     'ville', 'etat_province', 'code_postal', 'pays']

    def _candidat(self, obj):
        txt = u"%s %s (%s)" % (obj.nom.upper(), obj.prenom, obj.genre)
        txt = textwrap.wrap(txt, 30)
        return "<br/>".join(txt)
    _candidat.short_description = "Candidat"
    _candidat.admin_order_field = "nom"
    _candidat.allow_tags = True

    def _date_creation(self, obj):
        return obj.date_creation
    _date_creation.admin_order_field = "date_creation"
    _date_creation.short_description = "Date de réception"

    ### 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'

    ### Changer le statut à des candidats
    def changer_statut(modeladmin, request, queryset):
        if request.POST.get('post'):
            queryset.update(statut=request.POST.get('statut'))
            return None

        context = {
            'action_checkbox_name': admin.helpers.ACTION_CHECKBOX_NAME,
            'queryset': queryset,
            'status': STATUT_CHOICES,
        }

        return render_to_response("recrutement/selectionner_statut.html",
                context, context_instance = RequestContext(request))

    changer_statut.short_description = u'Changer statut'

    ### É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):
        items = [u"<li><a href='%s%s'>%s</li>" % \
                (settings.OE_PRIVE_MEDIA_URL, pj.path, pj.get_nom_display()) \
                for pj in obj.pieces_jointes()]
        html = "<a href='%s'>Candidature</a>" % (
            reverse('admin:recrutement_proxycandidat_change', args=(obj.id,))
        )
        return "%s<ul>%s</ul>" % (html, "\n".join(items))
    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 = "Moyenne"
    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_correspondants_rh in user_groupes or \
            grp_drh in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_directeurs_bureau in user_groupes or \
            grp_administrateurs in user_groupes or \
            grp_haute_direction 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_correspondants_rh in user_groupes or \
            grp_drh in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_directeurs_bureau in user_groupes or \
            grp_administrateurs in user_groupes or \
            grp_haute_direction 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 in user_groupes or \
            grp_drh in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_directeurs_bureau in user_groupes or \
            grp_administrateurs in user_groupes or \
            grp_haute_direction in user_groupes:
            return True
        return False

    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        if db_field.name == 'offre_emploi':
            employe = get_emp(request.user)
            kwargs["queryset"] = OffreEmploi.objects.filter(region=employe.implantation.region)
            return db_field.formfield(**kwargs)
        return super(CandidatAdmin, self).formfield_for_foreignkey(db_field, request, **kwargs)

    def get_changelist(self, request, **kwargs):
        return OrderedChangeList

    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') \
                .annotate(moyenne=Avg('evaluations__note'))

        user_groupes = request.user.groups.all()
        if grp_drh in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_haute_direction in user_groupes:
            return qs

        if grp_directeurs_bureau in user_groupes or \
            grp_correspondants_rh in user_groupes or \
            grp_administrateurs 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):
        user_groupes = request.user.groups.all()
        if request.user.is_superuser is True or \
            grp_correspondants_rh in user_groupes or \
            grp_drh in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_directeurs_bureau in user_groupes or \
            grp_administrateurs in user_groupes or \
            grp_haute_direction in user_groupes:
            return True

        if obj is not None:
            evaluateur = Evaluateur.objects.get(user=request.user)
            for e in obj.evaluations.all():
                if e.evaluateur == evaluateur:
                    return True

        return False

    def get_actions(self, request):
        return None


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(BaseAdmin, 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 in user_groupes or \
                grp_drh2 in user_groupes or \
                grp_haute_direction 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 in user_groupes or \
                grp_drh2 in user_groupes or \
                grp_haute_direction 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 in user_groupes or \
                grp_drh2 in user_groupes or \
                grp_haute_direction in user_groupes:
            return True
        return False


class CandidatEvaluationAdmin(BaseAdmin):
    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 in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_correspondants_rh in user_groupes or \
            grp_directeurs_bureau in user_groupes or \
            grp_administrateurs in user_groupes or \
            grp_haute_direction in user_groupes:
            is_recrutement = True
        else:
            is_recrutement = False

        return is_recrutement

    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 in user_groupes or \
            grp_drh2 in user_groupes or \
            grp_correspondants_rh in user_groupes or \
            grp_directeurs_bureau in user_groupes or \
            grp_administrateurs in user_groupes or \
            grp_haute_direction in user_groupes:
            return qs.filter(candidat__statut__in=('REC', 'SEL'))

        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):
    list_filter = []

    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(BaseAdmin, 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)