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)