[auf_rh_dae.git] / project / rh / views.py

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

from collections import defaultdict
from datetime import date
from decimal import Decimal

import pygraphviz as pgv
from reversion.models import Revision

from auf.django.references import models as ref
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.core.urlresolvers import reverse
from django.db.models import Q
from django.http import HttpResponse
from django.shortcuts import render, get_object_or_404, redirect

from project.decorators import drh_or_admin_required
from project.decorators import region_protected
from project.groups import get_employe_from_user
from project import groups
from project.decorators import in_one_of_group, in_drh_or_admin

from project.rh import ods
from project.rh import graph as rh_graph
from project.rh import models as rh
from project.rh.change_list import RechercheTemporelle
from project.rh.forms import MasseSalarialeForm
from project.rh.lib import get_lookup_params
from project.rh.templatetags.rapports import SortHeaders
from project.rh.historique import get_active_revisions, TodoForm

TWOPLACES = rh.TWOPLACES


def devises():
    liste = []
    for d in rh.Devise.objects.all():
        annee = date.today().year
        taux = rh.TauxChange.objects.filter(annee=annee, devise=d)
        data = {}
        if len(taux) == 0:
            data['taux_euro'] = 0
        else:
            data['taux_euro'] = taux[0].taux
        data['devise_code'] = d.id
        liste.append(data)
        
    return liste


@login_required
@drh_or_admin_required
def profil(request):
    """Profil personnel de l'employé - éditable"""
    employe = get_employe_from_user(request.user)
    c = {
      'user': request.user,
      'employe': employe,
    }
    return render(request, 'rh/profil.html', c)


@login_required
@drh_or_admin_required
def employes_liste(request):
    """Liste des employés."""
    today = date.today()
    employes = rh.Employe.objects   \
                    .exclude(dossiers__date_debut__gt=today) \
                    .exclude(dossiers__date_fin__lt=today) \
                    .order_by('nom')
    c = {
        'user': request.user,
        'employes': employes,
        }
    return render(request, 'rh/employes_liste.html', c)


@login_required
@drh_or_admin_required
def employe(request, id):
    """Information publique sur un employé."""
    try:
        employe = rh.Employe.objects.get(pk=id)
    except:
        employe = rh.Employe.objects.none()
    c = {
        'user': request.user,
        'employe': employe,
        }
    return render(request, 'rh/employe.html', c)


@login_required
@in_one_of_group((groups.CORRESPONDANT_RH,
    groups.ADMINISTRATEURS,
    groups.DIRECTEUR_DE_BUREAU,
    groups.DRH_NIVEAU_1,
    groups.DRH_NIVEAU_2))
