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