void writeGetMap( QgsServerInterface* serverIface, const QString& version,
const QgsServerRequest& request,
QgsServerResponse& response )
{
Q_UNUSED( version );
QgsServerRequest::Parameters params = request.parameters();
QgsWmsConfigParser* parser = getConfigParser( serverIface );
QgsWmsServer server( serverIface->configFilePath(),
*serverIface->serverSettings(), params, parser,
serverIface->accessControls() );
QScopedPointer<QImage> result( server.getMap() );
if ( !result.isNull() )
{
QString format = params.value( QStringLiteral( "FORMAT" ), QStringLiteral( "PNG" ) );
writeImage( response, *result, format, server.getImageQuality() );
}
else
{
throw QgsServiceException( QStringLiteral( "UnknownError" ),
QStringLiteral( "Failed to compute GetMap image" ) );
}
}
void writeAsDxf( QgsServerInterface *serverIface, const QgsProject *project,
const QString &version, const QgsServerRequest &request,
QgsServerResponse &response )
{
Q_UNUSED( version );
QgsServerRequest::Parameters params = request.parameters();
QgsWmsParameters wmsParameters( QUrlQuery( request.url() ) );
QgsRenderer renderer( serverIface, project, wmsParameters );
QMap<QString, QString> formatOptionsMap = parseFormatOptions( params.value( QStringLiteral( "FORMAT_OPTIONS" ) ) );
QgsDxfExport dxf = renderer.getDxf( formatOptionsMap );
QString codec = QStringLiteral( "ISO-8859-1" );
QMap<QString, QString>::const_iterator codecIt = formatOptionsMap.find( QStringLiteral( "CODEC" ) );
if ( codecIt != formatOptionsMap.constEnd() )
{
codec = formatOptionsMap.value( QStringLiteral( "CODEC" ) );
}
// Write output
response.setHeader( "Content-Type", "application/dxf" );
dxf.writeToFile( response.io(), codec );
}
QDomDocument getStyle( QgsServerInterface *serverIface, const QgsProject *project, const QString &version,
const QgsServerRequest &request )
{
Q_UNUSED( version );
QgsServerRequest::Parameters parameters = request.parameters();
QDomDocument doc;
QString styleName = parameters.value( QStringLiteral( "STYLE" ) );
QString layerName = parameters.value( QStringLiteral( "LAYER" ) );
if ( styleName.isEmpty() )
{
throw QgsBadRequestException( QgsServiceException::QGIS_MissingParameterValue,
QgsWmsParameter::STYLE );
}
if ( layerName.isEmpty() )
{
throw QgsBadRequestException( QgsServiceException::QGIS_MissingParameterValue,
QgsWmsParameter::LAYERS );
}
QStringList layerList;
layerList.append( layerName );
return getStyledLayerDescriptorDocument( serverIface, project, layerList );
}
void readLayersAndStyles( const QgsServerRequest::Parameters ¶meters, QStringList &layersList, QStringList &stylesList )
{
//get layer and style lists from the parameters trying LAYERS and LAYER as well as STYLE and STYLES for GetLegendGraphic compatibility
layersList = parameters.value( QStringLiteral( "LAYER" ) ).split( ',', QString::SkipEmptyParts );
layersList = layersList + parameters.value( QStringLiteral( "LAYERS" ) ).split( ',', QString::SkipEmptyParts );
stylesList = parameters.value( QStringLiteral( "STYLE" ) ).split( ',', QString::SkipEmptyParts );
stylesList = stylesList + parameters.value( QStringLiteral( "STYLES" ) ).split( ',', QString::SkipEmptyParts );
}
void QgsRequestHandler::setupParameters()
{
const QgsServerRequest::Parameters parameters = mRequest.parameters();
// SLD
QString value = parameters.value( QStringLiteral( "SLD" ) );
if ( !value.isEmpty() )
{
QgsMessageLog::logMessage( QStringLiteral( "http and ftp methods not supported with Qt5." ) );
}
// SLD_BODY
value = parameters.value( QStringLiteral( "SLD_BODY" ) );
if ( ! value.isEmpty() )
{
mRequest.setParameter( QStringLiteral( "SLD" ), value );
}
//feature info format?
QString infoFormat = parameters.value( QStringLiteral( "INFO_FORMAT" ) );
if ( !infoFormat.isEmpty() )
{
mFormat = infoFormat;
}
else //capabilities format or GetMap format
{
mFormatString = parameters.value( QStringLiteral( "FORMAT" ) );
QString formatString = mFormatString;
if ( !formatString.isEmpty() )
{
QgsMessageLog::logMessage( QStringLiteral( "formatString is: %1" ).arg( formatString ) );
//remove the image/ in front of the format
if ( formatString.contains( QLatin1String( "image/png" ), Qt::CaseInsensitive ) || formatString.compare( QLatin1String( "png" ), Qt::CaseInsensitive ) == 0 )
{
formatString = QStringLiteral( "PNG" );
}
else if ( formatString.contains( QLatin1String( "image/jpeg" ), Qt::CaseInsensitive ) || formatString.contains( QLatin1String( "image/jpg" ), Qt::CaseInsensitive )
|| formatString.compare( QLatin1String( "jpg" ), Qt::CaseInsensitive ) == 0 )
{
formatString = QStringLiteral( "JPG" );
}
else if ( formatString.compare( QLatin1String( "svg" ), Qt::CaseInsensitive ) == 0 )
{
formatString = QStringLiteral( "SVG" );
}
else if ( formatString.contains( QLatin1String( "pdf" ), Qt::CaseInsensitive ) )
{
formatString = QStringLiteral( "PDF" );
}
mFormat = formatString;
}
}
}
void executeRequest( const QgsServerRequest& request, QgsServerResponse& response,
const QgsProject* project )
{
QgsServerRequest::Parameters params = request.parameters();
QString versionString = params.value( "VERSION" );
// Set the default version
if ( versionString.isEmpty() )
{
versionString = version(); // defined in qgswfsutils.h
}
// Get the request
QString req = params.value( QStringLiteral( "REQUEST" ) );
if ( req.isEmpty() )
{
throw QgsServiceException( QStringLiteral( "OperationNotSupported" ),
QStringLiteral( "Please check the value of the REQUEST parameter" ) );
}
if ( QSTR_COMPARE( req, "GetCapabilities" ) )
{
writeGetCapabilities( mServerIface, project, versionString, request, response );
}
else if ( QSTR_COMPARE( req, "GetFeature" ) )
{
writeGetFeature( mServerIface, project, versionString, request, response );
}
else if ( QSTR_COMPARE( req, "DescribeFeatureType" ) )
{
writeDescribeFeatureType( mServerIface, versionString, request, response );
}
else if ( QSTR_COMPARE( req, "Transaction" ) )
{
writeTransaction( mServerIface, versionString, request, response );
}
else
{
// Operation not supported
throw QgsServiceException( QStringLiteral( "OperationNotSupported" ),
QStringLiteral( "Request %1 is not supported" ).arg( req ) );
}
}
void writeGetPrint( QgsServerInterface *serverIface, const QgsProject *project,
const QString &version, const QgsServerRequest &request,
QgsServerResponse &response )
{
QgsServerRequest::Parameters params = request.parameters();
Q_UNUSED( version );
QgsWmsParameters wmsParameters( QUrlQuery( request.url() ) );
QgsRenderer renderer( serverIface, project, wmsParameters );
QString format = params.value( "FORMAT" );
QString contentType;
// GetPrint supports svg/png/pdf
if ( format.compare( QLatin1String( "image/png" ), Qt::CaseInsensitive ) == 0 ||
format.compare( QLatin1String( "png" ), Qt::CaseInsensitive ) == 0 )
{
format = "png";
contentType = "image/png";
}
else if ( format.compare( QLatin1String( "image/svg" ), Qt::CaseInsensitive ) == 0 ||
format.compare( QLatin1String( "image/svg+xml" ), Qt::CaseInsensitive ) == 0 ||
format.compare( QLatin1String( "svg" ), Qt::CaseInsensitive ) == 0 )
{
format = "svg";
contentType = "image/svg+xml";
}
else if ( format.compare( QLatin1String( "application/pdf" ), Qt::CaseInsensitive ) == 0 ||
format.compare( QLatin1String( "pdf" ), Qt::CaseInsensitive ) == 0 )
{
format = "pdf";
contentType = "application/pdf";
}
else
{
throw QgsServiceException( QStringLiteral( "InvalidFormat" ),
QString( "Output format %1 is not supported by the GetPrint request" ).arg( format ) );
}
response.setHeader( QStringLiteral( "Content-Type" ), contentType );
response.write( renderer.getPrint( format ) );
}
void QgsRequestHandler::setupParameters()
{
const QgsServerRequest::Parameters parameters = mRequest.parameters();
// SLD
QString value = parameters.value( QStringLiteral( "SLD" ) );
if ( !value.isEmpty() )
{
// XXX Why keeping this ????
#if QT_VERSION < 0x050000
QByteArray fileContents;
if ( value.startsWith( "http", Qt::CaseInsensitive ) )
{
QgsHttpTransaction http( value );
if ( !http.getSynchronously( fileContents ) )
{
fileContents.clear();
}
}
else if ( value.startsWith( "ftp", Qt::CaseInsensitive ) )
{
Q_NOWARN_DEPRECATED_PUSH;
QgsFtpTransaction ftp;
if ( !ftp.get( value, fileContents ) )
{
fileContents.clear();
}
value = QUrl::fromPercentEncoding( fileContents );
Q_NOWARN_DEPRECATED_POP;
}
if fileContents.size() > 0 )
{
mRequest.setParameter( QStringLiteral( "SLD" ), QUrl::fromPercentEncoding( fileContents ) );
}
#else
QgsMessageLog::logMessage( QStringLiteral( "http and ftp methods not supported with Qt5." ) );
#endif
}
void writeGetLegendGraphics( QgsServerInterface* serverIface, const QString& version,
const QgsServerRequest& request, QgsServerResponse& response )
{
Q_UNUSED( version );
QgsServerRequest::Parameters params = request.parameters();
QgsRenderer renderer( serverIface, params, getConfigParser( serverIface ) );
QScopedPointer<QImage> result( renderer.getLegendGraphics() );
if ( !result.isNull() )
{
QString format = params.value( QStringLiteral( "FORMAT" ), QStringLiteral( "PNG" ) );
writeImage( response, *result, format, renderer.getImageQuality() );
}
else
{
throw QgsServiceException( QStringLiteral( "UnknownError" ),
QStringLiteral( "Failed to compute GetLegendGraphics image" ) );
}
}
void writeGetLegendGraphics( QgsServerInterface *serverIface, const QgsProject *project,
const QString &version, const QgsServerRequest &request,
QgsServerResponse &response )
{
Q_UNUSED( version );
QgsServerRequest::Parameters params = request.parameters();
QgsWmsParameters wmsParameters( QUrlQuery( request.url() ) );
QgsRenderer renderer( serverIface, project, wmsParameters );
std::unique_ptr<QImage> result( renderer.getLegendGraphics() );
if ( result )
{
QString format = params.value( QStringLiteral( "FORMAT" ), QStringLiteral( "PNG" ) );
writeImage( response, *result, format, renderer.getImageQuality() );
}
else
{
throw QgsServiceException( QStringLiteral( "UnknownError" ),
QStringLiteral( "Failed to compute GetLegendGraphics image" ) );
}
}
QDomDocument getStyles( QgsServerInterface *serverIface, const QgsProject *project, const QString &version,
const QgsServerRequest &request )
{
Q_UNUSED( version );
QgsServerRequest::Parameters parameters = request.parameters();
QString layersName = parameters.value( "LAYERS" );
if ( layersName.isEmpty() )
{
throw QgsBadRequestException( QgsServiceException::QGIS_MissingParameterValue,
QgsWmsParameter::LAYERS );
}
QStringList layerList = layersName.split( ',', QString::SkipEmptyParts );
if ( layerList.isEmpty() )
{
throw QgsBadRequestException( QgsServiceException::QGIS_MissingParameterValue,
QgsWmsParameter::LAYERS );
}
return getStyledLayerDescriptorDocument( serverIface, project, layerList );
}
QDomDocument createDescribeCoverageDocument( QgsServerInterface *serverIface, const QgsProject *project, const QString &version,
const QgsServerRequest &request )
{
Q_UNUSED( version );
QDomDocument doc;
QgsServerRequest::Parameters parameters = request.parameters();
#ifdef HAVE_SERVER_PYTHON_PLUGINS
QgsAccessControl *accessControl = serverIface->accessControls();
#endif
//wcs:WCS_Capabilities element
QDomElement coveDescElement = doc.createElement( QStringLiteral( "CoverageDescription" )/*wcs:CoverageDescription*/ );
coveDescElement.setAttribute( QStringLiteral( "xmlns" ), WCS_NAMESPACE );
coveDescElement.setAttribute( QStringLiteral( "xmlns:xsi" ), QStringLiteral( "http://www.w3.org/2001/XMLSchema-instance" ) );
coveDescElement.setAttribute( QStringLiteral( "xsi:schemaLocation" ), WCS_NAMESPACE + " http://schemas.opengis.net/wcs/1.0.0/describeCoverage.xsd" );
coveDescElement.setAttribute( QStringLiteral( "xmlns:gml" ), GML_NAMESPACE );
coveDescElement.setAttribute( QStringLiteral( "xmlns:xlink" ), QStringLiteral( "http://www.w3.org/1999/xlink" ) );
coveDescElement.setAttribute( QStringLiteral( "version" ), QStringLiteral( "1.0.0" ) );
coveDescElement.setAttribute( QStringLiteral( "updateSequence" ), QStringLiteral( "0" ) );
doc.appendChild( coveDescElement );
//defining coverage name
QString coveNames;
//read COVERAGE
QMap<QString, QString>::const_iterator cove_name_it = parameters.constFind( QStringLiteral( "COVERAGE" ) );
if ( cove_name_it != parameters.constEnd() )
{
coveNames = cove_name_it.value();
}
if ( coveNames.isEmpty() )
{
QMap<QString, QString>::const_iterator cove_name_it = parameters.constFind( QStringLiteral( "IDENTIFIER" ) );
if ( cove_name_it != parameters.constEnd() )
{
coveNames = cove_name_it.value();
}
}
QStringList coveNameList;
if ( !coveNames.isEmpty() )
{
coveNameList = coveNames.split( ',' );
for ( int i = 0; i < coveNameList.size(); ++i )
{
coveNameList.replace( i, coveNameList.at( i ).trimmed() );
}
}
QStringList wcsLayersId = QgsServerProjectUtils::wcsLayerIds( *project );
for ( int i = 0; i < wcsLayersId.size(); ++i )
{
QgsMapLayer *layer = project->mapLayer( wcsLayersId.at( i ) );
if ( !layer )
{
continue;
}
if ( layer->type() != QgsMapLayer::LayerType::RasterLayer )
{
continue;
}
#ifdef HAVE_SERVER_PYTHON_PLUGINS
if ( !accessControl->layerReadPermission( layer ) )
{
continue;
}
#endif
QString name = layer->name();
if ( !layer->shortName().isEmpty() )
name = layer->shortName();
name = name.replace( ' ', '_' );
if ( coveNameList.size() == 0 || coveNameList.contains( name ) )
{
QgsRasterLayer *rLayer = qobject_cast<QgsRasterLayer *>( layer );
coveDescElement.appendChild( getCoverageOffering( doc, const_cast<QgsRasterLayer *>( rLayer ), project ) );
}
}
return doc;
}
QDomDocument createDescribeFeatureTypeDocument( QgsServerInterface *serverIface, const QgsProject *project, const QString &version,
const QgsServerRequest &request )
{
Q_UNUSED( version );
QDomDocument doc;
QgsServerRequest::Parameters parameters = request.parameters();
QgsWfsParameters wfsParameters( parameters );
QgsWfsParameters::Format oFormat = wfsParameters.outputFormat();
// test oFormat
if ( oFormat == QgsWfsParameters::Format::NONE )
throw QgsBadRequestException( QStringLiteral( "Invalid WFS Parameter" ),
"OUTPUTFORMAT " + wfsParameters.outputFormatAsString() + "is not supported" );
QgsAccessControl *accessControl = serverIface->accessControls();
//xsd:schema
QDomElement schemaElement = doc.createElement( QStringLiteral( "schema" )/*xsd:schema*/ );
schemaElement.setAttribute( QStringLiteral( "xmlns" ), QStringLiteral( "http://www.w3.org/2001/XMLSchema" ) );
schemaElement.setAttribute( QStringLiteral( "xmlns:xsd" ), QStringLiteral( "http://www.w3.org/2001/XMLSchema" ) );
schemaElement.setAttribute( QStringLiteral( "xmlns:ogc" ), OGC_NAMESPACE );
schemaElement.setAttribute( QStringLiteral( "xmlns:gml" ), GML_NAMESPACE );
schemaElement.setAttribute( QStringLiteral( "xmlns:qgs" ), QGS_NAMESPACE );
schemaElement.setAttribute( QStringLiteral( "targetNamespace" ), QGS_NAMESPACE );
schemaElement.setAttribute( QStringLiteral( "elementFormDefault" ), QStringLiteral( "qualified" ) );
schemaElement.setAttribute( QStringLiteral( "version" ), QStringLiteral( "1.0" ) );
doc.appendChild( schemaElement );
//xsd:import
QDomElement importElement = doc.createElement( QStringLiteral( "import" )/*xsd:import*/ );
importElement.setAttribute( QStringLiteral( "namespace" ), GML_NAMESPACE );
if ( oFormat == QgsWfsParameters::Format::GML2 )
importElement.setAttribute( QStringLiteral( "schemaLocation" ), QStringLiteral( "http://schemas.opengis.net/gml/2.1.2/feature.xsd" ) );
else if ( oFormat == QgsWfsParameters::Format::GML3 )
importElement.setAttribute( QStringLiteral( "schemaLocation" ), QStringLiteral( "http://schemas.opengis.net/gml/3.1.1/base/gml.xsd" ) );
schemaElement.appendChild( importElement );
QStringList typeNameList;
QDomDocument queryDoc;
QString errorMsg;
if ( queryDoc.setContent( parameters.value( QStringLiteral( "REQUEST_BODY" ) ), true, &errorMsg ) )
{
//read doc
QDomElement queryDocElem = queryDoc.documentElement();
QDomNodeList docChildNodes = queryDocElem.childNodes();
if ( docChildNodes.size() )
{
for ( int i = 0; i < docChildNodes.size(); i++ )
{
QDomElement docChildElem = docChildNodes.at( i ).toElement();
if ( docChildElem.tagName() == QLatin1String( "TypeName" ) )
{
QString typeName = docChildElem.text().trimmed();
if ( typeName.contains( ':' ) )
typeNameList << typeName.section( ':', 1, 1 );
else
typeNameList << typeName;
}
}
}
}
else
{
QString typeNames = request.parameter( QStringLiteral( "TYPENAME" ) );
if ( !typeNames.isEmpty() )
{
QStringList typeNameSplit = typeNames.split( ',' );
for ( int i = 0; i < typeNameSplit.size(); ++i )
{
QString typeName = typeNameSplit.at( i ).trimmed();
if ( typeName.contains( ':' ) )
typeNameList << typeName.section( ':', 1, 1 );
else
typeNameList << typeName;
}
}
}
QStringList wfsLayerIds = QgsServerProjectUtils::wfsLayerIds( *project );
for ( int i = 0; i < wfsLayerIds.size(); ++i )
{
QgsMapLayer *layer = project->mapLayer( wfsLayerIds.at( i ) );
if ( layer->type() != QgsMapLayer::LayerType::VectorLayer )
{
continue;
}
QString name = layer->name();
if ( !layer->shortName().isEmpty() )
name = layer->shortName();
name = name.replace( ' ', '_' );
if ( !typeNameList.isEmpty() && !typeNameList.contains( name ) )
{
continue;
}
if ( accessControl && !accessControl->layerReadPermission( layer ) )
{
if ( !typeNameList.isEmpty() )
{
throw QgsSecurityAccessException( QStringLiteral( "Feature access permission denied" ) );
}
else
{
continue;
}
}
QgsVectorLayer *vLayer = qobject_cast<QgsVectorLayer *>( layer );
QgsVectorDataProvider *provider = vLayer->dataProvider();
if ( !provider )
{
continue;
}
setSchemaLayer( schemaElement, doc, const_cast<QgsVectorLayer *>( vLayer ) );
}
return doc;
}
QDomDocument getCapabilities( QgsServerInterface* serverIface, const QString& version,
const QgsServerRequest& request, bool projectSettings )
{
QDomDocument doc;
QDomElement wmsCapabilitiesElement;
QgsWmsConfigParser* configParser = getConfigParser( serverIface );
QgsServerRequest::Parameters parameters = request.parameters();
// Get service URL
QUrl href = serviceUrl( request, configParser );
//href needs to be a prefix
QString hrefString = href.toString( QUrl::FullyDecoded );
hrefString.append( href.hasQuery() ? "&" : "?" );
// XML declaration
QDomProcessingInstruction xmlDeclaration = doc.createProcessingInstruction( QStringLiteral( "xml" ),
QStringLiteral( "version=\"1.0\" encoding=\"utf-8\"" ) );
// Append format helper
std::function < void ( QDomElement&, const QString& ) > appendFormat = [&doc]( QDomElement & elem, const QString & format )
{
QDomElement formatElem = doc.createElement( QStringLiteral( "Format" )/*wms:Format*/ );
formatElem.appendChild( doc.createTextNode( format ) );
elem.appendChild( formatElem );
};
if ( version == QLatin1String( "1.1.1" ) )
{
doc = QDomDocument( QStringLiteral( "WMT_MS_Capabilities SYSTEM 'http://schemas.opengis.net/wms/1.1.1/WMS_MS_Capabilities.dtd'" ) ); //WMS 1.1.1 needs DOCTYPE "SYSTEM http://schemas.opengis.net/wms/1.1.1/WMS_MS_Capabilities.dtd"
doc.appendChild( xmlDeclaration );
wmsCapabilitiesElement = doc.createElement( QStringLiteral( "WMT_MS_Capabilities" )/*wms:WMS_Capabilities*/ );
}
else // 1.3.0 as default
{
doc.appendChild( xmlDeclaration );
wmsCapabilitiesElement = doc.createElement( QStringLiteral( "WMS_Capabilities" )/*wms:WMS_Capabilities*/ );
wmsCapabilitiesElement.setAttribute( QStringLiteral( "xmlns" ), QStringLiteral( "http://www.opengis.net/wms" ) );
wmsCapabilitiesElement.setAttribute( QStringLiteral( "xmlns:sld" ), QStringLiteral( "http://www.opengis.net/sld" ) );
wmsCapabilitiesElement.setAttribute( QStringLiteral( "xmlns:qgs" ), QStringLiteral( "http://www.qgis.org/wms" ) );
wmsCapabilitiesElement.setAttribute( QStringLiteral( "xmlns:xsi" ), QStringLiteral( "http://www.w3.org/2001/XMLSchema-instance" ) );
QString schemaLocation = QStringLiteral( "http://www.opengis.net/wms" );
schemaLocation += QLatin1String( " http://schemas.opengis.net/wms/1.3.0/capabilities_1_3_0.xsd" );
schemaLocation += QLatin1String( " http://www.opengis.net/sld" );
schemaLocation += QLatin1String( " http://schemas.opengis.net/sld/1.1.0/sld_capabilities.xsd" );
schemaLocation += QLatin1String( " http://www.qgis.org/wms" );
if ( configParser && configParser->wmsInspireActivated() )
{
wmsCapabilitiesElement.setAttribute( QStringLiteral( "xmlns:inspire_common" ), QStringLiteral( "http://inspire.ec.europa.eu/schemas/common/1.0" ) );
wmsCapabilitiesElement.setAttribute( QStringLiteral( "xmlns:inspire_vs" ), QStringLiteral( "http://inspire.ec.europa.eu/schemas/inspire_vs/1.0" ) );
schemaLocation += QLatin1String( " http://inspire.ec.europa.eu/schemas/inspire_vs/1.0" );
schemaLocation += QLatin1String( " http://inspire.ec.europa.eu/schemas/inspire_vs/1.0/inspire_vs.xsd" );
}
schemaLocation += " " + hrefString + "SERVICE=WMS&REQUEST=GetSchemaExtension";
wmsCapabilitiesElement.setAttribute( QStringLiteral( "xsi:schemaLocation" ), schemaLocation );
}
wmsCapabilitiesElement.setAttribute( QStringLiteral( "version" ), version );
doc.appendChild( wmsCapabilitiesElement );
configParser->serviceCapabilities( wmsCapabilitiesElement, doc );
//wms:Capability element
QDomElement capabilityElement = doc.createElement( QStringLiteral( "Capability" )/*wms:Capability*/ );
wmsCapabilitiesElement.appendChild( capabilityElement );
//wms:Request element
QDomElement requestElement = doc.createElement( QStringLiteral( "Request" )/*wms:Request*/ );
capabilityElement.appendChild( requestElement );
QDomElement dcpTypeElement = doc.createElement( QStringLiteral( "DCPType" )/*wms:DCPType*/ );
QDomElement httpElement = doc.createElement( QStringLiteral( "HTTP" )/*wms:HTTP*/ );
dcpTypeElement.appendChild( httpElement );
QDomElement elem;
//wms:GetCapabilities
elem = doc.createElement( QStringLiteral( "GetCapabilities" )/*wms:GetCapabilities*/ );
appendFormat( elem, ( version == QLatin1String( "1.1.1" ) ? "application/vnd.ogc.wms_xml" : "text/xml" ) );
elem.appendChild( dcpTypeElement );
requestElement.appendChild( elem );
// SOAP platform
//only give this information if it is not a WMS request to be in sync with the WMS capabilities schema
// XXX Not even sure that cam be ever true
if ( parameters.value( QStringLiteral( "SERVICE" ) ).compare( QLatin1String( "WMS" ), Qt::CaseInsensitive ) != 0 )
{
QDomElement soapElement = doc.createElement( QStringLiteral( "SOAP" )/*wms:SOAP*/ );
httpElement.appendChild( soapElement );
QDomElement soapResourceElement = doc.createElement( QStringLiteral( "OnlineResource" )/*wms:OnlineResource*/ );
soapResourceElement.setAttribute( QStringLiteral( "xmlns:xlink" ), QStringLiteral( "http://www.w3.org/1999/xlink" ) );
soapResourceElement.setAttribute( QStringLiteral( "xlink:type" ), QStringLiteral( "simple" ) );
soapResourceElement.setAttribute( QStringLiteral( "xlink:href" ), hrefString );
soapElement.appendChild( soapResourceElement );
}
//only Get supported for the moment
QDomElement getElement = doc.createElement( QStringLiteral( "Get" )/*wms:Get*/ );
httpElement.appendChild( getElement );
QDomElement olResourceElement = doc.createElement( QStringLiteral( "OnlineResource" )/*wms:OnlineResource*/ );
olResourceElement.setAttribute( QStringLiteral( "xmlns:xlink" ), QStringLiteral( "http://www.w3.org/1999/xlink" ) );
olResourceElement.setAttribute( QStringLiteral( "xlink:type" ), QStringLiteral( "simple" ) );
olResourceElement.setAttribute( QStringLiteral( "xlink:href" ), hrefString );
getElement.appendChild( olResourceElement );
//wms:GetMap
elem = doc.createElement( QStringLiteral( "GetMap" )/*wms:GetMap*/ );
appendFormat( elem, QStringLiteral( "image/jpeg" ) );
appendFormat( elem, QStringLiteral( "image/png" ) );
appendFormat( elem, QStringLiteral( "image/png; mode=16bit" ) );
appendFormat( elem, QStringLiteral( "image/png; mode=8bit" ) );
appendFormat( elem, QStringLiteral( "image/png; mode=1bit" ) );
appendFormat( elem, QStringLiteral( "application/dxf" ) );
elem.appendChild( dcpTypeElement.cloneNode().toElement() ); //this is the same as for 'GetCapabilities'
requestElement.appendChild( elem );
//wms:GetFeatureInfo
elem = doc.createElement( QStringLiteral( "GetFeatureInfo" ) );
appendFormat( elem, QStringLiteral( "text/plain" ) );
appendFormat( elem, QStringLiteral( "text/html" ) );
appendFormat( elem, QStringLiteral( "text/xml" ) );
appendFormat( elem, QStringLiteral( "application/vnd.ogc.gml" ) );
appendFormat( elem, QStringLiteral( "application/vnd.ogc.gml/3.1.1" ) );
elem.appendChild( dcpTypeElement.cloneNode().toElement() ); //this is the same as for 'GetCapabilities'
requestElement.appendChild( elem );
//wms:GetLegendGraphic
elem = doc.createElement(( version == QLatin1String( "1.1.1" ) ? "GetLegendGraphic" : "sld:GetLegendGraphic" )/*wms:GetLegendGraphic*/ );
appendFormat( elem, QStringLiteral( "image/jpeg" ) );
appendFormat( elem, QStringLiteral( "image/png" ) );
elem.appendChild( dcpTypeElement.cloneNode().toElement() ); // this is the same as for 'GetCapabilities'
requestElement.appendChild( elem );
//wms:DescribeLayer
elem = doc.createElement(( version == QLatin1String( "1.1.1" ) ? "DescribeLayer" : "sld:DescribeLayer" )/*wms:GetLegendGraphic*/ );
appendFormat( elem, QStringLiteral( "text/xml" ) );
elem.appendChild( dcpTypeElement.cloneNode().toElement() ); // this is the same as for 'GetCapabilities'
requestElement.appendChild( elem );
//wms:GetStyles
elem = doc.createElement(( version == QLatin1String( "1.1.1" ) ? "GetStyles" : "qgs:GetStyles" )/*wms:GetStyles*/ );
appendFormat( elem, QStringLiteral( "text/xml" ) );
elem.appendChild( dcpTypeElement.cloneNode().toElement() ); //this is the same as for 'GetCapabilities'
requestElement.appendChild( elem );
if ( projectSettings ) //remove composer templates from GetCapabilities in the long term
{
//wms:GetPrint
elem = doc.createElement( QStringLiteral( "GetPrint" ) /*wms:GetPrint*/ );
appendFormat( elem, QStringLiteral( "svg" ) );
appendFormat( elem, QStringLiteral( "png" ) );
appendFormat( elem, QStringLiteral( "pdf" ) );
elem.appendChild( dcpTypeElement.cloneNode().toElement() ); //this is the same as for 'GetCapabilities'
requestElement.appendChild( elem );
}
//Exception element is mandatory
elem = doc.createElement( QStringLiteral( "Exception" ) );
appendFormat( elem, ( version == QLatin1String( "1.1.1" ) ? "application/vnd.ogc.se_xml" : "XML" ) );
capabilityElement.appendChild( elem );
//UserDefinedSymbolization element
if ( version == QLatin1String( "1.3.0" ) )
{
elem = doc.createElement( QStringLiteral( "sld:UserDefinedSymbolization" ) );
elem.setAttribute( QStringLiteral( "SupportSLD" ), QStringLiteral( "1" ) );
elem.setAttribute( QStringLiteral( "UserLayer" ), QStringLiteral( "0" ) );
elem.setAttribute( QStringLiteral( "UserStyle" ), QStringLiteral( "1" ) );
elem.setAttribute( QStringLiteral( "RemoteWFS" ), QStringLiteral( "0" ) );
elem.setAttribute( QStringLiteral( "InlineFeature" ), QStringLiteral( "0" ) );
elem.setAttribute( QStringLiteral( "RemoteWCS" ), QStringLiteral( "0" ) );
capabilityElement.appendChild( elem );
if ( configParser->wmsInspireActivated() )
{
configParser->inspireCapabilities( capabilityElement, doc );
}
}
if ( projectSettings )
{
//Insert <ComposerTemplate> elements derived from wms:_ExtendedCapabilities
configParser->printCapabilities( capabilityElement, doc );
//WFS layers
QStringList wfsLayers = configParser->wfsLayerNames();
if ( !wfsLayers.isEmpty() )
{
QDomElement wfsLayersElem = doc.createElement( QStringLiteral( "WFSLayers" ) );
for ( auto wfsIt = wfsLayers.constBegin() ; wfsIt != wfsLayers.constEnd(); ++wfsIt )
{
QDomElement wfsLayerElem = doc.createElement( QStringLiteral( "WFSLayer" ) );
wfsLayerElem.setAttribute( QStringLiteral( "name" ), *wfsIt );
wfsLayersElem.appendChild( wfsLayerElem );
}
capabilityElement.appendChild( wfsLayersElem );
}
}
//add the xml content for the individual layers/styles
configParser->layersAndStylesCapabilities( capabilityElement, doc, version, projectSettings );
return doc;
}
// DescribeLayer is defined for WMS1.1.1/SLD1.0 and in WMS 1.3.0 SLD Extension
QDomDocument describeLayer( QgsServerInterface *serverIface, const QgsProject *project, const QString &version,
const QgsServerRequest &request )
{
Q_UNUSED( version );
QgsServerRequest::Parameters parameters = request.parameters();
if ( !parameters.contains( QStringLiteral( "SLD_VERSION" ) ) )
{
throw QgsServiceException( QStringLiteral( "MissingParameterValue" ),
QStringLiteral( "SLD_VERSION is mandatory for DescribeLayer operation" ), 400 );
}
if ( parameters[ QStringLiteral( "SLD_VERSION" )] != QLatin1String( "1.1.0" ) )
{
throw QgsServiceException( QStringLiteral( "InvalidParameterValue" ),
QStringLiteral( "SLD_VERSION = %1 is not supported" ).arg( parameters[ QStringLiteral( "SLD_VERSION" )] ), 400 );
}
if ( !parameters.contains( QStringLiteral( "LAYERS" ) ) )
{
throw QgsServiceException( QStringLiteral( "MissingParameterValue" ),
QStringLiteral( "LAYERS is mandatory for DescribeLayer operation" ), 400 );
}
QStringList layersList = parameters[ QStringLiteral( "LAYERS" )].split( ',', QString::SkipEmptyParts );
if ( layersList.isEmpty() )
{
throw QgsServiceException( QStringLiteral( "InvalidParameterValue" ), QStringLiteral( "Layers is empty" ), 400 );
}
QDomDocument myDocument = QDomDocument();
QDomNode header = myDocument.createProcessingInstruction( QStringLiteral( "xml" ), QStringLiteral( "version=\"1.0\" encoding=\"UTF-8\"" ) );
myDocument.appendChild( header );
// Create the root element
QDomElement root = myDocument.createElementNS( QStringLiteral( "http://www.opengis.net/sld" ), QStringLiteral( "DescribeLayerResponse" ) );
root.setAttribute( QStringLiteral( "xsi:schemaLocation" ), QStringLiteral( "http://www.opengis.net/sld http://schemas.opengis.net/sld/1.1.0/DescribeLayer.xsd" ) );
root.setAttribute( QStringLiteral( "xmlns:ows" ), QStringLiteral( "http://www.opengis.net/ows" ) );
root.setAttribute( QStringLiteral( "xmlns:se" ), QStringLiteral( "http://www.opengis.net/se" ) );
root.setAttribute( QStringLiteral( "xmlns:xlink" ), QStringLiteral( "http://www.w3.org/1999/xlink" ) );
root.setAttribute( QStringLiteral( "xmlns:xsi" ), QStringLiteral( "http://www.w3.org/2001/XMLSchema-instance" ) );
myDocument.appendChild( root );
// store the Version element
QDomElement versionNode = myDocument.createElement( QStringLiteral( "Version" ) );
versionNode.appendChild( myDocument.createTextNode( QStringLiteral( "1.1.0" ) ) );
root.appendChild( versionNode );
// get the wms service url defined in project or keep the one from the
// request url
QString wmsHrefString = serviceUrl( request, project ).toString();
// get the wfs service url defined in project or take the same as the
// wms service url
QString wfsHrefString = QgsServerProjectUtils::wfsServiceUrl( *project );
if ( wfsHrefString.isEmpty() )
{
wfsHrefString = wmsHrefString;
}
// get the wcs service url defined in project or take the same as the
// wms service url
QString wcsHrefString = QgsServerProjectUtils::wcsServiceUrl( *project );
if ( wcsHrefString.isEmpty() )
{
wcsHrefString = wmsHrefString;
}
// access control
#ifdef HAVE_SERVER_PYTHON_PLUGINS
QgsAccessControl *accessControl = serverIface->accessControls();
#endif
// Use layer ids
bool useLayerIds = QgsServerProjectUtils::wmsUseLayerIds( *project );
// WMS restricted layers
QStringList restrictedLayers = QgsServerProjectUtils::wmsRestrictedLayers( *project );
// WFS layers
QStringList wfsLayerIds = QgsServerProjectUtils::wfsLayerIds( *project );
// WCS layers
QStringList wcsLayerIds = QgsServerProjectUtils::wcsLayerIds( *project );
for ( QgsMapLayer *layer : project->mapLayers() )
{
QString name = layer->name();
if ( useLayerIds )
name = layer->id();
else if ( !layer->shortName().isEmpty() )
name = layer->shortName();
if ( !layersList.contains( name ) )
{
continue;
}
//unpublished layer
if ( restrictedLayers.contains( layer->name() ) )
{
throw QgsSecurityException( QStringLiteral( "You are not allowed to access to this layer" ) );
}
#ifdef HAVE_SERVER_PYTHON_PLUGINS
if ( accessControl && !accessControl->layerReadPermission( layer ) )
{
throw QgsSecurityException( QStringLiteral( "You are not allowed to access to this layer" ) );
}
#endif
// Create the NamedLayer element
QDomElement layerNode = myDocument.createElement( QStringLiteral( "LayerDescription" ) );
root.appendChild( layerNode );
// store the owsType element
QDomElement typeNode = myDocument.createElement( QStringLiteral( "owsType" ) );
// store the se:OnlineResource element
QDomElement oResNode = myDocument.createElement( QStringLiteral( "se:OnlineResource" ) );
oResNode.setAttribute( QStringLiteral( "xlink:type" ), QStringLiteral( "simple" ) );
// store the TypeName element
QDomElement nameNode = myDocument.createElement( QStringLiteral( "TypeName" ) );
switch ( layer->type() )
{
case QgsMapLayer::VectorLayer:
{
typeNode.appendChild( myDocument.createTextNode( QStringLiteral( "wfs" ) ) );
if ( wfsLayerIds.indexOf( layer->id() ) != -1 )
{
oResNode.setAttribute( QStringLiteral( "xlink:href" ), wfsHrefString );
}
// store the se:FeatureTypeName element
QDomElement typeNameNode = myDocument.createElement( QStringLiteral( "se:FeatureTypeName" ) );
typeNameNode.appendChild( myDocument.createTextNode( name ) );
nameNode.appendChild( typeNameNode );
break;
}
case QgsMapLayer::RasterLayer:
{
typeNode.appendChild( myDocument.createTextNode( QStringLiteral( "wcs" ) ) );
if ( wcsLayerIds.indexOf( layer->id() ) != -1 )
{
oResNode.setAttribute( QStringLiteral( "xlink:href" ), wcsHrefString );
}
// store the se:CoverageTypeName element
QDomElement typeNameNode = myDocument.createElement( QStringLiteral( "se:CoverageTypeName" ) );
typeNameNode.appendChild( myDocument.createTextNode( name ) );
nameNode.appendChild( typeNameNode );
break;
}
case QgsMapLayer::MeshLayer:
case QgsMapLayer::PluginLayer:
break;
}
layerNode.appendChild( typeNode );
layerNode.appendChild( oResNode );
layerNode.appendChild( nameNode );
}
return myDocument;
}