QGIS » QGIS Application

QString QgsGeometry::exportToGeoJSON()

{

  QgsDebugMsg( "entered." );

  // TODO: implement with GEOS

  if ( mDirtyWkb )

  {

    exportGeosToWkb();

  }

  if ( !mGeometry )

  {

    QgsDebugMsg( "WKB geometry not available!" );

    return QString::null;

  }

  QGis::WkbType wkbType;

  bool hasZValue = false;

  double *x, *y;

  QString mWkt; // TODO: rename

  // Will this really work when mGeometry[0] == 0 ???? I (gavin) think not.

  //wkbType = (mGeometry[0] == 1) ? mGeometry[1] : mGeometry[4];

  memcpy( &wkbType, &( mGeometry[1] ), sizeof( int ) );

  switch ( wkbType )

  {

    case QGis::WKBPoint25D:

    case QGis::WKBPoint:

    {

      mWkt += "{ \"type\": \"Point\", \"coordinates\": [";

      x = ( double * )( mGeometry + 5 );

      mWkt += QString::number( *x, 'f', 6 );

      mWkt += ", ";

      y = ( double * )( mGeometry + 5 + sizeof( double ) );

      mWkt += QString::number( *y, 'f', 6 );

      mWkt += "] }";

      return mWkt;

    }

    case QGis::WKBLineString25D:

      hasZValue = true;

    case QGis::WKBLineString:

    {

      QgsDebugMsg( "LINESTRING found" );

      unsigned char *ptr;

      int *nPoints;

      int idx;

      mWkt += "{ \"type\": \"LineString\", \"coordinates\": [ ";

      // get number of points in the line

      ptr = mGeometry + 5;

      nPoints = ( int * ) ptr;

      ptr = mGeometry + 1 + 2 * sizeof( int );

      for ( idx = 0; idx < *nPoints; ++idx )

      {

        if ( idx != 0 )

        {

          mWkt += ", ";

        }

        mWkt += "[";

        x = ( double * ) ptr;

        mWkt += QString::number( *x, 'f', 6 );

        mWkt += ", ";

        ptr += sizeof( double );

        y = ( double * ) ptr;

        mWkt += QString::number( *y, 'f', 6 );

        ptr += sizeof( double );

        if ( hasZValue )

        {

          ptr += sizeof( double );

        }

        mWkt += "]";

      }

      mWkt += " ] }";

      return mWkt;

    }

    case QGis::WKBPolygon25D:

      hasZValue = true;

    case QGis::WKBPolygon:

    {

      QgsDebugMsg( "POLYGON found" );

      unsigned char *ptr;

      int idx, jdx;

      int *numRings, *nPoints;

      mWkt += "{ \"type\": \"Polygon\", \"coordinates\": [ ";

      // get number of rings in the polygon

      numRings = ( int * )( mGeometry + 1 + sizeof( int ) );

      if ( !( *numRings ) )  // sanity check for zero rings in polygon

      {

        return QString();

      }

      int *ringStart; // index of first point for each ring

      int *ringNumPoints; // number of points in each ring

      ringStart = new int[*numRings];

      ringNumPoints = new int[*numRings];

      ptr = mGeometry + 1 + 2 * sizeof( int ); // set pointer to the first ring

      for ( idx = 0; idx < *numRings; idx++ )

      {

        if ( idx != 0 )

        {

          mWkt += ", ";

        }

        mWkt += "[ ";

        // get number of points in the ring

        nPoints = ( int * ) ptr;

        ringNumPoints[idx] = *nPoints;

        ptr += 4;

        for ( jdx = 0; jdx < *nPoints; jdx++ )

        {

          if ( jdx != 0 )

          {

            mWkt += ", ";

          }

          mWkt += "[";

          x = ( double * ) ptr;

          mWkt += QString::number( *x, 'f', 6 );

          mWkt += ", ";

          ptr += sizeof( double );

          y = ( double * ) ptr;

          mWkt += QString::number( *y, 'f', 6 );

          ptr += sizeof( double );

          if ( hasZValue )

          {

            ptr += sizeof( double );

          }

          mWkt += "]";

        }

        mWkt += " ]";

      }

      mWkt += " ] }";

      delete [] ringStart;

      delete [] ringNumPoints;

      return mWkt;

    }

    case QGis::WKBMultiPoint25D:

      hasZValue = true;

    case QGis::WKBMultiPoint:

    {

      unsigned char *ptr;

      int idx;

      int *nPoints;

      mWkt += "{ \"type\": \"MultiPoint\", \"coordinates\": [ ";

      nPoints = ( int* )( mGeometry + 5 );

      ptr = mGeometry + 5 + sizeof( int );

      for ( idx = 0; idx < *nPoints; ++idx )

      {

        ptr += ( 1 + sizeof( int ) );

        if ( idx != 0 )

        {

          mWkt += ", ";

        }

        mWkt += "[";

        x = ( double * )( ptr );

        mWkt += QString::number( *x, 'f', 6 );

        mWkt += ", ";

        ptr += sizeof( double );

        y = ( double * )( ptr );

        mWkt += QString::number( *y, 'f', 6 );

        ptr += sizeof( double );

        if ( hasZValue )

        {

          ptr += sizeof( double );

        }

        mWkt += "]";

      }

      mWkt += " ] }";

      return mWkt;

    }

    case QGis::WKBMultiLineString25D:

      hasZValue = true;

    case QGis::WKBMultiLineString:

    {

      QgsDebugMsg( "MULTILINESTRING found" );

      unsigned char *ptr;

      int idx, jdx, numLineStrings;

      int *nPoints;

      mWkt += "{ \"type\": \"MultiLineString\", \"coordinates\": [ ";

      numLineStrings = ( int )( mGeometry[5] );

      ptr = mGeometry + 9;

      for ( jdx = 0; jdx < numLineStrings; jdx++ )

      {

        if ( jdx != 0 )

        {

          mWkt += ", ";

        }

        mWkt += "[ ";

        ptr += 5; // skip type since we know its 2

        nPoints = ( int * ) ptr;

        ptr += sizeof( int );

        for ( idx = 0; idx < *nPoints; idx++ )

        {

          if ( idx != 0 )

          {

            mWkt += ", ";

          }

          mWkt += "[";

          x = ( double * ) ptr;

          mWkt += QString::number( *x, 'f', 6 );

          ptr += sizeof( double );

          mWkt += ", ";

          y = ( double * ) ptr;

          mWkt += QString::number( *y, 'f', 6 );

          ptr += sizeof( double );

          if ( hasZValue )

          {

            ptr += sizeof( double );

          }

          mWkt += "]";

        }

        mWkt += " ]";

      }

      mWkt += " ] }";

      return mWkt;

    }

    case QGis::WKBMultiPolygon25D:

      hasZValue = true;

    case QGis::WKBMultiPolygon:

    {

      QgsDebugMsg( "MULTIPOLYGON found" );

      unsigned char *ptr;

      int idx, jdx, kdx;

      int *numPolygons, *numRings, *nPoints;

      mWkt += "{ \"type\": \"MultiPolygon\", \"coordinates\": [ ";

      ptr = mGeometry + 5;

      numPolygons = ( int * ) ptr;

      ptr = mGeometry + 9;

      for ( kdx = 0; kdx < *numPolygons; kdx++ )

      {

        if ( kdx != 0 )

        {

          mWkt += ", ";

        }

        mWkt += "[ ";

        ptr += 5;

        numRings = ( int * ) ptr;

        ptr += 4;

        for ( idx = 0; idx < *numRings; idx++ )

        {

          if ( idx != 0 )

          {

            mWkt += ", ";

          }

          mWkt += "[ ";

          nPoints = ( int * ) ptr;

          ptr += 4;

          for ( jdx = 0; jdx < *nPoints; jdx++ )

          {

            if ( jdx != 0 )

            {

              mWkt += ", ";

            }

            mWkt += "[";

            x = ( double * ) ptr;

            mWkt += QString::number( *x, 'f', 6 );

            ptr += sizeof( double );

            mWkt += ", ";

            y = ( double * ) ptr;

            mWkt += QString::number( *y, 'f', 6 );

            ptr += sizeof( double );

            if ( hasZValue )

            {

              ptr += sizeof( double );

            }

            mWkt += "]";

          }

          mWkt += " ]";

        }

        mWkt += " ]";

      }

      mWkt += " ] }";

      return mWkt;

    }

    default:

      QgsDebugMsg( "error: mGeometry type not recognized" );

      return QString::null;

  }

}

    /** Exports the geometry to mGeoJSON

        @return true in case of success and false else

     */

    QString exportToGeoJSON();

  qgswfsserver.cpp

