class SecondaryMenuFormMixin(EntangledModelFormMixin):
page_id = ChoiceField(
label=_("CMS Page Id"),
help_text=_(
"Select a CMS page with a given unique Id (in advanced settings)."
),
)
offset = IntegerField(
label=_("Offset"),
initial=0,
help_text=_("Starting from which child menu."),
)
limit = IntegerField(
label=_("Limit"),
initial=100,
help_text=_("Number of child menus."),
)
class Meta:
entangled_fields = {'glossary': ['page_id', 'offset', 'limit']}
def __init__(self, *args, **kwargs):
choices = [(p.reverse_id, str(p))
for p in Page.objects.filter(reverse_id__isnull=False,
publisher_is_draft=False)]
self.base_fields['page_id'].choices = choices
super().__init__(*args, **kwargs)
class LoginForm(forms.Form):
"""
Login form
"""
def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
initial=None, error_class=ErrorList, label_suffix=':',
empty_permitted=False, request=None):
super(LoginForm, self).__init__(data, files, auto_id, prefix, initial,\
error_class, label_suffix, empty_permitted)
self.request = request
username = forms.CharField(label=_(u"用户名"), max_length=30)
password = forms.CharField(widget=forms.PasswordInput(render_value=False, attrs={'class': 'middle', 'size': 20}))
verify_img = forms.CharField(widget=CaptchaWidget())
type = ChoiceField(widget=RadioSelect(attrs={'style': 'width:auto;'}), initial=0, choices=UserProfile.USER_TYPE)
def clean_verify_img(self):
"""
Validate that the verify code is valid.
"""
verify_code = self.cleaned_data.get('verify_img', '')
if verify_code == self.request.session.get(settings.NAME, ''):
return verify_code
raise forms.ValidationError(_(u'验证码错误。'))
class MapTileForm(AbstractMapForm):
if settings.XGDS_MAP_SERVER_GDAL2TILES_ZOOM_LEVELS:
minZoom = IntegerField(initial=12, label="Min Zoom")
maxZoom = IntegerField(initial=20, label="Max Zoom", help_text="(UAV=23, Satellite=20)")
resampleMethod = ChoiceField(choices=settings.XGDS_MAP_SERVER_GDAL_RESAMPLE_OPTIONS,
label="Resampling")
sourceFile = ResumableFileField(allowed_mimes=("image/tiff",),
upload_url=lambda: reverse('uploadResumable'),
chunks_dir=getattr(settings, 'FILE_UPLOAD_TEMP_DIR'),
label="GeoTiff File"
)
def save(self, commit=True):
instance = super(MapTileForm, self).save(commit=False)
if not instance.creator:
instance.creator = self.cleaned_data['username']
instance.creation_time = datetime.datetime.now(pytz.utc)
else:
instance.modifier = self.cleaned_data['username']
instance.modification_time = self.cleaned_data['username']
instance.parent = self.getParentGroup()
if commit:
instance.save()
class Meta(AbstractMapForm.Meta):
model = MapTile
exclude = ['creator', 'modifier', 'creation_time', 'modification_time', 'deleted', 'processed', 'minx', 'miny', 'maxx', 'maxy', 'resolutions']
def __init__(self, booking, *args, **kwargs):
super(BookingChoicesForm, self).__init__(*args, **kwargs)
self.booking = booking
# Adding form fields for each choice in the event
choice_field_names = []
for choice in booking.event.choices.all():
field_name = (self.choice_id_stem + "{0}").format(choice.id)
choice_field_names.append(field_name)
options = list(choice.options.all())
options.sort(key=self._scoreOption)
options_choices = [(opt.id, opt.title) for opt in options]
self.fields[field_name] = ChoiceField(label=choice.title,
choices=options_choices)
# Define the Crispy Form helper
self.helper = FormHelper()
self.helper.form_method = "post"
self.helper.form_action = reverse(
"booking_update", kwargs={"booking_id": self.booking.id})
self.helper.form_class = "form-horizontal"
self.helper.label_class = "col-lg-3"
self.helper.field_class = "col-lg-9"
self.helper.layout = Layout(
Div(*choice_field_names),
FormActions(
Submit("save", "Save", css_class="btn btn-success"),
Reset("reset", "Reset", css_class="btn btn-warning"),
),
)
class MailFilterForm(Form):
filter = ChoiceField(label='Metoda filtrowania')
def __init__(self, filter_methods, *args, **kwargs):
self.filter_methods = filter_methods
super().__init__(*args, **kwargs)
self.fields['filter'].choices = [
(k, v[1]) for k, v in self.filter_methods.items()
]
self.helper = FormHelper(self)
self.helper.include_media = False
self.helper.layout.fields.append(
FormActions(
StrictButton('Filtruj',
type='submit',
css_class='btn-outline-primary mx-1 my-3 w-100'),
css_class='text-right',
))
@property
def filter_id(self):
return self.cleaned_data['filter']
@property
def filter_method(self):
return self.filter_methods[self.cleaned_data['filter']][0]
@property
def filter_name(self):
return self.filter_methods[self.cleaned_data['filter']][1]
class FinalizeGatewaySetupForm(Form):
YES = 'Y'
NO = 'N'
YES_NO_CHOICES = (
(YES, ugettext_lazy("Yes")),
(NO, ugettext_lazy("No")),
)
name = TrimmedCharField(
label=ugettext_lazy("Name"),
required=True
)
set_as_default = ChoiceField(
label=ugettext_lazy("Set as default gateway"),
choices=YES_NO_CHOICES,
required=True
)
def __init__(self, *args, **kwargs):
super(FinalizeGatewaySetupForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = 'form form-horizontal'
self.helper.label_class = 'col-sm-3 col-md-2'
self.helper.field_class = 'col-sm-3 col-md-2'
self.helper.layout = Layout(
Div(
hqcrispy.B3MultiField(
_("Name"),
Div(
hqcrispy.MultiInlineField(
'name',
ng_model='name'
)
),
get_rmi_error_placeholder('nameError'),
ng_class="{'has-error': nameError}"
),
hqcrispy.B3MultiField(
_("Set as default gateway"),
Div(
hqcrispy.MultiInlineField(
'set_as_default',
ng_model='setAsDefault',
style='margin-left: 0px;'
)
),
get_rmi_error_placeholder('setAsDefaultError'),
ng_class="{'has-error': setAsDefaultError}"
),
FormActions(
StrictButton(
_("Complete"),
id="id_create_backend",
css_class='btn-success',
ng_click='createBackend();'
)
)
)
)
class PartsRequestForm(Form):
# Ticket info
priority = ChoiceField(label='Request Priority', error_messages={'required': 'Please select a priority'})
# Request info
printer = ModelChoiceField(queryset=None, empty_label="-------------", label='Printer', error_messages={'required': 'Please select a printer'})
part = ChainedModelChoiceField('printer', reverse_lazy('printerrequests:chained_part'), Part, label='Part', error_messages={'required': 'Please select a part'})
address = CharField(label='Location')
def __init__(self, *args, **kwargs):
super(PartsRequestForm, self).__init__(*args, **kwargs)
self.fields['printer'].queryset = PrinterType.objects.filter(id__in=set(Part.objects.values_list('printer', flat=True)))
self.fields["priority"].choices = PRIORITY_CHOICES
self.helper = FormHelper()
self.helper.form_method = 'post'
self.helper.html5_required = True
self.helper.form_class = 'form-horizontal'
self.helper.label_class = 'col-sm-2'
self.helper.field_class = 'col-sm-8 col-md-6'
self.helper.layout = Layout(
Fieldset(
'Create a parts request',
*self.fields
),
FormActions(
Submit('submit', 'Submit'),
)
)
class FormatForm(BaseForm):
'''Form handling the validation of the format related argument in
a request'''
# py3 dict merge (see https://stackoverflow.com/a/26853961/3526777):
__additional_fieldnames__ = {}
format = ChoiceField(required=False, initial='json',
label='The format of the data returned',
choices=[('json', 'json'), ('text', 'text/csv')])
text_sep = TextSepField(required=False, initial='comma',
label='The (column) separator character',
help_text=('Ignored if the requested '
'format is not text'))
text_dec = TextDecField(required=False, initial='period',
label='The decimal separator character',
help_text=('Ignored if the requested '
'format is not text'))
def clean(self):
super().clean()
tsep, tdec = 'text_sep', 'text_dec'
# convert to symbols:
if self.cleaned_data[tsep] == self.cleaned_data[tdec] and \
self.cleaned_data['format'] == 'text':
msg = _("'%s' must differ from '%s' in 'text' format" %
(tsep, tdec))
err_ = ValidationError(msg, code='conflicting values')
# add_error removes also the field from self.cleaned_data:
self.add_error(tsep, err_)
self.add_error(tdec, err_)
return self.cleaned_data
class AppScaffoldingForm(Form):
name = CharField(max_length=80,
label=_('App name'),
validators=[validate_id],
help_text=_('The app name must be camel case e.g. MyApp'))
platform = ChoiceField(choices=lazy(get_versions, list),
required=True,
label=_('Nextcloud version'))
author_name = CharField(max_length=80, label=_('Author\'s full name'))
author_email = EmailField(label=_('Author\'s e-mail'))
author_homepage = URLField(label=_('Author\'s homepage'), required=False)
issue_tracker = URLField(label=_('Issue tracker URL'),
required=True,
help_text=_('Bug reports and feature requests'))
categories = MultipleChoiceField(required=True,
label=_('Categories'),
choices=lazy(get_categories, list),
help_text=_('Hold down CTRL and click to '
'select multiple entries'))
summary = CharField(
max_length=256,
label=_('Summary'),
help_text=
_('Short description of your app that will be rendered as short teaser'
))
description = CharField(widget=Textarea,
label=_('Description'),
help_text=_('Full description of what your app '
'does. Can contain Markdown.'))
class SMEForm(forms.Form):
first_name = forms.CharField(label='First Name',
max_length=255,
required=True)
last_name = forms.CharField(label='Last Name',
max_length=255,
required=True)
email = forms.CharField(label='Email', max_length=255, required=True)
review_limit = forms.IntegerField(label='Review Limit',
initial=100,
required=False)
pay_rate = forms.DecimalField(max_digits=10,
decimal_places=2,
initial=0.00)
job = ChoiceField([])
region = RegionChoiceField(queryset=make_region_list_for_sme_manager(),
empty_label="(none)",
required=False)
employer_user = EmployerUserChoiceField(
queryset=make_employer_user_form_queryset(),
label="Linked employer_user",
required=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['job'].choices = make_job_structure_for_dropdown(
True, include_invisible=True)
def margins(cls):
form_fields = {}
choices_format = [
('m-{}{}', _("4 sided margins ({})")),
('mx-{}{}', _("Horizontal margins ({})")),
('my-{}{}', _("Vertical margins ({})")),
('mt-{}{}', _("Top margin ({})")),
('mr-{}{}', _("Right margin ({})")),
('mb-{}{}', _("Bottom margin ({})")),
('ml-{}{}', _("Left margin ({})")),
]
sizes = list(range(0, 6)) + ['auto']
for bp in Breakpoint:
if bp == Breakpoint.xs:
choices = [(c.format('', s), format_lazy(l, s))
for c, l in choices_format for s in sizes]
choices.insert(0, ('', _("No Margins")))
else:
choices = [(c.format(bp.name + '-', s), format_lazy(l, s))
for c, l in choices_format for s in sizes]
choices.insert(
0,
('',
format_lazy(_("Inherit margin from {}"), previous_label)))
previous_label = bp.label
form_fields['margins_{}'.format(bp.name)] = ChoiceField(
label=format_lazy(_("Margins for {breakpoint}"),
breakpoint=bp.label),
choices=choices,
required=False,
initial='',
)
return form_fields
def paddings(cls):
form_fields = {}
choices_format = [
('p-{}{}', _("4 sided padding ({})")),
('px-{}{}', _("Horizontal padding ({})")),
('py-{}{}', _("Vertical padding ({})")),
('pt-{}{}', _("Top padding ({})")),
('pr-{}{}', _("Right padding ({})")),
('pb-{}{}', _("Bottom padding ({})")),
('pl-{}{}', _("Left padding ({})")),
]
sizes = range(0, 6)
for bp in Breakpoint:
if bp == Breakpoint.xs:
choices = [(c.format('', s), format_lazy(l, s))
for c, l in choices_format for s in sizes]
choices.insert(0, ('', _("No Padding")))
else:
choices = [(c.format(bp.name + '-', s), format_lazy(l, s))
for c, l in choices_format for s in sizes]
choices.insert(0, ('',
format_lazy(_("Inherit padding from {}"),
previous_label)))
previous_label = bp.label
form_fields['padding_{}'.format(bp.name)] = ChoiceField(
label=format_lazy(_("Padding for {breakpoint}"),
breakpoint=bp.label),
choices=choices,
required=False,
initial='',
)
return form_fields
def floats(cls):
form_fields = {}
choices_format = [
('float-{}none', _("Do not float")),
('float-{}left', _("Float left")),
('float-{}right', _("Float right")),
]
for bp in Breakpoint:
if bp == Breakpoint.xs:
choices = [(c.format(''), l) for c, l in choices_format]
choices.insert(0, ('', _("Unset")))
else:
choices = [(c.format(bp.name + '-'), l)
for c, l in choices_format]
choices.insert(
0,
('', format_lazy(_("Inherit float from {}"),
previous_label)))
previous_label = bp.label
form_fields['float_{}'.format(bp.name)] = ChoiceField(
label=format_lazy(_("Floats for {breakpoint}"),
breakpoint=bp.label),
choices=choices,
required=False,
initial='',
)
return form_fields
class BroadcastMessageForm(forms.Form):
text = CharField(label=ugettext_lazy("Text:"),
required=True,
max_length=160,
widget=forms.Textarea)
to = ChoiceField(
label=ugettext_lazy("To:"),
choices=(("All", ugettext_lazy("All Data Senders")),
("Associated",
ugettext_lazy("Data Senders associated to my project")),
("Additional", ugettext_lazy("Other People"))),
initial=("All"))
others = CharField(label=ugettext_lazy("Other People:"),
max_length=160,
widget=forms.Textarea,
required=False)
def __init__(self, *args, **kwargs):
super(BroadcastMessageForm, self).__init__(*args, **kwargs)
self.fields['text'].widget.attrs['watermark'] = ugettext_lazy(
'Enter your SMS text')
self.fields['text'].widget.attrs['id'] = 'sms_content'
def clean_others(self):
others = self.cleaned_data['others']
return [
number.strip() for number in others.split(',')
if number.strip() != ''
]
class UserChangeForm(AuthUserChangeForm):
language = ChoiceField(label=_("language"),
choices=[(k, _(v)) for k, v in settings.LANGUAGES],
initial=settings.LANGUAGE_CODE[:2])
class Meta:
model = User
def __init__(self, *args, **kwargs):
super(BlogForm, self).__init__(*args, **kwargs)
self.fields["display_format"] = ChoiceField()
self.fields["display_format"].choices = [
("structuredtext", "structuredtext"),
("markdown", "markdown"),
]
self.fields["url"].required = False
self.fields["summary"].required = False
self.fields["proper_keywords"].required = False
# 10 was default
self.fields["text"].widget.attrs["rows"] = 20
all_categories = dict(Category.objects.all().values_list("id", "name"))
one_year = timezone.now() - datetime.timedelta(days=365)
qs = (BlogItem.categories.through.objects.filter(
blogitem__pub_date__gte=one_year).values("category_id").annotate(
Count("category_id")).order_by("-category_id__count"))
category_choices = []
used = []
for count in qs:
pk = count["category_id"]
combined = "{} ({})".format(all_categories[pk],
count["category_id__count"])
category_choices.append((pk, combined))
used.append(pk)
category_items = all_categories.items()
for pk, name in sorted(category_items, key=lambda x: x[1].lower()):
if pk in used:
continue
combined = "{} (0)".format(all_categories[pk])
category_choices.append((pk, combined))
self.fields["categories"].choices = category_choices
def __init__(self, choices, initial=None, *args, **kwargs):
assert not kwargs.get('required',
False), "required=True is not supported"
allchoices = [x for x in choices] # Force choices into a list.
allchoices.append((OTHER_VAL, OTHER_PRES))
self.widget = ChoiceOrOtherWidget(choices=allchoices)
choice_initial, other_initial = None, None
if initial is not None:
# Match initial against one of the values
if initial in [x for x, y in choices]:
choice_initial = initial
else:
choice_initial = OTHER_VAL
other_initial = initial
fields = [
ChoiceField(required=False, choices=allchoices),
CharField(required=False)
]
# Be careful not to make the initial value a tuple;
# it's checked explicitly to be a list in MultiWidget's
# render.
super(ChoiceOrOtherField,
self).__init__(fields,
initial=[choice_initial, other_initial],
*args,
**kwargs)
class ImportForm(Form):
model = ChoiceField()
csv = CsvFileField()
def __init__(self,
app,
model,
data=None,
files=None,
auto_id='id_%s',
prefix=None,
initial=None):
super(ImportForm, self).__init__(data, files, auto_id, prefix, initial)
if self.data:
app, model = self.data['model'].split(':')
if model:
m = "%s:%s" % (app, model)
self.fields['model'].choices = [(m, m)]
self.fields['model'].widget = Input({'readonly': 'readonly'})
self.initial['model'] = m
elif app:
self.fields['model'].choices = _get_all_models(app)
else:
self.fields['model'].choices = _get_all_models()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['start_url'] = forms.CharField(label='URL', required=True)
self.fields['start_url'].widget.attrs['size'] = 80
self.fields['job'] = ChoiceField(
make_job_structure_for_dropdown(False, include_invisible=False))
self.fields['job'].widget.attrs['class'] = 'browser-default'
class DomainDeploymentForm(forms.Form):
city = CharField(label=ugettext_noop("City"), required=False)
country = CharField(label=ugettext_noop("Country"), required=False)
region = CharField(
label=ugettext_noop("Region"),
required=False,
help_text=ugettext_noop(
"e.g. US, LAC, SA, Sub-Saharan Africa, Southeast Asia, etc."))
deployment_date = CharField(label=ugettext_noop("Deployment date"),
required=False)
description = CharField(label=ugettext_noop("Description"),
required=False,
widget=forms.Textarea)
public = ChoiceField(label=ugettext_noop("Make Public?"),
choices=tf_choices('Yes', 'No'),
required=False)
def save(self, domain):
try:
domain.update_deployment(
city=self.cleaned_data['city'],
country=self.cleaned_data['country'],
region=self.cleaned_data['region'],
date=dateutil.parser.parse(
self.cleaned_data['deployment_date']),
description=self.cleaned_data['description'],
public=(self.cleaned_data['public'] == 'true'))
return True
except Exception:
return False
class Parcel(SoColissimoSchema):
soap_type_name = "ParcelVO"
DELIVERY_MODES = ('DOM', 'RDV', 'BPR', 'ACP', 'CDI', 'A2P', 'MRL', 'CIT',
'DOS', 'CMT', 'BDP')
weight = DecimalField(required=True,
min_value=0,
max_value=30,
decimal_places=2)
DeliveryMode = ChoiceField(required=False,
choices=[(d, d) for d in DELIVERY_MODES])
horsGabarit = BooleanField(required=False)
insuranceValue = IntegerField(required=False, min_value=0)
HorsGabaritAmount = IntegerField(required=False, min_value=0)
Instructions = CharField(required=False)
def clean_weight(self):
"""Ensure weight does not have a decimal part equals to 00"""
weight = self.cleaned_data.get('weight')
if weight % 1 == 0:
weight = int(weight)
return weight
def clean_DeliveryMode(self):
""" Default to "DOM" delivery mode if not specified """
delivery_mode = self.cleaned_data.get('delivery_mode')
if not delivery_mode:
delivery_mode = "DOM"
return delivery_mode
def _set_constants(self, parcel):
parcel.insuranceRange = "00"
parcel.ReturnReceipt = False
parcel.Recommendation = False
class HttpBackendForm(BackendForm):
url = TrimmedCharField(label=ugettext_noop("URL"), )
message_param = TrimmedCharField(
label=ugettext_noop("Message Parameter"), )
number_param = TrimmedCharField(
label=ugettext_noop("Phone Number Parameter"), )
include_plus = BooleanField(
required=False,
label=ugettext_noop("Include '+' in Phone Number"),
)
method = ChoiceField(
label=ugettext_noop("HTTP Request Method"),
choices=(("GET", "GET"), ("POST", "POST")),
)
additional_params = RecordListField(
input_name="additional_params",
label=ugettext_noop("Additional Parameters"),
)
def __init__(self, *args, **kwargs):
if "initial" in kwargs and "additional_params" in kwargs["initial"]:
additional_params_dict = kwargs["initial"]["additional_params"]
kwargs["initial"]["additional_params"] = [{
"name": key,
"value": value
} for key, value in additional_params_dict.items()]
super(HttpBackendForm, self).__init__(*args, **kwargs)
def clean_url(self):
value = self.cleaned_data.get("url")
if is_url_or_host_banned(value):
raise ValidationError(_("Invalid URL"))
return value
def clean_additional_params(self):
value = self.cleaned_data.get("additional_params")
result = {}
for pair in value:
name = pair["name"].strip()
value = pair["value"].strip()
if name == "" or value == "":
raise ValidationError("Please enter both name and value.")
if name in result:
raise ValidationError("Parameter name entered twice: %s" %
name)
result[name] = value
return result
@property
def gateway_specific_fields(self):
return crispy.Fieldset(
_("HTTP Settings"),
'url',
'method',
'message_param',
'number_param',
'include_plus',
'additional_params',
)
class FinalizeGatewaySetupForm(Form):
YES = 'Y'
NO = 'N'
YES_NO_CHOICES = (
(YES, ugettext_lazy("Yes")),
(NO, ugettext_lazy("No")),
)
name = TrimmedCharField(label=ugettext_lazy("Name"), required=True)
set_as_default = ChoiceField(label=ugettext_lazy("Set as default gateway"),
choices=YES_NO_CHOICES,
required=True)
def __init__(self, *args, **kwargs):
super(FinalizeGatewaySetupForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = 'form form-horizontal'
self.helper.label_class = 'col-sm-3 col-md-2'
self.helper.field_class = 'col-sm-3 col-md-2'
self.helper.layout = Layout(
Div(
hqcrispy.B3MultiField(
_("Name"),
Div(
hqcrispy.MultiInlineField(
'name',
data_bind='value: name',
)),
crispy.Div(
css_class="help-block",
data_bind="visible: nameError, text: nameError",
),
data_bind="css: {'has-error': nameError}",
),
hqcrispy.B3MultiField(
_("Set as default gateway"),
Div(
hqcrispy.MultiInlineField(
'set_as_default',
data_bind='value: setAsDefault',
style='margin-left: 0px;')),
crispy.Div(
css_class="help-block",
data_bind=
"visible: setAsDefaultError, text: setAsDefaultError",
),
data_bind="css: {'has-error': setAsDefaultError}",
),
FormActions(
StrictButton(
"",
id="id_create_backend",
css_class='btn-primary',
data_bind=
"text: backendButtonText, click: createBackend, disable: creatingBackend,"
"css: {'btn-primary': !backendButtonError(), "
"'btn-danger': backendButtonError()}",
))))
class BootstrapRowForm(ManageChildrenFormMixin, ModelForm):
"""
Form class to add non-materialized field to count the number of children.
"""
ROW_NUM_COLUMNS = (1, 2, 3, 4, 6, 12,)
num_children = ChoiceField(choices=tuple((i, ungettext_lazy('{0} column', '{0} columns', i).format(i)) for i in ROW_NUM_COLUMNS),
initial=3, label=_('Columns'),
help_text=_('Number of columns to be created with this row.'))
def __init__(self, *args, **kwargs):
super(ReminderForm, self).__init__(*args, **kwargs)
deadline_month = ChoiceField(
choices=(tuple([(n, convert_to_ordinal(n)) for n in range(1, 31)] +
[(31, ugettext_lazy('Last Day'))])),
widget=forms.Select,
required=False)
self.fields["deadline_month"] = deadline_month
class SMEContactForm(Form):
employer_job = ChoiceField([])
def __init__(self, employer, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields[
'employer_job'].choices = make_employer_job_structure_for_dropdown(
True, employer_id=employer.id)
def graph_form_factory(model):
app_name = model._meta.app_label
model_name = model.__name__
model_fields = [(f.name, f.verbose_name) for f in model._meta.fields if not f.primary_key]
graphs = [('PieChart', 'PieChart'), ('BarChart', 'BarChart')]
model_fields.insert(0, ('', 'N/A'))
class_name = "%s%sGraphForm" % (app_name, model_name)
attrs = {'initial': {'app': app_name, 'model': model_name},
'_selected_action': CharField(widget=MultipleHiddenInput),
'select_across': BooleanField(initial='0', widget=HiddenInput, required=False),
'app': CharField(initial=app_name, widget=HiddenInput),
'model': CharField(initial=model_name, widget=HiddenInput),
'graph_type': ChoiceField(label="Graph type", choices=graphs, required=True),
'axes_x': ChoiceField(label="Group by and count by", choices=model_fields, required=True)}
return DeclarativeFieldsMetaclass(str(class_name), (Form,), attrs)
class PalauteForm(ContactsForm):
msg = CharField(label='Mitä haluat sanoa?', widget=Textarea)
res = ChoiceField(choices=[(True, 'Haluan'), (False, 'En halua')],
label='Haluatko, että sinulle vastataan?',
widget=RadioSelect)
captcha = ReCaptchaField()
class RenderTemplateFormMixin(EntangledModelFormMixin):
render_template = ChoiceField(
label=_("Render template"),
help_text=_("Use alternative template for rendering this plugin."),
)
class Meta:
entangled_fields = {'glossary': ['render_template']}
def __init__(self, *args, **kwargs):
super(GenericForm, self).__init__(*args, **kwargs)
backends = get_backend_choices()
self.fields['backend'] = ChoiceField(
choices=backends,
initial=backends[0][0] if len(backends) else '',
widget=widgets.HiddenInput,
)
def __init__(self, initial=None, *args, **kwargs):
ChoiceField.__init__(self, IMPORT_FILE_TYPE_CHOICES, initial, *args, **kwargs)
def __init__(self, initial=None, *args, **kwargs):
ChoiceField.__init__(self, UnicodeEncodingField.CHOICES, initial, *args, **kwargs)
