def encode_capabilities(processes):
""" Encode Capabilities XML document. """
conf = CapabilitiesConfigReader(get_eoxserver_config())
# Avoid duplicate process offerings ...
process_set = set()
process_offerings = []
for process in processes:
process_identifier = (getattr(process, 'identifier', None)
or type(process).__name__)
if process_identifier not in process_set:
process_offerings.append(encode_process_brief(process))
process_set.add(process_identifier)
return WPS(
"Capabilities",
OWS(
"ServiceIdentification",
OWS("Title", conf.title),
OWS("Abstract", conf.abstract),
OWS("Keywords", *(OWS("Keyword", kw) for kw in conf.keywords)),
OWS("ServiceType", "WPS"),
OWS("ServiceTypeVersion", "1.0.0"),
OWS("Fees", conf.fees),
OWS("AccessConstraints", conf.access_constraints),
),
OWS(
"ServiceProvider", OWS("ProviderName", conf.provider_name),
OWS("ProviderSite", **{ns_xlink("href"): conf.provider_site}),
OWS(
"ServiceContact",
OWS("IndividualName", conf.individual_name),
OWS("PositionName", conf.position_name),
OWS(
"ContactInfo",
OWS("Phone", OWS("Voice", conf.phone_voice),
OWS("Facsimile", conf.phone_facsimile)),
OWS(
"Address", OWS("DeliveryPoint",
conf.delivery_point),
OWS("City", conf.city),
OWS("AdministrativeArea",
conf.administrative_area),
OWS("PostalCode", conf.postal_code),
OWS("Country", conf.country),
OWS("ElectronicMailAddress",
conf.electronic_mail_address))))),
_encode_operations_metadata(conf),
WPS("ProcessOfferings", *process_offerings),
WPS("Languages", WPS("Default", OWS("Language", "en-US")),
WPS("Supported", OWS("Language", "en-US"))),
# TODO: WPS("WSDL")
**{
"service": "WPS",
"version": "1.0.0",
ns_xml("lang"): "en-US",
"updateSequence": conf.update_sequence,
})
def render(self, layer_groups, request_values, request, **options):
config = CapabilitiesConfigReader(get_eoxserver_config())
http_service_url = get_http_service_url(request)
map_ = ms.Map()
map_.setMetaData({
"enable_request": "*",
"onlineresource": http_service_url,
}, namespace="ows")
map_.setMetaData("wms_getfeatureinfo_formatlist", "text/html")
map_.setProjection("EPSG:4326")
session = self.setup_map(layer_groups, map_, options)
# check if the required format is EO O&M
frmt = pop_param(request_values, "info_format")
use_eoom = False
if frmt in ("application/xml", "text/xml"):
request_values.append(("info_format", "application/vnd.ogc.gml"))
use_eoom = True
else:
request_values.append(("info_format", frmt))
with session:
request = ms.create_request(request_values)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
if not use_eoom:
# just return the response
return result, get_content_type(result)
else:
# do a postprocessing step and get all identifiers in order
# to encode them with EO O&M
decoder = GMLFeatureDecoder(result[0].data_file.read())
identifiers = decoder.identifiers
coverages = models.Coverage.objects.filter(
identifier__in=identifiers
)
# sort the result with the returned order of coverages
lookup_table = dict((c.identifier, c) for c in coverages)
coverages = [
lookup_table[identifier] for identifier in identifiers
]
# encode the coverages with the EO O&M
encoder = WCS20EOXMLEncoder()
return [
ResultBuffer(
encoder.serialize(
encoder.encode_coverage_descriptions(coverages)
), encoder.content_type
)
], encoder.content_type
def handle(self, request):
decoder = self.get_decoder(request)
qs = models.EOObject.objects.all()
cql_text = decoder.cql
if cql_text:
mapping, mapping_choices = filters.get_field_mapping_for_model(
qs.model)
ast = parse(cql_text)
filter_expressions = to_filter(ast, mapping, mapping_choices)
qs = qs.filter(filter_expressions)
else:
# lookup Collections, Products and Coverages
qs = models.EOObject.objects.filter(
Q( # include "WMS-visible" Products
product__isnull=False,
service_visibility__service='wms',
service_visibility__visibility=True)
| Q( # include "WMS-visible" Coverages
coverage__isnull=False,
service_visibility__service='wms',
service_visibility__visibility=True)
| Q( # include all Collections, exclude "WMS-invisible" later
collection__isnull=False)).exclude(
collection__isnull=False,
service_visibility__service='wms',
service_visibility__visibility=False)
qs = qs.select_subclasses()
#
map_renderer = get_map_renderer()
raster_styles = map_renderer.get_raster_styles()
geometry_styles = map_renderer.get_geometry_styles()
layer_mapper = LayerMapper(map_renderer.get_supported_layer_types(),
"__")
layer_descriptions = [
layer_mapper.get_layer_description(eo_object, raster_styles,
geometry_styles)
for eo_object in qs
]
encoder = self.get_encoder()
conf = CapabilitiesConfigReader(get_eoxserver_config())
return encoder.serialize(
encoder.encode_capabilities(
conf, request.build_absolute_uri(reverse(views.ows)),
crss.getSupportedCRS_WMS(format_function=crss.asShortCode),
map_renderer.get_supported_formats(), [], layer_descriptions),
pretty_print=settings.DEBUG), encoder.content_type
def _encode_common_response(process, status_elem, inputs, raw_inputs,
resp_doc):
"""Encode common execute response part shared by all specific responses."""
inputs = inputs or {}
conf = CapabilitiesConfigReader(get_eoxserver_config())
url = conf.http_service_url
if url[-1] == "?":
url = url[:-1]
elem = WPS(
"ExecuteResponse",
encode_process_brief(process),
WPS("Status", status_elem, creationTime=isoformat(now())),
{
"service":
"WPS",
"version":
"1.0.0",
ns_xml("lang"):
"en-US",
"serviceInstance":
("%s?service=WPS&version=1.0.0&request=GetCapabilities" % url)
},
)
if resp_doc.lineage:
inputs_data = []
for id_, prm in process.inputs:
if isinstance(prm, RequestParameter):
continue
prm = fix_parameter(id_, prm)
data = inputs.get(id_)
rawinp = raw_inputs.get(prm.identifier)
if rawinp is not None:
inputs_data.append(_encode_input(data, prm, rawinp))
elem.append(WPS("DataInputs", *inputs_data))
outputs_def = []
for id_, prm in process.outputs:
prm = fix_parameter(id_, prm)
outdef = resp_doc.get(prm.identifier)
if outdef is not None:
outputs_def.append(encode_output_def(outdef))
elem.append(WPS("OutputDefinitions", *outputs_def))
return elem
def encode_capabilities(self, request, sections):
conf = CapabilitiesConfigReader(get_eoxserver_config())
all_sections = "all" in sections
caps = []
if all_sections or "serviceidentification" in sections:
caps.append(self.encode_service_identification("DSEO", conf, []))
if all_sections or "serviceprovider" in sections:
caps.append(self.encode_service_provider(conf))
if all_sections or "operationsmetadata" in sections:
caps.append(
self.encode_operations_metadata(request, "DSEO", ["1.0.0"]))
return DSEO("Capabilities",
*caps,
version="1.0.0",
updateSequence=conf.update_sequence)
def encode_capabilities(self,
sections,
coverages_qs=None,
dataset_series_qs=None,
request=None):
conf = CapabilitiesConfigReader(get_eoxserver_config())
all_sections = "all" in sections
caps = []
if all_sections or "serviceidentification" in sections:
caps.append(self.encode_service_identification(conf))
if all_sections or "serviceprovider" in sections:
caps.append(self.encode_service_provider(conf))
if all_sections or "operationsmetadata" in sections:
caps.append(self.encode_operations_metadata(request))
if all_sections or "servicemetadata" in sections:
caps.append(self.encode_service_metadata())
inc_contents = all_sections or "contents" in sections
inc_coverage_summary = inc_contents or "coveragesummary" in sections
inc_dataset_series_summary = (inc_contents
or "datasetseriessummary" in sections)
if inc_contents or inc_coverage_summary or inc_dataset_series_summary:
caps.append(
self.encode_contents(
coverages_qs if inc_coverage_summary else None,
dataset_series_qs if inc_dataset_series_summary else None))
return WCS("Capabilities",
*caps,
version="2.0.1",
updateSequence=conf.update_sequence)
def get_conf(self):
from eoxserver.core.config import get_eoxserver_config
return CapabilitiesConfigReader(get_eoxserver_config())
def render(self, params):
conf = CapabilitiesConfigReader(get_eoxserver_config())
http_service_url = get_http_service_url(params.http_request)
map_ = Map()
map_.setMetaData(
{
"enable_request":
"*",
"onlineresource":
http_service_url,
"service_onlineresource":
conf.onlineresource,
"updateSequence":
conf.update_sequence,
"name":
conf.name,
"title":
conf.title,
"label":
conf.title,
"abstract":
conf.abstract,
"accessconstraints":
conf.access_constraints,
"addresstype":
"",
"address":
conf.delivery_point,
"stateorprovince":
conf.administrative_area,
"city":
conf.city,
"postcode":
conf.postal_code,
"country":
conf.country,
"contactelectronicmailaddress":
conf.electronic_mail_address,
"contactfacsimiletelephone":
conf.phone_facsimile,
"contactvoicetelephone":
conf.phone_voice,
"contactperson":
conf.individual_name,
"contactorganization":
conf.provider_name,
"contactposition":
conf.position_name,
"role":
conf.role,
"hoursofservice":
conf.hours_of_service,
"contactinstructions":
conf.contact_instructions,
"fees":
conf.fees,
"keywordlist":
",".join(conf.keywords),
"formats":
" ".join([f.wcs10name for f in self.get_wcs_formats()]),
"srs":
" ".join(
crss.getSupportedCRS_WCS(
format_function=crss.asShortCode)),
},
namespace="ows")
map_.setProjection("EPSG:4326")
for outputformat in self.get_all_outputformats(False):
map_.appendOutputFormat(outputformat)
for coverage in params.coverages:
layer = Layer(coverage.identifier)
render_coverage = Coverage.from_model(coverage)
layer.setProjection(render_coverage.grid.spatial_reference.proj)
extent = render_coverage.extent
size = render_coverage.size
resolution = ((extent[2] - extent[0]) / float(size[0]),
(extent[1] - extent[3]) / float(size[1]))
layer.setExtent(*extent)
layer.setMetaData(
{
"title":
coverage.identifier,
"label":
coverage.identifier,
"extent":
"%.10g %.10g %.10g %.10g" % extent,
"resolution":
"%.10g %.10g" % resolution,
"size":
"%d %d" % size,
"formats":
" ".join([f.wcs10name for f in self.get_wcs_formats()]),
"srs":
" ".join(
crss.getSupportedCRS_WCS(
format_function=crss.asShortCode)),
},
namespace="wcs")
map_.insertLayer(layer)
request = create_request(params)
request.setParameter("version", params.version)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
xml_result = etree.fromstring(result[0].data)
for elem in xml_result.xpath('//*[local-name() = "metadataLink"]'):
elem.getparent().remove(elem)
# Add CQL parameter to GetCapabilities operation
for elem in xml_result.xpath(
'//*[local-name() = "Operation"][@name = "GetCapabilities"]'):
ows = elem.nsmap['ows']
param = etree.SubElement(elem, '{%s}Parameter' % ows)
param.attrib['name'] = 'cql'
etree.SubElement(param, '{%s}AnyValue' % ows)
xml_result_data = etree.tostring(xml_result,
pretty_print=True,
encoding='UTF-8',
xml_declaration=True)
result[0] = ResultBuffer(xml_result_data, result[0].content_type)
return result
def render(self, params):
conf = CapabilitiesConfigReader(get_eoxserver_config())
http_service_url = get_http_service_url(params.http_request)
map_ = Map()
map_.setMetaData({
"enable_request": "*",
"onlineresource": http_service_url,
"service_onlineresource": conf.onlineresource,
"updateSequence": conf.update_sequence,
"name": conf.name,
"title": conf.title,
"label": conf.title,
"abstract": conf.abstract,
"accessconstraints": conf.access_constraints,
"addresstype": "",
"address": conf.delivery_point,
"stateorprovince": conf.administrative_area,
"city": conf.city,
"postcode": conf.postal_code,
"country": conf.country,
"contactelectronicmailaddress": conf.electronic_mail_address,
"contactfacsimiletelephone": conf.phone_facsimile,
"contactvoicetelephone": conf.phone_voice,
"contactperson": conf.individual_name,
"contactorganization": conf.provider_name,
"contactposition": conf.position_name,
"role": conf.role,
"hoursofservice": conf.hours_of_service,
"contactinstructions": conf.contact_instructions,
"fees": conf.fees,
"keywordlist": ",".join(conf.keywords),
"formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]),
"srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)),
}, namespace="ows")
map_.setProjection("EPSG:4326")
for outputformat in self.get_all_outputformats(False):
map_.appendOutputFormat(outputformat)
for coverage in params.coverages:
layer = Layer(coverage.identifier)
layer.setProjection(coverage.spatial_reference.proj)
extent = coverage.extent
size = coverage.size
resolution = ((extent[2] - extent[0]) / float(size[0]),
(extent[1] - extent[3]) / float(size[1]))
layer.setExtent(*extent)
layer.setMetaData({
"title": coverage.identifier,
"label": coverage.identifier,
"extent": "%.10g %.10g %.10g %.10g" % extent,
"resolution": "%.10g %.10g" % resolution,
"size": "%d %d" % size,
"formats": " ".join([f.wcs10name for f in self.get_wcs_formats()]),
"srs": " ".join(crss.getSupportedCRS_WCS(format_function=crss.asShortCode)),
}, namespace="wcs")
map_.insertLayer(layer)
request = create_request(params)
request.setParameter("version", params.version)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
return result
def render(self, collections, coverages, request_values, request):
conf = CapabilitiesConfigReader(get_eoxserver_config())
suffixes = self.suffixes
http_service_url = get_http_service_url(request)
map_ = Map()
map_.setMetaData(
{
"enable_request":
"*",
"onlineresource":
http_service_url,
"service_onlineresource":
conf.onlineresource,
"updateSequence":
conf.update_sequence,
"name":
conf.name,
"title":
conf.title,
"abstract":
conf.abstract,
"accessconstraints":
conf.access_constraints,
"addresstype":
"postal",
"address":
conf.delivery_point,
"stateorprovince":
conf.administrative_area,
"city":
conf.city,
"postcode":
conf.postal_code,
"country":
conf.country,
"contactelectronicmailaddress":
conf.electronic_mail_address,
"contactfacsimiletelephone":
conf.phone_facsimile,
"contactvoicetelephone":
conf.phone_voice,
"contactperson":
conf.individual_name,
"contactorganization":
conf.provider_name,
"contactposition":
conf.position_name,
"fees":
conf.fees,
"keywordlist":
",".join(conf.keywords),
"srs":
" ".join(
crss.getSupportedCRS_WCS(
format_function=crss.asShortCode)),
},
namespace="ows")
map_.setProjection("EPSG:4326")
map_.setMetaData(
{
"getmap_formatlist":
",".join([f.mimeType for f in self.get_wms_formats()]),
"getfeatureinfo_formatlist":
"text/html,application/vnd.ogc.gml,text/plain",
},
namespace="wms")
map_extent = None
for collection in collections:
group_name = None
# calculate extent and timextent for every collection
extent = collection.extent_wgs84
# save overall map extent
map_extent = self.join_extents(map_extent, extent)
eo_objects = collection.eo_objects.filter(begin_time__isnull=False,
end_time__isnull=False)
timeextent = ",".join(
map(
lambda o:
("/".join(map(isoformat, o.time_extent)) + "/PT1S"),
eo_objects))
if len(suffixes) > 1:
# create group layer, if there is more than one suffix for this
# collection
group_name = collection.identifier + "_group"
group_layer = Layer(group_name)
group_layer.setMetaData(
{
"title": group_name,
"abstract": group_name,
"extent": " ".join(map(str, extent)),
},
namespace="wms")
minx, miny, maxx, maxy = extent
group_layer.setExtent(minx, miny, maxx, maxy)
# add default style
default_class = Class("default")
default_style = Style("default")
default_class.insertStyle(default_style)
group_layer.insertClass(default_class)
map_.insertLayer(group_layer)
for suffix in suffixes:
layer_name = collection.identifier + (suffix or "")
layer = Layer(layer_name)
if group_name:
layer.setMetaData({"layer_group": "/" + group_name},
namespace="wms")
layer.setMetaData(
{
"title": layer_name,
"abstract": layer_name,
"extent": " ".join(map(str, extent)),
"timeextent": timeextent,
},
namespace="wms")
map_.insertLayer(layer)
for coverage in coverages:
extent = coverage.extent_wgs84
minx, miny, maxx, maxy = extent
# save overall map extent
map_extent = self.join_extents(map_extent, extent)
layer_name = coverage.identifier
layer = Layer(layer_name)
layer.setMetaData(
{
"title": layer_name,
"abstract": layer_name,
"extent": " ".join(map(str, extent)),
},
namespace="wms")
minx, miny, maxx, maxy = extent
layer.setExtent(minx, miny, maxx, maxy)
map_.insertLayer(layer)
# set the map_extent to a reasonable default value
# in case there is no coverage or collection
if map_extent is None:
map_extent = (0.0, 0.0, 1.0, 1.0)
map_minx, map_miny, map_maxx, map_maxy = map_extent
map_.setExtent(map_minx, map_miny, map_maxx, map_maxy)
request = create_request(request_values)
raw_result = map_.dispatch(request)
result = result_set_from_raw_data(raw_result)
return result, get_content_type(result)