#include "qgswfsserver.h"

#ifndef QGISDEBUG

      serviceString = parameterMap.value( "SERVICE", "WMS" );

#else

#endif

    if ( serviceString == "WFS" )

    {

      delete theServer;

      QgsWFSServer* theServer = 0;

      try

      {

        theServer = new QgsWFSServer( parameterMap );

      }

      catch ( QgsMapServiceException e ) //admin.sld may be invalid

      {

        theRequestHandler->sendServiceException( e );

        continue;

      }

      theServer->setAdminConfigParser( adminConfigParser );

      //request type

      QString request = parameterMap.value( "REQUEST" );

      if ( request.isEmpty() )

      {

        //do some error handling

        QgsDebugMsg( "unable to find 'REQUEST' parameter, exiting..." );

        theRequestHandler->sendServiceException( QgsMapServiceException( "OperationNotSupported", "Please check the value of the REQUEST parameter" ) );

        delete theRequestHandler;

        delete theServer;

        continue;

      }

      if ( request == "GetCapabilities" )

      {

        QDomDocument capabilitiesDocument;

        try

        {

          capabilitiesDocument = theServer->getCapabilities();

        }

        catch ( QgsMapServiceException& ex )

        {

          theRequestHandler->sendServiceException( ex );

          delete theRequestHandler;

          delete theServer;

          continue;

        }

        QgsDebugMsg( "sending GetCapabilities response" );

        theRequestHandler->sendGetCapabilitiesResponse( capabilitiesDocument );

        delete theRequestHandler;

        delete theServer;

        continue;

      }

      else if ( request == "DescribeFeatureType" )

      {

        QDomDocument describeDocument;

        try

        {

          describeDocument = theServer->describeFeatureType();

        }

        catch ( QgsMapServiceException& ex )

        {

          theRequestHandler->sendServiceException( ex );

          delete theRequestHandler;

          delete theServer;

          continue;

        }

        QgsDebugMsg( "sending GetCapabilities response" );

        theRequestHandler->sendGetCapabilitiesResponse( describeDocument );

        delete theRequestHandler;

        delete theServer;

        continue;

      }

      else if ( request == "GetFeature" )

      {

        //output format for GetFeature

        QString outputFormat = parameterMap.value( "OUTPUTFORMAT" );

        try

        {

          if ( theServer->getFeature( *theRequestHandler, outputFormat ) != 0 )

          {

            delete theRequestHandler;

            delete theServer;

            continue;

          } else {

            delete theRequestHandler;

            delete theServer;

            continue;

          }

        }

        catch ( QgsMapServiceException& ex )

        {

          theRequestHandler->sendServiceException( ex );

          delete theRequestHandler;

          delete theServer;

          continue;

        }

      }

      return 0;

    }

    virtual void featureTypeList( QDomElement& parentElement, QDomDocument& doc ) const = 0;

bool QgsHttpRequestHandler::startGetFeatureResponse( QByteArray* ba, const QString& infoFormat ) const

