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

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

import os
import datetime
import StringIO
from collections import defaultdict
from datetime import date
from simplejson import dumps
import warnings

from django.core.urlresolvers import reverse
from django.http import Http404, HttpResponse, HttpResponseGone
from django.shortcuts import redirect, render_to_response, get_object_or_404
from django.views.static import serve
from django.template import Context, RequestContext
from django.template.loader import get_template
from django.contrib import messages
from django.conf import settings
from django.contrib.auth.decorators import login_required

from reversion.models import Version

from sendfile import sendfile

from project.dae import models as dae
from project.rh_v1 import models as rh

from decorators import dae_groupe_requis, \
                       poste_dans_ma_region_ou_service, \
                       dossier_dans_ma_region_ou_service, \
                       vieux_dossier_dans_ma_region_ou_service, \
                       employe_dans_ma_region_ou_service, \
                       dossier_est_modifiable, \
                       poste_est_modifiable
from forms import *
from workflow import POSTE_ETAT_DRH_FINALISATION
from decorators import redirect_interdiction

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.code
        liste.append(data)
    return liste

def reponse_pdf(template_src, context_dict):
    """
    Générer une réponse HTTP avec un PDF
    """
    import ho.pisa as pisa
    pisa.showLogging()
    css = ""
    for f in ('css/pdf.css', 'css/dae.css'):
        css_file = os.path.join(settings.MEDIA_ROOT, f)
        css += open(css_file, 'r').read()
    context_dict['css'] = css

    template = get_template(template_src)
    context = Context(context_dict)
    html  = template.render(context)
    result = StringIO.StringIO()
    pdf = pisa.pisaDocument(html, result, encoding='UTF-8')
    if not pdf.err:
        return HttpResponse(result.getvalue(), mimetype='application/pdf')
    return HttpResponse("impossible de générer le pdf! %s" % html)


@dae_groupe_requis
def index(request):
    return render_to_response('dae/index.html', {}, RequestContext(request))


### POSTE

@dae_groupe_requis
@poste_dans_ma_region_ou_service
def poste_consulter(request, key):
    source, id = key.split('-')
    poste = get_object_or_404(dae.Poste, pk=id)
    
    if request.POST:
        validationForm = PosteWorkflowForm(request.POST, instance=poste, request=request)
        if validationForm.is_valid():
            validationForm.save()
            messages.add_message(request, messages.SUCCESS, "La validation a été enregistrée.")
            return redirect('dae_postes_liste')
    else:
        validationForm = PosteWorkflowForm(instance=poste, request=request)
    
    vars = {'poste' : poste, 'validationForm' : validationForm, }


    mode = request.GET.get('mode', None)
    if mode is None:
        return render_to_response('dae/poste_consulter.html', vars, RequestContext(request))
    if mode == 'pdf':
        return reponse_pdf('dae/poste_pdf.html', vars)
    if mode == 'vpdf':
        return render_to_response('dae/poste_pdf.html', vars, RequestContext(request))


@dae_groupe_requis
@poste_dans_ma_region_ou_service
@poste_est_modifiable
def poste(request, key=None):
    """ Formulaire pour un poste.

    Permet de créer ou modifier un poste. Si le poste n'existe que dans rh_v1
    il est automatiquement copié dans dae.

    """
    poste, data, vars = None, dict(), dict()

    if key:
        # Poste existant
        data['poste'] = key
        source, id = key.split('-')

        if source == 'dae':
            poste = get_object_or_404(dae.Poste, pk=id)
        elif source == 'rh':
            p = get_object_or_404(rh.Poste, pk=id)
            # Initialisation avec les valeurs du poste de rh_v1
            poste = dae.Poste(id_rh=p, nom=p.type_poste.nom)
            for field in ('implantation', 'type_poste', 'actif'):
                setattr(poste, field, getattr(p, field))
    else:
        # Nouveau poste
        vars['new'] = True

    if request.POST:
        data.update(dict(request.POST.items()))
        form = PosteForm(data, instance=poste, request=request)
        financementForm = FinancementForm(request.POST, instance=poste)
        piecesForm = PostePieceForm(request.POST, request.FILES, instance=poste)
        postesComparaisonsForm = PosteComparaisonForm(request.POST, instance=poste)
        if form.is_valid() and piecesForm.is_valid() and financementForm.is_valid() and postesComparaisonsForm.is_valid():
            poste = form.save()
            piecesForm.instance = poste
            piecesForm.save()
            financementForm.instance = poste
            financementForm.save()
            postesComparaisonsForm.instance = poste
            postesComparaisonsForm.save()
            messages.add_message(request, messages.SUCCESS, "Le poste %s a été sauvegardé." % poste)
            if request.POST.has_key('save'):
                return redirect('poste_consulter', key='dae-%s' % poste.id)
            else:
                return redirect('poste', key='dae-%s' % poste.id)
                
        else:
            messages.add_message(request, messages.ERROR, 'Il y a des erreurs dans le formulaire.')
            
    else:
        # 'initial' évite la validation prémature lors d'une copie de poste de
        # rh_v1 vers dae.
        form = PosteForm(initial=data, instance=poste, request=request)
        piecesForm = PostePieceForm(instance=poste)
        financementForm = FinancementForm(instance=poste)
        postesComparaisonsForm = PosteComparaisonForm(instance=poste)

    vars.update(dict(form=form, poste=poste, poste_key=key, piecesForm=piecesForm, financementForm=financementForm, postesComparaisonsForm=postesComparaisonsForm))

    return render_to_response('dae/poste.html', vars, RequestContext(request))

