def _build_WFS_xml(self, service_param: str, version_param: str):
""" Returns a POST request for a web feature service as xml
Args:
service_param (str): The service param
version_param (str): The version param
Returns:
xml (str): The xml document
"""
xml = ""
request_param = self._get_POST_val("request")
if request_param == OGCOperationEnum.DESCRIBE_FEATURE_TYPE.value:
xml = self._build_describe_feature_type_xml(
service_param, version_param, request_param)
elif request_param == OGCOperationEnum.GET_FEATURE.value:
xml = self._build_get_feature_xml(service_param, version_param,
request_param)
elif request_param == OGCOperationEnum.LOCK_FEATURE.value:
xml = self._build_lock_feature_xml(service_param, version_param,
request_param)
elif request_param == OGCOperationEnum.TRANSACTION.value:
xml = self._build_transaction_xml()
else:
raise KeyError(PARAMETER_ERROR.format(request_param))
return xml
def filter_queryset_metadata_bbox(queryset, bbox: str, bbox_srs: str, bbox_strict: bool):
""" Filters a given REST framework queryset by a given bbox.
Args:
queryset: A queryset containing elements
bbox: A bbox string (four coordinates)
bbox_srs: Defines the reference system for the bbox
bbox_strict: Defines whether only results fully inside or intersected as well shall be returned
Returns:
queryset: The given queryset which only contains matching elements
"""
if bbox is not None and len(bbox) > 0:
try:
srs = int(bbox_srs.split(":")[-1])
except ValueError:
# The srs is not valid
raise Exception(PARAMETER_ERROR.format("bbox-srs"))
if not isinstance(bbox, list):
bbox = bbox.split(",")
bbox = GEOSGeometry(Polygon.from_bbox(bbox), srid=srs)
bbox.transform(DEFAULT_SRS)
if bbox_strict:
filter_identifier = "bounding_geometry__contained"
else:
filter_identifier = "bounding_geometry__bboverlaps"
queryset = queryset.filter(
**{filter_identifier: bbox}
)
return queryset
def active_state(self, request, pk=None):
""" Activates a service via remote access
Args:
request: The incoming request
pk: The service id
Returns:
Response
"""
user = user_helper.get_user(request)
parameter_name = "active"
new_status = request.POST.dict().get(parameter_name, None)
new_status = utils.resolve_boolean_attribute_val(new_status)
response = APIResponse()
if new_status is None or not isinstance(new_status, bool):
response.data["msg"] = PARAMETER_ERROR.format(parameter_name)
return Response(data=response.data, status=500)
try:
md = Metadata.objects.get(service__id=pk)
response.data["oldStatus"] = md.is_active
md.is_active = new_status
md.save()
response.data["newStatus"] = md.is_active
response.data["success"] = True
return Response(data=response.data, status=200)
except ObjectDoesNotExist:
response.data["msg"] = SERVICE_NOT_FOUND
return Response(data=response.data, status=404)
def build_POST_xml(self):
""" Builds a POST xml document, according to the OGC WMS/WFS specifications.
Returns:
xml (str): The xml document
"""
xml = None
# decide which specification must be used for POST XML building
version_param = self._get_POST_val("version")
request_param = self._get_POST_val("request")
service_param = self._get_POST_val("service").lower()
if version_param is None:
raise KeyError(PARAMETER_ERROR.format("VERSION"))
if service_param is None:
raise KeyError(PARAMETER_ERROR.format("SERVICE"))
if service_param == OGCServiceEnum.WFS.value.lower():
# WFS 1.0.0 - 2.0.2 all have the same POST xml specification
xml = self._build_WFS_xml(service_param, version_param)
elif service_param == OGCServiceEnum.WMS.value.lower():
if version_param == OGCServiceVersionEnum.V_1_0_0.value:
xml = self._build_WMS_1_0_0_xml(service_param, version_param,
request_param)
elif version_param == OGCServiceVersionEnum.V_1_1_1.value:
xml = self._build_WMS_1_1_1_xml(service_param, version_param,
request_param)
elif version_param == OGCServiceVersionEnum.V_1_3_0.value:
xml = self._build_WMS_1_3_0_xml(service_param, version_param,
request_param)
else:
raise KeyError(PARAMETER_ERROR.format(version_param))
else:
raise KeyError(PARAMETER_ERROR.format(service_param))
return xml
def get_resource_capabilities(request: HttpRequest, md: Metadata):
""" Logic for retrieving a capabilities document.
If no capabilities document can be provided by the given parameter, a fallback document will be returned.
Args:
request:
md:
Returns:
"""
from service.tasks import async_increase_hits
stored_version = md.get_service_version().value
# move increasing hits to background process to speed up response time!
# todo: after refactoring of md.increase_hits() maybe we don't need to start async tasks... test it!!!
async_increase_hits.delay(md.id)
if not md.is_active:
return HttpResponse(content=SERVICE_DISABLED, status=423)
# check that we have the requested version in our database
version_param = None
version_tag = None
request_param = None
request_tag = None
use_fallback = None
for k, v in request.GET.dict().items():
if k.upper() == "VERSION":
version_param = v
version_tag = k
elif k.upper() == "REQUEST":
request_param = v
request_tag = k
elif k.upper() == "FALLBACK":
use_fallback = resolve_boolean_attribute_val(v)
# No version parameter has been provided by the request - we simply use the one we have.
if version_param is None or len(version_param) == 0:
version_param = stored_version
if version_param not in [data.value for data in OGCServiceVersionEnum]:
# version number not valid
return HttpResponse(content=PARAMETER_ERROR.format(version_tag), status=404)
elif request_param is not None and request_param != OGCOperationEnum.GET_CAPABILITIES.value:
# request not valid
return HttpResponse(content=PARAMETER_ERROR.format(request_tag), status=404)
else:
pass
if md.is_catalogue_metadata:
doc = md.get_remote_original_capabilities_document(version_param)
elif stored_version == version_param or use_fallback is True or not md.is_root():
# This is the case if
# 1) a version is requested, which we have in our database
# 2) the fallback parameter is set explicitly
# 3) a subelement is requested, which normally do not have capability documents
# We can check the cache for this document or we need to generate it!
doc = md.get_current_capability_xml(version_param)
else:
# we have to fetch the remote document
# fetch the requested capabilities document from remote - we do not provide this as our default (registered) one
xml = md.get_remote_original_capabilities_document(version_param)
tmp = xml_helper.parse_xml(xml)
if tmp is None:
raise ValueError("No xml document was retrieved. Content was :'{}'".format(xml))
# we fake the persisted service version, so the document setters will change the correct elements in the xml
# md.service.service_type.version = version_param
doc = Document(
content=xml,
metadata=md,
document_type=DocumentEnum.CAPABILITY.value,
is_original=True
)
doc.set_capabilities_secured(auto_save=False)
if md.use_proxy_uri:
doc.set_proxy(True, auto_save=False, force_version=version_param)
doc = doc.content
return doc