{

  if ( !ba )

  {

    return false;

  }

  if ( ba->size() < 1 )

  {

    return false;

  }

  QString format;

  if (infoFormat == "GeoJSON")

    format = "text/plain";

  else

    format = "text/xml";

  printf( "Content-Type: " );

  printf( format.toLocal8Bit() );

  printf( "\n" );

  printf( "\n" );

  fwrite( ba->data(), ba->size(), 1, FCGI_stdout );

  return true;

}

void QgsHttpRequestHandler::sendGetFeatureResponse( QByteArray* ba ) const

{

  if ( !ba )

  {

    return;

  }

  if ( ba->size() < 1 )

  {

    return;

  }

  fwrite( ba->data(), ba->size(), 1, FCGI_stdout );

}

void QgsHttpRequestHandler::endGetFeatureResponse( QByteArray* ba ) const

{

  if ( !ba )

  {

    return;

  }

  fwrite( ba->data(), ba->size(), 1, FCGI_stdout );

}

    virtual bool startGetFeatureResponse( QByteArray* ba, const QString& infoFormat ) const;

    virtual void sendGetFeatureResponse( QByteArray* ba ) const;

    virtual void endGetFeatureResponse( QByteArray* ba ) const;

void QgsProjectParser::featureTypeList( QDomElement& parentElement, QDomDocument& doc ) const

{

  QStringList nonIdentifiableLayers = identifyDisabledLayers();

  if ( mProjectLayerElements.size() < 1 )

  {

    return;

  }

  QMap<QString, QgsMapLayer *> layerMap;

  foreach( const QDomElement &elem, mProjectLayerElements )

  {

    QString type = elem.attribute( "type" );

    if ( type == "vector" )

    {

      //QgsMapLayer *layer = createLayerFromElement( *layerIt );

      QgsMapLayer *layer = createLayerFromElement( elem );

      if ( layer )

      {

        QgsDebugMsg( QString( "add layer %1 to map" ).arg( layer->id() ) );

        layerMap.insert( layer->id(), layer );

        QDomElement layerElem = doc.createElement( "FeatureType" );

        QDomElement nameElem = doc.createElement( "Name" );

        //We use the layer name even though it might not be unique.

        //Because the id sometimes contains user/pw information and the name is more descriptive

        QDomText nameText = doc.createTextNode( layer->name() );

        nameElem.appendChild( nameText );

        layerElem.appendChild( nameElem );

        QDomElement titleElem = doc.createElement( "Title" );

        QDomText titleText = doc.createTextNode( layer->name() );

        titleElem.appendChild( titleText );

        layerElem.appendChild( titleElem );

        //appendExGeographicBoundingBox( layerElem, doc, layer->extent(), layer->crs() );

        QDomElement srsElem = doc.createElement( "SRS" );

        QDomText srsText = doc.createTextNode( layer->crs().authid() );

        srsElem.appendChild( srsText );

        layerElem.appendChild( srsElem );

        QgsRectangle layerExtent = layer->extent();

        QDomElement bBoxElement = doc.createElement( "LatLongBoundingBox" );

        bBoxElement.setAttribute( "minx", QString::number( layerExtent.xMinimum() ) );

        bBoxElement.setAttribute( "miny", QString::number( layerExtent.yMinimum() ) );

        bBoxElement.setAttribute( "maxx", QString::number( layerExtent.xMaximum() ) );

        bBoxElement.setAttribute( "maxy", QString::number( layerExtent.yMaximum() ) );

        layerElem.appendChild( bBoxElement );

        parentElement.appendChild(layerElem);

      }

#if QGSMSDEBUG

      else

      {

        QString buf;

        QTextStream s( &buf );

        layerIt->save( s, 0 );

        QgsMSDebugMsg( QString( "layer %1 not found" ).arg( buf ) );

      }

#endif

    }

  }

  return;

}

    virtual void featureTypeList( QDomElement& parentElement, QDomDocument& doc ) const;

    virtual bool startGetFeatureResponse( QByteArray* ba, const QString& infoFormat ) const = 0;

    virtual void sendGetFeatureResponse( QByteArray* ba ) const = 0;

    virtual void endGetFeatureResponse( QByteArray* ba ) const = 0;

    void featureTypeList( QDomElement& parentElement, QDomDocument& doc ) const {};

#include "qgswfsserver.h"

#include "qgsconfigparser.h"

#include "qgscrscache.h"

#include "qgsfield.h"

#include "qgsgeometry.h"

#include "qgsmaplayer.h"

#include "qgsmaplayerregistry.h"

#include "qgsmaprenderer.h"

#include "qgsmaptopixel.h"

#include "qgspallabeling.h"

#include "qgsproject.h"

#include "qgsrasterlayer.h"

#include "qgsscalecalculator.h"

#include "qgscoordinatereferencesystem.h"

#include "qgsvectordataprovider.h"

#include "qgsvectorlayer.h"

#include "qgsfilter.h"

#include "qgslogger.h"

#include "qgsmapserviceexception.h"

#include "qgssldparser.h"

#include "qgssymbol.h"

#include "qgssymbolv2.h"

#include "qgsrenderer.h"

#include "qgslegendmodel.h"

#include "qgscomposerlegenditem.h"

#include "qgslogger.h"

#include "qgsrequesthandler.h"

#include <QImage>

#include <QPainter>

#include <QStringList>

#include <QTextStream>

#include <QDir>

//for printing

#include "qgscomposition.h"

#include <QBuffer>

#include <QPrinter>

#include <QSvgGenerator>

#include <QUrl>

#include <QPaintEngine>

QgsWFSServer::QgsWFSServer( QMap<QString, QString> parameters )

    : mParameterMap( parameters )

    , mConfigParser( 0 )

{

}

QgsWFSServer::~QgsWFSServer()

{

}

QgsWFSServer::QgsWFSServer()

{

}

QDomDocument QgsWFSServer::getCapabilities()

