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

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

import datetime
from ordereddict import OrderedDict
from django import forms
from django.core.urlresolvers import reverse
from django.core.exceptions import MultipleObjectsReturned
from django.forms.models import BaseInlineFormSet
from django.forms.models import (
    inlineformset_factory,
    modelformset_factory,
    _get_foreign_key,
    )
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 .widgets import ReadOnlyChoiceWidget, ReadOnlyWidget
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)
    q = Q(**{'zone_administrative': employe.implantation.zone_administrative})

    # TRAITEMENT DRH
    user_groupes = [g.name for g in request.user.groups.all()]
    if groups.DRH_NIVEAU_1 in user_groupes or \
       groups.DRH_NIVEAU_2 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)
    q_dae_region_service = Q(
        poste__implantation__zone_administrative=(
            employe.implantation.zone_administrative
        )
    )
    q_rh_region_service = Q(
        poste__implantation__zone_administrative=(
            employe.implantation.zone_administrative
        )
    )
    # TRAITEMENT DRH
    user_groupes = [g.name for g in request.user.groups.all()]
    if groups.DRH_NIVEAU_1 in user_groupes or \
       groups.DRH_NIVEAU_2 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, extra=""):
        if extra:
            extra = " [%s]" % extra
        return "%s %s %s" % (employe.nom.upper(), employe.prenom.title(), extra)

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


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]" % (
        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 __init__(self, *a, **kw):
        super(FlexibleRemunForm, self).__init__(*a, **kw)
        # self.fields['type'].widget = ReadOnlyChoiceWidget(choices=self.fields['type'].choices)

    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

    def has_changed(self):
        """
        Modification de has_changed pour qu'il ignore les montant a 0
        et les 'types'.
        """

        changed_data = self.changed_data

        # Type is set in hidden fields, it shouldn't be changed by the
        # user; ignore when checking if data has changed.
        if 'type' in changed_data:
            changed_data.pop(changed_data.index('type'))

        # Montant is set to 0 in javascript, ifnore 'montant' data if
        # its value is 0.

        # Generer le key tel qu'identifié dans self.data:
        montant_key = '-'.join((self.prefix, 'montant'))

        if ('montant' in changed_data and
            self.data.get(montant_key, '0') == '0'):
            changed_data.pop(changed_data.index('montant'))
        
        return bool(changed_data)


class ReadOnlyRemunForm(FlexibleRemunForm):
    def __init__(self, *a, **kw):
        super(FlexibleRemunForm, self).__init__(*a, **kw)
        for field in self.fields:
            field = self.fields[field]
            if not isinstance(field.widget, (
                    forms.widgets.HiddenInput,
                    forms.widgets.Select)):
                field.widget = ReadOnlyWidget()
            elif isinstance(field.widget, forms.widgets.Select):
                field.widget = ReadOnlyChoiceWidget(choices=field.choices)


class GroupedInlineFormset(BaseInlineFormSet):

    def set_groups(self,
                   groups,
                   group_accessor,
                   choice_overrides=[]):


        # Create pre-defined groups.
        self.groups = OrderedDict()
        for group in groups:
            self.groups[group[0]] = {
                'name': group[1],
                'key': group[0],
                'forms': [],
                }

        # Assign each form to a group.
        for form in self.forms:
            if bool(form.initial):
                grp = group_accessor(form)
                if grp[0] not in self.groups:
                    self.groups[grp[0]] = {
                        'name': grp[1],
                        'key': grp[0],
                        'forms': [],
                        }
                self.groups[grp[0]]['forms'].append(form)
    
        # Add extra forms (n extra for each grop).
        tmp_extras = []
        for i in xrange(len(self.groups) * self.extra):
            tmp_extras.insert(0, self._construct_form(i))

        for g in self.groups:
            for i in xrange(self.extra):
                self.groups[g]['forms'].append(tmp_extras.pop())
            

        # Override form choices with the data provided in
        # choice_overrides
        for key in choice_overrides:
            for form in self.groups.get(key, {'forms': []})['forms']:
                for field_key in choice_overrides[key]:
                    form.fields[field_key].choices = choice_overrides[
                        key][field_key]
                

        # Create an iterable for easier access in template.
        self.group_list = self.groups.values()

    # def set_groups(self, group_accessor, groups, group_order=[]):
    #     """
    #     group_accessor: A function that will get the key and name from
    #     each form.
    #     group_order: list the group keys here in a list and
    #     GroupedInlineFormset.groups will be ordered (ordereddict) by
    #     the key sequence provided here. Any missing key from the
    #     sequence will 
    #     """

    #     # Build group list.
    #     self.groups = OrderedDict()
    #     temp_groups = {}
    #     # self.groups_and_forms = []
    #     for form in self.forms:
    #         group_key, group_name = group_accessor(form)
    #         if not temp_groups.has_key(group_key):
    #             temp_groups[group_key] = {
    #                 'name': group_name,
    #                 'key': group_key,
    #                 'forms': [],
    #                 }
    #         temp_groups[group_key]['forms'].append(form)

    #     for order_key in group_order:
    #         if temp_groups.has_key(order_key):
    #             self.groups[order_key] = temp_groups.pop(order_key)

    #     for key in temp_groups:
    #         self.groups[key] = temp_groups[key]

    #     del temp_groups
            
    #     self.group_list = self.groups.values()


