First work to modularize the application (forms)

1 files changed, 105 insertions, 100 deletions

diff --git a/ishtar/furnitures/forms_files.py b/ishtar/furnitures/forms_files.py
index ae52fc8cc..4e63fc588 100644
--- a/ishtar/furnitures/forms_files.py
+++ b/ishtar/furnitures/forms_files.py
@@ -32,8 +32,12 @@ from ishtar import settings
 
 import models
 import widgets
-from forms import Wizard, FinalForm, FormSet, SearchWizard, formset_factory, \
-                  get_now, reverse_lazy
+from forms import Wizard, FinalForm, FormSet, ClosingWizard, SearchWizard, \
+                  formset_factory, get_now, reverse_lazy
+from forms_common import TownFormSet, ParcelFormSet
+from forms_operations import OperationAdministrativeActWizard, \
+AdministrativeActOpeForm, AdministrativeActOpeFormSelection, \
+AdministrativeActDeletionWizard, FinalAdministrativeActDeleteForm, is_preventive
 
 class FileWizard(Wizard):
     model = models.File
@@ -195,86 +199,6 @@ class FileFormAddress(forms.Form):
     postal_code = forms.CharField(label=_(u"Main address - postal code"),
                                   max_length=10)
 
-class TownForm(forms.Form):
-    form_label = _("Towns")
-    associated_models = {'town':models.Town}
-    # !FIXME hard_link, reverse_lazy doen't seem to work with formsets
-    town = forms.IntegerField(label=_(u"Town"), required=False,
-         widget=widgets.JQueryAutoComplete("/" + settings.URL_PATH + \
-                     'autocomplete-town', associated_model=models.Town),
-         validators=[models.valid_id(models.Town)])
-
-class TownFormSet(FormSet):
-    def clean(self):
-        """Checks that no towns are duplicated."""
-        if any(self.errors):
-            return
-        towns = []
-        for i in range(0, self.total_form_count()):
-            form = self.forms[i]
-            if not form.is_valid():
-                continue
-            if 'town' not in form.cleaned_data or not form.cleaned_data['town']:
-                continue
-            town = form.cleaned_data['town']
-            if town in towns:
-                raise forms.ValidationError, _("There are identical towns.")
-            towns.append(town)
-
-TownFormSet = formset_factory(TownForm, can_delete=True, formset=TownFormSet)
-TownFormSet.form_label = _("Towns")
-
-class ParcelForm(forms.Form):
-    form_label = _("Parcels")
-    base_model = 'parcel'
-    associated_models = {'parcel':models.Parcel, 'town':models.Town}
-    town = forms.ChoiceField(label=_("Town"), choices=(), required=False,
-                             validators=[models.valid_id(models.Town)])
-    section = forms.CharField(label=_(u"Section"), required=False,
-                             validators=[validators.MaxLengthValidator(4)])
-    parcel_number = forms.CharField(label=_(u"Parcel number"), required=False,
-                             validators=[validators.MaxLengthValidator(6)])
-    year = forms.IntegerField(label=_("Year"), required=False,
-                              initial=lambda:datetime.datetime.now().year,
-                           validators=[validators.MinValueValidator(1900),
-                                       validators.MaxValueValidator(2100)])
-    def __init__(self, *args, **kwargs):
-        towns = None
-        if 'data' in kwargs and 'TOWNS' in kwargs['data']:
-            towns = kwargs['data']['TOWNS']
-            # clean data if not "real" data
-            prefix_value = kwargs['prefix'] + '-town'
-            if not [k for k in kwargs['data'].keys()
-                    if k.startswith(prefix_value) and kwargs['data'][k]]:
-                kwargs['data'] = None
-                if 'files' in kwargs:
-                    kwargs.pop('files')
-        super(ParcelForm, self).__init__(*args, **kwargs)
-        if towns:
-            self.fields['town'].choices = [('', '--')] + towns
-
-    def clean(self):
-        """Check required fields"""
-        if any(self.errors):
-            return
-        if not self.cleaned_data or DELETION_FIELD_NAME in self.cleaned_data \
-           and self.cleaned_data[DELETION_FIELD_NAME]:
-            return
-        for key in ('town', 'parcel_number', 'year'):
-            if not key in self.cleaned_data or not self.cleaned_data[key]:
-                raise forms.ValidationError(_(u"All fields are required"))
-        return self.cleaned_data
-
-
-class ParcelFormSet(FormSet):
-    def clean(self):
-        """Checks that no parcels are duplicated."""
-        return clean_duplicated(self, ('town', 'parcel_number', 'year'))
-
-ParcelFormSet = formset_factory(ParcelForm, can_delete=True,
-                                formset=ParcelFormSet)
-ParcelFormSet.form_label = _("Parcels")
-
 class FileFormPreventive(forms.Form):
     form_label = _("Preventive informations")
     associated_models = {'general_contractor':models.Person,
@@ -308,22 +232,6 @@ class FileFormPreventive(forms.Form):
     reception_date = forms.DateField(label=_(u"Reception date"),
                                      initial=get_now, widget=widgets.JQueryDate)
 
-def is_preventive(form_name, model, type_key='file_type', key=''):
-    def func(self, request, storage):
-        if storage.prefix not in request.session or \
-           'step_data' not in request.session[storage.prefix] or \
-           form_name not in request.session[storage.prefix]['step_data'] or\
-           form_name + '-' + type_key not in \
-                     request.session[storage.prefix]['step_data'][form_name]:
-            return False
-        try:
-            type = int(request.session[storage.prefix]['step_data']\
-                                      [form_name][form_name+'-'+type_key])
-            return model.is_preventive(type, key)
-        except ValueError:
-            return False
-    return func
-
 file_search_wizard = SearchWizard([('general-file_search', FileFormSelection)],
                             url_name='file_search',)
 
@@ -335,7 +243,8 @@ file_creation_wizard = FileWizard([
                             ('preventive-file_creation', FileFormPreventive),
                             ('final-file_creation', FinalForm)],
              condition_list={
-'preventive-file_creation':is_preventive('general-file_creation', models.FileType)
+'preventive-file_creation':is_preventive('general-file_creation',
+                                         models.FileType, type_key='file_type')
                             },
                             url_name='file_creation',)
 
@@ -349,6 +258,102 @@ file_modification_wizard = FileWizard([
                           ('final-file_modification', FinalForm)],
              condition_list={
 'preventive-file_modification':is_preventive('general-file_modification',
-                                             models.FileType)
+                                         models.FileType, type_key='file_type')
                             },
                           url_name='file_modification',)