{

  QgsDebugMsg( "Entering." );

  QDomDocument doc;

  //wfs:WFS_Capabilities element

  QDomElement wfsCapabilitiesElement = doc.createElement( "WFS_Capabilities"/*wms:WFS_Capabilities*/ );

  wfsCapabilitiesElement.setAttribute( "xmlns", "http://www.opengis.net/wfs" );

  wfsCapabilitiesElement.setAttribute( "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance" );

  wfsCapabilitiesElement.setAttribute( "xsi:schemaLocation", "http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.0.0/wfs.xsd" );

  wfsCapabilitiesElement.setAttribute( "xmlns:ogc", "http://www.opengis.net/ogc" );

  wfsCapabilitiesElement.setAttribute( "xmlns:gml", "http://www.opengis.net/gml" );

  wfsCapabilitiesElement.setAttribute( "xmlns:ows", "http://www.opengis.net/ows" );

  wfsCapabilitiesElement.setAttribute( "xmlns:xlink", "http://www.w3.org/1999/xlink" );

  wfsCapabilitiesElement.setAttribute( "version", "1.0.0" );

  wfsCapabilitiesElement.setAttribute( "updateSequence", "0" );

  doc.appendChild( wfsCapabilitiesElement );

  if ( mConfigParser )

  {

    mConfigParser->serviceCapabilities( wfsCapabilitiesElement, doc );

  }

  //wfs:Capability element

  QDomElement capabilityElement = doc.createElement( "Capability"/*wfs:Capability*/ );

  wfsCapabilitiesElement.appendChild( capabilityElement );

  //wfs:Request element

  QDomElement requestElement = doc.createElement( "Request"/*wfs:Request*/ );

  capabilityElement.appendChild( requestElement );

  //wfs:GetCapabilities

  QDomElement getCapabilitiesElement = doc.createElement( "GetCapabilities"/*wfs:GetCapabilities*/ );

  requestElement.appendChild( getCapabilitiesElement );

  QDomElement capabilitiesFormatElement = doc.createElement( "Format" );/*wfs:Format*/

  getCapabilitiesElement.appendChild( capabilitiesFormatElement );

  QDomText capabilitiesFormatText = doc.createTextNode( "text/xml" );

  capabilitiesFormatElement.appendChild( capabilitiesFormatText );

  QDomElement dcpTypeElement = doc.createElement( "DCPType"/*wfs:DCPType*/ );

  getCapabilitiesElement.appendChild( dcpTypeElement );

  QDomElement httpElement = doc.createElement( "HTTP"/*wfs:HTTP*/ );

  dcpTypeElement.appendChild( httpElement );

  //Prepare url

  //Some client requests already have http://<SERVER_NAME> in the REQUEST_URI variable

  QString hrefString;

  QString requestUrl = getenv( "REQUEST_URI" );

  QUrl mapUrl( requestUrl );

  mapUrl.setHost( QString( getenv( "SERVER_NAME" ) ) );

  mapUrl.removeQueryItem( "REQUEST" );

  mapUrl.removeQueryItem( "VERSION" );

  mapUrl.removeQueryItem( "SERVICE" );

  hrefString = mapUrl.toString();

  //only Get supported for the moment

  QDomElement getElement = doc.createElement( "Get"/*wfs:Get*/ );

  httpElement.appendChild( getElement );

  QDomElement olResourceElement = doc.createElement( "OnlineResource"/*wfs:OnlineResource*/ );

  olResourceElement.setAttribute( "xlink:type", "simple" );

  requestUrl.truncate( requestUrl.indexOf( "?" ) + 1 );

  olResourceElement.setAttribute( "xlink:href", hrefString );

  getElement.appendChild( olResourceElement );

  //wfs:DescribeFeatureType

  QDomElement describeFeatureTypeElement = doc.createElement( "DescribeFeatureType"/*wfs:DescribeFeatureType*/ );

  requestElement.appendChild( describeFeatureTypeElement );

  QDomElement schemaDescriptionLanguageElement = doc.createElement( "SchemaDescriptionLanguage"/*wfs:SchemaDescriptionLanguage*/ );

  describeFeatureTypeElement.appendChild( schemaDescriptionLanguageElement );

  QDomElement xmlSchemaElement = doc.createElement( "XMLSCHEMA"/*wfs:XMLSCHEMA*/ );

  schemaDescriptionLanguageElement.appendChild( xmlSchemaElement );

  QDomElement describeFeatureTypeDhcTypeElement = dcpTypeElement.cloneNode().toElement();//this is the same as for 'GetCapabilities'

  describeFeatureTypeElement.appendChild( describeFeatureTypeDhcTypeElement );

  //wfs:GetFeature

  QDomElement getFeatureElement = doc.createElement( "GetFeature"/*wfs:GetFeature*/ );

  requestElement.appendChild( getFeatureElement );

  QDomElement getFeatureFormatElement = doc.createElement( "ResultFormat" );/*wfs:ResultFormat*/

  getFeatureElement.appendChild( getFeatureFormatElement );

  QDomElement gmlFormatElement = doc.createElement( "GML2" );/*wfs:GML2*/

  getFeatureFormatElement.appendChild( gmlFormatElement );

  QDomElement geojsonFormatElement = doc.createElement( "GeoJSON" );/*wfs:GeoJSON*/

  getFeatureFormatElement.appendChild( geojsonFormatElement );

  QDomElement getFeatureDhcTypeElement = dcpTypeElement.cloneNode().toElement();//this is the same as for 'GetCapabilities'

  getFeatureElement.appendChild( getFeatureDhcTypeElement );

  //wfs:FeatureTypeList element

  QDomElement featureTypeListElement = doc.createElement( "FeatureTypeList"/*wfs:FeatureTypeList*/ );

  capabilityElement.appendChild( featureTypeListElement );

  //wfs:Operations element

  QDomElement operationsElement = doc.createElement( "Operations"/*wfs:Operations*/ );

  featureTypeListElement.appendChild( operationsElement );

  //wfs:Query element

  QDomElement queryElement = doc.createElement( "Query"/*wfs:Query*/ );

  operationsElement.appendChild( queryElement );

  /*

   * Adding layer liste in featureTypeListElement

   */

  if ( mConfigParser )

  {

    mConfigParser->featureTypeList( featureTypeListElement, doc );

  }

  /*

   * Adding ogc:Filter_Capabilities in capabilityElement

   */

  //ogc:Filter_Capabilities element

  QDomElement filterCapabilitiesElement = doc.createElement( "ogc:Filter_Capabilities"/*ogc:Filter_Capabilities*/ );

  capabilityElement.appendChild( filterCapabilitiesElement );

  QDomElement spatialCapabilitiesElement = doc.createElement( "ogc:Spatial_Capabilities"/*ogc:Spatial_Capabilities*/ );

  filterCapabilitiesElement.appendChild( spatialCapabilitiesElement );

  QDomElement spatialOperatorsElement = doc.createElement( "ogc:Spatial_Operators"/*ogc:Spatial_Operators*/ );

  spatialCapabilitiesElement.appendChild( spatialOperatorsElement );

  QDomElement ogcBboxElement = doc.createElement( "ogc:BBOX"/*ogc:BBOX*/ );

  spatialOperatorsElement.appendChild( ogcBboxElement );

  QDomElement scalarCapabilitiesElement = doc.createElement( "ogc:Scalar_Capabilities"/*ogc:Scalar_Capabilities*/ );

  filterCapabilitiesElement.appendChild( scalarCapabilitiesElement );

  QDomElement comparisonOperatorsElement = doc.createElement( "ogc:Comparison_Operators"/*ogc:Comparison_Operators*/ );

  scalarCapabilitiesElement.appendChild( comparisonOperatorsElement );

  QDomElement simpleComparisonsElement = doc.createElement( "ogc:Simple_Comparisons"/*ogc:Simple_Comparisons*/ );

  comparisonOperatorsElement.appendChild( simpleComparisonsElement );

  return doc;

}

