')
t += str(
ngettext(
'The following field has an error:',
'The following fields have an error:',
len(widget_with_errors),
)
)
t += ' '
for i, widget in enumerate(widget_with_errors):
t += htmltext('%s') % (
widget.get_name_for_id(),
widget.get_name_for_id(),
widget.title,
)
if i < len(widget_with_errors) - 1:
t += htmltext('%s') % _(', ')
t += htmltext('
')
return t.getvalue()
class FormDef(StorableObject):
# noqa pylint: disable=too-many-public-methods
_names = 'formdefs'
_indexes = ['url_name']
_hashed_indexes = ['backoffice_submission_roles']
backoffice_class = 'wcs.admin.forms.FormDefPage'
data_sql_prefix = 'formdata'
pickle_module_name = 'formdef'
xml_root_node = 'formdef'
backoffice_section = 'forms'
verbose_name = _('Form')
verbose_name_plural = _('Forms')
item_name = pgettext_lazy('item', 'form')
item_name_plural = pgettext_lazy('item', 'forms')
fields_count_total_soft_limit = 200
fields_count_total_hard_limit = 400
name = None
description = None
keywords = None
url_name = None
table_name = None # for SQL only
fields = None
category_id = None
workflow_id = None
workflow_options = None
workflow_roles = None
roles = None
required_authentication_contexts = None
backoffice_submission_roles = None
discussion = False
confirmation = True
detailed_emails = True
disabled = False
only_allow_one = False
enable_tracking_codes = False
tracking_code_verify_fields = None
disabled_redirection = None
always_advertise = False
publication_date = None
expiration_date = None
has_captcha = False
skip_from_360_view = False
management_sidebar_items = {'__default__'}
submission_sidebar_items = {'__default__'}
include_download_all_button = False
appearance_keywords = None
digest_templates = None
lateral_template = None
submission_lateral_template = None
id_template = None
drafts_lifespan = None
drafts_max_per_user = None
user_support = None
submission_user_association = 'any'
documentation = None
geolocations = None
history_pane_default_mode = 'expanded'
sql_integrity_errors = None
# store reverse relations
reverse_relations = None
# store fields in a separate pickle chunk
lightweight = True
# prefixes for formdata variables
var_prefixes = ['form']
# users are allowed to access formdata where they're submitter.
user_allowed_to_access_own_data = True
submission_user_association_available_options = ['any', 'any-required', 'roles']
# declarations for serialization
TEXT_ATTRIBUTES = [
'name',
'url_name',
'description',
'keywords',
'publication_date',
'expiration_date',
'disabled_redirection',
'appearance_keywords',
'lateral_template',
'submission_lateral_template',
'id_template',
'drafts_lifespan',
'drafts_max_per_user',
'user_support',
'documentation',
'submission_user_association',
]
BOOLEAN_ATTRIBUTES = [
'discussion',
'detailed_emails',
'disabled',
'only_allow_one',
'enable_tracking_codes',
'confirmation',
'always_advertise',
'has_captcha',
'skip_from_360_view',
]
category_class = Category
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields = []
def __eq__(self, other):
return bool(
isinstance(other, FormDef) and self.xml_root_node == other.xml_root_node and self.id == other.id
)
def migrate(self):
changed = False
if self.__dict__.get('fields') is Ellipsis:
# don't run migration on lightweight objects
return
if isinstance(self.category_id, int):
self.category_id = str(self.category_id)
changed = True
if isinstance(self.workflow_id, int):
self.workflow_id = str(self.workflow_id)
changed = True
if self.roles:
for role in self.roles:
if isinstance(role, int):
self.roles = [str(x) for x in self.roles]
changed = True
break
if self.workflow_roles:
workflow_roles_list = self.workflow_roles.items()
for role_id in self.workflow_roles.values():
if isinstance(role_id, int):
self.workflow_roles = {x: str(y) for x, y in workflow_roles_list}
changed = True
break
if self.include_download_all_button: # 2023-12-30
self.management_sidebar_items = self.get_default_management_sidebar_items()
self.management_sidebar_items.add('download-files')
self.include_download_all_button = False
changed = True
for f in self.fields or []:
changed |= f.migrate()
if changed:
self.store(comment=_('Automatic update'), snapshot_store_user=False)
@classmethod
def remove_object(cls, id):
super().remove_object(id)
from . import sql
sql.SearchableFormDef.update(removed_obj_type=cls.xml_root_node, removed_obj_id=id)
if cls == FormDef:
# recreate global views so they don't reference formdata from
# deleted formefs
conn, cur = sql.get_connection_and_cursor()
with sql.atomic():
sql.clean_global_views(conn, cur)
cur.close()
def get_default_management_sidebar_items(self):
return {
'general',
'submission-context',
'user',
'geolocation',
'custom-template',
'pending-forms',
}
def get_management_sidebar_available_items(self):
return [
('general', _('General Information')),
('download-files', _('Button to download all files')),
('submission-context', _('Submission context')),
('user', _('Associated User')),
('geolocation', _('Geolocation')),
('custom-template', _('Custom template')),
('pending-forms', _('User Pending Forms')),
]
def management_sidebar_items_labels(self):
# return ordered labels
management_sidebar_items = self.get_management_sidebar_items()
for key, label in self.get_management_sidebar_available_items():
if key in management_sidebar_items:
yield label
def get_management_sidebar_items(self):
if self.management_sidebar_items == {'__default__'}:
return self.get_default_management_sidebar_items()
return self.management_sidebar_items or []
def get_default_submission_sidebar_items(self):
return {
'general',
'submission-context',
'user',
'custom-template',
}
def get_submission_sidebar_available_items(self):
return [
('general', _('General Information')),
('submission-context', _('Submission context')),
('user', _('Associated User')),
('custom-template', _('Custom template')),
]
def submission_sidebar_items_labels(self):
# return ordered labels
submission_sidebar_items = self.get_submission_sidebar_items()
for key, label in self.get_submission_sidebar_available_items():
if key in submission_sidebar_items:
yield label
def get_submission_sidebar_items(self):
if self.submission_sidebar_items == {'__default__'}:
return self.get_default_submission_sidebar_items()
return self.submission_sidebar_items or []
@property
def data_class_name(self):
return '_wcs_%s' % self.url_name.title()
def data_class(self, mode=None):
if 'formdef' not in sys.modules:
sys.modules['formdef'] = sys.modules[__name__]
if hasattr(sys.modules['formdef'], self.data_class_name):
data_class = getattr(sys.modules['formdef'], self.data_class_name)
# only use existing data class if it has a reference to this actual
# formdef
if data_class._formdef is self:
return data_class
from . import sql
table_name = sql.get_formdef_table_name(self)
cls = type(self.data_class_name, (sql.SqlFormData,), {'_formdef': self, '_table_name': table_name})
setattr(sys.modules['formdef'], self.data_class_name, cls)
setattr(sys.modules['wcs.formdef'], self.data_class_name, cls)
return cls
def get_new_field_id(self):
return str(uuid.uuid4())
def get_new_url_name(self):
new_url_name = simplify(self.name)[:250]
base_new_url_name = new_url_name
suffix_no = 0
while True:
try:
obj = self.get_on_index(new_url_name, 'url_name', ignore_migration=True)
except KeyError:
break
if obj.id == self.id:
break
suffix_no += 1
new_url_name = '%s-%s' % (base_new_url_name, suffix_no)
return new_url_name
@classmethod
def get_new_id(cls, create=False):
id = super().get_new_id(create=False)
id = cls.get_sql_new_id(id_start=int(id))
if create:
objects_dir = cls.get_objects_dir()
object_filename = os.path.join(objects_dir, fix_key(id))
try:
fd = os.open(object_filename, os.O_CREAT | os.O_EXCL)
except OSError:
return cls.get_new_id(create=True)
os.close(fd)
return str(id)
@classmethod
def get_sql_new_id(cls, id_start):
from . import sql
return sql.get_formdef_new_id(id_start=id_start)
def get_order_by(self, order_by):
if not order_by:
return order_by
direction = ''
if order_by.startswith('-'):
order_by = order_by[1:]
direction = '-'
for field in self.iter_fields(include_block_fields=True):
if getattr(field, 'block_field', None):
if field.key == 'items':
# not yet
continue
if order_by not in [field.contextual_varname, 'f%s' % field.contextual_id]:
continue
if field.contextual_varname == order_by:
order_by = 'f%s' % field.contextual_id
if getattr(field, 'block_field', None) and 'f%s' % field.contextual_id == order_by:
# field of block field, sort on the first element
order_by = "f%s->'data'->0->>'%s%s'" % (
field.block_field.id,
field.id,
'_display' if field.store_display_value else '',
)
elif field.store_display_value:
order_by += '_display'
break
if order_by == 'digest':
order_by = "digests->>'default'"
order_by = '%s%s' % (direction, order_by)
if order_by == 'criticality_level':
order_by = [order_by, 'receipt_time']
elif order_by == '-criticality_level':
order_by = [order_by, '-receipt_time']
return order_by
def has_admin_access(self, user):
# return True if user 1/ is global administrator for this type of object, or
# 2/ has one of the management roles defined in its category.
if get_publisher().get_backoffice_root().is_global_accessible(self.backoffice_section):
return True
if not user:
return False
if not self.category_id:
return False
management_roles = {x.id for x in getattr(self.category, 'management_roles') or []}
user_roles = set(user.get_roles())
return management_roles.intersection(user_roles)
@classonlymethod
def wipe(cls):
super().wipe()
cls.sql_wipe()
@classmethod
def sql_wipe(cls):
from . import sql
sql.formdef_wipe()
def store(self, comment=None, snapshot_store_user=True, application=None, *args, **kwargs):
assert not self.is_readonly()
if self.url_name is None:
# set url name if it's not yet there
self.url_name = self.get_new_url_name()
object_only = kwargs.pop('object_only', False)
if not object_only:
self.update_relations()
StorableObject.store(self, *args, **kwargs)
if object_only:
return
if get_publisher().snapshot_class:
get_publisher().snapshot_class.snap(
instance=self, comment=comment, store_user=snapshot_store_user, application=application
)
if get_publisher().has_postgresql_config():
self.update_storage()
self.store_related_custom_views()
self.update_searchable_formdefs_table()
self.update_category_reference()
if hasattr(self, 'xml_testdefs'):
self.finish_tests_xml_import()
def update_category_reference(self):
if getattr(self, '_onload_category_id', None) != self.category_id:
from . import sql
sql.update_global_view_formdef_category(self)
self._onload_category_id = self.category_id
def has_captcha_enabled(self):
return self.has_captcha and get_publisher().has_site_option('formdef-captcha-option')
def update_storage(self):
from . import sql
actions = sql.do_formdef_tables(self, rebuild_views=True, rebuild_global_views=True)
if actions:
cls = self.data_class()
for action in actions:
getattr(cls, action)()
def update_searchable_formdefs_table(self):
from . import sql
sql.SearchableFormDef.update(obj=self)
def update_relations(self):
from wcs.carddef import CardDef
self_ref = '%s:%s' % (self.xml_root_node, self.url_name)
self_relations_by_ref = self.build_relations_by_ref()
reverse_relations = []
# cross each formdef and cardef and check relations
for objdef in itertools.chain(
FormDef.select(ignore_errors=True, ignore_migration=True),
CardDef.select(ignore_errors=True, ignore_migration=True),
):
objdef_ref = '%s:%s' % (objdef.xml_root_node, objdef.url_name)
if objdef.xml_root_node == self.xml_root_node and objdef.id == self.id:
# don't build relations twice
objdef_relations_by_ref = self_relations_by_ref
else:
objdef_relations_by_ref = objdef.build_relations_by_ref()
reverse_relations += objdef_relations_by_ref.get(self_ref, [])
old_objdef_reverse_relations = copy.deepcopy(objdef.reverse_relations)
# remove relations with self in objdef's reverse_relations
new_objdef_reverse_relations = [
r for r in (objdef.reverse_relations or []) if r['obj'] != self_ref
]
# and update objdef's reverse_relations from self_relations_by_ref
new_objdef_reverse_relations += self_relations_by_ref.get(objdef_ref, [])
# sort objectdef's reverse_relations
new_objdef_reverse_relations = sorted(
new_objdef_reverse_relations, key=itemgetter('obj', 'varname', 'type')
)
if old_objdef_reverse_relations != new_objdef_reverse_relations:
objdef.reverse_relations = new_objdef_reverse_relations
objdef.store(object_only=True)
# sort self's reverse_relations and set
self.reverse_relations = sorted(reverse_relations, key=itemgetter('obj', 'varname', 'type'))
def build_relations_by_ref(self):
# build relations to other carddefs, to be stored in some object reverse field
self_ref = '%s:%s' % (self.xml_root_node, self.url_name)
relations_by_ref = collections.defaultdict(list)
def _check_field(field):
data_source = getattr(field, 'data_source', None)
if not data_source or not data_source.get('type', '').startswith('carddef:'):
return
# reverse relation of data_source['type'] to this object
obj_ref = ':'.join(data_source['type'].split(':')[:2]) # remove possible custom-view
relations_by_ref[obj_ref].append(
{
'varname': field.contextual_varname or '',
'type': field.key,
'obj': self_ref,
}
)
for field in self.iter_fields(include_block_fields=True):
if field.key in ['item', 'items', 'computed']:
_check_field(field)
# remove duplicated items
return {
k: list(map(dict, {tuple(sorted(d.items())) for d in v})) for k, v in relations_by_ref.items()
}
def store_related_custom_views(self):
for view in getattr(self, '_custom_views', []):
if not view.id:
existing_views = get_publisher().custom_view_class.select(
[
Equal('formdef_type', self.xml_root_node),
Equal('formdef_id', str(self.id)),
Equal('visibility', view.visibility),
Equal('slug', view.slug),
]
)
if existing_views:
view.id = existing_views[0].id
view.formdef = self
view.store()
def get_all_fields(self):
return (self.fields or []) + self.workflow.get_backoffice_fields()
def get_all_fields_dict(self):
return {x.id: x for x in self.get_all_fields()}
def get_total_count_data_fields(self):
count = len([x for x in self.fields or [] if not x.is_no_data_field and not x.key == 'block'])
for field in self.fields or []:
if not field.key == 'block':
continue
try:
count += len([x for x in field.block.fields or [] if not x.is_no_data_field]) * (
field.default_items_count or 1
)
except KeyError:
continue
return count
def iter_fields(self, include_block_fields=False, with_backoffice_fields=True, with_no_data_fields=True):
def _iter_fields(fields, block_field=None):
for field in fields:
if with_no_data_fields is False and field.is_no_data_field:
continue
# add contextual_id/contextual_varname attributes
# they are id/varname for normal fields
# but in case of blocks they are concatenation of block id/varname + field id/varname
field.contextual_id = field.id
field.contextual_varname = None
if block_field:
field.block_field = block_field
field.contextual_id = '%s-%s' % (field.block_field.id, field.id)
if field.varname and field.block_field.varname:
field.contextual_varname = '%s_%s' % (
field.block_field.varname,
field.varname,
)
else:
field.contextual_varname = field.varname
yield field
if field.key == 'block' and include_block_fields:
try:
field.block # load block
except KeyError:
# blockdef not found
continue
yield from _iter_fields(field.block.fields, block_field=field)
field._block = None # reset cache
if with_backoffice_fields:
fields = self.get_all_fields()
else:
fields = self.fields or []
yield from _iter_fields(fields)
def get_widget_fields(self):
return [field for field in self.fields or [] if isinstance(field, fields.WidgetField)]
@property
def default_digest_template(self):
return (self.digest_templates or {}).get('default')
def get_category(self):
if self.category_id:
try:
return self.category_class.get(self.category_id)
except KeyError:
return None
else:
return None
def set_category(self, category):
if category:
self.category_id = category.id
elif self.category_id:
self.category_id = None
category = property(get_category, set_category)
def get_drafts_lifespan(self):
return int(self.drafts_lifespan or DRAFTS_DEFAULT_LIFESPAN)
def get_drafts_max_per_user(self):
return int(self.drafts_max_per_user or DRAFTS_DEFAULT_MAX_PER_USER)
_workflow = None
def get_workflow(self):
if self._workflow and self._workflow.id == self.workflow_id:
return self._workflow
from wcs.workflows import Workflow
if self.workflow_id:
try:
self._workflow = Workflow.get(self.workflow_id)
except KeyError:
return Workflow.get_unknown_workflow()
return self._workflow
else:
self._workflow = self.get_default_workflow()
return self._workflow
@classmethod
def get_default_workflow(cls):
from wcs.workflows import Workflow
return Workflow.get_default_workflow()
def set_workflow(self, workflow):
if workflow and workflow.id not in ['_carddef_default', '_default']:
self.workflow_id = workflow.id
self._workflow = workflow
elif self.workflow_id:
self.workflow_id = None
self._workflow = None
workflow = property(get_workflow, set_workflow)
def get_dependencies(self):
yield self.category
if self.workflow_id and self.workflow.id not in ['_carddef_default', '_default']:
yield self.workflow
for field in self.fields or []:
yield from field.get_dependencies()
role_class = get_publisher().role_class
for role_id in itertools.chain(self.roles or [], self.backoffice_submission_roles or []):
yield role_class.get(role_id, ignore_errors=True)
for role_id in (self.workflow_roles or {}).values():
yield role_class.get(role_id, ignore_errors=True)
for view in get_publisher().custom_view_class.select_shared_for_formdef(formdef=self):
yield from view.get_dependencies()
for template in list((self.digest_templates or {}).values()) + [
self.lateral_template,
self.submission_lateral_template,
]:
yield from get_dependencies_from_template(template)
from .testdef import TestDef
for testdef in TestDef.select_for_objectdef(self):
yield from testdef.get_dependencies()
@property
def keywords_list(self):
if not self.keywords:
return []
return [x.strip() for x in self.keywords.split(',')]
@property
def appearance_keywords_list(self):
if not get_publisher().has_site_option('formdef-appearance-keywords'):
return []
if not self.appearance_keywords:
return []
return [x.strip() for x in self.appearance_keywords.split()]
def get_variable_options(self):
variables = {}
if not self.workflow.variables_formdef:
return variables
workflow_options = self.workflow_options or {}
for field in self.workflow.variables_formdef.fields:
if not field.varname:
continue
option_name = 'form_option_' + field.varname
variables[option_name] = getattr(field, 'default_value', None)
if workflow_options.get(field.varname) is not None:
variables[option_name] = workflow_options.get(field.varname)
if field.store_display_value:
if '%s_display' % field.varname in workflow_options:
variables[option_name + '_raw'] = variables[option_name]
variables[option_name] = workflow_options.get('%s_display' % field.varname)
if field.store_structured_value:
if '%s_structured' % field.varname in workflow_options:
variables[option_name + '_structured'] = workflow_options.get(
'%s_structured' % field.varname
)
return variables
def get_variable_options_for_form(self):
variables = {}
if not self.workflow.variables_formdef:
return variables
if not self.workflow_options:
return {}
for field in self.workflow.variables_formdef.fields:
if not field.varname:
continue
variables[str(field.id)] = self.workflow_options.get(field.varname)
return variables
def set_variable_options(self, form):
data = self.workflow.variables_formdef.get_data(form)
variables = {}
for field in self.workflow.variables_formdef.fields:
if not field.varname:
continue
variables[field.varname] = data.get(field.id)
if field.store_display_value:
variables[field.varname + '_display'] = data.get(field.id + '_display')
if field.store_structured_value:
variables[field.varname + '_structured'] = data.get(field.id + '_structured')
if not self.workflow_options:
self.workflow_options = {}
self.workflow_options.update(variables)
@classmethod
def get_by_urlname(cls, url_name, ignore_migration=False, ignore_errors=False, use_cache=False):
return cls.get_on_index(
url_name,
'url_name',
ignore_migration=ignore_migration,
ignore_errors=ignore_errors,
use_cache=use_cache,
)
get_by_slug = get_by_urlname
@property
def slug(self):
return self.url_name
@slug.setter
def slug(self, value):
self.url_name = value
def get_url(self, backoffice=False, preview=False, include_category=False, language=None):
if backoffice:
base_url = get_publisher().get_backoffice_url() + '/management'
elif preview:
base_url = get_publisher().get_frontoffice_url() + '/preview'
else:
base_url = get_publisher().get_frontoffice_url()
if language and get_publisher().has_i18n_enabled():
base_url += '/' + language
if include_category and self.category_id:
return '%s/%s/%s/' % (base_url, self.category.slug, self.url_name)
return '%s/%s/' % (base_url, self.url_name)
def get_api_url(self):
base_url = get_publisher().get_frontoffice_url()
return '%s/api/forms/%s/' % (base_url, self.url_name)
def get_admin_url(self):
base_url = get_publisher().get_backoffice_url()
return '%s/forms/%s/' % (base_url, self.id)
def get_backoffice_url(self):
return self.get_url(backoffice=True)
def get_preview_url(self):
return self.get_url(preview=True)
def get_field_admin_url(self, field):
return self.get_admin_url() + 'fields/%s/' % field.id
def get_submission_url(self, backoffice=False):
if backoffice:
return self.get_backoffice_submission_url()
return self.get_url()
def get_backoffice_submission_url(self):
base_url = get_publisher().get_backoffice_url() + '/submission'
return '%s/%s/' % (base_url, self.url_name)
def get_display_id_format(self):
return self.id_template or '{{formdef_id}}-{{form_number_raw}}'
def get_by_id_criteria(self, value):
if self.id_template:
return Equal('id_display', str(value))
try:
if int(value) >= 2**31:
# out of range for postgresql integer type; would raise DataError.
raise OverflowError
except ValueError:
# value not an integer, it could be id_display
return Equal('id_display', str(value))
return Equal('id', value)
def get_submission_lateral_block(self):
context = get_publisher().substitutions.get_context_variables(mode='lazy')
if self.submission_lateral_template is None:
new_value = None
else:
try:
new_value = Template(self.submission_lateral_template, autoescape=False, raises=True).render(
context
)
except Exception as e:
get_publisher().record_error(
_('Could not render submission lateral template (%s)' % e),
formdef=self,
exception=e,
)
return None
return new_value
def create_form(self, page=None, displayed_fields=None, transient_formdata=None):
form = FormDefForm()
if self.appearance_keywords:
form.attrs['class'] = 'quixote %s' % self.appearance_keywords
if self.keywords:
form.attrs['data-keywords'] = ' '.join(self.keywords_list)
self.add_fields_to_form(
form, page=page, displayed_fields=displayed_fields, transient_formdata=transient_formdata
)
return form
def get_computed_fields_from_page(self, page):
on_page = page is None
for field in self.fields:
if field.key == 'page':
if on_page:
break
if page.id == field.id:
on_page = True
continue
if not on_page:
continue
if field.key == 'computed':
yield field
def add_fields_to_form(
self,
form,
page=None,
displayed_fields=None,
form_data=None, # a dictionary, to fill fields
transient_formdata=None,
): # a FormData
on_page = page is None
hidden_varnames = set()
for field in self.fields:
field.formdef = self
if field.key == 'page':
if on_page:
break
if page.id == field.id:
on_page = True
continue
if not on_page:
continue
visible = field.is_visible(form_data, self)
if not visible:
if not field.has_live_conditions(self, hidden_varnames=hidden_varnames):
# ignore field.varname when checking later conditions for liveness
if field.varname:
hidden_varnames.add(field.varname)
# no live conditions so field can be skipped
continue
if isinstance(displayed_fields, list):
displayed_fields.append(field)
value = None
if form_data:
value = form_data.get(field.id)
if not field.add_to_form:
continue
widget = field.add_to_form(form, value)
widget.is_hidden = not (visible)
widget.field = field
if transient_formdata and not widget.is_hidden:
transient_formdata.data.update(self.get_field_data(field, widget))
# invalidate cache as comment fields (and other things?) may
# have accessed variables in non-lazy mode and caused a cache
# with now-obsolete values.
get_publisher().substitutions.invalidate_cache()
widget._parsed = False
widget.error = None
def get_page(self, page_no):
return [x for x in self.fields if x.key == 'page'][page_no]
def page_count(self):
return len([x for x in self.fields if x.key == 'page']) or 1
def create_view_form(self, dict=None, use_tokens=True, visible=True):
dict = dict or {}
form = Form(enctype='multipart/form-data', use_tokens=use_tokens)
if not visible:
form.attrs['style'] = 'display: none;'
if self.keywords:
form.attrs['data-keywords'] = ' '.join(self.keywords_list)
form_fields = self.fields
if form_fields and form_fields[0].key != 'page':
# add fake initial page in case it's missing
form_fields = [fields.PageField(label='', type='page')] + form_fields
# 1st pass to group fields on different pages
pages = []
current_page = {}
for field in form_fields:
if field.key == 'page':
current_page = {'page': field, 'fields': []}
current_page['disabled'] = not field.is_visible(dict, self)
pages.append(current_page)
continue
if current_page['disabled']:
continue
if field.key == 'title' and (
not current_page['fields'] and current_page['page'].label == field.label
):
# don't include first title of a page if that title has the
# same text as the page.
continue
if field.key in ('title', 'subtitle', 'comment') and not field.include_in_validation_page:
# don't render field that wouldn't be displayed.
continue
if not field.is_visible(dict, self):
continue
current_page['fields'].append(field)
# 2nd pass to create view form
for page in pages:
visible_contents = False
if page['fields'] and any(x.include_in_validation_page for x in page['fields']):
visible_contents = True
form.widgets.append(HtmlWidget(htmltext('')))
if page['page'].label:
form.widgets.append(HtmlWidget(htmltext('
%s
') % page['page'].label))
form.widgets.append(HtmlWidget(htmltext('
')))
for field in page['fields']:
value = dict.get(field.id)
if not field.add_to_view_form:
continue
if not field.include_in_validation_page:
form.widgets.append(HtmlWidget(htmltext('
')))
field.add_to_view_form(form, value)
form.widgets.append(HtmlWidget(htmltext('
')))
else:
field.add_to_view_form(form, value)
if visible_contents:
form.widgets.append(HtmlWidget(htmltext('