@dae_groupe_requis
def postes_liste(request):
    """ Liste des postes. """
    vars = dict()

    vars['postes_a_traiter'] = dae.Poste.objects.mes_choses_a_faire(request.user).all().order_by('-date_creation')
    vars['postes_non_valides'] = dae.Poste.objects.ma_region_ou_service(request.user).filter(~Q(etat=POSTE_ETAT_DRH_FINALISATION)).order_by('-date_creation')
    vars['postes_valides'] = dae.Poste.objects.ma_region_ou_service(request.user).filter(etat=POSTE_ETAT_DRH_FINALISATION).order_by('-date_creation')

    return render_to_response('dae/postes_liste.html', vars, RequestContext(request))

@login_required
def poste_piece(request, id):
    """Téléchargement d'une pièce jointe à un poste."""
    piece = get_object_or_404(dae.PostePiece, pk=id)
    if dae.Poste.objects.ma_region_ou_service(request.user).filter(id=piece.poste_id).exists():
        return sendfile(request, piece.fichier.path, attachment=True)
    else:
        return redirect_interdiction(request)


### DOSSIER

def filtered_type_remun():
    defaut = (2, 3, 8, 17) # salaire de base, indemnité de fonction, charges patronales
    return rh.TypeRemuneration.objects.filter(pk__in=defaut)

@dae_groupe_requis
@dossier_dans_ma_region_ou_service
def embauche_consulter(request, dossier_id):
    dossier = get_object_or_404(dae.Dossier, pk=dossier_id)

    if request.POST:
        validationForm = DossierWorkflowForm(request.POST, instance=dossier, request=request)
        if validationForm.is_valid():
            validationForm.save()
            messages.add_message(request, messages.SUCCESS, "La validation a été enregistrée.")
            return redirect('dae_embauches_liste')
    else:
        validationForm = DossierWorkflowForm(instance=dossier, request=request)
    
    vars = {
        'dossier' : dossier,
        'validationForm' : validationForm,
        }

    mode = request.GET.get('mode', None)
    if mode is None:
        return render_to_response('dae/embauche_consulter.html', vars, RequestContext(request))
    if mode == 'pdf':
        return reponse_pdf('dae/embauche_pdf.html', vars)
    if mode == 'vpdf':
        return render_to_response('dae/embauche_pdf.html', vars, RequestContext(request))

