def get_context_data(self, **kwargs):
context = super(PersonalDetailSelectPreviousAddressView,
self).get_context_data(**kwargs)
app_id = app_id_finder(self.request)
state = self.request.GET.get('state')
prev_address_response = NannyGatewayActions().list(
'previous-address', params={'person_id': app_id})
if prev_address_response.status_code == 200:
previous_address = []
for prev_address in prev_address_response.record:
if prev_address.get('street_line1') != '':
prev_address['moved_in_date'] = datetime.datetime.strptime(
prev_address['moved_in_date'], '%Y-%m-%d').date()
prev_address[
'moved_out_date'] = datetime.datetime.strptime(
prev_address['moved_out_date'], '%Y-%m-%d').date()
previous_address.append(prev_address)
context['previous_addresses'] = previous_address
app_id = app_id_finder(self.request)
context['id'] = app_id
application_record = NannyGatewayActions().read('application',
params={
'application_id':
app_id
}).record
context['personal_details_status'] = application_record[
'personal_details_status']
postcode = context['form'].initial['postcode']
context['postcode'] = postcode
context['hide_form'] = state == 'hidden'
return context
def form_valid(self, form):
application_id = self.request.GET['id']
nanny_api_response = NannyGatewayActions().read(
'childcare-training', params={'application_id': application_id})
if nanny_api_response.status_code == 404:
nanny_api_response = self.create_childcare_training_record()
record = nanny_api_response.record
childcare_training = form.cleaned_data['childcare_training']
for option, option_text in TypeOfChildcareTrainingForm.options:
if option in childcare_training:
record[option] = True
else:
record[option] = False
put_response = NannyGatewayActions().put('childcare-training',
params=record)
if record[
'no_training']: # If they have selected only 'No training' (wouldn't pass validation otherwise)
self.success_url = 'Childcare-Training-Course'
if put_response.status_code == 200:
return super(TypeOfChildcareTrainingFormView,
self).form_valid(form)
else:
if settings.DEBUG:
raise RuntimeError(
'The Nanny-Gateway API did not update the record as expected.'
)
else:
HttpResponseRedirect(reverse('Service-Unavailable'))
def form_valid(self, form):
app_id = app_id_finder(self.request)
api_response = NannyGatewayActions().list('previous-address',
params={
'person_id': app_id,
'order': '0'
})
if api_response.status_code == 200:
record = api_response.record[0]
NannyGatewayActions().delete('previous-address',
params={
'previous_address_id':
record['previous_address_id']
}) # Update entire record.
else:
record = {}
record['person_id'] = app_id
record['street_line1'] = form.cleaned_data['street_line1']
record['street_line2'] = form.cleaned_data['street_line2']
record['town'] = form.cleaned_data['town']
record['postcode'] = form.cleaned_data['postcode']
record['county'] = form.cleaned_data.get('county')
record['country'] = form.cleaned_data.get('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)
return super().form_valid(form)
def form_valid(self, form):
application_id = self.request.GET['id']
record = IdentityGatewayActions().read('user',
params={
'application_id':
application_id
}).record
record['sms_resend_attempts'] = 0
record['email_expiry_date'] = 0
IdentityGatewayActions().put('user', params=record)
response = login_redirect_helper.redirect_by_status(
record['application_id'])
CustomAuthenticationHandler.create_session(response,
{'email': record['email']})
# Update last accessed time when successfully signed in
nanny_actions = NannyGatewayActions()
app_response = nanny_actions.read(
'application', params={'application_id': application_id})
if app_response.status_code == 200 and hasattr(app_response, 'record'):
# application might not exist yet, if user signed out before completing contact details task
application = app_response.record
application['date_last_accessed'] = datetime.datetime.now()
application['application_expiry_email_sent'] = False
nanny_actions.put('application', application)
return response
def form_valid(self, formset):
application_id = app_id_finder(self.request)
if not formset.is_valid():
# If invalid, render same page with errors and stop
context = self.get_context_data()
context["formset"] = formset
return render(self.request, self.template_name, context)
self._save_and_replace_previous_names(application_id, formset)
if self.request.POST["action"] == "Add another name":
return self._previous_names_page_redirect(application_id,
show_extra=True)
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)
return super().form_valid(formset)
def _save_and_replace_previous_names(self, app_id, formset):
previous_names = NannyGatewayActions().list(
"previous-name", params={"application_id": app_id})
previous_names.record.sort(key=sort_func)
if previous_names.status_code == 200:
for j in range(1, len(previous_names.record)):
NannyGatewayActions().delete(
"previous-name",
params={
"previous_name_id":
previous_names.record[j]["previous_name_id"]
},
)
for i, form in enumerate(formset):
NannyGatewayActions().create(
"previous-name",
params={
"application_id": app_id,
"first_name": form.cleaned_data["first_name"],
"middle_names": form.cleaned_data["middle_names"],
"last_name": form.cleaned_data["last_name"],
"start_day": form.cleaned_data["start_date"].day,
"start_month": form.cleaned_data["start_date"].month,
"start_year": form.cleaned_data["start_date"].year,
"end_day": form.cleaned_data["end_date"].day,
"end_month": form.cleaned_data["end_date"].month,
"end_year": form.cleaned_data["end_date"].year,
"order": i + 1,
},
)
def post(self, request):
app_id = request.GET['id']
api_response = NannyGatewayActions().read(
'application', params={'application_id': app_id})
api_response.record['childcare_address_status'] = 'COMPLETED'
NannyGatewayActions().put('application', params=api_response.record)
return HttpResponseRedirect(build_url('Task-List', get={'id': app_id}))
def get_success_url(self):
application_id = app_id_finder(self.request)
if self.request.POST["name_history"] == "True":
success_url = "personal-details:Personal-Details-Birth-Name"
elif self.request.POST["name_history"] == "False":
response = NannyGatewayActions().list(
"previous-name", params={"application_id": application_id}
)
if response.status_code == 200:
for prev_name in response.record:
NannyGatewayActions().delete(
"previous-name",
params={"previous_name_id": prev_name["previous_name_id"]},
)
success_url = "personal-details:Personal-Details-Home-Address"
else:
raise ValueError(
"Invalid response passed to the name_history view from the Name history question in Nanny"
)
url = build_url(success_url, get=self.get_success_parameters())
return url
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)
data_dict = {
'application_id':
application_id,
'suitability_circumstances_details':
form.cleaned_data["suitability_circumstances_details"],
}
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
previous_address_id = self.request.GET.get('address_id')
api_response = NannyGatewayActions().read(
'previous-address',
params={'previous_address_id': previous_address_id})
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']
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['country'] = api_response.record['country']
initial['postcode'] = api_response.record['postcode']
initial['moved_in_date'] = datetime.datetime.strptime(
api_response.record['moved_in_date'], '%Y-%m-%d').date()
initial['moved_out_date'] = datetime.datetime.strptime(
api_response.record['moved_out_date'], '%Y-%m-%d').date()
return initial
def form_valid(self, form):
app_id = app_id_finder(self.request)
previous_address_id = self.request.POST.get('address_id')
api_response = NannyGatewayActions().read(
'previous-address',
params={'previous_address_id': previous_address_id})
street_line1 = form.cleaned_data['street_line1']
street_line2 = form.cleaned_data['street_line2']
town = form.cleaned_data['town']
county = form.cleaned_data['county']
country = form.cleaned_data.get('country', None)
postcode = form.cleaned_data['postcode']
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['street_line1'] = street_line1
record['street_line2'] = street_line2
record['town'] = town
record['county'] = county
record['country'] = country
record['postcode'] = postcode
record['moved_in_date'] = moved_in_date
record['moved_out_date'] = moved_out_date
NannyGatewayActions().put('previous-address', params=record)
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
application_record['first_aid_status'] = 'IN_PROGRESS'
NannyGatewayActions().put('application', params=application_record)
data_dict = {
'application_id':
application_id,
'training_organisation':
escape(form.cleaned_data['training_organisation']),
'course_title':
escape(form.cleaned_data['course_title']),
'course_date':
form.cleaned_data['course_date'],
}
existing_record = NannyGatewayActions().read(
'first-aid', params={'application_id': application_id})
if existing_record.status_code == 200:
NannyGatewayActions().patch('first-aid', params=data_dict)
elif existing_record.status_code == 404:
NannyGatewayActions().create('first-aid', params=data_dict)
if self.__first_aid_renew(form):
self.success_url = "first-aid:First-Aid-Renew"
else:
self.success_url = "first-aid:First-Aid-Declaration"
return super().form_valid(form)
def get_success_url(self):
application_id = app_id_finder(self.request)
existing_name_records = NannyGatewayActions().list(
"previous-name", params={"application_id": application_id})
names = existing_name_records.record
names.sort(key=sort_func)
previous_names = names[1:]
previous_name_ids = []
for prev_name in previous_names:
prev_name_id = prev_name["previous_name_id"]
previous_name_ids.append(prev_name_id)
if self.request.POST["previous_name"] == "True":
success_url = "personal-details:Personal-Details-Previous-Names"
elif self.request.POST["previous_name"] == "False":
for i in previous_name_ids:
NannyGatewayActions().delete("previous-name",
params={"previous_name_id": i})
success_url = "personal-details:Personal-Details-Name-history-summary"
else:
raise ValueError(
"Invalid response passed to the name_history view from the Name history question in Nanny"
)
url = build_url(success_url, get=self.get_success_parameters())
return url
def get_success_url(self):
application_id = app_id_finder(self.request)
if self.request.POST["gaps_in_five_year_address_history"] == "True":
self.success_url = "personal-details:Personal-Details-Address-Gap-Entry"
else:
response = NannyGatewayActions().list(
"missing-address-gap", params={"application_id": application_id}
)
if response.status_code == 200:
for gap in response.record:
NannyGatewayActions().delete(
"missing-address-gap",
params={
"missing_address_gap_id": gap["missing_address_gap_id"]
},
)
self.success_url = (
"personal-details:Personal-Details-Previous-Address-Summary"
)
url = super(
PersonalDetailGapsInFiveYearAddressHistoryView, self
).get_success_url()
return url
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)
data_dict = {
"application_id":
application_id,
"disqualification_details":
form.cleaned_data["disqualification_details"],
}
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 if_name(self, application_id, field, enabled, pk=None):
"""
This checks if a name has been flagged, as first, middle or last cannot be flagged individually.
It will be called on every field during the call to check_flags and remove_flags.
:param field: The name of the field with which to query the database.
:param enabled: Specify if you are setting the 'flagged' column to True or False.
:return: None
"""
if field in ("first_name", "middle_names", "last_name"):
query_params = {
"application_id": application_id,
"field_name": "name",
"table_pk": self.get_pk(pk),
}
arc_comments_filter = NannyGatewayActions().list(
"arc-comments", params=query_params)
if arc_comments_filter.status_code == 200 and bool(
arc_comments_filter.record[0]["flagged"]):
if enabled and field == "first_name":
comment = arc_comments_filter.record[0]["comment"]
self.cleaned_data = ""
self.add_error(field, forms.ValidationError(comment))
elif enabled and field != "first_name":
self.add_error(field, forms.ValidationError(""))
else:
arc_record = arc_comments_filter.record[0]
arc_record["flagged"] = False
NannyGatewayActions().put("arc-comments",
params=arc_record)
def _get_current_adress_info(context, application_id):
home_address_response = NannyGatewayActions().read(
"applicant-home-address", params={"application_id": application_id}
)
if home_address_response.status_code == 200:
home_address = home_address_response.record
person_details_response = NannyGatewayActions().read(
"applicant-personal-details", params={"application_id": application_id}
)
if person_details_response.status_code == 200:
moved_in = person_details_response.record["moved_in_date"]
dbs_response = NannyGatewayActions().read(
"dbs-check", params={"application_id": application_id}
)
if dbs_response.status_code == 200:
lived_abroad = dbs_response.record["lived_abroad"]
context["current_address"] = _get_full_address(home_address)
context["current_address_moved_in"] = datetime.datetime.strptime(
moved_in, "%Y-%m-%d"
)
context["lived_abroad"] = lived_abroad
return context
def post(self, request, *args, **kwargs):
application_id = self.request.POST.get('id')
master_summary = self.request.POST.get('master-summary')
hide_form = self.request.GET.get('state')
delete_action = ([
k for k, v in self.request.POST.items() if k.startswith('remove-')
] + [None])[0]
if delete_action is not None:
# param name in the form 'remove-[id]'
delete_id = delete_action[len('remove-'):]
# id will be blank if user is removing the new, empty form. Can safely ignore
if delete_id != '':
response = NannyGatewayActions().delete(
'previous-address',
params={'previous_address_id': delete_id})
return HttpResponseRedirect(
build_url('personal-details:Personal-Details-Previous-Address',
get={
'id': application_id,
'master-summary': master_summary,
'state': hide_form
}))
if hide_form == 'hidden':
api_response = NannyGatewayActions().list('previous-address',
params={
'person_id':
application_id,
'order': '0'
})
if api_response.status_code == 200:
NannyGatewayActions().delete('previous-address',
params=api_response.record[0])
return HttpResponseRedirect(
build_url(
'personal-details:Personal-Details-Gaps-In-Address-History',
get={
'id': request.POST['id'],
'summary': master_summary
}))
if 'delete-active' in request.POST:
return HttpResponseRedirect(
build_url('personal-details:Personal-Details-Previous-Address',
get={
'id': request.POST['id'],
'state': 'hidden',
'summary': master_summary
}))
form = self.get_form()
if form.is_valid():
return self.form_valid(form)
else:
return self.form_invalid(form)
def _get_previous_gaps_and_adresses_info(application_id):
previous_adresses_and_gaps = []
previous_adresses_response = NannyGatewayActions().list(
"previous-address", params={"person_id": application_id}
)
previous_adresses = None
if previous_adresses_response.status_code == 200:
previous_adresses = previous_adresses_response.record
if previous_adresses:
for index, address in enumerate(previous_adresses):
temp_address = dict()
temp_address["type"] = "adress"
temp_address["index"] = index + 1
temp_address["description"] = _get_full_address(address)
temp_address["start_date"] = datetime.datetime.strptime(
address["moved_in_date"], "%Y-%m-%d"
)
temp_address["end_date"] = datetime.datetime.strptime(
address["moved_out_date"], "%Y-%m-%d"
)
temp_address['id'] = address["previous_address_id"]
previous_adresses_and_gaps.append(temp_address)
previous_gaps_response = NannyGatewayActions().list(
"missing-address-gap", params={"application_id": application_id}
)
previous_gaps = None
if previous_gaps_response.status_code == 200:
previous_gaps = previous_gaps_response.record
if previous_gaps:
for index, gap in enumerate(previous_gaps):
temp_gap = dict()
temp_gap["type"] = "gap"
temp_gap["index"] = index + 1
temp_gap["description"] = gap["gap_reason"]
temp_gap["start_date"] = datetime.datetime.strptime(
_convert_to_full_date(
gap["moved_in_day"],
gap["moved_in_month"],
gap["moved_in_year"],
),
"%Y-%m-%d",
)
temp_gap["end_date"] = datetime.datetime.strptime(
_convert_to_full_date(
gap["moved_out_day"],
gap["moved_out_month"],
gap["moved_out_year"],
),
"%Y-%m-%d",
)
temp_gap['id'] = gap["missing_address_gap_id"]
previous_adresses_and_gaps.append(temp_gap)
return previous_adresses_and_gaps
def form_valid(self, form):
app_id = app_id_finder(self.request)
api_response = NannyGatewayActions().read('applicant-home-address', params={'application_id': app_id})
street_line1 = form.cleaned_data['street_line1']
street_line2 = form.cleaned_data['street_line2']
town = form.cleaned_data['town']
county = form.cleaned_data['county']
postcode = form.cleaned_data['postcode']
moved_in_date = form.cleaned_data['moved_in_date']
if form.cleaned_data['moved_in_date'] <= subtract_years(datetime.today().date(), 5):
response = NannyGatewayActions().list('previous-address', params={'person_id': app_id})
if response.status_code == 200:
for prev_address in response.record:
NannyGatewayActions().delete('previous-address',
params={'previous_address_id': prev_address['previous_address_id']})
response = NannyGatewayActions().list('missing-address-gap', params={'application_id': app_id})
if response.status_code == 200:
for prev_address_gap in response.record:
NannyGatewayActions().delete('missing-address-gap',
params={'missing_address_gap_id': prev_address_gap['missing_address_gap_id']})
# update the address record if it already existed
if api_response.status_code == 200:
record = api_response.record
record['street_line1'] = street_line1
record['street_line2'] = street_line2
record['town'] = town
record['county'] = county
record['postcode'] = postcode
NannyGatewayActions().put('applicant-home-address', params=record)
# create the address record if it didn't exist
elif api_response.status_code == 404:
apd_response = NannyGatewayActions().read('applicant-personal-details', params={'application_id': app_id})
if apd_response.status_code == 200:
pd_id = apd_response.record['personal_detail_id']
NannyGatewayActions().create(
'applicant-home-address',
params={
'application_id': app_id,
'personal_detail_id': pd_id,
'street_line1': street_line1,
'street_line2': street_line2,
'town': town,
'county': county,
'postcode': postcode,
}
)
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
record['moved_in_date'] = str(moved_in_date)
NannyGatewayActions().put('applicant-personal-details', params=record)
return super().form_valid(form)
def form_valid(self, form):
application_id = self.request.GET['id']
criminal_checks_record = NannyGatewayActions().read('dbs-check', params={'application_id': application_id}).record
criminal_checks_record['dbs_number'] = form.cleaned_data['dbs_number']
NannyGatewayActions().put('dbs-check', params=criminal_checks_record)
return super(NonCapitaDBSDetailsFormView, self).form_valid(form)
def get_context_data(self, **kwargs):
context = super().get_context_data()
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:
context['address'] = AddressHelper.format_address(api_response.record, ", ")
context['id'] = app_id
application_record = NannyGatewayActions().read('application', params={'application_id': app_id}).record
context['personal_details_status'] = application_record['personal_details_status']
return context
def post(self, request):
application_id = request.GET['id']
record = NannyGatewayActions().read('application',
params={
'application_id':
application_id
}).record
record['childcare_training_status'] = 'COMPLETED'
NannyGatewayActions().put('application', params=record)
return HttpResponseRedirect(
reverse('Task-List') + '?id=' + application_id)
def post(self, request):
application_id = request.GET['id']
record = NannyGatewayActions().read('application',
params={
'application_id':
application_id
}).record
record['childcare_training_status'] = 'IN_PROGRESS'
NannyGatewayActions().put('application', params=record)
return HttpResponseRedirect(
reverse('Childcare-Training-Summary') + '?id=' + application_id)
def post(self, request):
app_id = app_id_finder(self.request)
# update task status to be done
app_api_response = NannyGatewayActions().read(
'application', params={'application_id': app_id})
if app_api_response.status_code == 200:
record = app_api_response.record
record['insurance_cover_status'] = 'COMPLETED'
NannyGatewayActions().put('application', params=record)
return HttpResponseRedirect(build_url('Task-List', get={'id': app_id}))
def form_valid(self, form):
api_response = NannyGatewayActions().read(
'dbs-check', params={'application_id': self.request.GET['id']})
criminal_checks_record = api_response.record
criminal_checks_record['on_dbs_update_service'] = self.request.POST[
'on_dbs_update_service']
NannyGatewayActions().put('dbs-check', params=criminal_checks_record)
return super(DBSUpdateServiceFormView, self).form_valid(form)
def post(self, request):
application_id = self.request.POST['id']
application_record = NannyGatewayActions().read('application',
params={
'application_id':
application_id
}).record
application_record['first_aid_status'] = 'COMPLETED'
NannyGatewayActions().put('application', params=application_record)
return HttpResponseRedirect(
build_url(self.success_url_name, get={'id': application_id}))
def form_valid(self, form):
# pull the applicant's home address from their personal details
app_id = self.request.GET['id']
both_work_and_home_address = None
if form.cleaned_data['both_work_and_home_address'] == 'True':
both_work_and_home_address = True
self.success_url = 'Childcare-Address-Details'
elif form.cleaned_data['both_work_and_home_address'] == 'False':
both_work_and_home_address = False
self.success_url = 'Childcare-Address-Postcode-Entry'
childcare_address_changed_to_false = self.__check_childcare_address_changed_to_false(app_id,
both_work_and_home_address)
apd_api_response = NannyGatewayActions().read('applicant-personal-details', params={'application_id': app_id})
if apd_api_response.status_code == 200:
personal_detail_id = apd_api_response.record['personal_detail_id']
aha_api_response = NannyGatewayActions().read('applicant-home-address', params={'application_id': app_id})
if aha_api_response.status_code == 200:
home_address_record = aha_api_response.record
initial_both_work_and_home_address = home_address_record['childcare_address']
home_address_record['childcare_address'] = both_work_and_home_address
NannyGatewayActions().put('applicant-home-address', params=home_address_record)
# add new childcare address
if both_work_and_home_address and not initial_both_work_and_home_address:
NannyGatewayActions().create(
'childcare-address',
params={
'date_created': datetime.today(),
'application_id': app_id,
'street_line1': home_address_record['street_line1'],
'street_line2': home_address_record['street_line2'],
'town': home_address_record['town'],
'county': home_address_record['county'],
'country': home_address_record['country'],
'postcode': home_address_record['postcode'],
'home_address': True
}
)
if childcare_address_changed_to_false:
# Delete all childcare addresses that are the same as the Applicant's home address.
self.__delete_home_childcare_addresses(app_id)
redirect_url = build_url('Childcare-Address-Postcode-Entry', get={'id': app_id, 'add': '1'})
return HttpResponseRedirect(redirect_url)
return super(ChildcareLocationView, self).form_valid(form)
def post(self, request):
application_id = app_id_finder(request)
application_record = (NannyGatewayActions().read("application",
params={
"application_id":
application_id
}).record)
application_record["personal_details_status"] = "COMPLETED"
NannyGatewayActions().put("application", params=application_record)
return HttpResponseRedirect(
build_url(self.success_url_name, get={"id": application_id}))
def post(self, request):
app_id = request.POST['id']
# update the task status to be done
api_response = NannyGatewayActions().read(
'application',
params={
'application_id': app_id
}
)
api_response.record['childcare_address_status'] = 'COMPLETED'
NannyGatewayActions().put('application', params=api_response.record)
return HttpResponseRedirect(reverse('Task-List') + "?id=" + app_id)