def rapports_contrat(request):
    # statut default = actif?
    if 'HTTP_REFERER' in request.META.keys():
        referer = request.META['HTTP_REFERER']
        referer = "/".join(referer.split('/')[3:])
        referer = "/%s" % referer.split('?')[0]
        if referer != reverse('rhr_contrats'):
            params = request.GET.copy()
            params.update({'statut': 'Actif'})
            request.GET = params

    contrats = rh.Contrat.objects.select_related(
        'dossier', 'dossier__poste', 'dossier__poste__implantation',
        'type_contrat', 'dossier__employe'
    )

    # filters et recherche temporelle
    cl = RechercheTemporelle(dict(request.GET.items()), rh.Contrat)
    lookup_params = get_lookup_params(request)
    lookup_params = cl.purge_params(lookup_params)
    q_temporel = cl.get_q_temporel(contrats)
    q = Q(**lookup_params) & q_temporel
    contrats = contrats.filter(q)
    user_groups = [g.name for g in request.user.groups.all()]
    if groups.CORRESPONDANT_RH in user_groups or\
       groups.ADMINISTRATEURS in user_groups or\
       groups.DIRECTEUR_DE_BUREAU in user_groups:
        employe = get_employe_from_user(request.user)
        q = q & Q(
            dossier__poste__implantation__zone_administrative=(
                employe.implantation.zone_administrative
            )
        )

    contrats = contrats.filter(q)

    # tri
    if 'o' in request.GET:
        contrats = contrats.order_by(
            ('-' if request.GET.get('ot') == "desc" else '') + request.GET['o']
        )

    # affichage
    employes = set([c.dossier.employe_id for c in contrats])
    headers = [
        ("dossier__employe__id", u"#"),
        ("dossier__employe__nom", u"Employé"),
        ("dossier", u"Dossier : Poste"),
        ("type_contrat__nom", u"Contrat"),
        ("date_debut", u"Début contrat"),
        ("date_fin", u"Fin contrat"),
        ("dossier__statut_residence", u"Statut"),
        ("dossier__poste__implantation__zone_administrative", u"Zone administrative"),
        ("dossier__poste__implantation", u"Implantation"),
    ]
    h = SortHeaders(
        request, headers, order_field_type="ot", order_field="o",
        not_sortable=('dossier',)
    )

    c = {
        'cl': cl,
        'title': 'Rapport des contrats',
        'contrats': contrats,
        'count_employe': len(employes),
        'headers': list(h.headers()),
    }
    return render(request, 'rh/rapports/contrats.html', c)


@login_required
@in_one_of_group((groups.CORRESPONDANT_RH,
    groups.ADMINISTRATEURS,
    groups.DIRECTEUR_DE_BUREAU,
    groups.DRH_NIVEAU_1,
    groups.DRH_NIVEAU_2))
def rapports_employes_sans_contrat(request):
    """
    Employé sans contrat = a un Dossier qui n'a pas de Contrat associé
    Employé avec contrat échu = a un Dossier avec un Contrat se terminant hier
    au plus tard... (aujourd'hui = ok, pas date de fin = illimité donc ok)
    """
    lookup_params = get_lookup_params(request)

    # régionalisation
    user_groups = [g.name for g in request.user.groups.all()]
    if groups.CORRESPONDANT_RH in user_groups or\
       groups.ADMINISTRATEURS in user_groups or\
       groups.DIRECTEUR_DE_BUREAU in user_groups:
        employe = get_employe_from_user(request.user)
        lookup_params['poste__implantation__zone_administrative'] = \
                employe.implantation.zone_administrative

    dossiers = rh.Dossier.objects.sans_contrats_ou_echus(**lookup_params)
    dossiers_ids = [d.id for d in dossiers]
    employes = rh.Employe.objects.filter(id__in=dossiers_ids).distinct().count()

    # tri
    if 'o' in request.GET:
        dossiers = dossiers.order_by(
            ('-' if request.GET.get('ot') == "desc" else '') + request.GET['o']
        )

    # affichage
    headers = [
        ("employe__id", u"#"),
        ("employe__nom", u"Employé"),
        ("dossier", u"Dossier : Poste"),
        ("rh_contrats__type_contrat", u"Contrat"),
        ("rh_contrats__date_debut", u"Début contrat"),
        ("rh_contrats__date_fin", u"Fin contrat"),
        ("statut_residence", u"Statut"),
        ("poste__implantation__zone_administrative__code", u"Zone administrative"),
        ("poste__implantation__nom", u"Implantation"),
    ]
    h = SortHeaders(
        request, headers, order_field_type="ot", order_field="o",
        not_sortable=('dossier',)
    )

    c = {
        'title': u'Rapport des employés sans contrat ou contrat échu',
        'employes': employes,
        'dossiers': dossiers,
        'headers': list(h.headers()),
    }

    return render(request, 'rh/rapports/employes_sans_contrat.html', c)


@login_required
@in_one_of_group((groups.CORRESPONDANT_RH,
    groups.ADMINISTRATEURS,
    groups.DIRECTEUR_DE_BUREAU,
    groups.DRH_NIVEAU_1,
    groups.DRH_NIVEAU_2))
