def rendered_subwidget(self):
if utils.has_template_based_form_rendering():
renderer = get_default_renderer()
widget = self.bound_formfield.field.widget
attrs = self.field_attributes_dict
attrs['id'] = self.dom_id
option = widget.create_option(
name=self.django_subwidget['name'],
value=self.django_subwidget.get('value', None),
label=self.django_subwidget.get('label'),
selected=self.django_subwidget['selected'],
index=self.index_in_parent,
subindex=None,
attrs=self.field_attributes_dict)
return mark_safe(
renderer.render(
template_name=self.django_subwidget['template_name'],
context={'widget': option}))
# return render_to_string(
# template_name=self.django_subwidget['template_name'],
# context=self.django_subwidget
# )
else:
return self.django_subwidget.tag(attrs=self.field_attributes_dict)
def buttons(self):
renderer = self.renderer or get_default_renderer()
order = self.get_button_order()
buttons = sorted(self._buttons.items(), key=lambda t: order.index(t[0]) if t[0] in order else -1)
context = {'buttons': buttons, 'form': self}
return mark_safe(renderer.render(self.button_template, context))
def render(self, name, value, attrs=None, renderer=None):
if renderer is None:
renderer = get_default_renderer()
if value is None:
value = ""
final_attrs = self.build_attrs(self.attrs, attrs, name=name)
self._set_config()
external_plugin_resources = [[
force_str(a), force_str(b),
force_str(c)
] for a, b, c in self.external_plugin_resources]
return mark_safe(
renderer.render(
"ckeditor/widget.html",
{
"final_attrs":
flatatt(final_attrs),
"value":
conditional_escape(force_str(value)),
"id":
final_attrs["id"],
"config":
json_encode(self.config),
"external_plugin_resources":
json_encode(external_plugin_resources),
},
))
def render(self,
name,
value,
add_to_class=None,
attrs=None,
renderer=None):
if renderer is None:
renderer = get_default_renderer()
icons = IconFieldWidget.icons
# add "no-icon" if not required
if not attrs.get('required'):
if not any(f['font_class_name'] == 'cmsplus-icon-none'
for f in icons):
icons.insert(
0, {
'name': _('No icon'),
'label': _('No icon'),
'font_class_name': 'cmsplus-icon-none'
})
context = self.get_context(name, value, attrs)
context['widget']['icons'] = IconFieldWidget.icons
context['widget']['value'] = value
context['widget']['name'] = name
context['widget']['attrs'] = attrs
context['widget']['add_to_class'] = add_to_class
return mark_safe(renderer.render(self.template_name, context))
def render_feedback(self):
"""Render the invalid-feedback messages.
This tries to get all possible error messages from the model field and form field. The messages are
used to by CSS to display the correct error message upon submission and by JS during form validation.
"""
renderer = self.form.renderer or get_default_renderer()
msg_context = {
'field_label': self.label,
'value': self.value(),
}
if hasattr(self.field, 'max_length'):
msg_context['limit_value'] = self.field.max_length
if hasattr(self.field, 'min_length'):
msg_context['limit_value'] = self.field.min_length
if hasattr(self.field, 'get_message_context'):
msg_context.update(
self.field.get_message_context(msg_context['value']))
invalid = {}
# get model field validation messages first
if getattr(self.form, 'instance', None):
try:
field = self.form.instance._meta.get_field(self.name)
# update context for error message formatting
msg_context[
'model_name'] = self.form.instance._meta.verbose_name
# extra field validators
invalid.update({v.code: v.message for v in field.validators})
invalid.update(field.error_messages)
except FieldDoesNotExist:
pass
invalid.update({v.code: v.message for v in self.field.validators})
# Update this with any error messages raised by the field itself.
invalid.update({
k if k else 'default': v
for k, v in self.field.error_messages.items()
})
invalid = {
k: v % msg_context
for k, v in invalid.items() if k in self.field.html_errors
}
invalid.update({e.code: ' '.join(e) for e in self.errors.as_data()})
context = {
'field': self,
'valid': self.field.get_valid_feedback(),
'invalid': invalid,
}
return mark_safe(renderer.render(self.field.feedback_template,
context))
def test_admin_witget_render(self):
witget = AdminMapWidget()
done_html = '''
{"latitude": 51.562519, "longitude": -1.603156, "zoom": 5}
'''
out_html = witget.render('name', LatLong(22.123456, 33.654321), renderer=get_default_renderer())
self.assertTrue(out_html, done_html)
def __init__(self, initlist=None, error_class=None, renderer=None):
super().__init__(initlist)
if error_class is None:
self.error_class = "errorlist"
else:
self.error_class = "errorlist {}".format(error_class)
self.renderer = renderer or get_default_renderer()
def render(self, name, value, attrs=None, renderer=None):
"""Render the widget as an HTML string."""
context = self.get_context(name, value, attrs)
for opt in context["widget"]["optgroups"]:
opt[1][0]['obj'] = self.choices.queryset.get(name=opt[1][0]['label'])
if renderer is None:
renderer = get_default_renderer()
return mark_safe(renderer.render(self.template_name, context))
def buttons(self):
renderer = self.renderer or get_default_renderer()
order = self.get_button_order()
buttons = sorted(self._buttons.items(),
key=lambda t: order.index(t[0])
if t[0] in order else -1)
context = {'buttons': buttons, 'form': self}
return mark_safe(renderer.render(self.button_template, context))
def render(self, name, value, attrs=None, renderer=None):
if value is None:
translated_value = None
else:
translated_value = self.converter.from_database_format(value)
if renderer is None:
renderer = get_default_renderer()
return super(TinyMCERichTextArea, self).render(name, translated_value,
attrs, renderer)
def render(self, name, value, attrs=None, renderer=None):
context = super(CKEditor5Widget, self).get_context(name, value, attrs)
if renderer is None:
renderer = get_default_renderer()
context['config'] = self.config
context['script_id'] = "{}{}".format(attrs['id'], '_script')
if self._config_errors:
context['errors'] = ErrorList(self._config_errors)
return mark_safe(renderer.render(self.template_name, context))
def render_django111(**kwargs):
"""
Renders the widget using the django >= 1.11 way
:param kwargs: key word arguments with the test data
:return: rendered widget
"""
widget = kwargs.pop("widget")
renderer = get_default_renderer()
context = widget.get_context(kwargs['name'], kwargs['value'],
kwargs['attrs'])
return mark_safe(
renderer.render('django/forms/widgets/input.html', context))
def render_feedback(self):
"""Render the invalid-feedback messages.
This tries to get all possible error messages from the model field and form field. The messages are
used to by CSS to display the correct error message upon submission and by JS during form validation.
"""
renderer = self.form.renderer or get_default_renderer()
msg_context = {
'field_label': self.label,
'value': self.value(),
}
if hasattr(self.field, 'max_length'):
msg_context['limit_value'] = self.field.max_length
if hasattr(self.field, 'min_length'):
msg_context['limit_value'] = self.field.min_length
if hasattr(self.field, 'get_message_context'):
msg_context.update(self.field.get_message_context(msg_context['value']))
invalid = {}
# get model field validation messages first
if getattr(self.form, 'instance', None):
try:
field = self.form.instance._meta.get_field(self.name)
# update context for error message formatting
msg_context['model_name'] = self.form.instance._meta.verbose_name
# extra field validators
invalid.update({v.code: v.message for v in field.validators})
invalid.update(field.error_messages)
except FieldDoesNotExist:
pass
invalid.update({v.code: v.message for v in self.field.validators})
# Update this with any error messages raised by the field itself.
invalid.update({k if k else 'default': v for k, v in self.field.error_messages.items()})
invalid = {k: v % msg_context for k, v in invalid.items() if k in self.field.html_errors}
invalid.update({e.code: ' '.join(e) for e in self.errors.as_data()})
context = {
'field': self,
'valid': self.field.get_valid_feedback(),
'invalid': invalid,
}
return mark_safe(renderer.render(self.field.feedback_template, context))
def render(self, name, value, attrs=None, choices=(), renderer=None):
if not hasattr(self, 'data'):
self.data = {}
# Test if is a valid int
try:
value = int(value)
except (ValueError, TypeError):
value = None
if renderer is None:
renderer = get_default_renderer()
return mark_safe(
renderer.render(self.template_name,
self.get_context(name, value, attrs)))
def formset_factory(
form,
prefix=None,
formset=forms.BaseFormSet,
extra=1,
can_order=False,
can_delete=False,
max_num=None,
validate_max=False,
min_num=None,
validate_min=False,
absolute_max=None,
can_delete_extra=True,
renderer=None,
):
"""
Return a FormSet for the given form class. # /PS-IGNORE.
This function is basically the same as the one in django but adds 'prefix'
to the formset's attrs.
"""
if min_num is None:
min_num = formsets.DEFAULT_MIN_NUM
if max_num is None:
max_num = formsets.DEFAULT_MAX_NUM
# absolute_max is a hard limit on forms instantiated, to prevent
# memory-exhaustion attacks. Default to max_num + DEFAULT_MAX_NUM
# (which is 2 * DEFAULT_MAX_NUM if max_num is None in the first place).
if absolute_max is None:
absolute_max = max_num + formsets.DEFAULT_MAX_NUM
if max_num > absolute_max:
raise ValueError(
"'absolute_max' must be greater or equal to 'max_num'.")
attrs = {
"form": form,
"prefix": prefix,
"extra": extra,
"can_order": can_order, # /PS-IGNORE
"can_delete": can_delete,
"can_delete_extra": can_delete_extra,
"min_num": min_num,
"max_num": max_num,
"absolute_max": absolute_max,
"validate_min": validate_min,
"validate_max": validate_max,
"renderer": renderer or get_default_renderer(),
}
return type(form.__name__ + "FormSet", (formset, ), attrs)
def render(self, name, value, attrs=None, renderer=None):
if value is None:
value = ''
if renderer is None:
renderer = get_default_renderer()
return mark_safe(
renderer.render(
"django-editorjs-fields/widget.html", {
'widget': {
'name': name,
'value': conditional_escape(force_str(value)),
'attrs': self.build_attrs(self.attrs, attrs),
'config': json_encode(self.configuration()),
}
}))
def render(self, name, value, attrs=None, renderer=None):
if renderer is None:
renderer = get_default_renderer()
if value is None:
value = ''
attrs = attrs or {}
attrs['name'] = name
if hasattr(value, 'quill'):
attrs['quill'] = value.quill
else:
attrs['value'] = value
final_attrs = self.build_attrs(self.attrs, attrs)
return mark_safe(renderer.render('django_quill/widget.html', {
'final_attrs': flatatt(final_attrs),
'id': final_attrs['id'],
'name': final_attrs['name'],
'config': json_encode(self.config),
'quill': final_attrs.get('quill', None),
'value': final_attrs.get('value', None),
}))
def formset_factory(form,
formset=BaseFormSet,
extra=1,
can_order=False,
can_delete=False,
max_num=None,
validate_max=False,
min_num=None,
validate_min=False,
absolute_max=None,
can_delete_extra=True,
renderer=None):
"""Return a FormSet for the given form class."""
if min_num is None:
min_num = DEFAULT_MIN_NUM
if max_num is None:
max_num = DEFAULT_MAX_NUM
# absolute_max is a hard limit on forms instantiated, to prevent
# memory-exhaustion attacks. Default to max_num + DEFAULT_MAX_NUM
# (which is 2 * DEFAULT_MAX_NUM if max_num is None in the first place).
if absolute_max is None:
absolute_max = max_num + DEFAULT_MAX_NUM
if max_num > absolute_max:
raise ValueError(
"'absolute_max' must be greater or equal to 'max_num'.")
attrs = {
'form': form,
'extra': extra,
'can_order': can_order,
'can_delete': can_delete,
'can_delete_extra': can_delete_extra,
'min_num': min_num,
'max_num': max_num,
'absolute_max': absolute_max,
'validate_min': validate_min,
'validate_max': validate_max,
'renderer': renderer or get_default_renderer(),
}
return type(form.__name__ + 'FormSet', (formset, ), attrs)
def rendered_subwidget(self):
if utils.has_template_based_form_rendering():
renderer = get_default_renderer()
widget = self.bound_formfield.field.widget
attrs = self.field_attributes_dict
attrs['id'] = self.dom_id
option = widget.create_option(
name=self.django_subwidget['name'],
value=self.django_subwidget.get('value', None),
label=self.django_subwidget.get('label'),
selected=self.django_subwidget['selected'],
index=self.index_in_parent,
subindex=None,
attrs=self.field_attributes_dict)
if isinstance(option, dict) and option.get('type') in ('checkbox',
'radio'):
option['wrap_label'] = False
return mark_safe(
renderer.render(
template_name=self.django_subwidget['template_name'],
context={'widget': option}))
else:
return self.django_subwidget.tag(attrs=self.field_attributes_dict)
def __init__(self, *args, renderer=None, **kwargs):
super().__init__(*args, **kwargs)
self.renderer = renderer or get_default_renderer()
def media(self):
context = {"chart": self}
renderer = get_default_renderer()
return mark_safe(renderer.render(self.media_template, context))
def _render(template_name, context):
renderer = get_default_renderer()
return mark_safe(renderer.render(template_name, context))
def render(self, **kwargs):
if self.template_name is None:
raise TemplateDoesNotExist("No template_name set")
renderer = get_default_renderer()
context = self.get_context(**kwargs)
return renderer.render(self.template_name, context)
def formgroup(self):
renderer = self.form.renderer or get_default_renderer()
context = {'field': self}
return mark_safe(
renderer.render(self.field.formgroup_template, context))
def _render(template_name, context, renderer=None):
if renderer is None:
renderer = get_default_renderer()
return mark_safe(renderer.render(template_name, context))
def formgroup(self):
renderer = self.form.renderer or get_default_renderer()
context = {'field': self}
return mark_safe(renderer.render(self.field.formgroup_template, context))
def reveal(self, renderer=None):
template_name = "widgets/top_bar_reveal.html"
if renderer is None:
renderer = get_default_renderer()
return mark_safe(renderer.render(template_name, self.get_context()))
def __init__(self, data=None, renderer=None):
super().__init__(data)
self.renderer = renderer or get_default_renderer()