QDomDocument QgsWFSServer::describeFeatureType()

{

  QgsDebugMsg( "Entering." );

  QDomDocument doc;

  //xsd:schema

  QDomElement schemaElement = doc.createElement( "schema"/*xsd:schema*/ );

  schemaElement.setAttribute( "xmlns", "http://www.w3.org/2001/XMLSchema" );

  schemaElement.setAttribute( "xmlns:xsd", "http://www.w3.org/2001/XMLSchema" );

  schemaElement.setAttribute( "xmlns:ogc", "http://www.opengis.net/ogc" );

  schemaElement.setAttribute( "xmlns:gml", "http://www.opengis.net/gml" );

  schemaElement.setAttribute( "xmlns:qgs", "http://www.qgis.org/gml" );

  schemaElement.setAttribute( "targetNamespace", "http://www.qgis.org/gml" );

  doc.appendChild( schemaElement );

  //xsd:import

  QDomElement importElement = doc.createElement( "import"/*xsd:import*/ );

  importElement.setAttribute( "namespace", "http://www.opengis.net/gml" );

  importElement.setAttribute( "schemaLocation", "http://schemas.opengis.net/gml/2.1.2/feature.xsd" );

  schemaElement.appendChild( importElement );

  //read TYPENAME

  QString typeName;

  QMap<QString, QString>::const_iterator type_name_it = mParameterMap.find( "TYPENAME" );

  if ( type_name_it != mParameterMap.end() )

  {

    typeName = type_name_it.value();

  }

  else

  {

    return doc;

  }

  QStringList nonIdentifiableLayers = mConfigParser->identifyDisabledLayers();

  QMap< QString, QMap< int, QString > > aliasInfo = mConfigParser->layerAliasInfo();

  QMap< QString, QSet<QString> > hiddenAttributes = mConfigParser->hiddenAttributes();

  QList<QgsMapLayer*> layerList;

  QgsMapLayer* currentLayer = 0;

  layerList = mConfigParser->mapLayerFromStyle( typeName, "" );

  currentLayer = layerList.at( 0 );

  QgsVectorLayer* layer = dynamic_cast<QgsVectorLayer*>( currentLayer );

  if ( layer )

  {

    //is there alias info for this vector layer?

    QMap< int, QString > layerAliasInfo;

    QMap< QString, QMap< int, QString > >::const_iterator aliasIt = aliasInfo.find( currentLayer->id() );

    if ( aliasIt != aliasInfo.constEnd() )

    {

      layerAliasInfo = aliasIt.value();

    }

    //hidden attributes for this layer

    QSet<QString> layerHiddenAttributes;

    QMap< QString, QSet<QString> >::const_iterator hiddenIt = hiddenAttributes.find( currentLayer->id() );

    if ( hiddenIt != hiddenAttributes.constEnd() )

    {

      layerHiddenAttributes = hiddenIt.value();

    }

    //do a select with searchRect and go through all the features

    QgsVectorDataProvider* provider = layer->dataProvider();

    if ( !provider )

    {

      return doc;

    }

    typeName = typeName.replace( QString(" "), QString("_") );

    //xsd:element

    QDomElement elementElem = doc.createElement( "element"/*xsd:element*/ );

    elementElem.setAttribute( "name", typeName );

    elementElem.setAttribute( "type", "qgs:" + typeName + "Type" );

    elementElem.setAttribute( "substitutionGroup", "gml:_Feature" );

    schemaElement.appendChild( elementElem );

    //xsd:complexType

    QDomElement complexTypeElem = doc.createElement( "complexType"/*xsd:complexType*/ );

    complexTypeElem.setAttribute( "name", typeName + "Type" );

    schemaElement.appendChild( complexTypeElem );

    //xsd:complexType

    QDomElement complexContentElem = doc.createElement( "complexContent"/*xsd:complexContent*/ );

    complexTypeElem.appendChild( complexContentElem );

    //xsd:extension

    QDomElement extensionElem = doc.createElement( "extension"/*xsd:extension*/ );

    extensionElem.setAttribute( "base", "gml:AbstractFeatureType" );

    complexContentElem.appendChild( extensionElem );

    //xsd:sequence

    QDomElement sequenceElem = doc.createElement( "sequence"/*xsd:sequence*/ );

    extensionElem.appendChild( sequenceElem );

    //xsd:element

    QDomElement geomElem = doc.createElement( "element"/*xsd:element*/ );

    geomElem.setAttribute( "name", "geometry" );

    geomElem.setAttribute( "type", "gml:GeometryPropertyType" );

    geomElem.setAttribute( "minOccurs", "0" );

    geomElem.setAttribute( "maxOccurs", "1" );

    sequenceElem.appendChild( geomElem );

    const QgsFieldMap& fields = provider->fields();

    for ( QgsFieldMap::const_iterator it = fields.begin(); it != fields.end(); ++it )

    {

      QString attributeName = it.value().name();

      //skip attribute if it has edit type 'hidden'

      if ( layerHiddenAttributes.contains( attributeName ) )

      {

        continue;

      }

      //check if the attribute name should be replaced with an alias

      QMap<int, QString>::const_iterator aliasIt = layerAliasInfo.find( it.key() );

      if ( aliasIt != layerAliasInfo.constEnd() )

      {

        attributeName = aliasIt.value();

      }

      //xsd:element

      QDomElement geomElem = doc.createElement( "element"/*xsd:element*/ );

      geomElem.setAttribute( "name", attributeName );

      if ( it.value().type() == 2 )

        geomElem.setAttribute( "type", "integer" );

      else if ( it.value().type() == 6 )

        geomElem.setAttribute( "type", "double" );

      else

        geomElem.setAttribute( "type", "string" );

      sequenceElem.appendChild( geomElem );

    }

  }

  return doc;

}

