def layer_panel(request, bbox=None, **kwargs):
if request.method != 'GET':
return HttpResponseBadRequest()
try:
# both authorized_objects and sections are obtained from decorator
authorized_objects = kwargs['authorized_objects']
sections = kwargs['sections']
form = AnalysisCreationForm(
user=request.user,
exposure_layer=retrieve_layers(
'exposure', bbox=bbox,
authorized_objects=authorized_objects)[0],
hazard_layer=retrieve_layers(
'hazard', bbox=bbox, authorized_objects=authorized_objects)[0],
impact_functions=Analysis.impact_function_list())
context = {
'sections': sections,
'form': form,
'user': request.user,
}
return render(request, "geosafe/analysis/options_panel.html", context)
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def layer_panel(request, bbox=None, **kwargs):
"""
:param bbox: format [x0,y0,x1,y1]
:return:
"""
if request.method != 'GET':
return HttpResponseBadRequest()
try:
# both authorized_objects and sections are obtained from decorator
authorized_objects = kwargs['authorized_objects']
sections = kwargs['sections']
form = AnalysisCreationForm(
user=request.user,
exposure_layer=retrieve_layers(
'exposure', bbox=bbox,
authorized_objects=authorized_objects)[0],
hazard_layer=retrieve_layers(
'hazard', bbox=bbox, authorized_objects=authorized_objects)[0],
aggregation_layer=retrieve_layers(
'aggregation',
bbox=bbox,
authorized_objects=authorized_objects)[0])
context = {
'sections': sections,
'form': form,
'user': request.user,
}
return TemplateResponse(request,
"geosafe/analysis/options_panel.html",
context=context)
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def layer_panel(request, bbox=None):
if request.method != 'GET':
return HttpResponseBadRequest()
try:
authorized_objects = get_objects_for_user(
request.user, 'base.view_resourcebase').values('id')
sections = AnalysisCreateView.options_panel_dict(
authorized_objects=authorized_objects, bbox=bbox)
form = AnalysisCreationForm(
user=request.user,
exposure_layer=retrieve_layers(
'exposure', bbox=bbox,
authorized_objects=authorized_objects)[0],
hazard_layer=retrieve_layers(
'hazard', bbox=bbox, authorized_objects=authorized_objects)[0],
impact_functions=Analysis.impact_function_list())
context = {
'sections': sections,
'form': form,
'user': request.user,
}
return render(request, "geosafe/analysis/options_panel.html", context)
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def layer_panel(request, bbox=None):
if request.method != 'GET':
return HttpResponseBadRequest()
try:
sections = AnalysisCreateView.options_panel_dict(bbox=bbox)
form = AnalysisCreationForm(user=request.user,
exposure_layer=retrieve_layers('exposure',
bbox=bbox),
hazard_layer=retrieve_layers('hazard',
bbox=bbox))
context = {
'sections': sections,
'form': form,
'user': request.user,
}
return render(request, "geosafe/analysis/options_panel.html", context)
except Exception as e:
LOGGER.exception(e)
return HttpResponseServerError()
def process_analysis(self, clean_up=True, **kwargs):
"""Run InaSAFE analysis and test the results."""
# Prepare layer data
layers = {
'hazard_layer':
file_upload(kwargs.get('hazard_layer')),
'exposure_layer':
file_upload(kwargs.get('exposure_layer')),
'aggregation_layer':
(None if not kwargs.get('aggregation_layer') else
(file_upload(kwargs.get('aggregation_layer'))))
}
# Check layer uploaded
for key, layer in layers.iteritems():
if isinstance(layer, Layer):
# Wait until metadata for respective layer is read
wait_metadata(layer)
kwargs.update({key: layer.id})
self.assertEqual(Layer.objects.filter(id=layer.id).count(), 1)
else:
kwargs.update({key: ''})
# Prepare form
kwargs.update({
"keep": False,
"extent_option": Analysis.HAZARD_EXPOSURE_CODE
})
form = AnalysisCreationForm(kwargs, user=AnonymousUser())
if not form.is_valid():
LOGGER.debug(form.errors)
self.assertTrue(form.is_valid())
analysis = form.save()
""":type: geosafe.models.Analysis"""
# wait for the analysis to succeed whatever happens with
# the task progress
while not analysis.task_state == 'SUCCESS':
analysis.refresh_from_db()
time.sleep(1)
if analysis.get_task_result().failed():
LOGGER.debug(analysis.get_task_result().traceback)
self.assertTrue(analysis.get_task_result().successful())
self.assertEqual(analysis.get_task_state(), 'SUCCESS')
while not analysis.impact_layer:
analysis.refresh_from_db()
time.sleep(1)
impact_layer = analysis.impact_layer
wait_metadata(impact_layer)
LOGGER.debug('Layers: {0}'.format(Layer.objects.all()))
self.assertEqual(impact_layer.inasafe_metadata.layer_purpose,
'impact_analysis')
# Check if reports are being generated or not
self.assertIsNotNone(analysis.report_map)
self.assertIsNotNone(analysis.report_table)
if clean_up:
# Clean up layers
layer_items = [
l for _, l in layers.items() if isinstance(l, Layer)
]
for layer in layer_items:
layer.delete()
impact_layer.delete()
def test_run_analysis_no_aggregation(self):
"""Test running analysis without aggregation."""
data_helper = InaSAFETestData()
flood = data_helper.hazard('flood_data.geojson')
buildings = data_helper.exposure('buildings.geojson')
flood_layer = file_upload(flood)
# Wait until metadata is read
wait_metadata(flood_layer)
buildings_layer = file_upload(buildings)
# Wait until metadata is read
wait_metadata(buildings_layer)
# Check layer uploaded
self.assertEqual(Layer.objects.filter(id=flood_layer.id).count(), 1)
self.assertEqual(
Layer.objects.filter(id=buildings_layer.id).count(), 1)
form_data = {
'user': AnonymousUser(),
'user_title': 'Flood on Buildings custom Analysis',
'exposure_layer': buildings_layer.id,
'hazard_layer': flood_layer.id,
'keep': False,
'extent_option': Analysis.HAZARD_EXPOSURE_CODE
}
form = AnalysisCreationForm(form_data, user=form_data['user'])
if not form.is_valid():
LOGGER.debug(form.errors)
self.assertTrue(form.is_valid())
analysis = form.save()
""":type: geosafe.models.Analysis"""
while analysis.get_task_state() == 'PENDING':
analysis.refresh_from_db()
time.sleep(1)
if analysis.get_task_result().failed():
LOGGER.debug(analysis.get_task_result().traceback)
self.assertTrue(analysis.get_task_result().successful())
self.assertEqual(analysis.get_task_state(), 'SUCCESS')
while not analysis.impact_layer:
analysis.refresh_from_db()
time.sleep(1)
impact_layer = analysis.impact_layer
wait_metadata(impact_layer)
LOGGER.debug('Layers: {0}'.format(Layer.objects.all()))
self.assertEqual(impact_layer.inasafe_metadata.layer_purpose,
'impact_analysis')
flood_layer.delete()
buildings_layer.delete()
impact_layer.delete()