def rapports_masse_salariale(request):
    form = MasseSalarialeForm(request.user, request.GET)
    if 'annee' in request.GET and form.is_valid():
        zone_administrative = form.cleaned_data['zone_administrative']
        implantation = form.cleaned_data['implantation']
        annee = form.cleaned_data['annee']
        debut_annee = date(annee, 1, 1)
        fin_annee = date(annee, 12, 31)
        jours_annee = (fin_annee - debut_annee).days + 1
        today = date.today()

        # Récupérer les dossiers actifs
        dossiers = rh.Dossier.objects \
                .actifs(annee=annee) \
                .select_related(
                    'poste', 'poste__implantation',
                    'poste__implantation__zone_administrative',
                    'poste__implantation__adresse_physique_pays',
                    'employe', 'poste__type_poste', 'classement',
                    'statut', 'organisme_bstg'
                ) \
                .extra(
                    select={
                        'valeur_point': (
                            'SELECT valeur FROM rh_valeurpoint '
                            'WHERE annee = %d '
                            'AND implantation = ref_implantation.id' % annee
                        ),
                        'valeur_point_devise': (
                            'SELECT d.code '
                            'FROM rh_valeurpoint vp '
                            'INNER JOIN rh_devise d ON d.id = vp.devise '
                            'WHERE annee = %d '
                            'AND implantation = ref_implantation.id' % annee
                        )
                    }
                )
        if zone_administrative:
            dossiers = dossiers.filter(poste__implantation__zone_administrative=zone_administrative)
        if implantation:
            dossiers = dossiers.filter(poste__implantation=implantation)

        # Récupérer les rémunérations actives
        remun_actives = rh.Remuneration.objects \
                .actifs(annee=annee) \
                .select_related('devise', 'type')

        remuns = remun_actives.extra(
                    tables=['rh_tauxchange'],
                    where=[
                        'rh_tauxchange.devise = rh_devise.id',
                        'rh_tauxchange.annee = '
                        '(SELECT MAX(annee) FROM rh_tauxchange '
                        'WHERE devise = rh_devise.id '
                        'AND annee <= %s)',
                    ],
                    params=[annee],
                    select={
                        'taux_change': 'rh_tauxchange.taux'
                    }
                )

        if len(remun_actives) != len(remuns):
            raise rh.RemunIntegrityException("Toutes les remunerations ne disposent pas d'un "
                "taux de change pour l'année %d" % annee)

        if zone_administrative:
            remuns = remuns.filter(dossier__poste__implantation__zone_administrative=zone_administrative)
        if implantation:
            remuns = remuns.filter(dossier__poste__implantation=implantation)
        remuns_par_dossier = defaultdict(list)
        types_remun = set()
        for remun in remuns:
            types_remun.add(remun.type_id)
            remuns_par_dossier[remun.dossier_id].append(remun)

        # Récupérer les types de rémunération par nature
        types_remun_par_nature = defaultdict(list)
        for type in rh.TypeRemuneration.objects.all():
            if type.id in types_remun:
                types_remun_par_nature[type.nature_remuneration].append(type)
        titres_traitements = [
            t.nom for t in types_remun_par_nature[u'Traitement']
        ]
        titres_indemnites = [
            t.nom for t in types_remun_par_nature[u'Indemnité']
        ]
        titres_primes = [
            t.nom for t in types_remun_par_nature[u'Accessoire']
        ]
        titres_charges = [
            t.nom for t in types_remun_par_nature[u'Charges']
        ]

        # Boucler sur les dossiers et préprarer les lignes du rapport
        lignes = []
        masse_salariale_totale = 0
        for dossier in dossiers:
            debut_cette_annee = \
                    max(dossier.date_debut or debut_annee, debut_annee)
            fin_cette_annee = \
                    min(dossier.date_fin or fin_annee, fin_annee)
            jours = (fin_cette_annee - debut_cette_annee).days + 1

            remuns = remuns_par_dossier[dossier.id]
            devises = set(remun.devise.code for remun in remuns)
            if len(devises) == 1:
                devise = remuns[0].devise.code
                montant_remun = lambda r: r.montant
                taux_change = Decimal(str(remuns[0].taux_change))
            else:
                devise = 'EUR'
                montant_remun = lambda r: (
                    r.montant * Decimal(str(r.taux_change))
                )
                taux_change = Decimal(1)

            remuns_par_type = defaultdict(lambda: 0)

            for remun in remuns:
                montant_ajuste_euros = remun.montant_ajuste_euros(annee=annee)
                if len(devises) == 1:
                    devise = remuns[0].devise.code
                    montant_ajuste = (
                        montant_ajuste_euros /
                        Decimal(str(remuns[0].taux_change))
                        ).quantize(TWOPLACES)
                else:
                    montant_ajuste = montant_ajuste_euros.quantize(TWOPLACES)
                    devise = 'EUR'
                remuns_par_type[remun.type_id] += montant_ajuste

            traitements = [
                remuns_par_type[type.id]
                for type in types_remun_par_nature[u'Traitement']
            ]
            indemnites = [
                remuns_par_type[type.id]
                for type in types_remun_par_nature[u'Indemnité']
            ]
            primes = [
                remuns_par_type[type.id]
                for type in types_remun_par_nature[u'Accessoire']
            ]
            charges = [
                remuns_par_type[type.id]
                for type in types_remun_par_nature[u'Charges']
            ]
            masse_salariale = sum(remuns_par_type.values())
            masse_salariale_eur = (
                masse_salariale * taux_change
            ).quantize(TWOPLACES)
            masse_salariale_totale += masse_salariale_eur

            if dossier.valeur_point and dossier.classement \
               and dossier.classement.coefficient and dossier.regime_travail:
                salaire_theorique = (Decimal(str(
                    dossier.valeur_point * dossier.classement.coefficient
                )) * dossier.regime_travail / 100).quantize(TWOPLACES)
            else:
                salaire_theorique = None

            lignes.append({
                'dossier': dossier,
                'poste': dossier.poste,
                'date_debut': (
                    dossier.date_debut
                    if dossier.date_debut and dossier.date_debut.year == annee
                    else None
                ),
                'date_fin': (
                    dossier.date_fin
                    if dossier.date_fin and dossier.date_fin.year == annee
                    else None
                ),
                'jours': jours,
                'devise': devise,
                'valeur_point': dossier.valeur_point,
                'valeur_point_devise': dossier.valeur_point_devise,
                'regime_travail': dossier.regime_travail,
                'local_expatrie': {
                    'local': 'L', 'expat': 'E'
                }.get(dossier.statut_residence),
                'salaire_bstg': remuns_par_type[2],
                'salaire_bstg_eur': (
                    (remuns_par_type[2] * taux_change).quantize(TWOPLACES)
                ),
                'salaire_theorique': salaire_theorique,
                'traitements': traitements,
                'total_traitements': sum(traitements),
                'indemnites': indemnites,
                'total_indemnites': sum(indemnites),
                'primes': primes,
                'total_primes': sum(primes),
                'charges': charges,
                'total_charges': sum(charges),
                'masse_salariale': masse_salariale,
                'masse_salariale_eur': masse_salariale_eur,
            })

        # Récupérer les postes actifs pour déterminer le nombre de jours
        # vacants.
        postes = rh.Poste.objects.actifs(annee=annee) \
                .select_related(
                    'devise_max', 'valeur_point_max', 'classement_max'
                ) \
                .extra(
                    tables=['rh_tauxchange'],
                    where=[
                        'rh_tauxchange.annee = %s',
                        'rh_tauxchange.devise = rh_devise.id'
                    ],
                    params=[annee],
                    select={
                        'taux_change': 'rh_tauxchange.taux'
                    }
                )
        if zone_administrative:
            postes = postes.filter(implantation__zone_administrative=zone_administrative)
        if implantation:
            postes = postes.filter(implantation=implantation)
        postes = list(postes)
        postes_par_id = dict((poste.id, poste) for poste in postes)
        jours_vacants_date = dict(
            (poste.id, max(today, poste.date_debut or today))
            for poste in postes
        )
        jours_vacants = defaultdict(lambda: 0)
        for dossier in rh.Dossier.objects.actifs(annee=annee) \
                       .order_by('date_debut'):
            if dossier.poste_id not in jours_vacants_date:
                continue
            derniere_date = jours_vacants_date[dossier.poste_id]
            if dossier.date_debut is not None:
                jours_vacants[dossier.poste_id] += max((
                    dossier.date_debut - derniere_date
                ).days - 1, 0)
            jours_vacants_date[dossier.poste_id] = max(
                min(dossier.date_fin or fin_annee, fin_annee),
                derniere_date
            )
        for poste_id, derniere_date in jours_vacants_date.iteritems():
            jours_vacants[poste_id] += max((
                min(postes_par_id[poste_id].date_fin or fin_annee, fin_annee) -
                derniere_date
            ).days, 0)

        # Ajouter les lignes des postes vacants au rapport
        for poste_id, jours in jours_vacants.iteritems():
            if jours == 0:
                continue
            poste = postes_par_id[poste_id]
            if poste.valeur_point_max and poste.classement_max \
               and poste.classement_max.coefficient and poste.regime_travail:
                salaire_theorique = (Decimal(str(
                    poste.valeur_point_max.valeur *
                    poste.classement_max.coefficient
                )) * poste.regime_travail / 100).quantize(TWOPLACES)
            else:
                salaire_theorique = None

            local_expatrie = '/'.join(
                (['L'] if poste.local else []) +
                (['E'] if poste.expatrie else [])
            )

            salaire = (
                poste.salaire_max * jours / jours_annee *
                poste.regime_travail / 100
            ).quantize(TWOPLACES)
            indemnites = (
                poste.indemn_max * jours / jours_annee *
                poste.regime_travail / 100
            ).quantize(TWOPLACES)
            charges = (
                poste.autre_max * jours / jours_annee *
                poste.regime_travail / 100
            ).quantize(TWOPLACES)
            masse_salariale = salaire + indemnites + charges
            masse_salariale_eur = (
                masse_salariale * Decimal(str(poste.taux_change))
            ).quantize(TWOPLACES)
            masse_salariale_totale += masse_salariale_eur

            lignes.append({
                'poste': poste,
                'regime_travail': poste.regime_travail,
                'local_expatrie': local_expatrie,
                'jours': jours,
                'devise': poste.devise_max and poste.devise_max.code,
                'valeur_point': (
                    poste.valeur_point_max and poste.valeur_point_max.valeur
                ),
                'valeur_point_devise': (
                    poste.valeur_point_max and \
                    poste.valeur_point_max.devise.code
                ),
                'salaire_theorique': salaire_theorique,
                'traitements': [0] * len(titres_traitements),
                'total_traitements': salaire,
                'indemnites': [0] * len(titres_indemnites),
                'total_indemnites': indemnites,
                'primes': [0] * len(titres_primes),
                'total_primes': 0,
                'charges': [0] * len(titres_charges),
                'total_charges': charges,
                'masse_salariale': masse_salariale,
                'masse_salariale_eur': masse_salariale_eur
            })
        if 'ods' in request.GET:
            doc = ods.masse_salariale(
                lignes=lignes,
                annee=annee,
                titres_traitements=titres_traitements,
                titres_indemnites=titres_indemnites,
                titres_primes=titres_primes,
                titres_charges=titres_charges,
                masse_salariale_totale=masse_salariale_totale
            )
            response = HttpResponse(
                mimetype='vnd.oasis.opendocument.spreadsheet'
            )
            response['Content-Disposition'] = 'filename=masse-salariale.ods'
            doc.write(response)
            return response
        else:
            return render(request, 'rh/rapports/masse_salariale.html', {
                'form': form,
                'titres_traitements': titres_traitements,
                'titres_indemnites': titres_indemnites,
                'titres_primes': titres_primes,
                'titres_charges': titres_charges,
                'masse_salariale_totale': masse_salariale_totale,
                'lignes': lignes,
                'annee': annee
            })
    return render(request, 'rh/rapports/masse_salariale.html', {
        'form': form
    })