@dae_groupe_requis
@dossier_dans_ma_region_ou_service
@dossier_est_modifiable
def embauche(request, key=None, dossier_id=None):
    """ Formulaire d'autorisation d'embauche. """
    if not key:
        vars = dict(step='poste', form=ChoosePosteForm(request=request))
    else:
        type_remun = filtered_type_remun()
        vars = dict(type_remun=type_remun)
        source, id = key.split('-')
        if source != 'dae':
            return Http404
        poste = get_object_or_404(dae.Poste, pk=id)
        if not dossier_id:
            vars['new'] = True

        if request.POST:
            if request.POST['employe'] == '':
                # Nouvel employé
                employe = dae.Employe()
            else:
                employe_source, id = request.POST['employe'].split('-')
                if employe_source == 'dae':
                    # Employé DAE
                    employe = get_object_or_404(dae.Employe, pk=id)
                elif employe_source == 'rh':
                    # Employé RH, on le copie dans DAE
                    e = get_object_or_404(rh.Employe, pk=id)
                    employe = dae.Employe(id_rh=e, prenom=e.prenom, nom=e.nom,
                                          genre=e.genre)
                else:
                    raise Http404

            employe_form = EmployeForm(request.POST, instance=employe, request=request)

            if request.POST:
                if employe_form.is_valid():
                    data = dict(request.POST.items())
                    #with warnings.catch_warnings():
                    #    warnings.simplefilter('ignore')
                    employe = employe_form.save()
                    data['employe'] = 'dae-%s' % employe.id
                    employe_form = EmployeForm(data, instance=employe, request=request)

                if not dossier_id:
                    dossier = dae.Dossier(poste=poste, employe=employe)
                else:
                    dossier = get_object_or_404(dae.Dossier, pk=dossier_id)

                dossier_form = DossierForm(request.POST, instance=dossier)
                piecesForm = DossierPieceForm(request.POST, request.FILES, instance=dossier)
                dossiersComparaisonsForm = DossierComparaisonForm(request.POST, instance=dossier)
                remunForm = RemunForm(request.POST, instance=dossier)

                if dossier_form.is_valid() and \
                   piecesForm.is_valid() and \
                   dossiersComparaisonsForm.is_valid() and \
                   remunForm.is_valid():
                    employe.save()
                    dossier = dossier_form.save()
                    piecesForm.instance = dossier
                    piecesForm.save()
                    dossiersComparaisonsForm.instance = dossier
                    dossiersComparaisonsForm.save()
                    remunForm.instance = dossier
                    remunForm.save()

                    messages.add_message(request, messages.SUCCESS, "Le dossier %s a été sauvegardé." % dossier)
                    if request.POST.has_key('save'):
                        return redirect('embauche_consulter', dossier_id=dossier.id)
                    else:
                        return redirect('embauche', key=dossier.poste.key, dossier_id=dossier.id)
                        
                else:
                    messages.add_message(request, messages.ERROR, 'Il y a des erreurs dans le formulaire.')
                    
            else:
                dossier_form = DossierForm(instance=dossier)
                piecesForm = DossierPieceForm(instance=dossier)
                dossiersComparaisonsForm = DossierComparaisonForm(instance=dossier)
                remunForm = RemunForm(instance=dossier)
        else:
            # Initialisation d'un formulaire vide
            dossier_rh = rh.Dossier()
            poste_rh = poste.id_rh
            if dossier_id:
                dossier = get_object_or_404(dae.Dossier, pk=dossier_id)
                employe = dossier.employe
                data = dict(employe='dae-%s' % employe.id)
                employe_form = EmployeForm(initial=data, instance=employe, request=request)
            else:
                dossier = pre_filled_dossier(dossier_rh, 'new', poste_rh)
                employe_form = EmployeForm(request=request)

            dossier_form = DossierForm(instance=dossier)
            piecesForm = DossierPieceForm(instance=dossier)
            dossiersComparaisonsForm = DossierComparaisonForm(instance=dossier)
            remunForm = RemunForm(instance=dossier)

        vars = dict(step='employe',
                type_remun=type_remun,
                devises=devises(),
                poste=poste,
                dossier=dossier,
                piecesForm=piecesForm,
                remunForm=remunForm,
                dossiersComparaisonsForm=dossiersComparaisonsForm,
                forms=dict(employe=employe_form, dossier=dossier_form, )
                )
    

    return render_to_response('dae/embauche.html', vars,
                              RequestContext(request))
@dae_groupe_requis
@dossier_dans_ma_region_ou_service
def embauches_liste(request):
    """ Liste des embauches. """
    vars = dict()
    vars['embauches_a_traiter'] = dae.Dossier.objects.mes_choses_a_faire(request.user).all().order_by('-date_creation')
    vars['embauches_en_cours'] = dae.Dossier.objects.ma_region_ou_service(request.user).order_by('-date_creation')
    return render_to_response('dae/embauches_liste.html', vars, RequestContext(request))

