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.exceptions import MultipleObjectsReturned
  12 from django.core.urlresolvers import reverse
  13 from django.core.paginator import Paginator, InvalidPage
  14 from django.http import Http404, HttpResponse, HttpResponseGone
  15 from django.shortcuts import redirect, render_to_response, get_object_or_404
  16 from django.views.static import serve
  17 from django.template import Context, RequestContext
  18 from django.template.loader import get_template
  19 from django.contrib import messages
  20 from django.conf import settings
  21 from django.contrib.auth.decorators import login_required
  22 from django.contrib.contenttypes.models import ContentType
  23
  24 from reversion.models import Version
  25
  26 from sendfile import sendfile
  27
  28 from auf.django.permissions.decorators import get_object
  29
  30 from dae import models as dae
  31 from dae.forms import *
  32 from dae.workflow import DOSSIER_ETAT_FINALISE, DOSSIER_ETAT_REGION_FINALISATION, \
  33                          DOSSIER_ETAT_DRH_FINALISATION, POSTE_ETAT_FINALISE
  34 from dae.decorators import redirect_interdiction, dae_groupe_requis, \
  35         poste_dans_ma_region_ou_service, \
  36         dossier_dans_ma_region_ou_service, \
  37         vieux_dossier_dans_ma_region_ou_service, \
  38         employe_dans_ma_region_ou_service, \
  39         dossier_est_modifiable, \
  40         poste_est_modifiable, get_contrat
  41 from dae.mail import send_drh_finalisation_mail
  42 from rh import models as rh
  43
  44
  45 def devises():
  46     liste = []
  47     for d in rh.Devise.objects.all():
  48         annee = date.today().year
  49         taux = rh.TauxChange.objects.filter(annee=annee, devise=d)
  50         data = {}
  51         if len(taux) == 0:
  52             data['taux_euro'] = 0
  53         else:
  54             data['taux_euro'] = taux[0].taux
  55         data['devise_code'] = d.code
  56         liste.append(data)
  57     return liste
  58
  59 @dae_groupe_requis
  60 def index(request):
  61     return render_to_response('dae/index.html', {}, RequestContext(request))
  62
  63
  64 ### POSTE
  65
  66 @dae_groupe_requis
  67 @poste_dans_ma_region_ou_service
  68 def poste_consulter(request, key):
  69     source, id = key.split('-')
  70     poste = get_object_or_404(dae.Poste, pk=id)
  71
  72     if request.POST:
  73         validationForm = PosteWorkflowForm(request.POST, instance=poste, request=request)
  74         if validationForm.is_valid():
  75             validationForm.save()
  76             messages.add_message(request, messages.SUCCESS, "La validation a été enregistrée.")
  77             return redirect('dae_postes_liste')
  78     else:
  79         validationForm = PosteWorkflowForm(instance=poste, request=request)
  80
  81     comparaisons_internes = poste.comparaisons_internes.ma_region_ou_service(request.user)
  82
  83     vars = {
  84         'poste': poste,
  85         'validationForm': validationForm,
  86         'comparaisons_internes': comparaisons_internes
  87     }
  88
  89     return render_to_response('dae/poste_consulter.html', vars, RequestContext(request))
  90
  91 @dae_groupe_requis
  92 @poste_dans_ma_region_ou_service
  93 @poste_est_modifiable
  94 def poste(request, key=None):
  95     """ Formulaire pour un poste.
  96
  97     Permet de créer ou modifier un poste. Si le poste n'existe que dans rh_v1
  98     il est automatiquement copié dans dae.
  99
 100     """
 101     poste, data, vars = None, dict(), dict()
 102
 103     if key:
 104         # Poste existant
 105         data['poste'] = key
 106         source, id = key.split('-')
 107
 108         if source == 'dae':
 109             poste = get_object_or_404(dae.Poste, pk=id)
 110         elif source == 'rh':
 111             p = get_object_or_404(rh.Poste, pk=id)
 112             # Initialisation avec les valeurs du poste de rh_v1
 113             poste = dae.Poste(id_rh=p, nom=p.type_poste.nom)
 114             for field in ('implantation', 'type_poste', 'actif'):
 115                 setattr(poste, field, getattr(p, field))
 116     else:
 117         # Nouveau poste
 118         vars['new'] = True
 119
 120     if request.POST:
 121         data.update(dict(request.POST.items()))
 122         form = PosteForm(data, instance=poste, request=request)
 123         financementForm = FinancementForm(request.POST, instance=poste)
 124         piecesForm = PostePieceForm(request.POST, request.FILES, instance=poste)
 125         if isinstance(poste, dae.Poste):
 126             comparaisons_formset = PosteComparaisonFormSet(
 127                 request.POST,
 128                 queryset=poste.comparaisons_internes.ma_region_ou_service(request.user)
 129             )
 130         else:
 131             comparaisons_formset = PosteComparaisonFormSet(
 132                 request.POST,
 133                 queryset=dae.PosteComparaison.objects.none()
 134             )
 135         if form.is_valid() and piecesForm.is_valid() and financementForm.is_valid() and \
 136            comparaisons_formset.is_valid():
 137             poste = form.save()
 138             piecesForm.instance = poste
 139             piecesForm.save()
 140             financementForm.instance = poste
 141             financementForm.save()
 142
 143             # Ne remplacer que les comparaisons de ma région
 144             comparaisons = comparaisons_formset.save(commit=False)
 145             for comparaison in comparaisons:
 146                 comparaison.poste = poste
 147                 comparaison.save()
 148
 149             messages.add_message(request, messages.SUCCESS, "Le poste %s a été sauvegardé." % poste)
 150             if request.POST.has_key('save'):
 151                 return redirect('poste_consulter', key='dae-%s' % poste.id)
 152             else:
 153                 return redirect('poste', key='dae-%s' % poste.id)
 154
 155         else:
 156             messages.add_message(request, messages.ERROR, 'Il y a des erreurs dans le formulaire.')
 157
 158     else:
 159         # 'initial' évite la validation prémature lors d'une copie de poste de
 160         # rh_v1 vers dae.
 161         form = PosteForm(initial=data, instance=poste, request=request)
 162         piecesForm = PostePieceForm(instance=poste)
 163         financementForm = FinancementForm(instance=poste)
 164         if isinstance(poste, dae.Poste):
 165             comparaisons_formset = PosteComparaisonFormSet(
 166                 queryset=poste.comparaisons_internes.ma_region_ou_service(request.user)
 167             )
 168         else:
 169             comparaisons_formset = PosteComparaisonFormSet(
 170                 queryset=dae.PosteComparaison.objects.none()
 171             )
 172
 173     vars.update(dict(
 174         form=form, poste=poste, poste_key=key, piecesForm=piecesForm,
 175         financementForm=financementForm,
 176         comparaisons_formset=comparaisons_formset
 177     ))
 178
 179     return render_to_response('dae/poste.html', vars, RequestContext(request))
 180
 181 @dae_groupe_requis
 182 def postes_liste(request):
 183     """ Liste des postes. """
 184     content_type = ContentType.objects.get_for_model(dae.Poste)
 185     extra_select = {'derniere_validation': (
 186         "SELECT MAX(date) FROM workflow_workflowcommentaire "
 187         "WHERE content_type_id = '%s' AND object_id = dae_poste.id" % content_type.id
 188     )}
 189     postes_a_traiter = dae.Poste.objects.mes_choses_a_faire(request.user) \
 190             .extra(select=extra_select).order_by('-date_creation')
 191     postes_en_cours = dae.Poste.objects.ma_region_ou_service(request.user) \
 192             .extra(select=extra_select).filter(~Q(etat=POSTE_ETAT_FINALISE)).order_by('-date_creation')
 193     return render_to_response('dae/postes_liste.html', {
 194         'postes_a_traiter': postes_a_traiter,
 195         'postes_en_cours': postes_en_cours,
 196     }, RequestContext(request))
 197
 198 @login_required
 199 def poste_piece(request, id, filename):
 200     """Téléchargement d'une pièce jointe à un poste."""
 201     piece = get_object_or_404(dae.PostePiece, pk=id)
 202     if dae.Poste.objects.ma_region_ou_service(request.user).filter(id=piece.poste_id).exists():
 203         return sendfile(request, piece.fichier.path)
 204     else:
 205         return redirect_interdiction(request)
 206
 207
 208 ### DOSSIER
 209
 210 def filtered_type_remun():
 211     defaut = (2, 3, 8, 17) # salaire de base, indemnité de fonction, charges patronales
 212     return rh.TypeRemuneration.objects.filter(pk__in=defaut)
 213
 214 @dae_groupe_requis
 215 @dossier_dans_ma_region_ou_service
 216 def embauche_consulter(request, dossier_id):
 217     dossier = get_object_or_404(dae.Dossier, pk=dossier_id)
 218     etat_precedent = dossier.etat
 219
 220     if request.POST:
 221         validationForm = DossierWorkflowForm(request.POST, instance=dossier, request=request)
 222         if validationForm.is_valid():
 223             if etat_precedent == DOSSIER_ETAT_REGION_FINALISATION and \
 224                validationForm.cleaned_data['etat'] == DOSSIER_ETAT_DRH_FINALISATION:
 225                 send_drh_finalisation_mail(request, dossier)
 226             validationForm.save()
 227             messages.add_message(request, messages.SUCCESS, "La validation a été enregistrée.")
 228             return redirect('dae_embauches_liste')
 229     else:
 230         validationForm = DossierWorkflowForm(instance=dossier, request=request)
 231
 232     comparaisons_internes = dossier.poste.comparaisons_internes.ma_region_ou_service(request.user)
 233     comparaisons = dossier.comparaisons.ma_region_ou_service(request.user)
 234     vars = {
 235         'dossier': dossier,
 236         'validationForm': validationForm,
 237         'comparaisons_internes': comparaisons_internes,
 238         'comparaisons': comparaisons
 239     }
 240
 241     mode = request.GET.get('mode', None)
 242     return render_to_response('dae/embauche_consulter.html', vars, RequestContext(request))
 243
 244 @dae_groupe_requis
 245 def embauche_choisir_poste(request):
 246     return render_to_response('dae/embauche-choisir-poste.html', {
 247         'form': ChoosePosteForm(request=request)
 248     }, RequestContext(request))
 249
 250 @dae_groupe_requis
 251 @dossier_dans_ma_region_ou_service
 252 @dossier_est_modifiable
 253 def embauche(request, key=None, dossier_id=None):
 254     """ Formulaire d'autorisation d'embauche. """
 255
 256     # Récupérer ou créer un poste et un dossier
 257     source, id = key.split('-')
 258     if source != 'dae':
 259         return Http404
 260     poste = get_object_or_404(dae.Poste, pk=id)
 261
 262     if request.POST:
 263         if request.POST['employe'] == '':
 264             # Nouvel employé
 265             employe = dae.Employe()
 266         else:
 267             employe_source, id = request.POST['employe'].split('-')
 268             if employe_source == 'dae':
 269                 # Employé DAE
 270                 employe = get_object_or_404(dae.Employe, pk=id)
 271             elif employe_source == 'rh':
 272                 # Employé RH, on le copie dans DAE
 273                 e = get_object_or_404(rh.Employe, pk=id)
 274                 employe = dae.Employe(id_rh=e, prenom=e.prenom, nom=e.nom,
 275                                       genre=e.genre)
 276             else:
 277                 raise Http404
 278
 279         employe_form = EmployeForm(request.POST, instance=employe, request=request)
 280
 281         if employe_form.is_valid():
 282             data = dict(request.POST.items())
 283             employe = employe_form.save()
 284             data['employe'] = 'dae-%s' % employe.id
 285             employe_form = EmployeForm(data, instance=employe, request=request)
 286
 287         if not dossier_id:
 288             dossier = dae.Dossier(poste=poste, employe=employe)
 289         else:
 290             dossier = get_object_or_404(dae.Dossier, pk=dossier_id)
 291
 292         dossier_form = DossierForm(request.POST, instance=dossier)
 293         piecesForm = DossierPieceForm(request.POST, request.FILES, instance=dossier)
 294         comparaisons_formset = DossierComparaisonFormSet(
 295             request.POST,
 296             queryset=dossier.comparaisons.ma_region_ou_service(request.user)
 297         )
 298         remunForm = RemunForm(request.POST, instance=dossier)
 299
 300         if employe_form.is_valid() and \
 301            dossier_form.is_valid() and \
 302            piecesForm.is_valid() and \
 303            comparaisons_formset.is_valid() and \
 304            remunForm.is_valid():
 305             employe.save()
 306             dossier_form.save()
 307             piecesForm.save()
 308             remunForm.save()
 309
 310             # Ne remplacer que les comparaisons de ma région
 311             comparaisons = comparaisons_formset.save(commit=False)
 312             for comparaison in comparaisons:
 313                 comparaison.dossier = dossier
 314                 comparaison.save()
 315
 316             messages.success(request, "Le dossier %s a été sauvegardé." % dossier)
 317             if request.POST.has_key('save'):
 318                 return redirect('embauche_consulter', dossier_id=dossier.id)
 319             else:
 320                 return redirect('embauche', key=dossier.poste.key, dossier_id=dossier.id)
 321
 322         else:
 323             messages.add_message(request, messages.ERROR, 'Il y a des erreurs dans le formulaire.')
 324
 325     else:
 326         # Initialisation d'un formulaire vide
 327         if dossier_id:
 328             dossier = get_object_or_404(dae.Dossier, pk=dossier_id)
 329             employe = dossier.employe
 330             data = dict(employe='dae-%s' % employe.id)
 331             employe_form = EmployeForm(initial=data, instance=employe, request=request)
 332         else:
 333             dossier_rh = rh.Dossier()
 334             poste_rh = poste.id_rh
 335             dossier = pre_filled_dossier(dossier_rh, 'new', poste_rh)
 336             employe_form = EmployeForm(request=request)
 337
 338         dossier_form = DossierForm(instance=dossier)
 339         piecesForm = DossierPieceForm(instance=dossier)
 340         comparaisons_formset = DossierComparaisonFormSet(
 341             queryset=dossier.comparaisons.ma_region_ou_service(request.user)
 342         )
 343         remunForm = RemunForm(instance=dossier)
 344
 345     try:
 346         comparaisons_internes = dossier.poste.comparaisons_internes.ma_region_ou_service(
 347             request.user
 348         )
 349     except dae.Poste.DoesNotExist:
 350         comparaisons_internes = []
 351
 352     return render_to_response('dae/embauche.html', {
 353         'type_remun': filtered_type_remun(),
 354         'devises': devises(),
 355         'poste': poste,
 356         'dossier': dossier,
 357         'piecesForm': piecesForm,
 358         'remunForm': remunForm,
 359         'comparaisons_formset': comparaisons_formset,
 360         'forms': dict(employe=employe_form, dossier=dossier_form, ),
 361         'comparaisons_internes': comparaisons_internes
 362     }, RequestContext(request))
 363
 364 @dae_groupe_requis
 365 @dossier_dans_ma_region_ou_service
 366 def embauches_liste(request):
 367     """ Liste des embauches. """
 368     content_type = ContentType.objects.get_for_model(dae.Dossier)
 369     extra_select = {'derniere_validation': (
 370         "SELECT MAX(date) FROM workflow_workflowcommentaire "
 371         "WHERE content_type_id = '%s' AND object_id = dae_dossier.id" % content_type.id
 372     )}
 373     embauches_a_traiter = dae.Dossier.objects.mes_choses_a_faire(request.user) \
 374             .extra(select=extra_select).order_by('-date_creation')
 375     embauches_en_cours = dae.Dossier.objects.ma_region_ou_service(request.user) \
 376             .extra(select=extra_select).order_by('-date_creation').exclude(etat=DOSSIER_ETAT_FINALISE)
 377     return render_to_response('dae/embauches_liste.html', {
 378         'embauches_a_traiter': embauches_a_traiter,
 379         'embauches_en_cours': embauches_en_cours,
 380     }, RequestContext(request))
 381
 382 @dae_groupe_requis
 383 def embauches_finalisees(request):
 384     """Liste des embauches finalisées."""
 385     embauches = dae.Dossier.objects.ma_region_ou_service(request.user) \
 386             .filter(etat=DOSSIER_ETAT_FINALISE)
 387
 388     # Tri
 389     tri = request.GET.get('tri', None)
 390     if tri and tri.startswith('-'):
 391         dir = '-'
 392         tri = tri[1:]
 393     else:
 394         dir = ''
 395     if tri == 'region':
 396         embauches = embauches.order_by(dir + 'poste__implantation__region__nom')
 397     elif tri == 'implantation':
 398         embauches = embauches.order_by(dir + 'poste__implantation__nom')
 399     elif tri == 'poste':
 400         embauches = embauches.order_by(dir + 'poste__nom')
 401     elif tri == 'personne':
 402         embauches = embauches.order_by(dir + 'employe__nom',
 403                                        dir + 'employe__prenom')
 404     elif tri == 'date_debut':
 405         embauches = embauches.order_by(dir + 'debut_contrat')
 406     elif tri == 'date_fin':
 407         embauches = embauches.order_by(dir + 'fin_contrat')
 408
 409     # Pagination
 410     paginator = Paginator(embauches, 20)
 411     try:
 412         page = paginator.page(request.GET.get('page', 1))
 413     except InvalidPage:
 414         page = paginator.page(1)
 415
 416     return render_to_response('dae/embauches_finalisees.html', {
 417         'embauches': page
 418     }, RequestContext(request))
 419
 420 def employe(request, key):
 421     """ Récupération AJAX de l'employé pour la page d'embauche. """
 422     data = dict(employe=key)
 423
 424     if key == '':
 425         # Nouvel employé
 426         employe = dae.Employe()
 427     else:
 428         # Employé existant
 429         source, id = key.split('-')
 430
 431         if source == 'dae':
 432             employe = get_object_or_404(dae.Employe, pk=id)
 433         elif source == 'rh':
 434             e = get_object_or_404(rh.Employe, id=id)
 435             # Initialisation avec les valeurs de l'employé de rh_v1
 436             employe = dae.Employe(id_rh=e)
 437             for field in ('prenom', 'nom', 'genre'):
 438                 setattr(employe, field, getattr(e, field))
 439
 440     return HttpResponse(EmployeForm(initial=data, instance=employe, request=request).as_table())
 441
 442 ### CONTRATS
 443
 444 @dae_groupe_requis
 445 @get_contrat
 446 def contrat(request, contrat, filename):
 447     return sendfile(request, contrat.fichier.path)
 448
 449 @dae_groupe_requis
 450 @get_contrat
 451 def contrat_supprimer(request, contrat):
 452     if request.method == 'POST':
 453         if 'oui' in request.POST:
 454             contrat.delete()
 455         return redirect('embauche_consulter', dossier_id=contrat.dossier.id)
 456     return render_to_response('dae/contrat-supprimer.html', {
 457         'contrat': contrat
 458     }, RequestContext(request))
 459
 460 @dae_groupe_requis
 461 @dossier_dans_ma_region_ou_service
 462 def embauche_ajouter_contrat(request, dossier_id=None):
 463     dossier = get_object_or_404(dae.Dossier, pk=dossier_id)
 464     if request.method == 'POST':
 465         form = ContratForm(request.POST, request.FILES)
 466         if form.is_valid():
 467             contrat = form.save(commit=False)
 468             contrat.dossier = dossier
 469             contrat.save()
 470             return redirect('embauche_consulter', dossier_id=dossier.id)
 471     else:
 472         form = ContratForm()
 473     return render_to_response('dae/embauche-ajouter-contrat.html', {
 474         'form': form
 475     }, RequestContext(request))
 476
 477 ### DAE NUMERISEE
 478
 479 @get_object(dae.Dossier, 'consulter')
 480 def dae_numerisee(request, dossier):
 481     return sendfile(request, dossier.dae_numerisee.path)
 482
 483 @get_object(dae.Dossier, 'modifier_dae_numerisee')
 484 def dae_numerisee_modifier(request, dossier):
 485     if request.method == 'POST':
 486         form = DAENumeriseeForm(request.POST, request.FILES, instance=dossier)
 487         if form.is_valid():
 488             form.save()
 489             return redirect('embauche_consulter', dossier_id=dossier.id)
 490     else:
 491         form = DAENumeriseeForm(instance=dossier)
 492     return render_to_response('dae/dae_numerisee_modifier.html', {
 493         'form': form
 494     }, RequestContext(request))
 495
 496 @get_object(dae.Dossier, 'modifier_dae_numerisee')
 497 def dae_numerisee_supprimer(request, dossier):
 498     if request.method == 'POST':
 499         if 'oui' in request.POST:
 500             dossier.dae_numerisee = None
 501             dossier.save()
 502             return redirect('embauche_consulter', dossier_id=dossier.id)
 503     return render_to_response('dae/dae_numerisee_supprimer.html', {}, RequestContext(request))
 504
 505 ################################################################################
 506 # AJAX SECURISE
 507 ################################################################################
 508 @dae_groupe_requis
 509 @employe_dans_ma_region_ou_service
 510 def dossier(request, poste_key, employe_key):
 511     """ Récupération AJAX du dossier pour la page d'embauche. """
 512     data = dict()
 513
 514     poste_source, poste_id = poste_key.split('-')
 515     poste = get_object_or_404(dae.Poste, pk=poste_id)
 516
 517     # Récupérer la devise de l'implantation lié au poste
 518     implantation_devise = poste.get_default_devise()
 519     data.update({'devise' : implantation_devise})
 520
 521     if poste.id_rh_id is not None:
 522         poste_rh = get_object_or_404(rh.Poste, pk=poste.id_rh_id)
 523     else:
 524         poste_rh = None
 525
 526     ##########################################################################################
 527     #   NOUVEL EMPLOYE
 528     ##########################################################################################
 529     if employe_key == '':
 530         employe_source = 'new'
 531         employe = None
 532         dossier_rh = rh.Dossier()
 533         dossier = pre_filled_dossier(dossier_rh, employe_source, poste_rh)
 534
 535     ##########################################################################################
 536     #   EMPLOYE DAE
 537     ##########################################################################################
 538     if employe_key.startswith('dae'):
 539       employe_source, employe_id = employe_key.split('-')
 540       employe_dae = get_object_or_404(dae.Employe, pk=employe_id)
 541
 542       # récupération de l'ancien dossier rh v1 pour l'employe DAE
 543       try:
 544           dossier_rh = rh.Dossier.objects.get(employe=employe_dae.id_rh_id, date_fin=None)
 545       except (rh.Dossier.DoesNotExist):
 546           dossier_rh = rh.Dossier()
 547
 548       # on tente de récupérer le dossier DAE, au pire on le contruit en le
 549       # prépoluant avec son dossier rh v1.
 550       try:
 551           dossier = dae.Dossier.objects.get(employe=employe_dae, poste=poste)
 552       except (dae.Dossier.DoesNotExist):
 553           dossier = pre_filled_dossier(dossier_rh, employe_source, poste_rh)
 554       employe = employe_dae.id_rh
 555     ##########################################################################################
 556     #   EMPLOYE RH v1
 557     ##########################################################################################
 558     if employe_key.startswith('rh'):
 559       employe_source, employe_id = employe_key.split('-')
 560       employe_rh = get_object_or_404(rh.Employe, pk=employe_id)
 561
 562       # récupération de l'ancien dossier rh v1 pour l'employe rh v1, s'il n'en a pas,
 563       # on en fournit un nouveau qui servira uniquement un créer un nouveau dossier DAE.
 564       try:
 565           dossier_rh = rh.Dossier.objects.get(employe=employe_rh, date_fin=None)
 566       except (rh.Dossier.DoesNotExist):
 567           dossier_rh = rh.Dossier()
 568       dossier = pre_filled_dossier(dossier_rh, employe_source, poste_rh)
 569       employe = employe_rh
 570
 571     dossier_form = DossierForm(initial=data, instance=dossier)
 572     vars = dict(form=dossier_form, poste=poste, employe=employe)
 573     return render_to_response('dae/embauche-dossier.html', vars,
 574                           RequestContext(request))
 575
 576 #  @Cette fonction est appelée à partir de fonctions déjà sécurisée
 577 def pre_filled_dossier(dossier_rh, employe_source, poste_rh):
 578     dossier = dae.Dossier()
 579
 580     if employe_source != 'new' and dossier_rh.id:
 581         dossier.statut_anterieur = dossier_rh.statut
 582
 583         # Certains dossiers ont un classement à zéro
 584         if dossier_rh.classement_id > 0:
 585             dossier.classement_anterieur = dossier_rh.classement
 586
 587         # Récupération du salaire de base
 588         remun = dossier_rh.remunerations().filter(type=1).order_by('-date_debut')
 589         if remun:
 590             dossier.salaire_anterieur = remun[0].montant
 591             dossier.devise_anterieur = remun[0].devise
 592
 593     # Récupération du titulaire précédent
 594     try:
 595         dossiers = rh.Dossier.objects.order_by('-date_debut')
 596         if poste_rh:
 597             dossiers = dossiers.filter(poste=poste_rh)
 598         else:
 599             dossiers = rh.Dossier.objects.none()
 600         if len(dossiers):
 601             # Ce bloc ignore toutes les erreurs, car les données de rh
 602             # manquantes peuvent en générer
 603             d = dossiers[0]
 604             try:
 605                 titulaire = d.employe
 606                 dossier.employe_anterieur = titulaire
 607                 dossier.classement_titulaire_anterieur = d.classement
 608                 dossier.statut_titulaire_anterieur = d.statut
 609                 remun = d.remunerations().filter(type=1).order_by('-date_debut')[0]
 610                 dossier.salaire_titulaire_anterieur = remun.montant
 611                 dossier.devise_titulaire_anterieur = remun.devise
 612             except:
 613                 pass
 614             # TODO: afficher l'info, les champs ne sont pas dans le
 615             # modèle dae.Dossier: nom, prenom, classement, salaire
 616             pass
 617
 618     except (rh.Dossier.DoesNotExist):
 619         dossier_rh = rh.Dossier()
 620
 621     return dossier
 622
 623 @dae_groupe_requis
 624 @vieux_dossier_dans_ma_region_ou_service
 625 def dossier_resume(request, dossier_id=None):
 626     try:
 627         dossier = rh.Dossier.objects.get(id=dossier_id)
 628     except:
 629         return HttpResponseGone("Ce dossier n'est pas accessible")
 630
 631     data = {}
 632     data['personne'] = unicode(dossier.employe)
 633     data['classement'] = dossier.classement.id
 634     if dossier.statut is not None:
 635         data['statut'] = dossier.statut.id
 636     data['implantation'] = dossier.poste.implantation.id
 637     data['poste'] = u"%s %s" % (dossier.poste.type_poste.nom, dossier.poste.nom)
 638     salaire = dossier.get_salaire()
 639     data['montant'] = salaire.montant
 640     if salaire.devise is not None:
 641         data['devise'] = salaire.devise.id
 642         data['montant_euros'] = salaire.montant_euro()
 643     else:
 644         data['devise'] = None
 645         data['montant_euros'] = 0
 646     return HttpResponse(dumps(data))
 647
 648 @dae_groupe_requis
 649 @vieux_dossier_dans_ma_region_ou_service
 650 def poste_resume(request, dossier_id=None):
 651     """
 652     On travaille, en réalité sur le dossier mais on cache
 653     l'identité de la personne.
 654     """
 655     try:
 656         dossier = rh.Dossier.objects.get(id=dossier_id)
 657     except:
 658         return HttpResponseGone("Ce dossier n'est pas accessible")
 659
 660     salaire = dossier.get_salaire()
 661     data = {}
 662     data['implantation'] = dossier.poste.implantation.id
 663     data['poste'] = u"%s %s" % (dossier.poste.type_poste.nom, dossier.poste.nom)
 664     data['montant'] = salaire.montant
 665     if salaire is not None:
 666         data['devise'] = salaire.devise.id
 667         data['montant_euros'] = salaire.montant_euro()
 668     else:
 669         data['devise'] = None
 670         data['montant_euros'] = 0
 671     return HttpResponse(dumps(data))
 672
 673 def liste_postes(request):
 674     """ Appel AJAX :
 675     input : implantation_id
 676     output : JSON liste de valeur point
 677     """
 678     method = request.method
 679     params = getattr(request, method, [])
 680     data = []
 681
 682     # Voir le code de _poste_choices dans forms.py
 683     dae_ = dae.Poste.objects.filter(actif=True, id_rh__isnull=True)
 684     copies = dae.Poste.objects.exclude(id_rh__isnull=True)
 685     rh_postes_actifs = rh.Poste.objects.filter(actif=True)
 686
 687     if 'implantation_id' in params and params.get('implantation_id') is not u"":
 688         implantation_id = params.get('implantation_id')
 689         dae_ = dae_.filter(implantation__id=implantation_id)
 690         copies = copies.filter(implantation__id=implantation_id)
 691         rh_postes_actifs = rh_postes_actifs.filter(implantation__id=implantation_id)
 692
 693     id_copies = [p.id_rh_id for p in copies.all()]
 694     rhv1 = rh_postes_actifs.exclude(id__in=id_copies)
 695     rhv1 = rhv1.select_related(depth=1)
 696
 697     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])
 698     return HttpResponse(dumps(data))
 699
 700 @login_required
 701 def dossier_piece(request, id, filename):
 702     """Téléchargement d'une pièce jointe à un poste."""
 703     piece = get_object_or_404(dae.DossierPiece, pk=id)
 704     if dae.Dossier.objects.ma_region_ou_service(request.user).filter(id=piece.dossier_id).exists():
 705         return sendfile(request, piece.fichier.path)
 706     else:
 707         return redirect_interdiction(request)
 708
 709
 710 ################################################################################
 711 # AJAX SECURITE non nécessaire
 712 ################################################################################
 713 def coefficient(request):
 714     """ Appel AJAX :
 715     input : classement
 716     output : coefficient
 717     """
 718     method = request.method
 719     params = getattr(request, method, [])
 720     data = dict()
 721     if 'classement' in params and params.get('classement') is not u"":
 722         classement = params.get('classement')
 723         classement = rh.Classement.objects.get(pk=classement)
 724         data['coefficient'] = classement.coefficient
 725     else:
 726         data['coefficient'] = 0
 727     return HttpResponse(dumps(data))
 728
 729
 730 def devise(request):
 731     """ Appel AJAX :
 732     input : valeur_point
 733     output : devise, devise_code, taux_euro
 734     """
 735     method = request.method
 736     params = getattr(request, method, [])
 737     data = dict()
 738     if 'valeur_point' in params and params.get('valeur_point') is not u"":
 739         valeur_point = params.get('valeur_point')
 740         valeur_point = rh.ValeurPoint.objects.get(pk=valeur_point)
 741         annee = valeur_point.annee
 742         try:
 743             taux = rh.TauxChange.objects.get(annee=annee, devise=valeur_point.devise)
 744         except MultipleObjectsReturned:
 745             return HttpResponseGone(u"Il existe plusieurs taux pour la devise %s cette année-là : %s" % \
 746                 (valeur_point.devise.code, annee))
 747
 748         data['devise'] = taux.devise.id
 749         data['valeur'] = valeur_point.valeur
 750         data['devise_code'] = taux.devise.code
 751         data['taux_euro'] = taux.taux
 752     else:
 753         return HttpResponseGone("Vous devez choisir une valeur de point")
 754     return HttpResponse(dumps(data))
 755
 756 def devise_code(request):
 757     """ Appel AJAX :
 758     input : devise
 759     output : devise_code, taux_euro
 760     """
 761     method = request.method
 762     params = getattr(request, method, [])
 763     data = dict()
 764     if 'devise' in params:
 765         devise = params.get('devise')
 766         devise = rh.Devise.objects.get(pk=devise)
 767         annee = date.today().year
 768         taux = rh.TauxChange.objects.filter(annee=annee, devise=devise)
 769         if len(taux) == 0:
 770             return HttpResponseGone("Le taux n'est pas disponible")
 771         data['devise_code'] = devise.code
 772         data['taux_euro'] = taux[0].taux
 773     return HttpResponse(dumps(data))
 774
 775 def add_remun(request, dossier, type_remun):
 776     dossier = get_object_or_404(dae.Dossier, pk=dossier)
 777     type_remun = get_object_or_404(rh.TypeRemuneration, pk=type_remun)
 778     dae.Remuneration(dossier=dossier, devise=dossier.devise,
 779                      type=type_remun).save()
 780
 781     return render_to_response('dae/embauche-remun.html', dict(dossier=dossier),
 782                               RequestContext(request))
 783
 784 def salaire(request, implantation, devise, classement):
 785     if not devise or not classement:
 786         raise Http404
 787
 788     taux_impl = rh.TauxChange.objects.filter(implantation=implantation) \
 789                                      .order_by('-annee')
 790     taux = rh.TauxChange.objects.filter(devise=devise).order_by('-annee')
 791     vp = rh.ValeurPoint.objects.filter(implantation=implantation) \
 792                                .order_by('-annee')
 793     if vp.count() * taux.count() * taux_impl.count() == 0:
 794         raise Http404
 795
 796     classement = get_object_or_404(rh.Classement, pk=classement)
 797     taux, taux_impl, vp = taux[0].taux, taux_impl[0].taux, vp[0].valeur
 798
 799     salaire_euro = round(vp * classement.coefficient * taux_impl, 2)
 800     data = dict(salaire_euro=salaire_euro, taux=taux,
 801                 salaire_devise=round(salaire_euro / taux, 2))
 802
 803     return HttpResponse(dumps(data))
 804
 805 def liste_valeurs_point(request):
 806     """ Appel AJAX :
 807     input : implantation_id
 808     output : JSON liste de valeur point
 809     """
 810     method = request.method
 811     params = getattr(request, method, [])
 812     data = []
 813     annee_courante = datetime.datetime.now().year
 814     if 'implantation_id' in params and params.get('implantation_id') is not u"":
 815         implantation_id = params.get('implantation_id')
 816         preselectionne = rh.ValeurPoint.objects.filter(implantation=implantation_id, annee__in=(annee_courante,)).order_by("-annee")
 817         for o in preselectionne:
 818             data.append({'id' : o.id, 'label' : o.__unicode__(), 'devise' : o.devise_id, 'suggestion' : True})
 819     else:
 820         preselectionne = rh.ValeurPoint.objects.none()
 821
 822     liste_complete = rh.ValeurPoint.objects.filter(annee__in=(annee_courante,)).order_by("-annee")
 823     for o in liste_complete.exclude(id__in=[p.id for p in preselectionne]):
 824         data.append({'id' : o.id, 'label' : o.__unicode__(), 'devise' : o.devise_id, 'suggestion' : False})
 825     return HttpResponse(dumps(data, indent=4))