dep useless

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

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

from django.db.models import Q, Max
from django import forms
from django.forms.models import inlineformset_factory, modelformset_factory
from django.contrib.admin import widgets as admin_widgets
from ajax_select.fields import AutoCompleteSelectField
from auf.django.workflow.forms import WorkflowFormMixin
from auf.django.references import models as ref
from dae import models as dae
from utils import get_employe_from_user, is_user_dans_services_centraux
from rh import models as rh
from workflow import grp_drh, POSTE_ETATS_BOUTONS, DOSSIER_ETAT_FINALISE, POSTE_ETAT_FINALISE

def _implantation_choices(obj, request):
    # TRAITEMENT NORMAL
    employe = get_employe_from_user(request.user)
    # SERVICE
    if is_user_dans_services_centraux(request.user):
        q = Q(**{ 'id' : employe.implantation_id })
    # REGION
    else:
        q = Q(**{ 'region' : employe.implantation.region })

    # TRAITEMENT DRH
    if grp_drh in request.user.groups.all():
        q = Q()
    return [('', '----------')] + [(i.id, unicode(i), )for i in ref.Implantation.objects.filter(q)]

def _employe_choices(obj, request):
    # TRAITEMENT NORMAL
    employe = get_employe_from_user(request.user)
    # SERVICE
    if is_user_dans_services_centraux(request.user):
        q_dae_region_service = Q(poste__implantation=employe.implantation)
        q_rh_region_service = Q(poste__implantation=employe.implantation)
    # REGION
    else:
        q_dae_region_service = Q(poste__implantation__region=employe.implantation.region)
        q_rh_region_service = Q(poste__implantation__region=employe.implantation.region)
    # TRAITEMENT DRH
    if grp_drh in request.user.groups.all():
        q_dae_region_service = Q()
        q_rh_region_service = Q()

    # On filtre les employes avec les droits régionaux et on s'assure que c'est bien le dernier dossier en date pour sortir l'employe
    # On retient un employé qui travaille présentement dans la même région que le user connecté.
    dossiers_regionaux_ids = [d.id for d in dae.Dossier.objects.filter(q_dae_region_service)]
    employes_ids = [d['employe'] for d in dae.Dossier.objects.values('employe').annotate(dernier_dossier=Max('id')) if d['dernier_dossier'] in dossiers_regionaux_ids]
    dae_employe = dae.Employe.objects.filter(id__in=employes_ids)
    dae_ = dae_employe.filter(id_rh__isnull=True)
    copies = dae_employe.filter(Q(id_rh__isnull=False))
    id_copies = [p.id_rh_id for p in copies.all()]

    dossiers_regionaux_ids = [d.id for d in rh.Dossier.objects.filter(q_rh_region_service)]
    employes_ids = [d['employe'] for d in rh.Dossier.objects.values('employe').annotate(dernier_dossier=Max('id')) if d['dernier_dossier'] in dossiers_regionaux_ids]
    rhv1 = rh.Employe.objects.filter(id__in=employes_ids).exclude(id__in=id_copies)

    # On ajoute les nouveaux Employés DAE qui ont été crées, mais qui n'ont pas de Dossier associés
    employes_avec_dae = [d.employe_id for d in dae.Dossier.objects.all()]
    employes_orphelins = dae.Employe.objects.exclude(id__in=employes_avec_dae)


    def option_label(employe):
        return "%s %s" % (employe.nom.upper(), employe.prenom.title())

    return [('', 'Nouvel employé')] + \
           sorted([('dae-%s' % p.id, option_label(p)) for p in dae_ | copies | employes_orphelins] +
                  [('rh-%s' % p.id, option_label(p)) for p in rhv1],
                  key=lambda t: t[1])

def label_poste_display(poste):
    """Formate un visuel pour un poste dans une liste déroulante"""
    annee = ""
    if poste.date_debut:
        annee = poste.date_debut.year
    label = u"%s %s - %s [%s]" %(annee, poste.type_poste, poste.type_poste.famille_emploi.nom, poste.id)
    return label

PostePieceForm = inlineformset_factory(dae.Poste, dae.PostePiece)
DossierPieceForm = inlineformset_factory(dae.Dossier, dae.DossierPiece)
FinancementForm = inlineformset_factory(dae.Poste, dae.PosteFinancement, extra=2)

class DossierComparaisonForm(forms.ModelForm):

    recherche = AutoCompleteSelectField('dossiers', required=False)
    poste = forms.CharField(max_length=255, widget=forms.TextInput(attrs={'size':'60'}))

    class Meta:
        model = dae.DossierComparaison
        exclude = ('dossier',)

DossierComparaisonFormSet = modelformset_factory(
    dae.DossierComparaison, extra=3, max_num=3, form=DossierComparaisonForm
)

class PosteComparaisonForm(forms.ModelForm):

    recherche = AutoCompleteSelectField('dae_postes', required=False)

    class Meta:
        model = dae.PosteComparaison
        exclude = ('poste',)

PosteComparaisonFormSet = modelformset_factory(
    dae.PosteComparaison, extra=3, max_num=3, form=PosteComparaisonForm
)