@login_required
@drh_or_admin_required
def rapports_postes_modelisation(request):
    c = {}
    data = []

    for categorie in rh.CategorieEmploi.objects.all():
        types = rh.TypePoste.objects.filter(categorie_emploi=categorie)
        data_types = []
        for t in types.all():
            postes = rh.Poste.objects.filter(type_poste=t)
            data_types.append({
                'num_postes': postes.count(),
                'postes': postes.all(),
                'type': categorie,
                })

        data.append({
            'categorie': categorie,
            'nb_types': types.count(),
            'types': data_types
        })

    c['data'] = data

    return render(request, 'rh/rapports/postes_modelisation.html', c)


@login_required
@drh_or_admin_required
def rapports_postes_implantation(request):
    c = {}
    data = []
    for r in ref.Region.objects.all():
        implantations = []
        for i in ref.Implantation.objects.filter(region=r):
            implantations.append({
                'implantation': i,
                'postes': rh.Poste.objects.filter(implantation=i),
                'num_postes': rh.Poste.objects.filter(implantation=i).count(),
                })
        data.append({
            'region': r,
            'implantations': implantations
            })

    c['data'] = data

    return render(request, 'rh/rapports/postes_implantation.html', c)


@login_required
@drh_or_admin_required
def rapports_postes_service(request):
    c = {}
    data = []
    for s in rh.Service.objects.all():
        postes = rh.Poste.objects.filter(service=s).all()
        num_postes = rh.Poste.objects.filter(service=s).count()
        data.append({'service': s, 'num_postes': num_postes, 'postes': postes})

    c['data'] = data
    return render(request, 'rh/rapports/postes_service.html', c)