def remun_formset_factory(parent_model,
                          model,
                          form=forms.ModelForm,
                          formset=GroupedInlineFormset,
                          fk_name=None,
                          fields=None,
                          exclude=None,
                          can_order=False,
                          can_delete=True,
                          extra=2,
                          max_num=None,
                          formfield_callback=None,
                          groups=None,
                          choice_overrides=[]):
    trs = rh.TypeRemuneration.objects.all()
    # extra = max_num = trs.count()
    fk = _get_foreign_key(parent_model, model, fk_name=fk_name)
    # enforce a max_num=1 when the foreign key to the parent model is unique.
    if fk.unique:
        max_num = 1
    kwargs = {
        'form': form,
        'formfield_callback': formfield_callback,
        'formset': formset,
        'extra': extra,
        'can_delete': can_delete,
        'can_order': can_order,
        'fields': fields,
        'exclude': exclude,
        'max_num': max_num,
    }
    FormSet = modelformset_factory(model, **kwargs)
    FormSet.fk = fk

    def grouper(form):
        rtype = form.initial['type']
        if not isinstance(rtype, rh.TypeRemuneration):
            rtype = rh.TypeRemuneration.objects.get(id=rtype)
        return (rtype.nature_remuneration,
                rtype.nature_remuneration
                )

    def __init__(inst, *a, **kw):
        super(FormSet, inst).__init__(*a, **kw)

        # Warning, this constructor can be improved and made more
        # efficient.. it's a bit of a hack that will help creating a
        # "grouped" formset that works inside Django. Although the
        # code makes several iterations, I've timed it at 1ms to
        # for it's execution.

        # # Set initial data.
        # d_inst = kw.get('instance', None)

        # Set initial for all form type.
        # for form, tr in zip(inst.forms, trs):
        #     form.initial['type'] = tr

        # # Set form grouping.
        inst.set_groups(groups, grouper, choice_overrides)

        # # Create groups list of choices for type field.
        # inst.group_type_choices = {}
        # for group_key in inst.groups:
        #     inst.group_type_choices[group_key] = []

        # # Add choices based on form.initial which have been set above.
        # for form in inst.forms:
        #     inst.group_type_choices[
        #         form.initial['type'].nature_remuneration].append(
        #         (form.initial['type'].id, form.initial['type'].nom)
        #         )

        # # Finally... change the choices of each form in the formset:
        # for form in inst.forms:
        #     form.fields['type'].choices = inst.group_type_choices[
        #         form.initial['type'].nature_remuneration]

        
    FormSet.__init__ = __init__

    return FormSet


ReadOnlyRemunForm = remun_formset_factory(
    dae.Dossier,
    dae.Remuneration,
    form=ReadOnlyRemunForm,
    groups = [
        (u'Traitement', u'Traitement',),
        (u'Indemnité', u'Indemnité',),
        (u'Charges', u'Charges',),
        (u'Accessoire', u'Accessoire',),
        ]
    )

null_choice = ('', '-' * 10)
RemunForm = remun_formset_factory(
    dae.Dossier,
    dae.Remuneration,
    form=FlexibleRemunForm,
    groups = [
        (u'Traitement', u'Traitement',),
        (u'Indemnité', u'Indemnité',),
        (u'Charges', u'Charges',),
        (u'Accessoire', u'Accessoire',),
        ],
    choice_overrides = {
        u'Traitement': {
            'type': [null_choice] + list(
                rh.TypeRemuneration.objects.filter(
                nature_remuneration=u'Traitement').values_list(
                'id', 'nom')
                )
            },
        u'Indemnité': {
            'type': [null_choice] + list(
                rh.TypeRemuneration.objects.filter(
                nature_remuneration=u'Indemnité').values_list(
                'id', 'nom')
                )
            },
        u'Charges': {
            'type': [null_choice] + list(
                rh.TypeRemuneration.objects.filter(
                nature_remuneration=u'Charges').values_list(
                'id', 'nom')
                )
            },
        u'Accessoire': {
            'type': [null_choice] + list(
                rh.TypeRemuneration.objects.filter(
                nature_remuneration=u'Accessoire').values_list(
                'id', 'nom')
                )
            },
        }
    )

RemunForm = ReadOnlyRemunForm


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('implantation', '-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, ))
        today = datetime.date.today()
        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) \
                .filter(Q(date_debut__lte=today) &
                        (Q(date_fin__gte=today) |
                         Q(date_fin__isnull=True))
                        ) \
                .order_by('implantation', '-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='M'" % 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'),
        )
    )