def test_uses_grid_location(self):
"""Test regarding issue #2438
"""
working_dir = shakemap_extract_dir()
# population_path =
shake_event = ShakeEvent(
working_dir=working_dir,
event_id=SHAKE_ID_2,
locale='en',
force_flag=True,
data_is_local_flag=True,
# population_raster_path=population_path
)
expected_location = 'Yogyakarta'
self.assertEqual(
shake_event.event_dict()['shake-grid-location'],
expected_location)
inasafe_django = InaSAFEDjangoREST()
if inasafe_django.is_configured():
# generate report
shake_event.render_map()
# push to realtime django
push_shake_event_to_rest(shake_event)
# check shake event exists
session = inasafe_django.rest
response = session.earthquake(SHAKE_ID_2).GET()
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(
response.json()['location_description'],
shake_event.event_dict()['shake-grid-location'])
def test_uses_grid_location(self):
"""Test regarding issue #2438
"""
working_dir = shakemap_extract_dir()
# population_path =
shake_event = ShakeEvent(
working_dir=working_dir,
event_id=SHAKE_ID_2,
locale='en',
force_flag=True,
data_is_local_flag=True,
# population_raster_path=population_path
)
expected_location = 'Yogyakarta'
self.assertEqual(
shake_event.event_dict()['shake-grid-location'],
expected_location)
inasafe_django = InaSAFEDjangoREST()
if inasafe_django.is_configured():
# generate report
shake_event.render_map()
# push to realtime django
push_shake_event_to_rest(shake_event)
# check shake event exists
session = inasafe_django.rest
response = session.earthquake(SHAKE_ID_2).GET()
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(
response.json()['location_description'],
shake_event.event_dict()['shake-grid-location'])
def notify_realtime_rest(timestamp):
"""Notify realtime rest that someone is logged in to realtime.
This can indicate someone is pushing raw shakemap files
:param timestamp: python datetime object indicating shakemap timestamp
:type timestamp: datetime.datetime
"""
try:
inasafe_django = InaSAFEDjangoREST()
LOGGER.info(timestamp)
session = inasafe_django.rest
timestamp_utc = timestamp.astimezone(tz=pytz.utc)
data = {
'timestamp':
timestamp_utc.strftime(INASAFE_REALTIME_DATETIME_FORMAT)
}
headers = {'X-CSRFTOKEN': inasafe_django.csrf_token}
LOGGER.info('Is Logged in %s' %
session.is_logged_in.GET(headers=headers))
response = session.indicator.notify_shakemap_push.POST(data=data,
headers=headers)
# We will not handle post error, since we don't need it.
# It just simply fails
if response.status_code != requests.codes.ok:
LOGGER.info('Notify Shakemap Push Failed : Error code %s',
response.status_code)
except Exception as exc:
LOGGER.exception(exc)
def test_push_to_realtime(self):
# only do the test if realtime test server is configured
inasafe_django = InaSAFEDjangoREST()
if inasafe_django.is_configured():
working_dir = shakemap_extract_dir()
shake_event = ShakeEvent(
working_dir=working_dir,
event_id=SHAKE_ID,
locale='en',
data_is_local_flag=True)
# generate report
shake_event.render_map()
# push to realtime django
push_shake_event_to_rest(shake_event)
# check shake event exists
session = inasafe_django.rest
response = session.earthquake(SHAKE_ID).GET()
self.assertEqual(response.status_code, requests.codes.ok)
event_dict = shake_event.event_dict()
earthquake_data = {
'shake_id': shake_event.event_id,
'magnitude': float(event_dict.get('mmi')),
'depth': float(event_dict.get('depth-value')),
'time': shake_event.shake_grid.time,
'location': {
'type': 'Point',
'coordinates': [
shake_event.shake_grid.longitude,
shake_event.shake_grid.latitude
]
},
'location_description': event_dict.get('shake-grid-location')
}
for key, value in earthquake_data.iteritems():
if isinstance(value, datetime.datetime):
self.assertEqual(
datetime.datetime.strptime(
response.json()[key], '%Y-%m-%dT%H:%M:%SZ'
).replace(tzinfo=pytz.utc),
value
)
else:
self.assertEqual(response.json()[key], value)
def test_push_to_realtime(self):
# only do the test if realtime test server is configured
inasafe_django = InaSAFEDjangoREST()
if inasafe_django.is_configured():
working_dir = shakemap_extract_dir()
shake_event = ShakeEvent(
working_dir=working_dir,
event_id=SHAKE_ID,
locale='en',
data_is_local_flag=True)
# generate report
shake_event.render_map()
# push to realtime django
push_shake_event_to_rest(shake_event)
# check shake event exists
session = inasafe_django.rest
response = session.earthquake(SHAKE_ID).GET()
self.assertEqual(response.status_code, requests.codes.ok)
event_dict = shake_event.event_dict()
earthquake_data = {
'shake_id': shake_event.event_id,
'magnitude': float(event_dict.get('mmi')),
'depth': float(event_dict.get('depth-value')),
'time': shake_event.shake_grid.time,
'location': {
'type': 'Point',
'coordinates': [
shake_event.shake_grid.longitude,
shake_event.shake_grid.latitude
]
},
'location_description': event_dict.get('shake-grid-location')
}
for key, value in earthquake_data.iteritems():
if isinstance(value, datetime.datetime):
self.assertEqual(
datetime.datetime.strptime(
response.json()[key], '%Y-%m-%dT%H:%M:%SZ'
).replace(tzinfo=pytz.utc),
value
)
else:
self.assertEqual(response.json()[key], value)
def setUp(self):
self.inasafe_django = InaSAFEDjangoREST()
def push_shake_event_to_rest(shake_event, fail_silent=True):
"""Pushing shake event Grid.xml description files to REST server.
:param shake_event: The shake event to push
:type shake_event: ShakeEvent
:param fail_silent: If set True, will still continue whan the push process
failed. Default vaule to True. If False, this method will raise
exception.
:type fail_silent: bool
:return: Return True if successfully pushed data
:rtype: bool
"""
inasafe_django = InaSAFEDjangoREST()
# check credentials exists in os.environ
if not inasafe_django.is_configured():
LOGGER.info('Insufficient information to push shake map to '
'Django Realtime')
LOGGER.info('Please set environment for INASAFE_REALTIME_REST_URL, '
'INASAFE_REALTIME_REST_LOGIN_URL, '
'INASAFE_REALTIME_REST_USER, and '
'INASAFE_REALTIME_REST_PASSWORD')
return
event_dict = shake_event.event_dict()
# set headers and cookie
# begin communicating with server
LOGGER.info('----------------------------------')
LOGGER.info('Push data to REST server: %s', inasafe_django.base_url())
try:
session = inasafe_django.rest
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
'Content-Type': 'application/json'
}
# build the data request:
earthquake_data = {
'shake_id': shake_event.event_id,
'magnitude': float(event_dict.get('mmi')),
'depth': float(event_dict.get('depth-value')),
'time': str(shake_event.shake_grid.time),
'location': {
'type':
'Point',
'coordinates': [
shake_event.shake_grid.longitude,
shake_event.shake_grid.latitude
]
},
'location_description': event_dict.get('shake-grid-location')
}
# check does the shake event already exists?
response = session.earthquake(earthquake_data['shake_id']).GET()
if response.status_code == requests.codes.ok:
# event exists, we should update using PUT Url
response = session.earthquake(earthquake_data['shake_id']).PUT(
data=json.dumps(earthquake_data), headers=headers)
elif response.status_code == requests.codes.not_found:
# event does not exists, create using POST url
response = session.earthquake.POST(
data=json.dumps(earthquake_data), headers=headers)
if not (response.status_code == requests.codes.ok
or response.status_code == requests.codes.created):
# raise exceptions
error = RESTRequestFailedError(url=response.url,
status_code=response.status_code,
data=json.dumps(earthquake_data))
if fail_silent:
LOGGER.info(error.message)
else:
raise error
# post the report
# build report data
path_files = shake_event.generate_result_path_dict()
event_report_dict = {
'shake_id': shake_event.event_id,
'language': shake_event.locale
}
event_report_files = {
'report_pdf': open(path_files.get('pdf')),
'report_image': open(path_files.get('image')),
'report_thumbnail': open(path_files.get('thumbnail'))
}
# check report exists
# build headers and cookies
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
}
response = session('earthquake-report', event_report_dict['shake_id'],
event_report_dict['language']).GET()
if response.status_code == requests.codes.ok:
# event exists, we should update using PUT Url
response = session(
'earthquake-report', event_report_dict['shake_id'],
event_report_dict['language']).PUT(data=event_report_dict,
files=event_report_files,
headers=headers)
elif response.status_code == requests.codes.not_found:
# event doesn't exists, we should update using POST url
response = session('earthquake-report',
event_report_dict['shake_id']).POST(
data=event_report_dict,
files=event_report_files,
headers=headers)
if not (response.status_code == requests.codes.ok
or response.status_code == requests.codes.created):
error = RESTRequestFailedError(url=response.url,
status_code=response.status_code,
data=event_report_dict,
files=event_report_files)
if fail_silent:
LOGGER.info(error.message)
else:
raise error
return True
# pylint: disable=broad-except
except Exception as exc:
if fail_silent:
LOGGER.warning(exc)
else:
raise exc
def push_ash_event_to_rest(ash_event, fail_silent=True):
"""Push ash event to inasafe-django
:param ash_event: The Ash Event
:type ash_event: AshEvent
:param fail_silent:
:return:
"""
if not ash_event.impact_exists:
LOGGER.info('No impact exists. Will not push anything')
return
inasafe_django = InaSAFEDjangoREST()
# check credentials exists in os.environ
if not inasafe_django.is_configured():
LOGGER.info('Insufficient information to push shake map to '
'Django Realtime')
LOGGER.info('Please set environment for INASAFE_REALTIME_REST_URL, '
'INASAFE_REALTIME_REST_LOGIN_URL, '
'INASAFE_REALTIME_REST_USER, and '
'INASAFE_REALTIME_REST_PASSWORD')
return
# set headers and cookie
# begin communicating with server
LOGGER.info('----------------------------------')
LOGGER.info('Push data to REST server: %s', inasafe_django.base_url())
try:
session = inasafe_django.rest
# Create a zipped impact layer
impact_zip_path = ash_event.working_dir_path('impact.zip')
with ZipFile(impact_zip_path, 'w') as zipf:
for root, dirs, files in os.walk(ash_event.working_dir):
for f in files:
_, ext = os.path.splitext(f)
if ('impact' in f and
not f == 'impact.zip' and
not ext == '.pdf'):
filename = os.path.join(root, f)
zipf.write(filename, arcname=f)
# build the data request:
dateformat = '%Y-%m-%d %H:%M:%S %z'
timestring = '%Y%m%d%H%M%S%z'
ash_data = {
'volcano_name': ash_event.volcano_name,
'event_time': ash_event.time.strftime(dateformat),
'language': ash_event.locale,
}
ash_data_file = {
# 'impact_files': open(impact_zip_path),
# 'map_report': open(ash_event.map_report_path),
}
# modify headers
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
}
# post the report
# build report data
event_report_files = {
'report_map': open(ash_event.map_report_path),
}
# check report exists
# build headers and cookies
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
}
response = session(
'ash-report',
ash_data['volcano_name'],
ash_event.time.strftime(timestring)).GET()
report_exists = False
if response.status_code == requests.codes.ok:
result = response.json()
if result and 'count' in result and result['count'] > 0:
report_exists = True
elif response.status_code == requests.codes.not_found:
report_exists = False
if report_exists:
# event exists, we should update using PUT Url
response = session(
'ash-report',
ash_data['volcano_name'],
ash_event.time.strftime(timestring),
ash_event.locale).PUT(
data=ash_data,
files=event_report_files,
headers=headers)
else:
# event doesn't exists, we should update using POST url
response = session(
'ash-report',
ash_data['volcano_name'],
ash_event.time.strftime(timestring)).POST(
data=ash_data,
files=event_report_files,
headers=headers)
if not (response.status_code == requests.codes.ok or
response.status_code == requests.codes.created):
error = RESTRequestFailedError(
url=response.url,
status_code=response.status_code,
data=ash_data,
files=event_report_files)
if fail_silent:
LOGGER.warning(error.message)
else:
raise error
return True
# pylint: disable=broad-except
except Exception as exc:
if fail_silent:
LOGGER.warning(exc)
else:
raise exc
def push_flood_event_to_rest(flood_event, fail_silent=True):
"""Pushing shake event Grid.xml description files to REST server.
:param flood_event: The flood event to push
:type flood_event: FloodEvent
:param fail_silent: If set True, will still continue whan the push process
failed. Default vaule to True. If False, this method will raise
exception.
:type fail_silent:
:return: Return True if successfully pushed data
:rtype: bool
"""
if not flood_event.impact_exists:
LOGGER.info('No impact exists. Will not push anything')
return
inasafe_django = InaSAFEDjangoREST()
# check credentials exists in os.environ
if not inasafe_django.is_configured():
LOGGER.info('Insufficient information to push shake map to '
'Django Realtime')
LOGGER.info('Please set environment for INASAFE_REALTIME_REST_URL, '
'INASAFE_REALTIME_REST_LOGIN_URL, '
'INASAFE_REALTIME_REST_USER, and '
'INASAFE_REALTIME_REST_PASSWORD')
return
# set headers and cookie
# begin communicating with server
LOGGER.info('----------------------------------')
LOGGER.info('Push data to REST server: %s', inasafe_django.base_url())
try:
session = inasafe_django.rest
# Create a zipped impact layer
impact_zip_path = os.path.join(flood_event.report_path, 'impact.zip')
with ZipFile(impact_zip_path, 'w') as zipf:
for root, dirs, files in os.walk(flood_event.report_path):
for f in files:
_, ext = os.path.splitext(f)
if ('impact' in f and not f == 'impact.zip'
and not ext == '.pdf'):
filename = os.path.join(root, f)
zipf.write(filename, arcname=f)
# build the data request:
flood_data = {
'event_id': flood_event.report_id,
'time': flood_event.time,
'interval': flood_event.duration,
'source': flood_event.source,
'region': flood_event.region
}
flood_data_file = {
'hazard_layer': open(flood_event.hazard_zip_path),
'impact_layer': open(impact_zip_path)
}
# modify headers
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
}
# check does the shake event already exists?
response = session.flood(flood_data['event_id']).GET()
if response.status_code == requests.codes.ok:
# event exists, we should update using PUT Url
response = session.flood(flood_data['event_id']).PUT(
data=flood_data, files=flood_data_file, headers=headers)
elif response.status_code == requests.codes.not_found:
# event does not exists, create using POST url
response = session.flood.POST(data=flood_data,
files=flood_data_file,
headers=headers)
if not (response.status_code == requests.codes.ok
or response.status_code == requests.codes.created):
# raise exceptions
error = RESTRequestFailedError(url=response.url,
status_code=response.status_code,
data=flood_data)
if fail_silent:
LOGGER.warning(error.message)
else:
raise error
# post the report
# build report data
map_report_path = flood_event.map_report_path
table_report_path = flood_event.table_report_path
event_report_dict = {
'event_id': flood_event.report_id,
'language': flood_event.locale
}
event_report_files = {
'impact_map': open(map_report_path),
# 'impact_report': open(table_report_path)
}
# check report exists
# build headers and cookies
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
}
response = session('flood-report', event_report_dict['event_id'],
event_report_dict['language']).GET()
if response.status_code == requests.codes.ok:
# event exists, we should update using PUT Url
response = session('flood-report', event_report_dict['event_id'],
event_report_dict['language']).PUT(
data=event_report_dict,
files=event_report_files,
headers=headers)
elif response.status_code == requests.codes.not_found:
# event doesn't exists, we should update using POST url
response = session('flood-report',
event_report_dict['event_id']).POST(
data=event_report_dict,
files=event_report_files,
headers=headers)
if not (response.status_code == requests.codes.ok
or response.status_code == requests.codes.created):
error = RESTRequestFailedError(url=response.url,
status_code=response.status_code,
data=event_report_dict,
files=event_report_files)
if fail_silent:
LOGGER.warning(error.message)
else:
raise error
return True
# pylint: disable=broad-except
except Exception as exc:
if fail_silent:
LOGGER.warning(exc)
else:
raise exc
def push_flood_event_to_rest(flood_event, fail_silent=True):
"""Pushing shake event Grid.xml description files to REST server.
:param flood_event: The flood event to push
:type flood_event: FloodEvent
:param fail_silent: If set True, will still continue whan the push process
failed. Default vaule to True. If False, this method will raise
exception.
:type fail_silent:
:return: Return True if successfully pushed data
:rtype: bool
"""
if not flood_event.impact_exists:
LOGGER.info('No impact exists. Will not push anything')
return
inasafe_django = InaSAFEDjangoREST()
# check credentials exists in os.environ
if not inasafe_django.is_configured():
LOGGER.info('Insufficient information to push shake map to '
'Django Realtime')
LOGGER.info('Please set environment for INASAFE_REALTIME_REST_URL, '
'INASAFE_REALTIME_REST_LOGIN_URL, '
'INASAFE_REALTIME_REST_USER, and '
'INASAFE_REALTIME_REST_PASSWORD')
return
# set headers and cookie
# begin communicating with server
LOGGER.info('----------------------------------')
LOGGER.info('Push data to REST server: %s', inasafe_django.base_url())
try:
session = inasafe_django.rest
# Create a zipped impact layer
impact_zip_path = os.path.join(flood_event.report_path, 'impact.zip')
with ZipFile(impact_zip_path, 'w') as zipf:
for root, dirs, files in os.walk(flood_event.report_path):
for f in files:
_, ext = os.path.splitext(f)
if ('impact' in f and
not f == 'impact.zip' and
not ext == '.pdf'):
filename = os.path.join(root, f)
zipf.write(filename, arcname=f)
# build the data request:
flood_data = {
'event_id': flood_event.report_id,
'time': flood_event.time,
'interval': flood_event.duration,
'source': flood_event.source,
'region': flood_event.region
}
flood_data_file = {
'hazard_layer': open(flood_event.hazard_zip_path),
'impact_layer': open(impact_zip_path)
}
# modify headers
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
}
# check does the shake event already exists?
response = session.flood(
flood_data['event_id']).GET()
if response.status_code == requests.codes.ok:
# event exists, we should update using PUT Url
response = session.flood(
flood_data['event_id']).PUT(
data=flood_data,
files=flood_data_file,
headers=headers)
elif response.status_code == requests.codes.not_found:
# event does not exists, create using POST url
response = session.flood.POST(
data=flood_data,
files=flood_data_file,
headers=headers)
if not (response.status_code == requests.codes.ok or
response.status_code == requests.codes.created):
# raise exceptions
error = RESTRequestFailedError(
url=response.url,
status_code=response.status_code,
data=flood_data)
if fail_silent:
LOGGER.warning(error.message)
else:
raise error
# post the report
# build report data
map_report_path = flood_event.map_report_path
table_report_path = flood_event.table_report_path
event_report_dict = {
'event_id': flood_event.report_id,
'language': flood_event.locale
}
event_report_files = {
'impact_map': open(map_report_path),
# 'impact_report': open(table_report_path)
}
# check report exists
# build headers and cookies
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
}
response = session(
'flood-report',
event_report_dict['event_id'],
event_report_dict['language']).GET()
if response.status_code == requests.codes.ok:
# event exists, we should update using PUT Url
response = session(
'flood-report',
event_report_dict['event_id'],
event_report_dict['language']).PUT(
data=event_report_dict,
files=event_report_files,
headers=headers)
elif response.status_code == requests.codes.not_found:
# event doesn't exists, we should update using POST url
response = session(
'flood-report',
event_report_dict['event_id']).POST(
data=event_report_dict,
files=event_report_files,
headers=headers)
if not (response.status_code == requests.codes.ok or
response.status_code == requests.codes.created):
error = RESTRequestFailedError(
url=response.url,
status_code=response.status_code,
data=event_report_dict,
files=event_report_files)
if fail_silent:
LOGGER.warning(error.message)
else:
raise error
return True
# pylint: disable=broad-except
except Exception as exc:
if fail_silent:
LOGGER.warning(exc)
else:
raise exc
def push_ash_event_to_rest(ash_event, fail_silent=True):
"""Push ash event to inasafe-django
:param ash_event: The Ash Event
:type ash_event: AshEvent
:param fail_silent:
:return:
"""
if not ash_event.impact_exists:
LOGGER.info('No impact exists. Will not push anything')
return
inasafe_django = InaSAFEDjangoREST()
# check credentials exists in os.environ
if not inasafe_django.is_configured():
LOGGER.info('Insufficient information to push shake map to '
'Django Realtime')
LOGGER.info('Please set environment for INASAFE_REALTIME_REST_URL, '
'INASAFE_REALTIME_REST_LOGIN_URL, '
'INASAFE_REALTIME_REST_USER, and '
'INASAFE_REALTIME_REST_PASSWORD')
return
# set headers and cookie
# begin communicating with server
LOGGER.info('----------------------------------')
LOGGER.info('Push data to REST server: %s', inasafe_django.base_url())
try:
session = inasafe_django.rest
# Create a zipped impact layer
impact_zip_path = ash_event.working_dir_path('impact.zip')
with ZipFile(impact_zip_path, 'w') as zipf:
for root, dirs, files in os.walk(ash_event.working_dir):
for f in files:
_, ext = os.path.splitext(f)
if ('impact' in f and not f == 'impact.zip'
and not ext == '.pdf'):
filename = os.path.join(root, f)
zipf.write(filename, arcname=f)
# build the data request:
dateformat = '%Y-%m-%d %H:%M:%S %z'
timestring = '%Y%m%d%H%M%S%z'
ash_data = {
'volcano_name': ash_event.volcano_name,
'event_time': ash_event.time.strftime(dateformat),
'language': ash_event.locale,
}
ash_data_file = {
# 'impact_files': open(impact_zip_path),
# 'map_report': open(ash_event.map_report_path),
}
# modify headers
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
}
# post the report
# build report data
event_report_files = {
'report_map': open(ash_event.map_report_path),
}
# check report exists
# build headers and cookies
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
}
response = session('ash-report', ash_data['volcano_name'],
ash_event.time.strftime(timestring)).GET()
report_exists = False
if response.status_code == requests.codes.ok:
result = response.json()
if result and 'count' in result and result['count'] > 0:
report_exists = True
elif response.status_code == requests.codes.not_found:
report_exists = False
if report_exists:
# event exists, we should update using PUT Url
response = session('ash-report', ash_data['volcano_name'],
ash_event.time.strftime(timestring),
ash_event.locale).PUT(data=ash_data,
files=event_report_files,
headers=headers)
else:
# event doesn't exists, we should update using POST url
response = session('ash-report', ash_data['volcano_name'],
ash_event.time.strftime(timestring)).POST(
data=ash_data,
files=event_report_files,
headers=headers)
if not (response.status_code == requests.codes.ok
or response.status_code == requests.codes.created):
error = RESTRequestFailedError(url=response.url,
status_code=response.status_code,
data=ash_data,
files=event_report_files)
if fail_silent:
LOGGER.warning(error.message)
else:
raise error
return True
# pylint: disable=broad-except
except Exception as exc:
if fail_silent:
LOGGER.warning(exc)
else:
raise exc
def push_shake_event_to_rest(shake_event, fail_silent=True):
"""Pushing shake event Grid.xml description files to REST server.
:param shake_event: The shake event to push
:type shake_event: ShakeEvent
:param fail_silent: If set True, will still continue whan the push process
failed. Default vaule to True. If False, this method will raise
exception.
:type fail_silent: bool
:return: Return True if successfully pushed data
:rtype: bool
"""
inasafe_django = InaSAFEDjangoREST()
# check credentials exists in os.environ
if not inasafe_django.is_configured():
LOGGER.info('Insufficient information to push shake map to '
'Django Realtime')
LOGGER.info('Please set environment for INASAFE_REALTIME_REST_URL, '
'INASAFE_REALTIME_REST_LOGIN_URL, '
'INASAFE_REALTIME_REST_USER, and '
'INASAFE_REALTIME_REST_PASSWORD')
return
event_dict = shake_event.event_dict()
# set headers and cookie
# begin communicating with server
LOGGER.info('----------------------------------')
LOGGER.info('Push data to REST server: %s', inasafe_django.base_url())
try:
session = inasafe_django.rest
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
'Content-Type': 'application/json'
}
# build the data request:
earthquake_data = {
'shake_id': shake_event.event_id,
'magnitude': float(event_dict.get('mmi')),
'depth': float(event_dict.get('depth-value')),
'time': str(shake_event.shake_grid.time),
'location': {
'type': 'Point',
'coordinates': [
shake_event.shake_grid.longitude,
shake_event.shake_grid.latitude
]
},
'location_description': event_dict.get('shake-grid-location')
}
# check does the shake event already exists?
response = session.earthquake(
earthquake_data['shake_id']).GET()
if response.status_code == requests.codes.ok:
# event exists, we should update using PUT Url
response = session.earthquake(
earthquake_data['shake_id']).PUT(
data=json.dumps(earthquake_data), headers=headers)
elif response.status_code == requests.codes.not_found:
# event does not exists, create using POST url
response = session.earthquake.POST(
data=json.dumps(earthquake_data), headers=headers)
if not (response.status_code == requests.codes.ok or
response.status_code == requests.codes.created):
# raise exceptions
error = RESTRequestFailedError(
url=response.url,
status_code=response.status_code,
data=json.dumps(earthquake_data))
if fail_silent:
LOGGER.info(error.message)
else:
raise error
# post the report
# build report data
path_files = shake_event.generate_result_path_dict()
event_report_dict = {
'shake_id': shake_event.event_id,
'language': shake_event.locale
}
event_report_files = {
'report_pdf': open(path_files.get('pdf')),
'report_image': open(path_files.get('image')),
'report_thumbnail': open(path_files.get('thumbnail'))
}
# check report exists
# build headers and cookies
headers = {
'X-CSRFTOKEN': inasafe_django.csrf_token,
}
response = session(
'earthquake-report',
event_report_dict['shake_id'],
event_report_dict['language']).GET()
if response.status_code == requests.codes.ok:
# event exists, we should update using PUT Url
response = session(
'earthquake-report',
event_report_dict['shake_id'],
event_report_dict['language']).PUT(
data=event_report_dict,
files=event_report_files,
headers=headers)
elif response.status_code == requests.codes.not_found:
# event doesn't exists, we should update using POST url
response = session(
'earthquake-report',
event_report_dict['shake_id']).POST(
data=event_report_dict,
files=event_report_files,
headers=headers)
if not (response.status_code == requests.codes.ok or
response.status_code == requests.codes.created):
error = RESTRequestFailedError(
url=response.url,
status_code=response.status_code,
data=event_report_dict,
files=event_report_files)
if fail_silent:
LOGGER.info(error.message)
else:
raise error
return True
# pylint: disable=broad-except
except Exception as exc:
if fail_silent:
LOGGER.warning(exc)
else:
raise exc
def test_login_to_realtime(self):
# get logged in session
inasafe_django = InaSAFEDjangoREST()
self.assertTrue(inasafe_django.is_logged_in)
