renseigne la justification du poste

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

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

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

from django.core.urlresolvers import reverse
from django.http import Http404, HttpResponse, HttpResponseGone
from django.shortcuts import redirect, render_to_response, get_object_or_404
from django.template import RequestContext
from django.contrib import messages

from reversion.models import Version

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

from project.decorators import admin_required
from forms import *

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

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

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

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

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

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

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

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

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

@admin_required
def postes_liste(request):
    """ Liste des postes. """
    vars = dict()
    vars['postes'] = []

    for p in dae.Poste.objects.all().order_by('-date_creation'):
        versions =  Version.objects.get_for_object(p)
        if len(versions) > 0:
            premiere_revision = versions[0].revision
        else:
            premiere_revision = None

        if request.POST:
            validationForm = PosteValidationForm(request.POST, instance=p, prefix=p.id)
            if validationForm.is_valid():
                p = validationForm.save()
        else:
            validationForm = PosteValidationForm(instance=p, prefix=p.id)

        vars['postes'].append((p, premiere_revision, validationForm))

    if request.POST:
        return redirect(reverse('dae_postes_liste'))
        
    return render_to_response('dae/postes_liste.html', vars,
                              RequestContext(request))

def filtered_type_remun():
    # Exclusion de "Indemnité de fonction" des types de rémun utilisés
    return rh.TypeRemuneration.objects.exclude(pk=7)

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

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

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

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

                if not dossier:
                    dossier = dae.Dossier(poste=poste, employe=employe)
                else:
                    dossier = get_object_or_404(dae.Dossier, pk=dossier)
                dossier_form = DossierForm(request.POST, instance=dossier)
                piecesForm = DossierPieceForm(request.POST, request.FILES, instance=dossier)
                justificationsNouveauForm = JustificationNouvelEmployeForm(request.POST, instance=dossier)
                justificationsAutreForm = JustificationAutreEmployeForm(request.POST, instance=dossier)

                if dossier_form.is_valid() and piecesForm.is_valid() and justificationsNouveauForm.is_valid() and justificationsAutreForm.is_valid():
                    dossier = dossier_form.save()
                    piecesForm.instance = dossier
                    piecesForm.save()
                    justificationsNouveauForm.instance = dossier
                    justificationsNouveauForm.save()
                    justificationsAutreForm.instance = dossier
                    justificationsAutreForm.save()
                    if not dossier.remuneration_set.all():
                        # Pré-peuplement des entrées de la section "coût
                        # global", à l'exclusion de "Indemnité de fonction"
                        for type in type_remun.all():
                            dae.Remuneration(dossier=dossier, type=type,
                                             devise=dossier.devise).save()

                    else:
                        # Sauvegarde du coût global
                        cg_lines = defaultdict(dict)
                        for k, v in request.POST.items():
                            if k.startswith('cg-'):
                                prefix, field_name, cg_id = k.split('-')
                                cg_lines[int(cg_id)][unicode(field_name)] = v

                        for r in dossier.remuneration_set.all():
                            print 'trying %r' % r
                            if r.id in cg_lines:
                                if cg_lines[r.id]['montant'] == '':
                                   r.delete()
                                else:
                                    for k, v in cg_lines[r.id].items():
                                        setattr(r, k, v)
                                        r.save()
                    
                    messages.add_message(request, messages.SUCCESS, "Le dossier %s a été sauvegardé." % dossier)
                    return redirect('embauche', key='dae-%s' % poste.id,
                                    dossier=dossier.id)
                else:
                    messages.add_message(request, messages.ERROR, 'Il y a des erreurs dans le formulaire.')
                    
            else:
                dossier_form = DossierForm(instance=dossier)
                piecesForm = DossierPieceForm(instance=dossier)
                justificationsNouveauForm = JustificationNouvelEmployeForm(instance=dossier)
                justificationsAutreForm = JustificationAutreEmployeForm(instance=dossier)
        else:
            # Initialisation d'un formulaire vide
            dossier_rh = rh.Dossier()
            poste_rh = poste.id_rh
            if dossier:
                dossier = get_object_or_404(dae.Dossier, pk=dossier)
                employe = dossier.employe
                data = dict(employe='dae-%s' % employe.id)
                employe_form = EmployeForm(initial=data, instance=employe)
            else:
                dossier = pre_filled_dossier(dossier_rh, 'new', poste_rh)
                employe_form = EmployeForm()

            dossier_form = DossierForm(instance=dossier)
            piecesForm = DossierPieceForm(instance=dossier)
            justificationsNouveauForm = JustificationNouvelEmployeForm(instance=dossier)
            justificationsAutreForm = JustificationAutreEmployeForm(instance=dossier)

        vars = dict(step='employe',
                poste=poste,
                dossier=dossier,
                piecesForm=piecesForm,
                justificationsNouveauForm=justificationsNouveauForm,
                justificationsAutreForm=justificationsAutreForm,
                forms=dict(employe=employe_form, dossier=dossier_form, )
                )

    return render_to_response('dae/embauche.html', vars,
                              RequestContext(request))
@admin_required
def embauches_liste(request):
    """ Liste des embauches. """
    vars = dict()
    vars['embauches'] = []
    for d in dae.Dossier.objects.all().order_by('-date_creation'):
        versions =  Version.objects.get_for_object(d)
        if len(versions) > 0:
            premiere_revision = versions[0].revision
        else:
            premiere_revision = None
        vars['embauches'].append((d, premiere_revision))
    return render_to_response('dae/embauches_liste.html', vars,
                              RequestContext(request))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return HttpResponse(dumps(data))

def pre_filled_dossier(dossier_rh, employe_source, poste_rh):
    dossier = dae.Dossier()

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

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

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

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

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

    return dossier

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


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

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

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

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