Merge branch 'master' of http://gitlab.ctune.cn/DMapServer/DMapServer4.1

@@ -14,7 +14,7 @@
 #include <boost/typeof/typeof.hpp>
 #include "dmpproject.h"
 #include "dmptilelayer.h"
-
+#include "dmpvectorlayer.h"
 using namespace boost::property_tree;
 DmpProject *DmpProject::project_ = nullptr;
 
@@ -84,6 +84,7 @@ bool DmpProject::Read(const std::string &data)
       else if (layerType == 1)
       {
         //vector
+        mapLayer = new DmpVectorLayer();
       }
       else if (layerType == 2)
       {

@@ -8,6 +8,10 @@ SET (MAPSERVER_SRCS
   dmppgsql.cpp
   dmppgsqlpool.cpp
   dmppgsqlsourcepools.cpp
+  wfs/dmpwfs.cpp
+  wfs/dmpwfsgetcapabilities.cpp
+  wfs/dmpwfsgetfeature.cpp
+  wfs/dmpwfsparameters.cpp
   wms/dmpwmsrenderer.cpp
   wms/dmpwms.cpp
   wms/dmpwmsparameters.cpp
@@ -22,6 +26,9 @@ SET (MAPSERVER_HDRS
   dmppgsql.h
   dmppgsqlpool.h
   dmppgsqlsourcepools.h
+  wfs/dmpwfsgetcapabilities.h
+  wfs/dmpwfsgetfeature.h
+  wfs/dmpwfsparameters.h
   wms/dmpwmsrenderer.h
   wms/dmpwms.h
   wms/dmpwmsparameters.h

@@ -8,7 +8,7 @@
  ***************************************************************************/
  
 
- #include <string>
+#include <string>
 #include "dmpmodule.h"
 #include <boost/dll/alias.hpp> // for BOOST_DLL_ALIAS
 #include <boost/filesystem.hpp>
@@ -51,7 +51,11 @@ namespace DmpWfs
     
   };
 
-
+  //实际中，WebGIS服务器针对这些功能并不是必须全部实现，而是实现全部或部分。
+  //因此，根据依据这些功能的支持与否，可以将WFS分为3类：
+  //Basic WFS    ——    必须支持GetCapabilities、DescribeFeature Type、GetFeature功能
+  //XLink WFS    ——    必须在Basic WFS基础上加上GetGmlObject操作
+  //Transaction WFS    ——    也称为WFS-T，必须在Basic WFS基础上加上Transaction功能以及支持编辑数据，另外也可以加上GetGmlObject或LockFeature功能
   class DmpWfsModule : public DmpServiceModule
   {
   public:

+/**************************************************************************
+* file:              dmpwfsgetcapabilities.cpp
+
+* Author:            qingxiongf
+* Date:              2021-12-22 14:04:56
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpwfsgetcapabilities.h"
+#include "dmpserverresponse.h"
+#include "dmpserverrequest.h"
+#include "dmpserverproject.h"
+#include "dmpvectorlayer.h"
+
+
+namespace DmpWfs
+{
+  void writeGetCapabilities( const DmpServerContext &context, const DmpWfsParameters& params, 
+                             const  DmpProject* project,  bool projectSettings)
+  {
+    std::string serviceName = context.serverProject()->name();
+    std::string serviceTitle = context.serverProject()->title();
+    if(serviceTitle.empty()) serviceTitle = serviceName;
+
+    std::string version = params.Version();
+    std::string hrefUrl;
+    char char_hrefUrl[1024] = {0}; 
+	  std::string domain = context.request()->domain();
+    std::string port = context.request()->port();
+    if(port == "80" || port =="")
+    {
+      sprintf(char_hrefUrl, "http://%s%s", domain.c_str(), context.request()->path().c_str());
+    }
+    else
+    {
+      sprintf(char_hrefUrl, "http://%s:%s%s", domain.c_str(),port.c_str(), context.request()->path().c_str());
+    }
+    hrefUrl = char_hrefUrl;
+   // hrefUrl = "http://172.26.40.51:8821/?mapService=test";
+    std::shared_ptr<boost::property_tree::ptree> doc = getCapabilities(project, version,hrefUrl,serviceName,serviceTitle,projectSettings);
+
+    std::stringstream stream; 
+    write_xml(stream, *doc.get());
+    std::string xml;
+    xml = stream.str();
+
+   // DmpServerResponse* response = context.response();
+    context.response()->removeHeader("Content-Type");
+    context.response()->setHeader("Content-Type", "text/xml;charset=utf-8");
+    context.response()->write(xml);
+  }
+
+
+   std::shared_ptr<boost::property_tree::ptree>  getCapabilities( const DmpProject* project,
+                                const std::string &serviceName, const std::string &serviceTitle,
+                                const std::string &version, const std::string &hrefUrl,
+                                bool projectSettings )
+  {
+    std::shared_ptr<boost::property_tree::ptree> xmlRootDoc(new boost::property_tree::ptree());
+    boost::property_tree::ptree xmlRoot;
+    std::string rootname;
+
+    rootname = "WFS_Capabilities";
+    xmlRoot.add("<xmlattr>.xmlns:xsi","http://www.w3.org/2001/XMLSchema-instance");
+    xmlRoot.add("<xmlattr>.xmlns","http://www.opengis.net/wfs");
+    xmlRoot.add("<xmlattr>.xmlns:sld","http://www.opengis.net/sld");
+    xmlRoot.add("<xmlattr>.xsi:schemaLocation","http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.0.0/WFS-capabilities.xsd");
+    xmlRoot.add("<xmlattr>.version", version);
+    xmlRoot.add("<xmlattr>.updateSequence", "0");
+    
+    boost::property_tree::ptree ptService;
+    ptService.add("Name", serviceName);
+    ptService.add("Title", serviceTitle);
+    ptService.add("Abstract", "dmap wfs service");
+    ptService.add("Keywords", "WFS,DMAP,"+ serviceName );
+    ptService.add("OnlineResource", hrefUrl);
+    ptService.add("Fees","none");
+    ptService.add("AccessConstraints","none");
+    xmlRoot.add_child("Service",ptService);
+ 
+    boost::property_tree::ptree ptCapability;
+    addCapabilitiesRequest(ptCapability,hrefUrl);
+    xmlRoot.add_child("Capability",ptCapability);
+
+    boost::property_tree::ptree ptFeatureTypeList;
+    addFeatureTypeList(ptFeatureTypeList,project);
+    xmlRoot.add_child("FeatureTypeList",ptFeatureTypeList);
+
+    boost::property_tree::ptree ptFilter;
+    addFilterCapabilities(ptFilter,hrefUrl);
+    xmlRoot.add_child("ogc:Filter_Capabilities",ptFilter);
+
+    xmlRootDoc->add_child(rootname,xmlRoot);
+    return xmlRootDoc;
+
+  }
+
+  void addCapabilitiesRequest(boost::property_tree::ptree &pt, const std::string &hrefUrl)
+  {
+      boost::property_tree::ptree ptRequest;
+      
+      boost::property_tree::ptree ptGetCapabilities;
+      addCapabilitiesRequest_DCPType(ptGetCapabilities, hrefUrl, "Get");
+      addCapabilitiesRequest_DCPType(ptGetCapabilities, hrefUrl, "Post");
+      ptRequest.add_child("GetCapabilities", ptGetCapabilities);
+
+      boost::property_tree::ptree ptDescribeFeatureType;
+      boost::property_tree::ptree ptSchemaDescriptionLanguage;
+      ptSchemaDescriptionLanguage.add("XMLSCHEMA","");
+      ptDescribeFeatureType.add_child("SchemaDescriptionLanguage",ptSchemaDescriptionLanguage);
+      addCapabilitiesRequest_DCPType(ptDescribeFeatureType, hrefUrl, "Get");
+      addCapabilitiesRequest_DCPType(ptDescribeFeatureType, hrefUrl, "Post");
+      ptRequest.add_child("DescribeFeatureType", ptDescribeFeatureType);
+
+      boost::property_tree::ptree ptGetFeature;
+      boost::property_tree::ptree ptResultFormat;
+      ptResultFormat.add("GML2","");
+      ptResultFormat.add("GML3","");
+      ptResultFormat.add("GeoJSON","");
+      ptGetFeature.add_child("ResultFormat",ptResultFormat);
+      addCapabilitiesRequest_DCPType(ptGetFeature, hrefUrl, "Get");
+      addCapabilitiesRequest_DCPType(ptGetFeature, hrefUrl, "Post");
+      ptRequest.add_child("GetFeature", ptGetFeature);
+
+      boost::property_tree::ptree ptTransaction;
+      addCapabilitiesRequest_DCPType(ptTransaction, hrefUrl, "Post");
+      ptRequest.add_child("Transaction", ptTransaction);
+
+      pt.add_child("Request", ptRequest);
+      return;
+  }
+
+   void addCapabilitiesRequest_DCPType(boost::property_tree::ptree &pt, const std::string &hrefUrl, std::string method)
+   {
+       boost::property_tree::ptree pt_dcpType;
+       boost::property_tree::ptree pt_http;
+       boost::property_tree::ptree pt_method;
+
+       pt_method.add("<xmlattr>.onlineResource", hrefUrl);
+
+       pt_http.add_child(method, pt_method);
+       pt_dcpType.add_child("HTTP", pt_http);
+       pt.add_child("DCPType", pt_dcpType);
+   }
+
+   void addFeatureTypeList(boost::property_tree::ptree &pt,const DmpProject *project)
+   {
+       boost::property_tree::ptree ptOperations;
+       ptOperations.add("Query","");
+       pt.add_child("Operations", ptOperations);
+
+       int i = 0;
+       std::map<std::string, DmpMapLayer *> mapLayers = project->mapLayers();
+       for (std::map<std::string, DmpMapLayer *>::iterator iter = mapLayers.begin(); iter != mapLayers.end(); iter++, i++)
+       {
+           DmpVectorLayer *layer = (DmpVectorLayer *)iter->second;
+           std::string source = layer->source();
+           shared_ptr<DmpPgsql> pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(layer->source());
+           if (pPgsqlConn != nullptr)
+           {
+               boost::property_tree::ptree ptFeatureType;
+               std::string srs = "EPSG:" + std::__cxx11::to_string(project->crs().srid());
+               ptFeatureType.add("<xmlattr>.id", i);
+               ptFeatureType.add("Name", layer->name());
+               ptFeatureType.add("Title", layer->title());
+               ptFeatureType.add("DisplayColumn", "");
+               ptFeatureType.add("Geometry", "点");
+               ptFeatureType.add("GeometryColumn", layer->geom());
+               ptFeatureType.add("SRS", srs);
+
+               boost::property_tree::ptree ptBoundingbox;
+               ptBoundingbox.add("<xmlattr>.CRS", srs);
+               if (boost::iequals(srs, "CRS:84") || boost::iequals(srs, "EPSG:4326"))
+               {
+                   ptBoundingbox.add("<xmlattr>.miny", layer->extent().xmin());
+                   ptBoundingbox.add("<xmlattr>.maxy", layer->extent().xmax());
+                   ptBoundingbox.add("<xmlattr>.minx", layer->extent().ymin());
+                   ptBoundingbox.add("<xmlattr>.maxx", layer->extent().ymax());
+               }
+               else
+               {
+                   ptBoundingbox.add("<xmlattr>.minx", layer->extent().xmin());
+                   ptBoundingbox.add("<xmlattr>.maxx", layer->extent().xmax());
+                   ptBoundingbox.add("<xmlattr>.miny", layer->extent().ymin());
+                   ptBoundingbox.add("<xmlattr>.maxy", layer->extent().ymax());
+               }
+               ptFeatureType.add_child("LatLongBoundingBox", ptBoundingbox);
+
+               boost::property_tree::ptree ptFields;
+               for (; pPgsqlConn->next();)
+               {
+                   std::string fieldname = pPgsqlConn->getString(0);
+                   std::string typeString = pPgsqlConn->getString(1);
+                   std::string aliasName = "";
+                   std::string type = "";
+                   int typeInt = PGFieldType::VarCharFieldType;
+                   if (layer->geom() == fieldname)
+                   {
+                       typeString = "geometry";
+                       typeInt = PGFieldType::ShapeFieldType;
+                   }
+                   else if (typeString == "integer")
+                   {
+                       typeInt = PGFieldType::IntFieldType;
+                   }
+                   else if (typeString == "bigint")
+                   {
+                       typeInt = PGFieldType::BigIntFieldType;
+                   }
+                   else if (typeString == "double precision" || typeString == "real" || typeString == "numeric")
+                   {
+                       typeInt = PGFieldType::DoubleFieldType;
+                   }
+                   else if (typeString == "character varying" || typeString == "text")
+                   {
+                       typeInt = PGFieldType::VarCharFieldType;
+                   }
+                   else if (typeString == "geometry")
+                   {
+                       typeInt = PGFieldType::ShapeFieldType;
+                   }
+                   else if (typeString == "bytea")
+                   {
+                       typeInt = PGFieldType::ByteaFieldType;
+                   }
+                   else if (typeString == "timestamp without time zone")
+                   {
+                       typeInt = PGFieldType::TimestampWithoutTimeZone;
+                   }
+
+                   switch (typeInt)
+                   {
+                   case PGFieldType::IntFieldType:
+                       typeString = "integer";
+                       break;
+                   case PGFieldType::BigIntFieldType:
+                   case PGFieldType::DoubleFieldType:
+                       typeString = "double";
+                       break;
+                   case PGFieldType::VarCharFieldType:
+                       typeString = "string";
+                       break;
+                   default:
+                       break;
+                   }
+                   boost::property_tree::ptree ptField;
+                   ptField.add("<xmlattr>.name", fieldname);
+                   ptField.add("<xmlattr>.aliasName", aliasName);
+                   ptField.add("<xmlattr>.type", "xsd:" + typeString);
+                   ptField.add("<xmlattr>.minOccurs", "0");
+                   ptField.add("<xmlattr>.maxOccurs", "1");
+                   ptFields.add_child("Field", ptField);
+               }
+               ptFeatureType.add_child("Fields", ptFields);
+               pt.add_child("FeatureType", ptFeatureType);
+           }
+           
+       }
+   }
+
+
+   void addFilterCapabilities(boost::property_tree::ptree &pt,const std::string &hrefUrl)
+   {
+        boost::property_tree::ptree ptFilterCapabilities;
+
+        boost::property_tree::ptree ptSpatialCapabilities;
+        boost::property_tree::ptree ptSpatialOperators;
+        ptSpatialOperators.add("ogc:BBOX","");
+        ptSpatialCapabilities.add_child("ogc:Spatial_Operators",ptSpatialOperators);
+        ptFilterCapabilities.add_child("ogc:Spatial_Capabilities", ptSpatialCapabilities);
+
+
+        boost::property_tree::ptree ptScalarCapabilities;
+        boost::property_tree::ptree ptComparisonOperators;
+        ptComparisonOperators.add("ogc:Simple_Comparisons","");
+        ptScalarCapabilities.add_child("ogc:Comparison_Operators",ptComparisonOperators);
+        ptFilterCapabilities.add_child("ogc:Filter_Capabilities", ptScalarCapabilities);
+
+        pt.add_child("ogc:Filter_Capabilities", ptFilterCapabilities);
+   }
+
+
+}
\ No newline at end of file

+/**************************************************************************
+* file:              dmpwfsgetcapabilities.h
+
+* Author:            qingxiongf
+* Date:              2021-12-22 13:59:41
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpwfsgetcapabilities_h__
+#define __dmpwfsgetcapabilities_h__
+
+#include <boost/property_tree/ptree.hpp> 
+#include <boost/property_tree/xml_parser.hpp> 
+#include <boost/typeof/typeof.hpp>
+#include <memory>
+#include <vector>
+#include "dmpproject.h"
+#include "dmpwfsparameters.h"
+#include "dmpservercontext.h"
+#include "dmppgsqlsourcepools.h"
+
+using namespace mapserver;
+namespace DmpWfs
+{
+    
+  /**
+   * Output GetCapabilities response
+   */
+  void writeGetCapabilities( const DmpServerContext &context,const DmpWfsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings = false);
+
+    /**
+   * Creates the WMS GetCapabilities XML document.
+   * \param serverIface Interface for plugins
+   * \param project Project
+   * \param version WMS version
+   * \param request WMS request
+   * \param projectSettings If TRUE, adds extended project information (does not validate against WMS schema)
+   * \returns GetCapabilities XML document
+   */
+    std::shared_ptr<boost::property_tree::ptree>  getCapabilities( const DmpProject* project,
+                                const std::string &serviceName, const std::string &serviceTitle,
+                                const std::string &version, const std::string &hrefUrl,
+                                bool projectSettings );
+
+    void addCapabilitiesRequest(boost::property_tree::ptree &pt, const std::string &hrefUrl);
+
+    void addCapabilitiesRequest_DCPType(boost::property_tree::ptree &pt, const std::string &hrefUrl, std::string method);
+
+    void addFeatureTypeList(boost::property_tree::ptree &pt,const DmpProject* project);
+
+    void addFilterCapabilities(boost::property_tree::ptree &pt,const std::string &hrefUrl);
+    
+}
+
+
+#endif // __dmpwfsgetcapabilities_h__

+/**************************************************************************
+* file:              dmpwfsgetfeature.cpp
+
+* Author:            qingxiongf
+* Date:              2021-12-24 10:57:55
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpwfsgetfeature.h"
+namespace DmpWfs
+{
+    void writeGetFeature(const DmpServerContext &context,const DmpWfsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings)
+    {
+       
+    }
+
+    std::string WfsGetFeature(const DmpServerContext &context,const DmpWfsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings)
+    {
+      char buff[5000];
+	  return "";
+	//  SqlFactory sqlF;
+
+	  /*shared_ptr<WMSServer> service = _dmapWms.GetWmsService(parseString.mapService);
+	  if(service == nullptr)
+	  {
+		  return false;
+	  }
+
+	  sqlF.SetStartIndexCount(parseString.startIndex, parseString.maxFeatures, parseString.resulttype);
+	  std::vector<std::string> ids;
+	  if (parseString.featureid)
+	  {
+		  char *idstring[1000];
+		  //将ID值以逗号分开，并返回个数
+		  int idn = StringHelp::ParseStringTok(parseString.featureid, ',', idstring, 1000);
+		  for (int i = 0; i < idn; i++)
+		  {
+			  char *ss[2];
+			  //形式：LayerName.ID
+			  int n = StringHelp::ParseStringTok(idstring[i], '.', ss, 2);
+			  if (n == 2)
+			  {
+				  if (parseString.layerName == 0)
+				  {
+					  parseString.layerName = ss[0];
+				  }
+				  ids.push_back(ss[1]);
+			  }
+			  else if (n == 1)
+			  {
+				  ids.push_back(ss[0]);
+			  }
+		  }
+	  }
+
+	  std::vector<std::string> props;
+	  std::vector<std::string> propsAs;
+	  if (parseString.propertyname)
+	  {
+		  char *idstring[1000];
+		  int idn = StringHelp::ParseStringTok(parseString.propertyname, ',', idstring, 1000);
+		  for (int i = 0; i < idn; i++)
+		  {
+			  char *ss[2];
+			  std::string sProp, sPropAs;
+			  int n = StringHelp::ParseStringTok(idstring[i], '.', ss, 2);
+			  if (n == 2)
+			  {
+				  if (parseString.layerName == 0)
+				  {
+					  parseString.layerName = ss[0];
+				  }
+				  //又以空格分开
+				  StringHelp::GetAsStringSql(ss[1], sProp, sPropAs);
+				  props.push_back(sProp);
+				  propsAs.push_back(sPropAs);
+				  //sPropOrig=ss[1];
+			  }
+			  else if (n == 1)
+			  {
+				  StringHelp::GetAsStringSql(ss[0], sProp, sPropAs);
+				  props.push_back(sProp);
+				  propsAs.push_back(sPropAs); //props.push_back(ss[0]);
+			  }
+		  }
+	  }
+
+	  if (parseString.layerName == 0)
+		  return Error(buff, ErrorClass::ParaError, "layername not exist", ab);
+
+	  //const char *realLayer=0;
+	  //GetUpLayerID是干什么的？
+	  //似乎就是加了些L啊什么的。。 。
+	 // if (_GetUperLayerId(parseString.layerName, sLayer) == false)
+	 //	  return Error(buff, ErrorClass::ParaError, "layer not exist", ab);
+
+	  shared_ptr<MapLayer> mapLayer = service->GetLayer(parseString.layerName);
+
+	
+	  if(mapLayer == nullptr)
+	  {
+		   return Error(buff, ErrorClass::ParaError, "layer not find", ab);
+	  }
+
+	  shared_ptr<Workspace> pWorkspace = DataSourcePools::get_instance()->GetWorkspace(mapLayer->m_dbSource);
+	  if(pWorkspace == nullptr)
+	  {
+	    	return Error(buff, ErrorClass::DatabaseDisconnect, "连接数据库失败", ab);
+	  }
+	  shared_ptr<dmapFields> fields = pWorkspace->GetFields(mapLayer->m_layerName,"");
+
+	  if(fields == nullptr)
+	  {
+		  return Error(buff, ErrorClass::ParaError, "layername not exist", ab);
+	  }
+
+
+      shared_ptr<TableDesc> pTabledesc = this->ToTableDesc(fields,mapLayer->m_layerName);
+	  
+
+	  size_t propCount = props.size();
+	  if (propCount)
+	  {
+		  std::string sF; 
+		  for (int i = 0; i < propCount; i++)
+		  {
+			  if (i)
+				  sF = sF + ",";
+			  string sleft, sright, s;
+			  s = props[i];
+			  int at1 = s.find("("), at2 = s.find(")");
+
+			  if (at1 != string::npos && at2 == s.length() - 1 && at1 < at2)
+			  {
+				  sleft = s.substr(0, at1);
+				  sright = s.substr(at1 + 1, s.length() - 2 - at1);
+				  if (_stricmp(sleft.c_str(), "distinct") == 0)
+				  {
+					  sF = sF + sleft + " " + fields->GetFieldQuery(sright.c_str());
+				  }
+				  else
+				  {
+					  sF = sF + sleft + "(" + fields->GetFieldQuery(sright.c_str()) + ")";
+				  }
+			  }
+			  else
+			  {
+				  sF = sF + fields->GetFieldQuery(s.c_str());
+			  }
+			 
+		  }
+		  sqlF.prop = sF;
+	  }
+	  else
+	  {
+		  bool isJson = (parseString.format && (strcmpi(parseString.format, "geojson") ==0 || strcmpi(parseString.format, "json") ==0));
+		  this->GetAllField( srsOut,  sqlF.prop,mapLayer,pWorkspace,isJson);
+	  }
+
+	  size_t idCount = ids.size();
+
+	  
+
+	  if (parseString.filter)
+	  {
+		  clsFilter filter(mapLayer->m_srid);
+		  
+		  if (filter.Parse(parseString.filter, pTabledesc.get(),DatabaseTypePostgreSQL))
+		  {
+			  return Error(buff, ErrorClass::FilterError, filter.err, ab);
+		  }
+
+		  sqlF.AppendCondition(filter.sql);
+	  }
+	  if (parseString.sortby)
+	  {
+		  clsFilter filter(mapLayer->m_srid);
+		  if (filter.ParseOrder(parseString.sortby, pTabledesc.get(), DatabaseTypePostgreSQL))
+		  {
+			  return Error(buff, ErrorClass::SortError, filter.err, ab);
+		  }
+		  sqlF.order = filter.sql;
+	  }
+	  sqlF.table = mapLayer->m_layerName;
+	  std::string sq = sqlF.GetSql(DatabaseTypePostgreSQL);
+
+	  bool returnResult = pWorkspace->ExecWaitBinary(sq);
+	  if (!returnResult)
+	  {
+		  return Error(buff, ErrorClass::QueryError, pWorkspace->m_sError.c_str(), ab);
+	  }
+	  int ver = ParseString::GetGMLVersion(parseString.version, parseString.outputFormat);
+	  if (parseString.format && (strcmpi(parseString.format, "geojson") ==0|| strcmpi(parseString.format, "json")==0))
+	  {
+		  isPicture = 10;
+		  return this->FormatWFSJsonCAll(pWorkspace, ab, parseString.layerName, buff, ver);
+	  }
+	  else
+	  {
+		  isPicture = 0;
+		  return this->FormatWFSXMLCAll(pWorkspace, ab, parseString.layerName, buff, ver);
+	  }*/
+    }
+
+
+
+}
\ No newline at end of file

