def get_view_submission(schema):
session_data = get_session_store().session_data
if _is_submission_viewable(schema.json, session_data.submitted_time):
submitted_data = current_app.eq["storage"].get_by_key(
SubmittedResponse, session_data.tx_id
)
if submitted_data:
metadata_context = build_metadata_context_for_survey_completed(session_data)
pepper = current_app.eq["secret_store"].get_secret_by_name(
"EQ_SERVER_SIDE_STORAGE_ENCRYPTION_USER_PEPPER"
)
encrypter = StorageEncryption(
current_user.user_id, current_user.user_ik, pepper
)
submitted_data = encrypter.decrypt_data(submitted_data.data)
# for backwards compatibility
# submitted data used to be base64 encoded before encryption
try:
submitted_data = base64url_decode(submitted_data.decode()).decode()
except ValueError:
pass
submitted_data = json.loads(submitted_data)
answer_store = AnswerStore(submitted_data.get("answers"))
list_store = ListStore(submitted_data.get("lists"))
progress_store = ProgressStore(submitted_data.get("progress"))
metadata = submitted_data.get("metadata")
language_code = get_session_store().session_data.language_code
questionnaire_summary_context = QuestionnaireSummaryContext(
language_code,
schema,
answer_store,
list_store,
progress_store,
metadata,
)
context = questionnaire_summary_context(answers_are_editable=False)
return render_template(
template="view-submission",
metadata=metadata_context,
content=context,
survey_id=schema.json["survey_id"],
)
return redirect(url_for("post_submission.get_thank_you"))
def before_post_submission_request():
if request.method == "OPTIONS":
return None
metadata = get_metadata(current_user)
if not metadata:
raise NoQuestionnaireStateException(401)
questionnaire_store = get_questionnaire_store(
current_user.user_id, current_user.user_ik
)
if not questionnaire_store.submitted_at:
raise NotFound
handle_language()
session_store = get_session_store()
session_data = session_store.session_data
# pylint: disable=assigning-non-slot
g.schema = load_schema_from_session_data(session_data)
logger.bind(tx_id=session_data.tx_id, schema_name=session_data.schema_name)
logger.info(
"questionnaire request", method=request.method, url_path=request.full_path
)
def before_questionnaire_request():
metadata = get_metadata(current_user)
if not metadata:
raise NoTokenException(401)
logger.bind(tx_id=metadata['tx_id'])
values = request.view_args
if check_multiple_survey(metadata, values):
raise MultipleSurveyError
logger.bind(eq_id=values['eq_id'],
form_type=values['form_type'],
ce_id=values['collection_id'])
logger.info('questionnaire request',
method=request.method,
url_path=request.full_path)
session_store = get_session_store()
session_data = session_store.session_data
language_code = request.args.get('language_code')
if language_code:
session_data.language_code = language_code
session_store.save()
g.schema = load_schema_from_session_data(session_data)
def load_user(extend_session: bool = True) -> Optional[User]:
"""
Checks for the present of the JWT in the users sessions
:return: A user object if a JWT token is available in the session
:param extend_session: bool, whether to extend the session
"""
session_store = get_session_store()
if session_store and _is_session_valid(session_store):
logger.debug("session exists")
user_id = session_store.user_id
user_ik = cookie_session.get(USER_IK)
user = User(user_id, user_ik)
if session_store.session_data and session_store.session_data.tx_id:
logger.bind(tx_id=session_store.session_data.tx_id)
if extend_session:
_extend_session_expiry(session_store)
return user
logger.info("session does not exist")
cookie_session.pop(USER_IK, None)
def load_user():
"""
Checks for the present of the JWT in the users sessions
:return: A user object if a JWT token is available in the session
"""
session_store = get_session_store()
if session_store and session_store.user_id and _is_session_valid(
session_store):
logger.debug('session exists')
user_id = session_store.user_id
user_ik = cookie_session.get(USER_IK)
user = User(user_id, user_ik)
if session_store.session_data.tx_id:
logger.bind(tx_id=session_store.session_data.tx_id)
_extend_session_expiry(session_store)
return user
logger.info('session does not exist')
cookie_session.pop(USER_IK, None)
return None
def get_questionnaire(schema, questionnaire_store):
router = Router(
schema,
questionnaire_store.answer_store,
questionnaire_store.list_store,
questionnaire_store.progress_store,
questionnaire_store.metadata,
)
if not router.can_access_hub():
redirect_location = router.get_first_incomplete_location_in_survey()
return redirect(redirect_location.url())
language_code = get_session_store().session_data.language_code
hub = HubContext(
language=language_code,
schema=schema,
answer_store=questionnaire_store.answer_store,
list_store=questionnaire_store.list_store,
progress_store=questionnaire_store.progress_store,
metadata=questionnaire_store.metadata,
)
hub_context = hub.get_context(
router.is_survey_complete(), router.enabled_section_ids
)
return render_template("hub", content=hub_context)
def individual_response_text_message_confirmation(schema, questionnaire_store):
language_code = get_session_store().session_data.language_code
individual_response_handler = IndividualResponseHandler(
schema=schema,
questionnaire_store=questionnaire_store,
language=language_code,
request_args=request.args,
form_data=request.form,
list_item_id=None,
)
if request.method == "POST":
return redirect(url_for("questionnaire.get_questionnaire"))
try:
mobile_number = url_safe_serializer().loads(request.args["mobile_number"])
except BadSignature:
raise BadRequest
return render_template(
template="individual_response/confirmation-text-message",
mobile_number=mobile_number,
page_title=individual_response_handler.page_title(
lazy_gettext("An individual access code has been sent by text")
),
)
def get_locale(): # pylint: disable=unused-variable
session = get_session_store()
if session and session.session_data:
return session.session_data.language_code
return None
def get_thank_you(schema):
session_store = get_session_store()
session_data = session_store.session_data
if not session_data.submitted_time:
return redirect(url_for("questionnaire.get_questionnaire"))
metadata_context = build_metadata_context_for_survey_completed(session_data)
view_submission_url = None
view_submission_duration = 0
if _is_submission_viewable(schema.json, session_data.submitted_time):
view_submission_url = url_for(".get_view_submission")
view_submission_duration = humanize.naturaldelta(
timedelta(seconds=schema.json["view_submitted_response"]["duration"])
)
cookie_session.pop("account_service_log_out_url", None)
cookie_session.pop("account_service_url", None)
return render_template(
template="thank-you",
metadata=metadata_context,
survey_id=schema.json["survey_id"],
is_view_submitted_response_enabled=is_view_submitted_response_enabled(
schema.json
),
view_submission_url=view_submission_url,
view_submission_duration=view_submission_duration,
)
def before_questionnaire_request():
metadata = get_metadata(current_user)
if not metadata:
raise NoTokenException(401)
logger.bind(tx_id=metadata['tx_id'])
values = request.view_args
logger.bind(eq_id=values['eq_id'],
form_type=values['form_type'],
ce_id=values['collection_id'])
logger.info('questionnaire request',
method=request.method,
url_path=request.full_path)
_check_same_survey(
url_eq_id=values['eq_id'],
url_form_type=values['form_type'],
url_collection_id=values['collection_id'],
session_eq_id=metadata['eq_id'],
session_form_type=metadata['form_type'],
session_collection_id=metadata['collection_exercise_sid'])
session_data = get_session_store().session_data
g.schema = load_schema_from_session_data(session_data)
def get_view_submission(schema, eq_id, form_type): # pylint: disable=unused-argument
session_data = get_session_store().session_data
if _is_submission_viewable(schema.json, session_data.submitted_time):
submitted_data = data_access.get_by_key(SubmittedResponse,
session_data.tx_id)
if submitted_data:
metadata_context = build_metadata_context_for_survey_completed(
session_data)
pepper = current_app.eq['secret_store'].get_secret_by_name(
'EQ_SERVER_SIDE_STORAGE_ENCRYPTION_USER_PEPPER')
encrypter = StorageEncryption(current_user.user_id,
current_user.user_ik, pepper)
submitted_data = json.loads(
encrypter.decrypt_data(submitted_data.data))
answer_store = AnswerStore(
existing_answers=submitted_data.get('answers'))
metadata = submitted_data.get('metadata')
routing_path = PathFinder(schema, answer_store, metadata,
[]).get_full_routing_path()
schema_context = _get_schema_context(routing_path, 0, metadata,
answer_store, schema)
rendered_schema = renderer.render(schema.json, **schema_context)
summary_rendered_context = build_summary_rendering_context(
schema, rendered_schema['sections'], answer_store, metadata)
context = {
'summary': {
'groups':
summary_rendered_context,
'answers_are_editable':
False,
'is_view_submission_response_enabled':
is_view_submitted_response_enabled(schema.json),
},
'variables': None,
}
return render_theme_template(
schema.json['theme'],
template_name='view-submission.html',
metadata=metadata_context,
analytics_ua_id=current_app.config['EQ_UA_ID'],
survey_id=schema.json['survey_id'],
survey_title=TemplateRenderer.safe_content(
schema.json['title']),
content=context)
return redirect(
url_for('post_submission.get_thank_you',
eq_id=eq_id,
form_type=form_type))
def download_pdf(schema, eq_id, form_type):
session_data = get_session_store().session_data
if _is_submission_viewable(schema.json, session_data.submitted_time):
submitted_data = data_access.get_by_key(SubmittedResponse,
session_data.tx_id)
if submitted_data:
filename = '{}_{}.pdf'.format(eq_id, form_type)
html = _render_submission_page(session_data, submitted_data,
schema, eq_id, form_type)
css = """
.header__main {
background: none !important;
}
.header__title {
color: black !important;
}
"""
return render_pdf(HTML(string=html), [CSS(string=css)], filename)
return redirect(
url_for('post_submission.get_thank_you',
eq_id=eq_id,
form_type=form_type))
def before_request():
logger.info('feedback request', url_path=request.full_path)
session = get_session_store()
if session:
logger.bind(tx_id=session.session_data.tx_id)
g.schema = load_schema_from_session_data(session.session_data)
def before_questionnaire_request():
if request.method == "OPTIONS":
return None
if cookie_session.get("submitted"):
raise PreviouslySubmittedException(
"The Questionnaire has been previously submitted"
)
metadata = get_metadata(current_user)
if not metadata:
raise NoQuestionnaireStateException(401)
questionnaire_store = get_questionnaire_store(
current_user.user_id, current_user.user_ik
)
if questionnaire_store.submitted_at:
return redirect(url_for("post_submission.get_thank_you"))
logger.bind(
tx_id=metadata["tx_id"],
schema_name=metadata["schema_name"],
ce_id=metadata["collection_exercise_sid"],
)
logger.info(
"questionnaire request", method=request.method, url_path=request.full_path
)
handle_language()
session_store = get_session_store()
# pylint: disable=assigning-non-slot
g.schema = load_schema_from_session_data(session_store.session_data)
def when_user_logged_out(
sender_app: Flask,
user: str # pylint: disable=unused-argument
) -> None:
logger.debug("log out user")
session_store = get_session_store()
if session_store:
session_store.delete()
cookie_session.pop(USER_IK, None)
def block(schema,
questionnaire_store,
block_id,
list_name=None,
list_item_id=None):
try:
block_handler = get_block_handler(
schema=schema,
block_id=block_id,
list_name=list_name,
list_item_id=list_item_id,
questionnaire_store=questionnaire_store,
language=flask_babel.get_locale().language,
request_args=request.args,
form_data=request.form,
)
except InvalidLocationException:
raise NotFound
if block_handler.block["type"] == "RelationshipCollector":
return redirect(block_handler.get_first_location_url())
if "action[clear_radios]" in request.form:
block_handler.clear_radio_answers()
return redirect(request.url)
if request.method == "GET" or (hasattr(block_handler, "form")
and not block_handler.form.validate()):
return _render_page(
template=block_handler.rendered_block["type"],
context=block_handler.get_context(),
previous_location_url=block_handler.get_previous_location_url(),
schema=schema,
page_title=block_handler.page_title,
)
if block_handler.block["type"] in END_BLOCKS:
submission_handler = SubmissionHandler(
schema, questionnaire_store,
block_handler.router.full_routing_path())
submission_handler.submit_questionnaire()
language_code = get_session_store().session_data.language_code
if "census" in cookie_session["theme"]:
log_out_url = get_census_base_url(cookie_session["theme"],
language_code)
cookie_session["account_service_log_out_url"] = log_out_url
return redirect(url_for("post_submission.get_thank_you"))
block_handler.handle_post()
next_location_url = block_handler.get_next_location_url()
return redirect(next_location_url)
def handle_language():
session_store = get_session_store()
if session_store:
launch_language = (session_store.session_data.launch_language_code
or DEFAULT_LANGUAGE_CODE)
g.allowed_languages = get_allowed_languages(
session_store.session_data.schema_name, launch_language)
request_language = request.args.get("language_code")
if request_language and request_language in g.allowed_languages:
session_store.session_data.language_code = request_language
session_store.save()
def dump_submission():
answer_store = get_answer_store(current_user)
metadata = get_metadata(current_user)
session_data = get_session_store().session_data
schema = load_schema_from_session_data(session_data)
completed_blocks = get_completed_blocks(current_user)
routing_path = PathFinder(schema, answer_store, metadata,
completed_blocks).get_full_routing_path()
response = {
'submission': convert_answers(metadata, schema, answer_store,
routing_path)
}
return jsonify(response), 200
def get_sign_out():
"""
Signs the user out of eQ and redirects to the log out url.
"""
if not cookie_session:
log_out_url = get_census_base_url(None, None)
elif ("census" in (theme := cookie_session.get("theme", DEFAULT_THEME))
and cookie_session.get("submitted") is True):
session_store = get_session_store()
language_code = (session_store.session_data.language_code
if session_store else None)
log_out_url = get_census_base_url(theme, language_code)
def request_individual_response(schema, questionnaire_store):
language_code = get_session_store().session_data.language_code
list_item_id = request.args.get("list_item_id")
individual_response_handler = IndividualResponseHandler(
schema=schema,
questionnaire_store=questionnaire_store,
language=language_code,
request_args=request.args,
form_data=request.form,
list_item_id=list_item_id,
)
return individual_response_handler.handle_get()
def get_view_submission(schema, eq_id, form_type): # pylint: disable=unused-argument, too-many-locals
session_data = get_session_store().session_data
if _is_submission_viewable(schema.json, session_data.submitted_time):
submitted_data = data_access.get_by_key(SubmittedResponse,
session_data.tx_id)
if submitted_data:
return _render_submission_page(session_data, submitted_data,
schema, eq_id, form_type)
return redirect(
url_for('post_submission.get_thank_you',
eq_id=eq_id,
form_type=form_type))
def individual_response_who(schema, questionnaire_store):
language_code = get_session_store().session_data.language_code
individual_response_handler = IndividualResponseWhoHandler(
schema=schema,
questionnaire_store=questionnaire_store,
language=language_code,
request_args=request.args,
form_data=request.form,
)
if request.method == "POST" and individual_response_handler.form.validate():
return individual_response_handler.handle_post()
return individual_response_handler.handle_get()
def individual_response_text_message_confirm(schema, questionnaire_store, list_item_id):
language_code = get_session_store().session_data.language_code
individual_response_handler = IndividualResponseTextConfirmHandler(
schema=schema,
questionnaire_store=questionnaire_store,
language=language_code,
request_args=request.args,
form_data=request.form,
list_item_id=list_item_id,
)
if request.method == "POST" and individual_response_handler.form.validate():
return individual_response_handler.handle_post()
return individual_response_handler.handle_get()
def __init__(self, schema):
self.session_store = get_session_store()
self.session_data = self.session_store.session_data
self._schema = schema
if not self.session_data.submitted_time:
raise NotFound
self._is_census_theme = cookie_session.get("theme") in [
"census",
"census-nisra",
]
self.template = (self.CENSUS_THANK_YOU_TEMPLATE
if self._is_census_theme else
self.DEFAULT_THANK_YOU_TEMPLATE)
self.confirmation_email = self._get_confirmation_email()
def before_post_submission_request():
session_store = get_session_store()
if not session_store or not session_store.session_data:
raise NoTokenException(401)
session_data = session_store.session_data
handle_language()
g.schema = load_schema_from_session_data(session_data)
logger.bind(tx_id=session_data.tx_id, schema_name=session_data.schema_name)
logger.info(
"questionnaire request", method=request.method, url_path=request.full_path
)
def get_thank_you(schema, metadata, eq_id, form_type):
session_data = get_session_store().session_data
completeness = get_completeness(current_user)
if session_data.submitted_time:
metadata_context = build_metadata_context_for_survey_completed(
session_data)
view_submission_url = None
view_submission_duration = 0
if _is_submission_viewable(schema.json, session_data.submitted_time):
view_submission_url = url_for('.get_view_submission',
eq_id=eq_id,
form_type=form_type)
view_submission_duration = humanize.naturaldelta(
timedelta(seconds=schema.json['view_submitted_response']
['duration']))
cookie_message = request.cookies.get('ons_cookie_message_displayed')
allow_analytics = analytics_allowed(request)
return render_theme_template(
schema.json['theme'],
template_name='thank-you.html',
metadata=metadata_context,
analytics_gtm_id=current_app.config['EQ_GTM_ID'],
analytics_gtm_env_id=current_app.config['EQ_GTM_ENV_ID'],
survey_id=schema.json['survey_id'],
survey_title=TemplateRenderer.safe_content(schema.json['title']),
is_view_submitted_response_enabled=
is_view_submitted_response_enabled(schema.json),
view_submission_url=view_submission_url,
account_service_url=cookie_session.get('account_service_url'),
account_service_log_out_url=cookie_session.get(
'account_service_log_out_url'),
view_submission_duration=view_submission_duration,
cookie_message=cookie_message,
allow_analytics=allow_analytics)
routing_path = path_finder.get_full_routing_path()
router = Router(schema, routing_path, completeness)
next_location = router.get_next_location()
return _redirect_to_location(metadata['collection_exercise_sid'],
metadata.get('eq_id'),
metadata.get('form_type'), next_location)
def contact():
session = None
survey_id = None
session_store = get_session_store()
if session_store:
session = session_store.session_data
schema = load_schema_from_session_data(session)
survey_id = schema.json['survey_id']
contact_template = render_theme_template(
theme=cookie_session.get('theme', 'default'),
template_name='static/contact-us.html',
session=session,
survey_id=survey_id,
analytics_ua_id=current_app.config['EQ_UA_ID'])
return contact_template
def request_individual_response(schema, questionnaire_store):
language_code = get_session_store().session_data.language_code
list_item_id = request.args.get("list_item_id")
individual_response_handler = IndividualResponseHandler(
block_definition=None,
schema=schema,
questionnaire_store=questionnaire_store,
language=language_code,
request_args=request.args,
form_data=request.form,
list_item_id=list_item_id,
)
if request.method == "POST":
return individual_response_handler.handle_post()
return individual_response_handler.handle_get()
def before_post_submission_request():
if request.method == "OPTIONS":
return None
session_store = get_session_store()
session_data = session_store.session_data
if not session_data.submitted_time:
raise NotFound
handle_language()
g.schema = load_schema_from_session_data(session_data)
logger.bind(tx_id=session_data.tx_id, schema_name=session_data.schema_name)
logger.info("questionnaire request",
method=request.method,
url_path=request.full_path)
def individual_response_post_address_confirm(schema, questionnaire_store, list_item_id):
language_code = get_session_store().session_data.language_code
try:
individual_response_handler = IndividualResponsePostAddressConfirmHandler(
schema=schema,
questionnaire_store=questionnaire_store,
language=language_code,
request_args=request.args,
form_data=request.form,
list_item_id=list_item_id,
)
except IndividualResponsePostalDeadlinePast:
return redirect(url_for(".individual_response_how", list_item_id=list_item_id))
if request.method == "POST" and individual_response_handler.form.validate():
return individual_response_handler.handle_post()
return individual_response_handler.handle_get()