def employe(request, key):
    """ Récupération AJAX de l'employé pour la page d'embauche. """
    data = dict(employe=key)

    if key == '':
        # Nouvel employé
        employe = dae.Employe()
    else:
        # Employé existant
        source, id = key.split('-')

        if source == 'dae':
            employe = get_object_or_404(dae.Employe, pk=id)
        elif source == 'rh':
            e = get_object_or_404(rh.Employe, id=id)
            # Initialisation avec les valeurs de l'employé de rh_v1
            employe = dae.Employe(id_rh=e)
            for field in ('prenom', 'nom', 'genre'):
                setattr(employe, field, getattr(e, field))

    return HttpResponse(EmployeForm(initial=data, instance=employe, request=request).as_table())

################################################################################
# AJAX SECURISE
################################################################################
@dae_groupe_requis
@employe_dans_ma_region_ou_service
def dossier(request, poste_key, employe_key):
    """ Récupération AJAX du dossier pour la page d'embauche. """
    data = dict()

    poste_source, poste_id = poste_key.split('-')
    poste = get_object_or_404(dae.Poste, pk=poste_id)

    # Récupérer la devise de l'implantation lié au poste
    implantation_devise = poste.get_default_devise()
    data.update({'devise' : implantation_devise.id})
 
    if poste.id_rh_id is not None:
        poste_rh = get_object_or_404(rh.Poste, pk=poste.id_rh_id)
    else:
        poste_rh = None

    ##########################################################################################
    #   NOUVEL EMPLOYE
    ##########################################################################################
    if employe_key == '':
        employe_source = 'new'
        employe = None
        dossier_rh = rh.Dossier()
        dossier = pre_filled_dossier(dossier_rh, employe_source, poste_rh)

    ##########################################################################################
    #   EMPLOYE DAE
    ##########################################################################################
    if employe_key.startswith('dae'):
      employe_source, employe_id = employe_key.split('-')
      employe_dae = get_object_or_404(dae.Employe, pk=employe_id)

      # récupération de l'ancien dossier rh v1 pour l'employe DAE
      try:
          dossier_rh = rh.Dossier.objects.get(employe=employe_dae.id_rh_id, mandat_date_fin=None)
      except (rh.Dossier.DoesNotExist):
          dossier_rh = rh.Dossier()

      # on tente de récupérer le dossier DAE, au pire on le contruit en le 
      # prépoluant avec son dossier rh v1.
      try:
          dossier = dae.Dossier.objects.get(employe=employe_dae, poste=poste)
      except (dae.Dossier.DoesNotExist):
          dossier = pre_filled_dossier(dossier_rh, employe_source, poste_rh)
      employe = employe_dae.id_rh
    ##########################################################################################
    #   EMPLOYE RH v1
    ##########################################################################################
    if employe_key.startswith('rh'):
      employe_source, employe_id = employe_key.split('-')
      employe_rh = get_object_or_404(rh.Employe, pk=employe_id)

      # récupération de l'ancien dossier rh v1 pour l'employe rh v1, s'il n'en a pas,
      # on en fournit un nouveau qui servira uniquement un créer un nouveau dossier DAE.
      try:
          dossier_rh = rh.Dossier.objects.get(employe=employe_rh, mandat_date_fin=None)
      except (rh.Dossier.DoesNotExist):
          dossier_rh = rh.Dossier()
      dossier = pre_filled_dossier(dossier_rh, employe_source, poste_rh)
      employe = employe_rh

    dossier_form = DossierForm(initial=data, instance=dossier)
    vars = dict(form=dossier_form, poste=poste, employe=employe)
    return render_to_response('dae/embauche-dossier.html', vars,
                          RequestContext(request))

#  @Cette fonction est appelée à partir de fonctions déjà sécurisée
def pre_filled_dossier(dossier_rh, employe_source, poste_rh):
    dossier = dae.Dossier()

    if employe_source != 'new' and dossier_rh.id:
        dossier.statut_anterieur = dossier_rh.statut

        # Certains dossiers ont un classement à zéro
        if dossier_rh.classement_id > 0:
            dossier.classement_anterieur = dossier_rh.classement

        # Récupération du salaire de base
        remun = dossier_rh.remuneration_set.filter(type=1).order_by('-date_effective')
        if remun:
            dossier.salaire_anterieur = remun[0].montant
            dossier.devise_anterieur = remun[0].devise

    # Récupération du titulaire précédent
    try:
        dossiers = rh.Dossier.objects.order_by('-mandat_date_debut')
        if poste_rh:
            dossiers = dossiers.filter(poste1=poste_rh) | dossiers.filter(poste2=poste_rh)
        else:
            dossiers = rh.Dossier.objects.none()
        if len(dossiers):
            # Ce bloc ignore toutes les erreurs, car les données de rh
            # manquantes peuvent en générer
            d = dossiers[0]
            try:
                titulaire = d.employe
                dossier.employe_anterieur = titulaire
                dossier.classement_titulaire_anterieur = d.classement
                dossier.statut_titulaire_anterieur = d.statut
                remun = d.remuneration_set.filter(type=1).order_by('-date_effective')[0]
                dossier.salaire_titulaire_anterieur = remun.montant
                dossier.devise_titulaire_anterieur = remun.devise
            except:
                pass
            # TODO: afficher l'info, les champs ne sont pas dans le
            # modèle dae.Dossier: nom, prenom, classement, salaire
            pass

    except (rh.Dossier.DoesNotExist):
        dossier_rh = rh.Dossier()

    return dossier

