merge regionalisation

[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 = Decimal('0.01')


@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.grp_correspondants_rh,
    groups.grp_administrateurs,
    groups.grp_directeurs_bureau,
    groups.grp_drh,
    groups.grp_drh2))
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 = request.user.groups.all()
    if groups.grp_correspondants_rh in user_groups or\
       groups.grp_administrateurs in user_groups or\
       groups.grp_directeurs_bureau in user_groups:
        employe = get_employe_from_user(request.user)
        q = q & Q(dossier__poste__implantation__region=employe.implantation.region)

    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__region", u"Région"),
        ("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.grp_correspondants_rh,
    groups.grp_administrateurs,
    groups.grp_directeurs_bureau,
    groups.grp_drh,
    groups.grp_drh2))
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 = request.user.groups.all()
    q_region = Q()
    if groups.grp_correspondants_rh in user_groups or\
       groups.grp_administrateurs in user_groups or\
       groups.grp_directeurs_bureau in user_groups:
        employe = get_employe_from_user(request.user)
        q_region = Q(poste__implantation__region=employe.implantation.region)

    # contrats échus
    contrats_echus = rh.Contrat.objects.filter(
            date_fin__lt=date.today()
        ).filter(
            **lookup_params
        )

    # dossiers en cours sans contrat
    dossiers = rh.Dossier.objects.filter(q_region & (
            Q(date_fin=None) | Q(date_fin__gt=date.today())),
        ).exclude(
            date_debut__gt=date.today()
        ).filter(
            # sans contrat | contrat échu
            Q(rh_contrats=None) | Q(rh_contrats__in=contrats_echus)
        ).distinct()

    # employés sans contrat ou contrats échus
    employes = rh.Employe.objects.filter(rh_dossiers__in=dossiers)  \
        .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__region__code", u"Région"),
        ("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.grp_correspondants_rh,
    groups.grp_administrateurs,
    groups.grp_directeurs_bureau,
    groups.grp_drh,
    groups.grp_drh2))
def rapports_masse_salariale(request):
    form = MasseSalarialeForm(request.user, request.GET)
    if 'annee' in request.GET and form.is_valid():
        region = form.cleaned_data['region']
        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__region',
                    '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 region:
            dossiers = dossiers.filter(poste__implantation__region=region)
        if implantation:
            dossiers = dossiers.filter(poste__implantation=implantation)

        # Récupérer les rémunérations actives
        remuns = rh.Remuneration.objects \
                .actifs(annee=annee) \
                .select_related('devise', 'type') \
                .extra(
                    tables=['rh_tauxchange'],
                    where=[
                        'rh_tauxchange.annee = %s',
                        'rh_tauxchange.devise = rh_devise.id'
                    ],
                    params=[annee],
                    select={
                        'taux_change': 'rh_tauxchange.taux'
                    }
                )
        if region:
            remuns = remuns.filter(dossier__poste__implantation__region=region)
        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:
                if remun.type.nature_remuneration == u'Accessoire':
                    remuns_par_type[remun.type_id] += montant_remun(remun)
                else:
                    remuns_par_type[remun.type_id] += (
                        montant_remun(remun) * ((
                            min(remun.date_fin or fin_annee, fin_annee) -
                            max(remun.date_debut or debut_annee, debut_annee)
                        ).days + 1) / jours_annee *
                        dossier.regime_travail / 100
                    ).quantize(TWOPLACES)
            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 region:
            postes = postes.filter(implantation__region=region)
        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)
    c = {
        'title': u"Dossier %s" % (d, ),
        'is_popup': request.GET.get('_popup', False),
        'dossier': d,
        '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)

@in_one_of_group((groups.grp_correspondants_rh,
    groups.grp_administrateurs,
    groups.grp_directeurs_bureau,
    groups.grp_drh,
    groups.grp_drh2))
def employe_apercu(request, employe_id):
    employe = get_object_or_404(rh.Employe, pk=employe_id)
    user_groups = request.user.groups.all()
    dossiers = None

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

    if groups.grp_correspondants_rh in user_groups or\
       groups.grp_administrateurs in user_groups or\
       groups.grp_directeurs_bureau in user_groups:
        employe_connecte = get_employe_from_user(request.user)
        q = Q(employe=employe) & Q(poste__implantation__region=employe_connecte.implantation.region)
    
    dossiers = rh.Dossier.objects.filter(q).order_by('-date_debut')

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


@login_required
@in_one_of_group((groups.grp_correspondants_rh,
    groups.grp_administrateurs,
    groups.grp_directeurs_bureau,
    groups.grp_drh,
    groups.grp_drh2))
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.grp_correspondants_rh,
    groups.grp_administrateurs,
    groups.grp_directeurs_bureau,
    groups.grp_drh,
    groups.grp_drh2))
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.grp_correspondants_rh,
    groups.grp_administrateurs,
    groups.grp_directeurs_bureau,
    groups.grp_drh,
    groups.grp_drh2))
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.grp_correspondants_rh,
    groups.grp_administrateurs,
    groups.grp_directeurs_bureau,
    groups.grp_drh,
    groups.grp_drh2))
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',  'Traité'),
            'revisions': results,
            'page': page_revisions,
            'form': form,
    }

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