int QgsWFSServer::getFeature( QgsRequestHandler& request, const QString& format )

{

  QByteArray result;

  QgsDebugMsg( "Info format is:" + infoFormat );

  //read TYPENAME

  QString typeName;

  QMap<QString, QString>::const_iterator type_name_it = mParameterMap.find( "TYPENAME" );

  if ( type_name_it != mParameterMap.end() )

  {

    typeName = type_name_it.value();

  }

  else

  {

    return 1;

  }

  QStringList nonIdentifiableLayers = mConfigParser->identifyDisabledLayers();

  QMap< QString, QMap< int, QString > > aliasInfo = mConfigParser->layerAliasInfo();

  QMap< QString, QSet<QString> > hiddenAttributes = mConfigParser->hiddenAttributes();

  QList<QgsMapLayer*> layerList;

  QgsMapLayer* currentLayer = 0;

  layerList = mConfigParser->mapLayerFromStyle( typeName, "" );

  currentLayer = layerList.at( 0 );

  QgsVectorLayer* layer = dynamic_cast<QgsVectorLayer*>( currentLayer );

  if ( layer )

  {

    //is there alias info for this vector layer?

    QMap< int, QString > layerAliasInfo;

    QMap< QString, QMap< int, QString > >::const_iterator aliasIt = aliasInfo.find( currentLayer->id() );

    if ( aliasIt != aliasInfo.constEnd() )

    {

      layerAliasInfo = aliasIt.value();

    }

    //hidden attributes for this layer

    QSet<QString> layerHiddenAttributes;

    QMap< QString, QSet<QString> >::const_iterator hiddenIt = hiddenAttributes.find( currentLayer->id() );

    if ( hiddenIt != hiddenAttributes.constEnd() )

    {

      layerHiddenAttributes = hiddenIt.value();

    }

    //do a select with searchRect and go through all the features

    QgsVectorDataProvider* provider = layer->dataProvider();

    if ( !provider )

    {

      return 2;

    }

    QgsFeature feature;

    QgsAttributeMap featureAttributes;

    const QgsFieldMap& fields = provider->fields();

    //map extent

    QgsRectangle searchRect = layer->extent();

    //read FEATUREDID

    bool fidOk = false;

    QString fid;

    QMap<QString, QString>::const_iterator fidIt = mParameterMap.find( "FEATUREID" );

    if ( fidIt != mParameterMap.end() ) {

      fidOk = true;

      fid = fidIt.value();

    }

    //read FILTER

    bool filterOk = false;

    QDomDocument filter;

    QMap<QString, QString>::const_iterator filterIt = mParameterMap.find( "FILTER" );

    if ( filterIt != mParameterMap.end() ) {

      try {

      QString errorMsg;

      if ( !filter.setContent( filterIt.value(), true, &errorMsg ) )

      {

        QgsDebugMsg( "soap request parse error" );

        QgsDebugMsg( "error message: " + errorMsg );

        QgsDebugMsg( "the xml string was:" );

        QgsDebugMsg( filterIt.value() );

      }

      else 

      {

        filterOk = true;

      }

      } catch(QgsMapServiceException& e ) {

        filterOk = false;

      }

    }

    bool conversionSuccess;

    double minx, miny, maxx, maxy;

    bool bboxOk = false;

    //read BBOX

    QMap<QString, QString>::const_iterator bbIt = mParameterMap.find( "BBOX" );

    if ( bbIt == mParameterMap.end() )

    {

      minx = 0; miny = 0; maxx = 0; maxy = 0;

    }

    else

    {

      bboxOk = true;

      QString bbString = bbIt.value();

      minx = bbString.section( ",", 0, 0 ).toDouble( &conversionSuccess );

      if ( !conversionSuccess ) {bboxOk = false;}

      miny = bbString.section( ",", 1, 1 ).toDouble( &conversionSuccess );

      if ( !conversionSuccess ) {bboxOk = false;}

      maxx = bbString.section( ",", 2, 2 ).toDouble( &conversionSuccess );

      if ( !conversionSuccess ) {bboxOk = false;}

      maxy = bbString.section( ",", 3, 3 ).toDouble( &conversionSuccess );

      if ( !conversionSuccess ) {bboxOk = false;}

    }

    //read MAXFEATURES

    long maxFeat = layer->featureCount();

    long featureCounter = 0;

    QMap<QString, QString>::const_iterator mfIt = mParameterMap.find( "MAXFEATURES" );

    if ( mfIt != mParameterMap.end() )

    {

       QString mfString = mfIt.value();

       bool mfOk;

       maxFeat = mfString.toLong(&mfOk, 10);

       if ( !mfOk ) { maxFeat = layer->featureCount(); }

    }

    //read PROPERTYNAME

    bool withGeom = true;

    QgsAttributeList attrIndexes = provider->attributeIndexes();

    QMap<QString, QString>::const_iterator pnIt = mParameterMap.find( "PROPERTYNAME" );

    if ( pnIt != mParameterMap.end() )

    {

       QStringList attrList = pnIt.value().split( "," );

       if ( attrList.size() > 0 )

       {

         withGeom = false;

         QStringList::const_iterator alstIt;

         QList<int> idxList;

         QMap<QString, int> fieldMap = provider->fieldNameMap();

         QMap<QString, int>::const_iterator fieldIt;

         QString fieldName;

         for ( alstIt = attrList.begin(); alstIt != attrList.end(); ++alstIt )

         {

           fieldName = *alstIt;

           fieldIt = fieldMap.find( fieldName );

           if ( fieldIt != fieldMap.end() )

           {

             idxList.append( fieldIt.value() );

           }

           else if ( fieldName == "geometry" )

           {

             withGeom = true;

           }

         }

         if ( idxList.size() > 0 || withGeom)

         {

           attrIndexes = idxList;

         }

         else

         {

           withGeom = true;

         }

       }

    }

    QList<QgsFeature> featureList;

    if ( fidOk )

    {

      provider->featureAtId(  fid.toInt(), feature, withGeom, attrIndexes );

      featureList.append(feature);

    }

    else if ( filterOk )

    {

      provider->select( attrIndexes, searchRect, withGeom, true );

      try {

        QgsFilter* mFilter = QgsFilter::createFilterFromXml( filter.firstChild().toElement().firstChild().toElement(), layer );

        while ( provider->nextFeature( feature ) && featureCounter < maxFeat )

        {

          if ( mFilter )

          {

            if ( mFilter->evaluate( feature ) )

            {

              featureList.append(feature);

              ++featureCounter;

            }

          }

          else

          {

            featureList.append(feature);

              ++featureCounter;

          }

        }

        delete mFilter;

      } catch(QgsMapServiceException& e ) {

        while ( provider->nextFeature( feature ) && featureCounter < maxFeat )

        {

          featureList.append(feature);

          ++featureCounter;

        }

      }

    }

    else

    {

      if ( bboxOk )

        searchRect.set( minx, miny, maxx, maxy );

      provider->select( attrIndexes, searchRect, withGeom, true );

      while ( provider->nextFeature( feature ) && featureCounter < maxFeat )

      {

        featureList.append(feature);

        ++featureCounter;

      }

    }

    QList<QgsFeature>::const_iterator featureIt = featureList.constBegin();

    QString fcString;

    if ( format == "GeoJSON" )

    {

      featureCounter = 0;

      fcString = "{\"type\": \"FeatureCollection\",\n";

      fcString += " \"features\": [\n";

      result = fcString.toUtf8();

      request.startGetFeatureResponse(&result, format);

      fcString = "";

      for ( ; featureIt != featureList.constEnd(); ++featureIt )

      {

        feature = *featureIt;

        if (featureCounter == 0)

          fcString += "  {\"type\": \"Feature\",\n";

        else

          fcString += " ,{\"type\": \"Feature\",\n";

        fcString += "   \"id\": ";

        fcString +=  QString::number( feature.id() );

        fcString += ",\n";

        QgsGeometry* geom = feature.geometry();

        if ( geom && withGeom)

        {

          fcString += "  \"geometry\": ";

          fcString += geom->exportToGeoJSON();

          fcString += ",\n";

        }

        fcString += "   \"properties\": {\n";

        //read all attribute values from the feature

        featureAttributes = feature.attributeMap();

        int attributeCounter = 0;

        for ( QgsAttributeMap::const_iterator it = featureAttributes.begin(); it != featureAttributes.end(); ++it )

        {

          QString attributeName = fields[it.key()].name();

          //skip attribute if it has edit type 'hidden'

          if ( layerHiddenAttributes.contains( attributeName ) )

          {

            continue;

          }

          //check if the attribute name should be replaced with an alias

          QMap<int, QString>::const_iterator aliasIt = layerAliasInfo.find( it.key() );

          if ( aliasIt != layerAliasInfo.constEnd() )

          {

            attributeName = aliasIt.value();

          }

          if (attributeCounter == 0)

            fcString += "    \"";

          else

            fcString += "   ,\"";

          fcString += attributeName;

          fcString += "\": ";

          if (it->type() == 6 || it->type() == 2) 

          {

            fcString +=  it->toString();

          }

          else

          {

            fcString += "\"";

            fcString +=  it->toString().replace( QString( "\"" ), QString( "\\\"" ) );

            fcString += "\"";

          }

          fcString += "\n";

          ++attributeCounter;

        }

        fcString += "   }\n";

        fcString += "  }";

        fcString += "\n";

        result = fcString.toUtf8();

        request.sendGetFeatureResponse( &result );

        fcString = "";

        ++featureCounter;

      }

      fcString = "";

      fcString += " ]\n";

      fcString += "}";

      result = fcString.toUtf8();

      request.endGetFeatureResponse( &result );

      fcString = "";

    }

    else

    {

      QDomDocument gmlDoc;

      //wfs:FeatureCollection

      fcString = "<wfs:FeatureCollection";

      fcString += " xmlns=\"http://www.opengis.net/wfs\"";

      fcString += " xmlns:wfs=\"http://www.opengis.net/wfs\"";

      fcString += " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"";

      fcString += " xsi:schemaLocation=\"http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.0.0/wfs.xsd\"";

      fcString += " xmlns:ogc=\"http://www.opengis.net/ogc\"";

      fcString += " xmlns:gml=\"http://www.opengis.net/gml\"";

      fcString += " xmlns:ows=\"http://www.opengis.net/ows\"";

      fcString += " xmlns:xlink=\"http://www.w3.org/1999/xlink\"";

      fcString += " xmlns:qgs=\"http://www.qgis.org/gml\"";

      fcString += ">";

      result = fcString.toUtf8();

      request.startGetFeatureResponse(&result, format);

      fcString = "";

      for ( ; featureIt != featureList.constEnd(); ++featureIt )

      {

        feature = *featureIt;

        //gml:FeatureMember

        QDomElement featureElement = gmlDoc.createElement( "gml:featureMember"/*wfs:FeatureMember*/ );

        gmlDoc.appendChild(featureElement);

        //qgs:%TYPENAME%

        QDomElement typeNameElement = gmlDoc.createElement( "qgs:"+typeName.replace( QString(" "), QString("_") )/*qgs:%TYPENAME%*/ );

        typeNameElement.setAttribute( "fid", QString::number( feature.id() ) );

        featureElement.appendChild(typeNameElement);

        //read all attribute values from the feature

        featureAttributes = feature.attributeMap();

        for ( QgsAttributeMap::const_iterator it = featureAttributes.begin(); it != featureAttributes.end(); ++it )

        {

          QString attributeName = fields[it.key()].name();

          //skip attribute if it has edit type 'hidden'

          if ( layerHiddenAttributes.contains( attributeName ) )

          {

            continue;

          }

          //check if the attribute name should be replaced with an alias

          QMap<int, QString>::const_iterator aliasIt = layerAliasInfo.find( it.key() );

          if ( aliasIt != layerAliasInfo.constEnd() )

          {

            attributeName = aliasIt.value();

          }

          QDomElement fieldElem = gmlDoc.createElement( "qgs:"+attributeName );

          QDomText fieldText = gmlDoc.createTextNode( it->toString() );

          fieldElem.appendChild( fieldText );

          typeNameElement.appendChild( fieldElem );

        }

        if ( withGeom )

        {

          //add geometry column (as gml)

          QDomElement geomElem = gmlDoc.createElement( "qgs:geometry" );

          QDomElement gmlElem = createGeometryElem( feature.geometry(), gmlDoc );

          if ( !gmlElem.isNull() )

          {

            QgsCoordinateReferenceSystem layerCrs = layer->crs();

            if ( layerCrs.isValid() )

            {

              gmlElem.setAttribute( "srsName", layerCrs.authid() );

            }

            geomElem.appendChild( gmlElem );

            typeNameElement.appendChild( geomElem );

          }

        }

        result = gmlDoc.toByteArray();

        request.sendGetFeatureResponse( &result );

        gmlDoc.removeChild(featureElement);

      }

      fcString = "</wfs:FeatureCollection>";

      result = fcString.toUtf8();

      request.endGetFeatureResponse( &result );

      fcString = "";

    }

  }

  else

  {

    return 2;

  }

  return 0;

}