@dae_groupe_requis
@vieux_dossier_dans_ma_region_ou_service
def dossier_resume(request, dossier_id=None):
    try:
        dossier = rh.Dossier.objects.get(id=dossier_id)
    except:
        return HttpResponseGone("Ce dossier n'est pas accessible")

    data = {}
    data['personne'] = unicode(dossier.employe)
    data['classement'] = dossier.classement.id
    data['statut'] = dossier.statut.id
    data['implantation'] = dossier.implantation1.id
    data['poste'] = u"%s %s" % (dossier.poste1.type_poste.nom, dossier.complement1)
    data['montant'] = dossier.get_salaire()
    salaire = dossier.get_dernier_salaire_remun()
    if salaire is not None:
        data['devise'] = salaire.devise.id
        data['montant_euros'] = salaire.en_euros()
    else:
        data['devise'] = None
        data['montant_euros'] = 0
    return HttpResponse(dumps(data))

@dae_groupe_requis
@vieux_dossier_dans_ma_region_ou_service
def poste_resume(request, dossier_id=None):
    """
    On travaille, en réalité sur le dossier mais on cache
    l'identité de la personne.
    """
    try:
        dossier = rh.Dossier.objects.get(id=dossier_id)
    except:
        return HttpResponseGone("Ce dossier n'est pas accessible")

    data = {}
    data['implantation'] = dossier.implantation1.id
    data['poste'] = u"%s %s" % (dossier.poste1.type_poste.nom, dossier.complement1)
    data['montant'] = dossier.get_salaire()
    salaire = dossier.get_dernier_salaire_remun()
    if salaire is not None:
        data['devise'] = salaire.devise.id
        data['montant_euros'] = salaire.en_euros()
    else:
        data['devise'] = None
        data['montant_euros'] = 0
    return HttpResponse(dumps(data))

def liste_postes(request):
    """ Appel AJAX : 
    input : implantation_id
    output : JSON liste de valeur point
    """
    method = request.method
    params = getattr(request, method, [])
    data = []

    # Voir le code de _poste_choices dans forms.py
    dae_ = dae.Poste.objects.filter(actif=True, id_rh__isnull=True)
    copies = dae.Poste.objects.exclude(id_rh__isnull=True)
    rh_postes_actifs = rh.Poste.objects.filter(actif=True)

    if 'implantation_id' in params and params.get('implantation_id') is not u"":
        implantation_id = params.get('implantation_id')
        dae_ = dae_.filter(implantation__id=implantation_id)
        copies = copies.filter(implantation__id=implantation_id)
        rh_postes_actifs = rh_postes_actifs.filter(implantation__id=implantation_id)
   
    id_copies = [p.id_rh_id for p in copies.all()]
    rhv1 = rh_postes_actifs.exclude(id__in=id_copies)
    rhv1 = rhv1.select_related(depth=1)

    data = [('', 'Nouveau poste')] +  sorted([('dae-%s' % p.id, label_poste_display(p)) for p in dae_ | copies] + [('rh-%s' % p.id, label_poste_display(p)) for p in rhv1], key=lambda t: t[1])
    return HttpResponse(dumps(data))

@login_required
def dossier_piece(request, id):
    """Téléchargement d'une pièce jointe à un poste."""
    piece = get_object_or_404(dae.DossierPiece, pk=id)
    if dae.Dossier.objects.ma_region_ou_service(request.user).filter(id=piece.dossier_id).exists():
        return sendfile(request, piece.fichier.path, attachment=True)
    else:
        return redirect_interdiction(request)


