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