def column_form(self):
"""
Returns a form of booleans for each field in fields,
bound with self.data if is not None.
"""
if not hasattr(self, '_column_form'):
list_display = self.get_list_display()
default_fields = self.get_default_fields()
choices = [(field, capfirst(self._label(field))) for field in list_display]
if default_fields is None:
initial = list_display
else:
initial = default_fields
field = forms.MultipleChoiceField(
choices=choices,
initial=initial,
widget=forms.CheckboxSelectMultiple,
required=False,
)
# Workaround for https://github.com/gregmuellegger/django-floppyforms/issues/145
field.hidden_widget = forms.MultipleHiddenInput
fields = {
TABLE_COLUMN_FIELD: field,
}
Form = type(str('{}Form'.format(self.__class__.__name__)), (self.get_column_form_class(),), fields)
self._column_form = Form(self.data, prefix=self.form_prefix)
return self._column_form
class GenericSplitConfig(forms.Form):
def __init__(self, *args, **kwargs):
super(GenericSplitConfig, self).__init__(*args)
json_tables = RestClient.get_hbase_tables()
self.fields["tables_selection"].choices = [
[table['tableName'], table['tableName']] for table in json_tables
]
has_config = True
title = "Generic Split Configuration"
panel_info_template = "snippets/panel_info_generic_split.html"
number_of_splits = forms.IntegerField(widget=NumberSlider,
label='Number of splits',
required=False,
max_value=30)
tables_selection = forms.MultipleChoiceField(
widget=forms.SelectMultiple(attrs={'size': '10'}),
label='Tables selection',
required=False)
def get_json_config(self):
json_config = dict()
json_config['number_of_splits'] = self.cleaned_data['number_of_splits']
json_config['tables_selection'] = self.cleaned_data['tables_selection']
return json_config
class UpcomingMeetingParticipantsForm(forms.ModelForm):
board = forms.MultipleChoiceField(widget=OCCheckboxSelectMultiple, required=False)
class Meta:
model = Community
fields = (
'upcoming_meeting_participants',
'upcoming_meeting_guests',
)
widgets = {
'upcoming_meeting_participants': OCCheckboxSelectMultiple,
'upcoming_meeting_guests': forms.Textarea,
}
def __init__(self, *args, **kwargs):
super(UpcomingMeetingParticipantsForm, self).__init__(*args, **kwargs)
participants = self.instance.upcoming_meeting_participants.values_list(
'id', flat=True)
board_in = []
board_choices = []
for b in self.instance.get_board_members():
board_choices.append((b.id, b.display_name,))
if b.id in participants:
board_in.append(b.id)
self.fields['board'].choices = board_choices
self.initial['board'] = board_in
self.fields['upcoming_meeting_participants'].queryset = self.instance.get_members()
self.fields['upcoming_meeting_participants'].label = ""
class CloseMeetingForm(forms.ModelForm):
send_to_options = list(SendToOption.choices[2:])
# On QA servers, allow users to prevent sending of protocols
if settings.QA_SERVER:
send_to_options.insert(0, SendToOption.choices[0])
send_to = forms.TypedChoiceField(label=_("Send to"),
coerce=int,
choices=send_to_options,
widget=forms.RadioSelect)
issues = forms.MultipleChoiceField(
label=_("The selected issues will be archived"),
choices=[],
widget=forms.CheckboxSelectMultiple,
required=False)
class Meta:
model = Meeting
fields = ('held_at', )
widgets = {
'held_at': OCSplitDateTime,
}
def _get_issue_alert(self, issue):
if not issue.changed_in_current():
return _('Issue was not modified in this meeting')
elif issue.open_proposals():
return u'{0} {1}'.format(issue.open_proposals().count(),
_('Undecided proposals'))
else:
return None
def __init__(self, *args, **kwargs):
# self.helper = FormHelper()
#
# self.helper.add_input(Submit('submit', _('Close Meeting')))
issues = kwargs.pop('issues')
super(CloseMeetingForm, self).__init__(*args, **kwargs)
issues_op = []
init_vals = [] # issues which 'archive' checkbox should be checked
for issue in issues:
choice_txt = issue.title
alert_txt = self._get_issue_alert(issue)
if alert_txt:
choice_txt += u'<span class="help-text">{0}</span>'.format(
alert_txt)
else:
# mark as ready for archive only when no alerts exist
init_vals.append(issue.id)
issues_op.append((
issue.id,
mark_safe(choice_txt),
))
self.fields['issues'].choices = issues_op
self.fields['issues'].initial = init_vals
class OptaPlannerBalancingConfig(forms.Form):
def __init__(self, *args, **kwargs):
super(OptaPlannerBalancingConfig, self).__init__(*args)
json_tables = RestClient.get_hbase_tables()
self.fields["tables_selection"].choices = [
[table['tableName'], table['tableName']] for table in json_tables
]
has_config = True
title = "Opta Planner Balancing Configuration"
panel_info_template = "snippets/panel_info_optaplanner_balancing.html"
timeout = forms.IntegerField(
widget=NumberSlider,
label='Time in seconds to explore the space of solutions',
required=False,
max_value=240)
move_max = forms.IntegerField(
widget=NumberSlider,
label='Maximum number of moves (hard constraint)',
required=False,
max_value=240)
move_weight = forms.IntegerField(widget=NumberSlider,
label='Move weight (soft constraint)',
required=False,
max_value=100)
size_weight = forms.IntegerField(widget=NumberSlider,
label='Size weight (soft constraint)',
required=False,
max_value=100)
read_weight = forms.IntegerField(
widget=NumberSlider,
label='Read requests weight (soft constraint)',
required=False,
max_value=100)
write_weight = forms.IntegerField(
widget=NumberSlider,
label='Write requests weight (soft constraint)',
required=False,
max_value=100)
tables_selection = forms.MultipleChoiceField(
widget=forms.SelectMultiple(attrs={'size': '10'}),
label='Tables selection',
required=True)
def get_json_config(self):
if len(self.cleaned_data['tables_selection']) == 0:
raise forms.ValidationError("You must select at least one table!")
json_config = dict()
json_config['timeout'] = self.cleaned_data['timeout']
json_config['move_max'] = self.cleaned_data['move_max']
json_config['move_weight'] = self.cleaned_data['move_weight']
json_config['size_weight'] = self.cleaned_data['size_weight']
json_config['read_weight'] = self.cleaned_data['read_weight']
json_config['write_weight'] = self.cleaned_data['write_weight']
json_config['tables_selection'] = self.cleaned_data['tables_selection']
return json_config
class AllFieldsForm(forms.Form):
boolean = forms.BooleanField()
char = forms.CharField(max_length=50)
choices = forms.ChoiceField(choices=ALPHA_CHOICES)
date = forms.DateField()
datetime = forms.DateTimeField()
decimal = forms.DecimalField(decimal_places=2, max_digits=4)
email = forms.EmailField()
file_field = forms.FileField()
file_path = forms.FilePathField(path='uploads/')
float_field = forms.FloatField()
generic_ip_address = forms.GenericIPAddressField()
image = forms.ImageField()
integer = forms.IntegerField()
ip_address = forms.IPAddressField()
multiple_choices = forms.MultipleChoiceField(choices=ALPHA_CHOICES)
null_boolean = forms.NullBooleanField()
regex_field = forms.RegexField(regex='^\w+$', js_regex='^[a-zA-Z]+$')
slug = forms.SlugField()
split_datetime = forms.SplitDateTimeField()
time = forms.TimeField()
typed_choices = forms.TypedChoiceField(choices=NUMERIC_CHOICES, coerce=int)
typed_multiple_choices = forms.TypedMultipleChoiceField(
choices=NUMERIC_CHOICES, coerce=int)
url = forms.URLField()
# GIS fields.
if gis_forms:
osm_point = gis.PointField(
widget=mixin(gis.PointWidget, gis.BaseOsmWidget))
osm_multipoint = gis.MultiPointField(
widget=mixin(gis.MultiPointWidget, gis.BaseOsmWidget))
osm_linestring = gis.LineStringField(
widget=mixin(gis.LineStringWidget, gis.BaseOsmWidget))
osm_multilinestring = gis.MultiLineStringField(
widget=mixin(gis.MultiLineStringWidget, gis.BaseOsmWidget))
osm_polygon = gis.PolygonField(
widget=mixin(gis.PolygonWidget, gis.BaseOsmWidget))
osm_multipolygon = gis.MultiPolygonField(
widget=mixin(gis.MultiPolygonWidget, gis.BaseOsmWidget))
gmap_point = gis.PointField(
widget=mixin(gis.PointWidget, BaseGMapWidget))
gmap_multipoint = gis.MultiPointField(
widget=mixin(gis.MultiPointWidget, BaseGMapWidget))
gmap_linestring = gis.LineStringField(
widget=mixin(gis.LineStringWidget, BaseGMapWidget))
gmap_multilinestring = gis.MultiLineStringField(
widget=mixin(gis.MultiLineStringWidget, BaseGMapWidget))
gmap_polygon = gis.PolygonField(
widget=mixin(gis.PolygonWidget, BaseGMapWidget))
gmap_multipolygon = gis.MultiPolygonField(
widget=mixin(gis.MultiPolygonWidget, BaseGMapWidget))
def make_posts_form(self):
self.posts_form = None
list_choices = self.posts_actions();
if (not self.request.user.is_authenticated()
or not list_choices):
return
form_fields = {}
form_fields['list_action'] = forms.ChoiceField(choices=list_choices)
list_choices = []
for item in self.posts:
list_choices.append((item.pk, None))
if not list_choices:
return
form_fields['list_items'] = forms.MultipleChoiceField(choices=list_choices, widget=forms.CheckboxSelectMultiple)
self.posts_form = type('PostsViewForm', (Form,), form_fields)
def get_actions_form(self, page_items):
"""
Build a form object with list of all items actions
"""
if not self.actions:
return None # Dont build form
form_fields = {}
list_choices = []
for action in self.actions:
list_choices.append((action[0], action[1]))
form_fields['list_action'] = forms.ChoiceField(choices=list_choices)
list_choices = []
for item in page_items:
list_choices.append((item.pk, None))
form_fields['list_items'] = forms.MultipleChoiceField(
choices=list_choices, widget=forms.CheckboxSelectMultiple)
return type('AdminListForm', (Form, ), form_fields)
class TimeBasedForm(forms.Form):
"""A generic template for time and school year based forms"""
this_year = forms.BooleanField(
required=False,
initial=True,
widget=forms.CheckboxInput(
attrs={'onclick': 'toggle("id_this_year")'}))
all_years = forms.BooleanField(
required=False,
widget=forms.CheckboxInput(
attrs={'onclick': 'toggle("id_all_years")'}))
date_begin = forms.DateField(widget=adminwidgets.AdminDateWidget(),
required=False,
validators=settings.DATE_VALIDATORS)
date_end = forms.DateField(widget=adminwidgets.AdminDateWidget(),
required=False,
validators=settings.DATE_VALIDATORS)
# CourseMeet.day_choice is a tuple of tuples; need the first value from each inner tuple for initial
schedule_days = forms.MultipleChoiceField(
required=False,
choices=CourseMeet.day_choice,
help_text=
'''On applicable reports, only the selected days will be included.
Hold down "Control", or "Command" on a Mac, to select more than one.'''
)
marking_period = forms.ModelMultipleChoiceField(
required=False, queryset=MarkingPeriod.objects.all())
include_deleted = forms.BooleanField(required=False)
class Media:
js = ('/static/js/time_actions.js', )
def clean(self):
data = self.cleaned_data
if not data.get("this_year") and not data.get("all_years"):
if not data.get("date_begin") or not data.get("date_end"):
if not data.get("marking_period"):
raise forms.ValidationError(
"You must select this year, all years, specify a date, or select a marking period."
)
return data
def get_dates(self):
""" Returns begining and start dates in a tuple
Pass it form.cleaned_data """
data = self.cleaned_data
if data['this_year'] and not data['marking_period']:
start = SchoolYear.objects.get(active_year=True).start_date
# if they want a date in the future, let them specify it explicitly
end = min(date.today(),
SchoolYear.objects.get(active_year=True).end_date)
elif not data['this_year'] and not data['all_years'] and not data[
'marking_period']:
start = data['date_begin']
end = data['date_end']
elif data['marking_period']:
start = data['marking_period'].all().order_by(
'start_date')[0].start_date
end = data['marking_period'].all().order_by(
'-end_date')[0].end_date
else: # all of time
start = date(1980, 1, 1)
end = date(2980, 1, 1)
return (start, end)
class Form(forms.Form):
key = forms.MultipleChoiceField(
widget=forms.CheckboxSelectMultiple,
choices=choices,
)
class MultiForm(forms.Form):
multi = forms.MultipleChoiceField(
choices=CHOICES,
widget=forms.CheckboxSelectMultiple,
)
class MultiForm(forms.Form):
multi = forms.MultipleChoiceField(choices=CHOICES)
class MultiForm(forms.Form):
multi = forms.MultipleChoiceField(widget=forms.MultipleHiddenInput,
choices=some_choices)
def get_field(self):
from misago.forms import YesNoSwitch
extra = self.get_extra()
# Set validators
field_validators = []
if 'min' in extra:
if self.normalize_to in ('string', 'array'):
field_validators.append(validators.MinLengthValidator(extra['min']))
if self.normalize_to in ('integer', 'float'):
field_validators.append(validators.MinValueValidator(extra['min']))
if 'max' in extra:
if self.normalize_to in ('string', 'array'):
field_validators.append(validators.MaxLengthValidator(extra['max']))
if self.normalize_to in ('integer', 'float'):
field_validators.append(validators.MaxValueValidator(extra['max']))
# Yes-no
if self.field == 'yesno':
return forms.BooleanField(
initial=self.value,
label=_(self.name),
help_text=_(self.description) if self.description else None,
required=False,
widget=YesNoSwitch,
)
# Multi-list
if self.field == 'mlist':
return forms.MultipleChoiceField(
initial=self.value,
label=_(self.name),
help_text=_(self.description) if self.description else None,
widget=forms.CheckboxSelectMultiple,
validators=field_validators,
required=False,
choices=extra['choices']
)
# Select or choice
if self.field == 'select' or self.field == 'choice':
# Timezone list?
if extra['choices'] == '#TZ#':
extra['choices'] = tzlist()
return forms.ChoiceField(
initial=self.value,
label=_(self.name),
help_text=_(self.description) if self.description else None,
widget=forms.RadioSelect if self.field == 'choice' else forms.Select,
validators=field_validators,
required=False,
choices=extra['choices']
)
# Textarea
if self.field == 'textarea':
return forms.CharField(
initial=self.value,
label=_(self.name),
help_text=_(self.description) if self.description else None,
validators=field_validators,
required=False,
widget=forms.Textarea
)
kwargs = {
'initial': self.value,
'label': _(self.name),
'help_text': _(self.description) if self.description else None,
'validators': field_validators,
'required': False,
}
# Default input
default_input = forms.CharField
if self.normalize_to == 'integer':
default_input = forms.IntegerField
if self.normalize_to == 'float':
default_input = forms.FloatField
# Make text-input
return default_input(**kwargs)