@region_protected(rh.Dossier)
def dossier_apercu(request, dossier_id):
    d = get_object_or_404(rh.Dossier, pk=dossier_id)
    annees =  [
        x.year for x in d.remunerations().values_list(
            'date_debut', flat=True) if x is not None]
    min_y, max_y  = (
        (min(annees), max(annees)) if len(annees)
        else (date.today().year, date.today().year)
        )
    annees = reversed(range(min_y, max_y + 1))

    c = {
        'title': u"Dossier %s" % (d, ),
        'is_popup': request.GET.get('_popup', False),
        'devises': devises(),
        'dossier': d,
        'annees': annees,
        'pieces':  rh.DossierPiece.objects.filter(dossier__exact=d),
        'contrats': rh.Contrat.objects.filter(dossier__exact=d),
        'commentaires': rh.DossierCommentaire.objects.filter(dossier=d).all(),
        'media_url': settings.PRIVE_MEDIA_URL,
    }
    return render(request, 'admin/rh/dossier/apercu.html', c)


@region_protected(rh.Poste)
def poste_apercu(request, poste_id):
    p = get_object_or_404(rh.Poste, pk=poste_id)
    c = {
        'title': u"Poste %s" % (p, ),
        'is_popup': request.GET.get('_popup', False),
        'poste': p,
        'financements': (
            rh.PosteFinancement.objects.filter(poste=poste_id).all()
        ),
        'pieces': rh.PostePiece.objects.filter(poste=poste_id).all(),
        'dossiers': (
            rh.Dossier.objects.filter(poste=poste_id)
            .order_by("-date_debut").all()
        ),
        'comparaisons': (
            rh.PosteComparaison.objects.filter(poste=poste_id).all()
        ),
        'commentaires': (
            rh.PosteCommentaire.objects.filter(poste=poste_id).all()
        ),
        'media_url': settings.PRIVE_MEDIA_URL,
    }
    return render(request, 'admin/rh/poste/apercu.html', c)

