def get_block(eq_id, form_type, collection_id, group_id, group_instance, block_id): # pylint: disable=unused-argument
# Filter answers down to those we may need to render
answer_store = get_answer_store(current_user)
path_finder = PathFinder(g.schema_json, answer_store, get_metadata(current_user))
current_location = Location(group_id, group_instance, block_id)
valid_group = group_id in SchemaHelper.get_group_ids(g.schema_json)
if not valid_group or current_location not in path_finder.get_routing_path(group_id, group_instance):
raise NotFound
block = _render_schema(current_location)
error_messages = SchemaHelper.get_messages(g.schema_json)
form, template_params = get_form_for_location(block, current_location, answer_store, error_messages)
content = {'form': form, 'block': block}
if template_params:
content.update(template_params)
template = block['type'] if block and 'type' in block and block['type'] else 'questionnaire'
return _build_template(current_location, content, template)
def test_get_form_and_disable_mandatory_answers(self):
with self.app_request_context():
schema = load_schema_from_name("test_date_range")
block_json = schema.get_block("date-block")
location = Location(section_id="default-section",
block_id="date-block")
form = get_form_for_location(
schema,
block_json,
location,
AnswerStore(),
metadata=None,
disable_mandatory=True,
)
period_from_field = getattr(form, "date-range-from-answer", None)
period_to_field = getattr(form, "date-range-to-answer", None)
assert period_from_field
assert period_to_field
self.assertIsInstance(period_from_field.year.validators[0],
OptionalForm)
self.assertIsInstance(period_to_field.year.validators[0],
OptionalForm)
def test_get_form_deserialises_month_year_dates(self):
survey = load_schema_file("test_dates.json")
block_json = SchemaHelper.get_block(survey, "date-block")
location = SchemaHelper.get_first_location(survey)
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(
block_json, location,
AnswerStore([{
'answer_id': 'month-year-answer',
'group_id': 'a23d36db-6b07-4ce0-94b2-a843369511e3',
'group_instance': 0,
'block_id': 'date-block',
'value': '05/2015',
'answer_instance': 0,
}]), error_messages)
self.assertTrue(hasattr(form, "month-year-answer"))
month_year_field = getattr(form, "month-year-answer")
self.assertEquals(month_year_field.data, {
'month': '5',
'year': '2015',
})
def test_get_form_and_disable_mandatory_answers(self):
with self.app_request_context():
schema = load_schema_from_params('test', '0102')
block_json = schema.get_block('reporting-period')
location = Location(group_id='rsi',
group_instance=0,
block_id='introduction')
form = get_form_for_location(schema,
block_json,
location,
AnswerStore(),
metadata=None,
disable_mandatory=True)
self.assertTrue(hasattr(form, 'period-from'))
self.assertTrue(hasattr(form, 'period-to'))
period_from_field = getattr(form, 'period-from')
period_to_field = getattr(form, 'period-to')
self.assertIsInstance(period_from_field.month.validators[0],
OptionalForm)
self.assertIsInstance(period_to_field.month.validators[0],
OptionalForm)
def test_get_form_for_household_relationship(self):
with self.test_request_context():
survey = load_schema_file("census_household.json")
block_json = SchemaHelper.get_block(survey,
'household-relationships')
location = Location('who-lives-here-relationship', 0,
'household-relationships')
error_messages = SchemaHelper.get_messages(survey)
answer_store = AnswerStore([{
'group_id': 'who-lives-here-relationship',
'group_instance': 0,
'answer_id': 'first-name',
'block_id': 'household-composition',
'value': 'Joe',
'answer_instance': 0,
}, {
'group_id': 'who-lives-here-relationship',
'group_instance': 0,
'answer_id': 'last-name',
'block_id': 'household-composition',
'value': 'Bloggs',
'answer_instance': 0,
}, {
'group_id': 'who-lives-here-relationship',
'group_instance': 1,
'answer_id': 'first-name',
'block_id': 'household-composition',
'value': 'Jane',
'answer_instance': 1,
}, {
'group_id': 'who-lives-here-relationship',
'group_instance': 1,
'answer_id': 'last-name',
'block_id': 'household-composition',
'value': 'Bloggs',
'answer_instance': 1,
}])
form, _ = get_form_for_location(block_json, location, answer_store,
error_messages)
answer = SchemaHelper.get_first_answer_for_block(block_json)
self.assertTrue(hasattr(form, answer['id']))
field_list = getattr(form, answer['id'])
# With two people, we need to define 1 relationship
self.assertEqual(len(field_list.entries), 1)
def test_get_form_for_household_relationship(self):
with self.app_request_context():
schema = load_schema_from_params('census', 'household')
block_json = schema.get_block('household-relationships')
location = Location('who-lives-here-relationship', 0,
'household-relationships')
error_messages = schema.error_messages
answer_store = AnswerStore([{
'group_id': 'who-lives-here-relationship',
'group_instance': 0,
'answer_id': 'first-name',
'block_id': 'household-composition',
'value': 'Joe',
'answer_instance': 0,
}, {
'group_id': 'who-lives-here-relationship',
'group_instance': 0,
'answer_id': 'last-name',
'block_id': 'household-composition',
'value': 'Bloggs',
'answer_instance': 0,
}, {
'group_id': 'who-lives-here-relationship',
'group_instance': 1,
'answer_id': 'first-name',
'block_id': 'household-composition',
'value': 'Jane',
'answer_instance': 1,
}, {
'group_id': 'who-lives-here-relationship',
'group_instance': 1,
'answer_id': 'last-name',
'block_id': 'household-composition',
'value': 'Bloggs',
'answer_instance': 1,
}])
form = get_form_for_location(schema, block_json, location,
answer_store, error_messages)
answer = schema.get_answers_for_block('household-relationships')[0]
self.assertTrue(hasattr(form, answer['id']))
field_list = getattr(form, answer['id'])
# With two people, we need to define 1 relationship
self.assertEqual(len(field_list.entries), 1)
def validate_all_answers(answer_store, metadata):
path_finder = PathFinder(g.schema_json, answer_store, metadata)
error_messages = SchemaHelper.get_messages(g.schema_json)
for location in path_finder.get_location_path():
if not location.is_interstitial():
block_json = _render_schema(location)
form, _ = get_form_for_location(block_json, location, answer_store, error_messages)
if not form.validate():
logger.debug("Failed validation", location=str(location))
return False, location
return True, None
def _generate_wtf_form(block_schema, schema, current_location):
answer_store = get_answer_store(current_user)
metadata = get_metadata(current_user)
if request.method == "POST":
disable_mandatory = "action[save_sign_out]" in request.form
return post_form_for_block(
schema,
block_schema,
answer_store,
metadata,
request.form,
current_location,
disable_mandatory,
)
return get_form_for_location(schema, block_schema, current_location,
answer_store, metadata)
def build_view_context(block_type, metadata, schema, answer_store,
schema_context, rendered_block, current_location, form):
variables = None
if schema.json.get('variables'):
variables = renderer.render(schema.json.get('variables'),
**schema_context)
if block_type == 'Summary':
form = form or FlaskForm()
return build_view_context_for_final_summary(metadata, schema,
answer_store,
schema_context, block_type,
variables, form.csrf_token,
rendered_block)
if block_type == 'SectionSummary':
form = form or FlaskForm()
return build_view_context_for_section_summary(
metadata, schema, answer_store, schema_context, block_type,
variables, form.csrf_token, current_location.group_id)
if block_type == 'CalculatedSummary':
form = form or FlaskForm()
return build_view_context_for_calculated_summary(
metadata, schema, answer_store, schema_context, block_type,
variables, form.csrf_token, current_location)
if block_type == 'AnswerSummary':
form = form or FlaskForm()
return build_view_context_for_answer_summary(metadata, schema,
answer_store, block_type,
variables,
form.csrf_token,
current_location)
if block_type in ('Question', 'ConfirmationQuestion'):
form = form or get_form_for_location(
schema, rendered_block, current_location, answer_store, metadata)
return build_view_context_for_question(metadata, schema, answer_store,
current_location, variables,
rendered_block, form)
if block_type in ('Introduction', 'Interstitial', 'Confirmation'):
form = form or FlaskForm()
return build_view_context_for_non_question(variables, form.csrf_token,
rendered_block)
def test_get_form_for_household_composition(self):
with self.app_request_context():
schema = load_schema_from_params('test', 'household_question')
block_json = schema.get_block('household-composition')
location = Location('who-lives-here', 0, 'household-composition')
error_messages = schema.error_messages
form = get_form_for_location(schema, block_json, location, AnswerStore(), error_messages)
self.assertTrue(hasattr(form, 'household'))
self.assertEqual(len(form.household.entries), 1)
first_field_entry = form.household[0]
self.assertTrue(hasattr(first_field_entry, 'first-name'))
self.assertTrue(hasattr(first_field_entry, 'middle-names'))
self.assertTrue(hasattr(first_field_entry, 'last-name'))
def test_get_form_for_household_composition(self):
survey = load_schema_file("census_household.json")
block_json = SchemaHelper.get_block(survey, 'household-composition')
location = Location('who-lives-here', 0, 'household-composition')
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(block_json, location, AnswerStore(),
error_messages)
self.assertTrue(hasattr(form, "household"))
self.assertEquals(len(form.household.entries), 1)
first_field_entry = form.household[0]
self.assertTrue(hasattr(first_field_entry, "first-name"))
self.assertTrue(hasattr(first_field_entry, "middle-names"))
self.assertTrue(hasattr(first_field_entry, "last-name"))
def test_get_form_deserialises_dates(self):
with self.test_request_context():
survey = load_schema_file("1_0102.json")
block_json = SchemaHelper.get_block(survey, "reporting-period")
location = Location('rsi', 0, 'reporting-period')
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(
block_json, location,
AnswerStore([{
'answer_id': 'period-from',
'group_id': 'rsi',
'group_instance': 0,
'block_id': 'reporting-period',
'value': '01/05/2015',
'answer_instance': 0,
}, {
'answer_id': 'period-to',
'group_id': 'rsi',
'group_instance': 0,
'block_id': 'reporting-period',
'value': '01/09/2017',
'answer_instance': 0,
}]), error_messages)
self.assertTrue(hasattr(form, "period-to"))
self.assertTrue(hasattr(form, "period-from"))
period_to_field = getattr(form, "period-to")
period_from_field = getattr(form, "period-from")
self.assertEqual(period_from_field.data, {
'day': '01',
'month': '5',
'year': '2015',
})
self.assertEqual(period_to_field.data, {
'day': '01',
'month': '9',
'year': '2017',
})
def test_get_form_for_block_location(self):
survey = load_schema_file("1_0102.json")
block_json = SchemaHelper.get_block(survey, "reporting-period")
location = SchemaHelper.get_first_location(survey)
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(block_json, location, AnswerStore(),
error_messages)
self.assertTrue(hasattr(form, "period-to"))
self.assertTrue(hasattr(form, "period-from"))
period_from_field = getattr(form, "period-from")
period_to_field = getattr(form, "period-to")
self.assertIsInstance(period_from_field.day.validators[0],
DateRequired)
self.assertIsInstance(period_to_field.day.validators[0], DateRequired)
def _get_context(block, current_location, answer_store):
error_messages = SchemaHelper.get_messages(g.schema_json)
form, template_params = get_form_for_location(block, current_location,
answer_store, error_messages)
content = {'form': form, 'block': block}
if template_params:
content.update(template_params)
if block['type'] == 'Summary':
metadata = get_metadata(current_user)
aliases = SchemaHelper.get_aliases(g.schema_json)
schema_context = build_schema_context(metadata, aliases, answer_store)
rendered_schema_json = renderer.render(g.schema_json, **schema_context)
content.update({
'summary':
build_summary_rendering_context(rendered_schema_json, answer_store,
metadata)
})
return content
def test_get_form_deserialises_lists(self):
survey = load_schema_file("test_checkbox.json")
block_json = SchemaHelper.get_block(survey, "block-1")
location = SchemaHelper.get_first_location(survey)
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(
block_json, location,
AnswerStore([{
'answer_id': 'ca3ce3a3-ae44-4e30-8f85-5b6a7a2fb23c',
'group_id': '14ba4707-321d-441d-8d21-b8367366e761',
'group_instance': 0,
'block_id': 'block-1',
'value': ['Cheese', 'Ham'],
'answer_instance': 0,
}]), error_messages)
self.assertTrue(hasattr(form, "ca3ce3a3-ae44-4e30-8f85-5b6a7a2fb23c"))
checkbox_field = getattr(form, "ca3ce3a3-ae44-4e30-8f85-5b6a7a2fb23c")
self.assertEquals(checkbox_field.data, ['Cheese', 'Ham'])
def test_get_form_for_block_location(self):
with self.app_request_context():
schema = load_schema_from_name("test_date_range")
block_json = schema.get_block("date-block")
location = Location(section_id="default-section",
block_id="date-block")
form = get_form_for_location(schema,
block_json,
location,
AnswerStore(),
metadata=None)
self.assertTrue(hasattr(form, "date-range-from-answer"))
self.assertTrue(hasattr(form, "date-range-to-answer"))
period_from_field = getattr(form, "date-range-from-answer")
period_to_field = getattr(form, "date-range-to-answer")
self.assertIsInstance(period_from_field.year.validators[0],
DateRequired)
self.assertIsInstance(period_to_field.year.validators[0],
DateRequired)
def test_get_form_deserialises_lists(self):
with self.test_request_context():
survey = load_schema_file("test_checkbox.json")
block_json = SchemaHelper.get_block(survey, "mandatory-checkbox")
location = SchemaHelper.get_first_location(survey)
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(
block_json, location,
AnswerStore([{
'answer_id': 'mandatory-checkbox-answer',
'group_id': 'checkboxes',
'group_instance': 0,
'block_id': 'mandatory-checkbox',
'value': ['Cheese', 'Ham'],
'answer_instance': 0,
}]), error_messages)
self.assertTrue(hasattr(form, "mandatory-checkbox-answer"))
checkbox_field = getattr(form, "mandatory-checkbox-answer")
self.assertEqual(checkbox_field.data, ['Cheese', 'Ham'])
def test_get_form_and_disable_mandatory_answers(self):
with self.test_request_context():
survey = load_schema_file("1_0102.json")
block_json = SchemaHelper.get_block(survey, "reporting-period")
location = SchemaHelper.get_first_location(survey)
error_messages = SchemaHelper.get_messages(survey)
form, _ = get_form_for_location(block_json,
location,
AnswerStore(),
error_messages,
disable_mandatory=True)
self.assertTrue(hasattr(form, "period-from"))
self.assertTrue(hasattr(form, "period-to"))
period_from_field = getattr(form, "period-from")
period_to_field = getattr(form, "period-to")
self.assertIsInstance(period_from_field.month.validators[0],
OptionalForm)
self.assertIsInstance(period_to_field.month.validators[0],
OptionalForm)
def test_get_form_for_household_relationship_driven_by_multiple_answers(
self):
with self.app_request_context():
schema = load_schema_from_params(
'test', 'routing_on_answer_from_driving_repeating_group')
block_json = schema.get_block('relationships')
location = Location('household-relationships', 0, 'relationships')
error_messages = schema.error_messages
primary_group_instance_id = str(uuid.uuid4())
repeating_group_1_instance_id = str(uuid.uuid4())
repeating_group_2_instance_id = str(uuid.uuid4())
answer_store = AnswerStore({})
answer_store.add(
Answer(answer_id='primary-name',
value='Jon',
group_instance=0,
group_instance_id=primary_group_instance_id))
answer_store.add(
Answer(answer_id='primary-live-here',
value='No',
group_instance=0,
group_instance_id=primary_group_instance_id))
answer_store.add(
Answer(
answer_id='repeating-anyone-else',
answer_instance=0,
value='Yes',
group_instance=0,
))
answer_store.add(
Answer(answer_id='repeating-name',
answer_instance=0,
value='Adam',
group_instance=0,
group_instance_id=repeating_group_1_instance_id))
answer_store.add(
Answer(
answer_id='repeating-anyone-else',
answer_instance=0,
value='Yes',
group_instance=1,
))
answer_store.add(
Answer(answer_id='repeating-name',
answer_instance=0,
value='Ben',
group_instance=1,
group_instance_id=repeating_group_2_instance_id))
answer_store.add(
Answer(
answer_id='repeating-anyone-else',
answer_instance=0,
value='No',
group_instance=2,
))
form = get_form_for_location(schema, block_json, location,
answer_store, error_messages)
answer = schema.get_answers_for_block('relationships')[0]
self.assertTrue(hasattr(form, answer['id']))
field_list = getattr(form, answer['id'])
# With three people, we need to define 2 relationships
self.assertEqual(len(field_list.entries), 2)