+
+class FileClosingWizard(ClosingWizard):
+    model = models.File
+    fields = ['year', 'numeric_reference', 'internal_reference',
+              'file_type', 'in_charge', 'general_contractor', 'creation_date',
+              'reception_date', 'total_surface', 'total_developed_surface',
+              'address', 'address_complement', 'postal_code', 'comment']
+    if settings.COUNTRY == 'fr':
+        fields += ['saisine_type', 'reference_number']
+    fields += ['towns']
+
+class FileDeletionWizard(FileClosingWizard):
+    def get_formated_datas(self, forms):
+        datas = super(FileDeletionWizard, self).get_formated_datas(forms)
+        datas.append((_("Associated operations"), []))
+        for operation in models.Operation.objects.filter(
+                                        associated_file=self.current_obj).all():
+            if operation.end_date:
+                datas[-1][1].append(('', unicode(operation)))
+        return datas
+
+    def done(self, request, storage, form_list, **kwargs):
+        obj = self.get_current_object(request, storage)
+        for operation in models.Operation.objects.filter(
+                                                   associated_file=obj).all():
+            operation.delete()
+        obj.delete()
+        return render_to_response('wizard_done.html', {},
+                                  context_instance=RequestContext(request))
+
+
+class FinalFileDeleteForm(FinalForm):
+    confirm_msg = " "
+    confirm_end_msg = _(u"Would you like to delete this archaelogical file ?")
+
+file_deletion_wizard = FileDeletionWizard([
+                     ('selec-file_deletion', FileFormSelection),
+                     ('final-file_deletion', FinalFileDeleteForm)],
+                      url_name='file_deletion',)
+"""
+file_closing_wizard = FileWizard([
+                     ('selec-file_closing', FileFormSelection),
+                     ('date-operation_closing', OperationDateFormSelection),
+                     ('final-operation_closing', FinalOperationClosingForm)],
+                      url_name='operation_closing',)
+"""
+
+class FileAdministrativeActWizard(OperationAdministrativeActWizard):
+    model = models.File
+
+class FileEditAdministrativeActWizard(FileAdministrativeActWizard):
+    model = models.AdministrativeAct
+    edit = True
+    def get_associated_item(self, request, storage, dct):
+        return self.get_current_object(request, storage).associated_file
+
+class AdministrativeActFileSelect(forms.Form):
+    associated_file__towns = forms.IntegerField(label=_(u"Town"),
+         widget=widgets.JQueryAutoComplete("/" + settings.URL_PATH + \
+                     'autocomplete-town', associated_model=models.Town),
+         validators=[models.valid_id(models.Town)])
+    act_type = forms.ChoiceField(label=_("Act type"),
+                choices=models.ActType.get_types(dct={'intented_to':'F'}))
+
+class AdministrativeActFileFormSelection(AdministrativeActOpeFormSelection):
+    pk = forms.IntegerField(label="", required=False,
+       widget=widgets.JQueryJqGrid(reverse_lazy('get-administrativeactfile'),
+                      AdministrativeActFileSelect(), models.AdministrativeAct,
+                      table_cols='TABLE_COLS_FILE'),
+       validators=[models.valid_id(models.AdministrativeAct)])
+
+class AdministrativeActFileForm(AdministrativeActOpeForm):
+    act_type = forms.ChoiceField(label=_("Act type"),
+                choices=models.ActType.get_types(dct={'intented_to':'F'}))
+
+file_administrativeactfile_wizard = FileAdministrativeActWizard([
+       ('selec-file_administrativeactfile', FileFormSelection),
+       ('administrativeact-file_administrativeactfile', AdministrativeActFileForm),
+       ('final-file_administrativeactfile', FinalForm)],
+       url_name='file_administrativeactfile',)
+
+file_administrativeactfile_modification_wizard = FileEditAdministrativeActWizard([
+       ('selec-file_administrativeactfile_modification',
+                                            AdministrativeActFileFormSelection),
+       ('administrativeact-file_administrativeactfile_modification',
+                                            AdministrativeActFileForm),
+       ('final-file_administrativeactfile_modification', FinalForm)],
+       url_name='file_administrativeactfile_modification',)
+
+file_administrativeactfile_deletion_wizard = AdministrativeActDeletionWizard([
+                     ('selec-file_administrativeactfile_deletion',
+                                 AdministrativeActFileFormSelection),
+                     ('final-file_administrativeactfile_deletion',
+                                 FinalAdministrativeActDeleteForm)],
+                      url_name='file_administrativeactfile_deletion',)
+