@login_required
@in_one_of_group((groups.CORRESPONDANT_RH,
    groups.ADMINISTRATEURS,
    groups.DIRECTEUR_DE_BUREAU,
    groups.DRH_NIVEAU_1,
    groups.DRH_NIVEAU_2))
def employe_apercu(request, employe_id):
    employe = get_object_or_404(rh.Employe, pk=employe_id)
    user_groups = [g.name for g in request.user.groups.all()]
    dossiers = None

    if in_drh_or_admin(request.user):
        q = Q(employe=employe)

    if groups.CORRESPONDANT_RH in user_groups or\
       groups.ADMINISTRATEURS in user_groups or\
       groups.DIRECTEUR_DE_BUREAU in user_groups:
        employe_connecte = get_employe_from_user(request.user)
        q = Q(employe=employe) & Q(
            poste__implantation__zone_administrative=(
                employe_connecte.implantation.zone_administrative
            )
        )

    dossiers = rh.Dossier.objects.filter(q).order_by('-date_debut')

    dossier_principal = employe.dossier_principal()

    c = {
        'title': u"Employe %s" % (employe, ),
        'is_popup': request.GET.get('_popup', False),
        'employe': employe,
        'dossiers': dossiers,
        'dossier_principal': dossier_principal,
        'media_url': settings.PRIVE_MEDIA_URL,
        'annee': date.today().year,
        'devises': devises(),
    }
    return render(request, 'admin/rh/employe/apercu.html', c)


