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()