def modify_land_charge_confirm():
current_app.logger.info("Endpoint called - Updating charge")
AuditAPIService.audit_event(
"Vary request submitted.",
supporting_info={
'id': calc_display_id(g.session.add_charge_state.local_land_charge)
})
if g.session.charge_added_outside_users_authority:
AuditAPIService.audit_event(
"Charge location varied, extent(s) modified to be outside users authority.",
supporting_info={
'originating-authority': g.session.user.organisation,
'id':
calc_display_id(g.session.add_charge_state.local_land_charge)
})
if g.session.other_authority_update_permission:
AuditAPIService.audit_event(
"Charge location varied, extent(s) modified on a charge outside users authority.",
supporting_info={
'originating-authority': g.session.user.organisation,
'id':
calc_display_id(g.session.add_charge_state.local_land_charge)
})
MaintainApiService.update_charge(g.session.add_charge_state)
charge_id = calc_display_id(g.session.add_charge_state.local_land_charge)
g.session.add_charge_state = None
g.session.edited_fields = None
g.session.charge_added_outside_users_authority = None
g.session.other_authority_update_permission = None
g.session.other_authority_cancel_permission = None
g.session.commit()
current_app.logger.info("Charge removed from session - Rendering Template")
return render_template('modify_confirmation.html', charge_id=charge_id)
def update_charge(land_charge):
current_app.logger.info("Attempting to update a charge")
try:
# Update Author Information
land_charge.author = g.session.user.get_author_info()
charge_json = land_charge.to_json()
headers = {
'Content-Type': 'application/json',
'X-Trace-ID': g.trace_id
}
current_app.logger.info(
"Putting to maintain-api/local-land-charge/{}".format(
charge_json['local-land-charge']))
response = g.requests.put('{}/local-land-charge/{}'.format(
MAINTAIN_API_URL, charge_json['local-land-charge']),
json=charge_json,
headers=headers)
except Exception as ex:
error_message = 'Failed to send land charge to maintain-api. ' \
'TraceID : {} - Exception - {}' \
.format(g.trace_id, ex)
current_app.logger.exception(error_message)
AuditAPIService.audit_event(
"Failed to send land charge to maintain-api",
supporting_info={
'id': calc_display_id(land_charge.local_land_charge)
})
raise ApplicationError(500)
if response.status_code != 202:
current_app.logger.exception(
'Failed to send land charge to maintain-api. '
'TraceID : {} - Status: {}, Message: {}'.format(
g.trace_id, response.status_code, response.text))
AuditAPIService.audit_event(
"Failed to send land charge to maintain-api",
supporting_info={
'id': calc_display_id(land_charge.local_land_charge)
})
raise ApplicationError(500)
result = response.json()
current_app.logger.info(
"User ID '{}' updated charge {}. Entry number: {}, registration date: {}. TraceID={}"
.format(g.session.user.id, result['land_charge_id'],
result['entry_number'], result['registration_date'],
g.trace_id))
last_charge = LastCreatedCharge()
last_charge.charge_id = result['land_charge_id']
last_charge.entry_number = result['entry_number']
last_charge.registration_date = datetime.strptime(
result['registration_date'], "%Y-%m-%d").strftime("%d/%m/%Y")
g.session.last_created_charge = last_charge
g.session.commit()
def modify_lon_details_get(charge_id):
current_app.logger.info(
"Endpoint called with charge_id='{}'".format(charge_id))
# If the charge not in session, redirect to initial upload screen
if not g.session.add_lon_charge_state:
return redirect(
url_for("modify_lon.modify_lon_upload_get", charge_id=charge_id))
session_charge_id = calc_display_id(
g.session.add_lon_charge_state.local_land_charge)
# Check that charge ID in session and URL match.
# If they don't, redirect user to the charge ID they entered and clear session
if session_charge_id != charge_id:
g.session.add_lon_charge_state = None
g.session.commit()
return redirect(
url_for("modify_lon.modify_lon_upload_get", charge_id=charge_id))
# Retrieve Light Obstruction Notice Item
local_land_charge_service = LocalLandChargeService(current_app.config)
charge_item = g.session.add_lon_charge_state
updated, updated_date = get_history_update_info_by_charge_id(
charge_id, local_land_charge_service)
return render_template("modify_lon_details.html",
charge_id=charge_id,
charge_item=charge_item,
updated=updated,
updated_date=updated_date,
geometry=json.dumps(charge_item.geometry))
def post_financial_charge():
current_app.logger.info("Endpoint called")
if g.session.add_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
amount_secured = NumberConverter.format_number_string(request.form.get(
'amount-secured', ''),
leading_char='£',
force_two_dp=True)
interest_paid_indicator = request.form.get('interest-paid-indicator', '')
interest_rate = request.form.get('interest-rate', '')
current_app.logger.info("Running validation")
validation_errors = FinancialChargeDetailsValidator.validate(
amount_secured, interest_paid_indicator, interest_rate)
if validation_errors.errors:
current_app.logger.warning("Validation errors occurred")
return render_template(
'financial_charge_details.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
request_body=request.form,
submit_url=url_for(
'modify_land_charge.post_financial_charge')), 400
if interest_paid_indicator == "No":
interest_rate = NO_INTEREST_IS_PAYABLE
current_app.logger.info(
"Updating session object with charge amount: '%s' and no interest rate",
amount_secured)
edited = False
if has_value_changed(g.session.add_charge_state.amount_originally_secured,
amount_secured):
g.session.add_charge_state.amount_originally_secured = amount_secured
g.session.edited_fields.append('amount_originally_secured')
edited = True
if has_value_changed(g.session.add_charge_state.rate_of_interest,
interest_rate):
g.session.add_charge_state.rate_of_interest = interest_rate
g.session.edited_fields.append('rate_of_interest')
edited = True
if edited:
g.session.commit()
charge_display_id = calc_display_id(
g.session.add_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_display_id))
def post_expiry():
current_app.logger.info("Endpoint called")
if g.session.add_charge_state is None:
current_app.logger.error("Charge state not found in session - Returning error")
raise ApplicationError(500)
does_charge_expire = request.form.get('does_charge_expire', '')
charge_expiry_day = request.form.get('charge_expiry_day', '')
charge_expiry_month = request.form.get('charge_expiry_month', '')
charge_expiry_year = request.form.get('charge_expiry_year', '')
current_app.logger.info("Validating expiry information")
validation_errors = ExpiryValidator.validate(
does_charge_expire,
charge_expiry_day,
charge_expiry_month,
charge_expiry_year
)
if validation_errors.errors:
current_app.logger.warning("Validation errors present - Rendering page with validation errors")
return render_template(
'expiry.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
request_body=request.form,
submit_url=url_for('modify_land_charge.post_expiry')
), 400
current_app.logger.info("Field values validated - Updating session charge")
charge_expiry_date = None
edited = False
if does_charge_expire == 'yes':
if charge_expiry_day and charge_expiry_month and charge_expiry_year:
charge_expiry_date = datetime.date(
int(charge_expiry_year),
int(charge_expiry_month),
int(charge_expiry_day)
)
if g.session.add_charge_state.expiry_date is None \
or g.session.add_charge_state.expiry_date != charge_expiry_date:
edited = True
g.session.add_charge_state.expiry_date = charge_expiry_date
else:
if g.session.add_charge_state.expiry_date is not None:
edited = True
g.session.add_charge_state.expiry_date = None
if edited:
g.session.edited_fields.append('expiry_date')
g.session.commit()
charge_disp_id = calc_display_id(g.session.add_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_disp_id)
)
return redirect(url_for("modify_land_charge.modify_land_charge", local_land_charge=charge_disp_id))
def edit_servient_structure_position_post():
if g.session.add_lon_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
extent = request.form.get('extent')
part_extent_detail = request.form.get('part_extent_detail')
validation_error_builder = ServientStructurePositionValidator.validate(
extent, part_extent_detail)
if validation_error_builder.errors:
current_app.logger.warning("Validation errors occurred")
return render_template(
'servient_structure_position.html',
validation_errors=validation_error_builder.errors,
validation_summary_heading=validation_error_builder.
summary_heading_text,
submit_url=url_for(
'modify_lon.edit_servient_structure_position_post'),
request_body=request.form), 400
position_and_dimension = g.session.add_lon_charge_state.structure_position_and_dimension
edited = False
if extent == "All of the extent":
if 'part-explanatory-text' in position_and_dimension:
edited = True
del (position_and_dimension['part-explanatory-text'])
else:
if position_and_dimension["extent-covered"] != extent\
or 'part-explanatory-text' in position_and_dimension \
and position_and_dimension["part-explanatory-text"] != part_extent_detail:
edited = True
position_and_dimension["part-explanatory-text"] = part_extent_detail
position_and_dimension['extent-covered'] = extent
if edited:
g.session.add_lon_charge_state.structure_position_and_dimension = position_and_dimension
g.session.edited_fields[
'structure-position'] = 'Extent - planned development'
g.session.commit()
charge_display_id = calc_display_id(
g.session.add_lon_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_lon.modify_lon_details_get",
charge_id=charge_display_id))
def post_update_location_confirmation():
current_app.logger.info('Endpoint called')
if g.session.add_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
if g.session.add_charge_state.geometry is None:
current_app.logger.error(
"Geometry not found in session - Returning error")
raise ApplicationError(500)
confirmation = request.form.get('location-confirmation')
current_app.logger.info('Running validation')
validation_errors = LocationConfirmationValidator.validate(
confirmation, 'update')
if validation_errors.errors:
current_app.logger.warning('Validation errors occurred')
return render_template(
'update_location_confirmation.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
submit_url=url_for(
'modify_land_charge.post_update_location_confirmation'),
charge_id=calc_display_id(
g.session.add_charge_state.local_land_charge)), 400
g.session.other_authority_update_permission = True
g.session.commit()
charge_display_id = calc_display_id(
g.session.add_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_display_id))
def post_additional_info():
current_app.logger.info("Endpoint called")
if g.session.add_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
information = request.form['additional-info'].strip()
reference = request.form['reference'].strip()
current_app.logger.info("Validating information and reference")
validation_errors = AddChargeAdditionalInfoValidator.validate(
information, reference)
if validation_errors.errors:
current_app.logger.warning(
"Validation errors present - Rendering page with validation errors"
)
return render_template(
'additional_info.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
information=information,
reference=reference,
source_information_list=get_source_information_list(),
submit_url=url_for('modify_land_charge.post_additional_info')), 400
current_app.logger.info("Field values validated - Updating session charge")
edited = False
if has_value_changed(
g.session.add_charge_state.further_information_location,
information):
g.session.add_charge_state.further_information_location = information
edited = True
if has_value_changed(
g.session.add_charge_state.further_information_reference,
reference):
g.session.add_charge_state.further_information_reference = reference
edited = True
if edited:
g.session.edited_fields.append('further_information')
g.session.commit()
charge_disp_id = calc_display_id(
g.session.add_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_disp_id))
return redirect(
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_disp_id))
def test_modify_confirm_charge_outside_authority(self,
mock_maintain_api_service,
mock_audit):
self.client.set_cookie('localhost', Session.session_cookie_name,
'cookie_value')
self.mock_session.return_value.user.permissions = [
Permissions.vary_llc
]
self.mock_session.return_value.user.organisation = 'test org'
self.mock_session.return_value.charge_added_outside_users_authority = True
self.mock_session.return_value.other_authority_update_permission = False
state = LocalLandChargeItem.from_json(local_land_charge_1)
self.mock_session.return_value.add_charge_state = state
response = self.client.post(
url_for('modify_land_charge.modify_land_charge_confirm'))
self.assert_status(response, 200)
self.assert_template_used('modify_confirmation.html')
self.assert_context(
'charge_id',
'LLC-{}'.format(local_land_charge_1['local-land-charge']))
expected_call = [
call("Vary request submitted.",
supporting_info={
'id':
calc_display_id(local_land_charge_1['local-land-charge'])
}),
call(
"Charge location varied, extent(s) modified to be outside users authority.",
supporting_info={
'originating-authority':
self.mock_session.return_value.user.organisation,
'id':
calc_display_id(local_land_charge_1['local-land-charge'])
})
]
mock_audit.audit_event.assert_has_calls(expected_call)
def edit_lon_land_interest_post():
if g.session.add_lon_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
# Different validation and error messages are required for other instead of the existing options.
land_interest = request.form.get("servient-land-interest-description")
if land_interest == "Other":
land_interest = request.form.get("servient-land-interest-detail")
validation_error_builder = ValidationErrorBuilder()
FieldValidator(land_interest, 'servient-land-interest-detail', 'Land Interest', validation_error_builder,
summary_message="There are errors on the page. Describe the interest in land",
inline_message="Explain how the person applying for the light obstruction notice "
"owns or uses the land") \
.is_required()
checked = "Other"
else:
validation_error_builder = ValidationErrorBuilder()
FieldValidator(land_interest, 'servient-land-interest-description', 'Land Interest', validation_error_builder,
summary_message="Choose one",
inline_message="Choose one") \
.is_required()
checked = request.form.get("servient-land-interest-description")
if validation_error_builder.errors:
current_app.logger.warning("Validation errors occurred")
return render_template(
'lon_land_interest.html',
submit_url=url_for("modify_lon.edit_lon_land_interest_post"),
validation_errors=validation_error_builder.errors,
validation_summary_heading=validation_error_builder.
summary_heading_text,
checked=checked,
request_body=land_interest), 400
if g.session.add_lon_charge_state.servient_land_interest_description != land_interest:
g.session.add_lon_charge_state.servient_land_interest_description = land_interest
g.session.edited_fields[
'servient-land-interest-description'] = 'Interest'
g.session.commit()
charge_display_id = calc_display_id(
g.session.add_lon_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_lon.modify_lon_details_get",
charge_id=charge_display_id))
def test_post_selected_address_successful(self):
self.client.set_cookie('localhost', Session.session_cookie_name, 'cookie_value')
state = LocalLandChargeItem()
state.local_land_charge = 1
self.mock_session.return_value.add_charge_state = state
self.mock_session.return_value.user.permissions = [Permissions.vary_llc]
response = self.client.post(url_for(POST_ADDRESS_CONFIRMATION), data={
'has-address': 'ProvideAddress',
'selected-address': json.dumps(VALID_ADDRESS)
})
self.assert_status(response, 302)
self.assertRedirects(response, url_for(NEXT_URL, local_land_charge=charge_id_services.calc_display_id(
state.local_land_charge)))
def post_location():
current_app.logger.info("Endpoint called")
if g.session.add_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
information = None
if 'saved-features' in request.form:
information = json.loads(request.form['saved-features'].strip())
current_app.logger.info("Validating location geometry")
validation_errors = AddLocationMapValidator.validate(information)
if validation_errors.errors:
current_app.logger.warning(
"Validation errors present - Rendering page with validation errors"
)
return render_template(
'location.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
information=information,
submit_url=url_for('modify_land_charge.post_location')), 400
current_app.logger.info("Field values validated - Updating session charge")
if has_value_changed(g.session.add_charge_state.geometry, information):
g.session.edited_fields.append('location_info')
g.session.add_charge_state.geometry = information
g.session.commit()
if 'LLC LR Admins' not in g.session.user.roles and 'LLC LR Users' not in g.session.user.roles:
result = LocalAuthorityService(
current_app.config).get_authorities_by_extent(
build_extents_from_features(information))
if len(result) != 1 or g.session.user.organisation not in result:
return redirect(
url_for('modify_land_charge.get_location_confirmation'))
charge_display_id = calc_display_id(
g.session.add_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_display_id))
def edit_dominant_building_extent_post():
if g.session.add_lon_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
information = None
postcode_to_zoom = ''
if g.session.add_lon_charge_state.charge_address:
postcode_to_zoom = g.session.add_lon_charge_state.charge_address[
'postcode']
if 'saved-features' in request.form:
information = json.loads(request.form['saved-features'].strip())
validation_errors = AddLocationMapValidator.validate(
information, "Draw the extent", "Draw the extent")
if validation_errors.errors:
current_app.logger.warning(
"Validation errors present - Rendering page with validation errors"
)
return render_template(
'dominant_building_extent.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
information=information,
postcode=postcode_to_zoom,
submit_url=url_for(
'modify_lon.edit_dominant_building_extent_post')), 400
if g.session.add_lon_charge_state.geometry != information:
g.session.edited_fields['geometry'] = 'Extent'
g.session.add_lon_charge_state.geometry = information
g.session.commit()
charge_display_id = calc_display_id(
g.session.add_lon_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_lon.modify_lon_details_get",
charge_id=charge_display_id))
def test_post_location_description_successful(self):
self.client.set_cookie('localhost', Session.session_cookie_name, 'cookie_value')
state = LocalLandChargeItem()
state.local_land_charge = 1
self.mock_session.return_value.add_charge_state = state
self.mock_session.return_value.user.permissions = [Permissions.vary_llc]
charge_geographic_description = 'This is a valid description'
response = self.client.post(url_for(POST_ADDRESS_CONFIRMATION), data={
'has-address': 'No',
'charge-geographic-description': charge_geographic_description
})
self.assert_status(response, 302)
self.assertRedirects(response, url_for(NEXT_URL, local_land_charge=charge_id_services.calc_display_id(
state.local_land_charge)))
def modify_lon_upload_get(charge_id):
current_app.logger.info(
"Endpoint called with charge_id='{}'".format(charge_id))
local_land_charge_service = LocalLandChargeService(current_app.config)
# Retrieve Light Obstruction Notice Item
display_id, charge_item = get_lon_by_charge_id(charge_id,
local_land_charge_service)
g.session.edited_fields = {}
g.session.commit()
# Check that charge hasn't been cancelled in case user attempts to navigate to update URL manually
if charge_item.end_date:
current_app.logger.error(
'Attempted to update a cancelled charge. Charge ID: {}'.format(
charge_id))
raise ApplicationError(500)
# If the charge is in session we are in the process of updating it
if not g.session.add_lon_charge_state:
g.session.add_lon_charge_state = charge_item
g.session.commit()
current_app.logger.info("Session charge updated - Rendering Template")
return render_template('modify_lon_upload.html',
charge_id=display_id,
charge_item=charge_item)
else:
session_charge_id = calc_display_id(
g.session.add_lon_charge_state.local_land_charge)
# Check that charge ID in session and URL match.
# If they don't, redirect user to the charge ID they entered and clear session
if session_charge_id != display_id:
g.session.add_lon_charge_state = None
g.session.commit()
return redirect(
url_for("modify_lon.modify_lon_upload_get",
charge_id=charge_id))
return render_template('modify_lon_upload.html',
charge_id=display_id,
charge_item=charge_item)
def post_charge_date():
current_app.logger.info("Endpoint called")
if g.session.add_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
day = request.form.get('date-day')
month = request.form.get('date-month')
year = request.form.get('date-year')
current_app.logger.info("Validating charge date")
validation_errors = ChargeDateValidator.validate(day, month, year)
if validation_errors.errors:
current_app.logger.warning(
"Validation errors present - Rendering page with validation errors"
)
charge_date = {'day': day, 'month': month, 'year': year}
return render_template(
'charge_date.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
submit_url=url_for('modify_land_charge.post_charge_date'),
request=request,
date=charge_date)
current_app.logger.info("Field values validated - Updating session charge")
if year and month and day:
new_date = date(int(year), int(month), int(day))
else:
new_date = None
if g.session.add_charge_state.charge_creation_date != new_date:
g.session.add_charge_state.charge_creation_date = new_date
g.session.edited_fields.append('charge_creation_date')
g.session.commit()
charge_display_id = calc_display_id(
g.session.add_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_display_id))
def post_land_compensation_land_sold():
current_app.logger.info("Endpoint called with land-sold-description = '%s' and land-works-particulars = '%s'",
request.form.get('land-sold-description', ''),
request.form.get('land-works-particulars', ''))
if g.session.add_charge_state is None:
current_app.logger.error("Charge state not found in session - Returning error")
raise ApplicationError(500)
description = request.form['land-sold-description'].strip()
land_works_particulars = request.form['land-works-particulars'].strip()
current_app.logger.info('Running validation')
validation_errors = LandCompensationLandSoldValidator.validate(description, land_works_particulars)
if validation_errors.errors:
current_app.logger.warning('Validation errors occurred')
return render_template('land_compensation_land_sold.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
request_body=request.form,
submit_url=url_for('modify_land_charge.post_land_compensation_land_sold')), 400
current_app.logger.info("Updating session object with land-sold-description = '%s' and "
"land-works-particulars = '%s'", description, land_works_particulars)
charge_display_id = calc_display_id(g.session.add_charge_state.local_land_charge)
edited = False
if has_value_changed(g.session.add_charge_state.land_sold_description, description):
edited = True
g.session.edited_fields.append('land_sold_description')
g.session.add_charge_state.land_sold_description = description
if has_value_changed(g.session.add_charge_state.land_works_particulars, land_works_particulars):
edited = True
g.session.edited_fields.append('land_works_particulars')
g.session.add_charge_state.land_works_particulars = land_works_particulars
if edited:
g.session.commit()
current_app.logger.info("Redirecting to next step: %s",
url_for("modify_land_charge.modify_land_charge", local_land_charge=charge_display_id))
return redirect(url_for("modify_land_charge.modify_land_charge", local_land_charge=charge_display_id))
def edit_applicant_info_post():
if g.session.add_lon_charge_state is None:
current_app.logger.error("Charge state not found in session - Returning error")
raise ApplicationError(500)
address_form = request.form
current_app.logger.info("Running validation")
validation_error_builder = ApplicantInfoValidator.validate(address_form)
if validation_error_builder.errors:
current_app.logger.warning("Validation errors occurred")
return render_template('applicant_info.html',
validation_errors=validation_error_builder.errors,
validation_summary_heading=validation_error_builder.summary_heading_text,
submit_url=url_for('modify_lon.edit_applicant_info_post'),
country_list=get_sorted_countries(),
request_body=request.form), 400
applicant_address = AddressConverter.condense_address(address_form)
applicant_name = address_form.get('applicant_name')
current_app.logger.info("Updating session object")
if applicant_name != g.session.add_lon_charge_state.applicant_name:
g.session.add_lon_charge_state.applicant_name = applicant_name
g.session.edited_fields['applicant-name'] = 'Name'
if applicant_address != g.session.add_lon_charge_state.applicant_address:
g.session.add_lon_charge_state.applicant_address = applicant_address
g.session.edited_fields['applicant-address'] = 'Address'
g.session.commit()
charge_display_id = calc_display_id(g.session.add_lon_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_lon with charge_id='{}'".format(charge_display_id)
)
return redirect(url_for("modify_lon.modify_lon_details_get", charge_id=charge_display_id))
def get_update_location_confirmation():
current_app.logger.info('Endpoint called')
if g.session.add_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
if g.session.add_charge_state.geometry is None:
current_app.logger.error(
"Geometry not found in session - Returning error")
raise ApplicationError(500)
current_app.logger.info(
"Displaying page 'update_location_confirmation.html'")
return render_template(
'update_location_confirmation.html',
submit_url=url_for(
'modify_land_charge.post_update_location_confirmation'),
charge_id=calc_display_id(
g.session.add_charge_state.local_land_charge))
def test_put_update_land_charge_validation_error(self, mock_app, mock_audit):
with main.app.test_request_context():
g.requests = MagicMock()
g.trace_id = '123'
g.session = self.mock_session
response = MagicMock()
response.status_code = 500
response.text = "response"
g.requests.put.return_value = response
try:
MaintainApiService.update_charge(LocalLandChargeItem.from_json(s8))
except Exception as ex:
self.assertEqual(ex.http_code, 500)
mock_app.logger.exception.assert_called()
mock_app.logger.exception.assert_called_with(
'Failed to send land charge to maintain-api. TraceID : 123 - Status: 500, Message: response')
mock_audit.audit_event.assert_called_with('Failed to send land charge to maintain-api',
supporting_info={
'id': calc_display_id(s8['local-land-charge'])
})
return
self.fail()
def post_charge_description():
current_app.logger.info("Endpoint called")
if g.session.add_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
description = request.form['charge-description'].strip()
current_app.logger.info("Validating charge reason")
validation_errors = ChargeDescriptionValidator.validate(description)
if validation_errors.errors:
current_app.logger.warning(
"Validation errors present - Rendering page with validation errors"
)
return render_template(
'charge_description.html',
data=description,
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
submit_url=url_for(
'modify_land_charge.post_charge_description')), 400
current_app.logger.info("Field values validated - Updating session charge")
if has_value_changed(g.session.add_charge_state.supplementary_information,
description):
g.session.add_charge_state.supplementary_information = description
g.session.edited_fields.append('charge_description')
g.session.commit()
charge_display_id = calc_display_id(
g.session.add_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_display_id))
def post_address_for_charge():
"""Save more information about the location to session and move to the next screen.
:return: redirect to the next screen in the flow
"""
current_app.logger.info("Endpoint called")
if g.session.add_charge_state is None:
raise ApplicationError(500)
has_address = request.form.get('has-address')
charge_geographic_description = request.form.get(
'charge-geographic-description')
selected_address = request.form.get('selected-address')
current_app.logger.info("Validating location information")
validation_errors = AddressForChargeValidator.validate(
has_address, selected_address, charge_geographic_description)
if validation_errors.errors:
current_app.logger.warning(
"Validation errors present - Rendering page with validation errors"
)
return render_template(
'address_for_charge.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
charge_geographic_description=charge_geographic_description,
has_address=has_address,
submit_url=url_for(
"modify_land_charge.post_address_for_charge")), 400
current_app.logger.info("Field values validated - Updating session charge")
edited = False
if selected_address:
selected_address = json.loads(selected_address)
new_address = AddressConverter.to_charge_address(selected_address)
if g.session.add_charge_state.charge_address != new_address:
g.session.add_charge_state.charge_address = new_address
g.session.add_charge_state.charge_geographic_description = None
g.session.edited_fields.append('location_info')
edited = True
elif charge_geographic_description:
if g.session.add_charge_state.charge_geographic_description != charge_geographic_description:
g.session.add_charge_state.charge_geographic_description = charge_geographic_description
g.session.add_charge_state.charge_address = None
g.session.edited_fields.append('location_info')
edited = True
if edited:
g.session.commit()
charge_display_id = calc_display_id(
g.session.add_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_display_id))
def modify_land_charge(local_land_charge):
current_app.logger.info(
"Endpoint called with local_land_charge='{}'".format(
local_land_charge))
validate_charge_id(local_land_charge)
local_land_charge_service = LocalLandChargeService(current_app.config)
response = local_land_charge_service.get_by_charge_number(
local_land_charge)
if response.status_code == 404:
current_app.logger.warning(
"Charge not found for local_land_charge='{}' - Returning not found"
.format(local_land_charge))
raise ApplicationError(404)
response.raise_for_status()
updated, updated_date = get_history_update_info_by_charge_id(
local_land_charge, local_land_charge_service)
if not g.session.add_charge_state:
current_app.logger.info(
"Retrieving charge with local_land_charge='{}'".format(
local_land_charge))
# If the charge does not exist in the session, load it from the database, otherwise we are in the
# process of updating it and as such it should be loaded from the session data
charge_data = response.json()[0]['item']
charge_item = LocalLandChargeItem.from_json(charge_data)
current_app.logger.info(
"Charge information retrieved for local_land_charge='{}' - Updating session charge"
.format(local_land_charge))
g.session.add_charge_state = charge_item
g.session.edited_fields = []
g.session.commit()
current_app.logger.info("Session charge updated - Rendering Template")
else:
charge_id = calc_display_id(
g.session.add_charge_state.local_land_charge)
current_app.logger.info('charge_id: {}'.format(charge_id))
current_app.logger.info(
'local_land_charge: {}'.format(local_land_charge))
# Check that charge ID in session and URL match.
# If they don't, redirect user to the charge ID they entered and clear session
if charge_id != local_land_charge:
g.session.add_charge_state = None
g.session.edited_fields = None
g.session.commit()
return modify_land_charge(local_land_charge)
charge_item = g.session.add_charge_state
current_app.logger.info("Session charge updated - Rendering Template")
# Check that charge hasn't been cancelled in case user attempts to navigate to update URL manually
if charge_item.end_date:
current_app.logger.error(
'Attempted to update a cancelled charge. Charge ID: {}'.format(
local_land_charge))
raise ApplicationError(500)
# Check if the charge is outside of the user's authority, if user hasn't already updated the map
if not g.session.charge_added_outside_users_authority:
extent = build_extents_from_features(charge_item.geometry)
result = LocalAuthorityService(
current_app.config).get_authorities_by_extent(extent)
if should_show_confirmation_warning(result):
# In this case the charge is outside of the user's authority
if Permissions.add_extent_anywhere in g.session.user.permissions:
# If the user has permission to add a charge anywhere, give them update permission without asking
g.session.other_authority_update_permission = True
g.session.commit()
if not g.session.other_authority_update_permission:
# if the user has not confirmed that they can edit charges outside of their authority, make them
return redirect(
url_for(
'modify_land_charge.get_update_location_confirmation'))
return render_template('modify_charge.html',
charge_item=charge_item,
updated=updated,
updated_date=updated_date,
charge_id=response.json()[0]['display_id'],
geometry=json.dumps(charge_item.geometry),
edited_fields=get_ordered_edited_fields(
g.session.edited_fields, ReviewMap),
map=ReviewMap)
def post_land_compensation_payment():
current_app.logger.info("Endpoint called")
if g.session.add_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
land_compensation_paid = NumberConverter.format_number_string(
request.form.get('land-compensation-paid'),
leading_char='£',
force_two_dp=True)
amount_of_compensation = NumberConverter.format_number_string(
request.form.get('amount-of-compensation'),
leading_char='£',
force_two_dp=True)
land_compensation_amount_type = request.form.get(
'land-compensation-amount-type')
current_app.logger.info("Running validation")
validation_errors = LandCompensationPaymentValidator.validate(
land_compensation_paid, amount_of_compensation, True)
if validation_errors.errors:
current_app.logger.warning("Validation errors occurred")
return render_template(
'land_compensation_payment.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
request_body=request.form,
submit_url=url_for(
'modify_land_charge.post_land_compensation_payment')), 400
current_app.logger.info(
"Updating session object with land compensation amount: '%s' , \
total compensation: '%s' and land compensation amount type: '%s'",
land_compensation_paid, amount_of_compensation,
land_compensation_amount_type)
charge_display_id = calc_display_id(
g.session.add_charge_state.local_land_charge)
edited = False
if has_value_changed(g.session.add_charge_state.land_compensation_paid,
land_compensation_paid):
g.session.edited_fields.append('land_compensation_paid')
g.session.add_charge_state.land_compensation_paid = land_compensation_paid
edited = True
if has_value_changed(g.session.add_charge_state.amount_of_compensation,
amount_of_compensation):
g.session.edited_fields.append('amount_of_compensation')
g.session.add_charge_state.amount_of_compensation = amount_of_compensation
edited = True
if has_value_changed(
g.session.add_charge_state.land_compensation_amount_type,
land_compensation_amount_type):
g.session.edited_fields.append('land_compensation_amount_type')
g.session.add_charge_state.land_compensation_amount_type = land_compensation_amount_type
edited = True
if edited:
g.session.commit()
current_app.logger.info(
"Redirecting to next step: %s",
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_display_id))
return redirect(
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_display_id))
def edit_dominant_building_post():
if g.session.add_lon_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
validation_error_builder = DominantAddressValidator.validate(request.form)
if validation_error_builder.errors:
current_app.logger.warning("Validation errors occurred")
return render_template(
'dominant_building.html',
validation_errors=validation_error_builder.errors,
validation_summary_heading=validation_error_builder.
summary_heading_text,
submit_url=url_for('modify_lon.edit_dominant_building_post'),
request_body=request.form), 400
if request.form['have_address'] == 'Yes':
charge_address = {
'unique-property-reference-number': int(request.form['uprn']),
'postcode': request.form['postcode'],
'line-1': request.form['address_line_1']
}
if request.form['address_line_2']:
charge_address['line-2'] = request.form['address_line_2']
if request.form['address_line_3']:
charge_address['line-3'] = request.form['address_line_3']
if request.form['address_line_4']:
charge_address['line-4'] = request.form['address_line_4']
if request.form['address_line_5']:
charge_address['line-5'] = request.form['address_line_5']
if request.form['address_line_6']:
charge_address['line-6'] = request.form['address_line_6']
if charge_address != g.session.add_lon_charge_state.charge_address:
if 'charge_geographic_description' in g.session.edited_fields:
del g.session.edited_fields['charge_geographic_description']
current_app.logger.info(
'Adding charge-address field to edited_fields')
g.session.edited_fields['charge-address'] = 'Dominant address'
g.session.add_lon_charge_state.charge_address = charge_address
g.session.add_lon_charge_state.charge_geographic_description = ''
else:
charge_geographic_description = request.form[
'charge_geographic_description']
if charge_geographic_description != g.session.add_lon_charge_state.charge_geographic_description:
if 'charge-address' in g.session.edited_fields:
del g.session.edited_fields['charge-address']
current_app.logger.info(
'Adding charge_geographic_description field to edited_fields')
g.session.edited_fields[
'charge_geographic_description'] = 'Dominant address'
g.session.add_lon_charge_state.charge_address = ''
g.session.add_lon_charge_state.charge_geographic_description = charge_geographic_description
current_app.logger.info("Updating session object")
g.session.commit()
charge_display_id = calc_display_id(
g.session.add_lon_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_lon with charge_id='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_lon.modify_lon_details_get",
charge_id=charge_display_id))
def edit_servient_structure_height_post():
if g.session.add_lon_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
servient_structure_height_form = request.form
measurement = servient_structure_height_form.get('measurement')
height = servient_structure_height_form.get('height')
unit = servient_structure_height_form.get('unit')
validation_error_builder = ServientStructureHeightValidator.validate(
measurement, height, unit)
if validation_error_builder.errors:
current_app.logger.warning("Validation errors occurred")
return render_template(
'servient_structure_height.html',
validation_errors=validation_error_builder.errors,
validation_summary_heading=validation_error_builder.
summary_heading_text,
submit_url=url_for(
'modify_lon.edit_servient_structure_height_post'),
request_body=request.form), 400
current_app.logger.info("Updating session object")
structure_position_and_dimension = g.session.add_lon_charge_state.structure_position_and_dimension
edited = False
if measurement == "Unlimited height":
if 'height' not in g.session.add_lon_charge_state.structure_position_and_dimension:
edited = True
else:
if g.session.add_lon_charge_state.structure_position_and_dimension[
"height"] != "Unlimited height":
edited = True
structure_position_and_dimension["height"] = measurement
if 'units' in structure_position_and_dimension:
del (structure_position_and_dimension['units'])
else:
if 'height' not in g.session.add_lon_charge_state.structure_position_and_dimension:
edited = True
else:
if g.session.add_lon_charge_state.structure_position_and_dimension["height"] != height \
or g.session.add_lon_charge_state.structure_position_and_dimension["units"] != unit:
edited = True
structure_position_and_dimension["height"] = height
structure_position_and_dimension["units"] = unit
if edited:
g.session.add_lon_charge_state.structure_position_and_dimension = structure_position_and_dimension
g.session.edited_fields[
'structure-dimension'] = 'Height - planned development'
g.session.commit()
charge_display_id = calc_display_id(
g.session.add_lon_charge_state.local_land_charge)
current_app.logger.info(
"Session charge updated - Redirecting back to modify_land_charge with local_land_charge='{}'"
.format(charge_display_id))
return redirect(
url_for("modify_lon.modify_lon_details_get",
charge_id=charge_display_id))
def calc_display_id_filter(local_land_charge):
return calc_display_id(local_land_charge)
def post_land_compensation_ownership():
current_app.logger.info("Endpoint called")
if g.session.add_charge_state is None:
current_app.logger.error(
"Charge state not found in session - Returning error")
raise ApplicationError(500)
land_ownership_indicator = request.form.get('land-owned-indicator', '')
land_ownership_other = request.form.get('land-owned-other', '')
current_app.logger.info("Running validation")
validation_errors = LandCompensationOwnedValidator.validate(
land_ownership_indicator, land_ownership_other)
if validation_errors.errors:
current_app.logger.warning("Validation errors occurred")
return render_template(
'land_compensation_owned.html',
validation_errors=validation_errors.errors,
validation_summary_heading=validation_errors.summary_heading_text,
request_body=request.form,
submit_url=url_for(
'modify_land_charge.post_land_compensation_ownership')), 400
edited = False
if g.session.add_charge_state.land_capacity_description in [
'Freehold', 'Leasehold'
]:
if land_ownership_indicator == "Other":
edited = True
g.session.add_charge_state.land_capacity_description = land_ownership_other
elif has_value_changed(
g.session.add_charge_state.land_capacity_description,
land_ownership_indicator):
edited = True
g.session.add_charge_state.land_capacity_description = land_ownership_indicator
elif g.session.add_charge_state.land_capacity_description not in [
'Freehold', 'Leasehold'
]:
if land_ownership_indicator in ['Freehold', 'Leasehold']:
edited = True
g.session.add_charge_state.land_capacity_description = land_ownership_indicator
elif has_value_changed(
g.session.add_charge_state.land_capacity_description,
land_ownership_other):
edited = True
g.session.add_charge_state.land_capacity_description = land_ownership_other
if edited:
g.session.edited_fields.append('land_compensation_ownership')
g.session.commit()
current_app.logger.info(
"Updating session object with land capacity description: '%s'",
g.session.add_charge_state.land_capacity_description)
charge_display_id = calc_display_id(
g.session.add_charge_state.local_land_charge)
current_app.logger.info(
"Redirecting to next step: %s",
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_display_id))
return redirect(
url_for("modify_land_charge.modify_land_charge",
local_land_charge=charge_display_id))
