f7f658c8d3509182f8e0c543f861553aa922d4b8
[auf_rh_dae.git] / project / dae / views.py
1 # -*- encoding: utf-8 -*-
2
3 import os
4 import datetime
5 import StringIO
6 from collections import defaultdict
7 from datetime import date
8 from simplejson import dumps
9 import warnings
10
11 from django.core.urlresolvers import reverse
12 from django.http import Http404, HttpResponse, HttpResponseGone
13 from django.shortcuts import redirect, render_to_response, get_object_or_404
14 from django.template import Context, RequestContext
15 from django.template.loader import get_template
16 from django.contrib import messages
17 from django.conf import settings
18
19 from reversion.models import Version
20 import ho.pisa as pisa
21
22 from project.dae import models as dae
23 from project.rh_v1 import models as rh
24
25 from decorators import dae_groupe_requis, \
26 poste_dans_ma_region_ou_service, \
27 dossier_dans_ma_region_ou_service, \
28 employe_dans_ma_region_ou_service, \
29 dossier_est_modifiable
30 from forms import *
31
32 pisa.showLogging()
33
34 def reponse_pdf(template_src, context_dict):
35 """
36 Générer une réponse HTTP avec un PDF
37 """
38 css = ""
39 for f in ('css/pdf.css', 'css/dae.css'):
40 css_file = os.path.join(settings.MEDIA_ROOT, f)
41 css += open(css_file, 'r').read()
42 context_dict['css'] = css
43
44 template = get_template(template_src)
45 context = Context(context_dict)
46 html = template.render(context)
47 result = StringIO.StringIO()
48 pdf = pisa.pisaDocument(html, result, encoding='UTF-8')
49 if not pdf.err:
50 return HttpResponse(result.getvalue(), mimetype='application/pdf')
51 return HttpResponse("impossible de générer le pdf! %s" % html)
52
53
54 @dae_groupe_requis
55 def index(request):
56 return render_to_response('dae/index.html', {}, RequestContext(request))
57
58 @dae_groupe_requis
59 @poste_dans_ma_region_ou_service
60 def poste_consulter(request, key):
61 source, id = key.split('-')
62 poste = get_object_or_404(dae.Poste, pk=id)
63
64 if request.POST:
65 validationForm = PosteWorkflowForm(request.POST, instance=poste, request=request)
66 if validationForm.is_valid():
67 validationForm.save()
68 messages.add_message(request, messages.SUCCESS, "La validation a été enregistrée.")
69 return redirect('poste_consulter', key=key)
70 else:
71 validationForm = PosteWorkflowForm(instance=poste, request=request)
72
73 vars = {'poste' : poste, 'validationForm' : validationForm, }
74
75
76 mode = request.GET.get('mode', None)
77 if mode is None:
78 return render_to_response('dae/poste_consulter.html', vars, RequestContext(request))
79 if mode == 'pdf':
80 return reponse_pdf('dae/poste_pdf.html', vars)
81 if mode == 'vpdf':
82 return render_to_response('dae/poste_pdf.html', vars, RequestContext(request))
83
84
85 @dae_groupe_requis
86 @poste_dans_ma_region_ou_service
87 def poste(request, key=None):
88 """ Formulaire pour un poste.
89
90 Permet de créer ou modifier un poste. Si le poste n'existe que dans rh_v1
91 il est automatiquement copié dans dae.
92
93 """
94 poste, data, vars = None, dict(), dict()
95
96 if key:
97 # Poste existant
98 data['poste'] = key
99 source, id = key.split('-')
100
101 if source == 'dae':
102 poste = get_object_or_404(dae.Poste, pk=id)
103 elif source == 'rh':
104 p = get_object_or_404(rh.Poste, pk=id)
105 # Initialisation avec les valeurs du poste de rh_v1
106 poste = dae.Poste(id_rh=p, nom=p.type_poste.nom)
107 for field in ('implantation', 'type_poste', 'actif'):
108 setattr(poste, field, getattr(p, field))
109 else:
110 # Nouveau poste
111 vars['new'] = True
112
113 if request.POST:
114 data.update(dict(request.POST.items()))
115 form = PosteForm(data, instance=poste, request=request)
116 financementForm = FinancementForm(request.POST, instance=poste)
117 piecesForm = PostePieceForm(request.POST, request.FILES, instance=poste)
118 if form.is_valid() and piecesForm.is_valid() and financementForm.is_valid():
119 poste = form.save()
120 piecesForm.instance = poste
121 piecesForm.save()
122 financementForm.instance = poste
123 financementForm.save()
124 messages.add_message(request, messages.SUCCESS, "Le poste %s a été sauvegardé." % poste)
125 if request.POST.has_key('save'):
126 return redirect('poste_consulter', key='dae-%s' % poste.id)
127 else:
128 return redirect('poste', key='dae-%s' % poste.id)
129
130 else:
131 messages.add_message(request, messages.ERROR, 'Il y a des erreurs dans le formulaire.')
132
133 else:
134 # 'initial' évite la validation prémature lors d'une copie de poste de
135 # rh_v1 vers dae.
136 form = PosteForm(initial=data, instance=poste, request=request)
137 piecesForm = PostePieceForm(instance=poste)
138 financementForm = FinancementForm(instance=poste)
139
140 vars.update(dict(form=form, poste=poste, poste_key=key, piecesForm=piecesForm, financementForm=financementForm))
141
142 return render_to_response('dae/poste.html', vars, RequestContext(request))
143
144 @dae_groupe_requis
145 def postes_liste(request):
146 """ Liste des postes. """
147 vars = dict()
148 vars['postes'] = dae.Poste.objects.ma_region_ou_service(request.user).order_by('-date_creation')
149 return render_to_response('dae/postes_liste.html', vars, RequestContext(request))
150
151 def filtered_type_remun():
152 # Exclusion de "Indemnité de fonction" des types de rémun utilisés
153 return rh.TypeRemuneration.objects.exclude(pk=7)
154
155 @dae_groupe_requis
156 @dossier_dans_ma_region_ou_service
157 def embauche_consulter(request, dossier_id):
158 dossier = get_object_or_404(dae.Dossier, pk=dossier_id)
159
160 if request.POST:
161 validationForm = DossierWorkflowForm(request.POST, instance=dossier, request=request)
162 if validationForm.is_valid():
163 validationForm.save()
164 messages.add_message(request, messages.SUCCESS, "La validation a été enregistrée.")
165 return redirect('embauche_consulter', dossier_id=dossier.id)
166 else:
167 validationForm = DossierWorkflowForm(instance=dossier, request=request)
168
169 vars = {
170 'dossier' : dossier,
171 'validationForm' : validationForm,
172 }
173
174 mode = request.GET.get('mode', None)
175 if mode is None:
176 return render_to_response('dae/embauche_consulter.html', vars, RequestContext(request))
177 if mode == 'pdf':
178 return reponse_pdf('dae/embauche_pdf.html', vars)
179 if mode == 'vpdf':
180 return render_to_response('dae/embauche_pdf.html', vars, RequestContext(request))
181
182 @dae_groupe_requis
183 @dossier_dans_ma_region_ou_service
184 @dossier_est_modifiable
185 def embauche(request, key=None, dossier_id=None):
186 """ Formulaire d'autorisation d'embauche. """
187 if not key:
188 vars = dict(step='poste', form=ChoosePosteForm(request=request))
189 else:
190 type_remun = filtered_type_remun()
191 vars = dict(type_remun=type_remun)
192 source, id = key.split('-')
193 if source != 'dae':
194 return Http404
195 poste = get_object_or_404(dae.Poste, pk=id)
196 if not dossier_id:
197 vars['new'] = True
198
199 if request.POST:
200 if request.POST['employe'] == '':
201 # Nouvel employé
202 employe = dae.Employe()
203 else:
204 employe_source, id = request.POST['employe'].split('-')
205 if employe_source == 'dae':
206 # Employé DAE
207 employe = get_object_or_404(dae.Employe, pk=id)
208 elif employe_source == 'rh':
209 # Employé RH, on le copie dans DAE
210 e = get_object_or_404(rh.Employe, pk=id)
211 employe = dae.Employe(id_rh=e, prenom=e.prenom, nom=e.nom,
212 genre=e.genre)
213 else:
214 raise Http404
215
216 employe_form = EmployeForm(request.POST, instance=employe, request=request)
217
218 if request.POST:
219 if employe_form.is_valid():
220 data = dict(request.POST.items())
221 #with warnings.catch_warnings():
222 # warnings.simplefilter('ignore')
223 employe = employe_form.save()
224 data['employe'] = 'dae-%s' % employe.id
225 employe_form = EmployeForm(data, instance=employe, request=request)
226
227 if not dossier_id:
228 dossier = dae.Dossier(poste=poste, employe=employe)
229 else:
230 dossier = get_object_or_404(dae.Dossier, pk=dossier_id)
231 dossier_form = DossierForm(request.POST, instance=dossier)
232 piecesForm = DossierPieceForm(request.POST, request.FILES, instance=dossier)
233 justificationsNouveauForm = JustificationNouvelEmployeForm(request.POST, instance=dossier)
234 justificationsAutreForm = JustificationAutreEmployeForm(request.POST, instance=dossier)
235 dossiersComparaisonsForm = DossierComparaisonForm(request.POST, instance=dossier)
236
237 if dossier_form.is_valid() and piecesForm.is_valid() and justificationsNouveauForm.is_valid() and justificationsAutreForm.is_valid() and dossiersComparaisonsForm.is_valid():
238 dossier = dossier_form.save()
239 piecesForm.instance = dossier
240 piecesForm.save()
241 justificationsNouveauForm.instance = dossier
242 justificationsNouveauForm.save()
243 justificationsAutreForm.instance = dossier
244 justificationsAutreForm.save()
245 dossiersComparaisonsForm.instance = dossier
246 dossiersComparaisonsForm.save()
247
248 if not dossier.remuneration_set.all():
249 # Pré-peuplement des entrées de la section "coût
250 # global", à l'exclusion de "Indemnité de fonction"
251 for type in type_remun.all():
252 dae.Remuneration(dossier=dossier, type=type,
253 devise=dossier.devise).save()
254
255 else:
256 # Sauvegarde du coût global
257 cg_lines = defaultdict(dict)
258 for k, v in request.POST.items():
259 if k.startswith('cg-'):
260 prefix, field_name, cg_id = k.split('-')
261 cg_lines[int(cg_id)][unicode(field_name)] = v
262
263 for r in dossier.remuneration_set.all():
264 print 'trying %r' % r
265 if r.id in cg_lines:
266 if cg_lines[r.id]['montant'] == '':
267 r.delete()
268 else:
269 for k, v in cg_lines[r.id].items():
270 setattr(r, k, v)
271 r.save()
272
273 messages.add_message(request, messages.SUCCESS, "Le dossier %s a été sauvegardé." % dossier)
274 if request.POST.has_key('save'):
275 return redirect('embauche_consulter', dossier_id=dossier.id)
276 else:
277 return redirect('embauche', key=dossier.poste.key, dossier_id=dossier.id)
278
279 else:
280 messages.add_message(request, messages.ERROR, 'Il y a des erreurs dans le formulaire.')
281
282 else:
283 dossier_form = DossierForm(instance=dossier)
284 piecesForm = DossierPieceForm(instance=dossier)
285 justificationsNouveauForm = JustificationNouvelEmployeForm(instance=dossier)
286 justificationsAutreForm = JustificationAutreEmployeForm(instance=dossier)
287 dossiersComparaisonsForm = DossierComparaisonForm(instance=dossier)
288 else:
289 # Initialisation d'un formulaire vide
290 dossier_rh = rh.Dossier()
291 poste_rh = poste.id_rh
292 if dossier_id:
293 dossier = get_object_or_404(dae.Dossier, pk=dossier_id)
294 employe = dossier.employe
295 data = dict(employe='dae-%s' % employe.id)
296 employe_form = EmployeForm(initial=data, instance=employe, request=request)
297 else:
298 dossier = pre_filled_dossier(dossier_rh, 'new', poste_rh)
299 employe_form = EmployeForm(request=request)
300
301 dossier_form = DossierForm(instance=dossier)
302 piecesForm = DossierPieceForm(instance=dossier)
303 justificationsNouveauForm = JustificationNouvelEmployeForm(instance=dossier)
304 justificationsAutreForm = JustificationAutreEmployeForm(instance=dossier)
305 dossiersComparaisonsForm = DossierComparaisonForm(instance=dossier)
306
307 vars = dict(step='employe',
308 type_remun=type_remun,
309 poste=poste,
310 dossier=dossier,
311 piecesForm=piecesForm,
312 justificationsNouveauForm=justificationsNouveauForm,
313 justificationsAutreForm=justificationsAutreForm,
314 dossiersComparaisonsForm=dossiersComparaisonsForm,
315 forms=dict(employe=employe_form, dossier=dossier_form, )
316 )
317
318
319 return render_to_response('dae/embauche.html', vars,
320 RequestContext(request))
321 @dae_groupe_requis
322 @dossier_dans_ma_region_ou_service
323 def embauches_liste(request):
324 """ Liste des embauches. """
325 vars = dict()
326 vars['embauches'] = dae.Dossier.objects.ma_region_ou_service(request.user).order_by('-date_creation')
327 return render_to_response('dae/embauches_liste.html', vars, RequestContext(request))
328
329 def employe(request, key):
330 """ Récupération AJAX de l'employé pour la page d'embauche. """
331 data = dict(employe=key)
332
333 if key == '':
334 # Nouvel employé
335 employe = dae.Employe()
336 else:
337 # Employé existant
338 source, id = key.split('-')
339
340 if source == 'dae':
341 employe = get_object_or_404(dae.Employe, pk=id)
342 elif source == 'rh':
343 e = get_object_or_404(rh.Employe, id=id)
344 # Initialisation avec les valeurs de l'employé de rh_v1
345 employe = dae.Employe(id_rh=e)
346 for field in ('prenom', 'nom', 'genre'):
347 setattr(employe, field, getattr(e, field))
348
349 return HttpResponse(EmployeForm(initial=data, instance=employe, request=request).as_table())
350
351 ################################################################################
352 # AJAX SECURISE
353 ################################################################################
354 @dae_groupe_requis
355 @employe_dans_ma_region_ou_service
356 def dossier(request, poste_key, employe_key):
357 """ Récupération AJAX du dossier pour la page d'embauche. """
358 data = dict()
359
360 poste_source, poste_id = poste_key.split('-')
361 poste = get_object_or_404(dae.Poste, pk=poste_id)
362
363 # Récupérer la devise de l'implantation lié au poste
364 implantation_devise = poste.get_default_devise()
365 data.update({'devise' : implantation_devise.id})
366
367 if poste.id_rh_id is not None:
368 poste_rh = get_object_or_404(rh.Poste, pk=poste.id_rh_id)
369 else:
370 poste_rh = None
371
372 ##########################################################################################
373 # NOUVEL EMPLOYE
374 ##########################################################################################
375 if employe_key == '':
376 employe_source = 'new'
377 employe = None
378 dossier_rh = rh.Dossier()
379 dossier = pre_filled_dossier(dossier_rh, employe_source, poste_rh)
380
381 ##########################################################################################
382 # EMPLOYE DAE
383 ##########################################################################################
384 if employe_key.startswith('dae'):
385 employe_source, employe_id = employe_key.split('-')
386 employe_dae = get_object_or_404(dae.Employe, pk=employe_id)
387
388 # récupération de l'ancien dossier rh v1 pour l'employe DAE
389 try:
390 dossier_rh = rh.Dossier.objects.get(employe=employe_dae.id_rh_id, mandat_date_fin=None)
391 except (rh.Dossier.DoesNotExist):
392 dossier_rh = rh.Dossier()
393
394 # on tente de récupérer le dossier DAE, au pire on le contruit en le
395 # prépoluant avec son dossier rh v1.
396 try:
397 dossier = dae.Dossier.objects.get(employe=employe_dae, poste=poste)
398 except (dae.Dossier.DoesNotExist):
399 dossier = pre_filled_dossier(dossier_rh, employe_source, poste_rh)
400 employe = employe_dae.id_rh
401 ##########################################################################################
402 # EMPLOYE RH v1
403 ##########################################################################################
404 if employe_key.startswith('rh'):
405 employe_source, employe_id = employe_key.split('-')
406 employe_rh = get_object_or_404(rh.Employe, pk=employe_id)
407
408 # récupération de l'ancien dossier rh v1 pour l'employe rh v1, s'il n'en a pas,
409 # on en fournit un nouveau qui servira uniquement un créer un nouveau dossier DAE.
410 try:
411 dossier_rh = rh.Dossier.objects.get(employe=employe_rh, mandat_date_fin=None)
412 except (rh.Dossier.DoesNotExist):
413 dossier_rh = rh.Dossier()
414 dossier = pre_filled_dossier(dossier_rh, employe_source, poste_rh)
415 employe = employe_rh
416
417 dossier_form = DossierForm(initial=data, instance=dossier)
418 vars = dict(form=dossier_form, poste=poste, employe=employe)
419 return render_to_response('dae/embauche-dossier.html', vars,
420 RequestContext(request))
421
422 # @Cette fonction est appelée à partir de fonctions déjà sécurisée
423 def pre_filled_dossier(dossier_rh, employe_source, poste_rh):
424 dossier = dae.Dossier()
425
426 if employe_source != 'new' and dossier_rh.id:
427 dossier.statut_anterieur = dossier_rh.statut
428
429 # Certains dossiers ont un classement à zéro
430 if dossier_rh.classement_id > 0:
431 dossier.classement_anterieur = dossier_rh.classement
432
433 # Récupération du salaire de base
434 remun = dossier_rh.remuneration_set.filter(type=1)
435 if remun:
436 dossier.salaire_anterieur = remun[0].montant
437
438 # Récupération du titulaire précédent
439 try:
440 dossiers = rh.Dossier.objects.order_by('-mandat_date_fin')
441 dossiers = dossiers.filter(poste1=poste_rh) | dossiers.filter(poste2=poste_rh)
442 if len(dossiers):
443 # Ce bloc ignore toutes les erreurs, car les données de rh
444 # manquantes peuvent en générer
445 d = dossiers[0]
446 try:
447 titulaire = d.employe
448 dossier.employe_anterieur = titulaire
449 dossier.classement_titulaire_anterieur = d.classement
450 dossier.statut_titulaire_anterieur = d.statut
451 dossier.salaire_titulaire_anterieur = \
452 d.remuneration_set.all()[0].montant
453 except:
454 pass
455 # TODO: afficher l'info, les champs ne sont pas dans le
456 # modèle dae.Dossier: nom, prenom, classement, salaire
457 pass
458
459 except (rh.Dossier.DoesNotExist):
460 dossier_rh = rh.Dossier()
461
462 return dossier
463
464 @dae_groupe_requis
465 @dossier_dans_ma_region_ou_service
466 def dossier_resume(request, dossier_id=None):
467 """ Appel AJAX :
468 input : valeur_point
469 output : devise, devise_code, taux_euro
470 """
471 try:
472 dossier = rh.Dossier.objects.get(id=dossier_id)
473 except:
474 return HttpResponseGone("Ce dossier n'est pas accessible")
475
476 data = {}
477 data['personne'] = unicode(dossier.employe)
478 data['implantation'] = dossier.implantation1.id
479 data['poste'] = u"%s %s" % (dossier.poste1.type_poste.nom, dossier.complement1)
480 data['montant'] = dossier.get_salaire()
481 salaire = dossier.get_dernier_salaire_remun()
482 if salaire is not None:
483 data['devise'] = dossier.get_dernier_salaire_remun().devise.id
484 data['montant_euros'] = dossier.get_dernier_salaire_remun().en_euros()
485 else:
486 data['devise'] = None
487 data['montant_euros'] = 0
488 return HttpResponse(dumps(data))
489
490 def liste_postes(request):
491 """ Appel AJAX :
492 input : implantation_id
493 output : JSON liste de valeur point
494 """
495 method = request.method
496 params = getattr(request, method, [])
497 data = []
498
499 # Voir le code de _poste_choices dans forms.py
500 dae_ = dae.Poste.objects.filter(actif=True, id_rh__isnull=True)
501 copies = dae.Poste.objects.exclude(id_rh__isnull=True)
502 rh_postes_actifs = rh.Poste.objects.filter(actif=True)
503
504 if 'implantation_id' in params and params.get('implantation_id') is not u"":
505 implantation_id = params.get('implantation_id')
506 dae_ = dae_.filter(implantation__id=implantation_id)
507 copies = copies.filter(implantation__id=implantation_id)
508 rh_postes_actifs = rh_postes_actifs.filter(implantation__id=implantation_id)
509
510 id_copies = [p.id_rh_id for p in copies.all()]
511 rhv1 = rh_postes_actifs.exclude(id__in=id_copies)
512 rhv1 = rhv1.select_related(depth=1)
513
514 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])
515 return HttpResponse(dumps(data))
516
517
518 ################################################################################
519 # AJAX SECURITE non nécessaire
520 ################################################################################
521 def coefficient(request):
522 """ Appel AJAX :
523 input : classement
524 output : coefficient
525 """
526 method = request.method
527 params = getattr(request, method, [])
528 data = dict()
529 if 'classement' in params and params.get('classement') is not u"":
530 classement = params.get('classement')
531 classement = rh.Classement.objects.get(pk=classement)
532 data['coefficient'] = classement.coefficient
533 else:
534 data['coefficient'] = 0
535 return HttpResponse(dumps(data))
536
537
538 def devise(request):
539 """ Appel AJAX :
540 input : valeur_point
541 output : devise, devise_code, taux_euro
542 """
543 method = request.method
544 params = getattr(request, method, [])
545 data = dict()
546 if 'valeur_point' in params and params.get('valeur_point') is not u"":
547 valeur_point = params.get('valeur_point')
548 valeur_point = rh.ValeurPoint.objects.get(pk=valeur_point)
549 annee = valeur_point.annee
550 implantation = valeur_point.implantation
551 taux = rh.TauxChange.objects.get(annee=annee,
552 implantation=implantation)
553 data['devise'] = taux.devise.id
554 data['valeur'] = valeur_point.valeur
555 data['devise_code'] = taux.devise.code
556 data['taux_euro'] = taux.taux
557 else:
558 return HttpResponseGone("Vous devez choisir une valeur de point")
559 return HttpResponse(dumps(data))
560
561 def devise_code(request):
562 """ Appel AJAX :
563 input : devise
564 output : devise_code, taux_euro
565 """
566 method = request.method
567 params = getattr(request, method, [])
568 data = dict()
569 if 'devise' in params:
570 devise = params.get('devise')
571 devise = rh.Devise.objects.get(pk=devise)
572 annee = date.today().year
573 taux = rh.TauxChange.objects.filter(annee=annee, devise=devise)
574 if len(taux) == 0:
575 return HttpResponseGone("Le taux n'est pas disponible")
576 data['devise_code'] = devise.code
577 data['taux_euro'] = taux[0].taux
578 return HttpResponse(dumps(data))
579
580 def add_remun(request, dossier, type_remun):
581 dossier = get_object_or_404(dae.Dossier, pk=dossier)
582 type_remun = get_object_or_404(rh.TypeRemuneration, pk=type_remun)
583 dae.Remuneration(dossier=dossier, devise=dossier.devise,
584 type=type_remun).save()
585
586 return render_to_response('dae/embauche-remun.html', dict(dossier=dossier),
587 RequestContext(request))
588
589 def salaire(request, implantation, devise, classement):
590 if not devise or not classement:
591 raise Http404
592
593 taux_impl = rh.TauxChange.objects.filter(implantation=implantation) \
594 .order_by('-annee')
595 taux = rh.TauxChange.objects.filter(devise=devise).order_by('-annee')
596 vp = rh.ValeurPoint.objects.filter(implantation=implantation) \
597 .order_by('-annee')
598 if vp.count() * taux.count() * taux_impl.count() == 0:
599 raise Http404
600
601 classement = get_object_or_404(rh.Classement, pk=classement)
602 taux, taux_impl, vp = taux[0].taux, taux_impl[0].taux, vp[0].valeur
603
604 salaire_euro = round(vp * classement.coefficient * taux_impl, 2)
605 data = dict(salaire_euro=salaire_euro, taux=taux,
606 salaire_devise=round(salaire_euro / taux, 2))
607
608 return HttpResponse(dumps(data))
609
610 def liste_valeurs_point(request):
611 """ Appel AJAX :
612 input : implantation_id
613 output : JSON liste de valeur point
614 """
615 method = request.method
616 params = getattr(request, method, [])
617 data = []
618 annee_courante = datetime.datetime.now().year
619 if 'implantation_id' in params and params.get('implantation_id') is not u"":
620 implantation_id = params.get('implantation_id')
621 objects = rh.ValeurPoint.objects.filter(implantation=implantation_id, annee__in=(annee_courante-1, annee_courante)).order_by("-annee")
622 else:
623 objects = rh.ValeurPoint.objects.filter(annee__in=(annee_courante-1, annee_courante)).order_by("-annee")
624 for o in objects:
625 data.append({'id' : o.id, 'label' : o.__unicode__(), })
626 return HttpResponse(dumps(data))
627