def get_initial(self):
"""
Get initial defines the initial data for the form instance that is to be rendered on the page
:return: a dictionary mapping form field names, to values of the correct type
"""
initial = super().get_initial()
application_id = app_id_finder(self.request)
response = NannyGatewayActions().list('previous-name', params={'application_id': application_id})
if response.status_code == 200:
initial['name_history'] = True
else:
initial['name_history'] = False
return initial
def get_form(self, form_class=None):
"""
Method to instantiate the form for rendering in the view.
If it is a GET request, perform check for ARC comments.
If it is a POST, remove any existing ARC comments.
"""
form = super(NannyFormView, self).get_form(form_class)
endpoint = self.endpoint
id = app_id_finder(self.request)
if self.request.method == "GET":
if getattr(form, "check_flags", None):
form.check_flags(id, endpoint, id)
elif self.request.method == "POST":
if getattr(form, "remove_flags", None):
form.remove_flags(id, endpoint, id)
return form
def get_form(self, form_class=None):
"""
Method to instantiate the form for rendering in the view.
for this view it takes comment from ArcComments and saves it in context
"""
form = super(NannyFormView, self).get_form(form_class)
id = app_id_finder(self.request)
if self.request.method == "GET":
if getattr(form, "check_flags", None):
flag = form.check_flags(id)
# context["flag"] = flag
# print(context)
elif self.request.method == "POST":
if getattr(form, "remove_flags", None):
form.remove_flags(id)
return form
def get_initial(self):
"""
Get initial defines the initial data for the form instance that is to be rendered on the page
:return: a dictionary mapping form field names, to values of the correct type
"""
initial = super().get_initial()
application_id = app_id_finder(self.request)
response = NannyGatewayActions().list(
"missing-address-gap", params={"application_id": application_id}
)
if response.status_code == 200:
gaps = True
elif response.status_code == 404:
gaps = False
initial = {"gaps_in_five_year_address_history": gaps}
return initial
def get_context_data(self, **kwargs):
context = super().get_context_data()
application_id = app_id_finder(self.request)
show_extra = bool(self.request.GET.get('show-extra'))
context["id"] = application_id
application_record = (NannyGatewayActions().read("application",
params={
"application_id":
application_id
}).record)
context["personal_details_status"] = application_record[
"personal_details_status"]
context.update(
self._previous_names_page_render(application_id,
show_extra=show_extra))
return context
def get_initial(self):
initial = super().get_initial()
app_id = app_id_finder(self.request)
initial['id'] = app_id
api_response = NannyGatewayActions().list('previous-address',
params={
'person_id': app_id,
'order': '0'
})
if api_response.status_code == 200:
initial['postcode'] = api_response.record[0]['postcode']
crc_api_response = NannyGatewayActions().read(
"dbs-check", params={'application_id': app_id})
if crc_api_response.status_code == 200:
initial['lived_abroad'] = crc_api_response.record['lived_abroad']
return initial
def get_initial(self):
"""
Get initial defines the initial data for the form instance that is to be rendered on the page
:return: a dictionary mapping form field names, to values of the correct type
"""
initial = super().get_initial()
application_id = app_id_finder(self.request)
response = NannyGatewayActions().read(
'suitability', params={'application_id': application_id})
if response.status_code == 200:
personal_details_record = response.record
elif response.status_code == 404:
return initial
initial['social_services'] = personal_details_record['social_services']
# If there has yet to be an entry for the model associated with the form, then no population necessary
return initial
def get_initial(self):
initial = super(PersonalDetailSelectAddressView, self).get_initial()
app_id = app_id_finder(self.request)
api_response = NannyGatewayActions().read('applicant-home-address', params={'application_id': app_id})
if api_response.status_code == 200:
postcode = api_response.record['postcode']
initial['postcode'] = postcode
initial['id'] = app_id
address_choices = AddressHelper.create_address_lookup_list(postcode)
initial['choices'] = address_choices
pd_api_response = NannyGatewayActions().read('applicant-personal-details', params={'application_id': app_id})
if pd_api_response.status_code == 200:
record = pd_api_response.record
if record['moved_in_date'] is not None:
initial['moved_in_date'] = initial['moved_in_date'] = datetime.strptime(record['moved_in_date'], '%Y-%m-%d').date()
return initial
def form_valid(self, form):
application_id = app_id_finder(self.request)
postcode = form.cleaned_data['postcode']
api_response = NannyGatewayActions().read('applicant-home-address', params={'application_id': application_id})
if api_response.status_code == 200:
address_record = api_response.record
address_record['postcode'] = postcode
NannyGatewayActions().put('applicant-home-address', params=address_record)
else:
personal_details = NannyGatewayActions().read('applicant-personal-details', params={'application_id': application_id}).record
NannyGatewayActions().create(
'applicant-home-address',
params={
'application_id': application_id,
'personal_detail_id': personal_details['personal_detail_id'],
'postcode': postcode,
})
return super().form_valid(form)
def get_initial(self):
initial = super(PersonalDetailSelectPreviousAddressView,
self).get_initial()
app_id = app_id_finder(self.request)
master_summary = self.request.GET.get('master_summary')
api_response = NannyGatewayActions().list('previous-address',
params={
'person_id': app_id,
'order': '0'
})
if api_response.status_code == 200:
postcode = api_response.record[0]['postcode']
initial['postcode'] = postcode
initial['id'] = app_id
address_choices = AddressHelper.create_address_lookup_list(
postcode)
initial['choices'] = address_choices
return initial
def form_valid(self, form):
application_id = app_id_finder(self.request)
application_record = (NannyGatewayActions().read("application",
params={
"application_id":
application_id
}).record)
if (application_record["personal_details_status"] != "COMPLETED"
or application_record["personal_details_status"] != "FLAGGED"):
application_record["personal_details_status"] = "IN_PROGRESS"
NannyGatewayActions().put("application", params=application_record)
data_dict = {
"application_id": application_id,
"date_of_birth": form.cleaned_data["date_of_birth"],
}
response = NannyGatewayActions().read(
"applicant-personal-details",
params={"application_id": application_id})
if response.status_code == 200:
NannyGatewayActions().patch("applicant-personal-details",
params=data_dict)
elif response.status_code == 404:
NannyGatewayActions().create("applicant-personal-details",
params=data_dict)
prev_name_response = NannyGatewayActions().list("previous-name",
params={
"application_id":
application_id,
"order": "0"
})
if prev_name_response.status_code == 200:
data_dict = prev_name_response.record[0]
data_dict["start_day"] = form.cleaned_data["date_of_birth"].day
data_dict["start_month"] = form.cleaned_data["date_of_birth"].month
data_dict["start_year"] = form.cleaned_data["date_of_birth"].year
NannyGatewayActions().put("previous-name", params=data_dict)
return super().form_valid(form)
def form_valid(self, form):
application_id = app_id_finder(self.request)
application_record = NannyGatewayActions().read("application",
params={
"application_id":
application_id
}).record
if application_record["suitability_details_status"] not in (
"COMPLETED",
"FLAGGED",
):
application_record["suitability_details_status"] = "IN_PROGRESS"
NannyGatewayActions().put("application", params=application_record)
answer = form.cleaned_data["disqualification"]
data_dict = {
"application_id": application_id,
"disqualification": answer,
}
if answer == "False":
data_dict["disqualification_details"] = ""
arc_comments_response = NannyGatewayActions().list(
"arc-comments",
params={
"application_id": application_id,
'field_name': 'disqualification_details',
'endpoint_name': 'suitability'
})
if arc_comments_response.status_code == 200:
arc_record = arc_comments_response.record[0]
arc_record['flagged'] = False
NannyGatewayActions().put('arc-comments', params=arc_record)
existing_record = NannyGatewayActions().read(
"suitability", params={"application_id": application_id})
if existing_record.status_code == 200:
NannyGatewayActions().patch("suitability", params=data_dict)
elif existing_record.status_code == 404:
NannyGatewayActions().create("suitability", params=data_dict)
return super().form_valid(form)
def get_initial(self):
initial = super().get_initial()
app_id = app_id_finder(self.request)
initial['id'] = app_id
api_response = NannyGatewayActions().read('applicant-home-address', params={'application_id': app_id})
if api_response.status_code == 200:
initial['street_line1'] = api_response.record['street_line1']
initial['street_line2'] = api_response.record['street_line2']
initial['town'] = api_response.record['town']
initial['county'] = api_response.record['county']
initial['postcode'] = api_response.record['postcode']
# get moved in date
pd_api_response = NannyGatewayActions().read('applicant-personal-details', params={'application_id': app_id})
if pd_api_response.status_code == 200:
record = pd_api_response.record
if record['moved_in_date'] is not None:
initial['moved_in_date'] = datetime.strptime(record['moved_in_date'], '%Y-%m-%d').date()
return initial
def form_valid(self, form):
application_id = app_id_finder(self.request)
application_record = NannyGatewayActions().read('application',
params={
'application_id':
application_id
}).record
if application_record[
'suitability_details_status'] != 'COMPLETED' or application_record[
'suitability_details_status'] != 'FLAGGED':
application_record['suitability_details_status'] = 'IN_PROGRESS'
NannyGatewayActions().put('application', params=application_record)
answer = form.cleaned_data["social_services"]
data_dict = {
'application_id': application_id,
'social_services': answer,
}
if answer == "False":
data_dict["social_services_details"] = ""
arc_comments_response = NannyGatewayActions().list(
"arc-comments",
params={
"application_id": application_id,
'field_name': 'social_services_details',
'endpoint_name': 'suitability'
})
if arc_comments_response.status_code == 200:
arc_record = arc_comments_response.record[0]
arc_record['flagged'] = False
NannyGatewayActions().put('arc-comments', params=arc_record)
existing_record = NannyGatewayActions().read(
'suitability', params={'application_id': application_id})
if existing_record.status_code == 200:
NannyGatewayActions().patch('suitability', params=data_dict)
elif existing_record.status_code == 404:
NannyGatewayActions().create('suitability', params=data_dict)
return super().form_valid(form)
def form_valid(self, form):
app_id = app_id_finder(self.request)
selected_address_index = form.cleaned_data['previous_address']
postcode = self.request.POST.get('postcode')
api_response = NannyGatewayActions().list('previous-address',
params={
'person_id': app_id,
'order': '0'
})
# if statement for routing on "add another address" button, same form validation and database changes
# but redirect to the other page, and snippet into HTML of the redirected to page, get address from
# database and add to the template, value from request has ID and then
# NannyGatewayActions().delete("previous_address_id"...)
if api_response.status_code == 200:
record = api_response.record[0]
NannyGatewayActions().delete(
'previous-address',
params={'previous_address_id': record['previous_address_id']})
selected_address = AddressHelper.get_posted_address(
selected_address_index, postcode)
record['street_line1'] = selected_address['line1'].title()
record['street_line2'] = selected_address['line2'].title()
record['town'] = selected_address['townOrCity'].title()
record['county'] = ''.title()
record['postcode'] = selected_address['postcode']
record['country'] = 'United Kingdom'
record['moved_in_date'] = form.cleaned_data['moved_in_date']
record['moved_out_date'] = form.cleaned_data['moved_out_date']
all_addresses_response = NannyGatewayActions().list(
'previous-address', params={'person_id': app_id})
if all_addresses_response.status_code == 200:
record['order'] = len(all_addresses_response.record) + 1
else:
record['order'] = 1
NannyGatewayActions().create(
'previous-address', params=record) # Update entire record.
return super(PersonalDetailSelectPreviousAddressView,
self).form_valid(form)
def form_valid(self, form):
application_id = app_id_finder(self.request)
record = NannyGatewayActions().read('application',
params={
'application_id':
application_id
}).record
record['information_correct_declare'] = form.cleaned_data[
'confirm_declare']
record['date_updated'] = datetime.datetime.today()
NannyGatewayActions().put('application', params=record)
if record['application_status'] == 'FURTHER_INFORMATION':
# TODO: create a list of updated tasks
updated_list = generate_list_of_updated_tasks(record)
# TODO: send a re-submission email
pd_record = NannyGatewayActions().read(
'applicant-personal-details',
params={
'application_id': application_id
}).record
user_record = IdentityGatewayActions().read('user',
params={
'application_id':
application_id
}).record
resubmission_confirmation_email(user_record['email'],
record['application_reference'],
pd_record['first_name'],
updated_list)
# TODO: clear statuses against Nanny application
clear_arc_flagged_statuses(record)
# TODO: redirect to resubmitted page
self.success_url = 'declaration:confirmation'
else:
self.success_url = 'payment:gov-pay-send-handler'
return super().form_valid(form)
def form_valid(self, form):
app_id = app_id_finder(self.request)
gap_id = self.request.POST.get("gap_id")
api_response = NannyGatewayActions().read(
"missing-address-gap", params={"missing_address_gap_id": gap_id}
)
reason = form.cleaned_data["gap_reason"]
moved_in_date = form.cleaned_data["moved_in_date"]
moved_out_date = form.cleaned_data["moved_out_date"]
# update the address record if it already existed
if api_response.status_code == 200:
record = api_response.record
record["gap_reason"] = reason
record["moved_in_day"] = moved_in_date.day
record["moved_in_month"] = moved_in_date.month
record["moved_in_year"] = moved_in_date.year
record["moved_out_day"] = moved_out_date.day
record["moved_out_month"] = moved_out_date.month
record["moved_out_year"] = moved_out_date.year
NannyGatewayActions().put("missing-address-gap", params=record)
return super().form_valid(form)
def form_valid(self, form):
application_id = app_id_finder(self.request)
postcode = form.cleaned_data['postcode']
api_response = NannyGatewayActions().list('previous-address',
params={
'person_id':
application_id,
'order': '0'
})
if api_response.status_code == 200:
record = api_response.record[0]
record['postcode'] = postcode
NannyGatewayActions().put('previous-address', params=record)
else:
NannyGatewayActions().create('previous-address',
params={
'person_id': application_id,
'postcode': postcode,
'order': 0
})
return super().form_valid(form)
def get_success_url(self):
app_id = app_id_finder(self.request)
pd_api_response = NannyGatewayActions().read(
'applicant-personal-details', params={'application_id': app_id})
if pd_api_response.status_code == 200:
record = pd_api_response.record
moved_in_date_str = record['moved_in_date']
moved_in_date = datetime.datetime.strptime(moved_in_date_str,
'%Y-%m-%d').date()
else:
raise Exception(
"Issue calculating whether move in date is within the last 5 years."
)
today_date = datetime.date.today()
five_years_ago_date = today_date - relativedelta(years=5)
correct_lived_abroad = 'dbs:Criminal-Records-Abroad-View'
incorrect_lived_abroad_within_five = 'personal-details:Personal-Details-Previous-Address'
incorrect_lived_abroad_outside_five = 'personal-details:Personal-Details-Summary'
if self.request.POST['lived_abroad'] == 'True':
self.success_url = correct_lived_abroad
elif (self.request.POST['lived_abroad']
== 'False') & (moved_in_date > five_years_ago_date):
self.success_url = incorrect_lived_abroad_within_five
elif (self.request.POST['lived_abroad']
== 'False') & (moved_in_date <= five_years_ago_date):
self.success_url = incorrect_lived_abroad_outside_five
else:
raise ValueError(
"Invalid response passed to the lived_abroad view from the Lived abroad question in Nanny"
)
url = super(PersonalDetailLivedAbroadView, self).get_success_url()
return url
def get_initial(self):
initial = super().get_initial()
app_id = app_id_finder(self.request)
initial["id"] = app_id
gap_id = self.request.GET.get("gap_id")
api_response = NannyGatewayActions().read(
"missing-address-gap", params={"missing_address_gap_id": gap_id}
)
if api_response.status_code == 200:
record = api_response.record
initial["gap_reason"] = api_response.record["gap_reason"]
initial["moved_in_date"] = datetime.datetime(
record["moved_in_year"],
record["moved_in_month"],
record["moved_in_day"],
).date()
initial["moved_out_date"] = datetime.datetime(
record["moved_out_year"],
record["moved_out_month"],
record["moved_out_day"],
).date()
return initial
def form_valid(self, form):
application_id = app_id_finder(self.request)
application_record = (NannyGatewayActions().read("application",
params={
"application_id":
application_id
}).record)
if (application_record["personal_details_status"] != "COMPLETED"
or application_record["personal_details_status"] != "FLAGGED"):
application_record["personal_details_status"] = "IN_PROGRESS"
NannyGatewayActions().put("application", params=application_record)
if form.cleaned_data["title"] != "Other":
title = form.cleaned_data["title"]
else:
title = form.cleaned_data["other_title"]
data_dict = {
"application_id": application_id,
"title": title,
"first_name": form.cleaned_data["first_name"],
"middle_names": form.cleaned_data["middle_names"],
"last_name": form.cleaned_data["last_name"],
}
existing_record = NannyGatewayActions().read(
"applicant-personal-details",
params={"application_id": application_id})
if existing_record.status_code == 200:
NannyGatewayActions().patch("applicant-personal-details",
params=data_dict)
elif existing_record.status_code == 404:
NannyGatewayActions().create("applicant-personal-details",
params=data_dict)
return super().form_valid(form)
def get_initial(self):
"""
Get initial defines the initial data for the form instance that is to be rendered on the page
:return: a dictionary mapping form field names, to values of the correct type
"""
initial = super().get_initial()
application_id = app_id_finder(self.request)
response = NannyGatewayActions().read(
'first-aid', params={'application_id': application_id})
if response.status_code == 200:
first_aid_record = response.record
else:
return initial
initial['training_organisation'] = first_aid_record[
'training_organisation']
initial['course_title'] = first_aid_record['course_title']
initial['course_date'] = datetime.datetime.strptime(
first_aid_record['course_date'], '%Y-%m-%d')
# If there has yet to be an entry for the model associated with the form, then no population necessary
return initial
def post(self, request):
application_id = app_id_finder(request)
NannyGatewayActions().patch('application', params={'application_id': application_id, 'dbs_status': 'IN_PROGRESS'})
return HttpResponseRedirect(build_url(self.success_url_name, get={'id': application_id}))
def post(self, request, *args, **kwargs):
"""
Handle post requests to the guidance page.
"""
app_id = app_id_finder(request)
return HttpResponseRedirect(reverse(self.success_url_name) + "?id=" + app_id)
def get_context_data(self):
context = dict()
context["table_list"] = []
application_id = app_id_finder(self.request)
# Accessing various records holding the necessary data dictionaries for the rows in the summary tables
personal_details_record = (NannyGatewayActions().read(
"applicant-personal-details",
params={
"application_id": application_id
}).record)
dbs_record = (NannyGatewayActions().read("dbs-check",
params={
"application_id":
application_id
}).record)
address_record = (NannyGatewayActions().read("applicant-home-address",
params={
"application_id":
application_id
}).record)
previous_address_list = NannyGatewayActions().list(
"previous-address", params={"person_id": application_id})
previous_names_list = NannyGatewayActions().list(
"previous-name", params={"application_id": application_id})
address_gaps_list = NannyGatewayActions().list(
"missing-address-gap", params={"application_id": application_id})
# Assigning all data to variables for the rows in the data tables
name = (personal_details_record["first_name"] + " " +
personal_details_record["middle_names"] + " " +
personal_details_record["last_name"])
if previous_names_list.status_code == 200:
previous_names_record = previous_names_list.record
previous_names_record.sort(key=sort_func)
birth_name_record = previous_names_record[0]
birth_name = (birth_name_record["first_name"] + " " +
birth_name_record["middle_names"] + " " +
birth_name_record["last_name"])
birth_name_start_date = datetime.datetime(
birth_name_record["start_year"],
birth_name_record["start_month"],
birth_name_record["start_day"],
)
birth_name_start_datetime = birth_name_start_date.strftime(
"%d %B %Y")
birth_name_end_date = datetime.datetime(
birth_name_record["end_year"],
birth_name_record["end_month"],
birth_name_record["end_day"],
)
birth_name_end_datetime = birth_name_end_date.strftime("%d %B %Y")
elif previous_names_list.status_code == 404:
previous_names_record = []
else:
raise Exception("Unknown response for previous names data request")
lived_abroad = dbs_record["lived_abroad"]
date_of_birth_datetime = datetime.datetime.strptime(
personal_details_record["date_of_birth"], "%Y-%m-%d")
date_of_birth = date_of_birth_datetime.strftime("%d %B %Y")
address = AddressHelper.format_address(address_record, ", ")
name_history = len(previous_names_record) >= 1
if previous_address_list.status_code == 200:
previous_address_record = previous_address_list.record
elif previous_address_list.status_code == 404:
previous_address_record = []
else:
raise Exception(
"Unknown response for previous address data request")
if address_gaps_list.status_code == 200:
address_gaps_record = address_gaps_list.record
elif address_gaps_list.status_code == 404:
address_gaps_record = []
else:
raise Exception("Unknown response for address gap data request")
# Producing all rows for data tables
"""
Parameters for the Row() function from table_util
data_name: The name of the field as stored in the database
row_name: The name of the field as rendered on the template
value: The value of the field
back_link: The view which, when reversed, redirects to the page where the value is defined
change_link_description: An optional change link textual description value
error: The error associated with the field, empty by default, only populated on table.get_errors
"""
title_row = Row(
"title",
"Title",
personal_details_record["title"],
"personal-details:Personal-Details-Name",
"your title",
)
name_row = Row(
"name",
"Your name",
name,
"personal-details:Personal-Details-Name",
"your name",
)
date_of_birth_row = Row(
"date_of_birth",
"Date of birth",
date_of_birth,
"personal-details:Personal-Details-Date-Of-Birth",
"your date of birth",
)
home_address_row = Row(
"home_address",
"Your home address",
address,
"personal-details:Personal-Details-Manual-Address",
"your home address",
)
lived_abroad_row = Row(
"lived_abroad",
"Have you lived outside of the UK in the last 5 years?",
lived_abroad,
"personal-details:Personal-Details-Lived-Abroad",
"have you lived abroad in the last 5 years",
)
previous_names_row = Row(
"known_by_other_names",
"Have you previously been known by any other names?",
name_history,
"personal-details:Personal-Details-Name-History",
"have you been know by any previous names",
)
if previous_names_list.status_code == 200:
birth_name_row = Row(
"name_history",
"Birth name",
birth_name,
"personal-details:Personal-Details-Birth-Name",
"your birth name",
)
birth_name_start_date_row = Row(
"start_date",
"Start date",
birth_name_start_datetime,
"personal-details:Personal-Details-Birth-Name",
"date birth name was used from",
)
birth_name_end_date_row = Row(
"end_date",
"End date",
birth_name_end_datetime,
"personal-details:Personal-Details-Birth-Name",
"date birth name was used until",
)
# Your name and date of birth table
name_and_dob_table = Table(application_id)
name_and_dob_table.title = "Your name and date of birth"
name_and_dob_table.row_list = [
title_row,
name_row,
date_of_birth_row,
previous_names_row,
]
name_and_dob_table.get_errors("applicant-personal-details")
context["table_list"].append(name_and_dob_table)
# Name history table
if previous_names_list.status_code == 200:
name_history_table = Table(application_id)
name_history_table.title = "Name history"
name_history_table.row_list = [
birth_name_row,
birth_name_start_date_row,
birth_name_end_date_row,
]
previous_names_record.sort(key=lambda x: datetime.datetime(
x["start_year"], x["start_month"], x["start_day"]))
for i, name in enumerate(previous_names_record[1:]):
count = i + 1
previous_name = (name["first_name"] + " " +
name["middle_names"] + " " +
name["last_name"])
previous_name_row = Row(
"previous_names",
"Previous name {}".format(count),
previous_name,
"personal-details:Personal-Details-Previous-Names",
"previous name applicant has been known by",
)
name_history_table.row_list.append(previous_name_row)
previous_name_start_date = datetime.datetime(
name["start_year"], name["start_month"], name["start_day"])
previous_name_start_datetime = previous_name_start_date.strftime(
"%d %B %Y")
previous_name_start_date_row = Row(
"start_date",
"Start date",
previous_name_start_datetime,
"personal-details:Personal-Details-Previous-Names",
"date name was used from",
)
name_history_table.row_list.append(
previous_name_start_date_row)
previous_name_end_date = datetime.datetime(
name["end_year"], name["end_month"], name["end_day"])
previous_name_end_datetime = previous_name_end_date.strftime(
"%d %B %Y")
previous_name_end_date_row = Row(
"end_date",
"End date",
previous_name_end_datetime,
"personal-details:Personal-Details-Previous-Names",
"date name was used until",
)
name_history_table.row_list.append(previous_name_end_date_row)
name_history_table.get_errors(
endpoint="applicant-personal-details")
name_history_flagged = False
if name_history_table.row_list[0].error:
name_history_flagged = True
context['name_history_flagged'] = name_history_flagged
context["table_list"].append(name_history_table)
# Your home and childcare address table
home_and_childcare_address_table = Table(application_id)
home_and_childcare_address_table.title = "Your home address"
# Older applications won't have this - only try to do stuff if the date exists
if personal_details_record["moved_in_date"]:
moved_in_date_datetime = datetime.datetime.strptime(
personal_details_record["moved_in_date"], "%Y-%m-%d").date()
moved_in_date = moved_in_date_datetime.strftime("%d %B %Y")
moved_in_date_row = Row(
"moved_in_date",
"Moved in date",
moved_in_date,
"personal-details:Personal-Details-Manual-Address",
"your current address moved in date",
)
home_and_childcare_address_table.row_list = [
home_address_row,
moved_in_date_row,
lived_abroad_row,
]
else:
home_and_childcare_address_table.row_list = [
home_address_row,
lived_abroad_row,
]
home_and_childcare_address_table.get_errors(
["applicant-personal-details", "applicant-home-address"])
context["table_list"].append(home_and_childcare_address_table)
address_history_table = None
# Address history table
if previous_address_list.status_code == 200:
address_history_table = Table(application_id)
address_history_table.title = "Address history"
address_history_table.row_list = []
previous_address_record.sort(key=lambda x: x["moved_in_date"])
for i, address in enumerate(previous_address_record):
count = i + 1
previous_address = (address["street_line1"] + ", " +
address["street_line2"] + ", " +
address["town"] + ", " +
address["postcode"])
previous_address_row = Row(
"address_history" if i == 0 else 'previous_address',
"Previous address {}".format(count),
previous_address,
"personal-details:Personal-Details-Previous-Address-Change",
"previous addresses applicant has lived at",
row_pk=address["previous_address_id"],
)
address_history_table.row_list.append(previous_address_row)
previous_address_moved_in_date = datetime.datetime.strptime(
address["moved_in_date"], "%Y-%m-%d")
previous_address_moved_in_datetime = (
previous_address_moved_in_date.strftime("%d %B %Y"))
previous_address_moved_in_row = Row(
"moved_in_date",
"Date you moved in",
previous_address_moved_in_datetime,
"personal-details:Personal-Details-Previous-Address-Change",
"date address was used from",
row_pk=address["previous_address_id"],
)
address_history_table.row_list.append(
previous_address_moved_in_row)
previous_address_moved_out_date = datetime.datetime.strptime(
address["moved_out_date"], "%Y-%m-%d")
previous_address_moved_out_datetime = (
previous_address_moved_out_date.strftime("%d %B %Y"))
previous_address_moved_out_row = Row(
"moved_out_date",
"Date you moved out",
previous_address_moved_out_datetime,
"personal-details:Personal-Details-Previous-Address-Change",
"date address was used until",
row_pk=address["previous_address_id"],
)
address_history_table.row_list.append(
previous_address_moved_out_row)
if address_gaps_list.status_code == 200:
if not address_history_table:
address_history_table = Table(application_id)
address_history_table.title = "Address history"
address_history_table.row_list = []
address_gaps_record.sort(key=lambda x: datetime.datetime(
x["moved_in_year"], x["moved_in_month"], x["moved_in_day"]))
for i, gap in enumerate(address_gaps_record):
count = i + 1
address_gap = gap["gap_reason"]
address_gap_row = Row(
"previous_address_gap",
"Previous address gap {}".format(count),
address_gap,
"personal-details:Personal-Details-Address-Gap-Change",
"gaps in the applicants previous address history",
row_pk=gap["missing_address_gap_id"],
)
address_history_table.row_list.append(address_gap_row)
address_gap_start_date = datetime.datetime(
gap["moved_in_year"], gap["moved_in_month"],
gap["moved_in_day"])
address_gap_start_datetime = address_gap_start_date.strftime(
"%d %B %Y")
address_gap_start_date_row = Row(
"gap_start_date",
"Start date",
address_gap_start_datetime,
"personal-details:Personal-Details-Address-Gap-Change",
"beginning of gap in applicant's address history",
row_pk=gap["missing_address_gap_id"],
)
address_history_table.row_list.append(
address_gap_start_date_row)
address_gap_end_date = datetime.datetime(
gap["moved_out_year"], gap["moved_out_month"],
gap["moved_out_day"])
address_gap_end_datetime = address_gap_end_date.strftime(
"%d %B %Y")
address_gap_end_date_row = Row(
"gap_end_date",
"End date",
address_gap_end_datetime,
"personal-details:Personal-Details-Address-Gap-Change",
"end of gap in applicant's address history",
row_pk=gap["missing_address_gap_id"],
)
address_history_table.row_list.append(address_gap_end_date_row)
if address_history_table:
address_history_table.get_errors("applicant-personal-details")
context["table_list"].append(address_history_table)
context[
'address_history_flagged'] = True if address_history_table.row_list[
0].error else False
# Building the remaining context dictionary
context["id"] = application_id
context["application_id"] = application_id
context["page_title"] = "Check your answers: your personal details"
return context
