def general_search_screen():
print("Reached post")
criteria = request.args["criteria"].split(";")
# Build class for the forms that are passed in, this must be done dynamically
# create form object
# Build class for the forms that are passed in, this must be done dynamically
selection_form = create_form_class(criteria)
# create form object
form = selection_form(request.form)
mutable_form = create_new_dict(request.form)
clean_parameters = clean_search_parameters(mutable_form)
url_connect = build_uri(clean_parameters)
url_connect += ";first=10"
print("url connect: {}".format(url_connect))
data = GraphData(
discovery_service.contributor_search(url_connect, "business-layer"))
output_data = data.nodes
# links = data.page_info
return render_template(
"./contributor_search/GeneralSearchScreenGQL.html",
form=form,
records=output_data,
header=output_data[0],
fields=dict(form.__dict__["_fields"]),
links=data.page_info,
)
def general_search_screen_post():
log.info("general_search_screen_post")
criteria = request.args["criteria"].split(";")
# Build class for the forms that are passed in, this must be done dynamically
# create form object
# Build class for the forms that are passed in, this must be done dynamically
selection_form = create_form_class(criteria, log)
# create form object
form = selection_form(request.form)
mutable_form = create_new_dict(request.form)
clean_parameters = clean_search_parameters(mutable_form)
url_connect = build_uri(clean_parameters)
parameters = url_connect
url_connect += ";first=10"
log.info("url connect: {}".format(url_connect))
contributor_data = api_caller.contributor_search(parameters=url_connect)
data = GraphData(contributor_data)
output_data = data.nodes
log.info("Data from GraphQL for search: %s", output_data)
return render_template("./contributor_search/GeneralSearchScreenGQL.html",
form=form,
records=output_data,
header=output_data[0],
fields=dict(form.__dict__["_fields"]),
links=data.page_info,
parameters=parameters)
def view_form(inqcode, period, ruref):
print("entered view_form")
url_parameters = dict(
zip(["survey", "period", "reference"], [inqcode, period, ruref]))
url_connect = build_uri(url_parameters)
pl_url_connect = build_uri_2(url_parameters)
question_definition, contributor_details, form_responses = forms_connect_to_eureka(
url_connect)
# validations_output = forms_connect_to_eureka_validation(pl_url_connect)
definition = json.loads(question_definition)
contributor_data = json.loads(contributor_details)
form_response = json.loads(form_responses)
print("load json")
# validations_output = json.loads(validations_output)
# print(type(validations_output))
# print(validations_output)
# print(form_response)
# if there is a request method called then there's been a request for edit form
if request.method == "POST":
return redirect(
url_for("edit_form.edit_form",
ruref=ruref,
inqcode=inqcode,
period=period))
# if form_response is empty, then we have a blank form and so return just the definition
if not form_response:
return render_template("./view_form/BlankFormView.html",
survey=inqcode,
period=period,
ruref=ruref,
data=definition,
contributor_details=contributor_data[0],
locked=contributor_data[0]["lockedBy"])
return render_template("./view_form/FormView.html",
survey=inqcode,
period=period,
ruref=ruref,
data=definition,
contributor_details=contributor_data[0],
responses=form_response,
locked=contributor_data[0]["lockedBy"],
validation={})
def edit_form(inqcode, period, ruref):
# Init save_error to empty string
status_message = ""
# Build URI for business layer
url_parameters = dict(
zip(["survey", "period", "reference"], [inqcode, period, ruref]))
url_connect = build_uri(url_parameters)
pl_url_connect = build_uri_2(url_parameters)
# attempt to connect to Eureka, except common errors
question_definition, contributor_details, form_responses = forms_connect_to_eureka(
url_connect)
# validations_output = forms_connect_to_eureka_validation(pl_url_connect)
# update contributor table to lock the form for editing
discovery_service.update_locked_status(url_connect,
"persistence-layer",
data={"lockedBy": get_user()})
# load the json to turn it into a usable form
definition = json.loads(question_definition)
contributor_data = json.loads(contributor_details)
form_response = json.loads(form_responses)
# validations_output = json.loads(validations_output)
# Only run the following code if the UI has submitted a POST request
if request.method == "POST":
form = request.form
print(form)
# Only run the following code if saveForm is in the form, indicating that the save form button has been pressed
if request.form['action'] == 'saveForm':
print("saveform")
# Get the form
form = request.form
print(form)
print(form_response)
# Build up a contributor key
contributor_key_data = {
'survey': inqcode,
'period': period,
'reference': ruref
}
# Get the data from the form
data = {key: form[key] for key in form.keys()}
# decompose the field names from questionCode:number|instance:number to
# {questionCode: number, instance: number}
response_data = decompose_data(data)
original_data = build_json(form_response)
# print("form response: {}".format(form_response))
# print("original data: {}".format(original_data))
# Append the original responses to the JSON
response_data["Original Responses"] = original_data
# Append the username
response_data["user"] = {"user": get_user()}
# Append contributor PK
response_data["reference"] = ruref
response_data["period"] = period
response_data["survey"] = inqcode
# Build the URL for the contributor responses to update
url_connect = build_uri(contributor_key_data)
# Send the data to the business layer for processing
print("total json: {}".format(str(response_data)))
try:
discovery_service.update_response(url_connect,
"business-layer",
response_data)
except Exception as error:
status_message = {
"Error":
"There was an error when attempting to save new responses:\n{}"
.format(error)
}
return render_template(
"./edit_form/EditFormNew.html",
survey=inqcode,
period=period,
ruref=ruref,
data=definition,
contributor_details=contributor_data[0],
responses=form_response,
validation={},
status_message=json.dumps(status_message))
status_message = "New responses saved successfully"
# Get the refreshed data from the responses table
form_responses = discovery_service.form_response(
url_connect, "persistence-layer")
form_response = json.loads(form_responses)
# Render the responses
return render_template("./edit_form/EditFormNew.html",
survey=inqcode,
period=period,
ruref=ruref,
data=definition,
contributor_details=contributor_data[0],
responses=form_response,
validation={},
status_message=status_message)
if request.form['action'] == 'saveAndValidate':
print("Save and validate")
# Get the form
form = request.form
print(form)
# Build up a contributor key
contributor_key_data = {
'survey': inqcode,
'period': period,
'reference': ruref
}
# Get the data from the form
data = {key: form[key] for key in form.keys()}
# decompose the field names from questionCode:number|instance:number to
# {questionCode: number, instance: number}
response_data = decompose_data(data)
original_data = build_json(form_response)
# print("form response: {}".format(form_response))
# print("original data: {}".format(original_data))
# Append the original responses to the JSON
response_data["Original Responses"] = original_data
# Append the username
response_data["user"] = {"user": get_user()}
# Append contributor PK
response_data["reference"] = ruref
response_data["period"] = period
response_data["survey"] = inqcode
# Build the URL for the contributor responses to update
url_connect = build_uri(contributor_key_data)
# Send the data to the business layer for processing
print("total json: {}".format(str(response_data)))
output_from_bl = discovery_service.run_validations(
url_connect, "validation-persistence-layer", response_data)
response_from_bl = json.loads(output_from_bl)
if not response_from_bl["error"]:
# Get the refreshed data from the responses table
contributor_details = discovery_service.contributor_search_without_paging(
url_connect, "business-layer")
form_responses = discovery_service.form_response(
url_connect, "persistence-layer")
form_response = json.loads(form_responses)
validations_output = forms_connect_to_eureka_validation(
pl_url_connect)
validations_output = json.loads(validations_output)
contributor_data = json.loads(contributor_details)
return render_template("./edit_form/EditFormNew.html",
survey=inqcode,
period=period,
ruref=ruref,
data=definition,
contributor_details=contributor_data[0],
responses=form_response,
validation={})
else:
return render_template(
"./404.html",
message_header="Error in Validate on Save",
error_message=response_from_bl["error"])
# If the form doesn't have saveForm, then the exit button must have been pressed
# Update the contributor table to unlock the form
discovery_service.update_locked_status(url_connect,
"persistence-layer",
data={"lockedBy": ""})
# return the user to the view form screen
return redirect(
url_for("view_form.view_form",
ruref=ruref,
inqcode=inqcode,
period=period))
# Render the screen
return render_template("./edit_form/EditFormNew.html",
survey=inqcode,
period=period,
ruref=ruref,
data=definition,
contributor_details=contributor_data[0],
responses=form_response,
locked=contributor_data[0]["lockedBy"],
validation={},
status_message=json.dumps(status_message))
def view_form(inqcode, period, ruref):
if (
request.form
and request.form['action'] == 'save-and-validate'
and not current_app.auth.has_permission(["dev", "survey.*.write", "survey.*.manager"])
):
abort(403)
log.info("View_Form -- START --")
log.info("Request.form: %s", request.form)
try:
status_message = ""
url_parameters = dict(
zip(["survey", "period", "reference"], [inqcode, period, ruref]))
parameters = build_uri(url_parameters)
contributor_details = api_caller.contributor_search(parameters=parameters)
contributor_data = json.loads(contributor_details)
log.info("Contributor Details: %s", contributor_data)
log.info("Contributor Details[0]: %s", contributor_data['data'][0])
validation_outputs = api_caller.validation_outputs(parameters=parameters)
validations = json.loads(validation_outputs)
log.info("Validations output: %s", validations)
view_forms = api_caller.view_form_responses(parameters=parameters)
view_form_data = json.loads(view_forms)
log.info("View Form Data: %s", view_form_data)
historic_data = api_caller.get_historic_data(parameters=parameters)
historic_data_json = json.loads(historic_data)
log.info("History Data: %s", historic_data_json)
grouped_historic_data = group_historic_data(historic_data_json)
log.info("Grouped Historic Data by question : %s", grouped_historic_data)
status = contributor_data['data'][0]['status']
status_colour = check_status(status)
log.info("status colour: %s", status_colour)
filtered_validations = filter_validations(validations)
log.info("filtered validations: %s", filtered_validations)
response_and_validations = combine_responses_and_validations(view_form_data, filtered_validations)
log.info("response_and_validations: %s", response_and_validations)
ordered_response_and_validations = question_order(response_and_validations)
log.info("Combined Response and Validation Info Data: %s", ordered_response_and_validations)
override_button = override_all_button(ordered_response_and_validations)
except Exception as error:
log.info("Error %s", error)
if request.form and request.form['action'] == 'save-and-validate':
save_form(parameters, request.form, inqcode, period, ruref)
validate(inqcode, period, ruref)
time.sleep(6)
return redirect(url_for('view_form.view_form', inqcode=inqcode, period=period, ruref=ruref))
return render_template(
template_name_or_list=form_view_template_HTML,
survey=inqcode,
period=period,
ruref=ruref,
data=ordered_response_and_validations,
override_button=override_button,
status_message=json.dumps(status_message),
contributor_details=contributor_data['data'][0],
validation=filter_validations(validations),
user=get_user(),
status_colour=status_colour,
historic_data=historic_data_json,
grouped_historic_data=grouped_historic_data)
def general_search_screen():
criteria = request.args['criteria'].split(";")
# Build class for the forms that are passed in, this must be done dynamically
selection_form = create_form_class(criteria)
# create form object
form = selection_form(request.form)
# On search, and if form object passes validation enter block
current_page = -1
last_page = -1
if request.method == "POST":
if "nextButton" in request.form:
button_value = request.form['nextButton']
url_connect = button_value.split('/')[-1]
data = discovery_service.contributor_search(
url_connect, "persistence-layer")
output_data = json.loads(data)
links = output_data['links']
content = output_data['content']
# Remove individual links key from dictionary as this is blank and not needed on results table
for i in content:
del i['links']
page_info = output_data['page']
total_records = page_info['totalElements']
current_page = page_info['number']
last_page = page_info['totalPages'] - 1
print("Current Page: " + str(current_page))
first_link = build_links(links, 'first')
next_link = build_links(links, 'next')
prev_link = build_links(links, 'prev')
last_link = build_links(links, 'last')
return render_template(
"./contributor_search/GeneralSearchScreen.html",
next_url=next_link,
form=form,
prev_url=prev_link,
first_url=first_link,
last_url=last_link,
total_records=total_records,
current_page=current_page,
last_page=last_page,
records=content,
header=content[0],
fields=dict(form.__dict__['_fields']))
if "prevButton" in request.form:
button_value = request.form['prevButton']
url_connect = button_value.split('/')[-1]
data = discovery_service.contributor_search(
url_connect, "persistence-layer")
output_data = json.loads(data)
links = output_data['links']
content = output_data['content']
# Remove individual links key from dictionary as this is blank and not needed on results table
for i in content:
del i['links']
page_info = output_data['page']
total_records = page_info['totalElements']
current_page = page_info['number']
last_page = page_info['totalPages'] - 1
print("Current Page: " + str(current_page))
first_link = build_links(links, 'first')
next_link = build_links(links, 'next')
prev_link = build_links(links, 'prev')
last_link = build_links(links, 'last')
return render_template(
"./contributor_search/GeneralSearchScreen.html",
next_url=next_link,
form=form,
prev_url=prev_link,
first_url=first_link,
last_url=last_link,
total_records=total_records,
current_page=current_page,
last_page=last_page,
records=content,
header=content[0],
fields=dict(form.__dict__['_fields']))
if "firstButton" in request.form:
button_value = request.form['firstButton']
url_connect = button_value.split('/')[-1]
data = discovery_service.contributor_search(
url_connect, "persistence-layer")
output_data = json.loads(data)
links = output_data['links']
content = output_data['content']
# Remove individual links key from dictionary as this is blank and not needed on results table
for i in content:
del i['links']
page_info = output_data['page']
total_records = page_info['totalElements']
current_page = page_info['number']
last_page = page_info['totalPages'] - 1
print("Current Page: " + str(current_page))
first_link = build_links(links, 'first')
next_link = build_links(links, 'next')
prev_link = build_links(links, 'prev')
last_link = build_links(links, 'last')
return render_template(
"./contributor_search/GeneralSearchScreen.html",
next_url=next_link,
form=form,
prev_url=prev_link,
first_url=first_link,
last_url=last_link,
total_records=total_records,
current_page=current_page,
last_page=last_page,
records=content,
header=content[0],
fields=dict(form.__dict__['_fields']))
if "lastButton" in request.form:
button_value = request.form['lastButton']
url_connect = button_value.split('/')[-1]
data = discovery_service.contributor_search(
url_connect, "persistence-layer")
output_data = json.loads(data)
links = output_data['links']
content = output_data['content']
# Remove individual links key from dictionary as this is blank and not needed on results table
for i in content:
del i['links']
page_info = output_data['page']
total_records = page_info['totalElements']
current_page = page_info['number']
last_page = page_info['totalPages'] - 1
print("Current Page: " + str(current_page))
first_link = build_links(links, 'first')
next_link = build_links(links, 'next')
prev_link = build_links(links, 'prev')
last_link = build_links(links, 'last')
return render_template(
"./contributor_search/GeneralSearchScreen.html",
next_url=next_link,
form=form,
prev_url=prev_link,
first_url=first_link,
last_url=last_link,
total_records=total_records,
current_page=current_page,
last_page=last_page,
records=content,
header=content[0],
fields=dict(form.__dict__['_fields']))
# Clean inputs and build URL
mutable_form = create_new_dict(request.form)
clean_parameters = clean_search_parameters(mutable_form)
url_connect = build_uri(clean_parameters)
# Hard coding the sort conditions, to be changed in future
url_connect += "?page=0&size=10&sort=period,asc"
# Make a get request from the built up URL, when the request
# is made, the url is passed over to the Persistence layer
data = discovery_service.contributor_search(url_connect,
"persistence-layer")
# take the JSON string and turn is into a Python object, the resulting object should be a list of dictionaries
# Extracting content and links for pagination
output_data = json.loads(data)
links = output_data['links']
content = output_data['content']
# Remove individual links key from dictionary as this is blank and not needed on results table
for i in content:
del i['links']
page_info = output_data['page']
total_records = page_info['totalElements']
current_page = page_info['number']
last_page = page_info['totalPages'] - 1
print("Current Page: " + str(current_page))
first_link = build_links(links, 'first')
next_link = build_links(links, 'next')
prev_link = build_links(links, 'prev')
last_link = build_links(links, 'last')
print(len(content))
# Check if the python object does not contains the key "error" and if the length of the list is > 0
# This means that there have been no errors and the query returned at least one result
if 'error' not in content and content:
return render_template(
"./contributor_search/GeneralSearchScreen.html",
next_url=next_link,
form=form,
prev_url=prev_link,
first_url=first_link,
last_url=last_link,
total_records=total_records,
current_page=current_page,
last_page=last_page,
records=content,
header=content[0],
fields=dict(form.__dict__['_fields']))
# Now check that the object doesn't contain the key "error" and if the length of the list is 0
# This means that there have been no errors and the query returned no results
if 'error' not in content and not content:
current_page = -1
return render_template(
"./contributor_search/GeneralSearchScreen.html",
form=form,
fields=dict(form.__dict__['_fields']),
message="No results found",
current_page=current_page,
last_page=last_page,
)
# If the two above checks failed, then the query must have returned an error
dummy_list = [content]
return render_template("./contributor_search/GeneralSearchScreen.html",
form=form,
records=dummy_list,
fields=dict(form.__dict__['_fields']))
# before any searches are done, return just the webpage with the search fields.
return render_template("./contributor_search/GeneralSearchScreen.html",
form=form,
fields=dict(form.__dict__['_fields']),
current_page=current_page,
last_page=last_page)