poste

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

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

from django import forms
from django.core.urlresolvers import reverse
from django.forms.models import BaseInlineFormSet
from django.forms.models import inlineformset_factory, modelformset_factory
from django.db.models import Q, Max, Count
from django.shortcuts import redirect
from django.contrib.admin import widgets as admin_widgets

from ajax_select.fields import AutoCompleteSelectField

from auf.django.references import models as ref
from auf.django.workflow.forms import WorkflowFormMixin
from auf.django.workflow.models import WorkflowCommentaire

from project import groups
from project.rh import models as rh
from project.dae import models as dae
from project.dae.workflow import POSTE_ETATS_BOUTONS, POSTE_ETAT_FINALISE


class BaseInlineFormSetWithInitial(BaseInlineFormSet):
    """
    Cette classe permet de fournir l'option initial aux inlineformsets.
    Elle devient désuette en django 1.4.
    """
    def __init__(self, data=None, files=None, instance=None,
                 save_as_new=False, prefix=None, queryset=None, **kwargs):

        self.initial_extra = kwargs.pop('initial', None)

        from django.db.models.fields.related import RelatedObject
        if instance is None:
            self.instance = self.fk.rel.to()
        else:
            self.instance = instance
        self.save_as_new = save_as_new
        # is there a better way to get the object descriptor?
        self.rel_name = RelatedObject(self.fk.rel.to, self.model, self.fk).get_accessor_name()
        if queryset is None:
            queryset = self.model._default_manager
        qs = queryset.filter(**{self.fk.name: self.instance})
        super(BaseInlineFormSetWithInitial, self).__init__(data, files, prefix=prefix,
                                                queryset=qs, **kwargs)

    def _construct_form(self, i, **kwargs):
        if self.is_bound and i < self.initial_form_count():
            # Import goes here instead of module-level because importing
            # django.db has side effects.
            from django.db import connections
            pk_key = "%s-%s" % (self.add_prefix(i), self.model._meta.pk.name)
            pk = self.data[pk_key]
            pk_field = self.model._meta.pk
            pk = pk_field.get_db_prep_lookup('exact', pk,
                connection=connections[self.get_queryset().db])
            if isinstance(pk, list):
                pk = pk[0]
            kwargs['instance'] = self._existing_object(pk)
        if i < self.initial_form_count() and not kwargs.get('instance'):
            kwargs['instance'] = self.get_queryset()[i]
        if i >= self.initial_form_count() and self.initial_extra:
            # Set initial values for extra forms
            try:
                kwargs['initial'] = self.initial_extra[i-self.initial_form_count()]
            except IndexError:
                pass

        defaults = {'auto_id': self.auto_id, 'prefix': self.add_prefix(i)}
        if self.is_bound:
            defaults['data'] = self.data
            defaults['files'] = self.files
        if self.initial:
            try:
                defaults['initial'] = self.initial[i]
            except IndexError:
                pass
        # Allow extra forms to be empty.
        if i >= self.initial_form_count():
            defaults['empty_permitted'] = True
        defaults.update(kwargs)
        form = self.form(**defaults)
        self.add_fields(form, i)
        return form


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

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


def _employe_choices(obj, request):
    # TRAITEMENT NORMAL
    employe = groups.get_employe_from_user(request.user)
    # SERVICE
    if groups.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
    user_groupes = [g.name for g in request.user.groups.all()]
    if groups.DRH_NIVEAU_1 in user_groupes:
        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

    nom = poste.nom
    label = u"%s (%s) %s - %s [%s]" % (
        annee,
        poste.implantation.nom_court,
        nom,
        poste.type_poste.categorie_emploi.nom,
        poste.id,
        )
    return label


PostePieceFormSet = inlineformset_factory(dae.Poste, dae.PostePiece,)
DossierPieceForm = inlineformset_factory(dae.Dossier, dae.DossierPiece)

# Ce formset est utilisé dans le cas de la création de poste prépopulé avec les
# données de RH
FinancementFormSetInitial = inlineformset_factory(
    dae.Poste,
    dae.PosteFinancement,
    formset=BaseInlineFormSetWithInitial,
    extra=2
)
FinancementFormSet = 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',)