QDomElement QgsWFSServer::createGeometryElem( QgsGeometry* geom, QDomDocument& doc ) /*const*/

{

  if ( !geom )

  {

    return QDomElement();

  }

  QDomElement geomElement;

  QString geomTypeName;

  QGis::WkbType wkbType = geom->wkbType();

  switch ( wkbType )

  {

    case QGis::WKBPoint:

    case QGis::WKBPoint25D:

      geomElement = createPointElem( geom, doc );

      break;

    case QGis::WKBMultiPoint:

    case QGis::WKBMultiPoint25D:

      geomElement = createMultiPointElem( geom, doc );

      break;

    case QGis::WKBLineString:

    case QGis::WKBLineString25D:

      geomElement = createLineStringElem( geom, doc );

      break;

    case QGis::WKBMultiLineString:

    case QGis::WKBMultiLineString25D:

      geomElement = createMultiLineStringElem( geom, doc );

      break;

    case QGis::WKBPolygon:

    case QGis::WKBPolygon25D:

      geomElement = createPolygonElem( geom, doc );

      break;

    case QGis::WKBMultiPolygon:

    case QGis::WKBMultiPolygon25D:

      geomElement = createMultiPolygonElem( geom, doc );

      break;

    default:

      return QDomElement();

  }

  return geomElement;

}

