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

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

import os
import datetime
import StringIO
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 Context, RequestContext
from django.template.loader import get_template
from django.contrib import messages
from django.conf import settings

from reversion.models import Version
import ho.pisa as pisa

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

from decorators import dae_groupe_requis, \
                       poste_dans_ma_region_ou_service, \
                       dossier_dans_ma_region_ou_service, \
                       employe_dans_ma_region_ou_service, \
                       dossier_est_modifiable, \
                       poste_est_modifiable
from forms import *

pisa.showLogging()

def reponse_pdf(template_src, context_dict):
    """
    Générer une réponse HTTP avec un PDF
    """
    css = ""
    for f in ('css/pdf.css', 'css/dae.css'):
        css_file = os.path.join(settings.MEDIA_ROOT, f)
        css += open(css_file, 'r').read()
    context_dict['css'] = css

    template = get_template(template_src)
    context = Context(context_dict)
    html  = template.render(context)
    result = StringIO.StringIO()
    pdf = pisa.pisaDocument(html, result, encoding='UTF-8')
    if not pdf.err:
        return HttpResponse(result.getvalue(), mimetype='application/pdf')
    return HttpResponse("impossible de générer le pdf! %s" % html)


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

@dae_groupe_requis
@poste_dans_ma_region_ou_service
def poste_consulter(request, key):
    source, id = key.split('-')
    poste = get_object_or_404(dae.Poste, pk=id)
    
    if request.POST:
        validationForm = PosteWorkflowForm(request.POST, instance=poste, request=request)
        if validationForm.is_valid():
            validationForm.save()
            messages.add_message(request, messages.SUCCESS, "La validation a été enregistrée.")
            return redirect('poste_consulter', key=key)
    else:
        validationForm = PosteWorkflowForm(instance=poste, request=request)
    
    vars = {'poste' : poste, 'validationForm' : validationForm, }


    mode = request.GET.get('mode', None)
    if mode is None:
        return render_to_response('dae/poste_consulter.html', vars, RequestContext(request))
    if mode == 'pdf':
        return reponse_pdf('dae/poste_pdf.html', vars)
    if mode == 'vpdf':
        return render_to_response('dae/poste_pdf.html', vars, RequestContext(request))


@dae_groupe_requis
@poste_dans_ma_region_ou_service
@poste_est_modifiable
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, request=request)
        financementForm = FinancementForm(request.POST, instance=poste)
        piecesForm = PostePieceForm(request.POST, request.FILES, instance=poste)
        if 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)
            if request.POST.has_key('save'):
                return redirect('poste_consulter', key='dae-%s' % poste.id)
            else:
                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, request=request)
        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))

@dae_groupe_requis
def postes_liste(request):
    """ Liste des postes. """
    vars = dict()
    vars['postes'] = dae.Poste.objects.ma_region_ou_service(request.user).order_by('-date_creation')
    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)

@dae_groupe_requis
@dossier_dans_ma_region_ou_service
def embauche_consulter(request, dossier_id):
    dossier = get_object_or_404(dae.Dossier, pk=dossier_id)

    if request.POST:
        validationForm = DossierWorkflowForm(request.POST, instance=dossier, request=request)
        if validationForm.is_valid():
            validationForm.save()
            messages.add_message(request, messages.SUCCESS, "La validation a été enregistrée.")
            return redirect('embauche_consulter', dossier_id=dossier.id)
    else:
        validationForm = DossierWorkflowForm(instance=dossier, request=request)
    
    vars = {
        'dossier' : dossier,
        'validationForm' : validationForm,
        }

    mode = request.GET.get('mode', None)
    if mode is None:
        return render_to_response('dae/embauche_consulter.html', vars, RequestContext(request))
    if mode == 'pdf':
        return reponse_pdf('dae/embauche_pdf.html', vars)
    if mode == 'vpdf':
        return render_to_response('dae/embauche_pdf.html', vars, RequestContext(request))