+/**************************************************************************
+* file:              dmpwfsgetfeature.h
+
+* Author:            qingxiongf
+* Date:              2021-12-24 10:57:45
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpwfsgetfeature_h__
+#define __dmpwfsgetfeature_h__
+#include <boost/property_tree/ptree.hpp> 
+#include <boost/property_tree/xml_parser.hpp> 
+#include <boost/typeof/typeof.hpp>
+#include <memory>
+#include <vector>
+#include "dmpproject.h"
+#include "dmpwfsparameters.h"
+#include "dmpservercontext.h"
+#include "dmppgsqlsourcepools.h"
+
+namespace DmpWfs
+{
+    void writeGetFeature(const DmpServerContext &context,const DmpWfsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings = false);
+
+  //  std::string WfsGetFeature(const DmpServerContext &context,const DmpWfsParameters& params, 
+   //                          const  DmpProject* project,
+  //                           bool projectSettings = false);
+
+   
+}
+
+#endif // __dmpwfsgetfeature_h__

+
+/**************************************************************************
+* file:              dmpwfsparameters.h
+
+* Author:            qingxiongf
+* Date:              2021-12-22 20:46:29
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpwfsparameters_h__
+#define __dmpwfsparameters_h__
+
+
+#include "dmpserverparameters.h"
+
+namespace DmpWfs
+{
+   class DmpWfsParameters : public DmpServerParameters
+    {
+    public:
+        enum class Format
+        {
+            NONE,
+            JPG,
+            PNG,
+            TEXT,
+            XML,
+            HTML,
+            GML2,
+            GML3,
+            GeoJson
+        };
+        DmpWfsParameters(const DmpServerParameters &parameters);
+        DmpWfsParameters();
+        virtual ~DmpWfsParameters() = default;
+        //GetCapabilities
+        std::string Service() const;  //必须 值为WFS
+        std::string Request() const;  //必须 值为 GetCapabilities GetFeature DescribeFeatureType GetGmlObject  Transaction  LockFeature        
+        std::string Version() const; //必须  服务版本， 值为 1.0.0, 1.1.0, 1.1.1, 1.3
+
+        //DescribeFeatureType 
+        //GetFeature
+        std::string TypeName() const; //必须 坐标系 
+        std::string OutputFormat() const; //必须
+        std::string BBox() const; //必须
+        std::string Filter() const; 
+        std::string Sortby() const;
+        int MaxFeatures() const;  //指定返回最多要素
+        std::string PropertyName() const; //指定返回的要素属性，没有指定不返回
+        std::string SrsName() const; //空间参考坐标
+        std::string FeatureID() const; //要素ID
+        //std::string Expiry(); 
+        //std::string ResultType();
+        //std::string FeatureVsrsion();
+
+       //Transaction（对要素数据增、删、改）
+       //暂时不实现
+
+
+
+    private:
+        bool GetStringParameter(const char* key, std::string &value) const;
+        bool GetIntParameter(const char* key, int& value) const;
+      
+    };
+}
+
+#endif // __dmpwfsparameters_h__
+