def lookup_coverages(self, decoder): sections = decoder.sections inc_coverages = ("all" in sections or "contents" in sections or "coveragesummary" in sections) inc_dataset_series = ("all" in sections or "contents" in sections or "datasetseriessummary" in sections) if inc_coverages: cql_text = decoder.cql if cql_text: qs = models.EOObject.objects.all() mapping, mapping_choices = filters.get_field_mapping_for_model( models.Coverage # TODO: allow mapping to Mosaic as-well? ) ast = parse(cql_text) filter_expressions = to_filter(ast, mapping, mapping_choices) qs = qs.filter(filter_expressions) else: qs = models.EOObject.objects.filter( service_visibility__service='wcs', service_visibility__visibility=True) qs = qs.order_by('id').select_subclasses(models.Coverage, models.Mosaic) coverages = [from_model(coverage) for coverage in qs] else: coverages = [] if inc_dataset_series: cql_text = decoder.datasetseriescql if cql_text: qs = models.EOObject.objects.all() mapping, mapping_choices = filters.get_field_mapping_for_model( qs. model # TODO: mapping to Collection/Product would be better ) ast = parse(cql_text) filter_expressions = to_filter(ast, mapping, mapping_choices) qs = qs.filter(filter_expressions) dataset_series_qs = models.EOObject.objects.filter( Q(product__isnull=False, service_visibility__service='wcs', service_visibility__visibility=True) | Q(collection__isnull=False)).exclude( collection__isnull=False, service_visibility__service='wcs', service_visibility__visibility=False) # reduce data transfer by only selecting required elements dataset_series_qs = dataset_series_qs.only("identifier", "begin_time", "end_time", "footprint") else: dataset_series_qs = models.EOObject.objects.none() return coverages, dataset_series_qs
def filter(self, qs, parameters): mapping, mapping_choices = filters.get_field_mapping_for_model( qs.model) decoder = EarthObservationExtensionDecoder(parameters) query_filters = [] for filter_name, db_accessor in mapping.items(): value = getattr(decoder, filter_name, None) if value: attr = filters.attribute(filter_name, mapping) if isinstance(value, list): query_filters.append(filters.contains(attr, value)) elif isinstance(value, dict): if 'min' in value: query_filters.append( filters.compare( attr, value['min'], '>=' if value['min_inclusive'] else '>', mapping_choices)) if 'max' in value: query_filters.append( filters.compare( attr, value['max'], '<=' if value['max_inclusive'] else '<', mapping_choices)) else: query_filters.append( filters.compare(attr, value, '=', mapping_choices)) if query_filters: qs = qs.filter(filters.combine(query_filters, 'AND')) return qs
def lookup_coverages(self, decoder): """ Default implementation of the coverage lookup. Simply returns all coverages in no specific order. """ cql_text = decoder.cql if cql_text: qs = models.EOObject.objects.all() 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: qs = models.EOObject.objects.filter( Q(service_visibility__service='wcs', service_visibility__visibility=True) | Q( # include mosaics with a Grid mosaic__isnull=False, mosaic__grid__isnull=False, service_visibility__service='wcs', service_visibility__visibility=True)) return qs.order_by("identifier").select_subclasses( models.Coverage, models.Mosaic)
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 filter(self, qs, parameters): mapping, mapping_choices = filters.get_field_mapping_for_model( qs.model) decoder = CQLExtensionDecoder(parameters) cql_text = decoder.cql if cql_text: ast = ecql.parse(cql_text) filter_expressions = ecql.to_filter(ast, mapping, mapping_choices) qs = qs.filter(filter_expressions) return qs
def handle(self, cql_filters, **options): self.verbosity = int(options.get('verbosity', 1)) # get the model class and the field mapping (with choices) ModelClass = getattr(models, options.get('type')) mapping, mapping_choices = get_field_mapping_for_model(ModelClass) # print the available attributes, if requested if options.get('show_attributes'): print("\n".join(mapping.keys())) return # filter by collection, if requested collection_id = options.get('collection_id') if collection_id: try: collection = models.Collection.objects.get( identifier=collection_id ) qs = ModelClass.objects.filter(collections__in=[collection.pk]) except models.Collection.DoesNotExist: raise CommandError('No such collection %r' % collection_id) else: qs = ModelClass.objects.all() if len(cql_filters) < 1: raise CommandError('No CQL filter passed.') for cql_filter in cql_filters: ast = parse(cql_filter) if self.verbosity >= 2: self.print_msg(get_repr(ast), 2) filters = to_filter(ast, mapping, mapping_choices) if not filters: raise CommandError('Invalid filter specified') if options['exclude']: qs = ModelClass.objects.exclude(filters) else: qs = ModelClass.objects.filter(filters) if self.verbosity >= 2: self.print_msg(filters, 2) qs = qs.values_list('identifier', flat=True) print ("\n".join(qs))
def get_schema(self, collection=None, model_class=None): mapping, mapping_choices = filters.get_field_mapping_for_model( model_class or models.Product, True) schema = [] summary = None if collection: summary = self._load_product_summary(collection) for key, value in mapping.items(): param = dict(name=key, type=key) if summary: param_summary = summary.get(key) # leave out all parameters not present in the summary if not self._is_param_summary_valid(param_summary): continue # insert information from the parameter summary if isinstance(param_summary, list): param['options'] = param_summary elif isinstance(param_summary, dict): min_ = param_summary.get('min') max_ = param_summary.get('max') if min_ is not None: param['min'] = min_ if max_ is not None: param['max'] = max_ # use the mapping choices to get a list of options, if possible if 'options' not in param and value in mapping_choices: param['options'] = list(mapping_choices[value].keys()) schema.append(param) return schema