def get(self, request, exception_id, *args, **kwargs):
e = self.get_object(exception_id)
if not e:
return json_response(
errors={'exception_id': "Object not found"}, status=404)
data = e.expose()
return json_response(data)
def get(self, request, adm_code, **kwargs):
try:
app = self.get_app()
except KeyError:
app = None
try:
adm = AdministrativeDivision.objects.get(code=adm_code)
except AdministrativeDivision.DoesNotExist:
adm = None
if adm is None:
return json_response(errors=["Invalid code"], status=404)
try:
reg = Region.objects.get(name=kwargs['reg'])
except Region.DoesNotExist:
reg = None
if reg is None:
return json_response(errors=["Invalid region"], status=404)
children = adm.children.all()
_features = [adm] + list(children)
features = [self._make_feature(item, app, reg) for item in _features]
out = {'type': 'FeatureCollection', 'features': features}
return json_response(out)
def register(request):
current_site = Site.objects.get_current()
siteurl = settings.SITEURL
parsed = urlsplit(siteurl)
domain = parsed.netloc
# check domain (sites.Site) and settings.SITEURL
if domain != current_site.domain:
return json_response(
errors='Configuration mismatch: settings.SITEURL and sites.Site',
status=500)
# check if a key is already present
try:
SkRegistration.objects.get(site=current_site)
return json_response(
errors='URI already presents in the local catalog', status=500)
except SkRegistration.DoesNotExist:
pass
# check for services metadata
if ServicesMetadata.objects.count() == 1:
services_metadata = ServicesMetadata.objects.all()[0]
else:
return json_response(errors='Missing metadata', status=500)
_md = model_to_dict(services_metadata)
_md['base_url'] = settings.SITEURL
status, api_key = _register(domain=domain, md=json.dumps(_md))
if status is True:
skr = SkRegistration(api_key=api_key, site=current_site)
skr.save()
return json_response(body={'success': True})
else:
return json_response(errors=api_key, status=500)
def get(self, request, *args, **kwargs):
locations = self.get_location(**kwargs)
if not locations:
return json_response(errors=['Invalid location code'], status=404)
loc = locations[-1]
app = self.get_app()
hazard_types = HazardType.objects.filter(app=app)
hazard_type = self.get_hazard_type(loc, **kwargs)
if not hazard_type:
return json_response(errors=['Invalid hazard type'], status=404)
(
atype,
atypes,
) = self.get_analysis_type(loc, hazard_type, **kwargs)
if not atype:
return json_response(
errors=['No analysis type available for location/hazard type'],
status=404)
out = {
'navItems':
[location.set_app(app).export() for location in locations],
'overview': [ht.set_location(loc).export() for ht in hazard_types],
'context': self.get_context_url(**kwargs),
'furtherResources': self.get_further_resources(**kwargs),
'hazardType': hazard_type.get_hazard_details(),
'analysisType': atype.get_analysis_details()
}
return json_response(out)
def ediproxy_importmd(request, layername):
layer = _resolve_layer(request, layername, 'base.change_resourcebase',
_PERMISSION_MSG_METADATA)
isoml = request.POST.get('generatedXml').encode('utf8')
ediml = request.POST.get('ediml').encode('utf8')
edimlid = request.POST.get('edimlid')
try:
_savelayermd(layer, isoml, ediml, version='2')
except Exception as e:
return json_response(exception=e, status=500)
return json_response(body={'success': True})
# fare una class base view
# e spostare in una nuova funzione rest
# def load_isoedimlid(request, layername):
# def load_isoediml(request, layername):
# layer = _resolve_layer(request, layername, 'base.change_layer', _PERMISSION_MSG_METADATA)
# ediml = request.raw_post_data
# _savelayermd(layer, rndt, ediml)
# except Exception as e:
# return json_response(exception=e, status=500)
# return json_response(body={'success':True,'redirect': reverse('layer_detail', args=(layer.typename,))})
# # return HttpResponseRedirect()
# # def load_
def get(self, request, *args, **kwargs):
locations = self.get_location(**kwargs)
app = self.get_app()
if not locations:
return json_response(errors=['Invalid location code'], status=404)
loc = locations[-1]
hazard_type = self.get_hazard_type(loc, **kwargs)
if not hazard_type:
return json_response(errors=['Invalid hazard type'], status=404)
(
atype,
atypes,
) = self.get_analysis_type(loc, hazard_type, **kwargs)
if not atype:
return json_response(
errors=['No analysis type available for location/hazard type'],
status=404)
risks = atype.get_risk_analysis_list(id=kwargs['an'])
if not risks:
return json_response(
errors=['No risk analysis found for given parameters'],
status=404)
risk = risks[0]
out = {'riskAnalysisData': risk.get_risk_details()}
dymlist = risk.dymension_infos.all().distinct()
if kwargs.get('dym'):
dimension = dymlist.get(id=kwargs['dym'])
else:
dimension = dymlist.filter(
riskanalysis_associacion__axis=self.AXIS_X).distinct().get()
feat_kwargs = self.url_kwargs_to_query_params(**kwargs)
feat_kwargs['risk_analysis'] = risk.name
features = self.get_features(risk, dimension, dymlist, **feat_kwargs)
out['riskAnalysisData']['data'] = self.reformat_features(
risk, dimension, dymlist, features['features'])
out['context'] = self.get_context_url(**kwargs)
out['wms'] = {
'style': None,
'viewparams': self.get_viewparams(risk, hazard_type, loc),
'baseurl': settings.OGC_SERVER['default']['PUBLIC_LOCATION']
}
out['riskAnalysisData']['unitOfMeasure'] = risk.unit_of_measure
out['riskAnalysisData']['additionalLayers'] = [(
l.id,
l.typename,
l.title,
) for l in risk.additional_layers.all()]
out['furtherResources'] = self.get_further_resources(**kwargs)
#url(r'loc/(?P<loc>[\w\-]+)/ht/(?P<ht>[\w\-]+)/at/(?P<at>[\w\-]+)/an/(?P<an>[\w\-]+)/pdf/$', views.pdf_report, name='pdf_report'),
out['pdfReport'] = app.url_for('pdf_report', loc.code,
hazard_type.mnemonic, atype.name,
risk.id)
return json_response(out)
def get(self, request, *args, **kwargs):
qargs = self.get_filter_args(request)
if self.errors:
return json_response(
{
'success': False,
'status': 'errors',
'errors': self.errors
},
status=400)
q = self.get_queryset(**qargs)
from_fields = [f[0] for f in self.fields_map]
to_fields = [f[1] for f in self.fields_map]
labels = dict(EventType.EVENT_TYPES)
out = [
dict(
zip(to_fields,
(getattr(item, f) if f != 'type_label' else labels[getattr(
item, 'name')] for f in from_fields))) for item in q
]
data = {
self.output_name: out,
'success': True,
'errors': {},
'status': 'ok'
}
if self.output_name != 'data':
data['data'] = {'key': self.output_name}
return json_response(data)
def get(self, request, exception_id, *args, **kwargs):
e = self.get_object(exception_id)
if not e:
return json_response(errors={'exception_id': "Object not found"},
status=404)
data = e.expose()
return json_response(data)
def register(request):
current_site = Site.objects.get_current()
siteurl = settings.SITEURL
parsed = urlsplit(siteurl)
domain=parsed.netloc
# check domain (sites.Site) and settings.SITEURL
if domain != current_site.domain:
return json_response(errors='Configuration mismatch: settings.SITEURL and sites.Site', status=500)
# check if a key is already present
try:
SkRegistration.objects.get(site=current_site)
return json_response(errors='URI already presents in the local catalog', status=500)
except SkRegistration.DoesNotExist:
pass
# check for services metadata
if ServicesMetadata.objects.count() == 1:
services_metadata = ServicesMetadata.objects.all()[0]
else:
return json_response(errors='Missing metadata', status=500)
_md = model_to_dict(services_metadata)
_md['base_url'] = settings.SITEURL
status, api_key = _register(domain = domain, md=json.dumps(_md))
if status is True:
skr = SkRegistration(api_key = api_key, site = current_site)
skr.save()
return json_response(body={'success':True})
else:
return json_response(errors=api_key, status=500)
def ediproxy_importmd(request, layername):
layer = _resolve_layer(request, layername, 'base.change_resourcebase', _PERMISSION_MSG_METADATA)
isoml = request.POST.get('generatedXml').encode('utf8')
ediml = request.POST.get('ediml').encode('utf8')
edimlid = request.POST.get('edimlid')
try:
_savelayermd(layer, isoml, ediml, version='2')
except Exception as e:
return json_response(exception=e, status=500)
return json_response(body={'success':True})
# fare una class base view
# e spostare in una nuova funzione rest
# def load_isoedimlid(request, layername):
# def load_isoediml(request, layername):
# layer = _resolve_layer(request, layername, 'base.change_layer', _PERMISSION_MSG_METADATA)
# ediml = request.raw_post_data
# _savelayermd(layer, rndt, ediml)
# except Exception as e:
# return json_response(exception=e, status=500)
# return json_response(body={'success':True,'redirect': reverse('layer_detail', args=(layer.typename,))})
# # return HttpResponseRedirect()
# # def load_
def sensormlproxy(request):
# if SkRegistration.objects.get_current() is None:
# return json_response(errors='You must register the GET-IT before save a Metadata',
# status=500)
service = settings.RITMARE['MDSERVICE'] + 'postMetadata'
headers = {
# 'api_key': get_key(),
'Content-Type': 'application/xml'
}
r = requests.post(service,
data=request.raw_post_data,
headers=headers,
verify=False)
if r.status_code == 200:
sensorml = r.text
# get fileid
ediml = etree.fromstring(request.raw_post_data)
fileid = ediml.find('fileId').text
headers = {
'Accept':
'application/xml',
'Content-Type':
'application/xml',
'Authorization':
"%s" %
settings.SOS_SERVER['default']['TRANSACTIONAL_AUTHORIZATION_TOKEN']
}
settings.SOS_SERVER['default']['LOCATION']
sos_response = requests.post(
settings.SOS_SERVER['default']['LOCATION'] + '/pox',
data=sensorml.encode('utf8'),
headers=headers,
verify=False)
if sos_response.status_code == 200:
tr = etree.fromstring(sos_response.content)
if tr.tag == nspath_eval("ows110:ExceptionReport", namespaces):
return json_response(
exception=sos_response.text.encode('utf8'), status=500)
# save sensorml & edi xml
sensor = Sensor(fileid=fileid)
sensor.sensorml = sensorml
sensor.ediml = request.raw_post_data
sensor.save()
return json_response(body={
'success': True,
'redirect': reverse('osk_browse')
})
else:
return json_response(exception=sos_response.text.encode('utf8'),
status=500)
return json_response(errors='Cannot create SensorML', status=500)
def get(self, request, *args, **kwargs):
reg = self.get_region(**kwargs)
locations = self.get_location(**kwargs)
if not locations:
return json_response(errors=['Invalid location code'], status=404)
loc = locations[-1]
app = self.get_app()
hazard_types = HazardType.objects.filter(app=app)
analysis_classes = AnalysisClass.objects.all()
analysis_types = AnalysisType.objects.filter(app=app)
hazard_type = self.get_hazard_type(reg, loc, **kwargs)
if not hazard_type:
return json_response(errors=['Invalid hazard type'], status=404)
(
atype_r,
atype_e,
atypes,
aclass,
) = self.get_analysis_type(reg, loc, hazard_type, **kwargs)
if not atype_r and not atype_e:
return json_response(
errors=['No analysis type available for location/hazard type'],
status=404)
overview = {
'hazardType': [
ht.set_region(reg).set_location(loc).export()
for ht in hazard_types
],
'analysisClass': [ac.export() for ac in analysis_classes],
'analysisType':
[at.export(at.EXPORT_FIELDS_BASIC) for at in analysis_types]
}
out = {
'navItems': [
location.set_app(app).set_region(reg).export()
for location in locations
],
#'overview': [ht.set_region(reg).set_location(loc).export() for ht in hazard_types],
'overview':
overview,
'context':
self.get_context_url(**kwargs),
'furtherResources':
self.get_further_resources(**kwargs),
'hazardType':
hazard_type.get_hazard_details(),
'analysisType':
atype_r.get_analysis_details() if atype_r else {},
'analysisTypeE':
atype_e.get_analysis_details() if atype_e else {}
}
return json_response(out)
def verify(request):
status = _verify()
if status is True:
skr = SkRegistration.objects.get_current()
skr.verified = True
skr.save()
return json_response(body={'success':True})
else:
return json_response(exception=api_key, status=500)
def verify(request):
status = _verify()
if status is True:
skr = SkRegistration.objects.get_current()
skr.verified = True
skr.save()
return json_response(body={'success': True})
else:
return json_response(exception=api_key, status=500)
def get(self, request, *args, **kwargs):
locations = self.get_location(**kwargs)
app = self.get_app()
if not locations:
return json_response(errors=['Invalid location code'], status=404)
loc = locations[-1]
#hazard_type = self.get_hazard_type(loc, **kwargs)
try:
risk_analysis = RiskAnalysis.objects.get(id=kwargs['an'])
except RiskAnalysis.DoesNotExist:
return json_response(errors=['Invalid risk analysis'], status=404)
events = self.get_events(**kwargs)
if not events:
return json_response(errors=['Invalid event Id(s)'], status=404)
adm_level = self.get_current_adm_level(**kwargs)
#if not hazard_type:
#return json_response(errors=['Invalid hazard type'], status=404)
wms_events = {
'style': None,
'viewparams': self.get_viewparams(adm_level, risk_analysis, events),
'baseurl': settings.OGC_SERVER['default']['PUBLIC_LOCATION']
}
layer_style = {
'name': 'monochromatic',
'title': None,
'url': 'http://localhost:8080/geoserver/rest/styles/monochromatic.sld'
}
layer_events = {
'layerName': 'geonode:risk_analysis_event_location',
'layerStyle': layer_style,
'layerTitle': 'risk_analysis_event_location'
}
related_layers_events = [(l.id, l.typename, l.title, ) for l in events.first().related_layers.all()] if events.count() == 1 else []
feat_kwargs = self.url_kwargs_to_query_params(**kwargs)
features = self.get_features_base('geonode:risk_analysis', None, **feat_kwargs)
values = [[f['properties']['dim1_value'], f['properties']['dim2_value'], f['properties']['value']] for f in features['features']]
out = {
'wms': wms_events,
'layer': layer_events,
'relatedLayers': related_layers_events,
'eventValues': values
}
return json_response(out)
def ediproxy_importmd(request, layername):
layer = _resolve_layer(request, layername, 'layers.change_layer', _PERMISSION_MSG_METADATA)
isoml = request.POST.get('generatedXml').encode('utf8')
ediml = request.POST.get('ediml').encode('utf8')
edimlid = request.POST.get('edimlid')
try:
_savelayermd(layer, isoml, ediml, version='2')
except Exception as e:
return json_response(exception=e, status=500)
return json_response(body={'success':True})
def rndtproxy(request, layername):
layer = _resolve_layer(request, layername, 'layers.change_layer',
_PERMISSION_MSG_METADATA)
service = settings.RITMARE['MDSERVICE'] + 'postMetadata'
headers = {
'api_key': get_key(),
'Content-Type': 'application/xml',
}
r = requests.post(service,
data=request.raw_post_data,
headers=headers,
verify=False)
if r.status_code == 200:
rndt = r.text.encode('utf8')
# extract fileid
ediml = etree.fromstring(request.raw_post_data)
fileid = ediml.find('fileId').text
# new fileid must be equal to the old one
if layer.mdextension.fileid is not None:
if int(layer.mdextension.fileid) != int(fileid):
return json_response(
errors='New fileid (%s) is different from the old one (%s)'
% (fileid, layer.mdextension.fileid),
status=500)
else:
layer.mdextension.fileid = fileid
else:
return json_response(errors='Cannot create RNDT', status=500)
try:
vals, keywords = rndt2dict(etree.fromstring(rndt))
errors = _post_validate(vals)
if len(errors) > 0:
return json_response(exception=errors, status=500)
_mdimport(layer, vals, keywords, rndt)
except Exception as e:
return json_response(exception=e, status=500)
# save rndt & edi xml
layer.mdextension.md_date = vals['md_language']
layer.mdextension.md_date = vals['md_date']
layer.mdextension.rndt_xml = rndt
layer.mdextension.elements_xml = request.raw_post_data
layer.mdextension.save()
return json_response(
body={
'success': True,
'redirect': reverse('layer_detail', args=(layer.typename, ))
})
def get(self, request, *args, **kwargs):
service = kwargs.get('exposed')
if not service:
data = [{'name': s, 'url': reverse('monitoring:api_beacon_exposed', args=(s,))} for s in exposes.keys()]
return json_response({'exposed': data})
try:
ex = exposes[service]()
except KeyError:
return json_response(errors={'exposed': 'No service for {}'.format(service)}, status=404)
out = {'data': ex.expose(),
'timestamp': datetime.utcnow().replace(tzinfo=pytz.utc)}
return json_response(out)
def get(self, *args, **kwargs):
rid = self.kwargs['risk_id']
risk = self.get_risk()
if risk is None:
return json_response({'errors': ['Invalid risk id']}, status=404)
out = {}
out['success'] = True
out['data'] = {
'layers':
list(risk.additional_layers.all().values_list('typename',
flat=True))
}
return json_response(out)
def get(self, request, *args, **kwargs):
service = kwargs.get('exposed')
if not service:
data = [{'name': s, 'url': reverse(
'monitoring:api_beacon_exposed', args=(s,))} for s in exposes.keys()]
return json_response({'exposed': data})
try:
ex = exposes[service]()
except KeyError:
return json_response(
errors={'exposed': 'No service for {}'.format(service)}, status=404)
out = {'data': ex.expose(),
'timestamp': datetime.utcnow().replace(tzinfo=pytz.utc)}
return json_response(out)
def post(self, request, *args, **kwargs):
user_auth = UserAuth()
request_validation = user_auth.validate_request(request, **kwargs)
if request_validation['status'] == 'ok':
if not user_auth.is_user_allowed(request, **kwargs):
return json_response(errors=[
'You are not allowed to access the requested resources'
],
status=403)
else:
return json_response(errors=[request_validation['message']],
status=request_validation['code'])
return json_response({'success': True})
def sensormlproxy(request):
# if SkRegistration.objects.get_current() is None:
# return json_response(errors='You must register the GET-IT before save a Metadata',
# status=500)
service = settings.RITMARE['MDSERVICE'] + 'postMetadata'
headers = {
# 'api_key': get_key(),
'Content-Type': 'application/xml'
}
r = requests.post(service, data=request.raw_post_data, headers=headers, verify=False)
if r.status_code == 200:
sensorml = r.text
# get fileid
ediml = etree.fromstring(request.raw_post_data)
fileid = ediml.find('fileId').text
headers = {
'Accept': 'application/xml',
'Content-Type': 'application/xml',
'Authorization': "%s" % settings.SOS_SERVER['default']['TRANSACTIONAL_AUTHORIZATION_TOKEN']
}
settings.SOS_SERVER['default']['LOCATION']
sos_response = requests.post(
settings.SOS_SERVER['default']['LOCATION'] + '/pox',
data=sensorml.encode('utf8'), headers=headers,
verify=False
)
if sos_response.status_code == 200:
tr = etree.fromstring(sos_response.content)
if tr.tag == nspath_eval("ows110:ExceptionReport", namespaces):
return json_response(exception=sos_response.text.encode('utf8'), status=500)
# save sensorml & edi xml
sensor = Sensor(fileid=fileid)
sensor.sensorml = sensorml
sensor.ediml = request.raw_post_data
sensor.save()
return json_response(body={'success':True,'redirect': reverse('osk_browse')})
else:
return json_response(exception=sos_response.text.encode('utf8'), status=500)
return json_response(errors='Cannot create SensorML',
status=500)
def get(self, request, *args, **kwargs):
authkey = kwargs.get('authkey')
if not authkey or authkey != self.authkey:
out = {
'success': False,
'status': 'error',
'errors': {
'denied': ['Call is not permitted']
}
}
return json_response(out, status=401)
else:
call_command('collect_metrics', '-n', '-t', 'xml')
out = {'success': True, 'status': 'ok', 'errors': {}}
return json_response(out)
def get(self, request, the_name, *args, **kwargs):
filter = request.GET.get('filter', None)
out = {}
out['hello'] = the_name or 'world'
if filter:
out['filter'] = filter
return json_response(out)
def get(self, *args, **kwargs):
q = self.get_queryset()
out = []
for item in q:
out.append({'name': item.name, 'ip': item.ip})
return json_response({'hosts': out})
def get(self, request, *args, **kwargs):
authkey = kwargs.get('authkey')
if not authkey or authkey != self.authkey:
out = {'success': False,
'status': 'error',
'errors': {'denied': ['Call is not permitted']}
}
return json_response(out, status=401)
else:
call_command(
'collect_metrics', '-n', '-t', 'xml')
out = {'success': True,
'status': 'ok',
'errors': {}
}
return json_response(out)
def get(self, *args, **kwargs):
filters = self.get_filters(**kwargs)
if self.errors:
return json_response({'status': 'error',
'success': False,
'errors': self.errors},
status=400)
metric_name = kwargs['metric_name']
last = filters.pop('last', None)
if last:
td = timedelta(seconds=last)
now = datetime.utcnow().replace(tzinfo=pytz.utc)
filters['valid_from'] = now - td
filters['valid_to'] = now
out = capi.get_metrics_for(metric_name, **filters)
return json_response({'data': out})
def get(self, *args, **kwargs):
filters = self.get_filters(**kwargs)
if self.errors:
return json_response({'status': 'error',
'success': False,
'errors': self.errors},
status=400)
metric_name = kwargs['metric_name']
last = filters.pop('last', None)
if last:
td = timedelta(seconds=last)
now = datetime.utcnow().replace(tzinfo=pytz.utc)
filters['valid_from'] = now - td
filters['valid_to'] = now
out = capi.get_metrics_for(metric_name, **filters)
return json_response({'data': out})
def get(self, request, *args, **kwargs):
reg = self.get_region(**kwargs)
locations = self.get_location(**kwargs)
if not locations:
return json_response(errors=['Invalid location code'], status=404)
loc = locations[-1]
app = self.get_app()
hazard_types = HazardType.objects.filter(app=app)
location_data = {'navItems': [location.set_app(app).set_region(reg).export() for location in locations],
'context': self.get_context_url(**kwargs),
'furtherResources': self.get_further_resources(**kwargs),
'overview': [ht.set_region(reg).set_location(loc).export() for ht in hazard_types]}
return json_response(location_data)
def get(self, request, *args, **kwargs):
out = {'success': False, 'status': 'error', 'data': [], 'errors': {}}
fields = (
'field_name',
'steps',
'current_value',
'steps_calculated',
'unit',
'is_enabled',
)
if auth.get_user(request).is_authenticated:
obj = self.get_object()
out['success'] = True
out['status'] = 'ok'
form = obj.get_user_form()
fields = [dump(r, fields) for r in obj.definitions.all()]
out['data'] = {
'form': form.as_table(),
'fields': fields,
'emails': obj.emails,
'notification': dump(obj)
}
status = 200
else:
out['errors']['user'] = ['User is not authenticated']
status = 401
return json_response(out, status=status)
def post(self, request, *args, **kwargs):
out = {'success': False, 'status': 'error', 'data': [], 'errors': {}}
if auth.get_user(request).is_authenticated:
obj = self.get_object()
try:
is_json = True
data = json.loads(request.body)
except (
TypeError,
ValueError,
):
is_json = False
data = request.POST.copy()
try:
configs = obj.process_user_form(data, is_json=is_json)
out['success'] = True
out['status'] = 'ok'
out['data'] = [dump(c) for c in configs]
status = 200
except forms.ValidationError as err:
out['errors'] = err.errors
status = 400
else:
out['errors']['user'] = ['User is not authenticated']
status = 401
return json_response(out, status=status)
def post(self, request, *args, **kwargs):
out = {'success': False, 'status': 'error', 'data': [], 'errors': {}}
status = 500
if request.user.is_authenticated():
obj = self.get_object()
try:
is_json = True
data = json.loads(request.body)
except (TypeError, ValueError,):
is_json = False
data = request.POST.copy()
try:
configs = obj.process_user_form(data, is_json=is_json)
out['success'] = True
out['status'] = 'ok'
out['data'] = [dump(c) for c in configs]
status = 200
except forms.ValidationError as err:
out['errors'] = err.errors
status = 400
else:
out['errors']['user'] = ['User is not authenticated']
status = 401
return json_response(out, status=status)
def get(self, request, *args, **kwargs):
capi = CollectorAPI()
checks = capi.get_notifications()
data = {'status': 'ok', 'success': True, 'data': {}}
d = data['data']
d['problems'] = problems = []
d['health_level'] = 'ok'
_levels = (
'fatal',
'error',
'warning',
)
levels = set()
for nc, ncdata in checks:
for ncd in ncdata:
levels.add(ncd.severity)
problems.append(dump(ncd, self.fields))
if levels:
for lyr in _levels:
if lyr in levels:
d['health_level'] = lyr
break
return json_response(data)
def get(self, *args, **kwargs):
q = self.get_queryset()
out = []
for item in q:
out.append({'name': item.name, 'ip': item.ip})
return json_response({'hosts': out})
def ediproxy_importmd(request):
# if SkRegistration.objects.get_current() is None:
# return json_response(errors='You must register the GET-IT before save a Metadata',
# status=500)
generatedXml = request.POST.get('generatedXml')
if not generatedXml:
return json_response(exception="No sensor data has been found",
status=500)
insertsensor = request.POST.get('generatedXml').encode('utf8')
ediml = request.POST.get('ediml').encode('utf8')
edimlid = request.POST.get('edimlid')
headers = {
'Accept':
'application/xml',
'Content-Type':
'application/xml',
'Authorization':
f"{settings.SOS_SERVER['default']['TRANSACTIONAL_AUTHORIZATION_TOKEN']}"
}
sos_response = requests.post(
f"{settings.SOS_SERVER['default']['LOCATION']}/pox",
data=insertsensor,
headers=headers,
verify=False)
if sos_response.status_code == 200:
_content = sos_response.content
tr = etree.fromstring(_content)
if tr.tag == nspath_eval("ows110:ExceptionReport", namespaces):
return json_response(exception=sos_response.text.encode('utf8'),
status=500)
# save sensorml & edi xml
_ediml = etree.fromstring(ediml)
fileid = _ediml.find('fileId').text
sensor = Sensor(fileid=fileid)
sensor.sensorml = insertsensor
sensor.ediml = ediml
sensor.save()
return json_response(body={
'success': True,
'redirect': reverse('osk_browse')
})
else:
return json_response(exception=sos_response.text.encode('utf8'),
status=500)
def get(self, *args, **kwargs):
_metrics = capi.get_metric_names()
out = []
for srv, mlist in _metrics:
out.append({'service': srv.name,
'metrics': [{'name': m.name, 'unit': m.unit, 'type': m.type}
for m in mlist]})
return json_response({'metrics': out})
def get(self, *args, **kwargs):
_metrics = capi.get_metric_names()
out = []
for srv, mlist in _metrics:
out.append({'service': srv.name,
'metrics': [{'name': m.name, 'unit': m.unit, 'type': m.type}
for m in mlist]})
return json_response({'metrics': out})
def rndtproxy(request, layername):
layer = _resolve_layer(request, layername, 'base.change_layer', _PERMISSION_MSG_METADATA)
ediml = request.body
try:
rndt = _ediml2rndt(ediml)
except UnregisteredSKException, e:
return json_response(errors=e.message,
status=500)
def rndtproxy(request, layername):
layer = _resolve_layer(request, layername, 'layers.change_layer', _PERMISSION_MSG_METADATA)
ediml = request.raw_post_data
try:
rndt = _ediml2rndt(ediml)
except UnregisteredSKException, e:
return json_response(errors=e.message,
status=500)
def get(self, request):
out = {'success': True}
data = []
out['data'] = data
for link in Link.objects.filter(
link_type__in=LINK_TYPES).distinct('url'):
data.append({'url': link.url, 'type': link.link_type})
return json_response(out)
def listediml(request):
# body={'success':True,'redirect': reverse('layer_detail', args=(layer.typename,))}
data = []
for l in Layer.objects.all():
if l.mdextension.elements_xml is not None:
url = '%s%s/ediml' % (settings.SITEURL[:-1], l.get_absolute_url()),
data.append({'url': url})
return json_response(data)
def post(self, request, *args, **kwargs):
if not request.user.is_authenticated():
out = {'success': False,
'status': 'error',
'errors': {'user': ['User is not authenticated']}
}
return json_response(out, status=401)
if not (request.user.is_superuser or request.user.is_staff):
out = {'success': False,
'status': 'error',
'errors': {'user': ['User is not permitted']}
}
return json_response(out, status=401)
do_autoconfigure()
out = {'success': True,
'status': 'ok',
'errors': {}
}
return json_response(out)
def get(self, request, *args, **kwargs):
qargs = self.get_filter_args(request)
if self.errors:
return json_response({'success': False,
'status': 'errors',
'errors': self.errors},
status=400)
q = self.get_queryset(**qargs)
from_fields = [f[0] for f in self.fields_map]
to_fields = [f[1] for f in self.fields_map]
out = [dict(zip(to_fields, (getattr(item, f)
for f in from_fields))) for item in q]
data = {self.output_name: out,
'success': True,
'errors': {},
'status': 'ok'}
if self.output_name != 'data':
data['data'] = {'key': self.output_name}
return json_response(data)
def post(self, request, *args, **kwargs):
if not request.user.is_authenticated():
out = {'success': False,
'status': 'error',
'errors': {'user': ['User is not authenticated']}
}
return json_response(out, status=401)
if not (request.user.is_superuser or request.user.is_staff):
out = {'success': False,
'status': 'error',
'errors': {'user': ['User is not permitted']}
}
return json_response(out, status=401)
do_autoconfigure()
out = {'success': True,
'status': 'ok',
'errors': {}
}
return json_response(out)
def rndtproxy(request, layername):
layer = _resolve_layer(request, layername, 'layers.change_layer', _PERMISSION_MSG_METADATA)
service = settings.RITMARE['MDSERVICE'] + 'postMetadata'
headers = {'api_key': get_key(),
'Content-Type': 'application/xml',
}
r = requests.post(service, data=request.raw_post_data, headers=headers, verify=False)
if r.status_code == 200:
rndt = r.text.encode('utf8')
# extract fileid
ediml = etree.fromstring(request.raw_post_data)
fileid = ediml.find('fileId').text
# new fileid must be equal to the old one
if layer.mdextension.fileid is not None:
if int(layer.mdextension.fileid) != int(fileid):
return json_response(errors='New fileid (%s) is different from the old one (%s)' % (fileid, layer.mdextension.fileid),
status=500)
else:
layer.mdextension.fileid = fileid
else:
return json_response(errors='Cannot create RNDT',
status=500)
try:
vals, keywords = rndt2dict(etree.fromstring(rndt))
errors = _post_validate(vals)
if len(errors) > 0:
return json_response(exception=errors, status=500)
_mdimport(layer, vals, keywords, rndt)
except Exception as e:
return json_response(exception=e, status=500)
# save rndt & edi xml
layer.mdextension.md_date = vals['md_language']
layer.mdextension.md_date = vals['md_date']
layer.mdextension.rndt_xml = rndt
layer.mdextension.elements_xml = request.raw_post_data
layer.mdextension.save()
return json_response(body={'success':True,'redirect': reverse('layer_detail', args=(layer.typename,))})
def post(self, request, *args, **kwargs):
out = {'success': False, 'status': 'error', 'data': [], 'errors': {}}
d = self.create(request, *args, **kwargs)
if d is None:
out['errors'] = self.errors
status = 400
else:
out['data'] = dump(d)
out['success'] = True
out['status'] = 'ok'
status = 200
return json_response(out, status=status)
def get(self, *args, **kwargs):
q = self.get_queryset()
out = []
for item in q:
out.append({'name': item.name,
'host': item.host.name,
'id': item.id,
'type': item.service_type.name,
'check_interval': item.check_interval.total_seconds(),
'last_check': item.last_check})
return json_response({'services': out})
def _annotations_get(req, mapid):
mapobj = resolve_object(req, Map, {'id': mapid}, permission='base.view_resourcebase')
cols = ['title', 'content', 'media', 'start_time', 'end_time', 'in_map', 'in_timeline', 'appearance', 'auto_show', 'pause_playback']
ann = Annotation.objects.filter(map=mapid)
ann = ann.order_by('start_time', 'end_time', 'title')
if bool(req.GET.get('in_map', False)):
ann = ann.filter(in_map=True)
if bool(req.GET.get('in_timeline', False)):
ann = ann.filter(in_timeline=True)
if 'page' in req.GET:
page = int(req.GET['page'])
page_size = 25
start = page * page_size
end = start + page_size
ann = ann[start:end]
if 'csv' in req.GET:
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename=map-%s-annotations.csv' % mapobj.id
response['Content-Encoding'] = 'utf-8'
writer = csv.writer(response)
writer.writerow(cols)
sidx = cols.index('start_time')
eidx = cols.index('end_time')
# default csv writer chokes on unicode
encode = lambda v: v.encode('utf-8') if isinstance(v, basestring) else str(v)
get_value = lambda a, c: getattr(a, c) if c not in ('start_time', 'end_time') else ''
for a in ann:
vals = [encode(get_value(a, c)) for c in cols]
vals[sidx] = a.start_time_str
vals[eidx] = a.end_time_str
writer.writerow(vals)
return response
# strip the superfluous id, it will be added at the feature level
props = [c for c in cols if c != 'id']
def encode(query_set):
results = []
for res in query_set:
feature = {'id': res.id}
if res.the_geom:
feature['geometry'] = res.the_geom
fp = feature['properties'] = {}
for p in props:
val = getattr(res, p)
if val is not None:
fp[p] = val
results.append(feature)
return results
return json_response({'type':'FeatureCollection','features':encode(ann)})
def listediml(request):
# body={'success':True,'redirect': reverse('layer_detail', args=(layer.typename,))}
data = []
for l in Layer.objects.all():
if l.mdextension.elements_xml is not None:
url = '%s%s/ediml' % (settings.SITEURL[:-1], l.get_absolute_url()),
data.append({'url': url})
if not data:
data.append('Not results')
return json_response(body=data)
def ediproxy_importmd(request):
# if SkRegistration.objects.get_current() is None:
# return json_response(errors='You must register the GET-IT before save a Metadata',
# status=500)
insertsensor = request.POST.get('generatedXml').encode('utf8')
ediml = request.POST.get('ediml').encode('utf8')
edimlid = request.POST.get('edimlid')
headers = {
'Accept': 'application/xml',
'Content-Type': 'application/xml',
'Authorization': "%s" % settings.SOS_SERVER['default']['TRANSACTIONAL_AUTHORIZATION_TOKEN']
}
sos_response = requests.post(
settings.SOS_SERVER['default']['LOCATION'] + '/pox',
data=insertsensor, headers=headers,
verify=False
)
if sos_response.status_code == 200:
tr = etree.fromstring(sos_response.content)
if tr.tag == nspath_eval("ows110:ExceptionReport", namespaces):
return json_response(exception=sos_response.text.encode('utf8'), status=500)
# save sensorml & edi xml
_ediml = etree.fromstring(ediml)
fileid = _ediml.find('fileId').text
sensor = Sensor(fileid=fileid)
sensor.sensorml = insertsensor
sensor.ediml = ediml
sensor.save()
return json_response(body={'success':True,'redirect': reverse('osk_browse')})
else:
return json_response(exception=sos_response.text.encode('utf8'), status=500)
def deletesensor(request, template='osk/osk_deletesensor.html'):
try:
if (request.method == 'GET'):
procedure = request.GET['procedure']
return render_to_response(template,RequestContext(request, {
"procedure": procedure
}))
if (request.method == 'POST'):
procedure = request.POST['procedure']
headers = {
'Accept': 'application/xml',
'Content-Type': 'application/xml',
'Authorization': "%s" % settings.SOS_SERVER['default']['TRANSACTIONAL_AUTHORIZATION_TOKEN']
}
params = {
'service': 'SOS',
'version': '2.0.0',
'request': 'DeleteSensor',
'procedure': procedure
}
sos_response = requests.get(
settings.SOS_SERVER['default']['LOCATION'] + '/kvp',
params=params,
headers=headers,
verify=False
)
if sos_response.status_code == 200:
tr = etree.fromstring(sos_response.content)
if tr.tag == nspath_eval("ows110:ExceptionReport", namespaces):
return json_response(exception=sos_response.text.encode('utf8'), status=500)
# force sos cache reload
force_soscache_reload()
# todo: remove Sensor object
return HttpResponseRedirect(reverse("osk_browse"))
else:
return HttpResponse("Not allowed",status=403)
except PermissionDenied:
return HttpResponse(
'You are not allowed to delete this layer',
mimetype="text/plain",
status=401
)
def get(self, request):
out = {'success': True}
data = []
out['data'] = data
# per-layer links
# for link in Link.objects.filter(link_type__in=LINK_TYPES): # .distinct('url'):
# data.append({'url': link.url, 'type': link.link_type})
data.append({'url': ows._wcs_get_capabilities(), 'type': 'OGC:WCS'})
data.append({'url': ows._wfs_get_capabilities(), 'type': 'OGC:WFS'})
data.append({'url': ows._wms_get_capabilities(), 'type': 'OGC:WMS'})
# catalogue from configuration
for catname, catconf in settings.CATALOGUE.items():
data.append({'url': catconf['URL'], 'type': 'OGC:CSW'})
# main site url
data.append({'url': settings.SITEURL, 'type': 'WWW:LINK'})
return json_response(out)
def get(self, request, *args, **kwargs):
capi = CollectorAPI()
checks = capi.get_notifications()
data = {'status': 'ok', 'success': True, 'data': {}}
d = data['data']
d['problems'] = problems = []
d['health_level'] = 'ok'
_levels = ('fatal', 'error', 'warning',)
levels = set([])
for nc, ncdata in checks:
for ncd in ncdata:
levels.add(ncd.severity)
problems.append(dump(ncd, self.fields))
if levels:
for l in _levels:
if l in levels:
d['health_level'] = l
break
return json_response(data)
def get(self, request, *args, **kwargs):
out = {'success': False, 'status': 'error', 'data': [], 'errors': {}}
status = 500
fields = ('field_name',
'steps',
'current_value',
'steps_calculated',
'unit',
'is_enabled',)
if request.user.is_authenticated():
obj = self.get_object()
out['success'] = True
out['status'] = 'ok'
form = obj.get_user_form()
fields = [dump(r, fields) for r in obj.definitions.all()]
out['data'] = {'form': form.as_table(),
'fields': fields,
'emails': obj.emails,
'notification': dump(obj)}
status = 200
else:
out['errors']['user'] = ['User is not authenticated']
status = 401
return json_response(out, status=status)
def respond(*args, **kw):
kw["content_type"] = "text/html"
return json_response(*args, **kw)
def rndt(request, layername):
layer = _resolve_layer(request, layername, 'base.view_layer', _PERMISSION_MSG_METADATA)
rndt = layer.mdextension.rndt_xml
return HttpResponse(rndt, content_type="text/xml")
def rndtproxy(request, layername):
layer = _resolve_layer(request, layername, 'base.change_layer', _PERMISSION_MSG_METADATA)
ediml = request.body
try:
rndt = _ediml2rndt(ediml)
except UnregisteredSKException, e:
return json_response(errors=e.message,
status=500)
if not rndt:
return json_response(errors='Cannot create RNDT',
status=500)
try:
_savelayermd(layer, rndt, ediml)
except Exception as e:
return json_response(exception=e, status=500)
return json_response(body={'success':True,'redirect': reverse('layer_detail', args=(layer.typename,))})
# return HttpResponseRedirect()
def _post_validate(vals):
errors = []
# check required fields
# required = [f.name for f in Layer._meta.fields if not f.blank]
# required = ['uuid', 'title', 'date', 'date_type', 'language', 'supplemental_information']
# Uuid could be None
# required = ['uuid', 'title', 'date', 'date_type', 'language']
def respond(*args, **kw):
kw['content_type'] = 'text/html'
return json_response(*args, **kw)
def _boxes_post(req, mapid):
mapobj = resolve_object(req, Map, {'id':mapid}, permission='base.change_resourcebase')
# default action
action = 'upsert'
# default for json to unpack properties for each 'row'
get_props = lambda r: r['properties']
# operation to run on completion
finish = lambda: None
# track created boxes
created = []
# csv or client to account for differences
form_mode = 'client'
content_type = None
overwrite = False
error_format = None
def id_collector(form):
created.append(form.instance.id)
if not req.FILES:
# json body
data = json.loads(req.body)
if isinstance(data, dict):
action = data.get('action', action)
if 'features' in data:
data = data.get('features')
else:
fp = iter(req.FILES.values()).next()
# ugh, builtin csv reader chokes on unicode
data = unicode_csv_dict_reader(fp)
id_collector = lambda f: None
form_mode = 'csv'
content_type = 'text/html'
get_props = lambda r: r
ids = list(StoryBox.objects.filter(map=mapobj).values_list('id', flat=True))
# delete existing, we overwrite
finish = lambda: StoryBox.objects.filter(id__in=ids).delete()
overwrite = True
def error_format(row_errors):
response = []
for re in row_errors:
row = re[0] + 1
for e in re[1]:
response.append('[%s] %s : %s' % (row, e, re[1][e]))
return 'The following rows had problems:<ul><li>' + '</li><li>'.join(response) + "</li></ul>"
if action == 'delete':
StoryBox.objects.filter(pk__in=data['ids'], map=mapobj).delete()
return json_response({'success': True})
if action != 'upsert':
return HttpResponse('%s not supported' % action, status=400)
errors = _write_boxes(data, get_props, id_collector, mapobj, overwrite, form_mode)
if errors:
transaction.rollback()
body = None
if error_format:
return HttpResponse(error_format(errors), status=400)
else:
finish()
transaction.commit()
body = {'success': True}
if created:
body['ids'] = created
return json_response(body=body, errors=errors, content_type=content_type)
def _boxes_get(req, mapid):
mapobj = resolve_object(req, Map, {'id': mapid}, permission='base.view_resourcebase')
cols = ['title', 'description', 'start_time', 'end_time', 'center', 'speed',
'interval', 'playback', 'playbackRate', 'intervalRate', 'zoom']
box = StoryBox.objects.filter(map=mapid)
box = box.order_by('start_time', 'end_time', 'title')
if bool(req.GET.get('in_map', False)):
box = box.filter(in_map=True)
if bool(req.GET.get('in_timeline', False)):
box = box.filter(in_timeline=True)
if 'page' in req.GET:
page = int(req.GET['page'])
page_size = 25
start = page * page_size
end = start + page_size
box = box[start:end]
if 'csv' in req.GET:
response = HttpResponse(mimetype='text/csv')
response['Content-Disposition'] = 'attachment; filename=map-%s-boxes.csv' % mapobj.id
response['Content-Encoding'] = 'utf-8'
writer = csv.writer(response)
writer.writerow(cols)
sidx = cols.index('start_time')
eidx = cols.index('end_time')
# default csv writer chokes on unicode
encode = lambda v: v.encode('utf-8') if isinstance(v, basestring) else str(v)
get_value = lambda a, c: getattr(a, c) if c not in ('start_time', 'end_time') else ''
for a in box:
vals = [encode(get_value(a, c)) for c in cols]
vals[sidx] = a.start_time_str
vals[eidx] = a.end_time_str
writer.writerow(vals)
return response
# strip the superfluous id, it will be added at the feature level
props = [c for c in cols if c != 'id']
def encode(query_set):
results = []
for res in query_set:
feature = { 'id' : res.id}
if res.the_geom:
feature['geometry'] = res.the_geom
fp = feature['properties'] = {}
for p in props:
val = getattr(res, p)
if val is not None:
if isinstance(val, unicode) and '{' in val:
import ast
fp[p] = ast.literal_eval(val)
elif isinstance(val, unicode) and '[' in val:
import ast
fp[p] = ast.literal_eval(val)
else:
fp[p] = val
results.append(feature)
return results
return json_response({'type':'FeatureCollection','features':encode(box)})