@dae_groupe_requis
@dossier_dans_ma_region_ou_service
@dossier_est_modifiable
def embauche(request, key=None, dossier_id=None):
    """ Formulaire d'autorisation d'embauche. """
    if not key:
        vars = dict(step='poste', form=ChoosePosteForm(request=request))
    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_id:
            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, request=request)

            if 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, request=request)

                if not dossier_id:
                    dossier = dae.Dossier(poste=poste, employe=employe)
                else:
                    dossier = get_object_or_404(dae.Dossier, pk=dossier_id)
                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)
                dossiersComparaisonsForm = DossierComparaisonForm(request.POST, instance=dossier)

                if dossier_form.is_valid() and piecesForm.is_valid() and justificationsNouveauForm.is_valid() and justificationsAutreForm.is_valid() and dossiersComparaisonsForm.is_valid():
                    dossier = dossier_form.save()
                    piecesForm.instance = dossier
                    piecesForm.save()
                    justificationsNouveauForm.instance = dossier
                    justificationsNouveauForm.save()
                    justificationsAutreForm.instance = dossier
                    justificationsAutreForm.save()
                    dossiersComparaisonsForm.instance = dossier
                    dossiersComparaisonsForm.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)
                    if request.POST.has_key('save'):
                        return redirect('embauche_consulter', dossier_id=dossier.id)
                    else:
                        return redirect('embauche', key=dossier.poste.key, dossier_id=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)
                dossiersComparaisonsForm = DossierComparaisonForm(instance=dossier)
        else:
            # Initialisation d'un formulaire vide
            dossier_rh = rh.Dossier()
            poste_rh = poste.id_rh
            if dossier_id:
                dossier = get_object_or_404(dae.Dossier, pk=dossier_id)
                employe = dossier.employe
                data = dict(employe='dae-%s' % employe.id)
                employe_form = EmployeForm(initial=data, instance=employe, request=request)
            else:
                dossier = pre_filled_dossier(dossier_rh, 'new', poste_rh)
                employe_form = EmployeForm(request=request)

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

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

    return render_to_response('dae/embauche.html', vars,
                              RequestContext(request))
@dae_groupe_requis
@dossier_dans_ma_region_ou_service
def embauches_liste(request):
    """ Liste des embauches. """
    vars = dict()
    vars['embauches'] = dae.Dossier.objects.ma_region_ou_service(request.user).order_by('-date_creation')
    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, request=request).as_table())

################################################################################
# AJAX SECURISE
################################################################################
@dae_groupe_requis
@employe_dans_ma_region_ou_service
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))

#  @Cette fonction est appelée à partir de fonctions déjà sécurisée
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

@dae_groupe_requis
@dossier_dans_ma_region_ou_service
def dossier_resume(request, dossier_id=None):
    """ Appel AJAX : 
    input : valeur_point
    output : devise, devise_code, taux_euro
    """
    try:
        dossier = rh.Dossier.objects.get(id=dossier_id)
    except:
        return HttpResponseGone("Ce dossier n'est pas accessible")

    data = {}
    data['personne'] = unicode(dossier.employe)
    data['implantation'] = dossier.implantation1.id
    data['poste'] = u"%s %s" % (dossier.poste1.type_poste.nom, dossier.complement1)
    data['montant'] = dossier.get_salaire()
    salaire = dossier.get_dernier_salaire_remun()
    if salaire is not None:
        data['devise'] = dossier.get_dernier_salaire_remun().devise.id
        data['montant_euros'] = dossier.get_dernier_salaire_remun().en_euros()
    else:
        data['devise'] = None
        data['montant_euros'] = 0
    return HttpResponse(dumps(data))

def liste_postes(request):
    """ Appel AJAX : 
    input : implantation_id
    output : JSON liste de valeur point
    """
    method = request.method
    params = getattr(request, method, [])
    data = []

    # Voir le code de _poste_choices dans forms.py
    dae_ = dae.Poste.objects.filter(actif=True, id_rh__isnull=True)
    copies = dae.Poste.objects.exclude(id_rh__isnull=True)
    rh_postes_actifs = rh.Poste.objects.filter(actif=True)

    if 'implantation_id' in params and params.get('implantation_id') is not u"":
        implantation_id = params.get('implantation_id')
        dae_ = dae_.filter(implantation__id=implantation_id)
        copies = copies.filter(implantation__id=implantation_id)
        rh_postes_actifs = rh_postes_actifs.filter(implantation__id=implantation_id)
   
    id_copies = [p.id_rh_id for p in copies.all()]
    rhv1 = rh_postes_actifs.exclude(id__in=id_copies)
    rhv1 = rhv1.select_related(depth=1)

    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])
    return HttpResponse(dumps(data))


################################################################################
# AJAX SECURITE non nécessaire
################################################################################
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 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))

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 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))