def __init__(self, *args, **kwargs):
self.request = kwargs.pop('request', None)
clone = self.request.GET.get("clone", None)
name_suggest_fields = kwargs.pop('name_suggest_fields', [])
separator = kwargs.pop('separator', '-')
if clone:
item_to_clone = MDR._concept.objects.filter(id=clone).first().item
kwargs['initial'] = concept_to_clone_dict(item_to_clone)
super(AdminConceptForm, self).__init__(*args, **kwargs)
if self.instance and not clone:
self.itemtype = self.instance.__class__
self.fields['deprecated'] = forms.ModelMultipleChoiceField(
required=False,
label="Supersedes",
queryset=self.itemtype.objects.all(),
)
if self.instance.get_autocomplete_name(
) in autocomplete_light.registry.keys():
# if there is an autocomplete for this item, then replace it
# TODO: when autocomplete respects queryset these can be done automatically
self.fields[
'deprecated'].widget = autocomplete_light.MultipleChoiceWidget(
self.instance.get_autocomplete_name())
self.fields['deprecated'].initial = self.instance.supersedes.all()
if name_suggest_fields:
self.fields['name'].widget = widgets.NameSuggestInput(
name_suggest_fields=name_suggest_fields, separator=separator)
self.fields[
'workgroup'].queryset = self.request.user.profile.editable_workgroups.all(
)
class DocumentForm(GenericModelForm):
related = GenericModelMultipleChoiceField(
widget=autocomplete_light.MultipleChoiceWidget(
'AutocompleteDocumentRelations'))
class Meta:
model = Document
class MultipleDirectorSearchForm(FixedModelForm):
personnes = forms.ModelMultipleChoiceField(
Person.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('Director'))
class Meta:
model = PersonsSearch
class CmsForm(PermalinkForm):
class Meta:
model = CommonCms
title = forms.CharField(max_length=512, help_text=_('Title in 512 characters'))
image = files_widget.forms.FilesFormField(required=False, fields=(forms.CharField(required=False), forms.CharField(required=False), forms.CharField(required=False), ), widget=files_widget.forms.widgets.ImageWidget())
permalink = forms.CharField()
summary = forms.CharField(required=False, widget=forms.Textarea(attrs={'rows': 5, 'maxlength': 240}))
description = forms.CharField(required=False, widget=CKEditorWidget())
topics = forms.ModelMultipleChoiceField(queryset=Topic.objects.filter(level=0), widget=forms.CheckboxSelectMultiple(attrs={'id': 'id_topics'}))
tags = TagField(required=False, widget=TagAutocompleteTagIt(max_tags=False), help_text='')
in_the_news = forms.ModelMultipleChoiceField(
required=False,
queryset=Party.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(CmsHasPartyAutocomplete,
attrs={'placeholder': _('Type to search organizations or people by name.'), 'class': 'form-control'}
)
)
is_promoted = forms.BooleanField(
required=False,
widget=forms.CheckboxInput(attrs={'id': 'id_is_promoted'})
)
class M2MForm(forms.Form):
items_to_add = forms.ModelMultipleChoiceField(
queryset=self.model_to_add.objects.visible(self.request.user),
label="Attach",
required=False,
widget=autocomplete_light.MultipleChoiceWidget(
self.model_to_add.get_autocomplete_name()),
)
class SiteFilterForm(autocomplete_light.ModelForm):
name = autocomplete_light.ModelMultipleChoiceField(
Site.objects.all(),
required=False,
widget=autocomplete_light.MultipleChoiceWidget('SiteAutocomplete'))
class Meta:
model = Site
fields = ['name']
class EditPostForm(forms.ModelForm):
relatedItems = forms.ModelMultipleChoiceField(
queryset=MDR._concept.objects.all(),
label="Related items", required=False,
widget=autocomplete_light.MultipleChoiceWidget('Autocomplete_concept')
)
class Meta:
model = MDR.DiscussionPost
exclude = ['author', 'workgroup', 'closed']
class ProfileForm(forms.ModelForm):
user = forms.ModelChoiceField(
User.objects.all(),
widget=autocomplete_light.ChoiceWidget('UserAutocomplete'))
cities = forms.ModelMultipleChoiceField(
City.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('CityAutocomplete'))
class Meta:
model = Profile
class ChildCreateForm(forms.ModelForm):
'''using django-autocomplete-light'''
guardians = forms.ModelMultipleChoiceField(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserAutocomplete'))
class Meta:
model = Child
exclude = (
'information',
'teacher_notes',
)
class ModelGroupForm(GenericModelForm):
"""
Use AutocompleteTaggableItems defined in
gfk_autocomplete.autocomplete_light_registry.
"""
related = GenericModelMultipleChoiceField(
widget=autocomplete_light.MultipleChoiceWidget(
'AutocompleteTaggableItems'))
class Meta:
model = ModelGroup
class PredictionForm(FixedModelForm):
actors = forms.ModelMultipleChoiceField(
Person.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('Actor'))
directors = forms.ModelChoiceField(
Person.objects.all(),
widget=autocomplete_light.ChoiceWidget('Director'))
genre1 = forms.ModelChoiceField(
Person.objects.all(), widget=autocomplete_light.ChoiceWidget('genre1'))
genre2 = forms.ModelChoiceField(
Person.objects.all(), widget=autocomplete_light.ChoiceWidget('genre2'))
keyword = forms.ModelMultipleChoiceField(
Person.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('keyword_simple'))
class Media:
js = ('javascript/prediction/dependant_autocomplete.js', )
class Meta:
model = Prediction
widgets = autocomplete_light.get_widgets_dict(Prediction)
def __init__(self, attrs=None):
widget_list = []
for el in settings.THESAURI:
cleaned_name = el['name'].replace("-", " ").replace("_", " ").title()
widget_list.append(
autocomplete_light.MultipleChoiceWidget(
'thesaurus_' + el['name'],
attrs={'placeholder': '%s - Start typing for suggestions' % cleaned_name},
extra_context={'thesauri_title': cleaned_name}))
widgets = tuple(widget_list)
super(MultiThesauriWidget, self).__init__(widgets, attrs)
class ClassroomCreateForm(ModelForm):
'''using django-autocomplete-light'''
teachers = ModelMultipleChoiceField(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserAutocomplete'))
class Meta:
model = Classroom
fields = (
'name',
'description',
'teachers',
)
class AreaForm(autocomplete_light.ModelForm):
period_reference = autocomplete_light.ModelMultipleChoiceField(Book.objects.all(),
required = False,
widget =autocomplete_light.MultipleChoiceWidget('BookAutocomplete')
)
reference = autocomplete_light.ModelMultipleChoiceField(Book.objects.all(),
required = False,
widget =autocomplete_light.MultipleChoiceWidget('BookAutocomplete')
)
class Meta:
model = Area
#exclude =['reference', 'period_reference']
fields="__all__"
def __init__(self, *args, **kwargs):
super(AreaForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.add_input(Submit('submit','Create'))
instance = getattr(self, 'instance', None)
if instance and instance.pk:
self.fields['site'].widget.attrs['readonly'] = True #lock some fields in editing mode from editing
self.fields['site'].widget.attrs['disabled'] = True
self.fields['area_type'].widget.attrs['readonly'] = True
self.fields['area_type'].widget.attrs['disabled'] = True
def clean_site(self):
instance = getattr(self, 'instance', None)
if instance and instance.pk:
return instance.site
else:
return self.cleaned_data['site']
def clean_area_type(self):
instance = getattr(self, 'instance', None)
if instance and instance.pk:
return instance.area_type
else:
return self.cleaned_data['area_type']
class InterpretationForm(autocomplete_light.ModelForm):
reference = autocomplete_light.ModelMultipleChoiceField(Book.objects.all(),
required = False,
widget =autocomplete_light.MultipleChoiceWidget('BookAutocomplete'))
class Meta:
model = Interpretation
fields = '__all__'
def __init__(self, *args, **kwargs):
super(InterpretationForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.add_input(Submit('submit','Create'))
class GKSearchForm(FixedModelForm):
genre = forms.ModelChoiceField(
Person.objects.all(),
widget=autocomplete_light.ChoiceWidget('GenreAutocomplete'))
keyword = forms.ModelMultipleChoiceField(
Person.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('KeywordAutocomplete'))
class Media:
js = ('javascript/dependant_autocomplete_simple.js', )
class Meta:
model = GKSearch
widgets = autocomplete_light.get_widgets_dict(GKSearch)
class AddMembers(forms.Form):
roles = forms.MultipleChoiceField(
label=_("Workgroup roles"),
choices=sorted(MDR.Workgroup.roles.items()),
widget=forms.CheckboxSelectMultiple
)
users = forms.ModelMultipleChoiceField(
label=_("Select users"),
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('Autocomplete_AristotleUser')
)
def clean_roles(self):
roles = self.cleaned_data['roles']
roles = [role for role in roles if role in MDR.Workgroup.roles.keys()]
return roles
def __init__(self, *args, **kwargs):
initial_items = kwargs.pop('items', [])
super(BulkActionForm, self).__init__(*args, **kwargs)
if 'user' in kwargs.keys():
self.user = kwargs.pop('user', None)
queryset = MDR._concept.objects.visible(self.user)
else:
queryset = MDR._concept.objects.public()
self.fields['items'] = ForbiddenAllowedModelMultipleChoiceField(
label=self.item_label,
validate_queryset=MDR._concept.objects.all(),
queryset=queryset,
initial=initial_items,
widget=autocomplete_light.MultipleChoiceWidget(
'Autocomplete_concept'))
class SiteForm(autocomplete_light.ModelForm):
reference = autocomplete_light.ModelMultipleChoiceField(Book.objects.all(),
required = False,
widget =autocomplete_light.MultipleChoiceWidget('BookAutocomplete'),
help_text="Bibliographic and web-based references to publications and other relevant information on the site.")
class Meta:
model = Site
#exclude=["alternative_name"]
fields = '__all__'
def __init__(self, *args, **kwargs):
super(SiteForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.add_input(Submit('submit','Create'))
class QueueForm(forms.Form):
adds = forms.ModelMultipleChoiceField(None,
required=False,
widget=autocomplete_light.MultipleChoiceWidget(attrs={'class': 'form-control'}),
)
def __init__(self, queryset=None, autocomplete=None, label=None, placeholder=None, *args, **kwargs):
autocomplete.choices = queryset
self.base_fields['adds'].queryset = queryset
self.base_fields['adds'].widget.autocomplete=autocomplete
self.base_fields['adds'].label = label
self.base_fields['adds'].widget.attrs['placeholder'] = placeholder
super(QueueForm, self).__init__(*args, **kwargs)
self.fields['adds'].help_text = None
class Meta:
model = Entry
fields = [
'title', 'about', 'text', 'photo', 'active', 'top', 'author',
'category', 'tags'
]
widgets = {
'tags':
autocomplete_light.MultipleChoiceWidget(
'TagAutocomplete',
attrs={
'data-autocomplete-minimum-characters': 1,
'placeholder': 'Selecciona los tags ...',
'class': 'multiplechoicewidget'
},
widget_attrs={'data-widget-maximum-values': 10}),
}
class Meta:
model = Idea
fields = ('title', 'hashtag', 'tagline', 'description', 'lots',
'website', 'video')
widgets = {
'lots':
autocomplete_light.MultipleChoiceWidget('LotAutocomplete'),
'hashtag':
forms.TextInput(
attrs={
'class':
'form-control',
'placeholder':
'The twitter hashtag of your project. Include #.'
}),
'tagline':
forms.Textarea(
attrs={
'rows': 2,
'class': 'form-control',
'placeholder': 'A short description of your project'
}),
'description':
forms.Textarea(
attrs={
'rows': 20,
'class': 'form-control',
'placeholder': 'Tell us more in-depth about your project'
}),
'website':
forms.URLInput(
attrs={
'class':
'form-control',
'placeholder':
'The url of the project website. Include http://'
}),
'video':
forms.TextInput(
attrs={
'class': 'form-control',
'placeholder': 'A link to a YouTube or Vimeo video'
}),
}
class InviteTestifyEditForm(CommonForm):
receivers = forms.ModelMultipleChoiceField(
required=True,
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
UserReceiverAutocomplete,
attrs={
'placeholder': _('Type to search people by name.'),
'class': 'form-control'
}))
message = forms.CharField(
required=False,
widget=forms.Textarea(attrs={
'rows': 2,
'placeholder': 'Your invites message'
}))
def __init__(self, *args, **kwargs):
self.item = kwargs.pop('item')
self.qs = kwargs.pop('qs')
self.user = kwargs.pop('user')
super(DeprecateForm, self).__init__(*args, **kwargs)
if self.item.get_autocomplete_name(
) in autocomplete_light.registry.keys():
form_widget = autocomplete_light.MultipleChoiceWidget(
self.item.get_autocomplete_name())
else:
# if there is no autocomplete for this item, then just give a select
# TODO: when autocomplete respects queryset these can be done automatically
form_widget = forms.SelectMultiple
self.fields['olderItems'] = forms.ModelMultipleChoiceField(
queryset=self.qs,
label=_("Supersede older items"),
required=False,
initial=self.item.supersedes.all(),
widget=form_widget)
class ProfileForm(forms.ModelForm):
user = forms.ModelChoiceField(
User.objects.all(),
widget=autocomplete_light.ChoiceWidget('UserAutocomplete'))
cities = forms.ModelMultipleChoiceField(
City.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
'CityAutocomplete',
# optionnal: override an autocomplete.js option
autocomplete_js_attributes={
'minimum_characters': 0,
'placeholder': 'Choose 3 cities ...'
},
# optionnal: override a widget.js option
widget_js_attributes={'max_values': 3}))
# Note that defining *_js_attributes on Autocomplete classes or instances
# also work.
class Meta:
model = Profile
class DeprecateForm(forms.Form):
olderItems = forms.ModelMultipleChoiceField(
queryset=MDR._concept.objects.all(),
label="Supersede older items",
required=False,
widget=autocomplete_light.MultipleChoiceWidget('Autocomplete_concept'))
def __init__(self, *args, **kwargs):
self.item = kwargs.pop('item')
self.qs = kwargs.pop('qs')
self.user = kwargs.pop('user')
super(DeprecateForm, self).__init__(*args, **kwargs)
if self.item.get_autocomplete_name(
) in autocomplete_light.registry.keys():
form_widget = autocomplete_light.MultipleChoiceWidget(
self.item.get_autocomplete_name())
else:
# if there is no autocomplete for this item, then just give a select
# TODO: when autocomplete respects queryset these can be done automatically
form_widget = forms.SelectMultiple
self.fields['olderItems'] = forms.ModelMultipleChoiceField(
queryset=self.qs,
label=_("Supersede older items"),
required=False,
initial=self.item.supersedes.all(),
widget=form_widget)
def clean_olderItems(self):
olderItems = self.cleaned_data['olderItems']
if self.item in olderItems:
raise forms.ValidationError("An item may not supersede itself")
for i in olderItems:
if not user_can_edit(self.user, i):
raise forms.ValidationError(
"You cannot supersede an item that you do not have permission to edit"
)
return olderItems
class NewPostForm(forms.ModelForm):
relatedItems = forms.ModelMultipleChoiceField(
queryset=MDR._concept.objects.all(),
label="Related items", required=False,
widget=autocomplete_light.MultipleChoiceWidget('Autocomplete_concept')
)
class Meta:
model = MDR.DiscussionPost
fields = ['title', 'body', 'workgroup', 'relatedItems']
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user', None)
super(NewPostForm, self).__init__(*args, **kwargs)
self.fields['workgroup'].queryset = self.user.profile.myWorkgroups
def clean_relatedItems(self):
"""
Attempting to add items you don't have permission to will silently fail.
Its unlikely to happen in normal use.
"""
relatedItems = self.cleaned_data['relatedItems']
relatedItems = [i for i in relatedItems if user_can_view(self.user, i)]
return relatedItems
class FindsForm(autocomplete_light.ModelForm, forms.ModelForm):
reference = autocomplete_light.ModelMultipleChoiceField(Book.objects.all(),
required = False,
widget =autocomplete_light.MultipleChoiceWidget('BookAutocomplete'),
help_text="Bibliographic and web-based reference(s) to publications and other relevant resources on the selected small finds.")
research_event = forms.ModelChoiceField(queryset=ResearchEvent.objects.all(),
help_text="Project/ Research the finds are related to.", required=False)
class Meta:
model = Finds
fields = '__all__'
def __init__(self, *args, **kwargs):
super(FindsForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.add_input(Submit('submit','Create'))
instance = getattr(self, 'instance', None)
if instance and instance.pk:
self.fields['area'].widget.attrs['readonly'] = True
self.fields['area'].widget.attrs['disabled'] = True
self.fields['finds_type'].widget.attrs['readonly'] = True
self.fields['finds_type'].widget.attrs['disabled'] = True
def clean_area(self):
instance = getattr(self, 'instance', None)
if instance and instance.pk:
return instance.area
else:
return self.cleaned_data['area']
def clean_finds_type(self):
instance = getattr(self, 'instance', None)
if instance and instance.pk:
return instance.finds_type
else:
return self.cleaned_data['finds_type']
class CourseForm(forms.Form):
course = forms.CharField(
max_length=255,
widget=autocomplete_light.MultipleChoiceWidget('CourseAutocomplete'))
class OrganizationEditForm(PermalinkForm):
permalink = forms.CharField()
kind = forms.ChoiceField(
label=_('What kind of your created ?'),
required=True,
widget=forms.RadioSelect(attrs={'id': 'id_kind'}),
choices=Organization.KIND_CHOICES,
)
admins = forms.ModelMultipleChoiceField(
required=False,
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
UserAdminAutocomplete,
attrs={
'placeholder': _('Type to search people by name.'),
'class': 'form-control'
}))
peoples = forms.ModelMultipleChoiceField(
required=False,
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
UserPeopleAutocomplete,
attrs={
'placeholder': _('Type for search people by name.'),
'class': 'form-control'
}))
partners = forms.ModelMultipleChoiceField(
required=False,
queryset=Organization.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
OrganizationPartnerAutocomplete,
attrs={
'placeholder': _('Type to search organizations by name.'),
'class': 'form-control'
}))
supporters = forms.ModelMultipleChoiceField(
required=False,
queryset=Party.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
PartySupporterAutocomplete,
attrs={
'placeholder':
_('Type to search organizations or people by name.'),
'class': 'form-control'
}))
recipients = forms.ModelMultipleChoiceField(
required=False,
queryset=Organization.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
OrganizationRecipientAutocomplete,
attrs={
'placeholder': _('Type to search organizations by name.'),
'class': 'form-control'
}))
investors = forms.ModelMultipleChoiceField(
required=False,
queryset=Party.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
PartyInvestorAutocomplete,
attrs={
'placeholder':
_('Type to search organizations or people by name.'),
'class': 'form-control'
}))
invest_recipients = forms.ModelMultipleChoiceField(
required=False,
queryset=Party.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
OrganizationInvestRecipientAutocomplete,
attrs={
'placeholder':
_('Type to search organizations or people by name.'),
'class': 'form-control'
}))
portfolios = forms.ModelMultipleChoiceField(
required=False,
queryset=Portfolio.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
PortfolioAutocomplete,
attrs={
'placeholder': _('Type for search portfolios by title.'),
'class': 'form-control'
}))
jobs = forms.ModelMultipleChoiceField(
required=False,
queryset=Job.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
JobAutocomplete,
attrs={
'placeholder': _('Type to search jobs by title.'),
'class': 'form-control'
}))
received_fundings = forms.ModelMultipleChoiceField(
required=False,
queryset=PartyReceivedFundingParty.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
PartyReceivedFundingPartyAutocomplete))
gived_fundings = forms.ModelMultipleChoiceField(
required=False,
queryset=PartyReceivedFundingParty.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
PartyGivedFundingPartyAutocomplete))
received_investings = forms.ModelMultipleChoiceField(
required=False,
queryset=PartyReceivedInvestingParty.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
PartyReceivedInvestingPartyAutocomplete))
gived_investings = forms.ModelMultipleChoiceField(
required=False,
queryset=PartyReceivedInvestingParty.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget(
PartyGivedInvestingPartyAutocomplete))
# Internal
image = files_widget.forms.FilesFormField(
required=False,
fields=(
forms.CharField(required=False),
forms.CharField(required=False),
forms.CharField(required=False),
),
widget=files_widget.forms.widgets.ImageWidget())
images = files_widget.forms.FilesFormField(
required=False,
fields=(
forms.CharField(required=False),
forms.CharField(required=False),
forms.CharField(required=False),
),
widget=files_widget.forms.widgets.ImagesWidget())
name = forms.CharField(max_length=255, widget=forms.TextInput())
summary = forms.CharField(
required=True,
widget=forms.Textarea(attrs={
'rows': 2,
'maxlength': SUMMARY_MAX_LENGTH
}))
description = forms.CharField(required=True, widget=CKEditorWidget())
# Taxonomy
type_of_needs = forms.ModelMultipleChoiceField(
required=False,
queryset=TypeOfNeed.objects.all(),
widget=forms.CheckboxSelectMultiple(attrs={'id': 'id_type_of_needs'}))
type_of_supports = forms.ModelMultipleChoiceField(
required=False,
queryset=TypeOfSupport.objects.all(),
widget=forms.CheckboxSelectMultiple(
attrs={'id': 'id_type_of_supports'}))
organization_primary_role = forms.ModelChoiceField(
required=True,
queryset=OrganizationRole.objects.all(),
widget=forms.RadioSelect(attrs={'id': 'id_organization_primary_role'}))
organization_roles = forms.ModelMultipleChoiceField(
required=True,
queryset=OrganizationRole.objects.all(),
widget=forms.CheckboxSelectMultiple(
attrs={'id': 'id_organization_roles'}))
organization_types = forms.ModelMultipleChoiceField(
required=False,
queryset=OrganizationType.objects.all(),
widget=forms.CheckboxSelectMultiple(
attrs={'id': 'id_organization_types'}))
investor_types = forms.ModelMultipleChoiceField(
required=False,
queryset=InvestorType.objects.all(),
widget=forms.CheckboxSelectMultiple(attrs={'id': 'id_investor_types'}))
topics = TreeNodeMultipleChoiceField(
queryset=Topic.objects.all(),
level_indicator=u'⌞',
widget=forms.CheckboxSelectMultiple(attrs={'id': 'id_topics'}))
country = forms.ModelChoiceField(
queryset=Country.objects.all(),
widget=forms.Select(attrs={'class': 'form-control'}))
product_launch = forms.ModelChoiceField(
required=False,
queryset=OrganizationProductLaunch.objects.all(),
widget=forms.Select(attrs={'class': 'form-control'}))
funding = forms.ModelChoiceField(
required=False,
queryset=OrganizationFunding.objects.all(),
widget=forms.Select(attrs={'class': 'form-control'}))
request_funding = forms.ModelChoiceField(
required=False,
queryset=OrganizationFunding.objects.all(),
widget=forms.Select(attrs={'class': 'form-control'}))
deal_size_start = forms.IntegerField(required=False,
min_value=0,
max_value=100000000000,
widget=forms.NumberInput)
deal_size_end = forms.IntegerField(required=False,
min_value=0,
max_value=100000000000,
widget=forms.NumberInput)
# External
facebook_url = forms.URLField(
required=False,
widget=forms.URLInput(attrs={
'class': 'form-control last',
'placeholder': _('Facebook URL')
}))
twitter_url = forms.URLField(
required=False,
widget=forms.URLInput(attrs={
'class': 'form-control last',
'placeholder': _('Twitter URL')
}))
linkedin_url = forms.URLField(
required=False,
widget=forms.URLInput(attrs={
'class': 'form-control last',
'placeholder': _('Linkedin URL')
}))
homepage_url = forms.URLField(
required=False,
widget=forms.URLInput(attrs={
'class': 'form-control last',
'placeholder': _('Homepage URL')
}))
# Meta
status = forms.ChoiceField(
required=False,
widget=forms.RadioSelect(attrs={'id': 'id_status'}),
choices=STATUS_CHOICES)
specials = forms.ModelMultipleChoiceField(
required=False,
queryset=Special.objects.all(),
widget=forms.CheckboxSelectMultiple(attrs={'id': 'id_specials'}))
def __init__(self,
inst=None,
model=None,
request_user=None,
*args,
**kwargs):
super(OrganizationEditForm, self).__init__(inst, model, request_user,
*args, **kwargs)
if inst.type_of_organization in [
inst.TYPE_SOCIAL_ENTERPRISE, inst.TYPE_STARTUP
]:
self.fields['type_of_needs'].required = True
self.fields['growth_stage'] = forms.ModelChoiceField(
required=False,
queryset=OrganizationGrowthStage.objects.all(),
widget=forms.Select(attrs={'class': 'form-control'}))
if inst.type_of_organization in [inst.TYPE_STARTUP]:
self.fields['product_launch'].required = True
self.fields['funding'].required = True
elif inst.type_of_organization == inst.TYPE_SUPPORTING_ORGANIZATION:
self.fields['growth_stage'] = forms.ModelMultipleChoiceField(
required=False,
queryset=OrganizationGrowthStage.objects.all(),
widget=forms.CheckboxSelectMultiple(
attrs={'id': 'id_growth_stage'}))
# bypass check required
if self.request_user and self.request_user.is_editor:
for field_name, field in self.fields.iteritems():
if hasattr(field, 'required'):
field.required = False
self.fields['kind'].required = True
self.fields['name'].required = True
self.fields['permalink'].required = True
def clean(self):
cleaned_data = super(OrganizationEditForm, self).clean()
# bypass check required
if self.request_user and self.request_user.is_editor:
return cleaned_data
for role in cleaned_data['organization_roles'].all():
field_name = '%s_types' % role.permalink
if role.permalink == Organization.TYPE_SUPPORTING_ORGANIZATION:
self.fields['organization_types'].required = True
self.fields['type_of_supports'].required = True
self.validate_required_field(cleaned_data,
'organization_types')
self.validate_required_field(cleaned_data, 'type_of_supports')
else:
field = self.fields.get(field_name)
if field:
field.required = True
self.validate_required_field(cleaned_data, field_name)
return cleaned_data
def validate_required_field(self,
cleaned_data,
field_name,
message="This field is required"):
if (field_name in cleaned_data
and (cleaned_data[field_name] is None or
(hasattr(cleaned_data[field_name], 'all')
and cleaned_data[field_name].all().count() == 0))):
self._errors[field_name] = self.error_class([message])
del cleaned_data[field_name]
