From 3159c0314ec7de73ac637221017748e2a9f37d59 Mon Sep 17 00:00:00 2001 From: Étienne Loks Date: Fri, 17 Nov 2017 13:31:20 +0100 Subject: Custom forms: admin form --- ishtar_common/admin.py | 66 +++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 65 insertions(+), 1 deletion(-) (limited to 'ishtar_common/admin.py') diff --git a/ishtar_common/admin.py b/ishtar_common/admin.py index c3ad21710..8045bff13 100644 --- a/ishtar_common/admin.py +++ b/ishtar_common/admin.py @@ -31,6 +31,7 @@ from django.contrib.contenttypes.models import ContentType from django.contrib.sites.admin import SiteAdmin from django.contrib.sites.models import Site from django.contrib.gis.forms import PointField, OSMWidget, MultiPolygonField +from django.core.cache import cache from django.http import HttpResponseRedirect, HttpResponse from django.shortcuts import render from django.template.defaultfilters import slugify @@ -38,8 +39,22 @@ from django.utils.translation import ugettext_lazy as _ from django import forms -from ishtar_common.apps import admin_site from ishtar_common import models +from ishtar_common.apps import admin_site +from ishtar_common.utils import get_cache + +from ishtar_common import forms as common_forms +from archaeological_files import forms as file_forms +from archaeological_operations import forms as operation_forms +from archaeological_context_records import forms as context_record_forms +from archaeological_finds import forms as find_forms, \ + forms_treatments as treatment_forms +from archaeological_warehouse import forms as warehouse_forms + + +ISHTAR_FORMS = [common_forms, file_forms, operation_forms, + context_record_forms, find_forms, treatment_forms, + warehouse_forms] class ImportGenericForm(forms.Form): @@ -319,11 +334,14 @@ class ImporterModelAdmin(admin.ModelAdmin): list_display = ('name', 'klass') model = models.ImporterModel + admin_site.register(models.ImporterModel, ImporterModelAdmin) class FormaterTypeAdmin(admin.ModelAdmin): list_display = ('formater_type', 'options') + + admin_site.register(models.FormaterType, FormaterTypeAdmin) @@ -331,6 +349,8 @@ class ImportAdmin(admin.ModelAdmin): list_display = ('name', 'importer_type', 'imported_file', 'user', 'state', 'creation_date') form = make_ajax_form(models.Import, {'user': 'ishtaruser'}) + + admin_site.register(models.Import, ImportAdmin) @@ -338,6 +358,8 @@ class TargetKeyGroupAdmin(admin.ModelAdmin): list_display = ('name', 'all_user_can_use', 'all_user_can_modify', 'available') search_fields = ('name',) + + admin_site.register(models.TargetKeyGroup, TargetKeyGroupAdmin) @@ -346,6 +368,8 @@ class TargetKeyAdmin(admin.ModelAdmin): 'value', 'is_set') list_filter = ("is_set", "target__column__importer_type") search_fields = ('target__target', 'value', 'key') + + admin_site.register(models.TargetKey, TargetKeyAdmin) @@ -353,12 +377,15 @@ class OperationTypeAdmin(GeneralTypeAdmin): list_display = GeneralTypeAdmin.list_display + ['order', 'preventive'] model = models.OperationType + admin_site.register(models.OperationType, OperationTypeAdmin) class SpatialReferenceSystemAdmin(GeneralTypeAdmin): list_display = GeneralTypeAdmin.list_display + ['order', 'srid'] model = models.SpatialReferenceSystem + + admin_site.register(models.SpatialReferenceSystem, SpatialReferenceSystemAdmin) @@ -418,6 +445,43 @@ class JsonDataFieldAdmin(admin.ModelAdmin): admin_site.register(models.JsonDataField, JsonDataFieldAdmin) +def get_choices_form(): + cache_key, value = get_cache(models.CustomForm, ['associated-forms']) + if value: + return value + forms = set() + for app_form in ISHTAR_FORMS: + for form in dir(app_form): + if 'Form' not in form: + # not very clean... but do not treat inappropriate items + continue + form = getattr(app_form, form) + if not issubclass(form, common_forms.CustomForm)\ + or not getattr(form, 'form_slug', None): + continue + forms.add((form.form_slug, form.form_admin_name)) + forms = list(forms) + cache.set(cache_key, forms, settings.CACHE_TIMEOUT) + return forms + + +class CustomFormForm(forms.ModelForm): + class Meta: + model = models.CustomForm + exclude = [] + form = forms.ChoiceField(label=_(u"Form"), choices=get_choices_form) + users = AutoCompleteSelectMultipleField('ishtaruser', required=False, + label=_(u"Users")) + + +class CustomFormAdmin(admin.ModelAdmin): + list_display = ['name', 'form', 'available'] + form = CustomFormForm + + +admin_site.register(models.CustomForm, CustomFormAdmin) + + class AdministrationScriptAdmin(admin.ModelAdmin): list_display = ['name', 'path'] -- cgit v1.2.3 From 828fc2faebf1b7fd86d9aaaedf1bd3bbd0d3c6dc Mon Sep 17 00:00:00 2001 From: Étienne Loks Date: Sun, 19 Nov 2017 20:08:16 +0100 Subject: Custom forms: admin forms --- ishtar_common/admin.py | 87 +++++++++++++++++++++++++++++++++++++++++-------- ishtar_common/forms.py | 27 +++++++++++++++ ishtar_common/models.py | 48 +++++++++++++++++++++++++-- ishtar_common/utils.py | 6 ++-- 4 files changed, 151 insertions(+), 17 deletions(-) (limited to 'ishtar_common/admin.py') diff --git a/ishtar_common/admin.py b/ishtar_common/admin.py index 8045bff13..7c21fa4be 100644 --- a/ishtar_common/admin.py +++ b/ishtar_common/admin.py @@ -32,6 +32,7 @@ from django.contrib.sites.admin import SiteAdmin from django.contrib.sites.models import Site from django.contrib.gis.forms import PointField, OSMWidget, MultiPolygonField from django.core.cache import cache +from django.forms import BaseInlineFormSet from django.http import HttpResponseRedirect, HttpResponse from django.shortcuts import render from django.template.defaultfilters import slugify @@ -91,6 +92,7 @@ def gen_import_generic(self, request, queryset): request.POST.getlist(admin.ACTION_CHECKBOX_NAME)}) return render(request, 'admin/import_from_csv.html', {'csv_form': form}) + gen_import_generic.short_description = "Import from a CSV file" @@ -166,6 +168,7 @@ class IshtarSiteProfileAdmin(admin.ModelAdmin): 'find', 'warehouse', 'mapping', 'preservation') model = models.IshtarSiteProfile + admin_site.register(models.IshtarSiteProfile, IshtarSiteProfileAdmin) @@ -173,6 +176,7 @@ class DepartmentAdmin(admin.ModelAdmin): list_display = ('number', 'label',) model = models.Department + admin_site.register(models.Department, DepartmentAdmin) @@ -183,6 +187,7 @@ class OrganizationAdmin(HistorizedObjectAdmin): exclude = ('merge_key', 'merge_exclusion', 'merge_candidate', ) model = models.Organization + admin_site.register(models.Organization, OrganizationAdmin) @@ -194,6 +199,7 @@ class PersonAdmin(HistorizedObjectAdmin): form = make_ajax_form(models.Person, {'attached_to': 'organization'}) model = models.Person + admin_site.register(models.Person, PersonAdmin) @@ -251,6 +257,7 @@ class AuthorAdmin(admin.ModelAdmin): model = models.Author form = make_ajax_form(models.Author, {'person': 'person'}) + admin_site.register(models.Author, AuthorAdmin) @@ -259,11 +266,14 @@ class PersonTypeAdmin(admin.ModelAdmin): model = models.PersonType filter_vertical = ('groups',) + admin_site.register(models.PersonType, PersonTypeAdmin) class GlobalVarAdmin(admin.ModelAdmin): list_display = ['slug', 'description', 'value'] + + admin_site.register(models.GlobalVar, GlobalVarAdmin) @@ -290,16 +300,22 @@ class ImporterDefaultAdmin(admin.ModelAdmin): list_display = ('importer_type', 'target') model = models.ImporterDefault inlines = (ImporterDefaultValuesInline,) + + admin_site.register(models.ImporterDefault, ImporterDefaultAdmin) class ImporterTypeAdmin(admin.ModelAdmin): list_display = ('name', 'associated_models', 'available') + + admin_site.register(models.ImporterType, ImporterTypeAdmin) class RegexpAdmin(admin.ModelAdmin): list_display = ('name', 'description', "regexp") + + admin_site.register(models.Regexp, RegexpAdmin) @@ -327,6 +343,8 @@ class ImporterColumnAdmin(admin.ModelAdmin): 'targets_lbl', 'duplicate_fields_lbl', 'required') list_filter = ('importer_type',) inlines = (ImportTargetInline, ImporterDuplicateFieldInline) + + admin_site.register(models.ImporterColumn, ImporterColumnAdmin) @@ -392,6 +410,8 @@ admin_site.register(models.SpatialReferenceSystem, SpatialReferenceSystemAdmin) class ItemKeyAdmin(admin.ModelAdmin): list_display = ('content_type', 'key', 'content_object', 'importer') search_fields = ('key', ) + + admin_site.register(models.ItemKey, ItemKeyAdmin) @@ -449,18 +469,10 @@ def get_choices_form(): cache_key, value = get_cache(models.CustomForm, ['associated-forms']) if value: return value - forms = set() - for app_form in ISHTAR_FORMS: - for form in dir(app_form): - if 'Form' not in form: - # not very clean... but do not treat inappropriate items - continue - form = getattr(app_form, form) - if not issubclass(form, common_forms.CustomForm)\ - or not getattr(form, 'form_slug', None): - continue - forms.add((form.form_slug, form.form_admin_name)) - forms = list(forms) + forms = [] + for slug in models.CustomForm.register(): + forms.append((slug, models.CustomForm._register[slug].form_admin_name)) + forms = sorted(forms, key=lambda x: x[1]) cache.set(cache_key, forms, settings.CACHE_TIMEOUT) return forms @@ -474,9 +486,57 @@ class CustomFormForm(forms.ModelForm): label=_(u"Users")) +class ExcludeFieldFormset(BaseInlineFormSet): + def get_form_kwargs(self, index): + kwargs = super(ExcludeFieldFormset, self).get_form_kwargs(index) + if not self.instance or not self.instance.pk: + return kwargs + form = self.instance.get_form_class() + if not form: + kwargs['choices'] = [] + return kwargs + kwargs['choices'] = [('', '--')] + form.get_custom_fields() + return kwargs + + +class ExcludeFieldForm(forms.ModelForm): + class Meta: + model = models.ExcludedField + exclude = [] + field = forms.ChoiceField(label=_(u"Field")) + + def __init__(self, *args, **kwargs): + choices = kwargs.pop('choices') + super(ExcludeFieldForm, self).__init__(*args, **kwargs) + self.fields['field'].choices = choices + + +class ExcludeFieldInline(admin.TabularInline): + model = models.ExcludedField + extra = 2 + form = ExcludeFieldForm + formset = ExcludeFieldFormset + + class CustomFormAdmin(admin.ModelAdmin): - list_display = ['name', 'form', 'available'] + list_display = ['name', 'form', 'available', 'apply_to_all', + 'users_lbl', 'user_types_lbl'] + fields = ('name', 'form', 'available', 'apply_to_all', 'users', + 'user_types') form = CustomFormForm + inlines = [ExcludeFieldInline] + + def get_inline_instances(self, request, obj=None): + # no inline on creation + if not obj: + return [] + return super(CustomFormAdmin, self).get_inline_instances(request, + obj=obj) + + def get_readonly_fields(self, request, obj=None): + if obj: + return ('form',) + return [] admin_site.register(models.CustomForm, CustomFormAdmin) @@ -515,6 +575,7 @@ class AdministrationTaskAdmin(admin.ModelAdmin): return ("script", ) + self.readonly_fields return self.readonly_fields + admin_site.register(models.AdministrationTask, AdministrationTaskAdmin) diff --git a/ishtar_common/forms.py b/ishtar_common/forms.py index d0c2bb035..0f1fa20f8 100644 --- a/ishtar_common/forms.py +++ b/ishtar_common/forms.py @@ -302,6 +302,33 @@ class CustomForm(object): form_admin_name = "" form_slug = "" + def __init__(self, *args, **kwargs): + super(CustomForm, self).__init__(*args, **kwargs) + # todo: filter by user / group... + q = models.CustomForm.objects.filter(form=self.form_slug, + available=True, apply_to_all=True) + if not q.count(): + return + # todo: prevent multiple result in database + form = q.all()[0] + for excluded in form.excluded_fields.all(): + # could have be filtered previously + if excluded.field in self.fields: + self.fields.pop(excluded.field) + + @classmethod + def get_custom_fields(cls): + fields = cls.base_fields + customs = [] + for key in fields: + field = fields[key] + # cannot customize display of required and hidden field + # field with no label are also rejected + if field.required or field.widget.is_hidden or not field.label: + continue + customs.append((key, field.label)) + return sorted(customs, key=lambda x: x[1]) + class DocumentGenerationForm(forms.Form): """ diff --git a/ishtar_common/models.py b/ishtar_common/models.py index a5a3d96c1..c888e87fd 100644 --- a/ishtar_common/models.py +++ b/ishtar_common/models.py @@ -1647,14 +1647,58 @@ class CustomForm(models.Model): verbose_name_plural = _(u"Custom forms") ordering = ['name', 'form'] + def users_lbl(self): + users = [unicode(user) for user in self.users.all()] + return " ; ".join(users) + + users_lbl.short_description = _(u"Users") + + def user_types_lbl(self): + user_types = [unicode(u) for u in self.user_types.all()] + return " ; ".join(user_types) + + user_types_lbl.short_description = _(u"User types") + + @classmethod + def register(cls): + if hasattr(cls, '_register'): + return cls._register + cache_key, value = get_cache(cls.__class__, ['dct-forms'], + app_label='ishtar_common') + if value: + cls._register = value + return cls._register + cls._register = {} + # ideally should be improved but only used in admin + from ishtar_common.admin import ISHTAR_FORMS + from ishtar_common.forms import CustomForm + + for app_form in ISHTAR_FORMS: + for form in dir(app_form): + if 'Form' not in form: + # not very clean... but do not treat inappropriate items + continue + form = getattr(app_form, form) + if not issubclass(form, CustomForm) \ + or not getattr(form, 'form_slug', None): + continue + cls._register[form.form_slug] = form + return cls._register + + def get_form_class(self): + register = self.register() + if self.form not in self._register: + return + return register[self.form] + class ExcludedField(models.Model): custom_form = models.ForeignKey(CustomForm, related_name='excluded_fields') field = models.CharField(_(u"Field"), max_length=250) class Meta: - verbose_name = _(u"Custom form - excluded field") - verbose_name_plural = _(u"Custom form - excluded fields") + verbose_name = _(u"Excluded field") + verbose_name_plural = _(u"Excluded fields") class GlobalVar(models.Model, Cached): diff --git a/ishtar_common/utils.py b/ishtar_common/utils.py index 5d9e85c60..ae178a752 100644 --- a/ishtar_common/utils.py +++ b/ishtar_common/utils.py @@ -51,9 +51,11 @@ def get_current_year(): return datetime.datetime.now().year -def get_cache(cls, extra_args=[]): +def get_cache(cls, extra_args=tuple(), app_label=None): + if not app_label: + app_label = cls._meta.app_label cache_key = u"{}-{}-{}".format( - settings.PROJECT_SLUG, cls._meta.app_label, cls.__name__) + settings.PROJECT_SLUG, app_label, cls.__name__) for arg in extra_args: if not arg: cache_key += '-0' -- cgit v1.2.3 From 6a3c8c3ff340110960bf64dbfc31e526243f6616 Mon Sep 17 00:00:00 2001 From: Étienne Loks Date: Tue, 21 Nov 2017 10:46:58 +0100 Subject: Custom forms: disable completly a form --- archaeological_operations/forms.py | 7 ++- archaeological_operations/tests.py | 23 +++++++++ archaeological_operations/wizards.py | 6 ++- ishtar_common/admin.py | 4 +- ishtar_common/forms.py | 21 +++++++-- .../migrations/0024_custom_form_enabled.py | 24 ++++++++++ ishtar_common/models.py | 4 ++ ishtar_common/utils.py | 19 ++++++++ ishtar_common/wizards.py | 55 +++++++++++++--------- 9 files changed, 132 insertions(+), 31 deletions(-) create mode 100644 ishtar_common/migrations/0024_custom_form_enabled.py (limited to 'ishtar_common/admin.py') diff --git a/archaeological_operations/forms.py b/archaeological_operations/forms.py index 61be371d1..47fe746f5 100644 --- a/archaeological_operations/forms.py +++ b/archaeological_operations/forms.py @@ -997,8 +997,10 @@ OperationFormModifGeneral.associated_models = \ OperationFormModifGeneral.associated_models['associated_file'] = File -class CollaboratorForm(forms.Form): +class CollaboratorForm(CustomForm, forms.Form): form_label = _(u"Collaborators") + form_admin_name = _(u"Operation - Collaborators") + form_slug = "operation-collaborators" base_models = ['collaborator'] associated_models = {'collaborator': Person, } collaborator = widgets.Select2MultipleField( @@ -1006,7 +1008,8 @@ class CollaboratorForm(forms.Form): def __init__(self, *args, **kwargs): super(CollaboratorForm, self).__init__(*args, **kwargs) - self.fields['collaborator'].widget.attrs['full-width'] = True + if 'collaborator' in self.fields: + self.fields['collaborator'].widget.attrs['full-width'] = True class OperationFormPreventive(forms.Form): diff --git a/archaeological_operations/tests.py b/archaeological_operations/tests.py index 9f07aff45..af6199774 100644 --- a/archaeological_operations/tests.py +++ b/archaeological_operations/tests.py @@ -1221,6 +1221,29 @@ class CustomFormTest(TestCase, OperationInitTest): msg="filter user - 'address' field not found on the modification " "wizard. It should not have been filtered.") + def test_enabled(self): + c = Client() + c.login(username=self.username, password=self.password) + + cls_wiz = OperationWizardModifTest + url = reverse(cls_wiz.url_name) + # first wizard step + step = 'selec-operation_modification' + cls_wiz.wizard_post(c, url, step, {'pk': self.operations[0].pk}) + + step = 'collaborators-operation_modification' + data = { + '{}{}-current_step'.format(cls_wiz.url_name, + cls_wiz.wizard_name): [step], + } + response = c.post(url, data) + self.assertNotEqual(response.status_code, 404) + CustomForm.objects.create( + name="Test2", form="operation-collaborators", available=True, + apply_to_all=True, enabled=False) + response = c.post(url, data) + self.assertEqual(response.status_code, 404) + class OperationSearchTest(TestCase, OperationInitTest): fixtures = FILE_FIXTURES diff --git a/archaeological_operations/wizards.py b/archaeological_operations/wizards.py index fffe34ca7..24c1af45b 100644 --- a/archaeological_operations/wizards.py +++ b/archaeological_operations/wizards.py @@ -23,6 +23,7 @@ from django.conf import settings from django.core.exceptions import ObjectDoesNotExist from django.core.urlresolvers import reverse from django.db.models import Max +from django.http import Http404 from django.shortcuts import render from django.utils.translation import ugettext_lazy as _ @@ -149,7 +150,10 @@ class OperationWizard(Wizard): data = {} if not step: step = self.steps.current - form = self.get_form_list()[step] + try: + form = self.get_form_list()[step] + except KeyError: + raise Http404() # manage the dynamic choice of towns if step.startswith('towns') and hasattr(form, 'management_form'): data['TOWNS'] = self.get_towns() diff --git a/ishtar_common/admin.py b/ishtar_common/admin.py index 7c21fa4be..189a02c05 100644 --- a/ishtar_common/admin.py +++ b/ishtar_common/admin.py @@ -519,9 +519,9 @@ class ExcludeFieldInline(admin.TabularInline): class CustomFormAdmin(admin.ModelAdmin): - list_display = ['name', 'form', 'available', 'apply_to_all', + list_display = ['name', 'form', 'available', 'enabled', 'apply_to_all', 'users_lbl', 'user_types_lbl'] - fields = ('name', 'form', 'available', 'apply_to_all', 'users', + fields = ('name', 'form', 'available', 'enabled', 'apply_to_all', 'users', 'user_types') form = CustomFormForm inlines = [ExcludeFieldInline] diff --git a/ishtar_common/forms.py b/ishtar_common/forms.py index 683726e67..da6a1c051 100644 --- a/ishtar_common/forms.py +++ b/ishtar_common/forms.py @@ -34,7 +34,7 @@ from django.utils.translation import ugettext_lazy as _ import models import widgets -from wizards import MultiValueDict +from ishtar_common.utils import MultiValueDict # from formwizard.forms import NamedUrlSessionFormWizard @@ -311,7 +311,17 @@ class CustomForm(object): except AttributeError: pass super(CustomForm, self).__init__(*args, **kwargs) - base_q = {"form": self.form_slug, 'available': True} + available, excluded = self.check_availability_and_excluded_fields( + current_user) + for exc in excluded: + if exc in self.fields: + self.fields.pop(exc) + + @classmethod + def check_availability_and_excluded_fields(cls, current_user): + if not current_user: + return True, [] + base_q = {"form": cls.form_slug, 'available': True} # order is important : try for user, user type then all query_dicts = [] if current_user: @@ -325,17 +335,20 @@ class CustomForm(object): dct = base_q.copy() dct.update({'apply_to_all': True}) query_dicts.append(dct) + excluded_lst = [] for query_dict in query_dicts: q = models.CustomForm.objects.filter(**query_dict) if not q.count(): continue # todo: prevent multiple result in database form = q.all()[0] + if not form.enabled: + return False, [] for excluded in form.excluded_fields.all(): # could have be filtered previously - if excluded.field in self.fields: - self.fields.pop(excluded.field) + excluded_lst.append(excluded.field) break + return True, excluded_lst @classmethod def get_custom_fields(cls): diff --git a/ishtar_common/migrations/0024_custom_form_enabled.py b/ishtar_common/migrations/0024_custom_form_enabled.py new file mode 100644 index 000000000..92fd32f6e --- /dev/null +++ b/ishtar_common/migrations/0024_custom_form_enabled.py @@ -0,0 +1,24 @@ +# -*- coding: utf-8 -*- +# Generated by Django 1.11 on 2017-11-21 09:55 +from __future__ import unicode_literals + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ('ishtar_common', '0023_excludedfield'), + ] + + operations = [ + migrations.AlterModelOptions( + name='excludedfield', + options={'verbose_name': 'Excluded field', 'verbose_name_plural': 'Excluded fields'}, + ), + migrations.AddField( + model_name='customform', + name='enabled', + field=models.BooleanField(default=True, help_text='Disable with caution: disabling a form with mandatory fields may lead to database errors.', verbose_name='Enable this form'), + ), + ] diff --git a/ishtar_common/models.py b/ishtar_common/models.py index c888e87fd..b0751f661 100644 --- a/ishtar_common/models.py +++ b/ishtar_common/models.py @@ -1635,6 +1635,10 @@ class CustomForm(models.Model): name = models.CharField(_(u"Name"), max_length=250) form = models.CharField(_(u"Form"), max_length=250) available = models.BooleanField(_(u"Available"), default=True) + enabled = models.BooleanField( + _(u"Enable this form"), default=True, + help_text=_(u"Disable with caution: disabling a form with mandatory " + u"fields may lead to database errors.")) apply_to_all = models.BooleanField( _(u"Apply to all"), default=False, help_text=_(u"Apply this form to all users. If set to True, selecting " diff --git a/ishtar_common/utils.py b/ishtar_common/utils.py index ae178a752..cc01f23e7 100644 --- a/ishtar_common/utils.py +++ b/ishtar_common/utils.py @@ -28,6 +28,7 @@ from django.conf import settings from django.contrib.gis.geos import GEOSGeometry from django.core.cache import cache from django.core.urlresolvers import reverse +from django.utils.datastructures import MultiValueDict as BaseMultiValueDict from django.utils.safestring import mark_safe from django.utils.translation import ugettext_lazy as _, ugettext from django.template.defaultfilters import slugify @@ -47,6 +48,24 @@ class BColors: UNDERLINE = '\033[4m' +class MultiValueDict(BaseMultiValueDict): + def get(self, *args, **kwargs): + v = super(MultiValueDict, self).getlist(*args, **kwargs) + if callable(v): + v = v() + if type(v) in (list, tuple) and len(v) > 1: + v = ",".join(v) + elif type(v) not in (int, unicode): + v = super(MultiValueDict, self).get(*args, **kwargs) + return v + + def getlist(self, *args, **kwargs): + lst = super(MultiValueDict, self).getlist(*args, **kwargs) + if type(lst) not in (tuple, list): + lst = [lst] + return lst + + def get_current_year(): return datetime.datetime.now().year diff --git a/ishtar_common/wizards.py b/ishtar_common/wizards.py index f86e03df0..e82b32671 100644 --- a/ishtar_common/wizards.py +++ b/ishtar_common/wizards.py @@ -34,37 +34,19 @@ from django.db.models.fields.files import FileField, ImageFieldFile from django.db.models.fields.related import ManyToManyField from django.db.models.fields import NOT_PROVIDED -from django.http import HttpResponseRedirect +from django.http import HttpResponseRedirect, Http404 from django.forms import ValidationError from django.shortcuts import redirect, render from django.template import loader -from django.utils.datastructures import MultiValueDict as BaseMultiValueDict from django.utils.translation import ugettext_lazy as _ from ishtar_common import models -from ishtar_common.utils import get_all_field_names +from ishtar_common.forms import CustomForm +from ishtar_common.utils import get_all_field_names, MultiValueDict logger = logging.getLogger(__name__) -class MultiValueDict(BaseMultiValueDict): - def get(self, *args, **kwargs): - v = super(MultiValueDict, self).getlist(*args, **kwargs) - if callable(v): - v = v() - if type(v) in (list, tuple) and len(v) > 1: - v = ",".join(v) - elif type(v) not in (int, unicode): - v = super(MultiValueDict, self).get(*args, **kwargs) - return v - - def getlist(self, *args, **kwargs): - lst = super(MultiValueDict, self).getlist(*args, **kwargs) - if type(lst) not in (tuple, list): - lst = [lst] - return lst - - def check_rights(rights=[], redirect_url='/'): """ Decorator that checks the rights to access the view. @@ -125,6 +107,19 @@ def _check_right(step, condition=True): """ +def filter_no_fields_form(form, other_check=None): + def func(self): + if issubclass(form, CustomForm): + enabled, exc = form.check_availability_and_excluded_fields( + self.request.user.ishtaruser) + if not enabled: + return False + if other_check: + return other_check(self) + return True + return func + + class Wizard(NamedUrlWizardView): model = None label = '' @@ -155,6 +150,19 @@ class Wizard(NamedUrlWizardView): self.condition_dict[form_key] = cond ''' + @classmethod + def get_initkwargs(cls, *args, **kwargs): + kwargs = super(Wizard, cls).get_initkwargs(*args, **kwargs) + # remove + for form_key in kwargs['form_list']: + form = kwargs['form_list'][form_key] + other_check = None + if form_key in kwargs['condition_dict']: + other_check = kwargs['condition_dict'][form_key] + kwargs['condition_dict'][form_key] = filter_no_fields_form( + form, other_check) + return kwargs + def dispatch(self, request, *args, **kwargs): self.current_right = kwargs.get('current_right', None) @@ -813,7 +821,10 @@ class Wizard(NamedUrlWizardView): data = data.copy() if not step: step = self.steps.current - form = self.get_form_list()[step] + try: + form = self.get_form_list()[step] + except KeyError: + raise Http404() if hasattr(form, 'management_form'): # manage deletion to_delete, not_to_delete = self.get_deleted(data.keys()) -- cgit v1.2.3