class FlexibleRemunForm(forms.ModelForm):

    montant_mensuel = forms.DecimalField(required=False)
    montant = forms.DecimalField(required=True, label='Montant annuel')

    class Meta:
        model = dae.Remuneration

    def clean_devise(self):
        devise = self.cleaned_data['devise']
        if devise.code == 'EUR':
            return devise
        implantation = ref.Implantation.objects.get(id=self.data['implantation'])
        liste_taux = devise.tauxchange_set.order_by('-annee')
        if len(liste_taux) == 0:
            raise forms.ValidationError(u"La devise %s n'a pas de taux pour l'implantation %s" % (devise, implantation))
        else:
            return devise

RemunForm = inlineformset_factory(
    dae.Dossier, dae.Remuneration, extra=5, form=FlexibleRemunForm
)

class PosteForm(forms.ModelForm):
    """ Formulaire des postes. """

    # On ne propose que les services actifs
    service = forms.ModelChoiceField(queryset=rh.Service.objects.filter(archive=False), required=True)

    responsable=AutoCompleteSelectField('responsables', required=True)
    #responsable = forms.ModelChoiceField(
    #        queryset=rh.Poste.objects.select_related(depth=1))

    # La liste des choix est laissée vide. Voir __init__ pour la raison.
    poste = forms.ChoiceField(label="Nouveau poste ou évolution du poste",
                              choices=(), required=False)

    valeur_point_min  = forms.ModelChoiceField(queryset=rh.ValeurPoint.actuelles.all(), required=False)
    valeur_point_max = forms.ModelChoiceField(queryset=rh.ValeurPoint.actuelles.all(), required=False)


    class Meta:
        model = dae.Poste
        fields = ('type_intervention',
                  'poste', 'implantation', 'type_poste', 'service', 'nom',
                  'responsable', 'local', 'expatrie', 'mise_a_disposition',
                  'appel', 'date_debut', 'date_fin',
                  'regime_travail', 'regime_travail_nb_heure_semaine',
                  'classement_min', 'classement_max',
                  'valeur_point_min', 'valeur_point_max',
                  'devise_min', 'devise_max',
                  'salaire_min', 'salaire_max',
                  'indemn_expat_min', 'indemn_expat_max',
                  'indemn_fct_min', 'indemn_fct_max',
                  'charges_patronales_min', 'charges_patronales_max',
                  'autre_min', 'autre_max', 'devise_comparaison',
                  'comp_locale_min', 'comp_locale_max',
                  'comp_universite_min', 'comp_universite_max',
                  'comp_fonctionpub_min', 'comp_fonctionpub_max',
                  'comp_ong_min', 'comp_ong_max',
                  'comp_autre_min', 'comp_autre_max',
                  'justification',
                  )
        widgets = dict(type_intervention=forms.RadioSelect(),
                       appel=forms.RadioSelect(),
                       nom=forms.TextInput(attrs={'size': 60},),
                       date_debut=admin_widgets.AdminDateWidget(),
                       date_fin=admin_widgets.AdminDateWidget(),
                       justification=forms.Textarea(attrs={'cols': 80},),
                       #devise_min=forms.Select(attrs={'disabled':'disabled'}),
                       #devise_max=forms.Select(attrs={'disabled':'disabled'}),
                    )

    def __init__(self, *args, **kwargs):
        """ Mise à jour dynamique du contenu du menu des postes.

        Si on ne met le menu à jour de cette façon, à chaque instantiation du
        formulaire, son contenu est mis en cache par le système et il ne
        reflète pas les changements apportés par les ajouts, modifications,
        etc...

        Aussi, dans ce cas-ci, on ne peut pas utiliser un ModelChoiceField
        car le "id" de chaque choix est spécial (voir _poste_choices).

        """
        request = kwargs.pop('request')
        super(PosteForm, self).__init__(*args, **kwargs)
        self.fields['poste'].choices = self._poste_choices(request)
        self.fields['implantation'].choices = _implantation_choices(self, request)

        # Quand le dae.Poste n'existe pas, on recherche dans les dossiers rhv1
        if self.instance and self.instance.id is None:
            dossiers = self.instance.get_dossiers()
            if len(dossiers) > 0:
                self.initial['service'] = dossiers[0].poste.service


    def _poste_choices(self, request):
        """ Menu déroulant pour les postes.

        Constitué des postes de dae et des postes de rh_v1 qui n'ont pas
        d'équivalent dans dae.

        """
        dae_ = dae.Poste.objects.ma_region_ou_service(request.user).filter(id_rh__isnull=True)
        copies = dae.Poste.objects.ma_region_ou_service(request.user).exclude(id_rh__isnull=True)
        id_copies = [p.id_rh_id for p in copies.all()]
        rhv1 = rh.Poste.objects.ma_region_ou_service(request.user).exclude(id__in=id_copies)
        # Optimisation de la requête
        rhv1 = rhv1.select_related(depth=1)

        return [('', '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])

    def clean(self):
        """
        Validation conditionnelles de certains champs.
        """
        cleaned_data  = self.cleaned_data

        if cleaned_data.get("local") is False and cleaned_data.get("expatrie") is False:
            msg = "Le poste doit au moins être ouvert localement ou aux expatriés"
            self._errors["local"] = self.error_class([msg])
            self._errors["expatrie"] = ''
            raise forms.ValidationError(msg)

        return cleaned_data



    def save(self, *args, **kwargs):
        kwargs2 = kwargs.copy()
        kwargs2['commit'] = False
        poste = super(PosteForm, self).save(*args, **kwargs2)
        # id_rh
        if 'commit' not in kwargs or kwargs['commit']:
            poste.save()
        return poste


class ChoosePosteForm(forms.ModelForm):
    class Meta:
        model = dae.Poste
        fields = ('poste',)

    # La liste des choix est laissée vide. Voir PosteForm.__init__.
    poste = forms.ChoiceField(choices=(), required=False)

    def __init__(self, request=None, *args, **kwargs):
        super(ChoosePosteForm, self).__init__(*args, **kwargs)
        self.fields['poste'].choices = self._poste_choices(request)

    def _poste_choices(self, request):
        """ Menu déroulant pour les postes. """
        dae_ = dae.Poste.objects.ma_region_ou_service(request.user).filter(id_rh__isnull=True)
        copies = dae.Poste.objects.ma_region_ou_service(request.user).exclude(id_rh__isnull=True)
        id_copies = [p.id_rh_id for p in copies.all()]

        return [('', '----------')] + \
               sorted([('dae-%s' % p.id, unicode(p)) for p in dae_ | copies],
                      key=lambda t: t[1])


class EmployeForm(forms.ModelForm):
    """ Formulaire des employés. """
    class Meta:
        model = dae.Employe
        fields = ('employe', 'nom', 'prenom', 'genre')

    # La liste des choix est laissée vide. Voir Poste.__init__ pour la raison.
    employe = forms.ChoiceField(choices=(), required=False)

    def __init__(self, *args, **kwargs):
        """ Mise à jour dynamique du contenu du menu des employés. """
        request = kwargs.pop('request', None)
        super(EmployeForm, self).__init__(*args, **kwargs)
        self.fields['employe'].choices = _employe_choices(self, request)


class DossierForm(forms.ModelForm):
    """ Formulaire des dossiers. """
    class Meta:
        exclude= ('etat', 'employe', 'poste', 'date_debut', )
        model = dae.Dossier
        widgets = dict(statut_residence=forms.RadioSelect(),
                       contrat_date_debut=admin_widgets.AdminDateWidget(),
                       contrat_date_fin=admin_widgets.AdminDateWidget(),
                    )

WF_HELP_TEXT = ""

class PosteWorkflowForm(WorkflowFormMixin):
    bouton_libelles = POSTE_ETATS_BOUTONS
    class Meta:
        fields = ('etat', )
        model = dae.Poste

    def __init__(self, *args, **kwargs):
        super(PosteWorkflowForm, self).__init__(*args, **kwargs)
        self.fields['etat'].help_text = WF_HELP_TEXT


class DossierWorkflowForm(WorkflowFormMixin):
    bouton_libelles = POSTE_ETATS_BOUTONS # meme workflow que poste...
    class Meta:
        fields = ('etat', )
        model = dae.Dossier

    def __init__(self, *args, **kwargs):
        super(DossierWorkflowForm, self).__init__(*args, **kwargs)
        self.fields['etat'].help_text = WF_HELP_TEXT
        self._etat_initial = self.instance.etat

    def save(self):
        super(DossierWorkflowForm, self).save()
        poste = self.instance.poste
        if poste.etat == self._etat_initial:
            poste.etat = self.instance.etat
            poste.save()

class ContratForm(forms.ModelForm):

    class Meta:
        fields = ('type_contrat', )
        model = dae.Contrat

class DAENumeriseeForm(forms.ModelForm):

    class Meta:
        model = dae.Dossier
        fields = ('dae_numerisee',)

class DAEImportableForm(forms.Form):
    qs_poste = dae.Poste.objects.filter(etat=POSTE_ETAT_FINALISE)
    qs_dossier = dae.Dossier.objects.filter(etat=DOSSIER_ETAT_FINALISE)
    poste = forms.ModelChoiceField(queryset=qs_poste, label="Poste finalisé", required=False)
    dossier = forms.ModelChoiceField(queryset=qs_dossier, label="DAE finalisée", required=False)

    def clean_poste(self):
        poste = self.cleaned_data['poste']
        if poste is not None and poste.est_importe():
            raise forms.ValidationError("Ce poste a déjà été importé")
        return poste

    def clean_dossier(self):
        dossier = self.cleaned_data['dossier']
        if dossier is not None and not dossier.poste.est_importe():
            raise forms.ValidationError("Le poste de ce dossier doit être importé avant de pouvoir importer le dossier.")
        return dossier

    def importer_poste(self):
        poste = self.cleaned_data['poste']
        if poste is not None and not poste.est_importe():
            poste.importer()