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 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 handle(self, request):
decoder = self.get_decoder(request)
minx, miny, maxx, maxy = decoder.bbox
x = decoder.x
y = decoder.y
time = decoder.time
crs = decoder.srs
layer_names = decoder.layers
width = decoder.width
height = decoder.height
# calculate the zoomlevel
zoom = calculate_zoom((minx, miny, maxx, maxy), width, height, crs)
if not layer_names:
raise InvalidParameterException("No layers specified", "layers")
srid = crss.parseEPSGCode(
crs, (crss.fromShortCode, crss.fromURN, crss.fromURL))
if srid is None:
raise InvalidCRS(crs, "crs")
field_mapping, mapping_choices = get_field_mapping_for_model(
models.Product)
# calculate resolution
# TODO: dateline
resx = (maxx - minx) / width
resy = (maxy - miny) / height
p_minx = x * resx
p_miny = y * resy
p_maxx = (x + 1) * resx
p_maxy = (y + 1) * resy
filter_expressions = filters.bbox(filters.attribute(
'footprint', field_mapping),
p_minx,
p_miny,
p_maxx,
p_maxy,
crs,
bboverlaps=False)
if time:
filter_expressions &= filters.time_interval(time)
cql = getattr(decoder, 'cql', None)
if cql:
cql_filters = to_filter(parse(cql), field_mapping, mapping_choices)
filter_expressions &= cql_filters
# TODO: multiple sorts per layer?
sort_by = getattr(decoder, 'sort_by', None)
if sort_by:
sort_by = (field_mapping.get(sort_by[0], sort_by[0]), sort_by[1])
styles = decoder.styles
if styles:
styles = styles.split(',')
else:
styles = [None] * len(layer_names)
dimensions = {
"time": time,
"elevation": decoder.elevation,
"ranges": decoder.dim_range,
"bands": decoder.dim_bands,
"wavelengths": decoder.dim_wavelengths,
}
feature_info_renderer = get_feature_info_renderer()
layer_mapper = LayerMapper(
feature_info_renderer.get_supported_layer_types(), "__")
layers = []
for layer_name, style in zip(layer_names, styles):
name, suffix = layer_mapper.split_layer_suffix_name(layer_name)
layer = layer_mapper.lookup_layer(name,
suffix,
style,
filter_expressions,
sort_by,
zoom=zoom,
**dimensions)
layers.append(layer)
map_ = Map(width=decoder.width,
height=decoder.height,
format=decoder.format,
bbox=(minx, miny, maxx, maxy),
crs=crs,
bgcolor=decoder.bgcolor,
transparent=decoder.transparent,
layers=layers)
result_bytes, content_type, filename = feature_info_renderer.render_feature_info(
map_)
response = HttpResponse(result_bytes, content_type=content_type)
if filename:
response[
'Content-Disposition'] = 'inline; filename="%s"' % filename
return response