################################################################################
# AJAX SECURITE non nécessaire
################################################################################
def coefficient(request):
    """ Appel AJAX : 
    input : classement
    output : coefficient
    """
    method = request.method
    params = getattr(request, method, [])
    data = dict()
    if 'classement' in params and params.get('classement') is not u"":
        classement = params.get('classement')
        classement = rh.Classement.objects.get(pk=classement)
        data['coefficient'] = classement.coefficient
    else:
        data['coefficient'] = 0
    return HttpResponse(dumps(data))


def devise(request):
    """ Appel AJAX : 
    input : valeur_point
    output : devise, devise_code, taux_euro
    """
    method = request.method
    params = getattr(request, method, [])
    data = dict()
    if 'valeur_point' in params and params.get('valeur_point') is not u"": 
        valeur_point = params.get('valeur_point')
        valeur_point = rh.ValeurPoint.objects.get(pk=valeur_point)
        annee = valeur_point.annee
        implantation = valeur_point.implantation
        taux = rh.TauxChange.objects.get(annee=annee, 
                                        implantation=implantation)
        data['devise'] = taux.devise.id
        data['valeur'] = valeur_point.valeur
        data['devise_code'] = taux.devise.code
        data['taux_euro'] = taux.taux
    else:
        return HttpResponseGone("Vous devez choisir une valeur de point")
    return HttpResponse(dumps(data))
    
def devise_code(request):
    """ Appel AJAX : 
    input : devise
    output : devise_code, taux_euro
    """
    method = request.method
    params = getattr(request, method, [])
    data = dict()
    if 'devise' in params:
        devise = params.get('devise')
        devise = rh.Devise.objects.get(pk=devise)
        annee = date.today().year
        taux = rh.TauxChange.objects.filter(annee=annee, devise=devise)
        if len(taux) == 0:
            return HttpResponseGone("Le taux n'est pas disponible")
        data['devise_code'] = devise.code
        data['taux_euro'] = taux[0].taux
    return HttpResponse(dumps(data))

def add_remun(request, dossier, type_remun):
    dossier = get_object_or_404(dae.Dossier, pk=dossier)
    type_remun = get_object_or_404(rh.TypeRemuneration, pk=type_remun)
    dae.Remuneration(dossier=dossier, devise=dossier.devise,
                     type=type_remun).save()

    return render_to_response('dae/embauche-remun.html', dict(dossier=dossier),
                              RequestContext(request))

def salaire(request, implantation, devise, classement):
    if not devise or not classement:
        raise Http404

    taux_impl = rh.TauxChange.objects.filter(implantation=implantation) \
                                     .order_by('-annee')
    taux = rh.TauxChange.objects.filter(devise=devise).order_by('-annee')
    vp = rh.ValeurPoint.objects.filter(implantation=implantation) \
                               .order_by('-annee')
    if vp.count() * taux.count() * taux_impl.count() == 0:
        raise Http404

    classement = get_object_or_404(rh.Classement, pk=classement)
    taux, taux_impl, vp = taux[0].taux, taux_impl[0].taux, vp[0].valeur

    salaire_euro = round(vp * classement.coefficient * taux_impl, 2)
    data = dict(salaire_euro=salaire_euro, taux=taux,
                salaire_devise=round(salaire_euro / taux, 2))

    return HttpResponse(dumps(data))

def liste_valeurs_point(request):
    """ Appel AJAX : 
    input : implantation_id
    output : JSON liste de valeur point
    """
    method = request.method
    params = getattr(request, method, [])
    data = []
    annee_courante = datetime.datetime.now().year
    if 'implantation_id' in params and params.get('implantation_id') is not u"":
        implantation_id = params.get('implantation_id')
        preselectionne = rh.ValeurPoint.objects.filter(implantation=implantation_id, annee__in=(annee_courante,)).order_by("-annee")
        for o in preselectionne:
            data.append({'id' : o.id, 'label' : o.__unicode__(), 'devise' : o.get_tauxchange_courant().devise.id, 'suggestion' : True})
    else:
        preselectionne = rh.ValeurPoint.objects.none()

    liste_complete = rh.ValeurPoint.objects.filter(annee__in=(annee_courante,)).order_by("-annee")
    for o in liste_complete.exclude(id__in=[p.id for p in preselectionne]):
        data.append({'id' : o.id, 'label' : o.__unicode__(), 'devise' : o.get_tauxchange_courant().devise.id, 'suggestion' : False})
    return HttpResponse(dumps(data))