QDomElement QgsWFSServer::createLineStringElem( QgsGeometry* geom, QDomDocument& doc ) const

{

  if ( !geom )

  {

    return QDomElement();

  }

  QDomElement lineStringElem = doc.createElement( "gml:LineString" );

  QDomElement coordElem = createCoordinateElem( geom->asPolyline(), doc );

  lineStringElem.appendChild( coordElem );

  return lineStringElem;

}

QDomElement QgsWFSServer::createMultiLineStringElem( QgsGeometry* geom, QDomDocument& doc ) const

{

  if ( !geom )

  {

    return QDomElement();

  }

  QDomElement multiLineStringElem = doc.createElement( "gml:MultiLineString" );

  QgsMultiPolyline multiline = geom->asMultiPolyline();

  QgsMultiPolyline::const_iterator multiLineIt = multiline.constBegin();

  for ( ; multiLineIt != multiline.constEnd(); ++multiLineIt )

  {

    QgsGeometry* lineGeom = QgsGeometry::fromPolyline( *multiLineIt );

    if ( lineGeom )

    {

      QDomElement lineStringMemberElem = doc.createElement( "gml:lineStringMember" );

      QDomElement lineElem = createLineStringElem( lineGeom, doc );

      lineStringMemberElem.appendChild( lineElem );

      multiLineStringElem.appendChild( lineStringMemberElem );

    }

    delete lineGeom;

  }

  return multiLineStringElem;

}