@login_required
@in_one_of_group((groups.CORRESPONDANT_RH,
    groups.ADMINISTRATEURS,
    groups.DIRECTEUR_DE_BUREAU,
    groups.DRH_NIVEAU_1,
    groups.DRH_NIVEAU_2))
def organigrammes_employe(request, id, level="all"):
    poste = get_object_or_404(rh.Poste, pk=id)
    dossiers_by_poste = dict(
        (d.poste_id, d)
        for d in rh.Dossier.objects.select_related('employe', 'poste').all()
    )
    postes_by_id = dict((p.id, p) for p in rh.Poste.objects.all())

    e = dossiers_by_poste[poste.id].employe
    name = u"Organigramme de [%s] %s %s" % (e.id, e.nom.upper(), e.prenom)
    graph = pgv.AGraph()

    if rh.Poste.objects.filter(responsable=poste).count() > 0:
        postes_handle = [poste]
        while postes_handle:
            postes_handle = rh.Poste.objects.select_related('implantation') \
                    .filter(
                        Q(date_fin__gt=date.today()) | Q(date_fin=None),
                        Q(date_debut__lt=date.today()) | Q(date_debut=None),
                        responsable__in=postes_handle
                    ).exclude(responsable=None).all()

            for p in postes_handle:
                if p.responsable_id != p.id:
                    graph.add_edge(
                        dossiers_by_poste[p.responsable_id].poste_id, p.id
                    )

    else:
        graph.add_node(poste.id)

    if level != "all":
        postes_niveau = [poste.id]
        for niveau in range(int(level)):
            postes_niveau = [
                p.id for p in
                rh.Poste.objects.filter(responsable__in=postes_niveau).all()
            ]

        while postes_niveau:
            postes_niveau = [
                p.id for p in
                rh.Poste.objects.filter(responsable__in=postes_niveau).all()
            ]
            if postes_niveau:
                for p in postes_niveau:
                    if graph.has_node(p):
                        graph.delete_node(p)

    a = graph
    a.name = name.encode('ascii', 'xmlcharrefreplace')

    poste_remontant = poste
    while poste_remontant.responsable_id:
        a.add_edge(poste_remontant.responsable_id, poste_remontant.id)
        poste_remontant = poste_remontant.responsable

    rh_graph.bind_poste_to_graph(request.user, a, postes_by_id)
    #a.graph_attr['normalize'] = True
    #a.graph_attr['level'] = 2
    a.layout(prog='dot')

    svg = a.draw(format='svg')

    c = {
        'svg': svg
    }

    if 'forcer' in request.GET:
        response = HttpResponse(svg, content_type='image/svg+xml')
        response['Content-Disposition'] = \
                'attachment; filename=organigramme.svg'
        return response

    return render(request, 'rh/organigrammes/employe.html', c,
        content_type="image/svg+xml"
    )