# Ce formset est utilisé dans le cas de la création de poste prépopulé avec les
# données de RH
PosteComparaisonFormSetInitial = inlineformset_factory(
    dae.Poste,
    dae.PosteComparaison,
    extra=3,
    max_num=3,
    form=PosteComparaisonForm,
    formset=BaseInlineFormSetWithInitial,
)
PosteComparaisonFormSet = inlineformset_factory(
    dae.Poste,
    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.all(), 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 RH
        """
        postes_rh = rh.Poste.objects.ma_region_ou_service(request.user).all()
        postes_rh = postes_rh.select_related(depth=1)

        return [('', 'Nouveau poste')] + \
               sorted([('rh-%s' % p.id, label_poste_display(p)) for p in
                   postes_rh],
                      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


class ChoosePosteForm(forms.Form):
    class Meta:
        fields = ('poste',)

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

    def __init__(self, request=None, *args, **kwargs):
        super(ChoosePosteForm, self).__init__(*args, **kwargs)
        self.fields['postes_dae'].choices = self._poste_dae_choices(request)
        self.fields['postes_rh'].choices = self._poste_rh_choices(request)

    def _poste_dae_choices(self, request):
        """ Menu déroulant pour les postes."""
        postes_dae = dae.Poste.objects.ma_region_ou_service(request.user) \
                .exclude(etat__in=(POSTE_ETAT_FINALISE, )) \
                .annotate(num_dae=Count('dae_dossiers')) \
                .filter(num_dae=0) \
                .order_by('-date_debut')

        return [('', '----------')] + \
               [('dae-%s' % p.id, label_poste_display(p)) for p in postes_dae]

    def _poste_rh_choices(self, request):
        """ Menu déroulant pour les postes."""
        postes_dae = dae.Poste.objects.exclude(etat__in=(POSTE_ETAT_FINALISE, ))
        id_poste_dae_commences = [p.id_rh_id for p in postes_dae if p.id_rh is not None]
        postes_rh = rh.Poste.objects.ma_region_ou_service(request.user) \
                .exclude(id__in=id_poste_dae_commences) \
                .order_by('-date_debut')

        return [('', '----------')] + \
               [('rh-%s' % p.id, label_poste_display(p)) for p in postes_rh]

    def clean(self):
        cleaned_data = super(ChoosePosteForm, self).clean()
        postes_dae = cleaned_data.get("postes_dae")
        postes_rh = cleaned_data.get("postes_rh")
        if (postes_dae is u"" and postes_rh is u"") or \
           (postes_dae is not u"" and postes_rh is not u""):
                raise forms.ValidationError("Choisissez un poste DAE ou un poste RH")
        return cleaned_data

    def redirect(self):
        poste_dae_key = self.cleaned_data.get("postes_dae")
        if poste_dae_key is not u"":
            return redirect(reverse('embauche', args=(poste_dae_key,)))
        poste_rh_key = self.cleaned_data.get("postes_rh")
        if poste_rh_key is not u"":
            return redirect("%s?creer_dossier_dae" % reverse('poste', args=(poste_rh_key,)))

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

        # créer le commentaire automatique pour le poste associé
        commentaire = WorkflowCommentaire()
        commentaire.content_object = poste
        texte = u"Validation automatique à travers le dossier [%s] de %s\n%s" %(
                self.instance.id,
                self.instance,
                self.data.get('commentaire', ''),
                )
        commentaire.texte = texte
        commentaire.etat_initial = self.instance._etat_courant
        commentaire.etat_final = self.instance.etat
        commentaire.owner = self.request.user
        commentaire.save()

        # force l'état du poste
        poste.etat = self.instance.etat
        poste.save()


class ContratForm(forms.ModelForm):

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


class DAENumeriseeForm(forms.ModelForm):

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


class DAEFinaliseesSearchForm(forms.Form):
    q = forms.CharField(
        label='Recherche', required=False,
        widget=forms.TextInput(attrs={'size': 40})
    )
    importees = forms.ChoiceField(
        label='Importation', required=False, choices=(
            ('', ''),
            ('oui', 'DAE importées seulement'),
            ('non', 'DAE non-importées seulement'),
        )
    )