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