@login_required
@in_one_of_group((groups.CORRESPONDANT_RH,
    groups.ADMINISTRATEURS,
    groups.DIRECTEUR_DE_BUREAU,
    groups.DRH_NIVEAU_1,
    groups.DRH_NIVEAU_2))
def organigrammes_service(request, id):
    service = get_object_or_404(rh.Service, pk=id)
    svg = rh_graph.organigramme_postes_cluster( \
            request.user, \
            cluster_filter={"service": service}, \
            titre=u"Organigramme du service %s" % service.nom,
            cluster_titre=service.nom)

    return render(request, 'rh/organigrammes/vide.html', {
        'svg': svg
    }, content_type="image/svg+xml")


@login_required
@in_one_of_group((groups.CORRESPONDANT_RH,
    groups.ADMINISTRATEURS,
    groups.DIRECTEUR_DE_BUREAU,
    groups.DRH_NIVEAU_1,
    groups.DRH_NIVEAU_2))
def organigrammes_implantation(request, id):
    implantation = get_object_or_404(ref.Implantation, pk=id)
    svg = rh_graph.organigramme_postes_cluster( \
            request.user, \
            cluster_filter={"implantation": implantation}, \
            titre=u"Organigramme de l'implantation %s" % implantation.nom,
            cluster_titre=implantation.nom)
    return render(request, 'rh/organigrammes/vide.html', {
        'svg': svg
    }, content_type="image/svg+xml")


@login_required
@in_one_of_group((groups.CORRESPONDANT_RH,
    groups.ADMINISTRATEURS,
    groups.DIRECTEUR_DE_BUREAU,
    groups.DRH_NIVEAU_1,
    groups.DRH_NIVEAU_2))
def organigrammes_region(request, id):
    region = get_object_or_404(ref.Region, pk=id)
    svg = rh_graph.organigramme_postes_cluster( \
            request.user, \
            cluster_filter={"implantation__region": region}, \
            titre=u"Organigramme du bureau de %s" % region.nom,
            cluster_titre=region.nom)

    return render(request, 'rh/organigrammes/vide.html', {
        'svg': svg
    }, content_type="image/svg+xml")


@login_required
@drh_or_admin_required
def historique_des_modifications(request,):

    from django.core.paginator import Paginator

    revisions = get_active_revisions()
    paginator = Paginator(revisions, 50)
    page = request.GET.get('page')
    try:
        page_revisions = paginator.page(page)
    except:
        page_revisions = paginator.page(1)

    results = page_revisions.object_list
    if request.POST:
        form = TodoForm(request.POST, revisions=results)
        if form.is_valid():
            for id in form.cleaned_data['items']:
                revision = Revision.objects.get(id=id)
                rh.ModificationTraite(revision=revision).save()
            return redirect(reverse('rhr_historique_des_modifications'))
    else:

        form = TodoForm(revisions=results)
    
    c = {
            'headers': ('Date', 'Auteur', 'Type', 'Objet', 'Historique',
                'Commentaire', ),
            'revisions': results,
            'page': page_revisions,
            'form': form,
    }

    return render(request, 'rh/rapports/historique_des_modifications.html', c)