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

@@ -11,21 +11,22 @@
 #include "dmpvectorlayerrenderer.h"
 #include "dmpproviderregistry.h"
 #include "libpq-fe.h"
+#include "clsUtil.h"
+#include <boost/algorithm/string/predicate.hpp>
 
 DmpVectorLayer::DmpVectorLayer(const std::string &path,
-                               const std::string &baseName,
-                               const std::string &providerKey,
-                               const DmpVectorLayer::LayerOptions &options)
-  : DmpMapLayer(DmpMapLayerType::VectorLayer, baseName, path)
-  , readExtentFromXml_(options.readExtentFromXml)
+							   const std::string &baseName,
+							   const std::string &providerKey,
+							   const DmpVectorLayer::LayerOptions &options)
+	: DmpMapLayer(DmpMapLayerType::VectorLayer, baseName, path), readExtentFromXml_(options.readExtentFromXml)
 {
-  wkbType_ = options.fallbackWkbType;
-  setProviderType(providerKey);
+	wkbType_ = options.fallbackWkbType;
+	setProviderType(providerKey);
 
-  if (!path.empty() && !providerKey.empty())
-  {
-    setDataSource(path, baseName, providerKey, options.loadDefaultStyle );
-  }
+	if (!path.empty() && !providerKey.empty())
+	{
+		setDataSource(path, baseName, providerKey, options.loadDefaultStyle);
+	}
 }
 
 DmpVectorLayer::~DmpVectorLayer()
@@ -34,147 +35,254 @@ DmpVectorLayer::~DmpVectorLayer()
 
 DmpMapLayerRenderer *DmpVectorLayer::createMapRenderer(DmpRenderContext &rendererContext)
 {
-  return new DmpVectorLayerRenderer(this, rendererContext);
+	return new DmpVectorLayerRenderer(this, rendererContext);
 }
 
 bool DmpVectorLayer::readXml(const boost::property_tree::ptree &layerNode)
 {
-  //id="gzxxd_aabe200b_5b63_4b82_8546_af1fc99e4ec6" name="gzxxd" alias="中学" type="1"
-  // geometry="Point" alwaysShow="true" maxScale="0" maxScale="50000"
-  id_ = layerNode.get<std::string>("<xmlattr>.id");
-  name_ = layerNode.get<std::string>("<xmlattr>.name");
-  title_ = layerNode.get<std::string>("<xmlattr>.alias");
-  boost::property_tree::ptree pExtent = layerNode.get_child("extent");
-  extent_ = DmpXmlUtils::readRectangle(pExtent);
-  dataSource_ = layerNode.get<std::string>("datasource");
-
-  setDataProvider("postgres");
-
- // boost::property_tree::ptree pResourceMetadata = layerNode.get_child("resourcemetadata");
- // schema_ = layerNode.get<std::string>("schema");
- // geom_ = layerNode.get<std::string>("geom");
- // featurecount_ = layerNode.get<unsigned int>("featurecount");
-
-  boost::property_tree::ptree ptRenderer = layerNode.get_child("renderer");
-  auto pIter = ptRenderer.begin();
-  if(pIter == ptRenderer.end())return false;
-  DmapCore_30::Renderer* renderer_30 = nullptr;
-  DmapCore_30::clsXML::XMLParse(pIter->first, pIter->second, &renderer_30);
-  renderer_30_ = shared_ptr<DmapCore_30::Renderer>(renderer_30);
-
- // geom_ = "geom";
- // schema_ = "public";
- // wkbType_ = DmpWkbTypes::MultiLineString;
-
-  return true;
+	//id="gzxxd_aabe200b_5b63_4b82_8546_af1fc99e4ec6" name="gzxxd" alias="中学" type="1"
+	// geometry="Point" alwaysShow="true" maxScale="0" maxScale="50000"
+	id_ = layerNode.get<std::string>("<xmlattr>.id");
+	name_ = layerNode.get<std::string>("<xmlattr>.name");
+	title_ = layerNode.get<std::string>("<xmlattr>.alias");
+	boost::property_tree::ptree pExtent = layerNode.get_child("extent");
+	extent_ = DmpXmlUtils::readRectangle(pExtent);
+	dataSource_ = layerNode.get<std::string>("datasource");
+
+	if (!setDataProvider(dataSource_))
+	{
+		schema_ = layerNode.get<std::string>("<xmlattr>.schema");
+		geom_ = layerNode.get<std::string>("<xmlattr>.geomfield");
+		wkbTypeString_ = layerNode.get<std::string>("<xmlattr>.geometry");
+		featurecount_ = layerNode.get<unsigned int>("<xmlattr>.featurecount");
+		srid_ = layerNode.get<std::string>("<xmlattr>.srid");
+	}
+
+	if (boost::iequals(wkbTypeString_, "POINT"))
+		wkbType_ = DmpWkbTypes::Point;
+	else if (boost::iequals(wkbTypeString_, "MULTIPOINT"))
+		wkbType_ = DmpWkbTypes::MultiPoint;
+	else if (boost::iequals(wkbTypeString_, "LINESTRING"))
+		wkbType_ = DmpWkbTypes::LineString;
+	else if (boost::iequals(wkbTypeString_, "MULTILINESTRING"))
+		wkbType_ = DmpWkbTypes::MultiLineString;
+	else if (boost::iequals(wkbTypeString_, "POLYGON"))
+		wkbType_ = DmpWkbTypes::Polygon;
+	else if (boost::iequals(wkbTypeString_, "MULTIPOLYGON"))
+		wkbType_ = DmpWkbTypes::MultiPolygon;
+	else if (boost::iequals(wkbTypeString_, "GEOMETRY"))
+		wkbType_ = DmpWkbTypes::Unknown;
+
+	boost::property_tree::ptree ptRenderer = layerNode.get_child("renderer");
+	auto pIter = ptRenderer.begin();
+	if (pIter == ptRenderer.end())
+		return false;
+	DmapCore_30::Renderer *renderer_30 = nullptr;
+	DmapCore_30::clsXML::XMLParse(pIter->first, pIter->second, &renderer_30);
+	renderer_30_ = shared_ptr<DmapCore_30::Renderer>(renderer_30);
+
+	// geom_ = "geom";
+	// schema_ = "public";
+	// wkbType_ = DmpWkbTypes::MultiLineString;
+
+	return true;
 }
 
 bool DmpVectorLayer::writeXml(boost::property_tree::ptree &layerNode)
 {
-  layerNode.add("<xmlattr>.id", id_);
-  layerNode.add("<xmlattr>.name", name_);
-  layerNode.add("<xmlattr>.alias", title_);
-
-
-  boost::property_tree::ptree ptExtent;
-  ptExtent.add("xmin", extent_.xmin());
-  ptExtent.add("ymin", extent_.ymin());
-  ptExtent.add("xmax", extent_.xmax());
-  ptExtent.add("ymax", extent_.ymax());
-  layerNode.add_child("extent", ptExtent);
-
-  layerNode.add("datasource", dataSource_);
-   boost::property_tree::ptree ptRenderer;
-  if(this->renderer_30_)
-  {
-     this->renderer_30_->ParsePtree(ptRenderer);
-  }
-  layerNode.add_child("renderer",ptRenderer);
-
-  return true;
+	layerNode.add("<xmlattr>.id", id_);
+	layerNode.add("<xmlattr>.name", name_);
+	layerNode.add("<xmlattr>.alias", title_);
+
+	boost::property_tree::ptree ptExtent;
+	ptExtent.add("xmin", extent_.xmin());
+	ptExtent.add("ymin", extent_.ymin());
+	ptExtent.add("xmax", extent_.xmax());
+	ptExtent.add("ymax", extent_.ymax());
+	layerNode.add_child("extent", ptExtent);
+
+	layerNode.add("datasource", dataSource_);
+	boost::property_tree::ptree ptRenderer;
+	if (this->renderer_30_)
+	{
+		this->renderer_30_->ParsePtree(ptRenderer);
+	}
+	layerNode.add_child("renderer", ptRenderer);
+
+	return true;
 }
 
-void DmpVectorLayer::setRenderer(DmpFeatureRenderer *renderer)
+bool DmpVectorLayer::writejson(std::string &json)
 {
+	string shapeTypeString = "UNKNOWORD";
+
+	switch (wkbType_)
+	{
+	case DmpWkbTypes::Point:
+		shapeTypeString = "POINT";
+		break;
+	case DmpWkbTypes::MultiPoint:
+		shapeTypeString = "MULTIPOINT";
+		break;
+	case DmpWkbTypes::LineString:
+		shapeTypeString = "LINESTRING";
+		break;
+	case DmpWkbTypes::MultiLineString:
+		shapeTypeString = "MULTILINESTRING";
+		break;
+	case DmpWkbTypes::Polygon:
+		shapeTypeString = "POLYGON";
+		break;
+	case DmpWkbTypes::MultiPolygon:
+		shapeTypeString = "MULTIPOLYGON";
+		break;
+	default:
+		shapeTypeString = "UNKNOWORD";
+		break;
+	}
+
+	bool alwaysShow = this->minScale() == 0 && this->maxScale() > 10000000000;
+	char buff_maxscale[100];
+	char buff_minscale[100];
+	if (this->maxScale() > 100000000)
+	{
+		sprintf(buff_maxscale, "%e", this->maxScale());
+	}
+	else
+	{
+		sprintf(buff_maxscale, "%.0f", this->maxScale());
+	}
+
+	if (this->minScale() > 100000000)
+	{
+		sprintf(buff_minscale, "%e", this->minScale());
+	}
+	else
+	{
+		sprintf(buff_minscale, "%.0f", this->minScale());
+	}
+	//Display scale setting  type="1" geometry="Point" alwaysShow="true" maxScale="0" maxScale="50000">
+	char resultbuff[1000];
+	string json_source = this->source();
+	DmapCore_30::clsUtil::ToJSONString(json_source);
+	sprintf(resultbuff,
+			R"({"workspace":"","type":"1","dbsource":"%s","data":"","schema":"%s","alias":"%s","name":"%s","id":"%s","filter":"%s","visible":"%s","tag":"","minScale":"%s","maxScale":"%s","geometry":"%s","alwaysShow":"%s")",
+			json_source.c_str(),
+			this->schema().c_str(),
+			this->title().c_str(),
+			this->name().c_str(),
+			this->id().c_str(),
+			this->wherestr_.c_str(),
+			"true",
+			buff_minscale, buff_maxscale,
+			shapeTypeString.c_str(),
+			alwaysShow ? "true" : "false");
+
+	json.append(resultbuff);
+	if (this->renderer_30_ != nullptr)
+	{
+
+		json.append(",");
+		DmapCore_30::AppendBuffer ab;
+		this->renderer_30_->ToJson(&ab);
+		json.append(ab.GetString());
+	}
+	json.append("}");
+	return true;
+}
 
+void DmpVectorLayer::setRenderer(DmpFeatureRenderer *renderer)
+{
 }
 
 void DmpVectorLayer::setDataSource(const std::string &dataSource, const std::string &baseName, const std::string &provider, bool loadDefaultStyleFlag)
 {
-  DmpWkbTypes::GeometryType geomType = GeometryType();
+	DmpWkbTypes::GeometryType geomType = GeometryType();
 }
 
 DmpWkbTypes::GeometryType DmpVectorLayer::GeometryType() const
 {
-  return DmpWkbTypes::GeometryType(wkbType_);
+	return DmpWkbTypes::GeometryType(wkbType_);
 }
 
-bool DmpVectorLayer::setDataProvider(std::string const &provider)
+bool DmpVectorLayer::setDataProvider(const std::string &provider)
 {
-  //临时测试使用
-  PGconn* pPGconn = PQconnectdb(dataSource_.c_str());
+	if (provider.size() < 50)
+		return false;
+	isinit_ = true;
+	//临时测试使用
+	PGconn *pPGconn = PQconnectdb(provider.c_str());
 	ConnStatusType t = PQstatus(pPGconn);
 	if (t != CONNECTION_OK)
-			return false;
+		return false;
 	int re = PQsetClientEncoding(pPGconn, "UTF-8");
 
-  std::string sql = "select  t.f_geometry_column, t.type ,f_table_schema,t.srid from public.geometry_columns t where lower( t.f_table_name) = lower('" + name_ + "');";
-  PGresult* pPGresult= PQexec(pPGconn, sql.c_str());
+	std::string sql = "select  t.f_geometry_column, t.type ,f_table_schema,t.srid from public.geometry_columns t where lower( t.f_table_name) = lower('" + name_ + "');";
+	PGresult *pPGresult = PQexec(pPGconn, sql.c_str());
 	char *sz = PQerrorMessage(pPGconn);
-	if(sz != nullptr && strcmp(sz,"") !=0)
-  {
-    	PQfinish(pPGconn); return false;
-  } 
-
-  int	rowCount = PQntuples(pPGresult);
-  if(rowCount<1) 
-  {
-    	PQfinish(pPGconn); return false;
-  } 
-
-  geom_ =  PQgetvalue(pPGresult, 0, 0);
-  const char* geomtype =  PQgetvalue(pPGresult, 0, 1);
-  schema_ =  PQgetvalue(pPGresult, 0, 2);
-  //std::string srid = PQgetvalue(pPGresult, 0, 3);
-	
+	if (sz != nullptr && strcmp(sz, "") != 0)
+	{
+		PQfinish(pPGconn);
+		return false;
+	}
+
+	int rowCount = PQntuples(pPGresult);
+	if (rowCount < 1)
+	{
+		PQfinish(pPGconn);
+		return false;
+	}
+
+	geom_ = PQgetvalue(pPGresult, 0, 0);
+	const char *geomtype = PQgetvalue(pPGresult, 0, 1);
+	schema_ = PQgetvalue(pPGresult, 0, 2);
+	std::string srid = PQgetvalue(pPGresult, 0, 3);
+	wkbTypeString_ = geomtype;
+	srid_ = srid;
 	if (!geomtype)
 		return false;
-	if (!strcmp(geomtype, "POINT")) wkbType_ = DmpWkbTypes::Point;
-	else if (!strcmp(geomtype, "MULTIPOINT")) wkbType_ = DmpWkbTypes::MultiPoint;
-	else if (!strcmp(geomtype, "LINESTRING")) wkbType_ = DmpWkbTypes::LineString;
-	else if (!strcmp(geomtype, "MULTILINESTRING"))wkbType_ = DmpWkbTypes::MultiLineString;
-	else if (!strcmp(geomtype, "POLYGON")) wkbType_ = DmpWkbTypes::Polygon;
-	else if (!strcmp(geomtype, "MULTIPOLYGON")) wkbType_ = DmpWkbTypes::MultiPolygon;
-	else if (!strcmp(geomtype, "GEOMETRY")) wkbType_ = DmpWkbTypes::Unknown;
-  PQclear(pPGresult); pPGresult = NULL;
+	if (!strcmp(geomtype, "POINT"))
+		wkbType_ = DmpWkbTypes::Point;
+	else if (!strcmp(geomtype, "MULTIPOINT"))
+		wkbType_ = DmpWkbTypes::MultiPoint;
+	else if (!strcmp(geomtype, "LINESTRING"))
+		wkbType_ = DmpWkbTypes::LineString;
+	else if (!strcmp(geomtype, "MULTILINESTRING"))
+		wkbType_ = DmpWkbTypes::MultiLineString;
+	else if (!strcmp(geomtype, "POLYGON"))
+		wkbType_ = DmpWkbTypes::Polygon;
+	else if (!strcmp(geomtype, "MULTIPOLYGON"))
+		wkbType_ = DmpWkbTypes::MultiPolygon;
+	else if (!strcmp(geomtype, "GEOMETRY"))
+		wkbType_ = DmpWkbTypes::Unknown;
+	PQclear(pPGresult);
+	pPGresult = NULL;
 	PQfinish(pPGconn);
-  
-  return true;
-
-
-  providerKey_ = provider;
-  delete dataProvider_;
-  
-  dataProvider_ = dynamic_cast<DmpVectorDataProvider *>(DmpProviderRegistry::Instance(provider)->CreateProvider(provider, dataSource_));
-  if (!dataProvider_)
-  {
-    isValid_ = false;
-    return false;
-  }
-  isValid_ = dataProvider_->IsValid()
-  ;
-  if (!isValid_)
-  {
-    return false;
-  }
-  wkbType_ = dataProvider_->WkbType();
-  return true;
-}
 
-  shared_ptr<DmpVectorThinLayer> DmpVectorLayer::GetCurrentScaleTable(double dx)
+	return true;
+
+	providerKey_ = provider;
+	delete dataProvider_;
+
+	dataProvider_ = dynamic_cast<DmpVectorDataProvider *>(DmpProviderRegistry::Instance(provider)->CreateProvider(provider, dataSource_));
+	if (!dataProvider_)
+	{
+		isValid_ = false;
+		return false;
+	}
+	isValid_ = dataProvider_->IsValid();
+	if (!isValid_)
 	{
-	  
-/*
+		return false;
+	}
+	wkbType_ = dataProvider_->WkbType();
+	return true;
+}
+
+shared_ptr<DmpVectorThinLayer> DmpVectorLayer::GetCurrentScaleTable(double dx)
+{
+
+	/*
 		int outTime = 600;
 		if(this->dataCount >500000 && this->m_pDataset->m_MapLayerThinning.size() ==0)
 		{
@@ -197,14 +305,14 @@ bool DmpVectorLayer::setDataProvider(std::string const &provider)
 		}
 */
 
-		for(int i =0; i< this->thinLayers_.size(); i++)
-		{
-			shared_ptr<DmpVectorThinLayer> mapLayerThinning =  this->thinLayers_[i];
+	for (int i = 0; i < this->thinLayers_.size(); i++)
+	{
+		shared_ptr<DmpVectorThinLayer> mapLayerThinning = this->thinLayers_[i];
 
-			if(mapLayerThinning->IsCurrentLayer(dx))
-			{
-				return mapLayerThinning;
-			}
+		if (mapLayerThinning->IsCurrentLayer(dx))
+		{
+			return mapLayerThinning;
 		}
-		return nullptr;
-	}
\ No newline at end of file
+	}
+	return nullptr;
+}
\ No newline at end of file

@@ -44,6 +44,7 @@ class CORE_EXPORT DmpVectorLayer : public DmpMapLayer
     DmpMapLayerRenderer *createMapRenderer(DmpRenderContext &rendererContext);
     bool readXml(const boost::property_tree::ptree &layerNode);
     bool writeXml(boost::property_tree::ptree &layerNode);
+    bool writejson(std::string& json);
 
     DmpFeatureRenderer *renderer() { return renderer_; }
     void setRenderer(DmpFeatureRenderer *renderer);
@@ -59,7 +60,10 @@ class CORE_EXPORT DmpVectorLayer : public DmpMapLayer
     std::string  schema() { return schema_;}
     std::string  geom()  { return geom_;} 
     std::string  wherestr() { return wherestr_;} 
+    std::string  GeomTypeString(){return wkbTypeString_;}
+    std::string  srid(){return  srid_;}
     size_t featurecount(){return featurecount_;}
+    bool IsInit(){return isinit_;}
   private:
     bool readExtentFromXml_;
     DmpWkbTypes::Type wkbType_ = DmpWkbTypes::Unknown;
@@ -69,10 +73,15 @@ class CORE_EXPORT DmpVectorLayer : public DmpMapLayer
     std::string  schema_;
     std::string  geom_;
     size_t featurecount_;
+    std::string wkbTypeString_;
+    std::string srid_;
 
     std::string wherestr_;
+    bool isinit_ = false;
     shared_ptr<DmapCore_30::Renderer> renderer_30_ = nullptr;
     vector<shared_ptr<DmpVectorThinLayer>> thinLayers_;
+
+    
     
 };
 #endif //__dmpvectorlayer_h__

@@ -53,22 +53,34 @@ namespace DmapCore_30
 		for (auto ptchild = pt.begin(); ptchild != pt.end(); ++ptchild)
 			{
 				string sz = ptchild->first;
+				
 				if (boost::iequals(sz, "OTHER"))
 				{
-					//rapidxml::xml_node<char>* node2 = node1->first_node();
-					clsXML::XMLParse(ptchild->first,ptchild->second,  &m_pDefaultSymbol);
+					for(auto ptchild2 = ptchild->second.begin(); ptchild2 != ptchild->second.end(); ptchild2++)
+					{
+						if(ptchild2->first != "<xmlattr>")
+						{
+							clsXML::XMLParse(ptchild2->first,ptchild2->second,  &m_pDefaultSymbol);
+							break;
+						}
+					}
+					
 				}
 				else if (boost::iequals(sz, "EXACT")) 
 				{
 					string sValue = clsXML::XMLGetPropByString(ptchild->second, "value");
-
-					//rapidxml::xml_node<char>* node2 = node1->first_node();//exact 只有一个子节点 ,存着简单样
-					Renderer* pSymbol = NULL;
-					clsXML::XMLParse(ptchild->first, ptchild->second,  &pSymbol);
-
-					ValueMapRendererComponent* vmrc = new ValueMapRendererComponent(pSymbol, sValue);
-
-					m_vComponents.push_back(vmrc);//引用只需要一份, 无需AddRef
+					//auto ptchild2 = ptchild->second.begin();
+					for(auto ptchild2 = ptchild->second.begin(); ptchild2 != ptchild->second.end(); ptchild2++)
+					{
+						if (ptchild2->first != "<xmlattr>")
+						{
+							Renderer *pSymbol = NULL;
+							clsXML::XMLParse(ptchild2->first, ptchild2->second, &pSymbol);
+							ValueMapRendererComponent *vmrc = new ValueMapRendererComponent(pSymbol, sValue);
+							m_vComponents.push_back(vmrc); //引用只需要一份, 无需AddRef
+							break;
+						}
+					}
 				}
 				else{ ; }
 			}

@@ -587,6 +587,104 @@ namespace DmapCore_30
 			*bValue = false;
 	}
 
+	
+	void clsUtil::ToXMLString(std::string &s)
+	{
+		const char *str1 = s.c_str();
+		if (strstr(str1, "&"))
+		{
+			s = clsUtil::CharReplace(s, "&", "&");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "<"))
+		{
+			s = clsUtil::CharReplace(s, "<", "&lt;");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, ">"))
+		{
+			s = clsUtil::CharReplace(s, ">", "&gt;");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "\""))
+		{
+			s = clsUtil::CharReplace(s, "\"", "&quot;");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "\r"))
+		{
+			s = clsUtil::CharReplace(s, "\r", "");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "\n"))
+		{
+			s = clsUtil::CharReplace(s, "\n", "");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "'"))
+		{
+			s = clsUtil::CharReplace(s, "'", "&apos;");
+			//str1=s.c_str();
+		}
+		return;
+	}
+
+	void clsUtil::ToJSONString(std::string &s)
+	{
+		const char *str1 = s.c_str();
+		if (strstr(str1, "\\"))
+		{
+			s = clsUtil::CharReplace(s, "\\", "\\\\");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "/"))
+		{
+			s = clsUtil::CharReplace(s, "/", "\\/");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "\""))
+		{
+			s = clsUtil::CharReplace(s, "\"", "\\\"");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "\\r"))
+		{
+			s = clsUtil::CharReplace(s, "\\r", "");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "\\n"))
+		{
+			s = clsUtil::CharReplace(s, "\\n", "");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "\r"))
+		{
+			s = clsUtil::CharReplace(s, "\r", "");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "\n"))
+		{
+			s = clsUtil::CharReplace(s, "\n", "");
+			str1 = s.c_str();
+		}
+		if (strstr(str1, "\t"))
+		{
+			s = clsUtil::CharReplace(s, "'", "\\t");
+			//str1=s.c_str();
+		}
+		return;
+	}
+
+	string clsUtil::CharReplace(string strsrc, string strfind, string strrep)
+	{
+		 for(string::size_type   pos(0);   pos!=string::npos;   pos+=strrep.length())   {     
+            if(   (pos=strsrc.find(strfind,pos))!=string::npos   )     
+                strsrc.replace(pos,strfind.length(),strrep);     
+            else   break;     
+        }
+        return   strsrc;   
+	}
+
 	std::string  clsUtil::fmt(char* fmt, ...)
 	{
 		va_list argptr;

@@ -73,7 +73,11 @@ else { to[index]->Release(); to[index] = from; }\
 
 		static void GetFiles(string path, string exd, vector<string> & files);
 		static int  ParseStringTok(char * sz, char  toK, char ** szPtr, int maxPtr);
-		
+
+		static void ToJSONString(std::string &s);
+		static void ToXMLString(std::string &s);
+		static string CharReplace(string strsrc, string strfind, string strrep);
+
 		static std::string fmt(char *, ...);
 		static std::string fmt(const char*, ...);
 		static void ValueString(string * s, bool* bValue);

@@ -32,6 +32,7 @@ SET (DMAP_SERVER_SRCS
   dmpserverparameters.cpp
   dmpserverplugins.cpp
   dmpserverutils.cpp
+  dmpserverdes.cpp
   dmpserverloader.cpp
   dmpserverproject.cpp
   dmpserverregistry.cpp
@@ -39,7 +40,6 @@ SET (DMAP_SERVER_SRCS
   python/dmpserverwrapper.cpp
   dmphttpbase.cpp
   dmphttputils.cpp
- 
 )
 
 SET (DMAP_SERVER_HDRS
@@ -63,6 +63,7 @@ SET (DMAP_SERVER_HDRS
   dmpserverparameters.h
   dmpserverplugins.h
   dmpserverutils.h
+  dmpserverdes.h
   dmpservice.h
   dmpservermodule.h
   dmpserverloader.h
@@ -71,7 +72,6 @@ SET (DMAP_SERVER_HDRS
   python/dmppythonutils.h
   dmphttpbase.h
   dmphttputils.h
-  
 )
 
 #############################################################

@@ -49,7 +49,8 @@ public:
 		{
 			return;
 		}
-
+        
+		
 		DmpSpServerRequest dmpRequest(request);
 		DmpSpServerResponse dmpResponse(response);
 		pDmpServer->HandleRequest(dmpRequest, dmpResponse);

@@ -54,25 +54,25 @@ if (temp_data.find(http_) == 0) {
 int DmpHttp::DmpHttpBase::buildPostRequest(const std::string& server, const std::string& path,
 	std::ostream& out_request) {
 	// 分割path中的json数据
-	// std::string temp_path(path), temp_json;
-	// int json_pos_begin = temp_path.find(HTTP_JSON_BEGIN) + 1;
-	// int json_pos_end = temp_path.find(HTTP_JSON_END);
-	// if (json_pos_begin != std::string::npos) {
-	// 	// 计算json的长度
-	// 	int temp_json_lenth = std::string::npos;
-	// 	if (json_pos_end != temp_json_lenth) {
-	// 		temp_json_lenth = (json_pos_end - json_pos_begin); 
-	// 	}
-	// 	temp_json = temp_path.substr(json_pos_begin, temp_json_lenth);
-	// 	temp_path = temp_path.substr(0, (json_pos_begin - 1));
-	// }
-	// out_request << "POST " << temp_path.c_str() << " HTTP/1.0\r\n";
-	// out_request << "Host: " << server.c_str() << "\r\n"; 
-	// out_request << "Content-Length: " << temp_json.length() << "\r\n";
-	// out_request << "Content-Type: application/x-www-form-urlencoded\r\n";
-	// out_request << "Accept: */*\r\n";
-	// out_request << "Connection: close\r\n\r\n";
-	// out_request << temp_json.c_str();
+	std::string temp_path(path), temp_json;
+	int json_pos_begin = temp_path.find(HTTP_JSON_BEGIN) + 1;
+	int json_pos_end = temp_path.find(HTTP_JSON_END);
+	if (json_pos_begin != std::string::npos) {
+		// 计算json的长度
+		int temp_json_lenth = std::string::npos;
+		if (json_pos_end != temp_json_lenth) {
+			temp_json_lenth = (json_pos_end - json_pos_begin); 
+		}
+		temp_json = temp_path.substr(json_pos_begin, temp_json_lenth);
+		temp_path = temp_path.substr(0, (json_pos_begin - 1));
+	}
+	out_request << "POST " << temp_path.c_str() << " HTTP/1.0\r\n";
+	out_request << "Host: " << server.c_str() << "\r\n"; 
+	out_request << "Content-Length: " << temp_json.length() << "\r\n";
+	out_request << "Content-Type: application/x-www-form-urlencoded\r\n";
+	out_request << "Accept: */*\r\n";
+	out_request << "Connection: close\r\n\r\n";
+	out_request << temp_json.c_str();
 	return HTTP_SUCCESS;
 }
 

@@ -11,8 +11,8 @@
 #include <iostream>
 #include <boost/asio.hpp>
 namespace DmpHttp
-{
-    #define HTTP_SUCCESS            (0)          // 操作成功
+{ 
+    #define HTTP_SUCCESS       (0)          // 操作成功
     #define HTTP_ERROR_UNKNOWN      (-1)         // 未知的错误
     #define HTTP_ERROR_NETWORK      (-2)         // 网络连接失败
     #define HTTP_ERROR_HTTP_HEAD    (-3)         // 未找到协议头 http || https 
@@ -35,6 +35,7 @@ namespace DmpHttp
         virtual ~DmpHttpBase();  
 	    // Post请求
 	    virtual int post(const std::string& url) = 0;
+        virtual int post(const std::string& url, std::string& postData)= 0;
         // get请求
         virtual int get(const std::string& url) = 0;  
 	    virtual std::string getResponse(void) = 0;

@@ -18,6 +18,11 @@ int DmpHttp::DmpHttpUtils::post(const std::string& url)
 	handleRequestResolve(url, DmpHttpBase::buildPostRequest);
 	return HTTP_SUCCESS;
 }
+int DmpHttp::DmpHttpUtils::post(const std::string& url, std::string& postData)
+{
+	handleRequestResolve(url,postData, DmpHttpBase::buildPostRequest);
+	return HTTP_SUCCESS;
+}
 int DmpHttp::DmpHttpUtils::get(const std::string& url) 
 {
 	handleRequestResolve(url, DmpHttpBase::buildGetRequest);
@@ -47,6 +52,32 @@ void DmpHttp::DmpHttpUtils::handleRequestResolve(const std::string& url, pBuildR
 	}	
 	return;
 }
+void DmpHttp::DmpHttpUtils::handleRequestResolve(const std::string& url, std::string& postData,  pBuildRequest func) 
+{
+	try {
+		responseData_.clear();
+		// 解析URL
+		std::string server, port,path;
+		parseUrl(url, server, port, path);
+		path=postData;
+ 
+		std::ostream request_stream(&request_); 
+		// 合成请求
+		func(server, path, request_stream);
+ 
+		// 解析服务地址\端口
+		boost::asio::ip::tcp::resolver::query query(server, port);
+		resolver_.async_resolve(query,
+			boost::bind(&DmpHttpUtils::handleResolve, this,
+			boost::asio::placeholders::error,
+			boost::asio::placeholders::iterator));
+	}
+	catch (std::exception& e) {
+		socket_.close();
+		std::cout << "Exception: " << e.what() << "\n";
+	}	
+	return;
+}
 void DmpHttp::DmpHttpUtils::handleResolve(const boost::system::error_code& err,
 	boost::asio::ip::tcp::resolver::iterator endpoint_iterator) {
 	if (err) {
@@ -173,7 +204,14 @@ std::string DmpHttp::post(const std::string &url) {
 	io.run();
 	return c.getResponse();
 }
-
+std::string DmpHttp::post(const std::string& url, std::string& postData)
+{
+	boost::asio::io_service io;
+	DmpHttp::DmpHttpUtils c(io);
+	c.post(url,postData);
+	io.run();
+	return c.getResponse();
+}
 std::string DmpHttp::get(const std::string &url) {
 	boost::asio::io_service io;
 	DmpHttp::DmpHttpUtils c(io);

@@ -20,12 +20,14 @@ namespace DmpHttp
 		DmpHttpUtils(boost::asio::io_service& io_service);
 	    virtual ~DmpHttpUtils();
         virtual int post(const std::string& url);
+		virtual int post(const std::string& url, std::string& postData);
         virtual int get(const std::string& url);
 
         virtual std::string getResponse(void) {return responseData_;}
         private:
         // 建立请求
 	    void handleRequestResolve(const std::string& url, pBuildRequest func);
+		void handleRequestResolve(const std::string& url, std::string& path, pBuildRequest func);
 	    // 解析后
 	    void handleResolve(const boost::system::error_code& err,
 		    boost::asio::ip::tcp::resolver::iterator endpoint_iterator);
@@ -52,6 +54,7 @@ namespace DmpHttp
 	    std::string responseData_;
     };
     std::string post(const std::string &url);
+	std::string post(const std::string& url, std::string& postData);
     std::string get(const std::string &url);
 }
 

@@ -10,7 +10,7 @@
 #include <iostream>
 #include "dmpserverconfig.h"
 #include "dmpapplication.h"
-
+#include "dmphttputils.h"
 DmpServerConfig::DmpServerConfig()
 {
     std::string iniFile = DmpApplication::Instance()->libexecPath() + iniFileName_;
@@ -82,4 +82,14 @@ std::string DmpServerConfig::getValue(const std::string &section,const std::stri
         std::cerr << "Exception: " << e.what() << "\n";
     }
     return value;
+}
+
+std::string DmpServerConfig::HttpPost(const std::string& url, std::string& postData)
+{
+    return DmpHttp::post(url, postData);
+}
+
+std::string DmpServerConfig::HttpGet(const std::string& url)
+{
+    return DmpHttp::get(url);
 }
\ No newline at end of file

@@ -22,6 +22,9 @@ public:
     std::string getPqsqlConnect();
     std::string getMetaUrl();
     std::string getValue(const std::string &section,const std::string &key);
+
+    std::string HttpPost(const std::string& url, std::string& postData);
+    std::string HttpGet(const std::string& url);
 private:
     DmpServerConfig();
     boost::property_tree::ptree ptIni_;

+/**************************************************************************
+* file:              dmpserverdes.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-13 19:20:30
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpserverdes.h"
+#include "dmpserverutils.h"
+
+//std::string RsaBase64Encrypt(const std::string &source, const char* key)
+//{
+//}
+
+std::string DmpServerDes::DesBase64Decrypt(const std::string &source, const char* key)
+{
+  //  char key[] = "Chinadci";
+    char decry[1000] = {0};
+    std::string decbase64_source;
+    if(!DmpServerUtils::Base64Decode(source, &decbase64_source))
+    {
+        return "";
+    }
+    int size = decbase64_source.size();
+    for(; size>0; size--)
+    {
+        if(decbase64_source[size-1] != 0)break;
+    }
+    DmpServerDes rsa2048;
+    rsa2048.Decrypt((unsigned char *)decbase64_source.c_str(), size, (unsigned char *)key, (unsigned char *)decry);
+    for (size_t i = 0; i < strlen(decry) && i < 1000; i++)
+    {
+        if (decry[i] == '\b')
+        {
+            decry[i] = '\0';
+            break;
+        }
+    }
+    return decry;
+}
+
+
+void DmpServerDes::generate_key(unsigned char *key)
+{
+    int i;
+    for (i = 0; i < 8; i++)
+    {
+        key[i] = rand() % 255;
+    }
+}
+
+void DmpServerDes::generate_sub_keys(unsigned char *main_key, key_set *key_sets)
+{
+    int initial_key_permutaion[] = {57, 49, 41, 33, 25, 17, 9,
+                                    1, 58, 50, 42, 34, 26, 18,
+                                    10, 2, 59, 51, 43, 35, 27,
+                                    19, 11, 3, 60, 52, 44, 36,
+                                    63, 55, 47, 39, 31, 23, 15,
+                                    7, 62, 54, 46, 38, 30, 22,
+                                    14, 6, 61, 53, 45, 37, 29,
+                                    21, 13, 5, 28, 20, 12, 4};
+
+    int key_shift_sizes[] = {-1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1};
+
+    int sub_key_permutation[] = {14, 17, 11, 24, 1, 5,
+                                 3, 28, 15, 6, 21, 10,
+                                 23, 19, 12, 4, 26, 8,
+                                 16, 7, 27, 20, 13, 2,
+                                 41, 52, 31, 37, 47, 55,
+                                 30, 40, 51, 45, 33, 48,
+                                 44, 49, 39, 56, 34, 53,
+                                 46, 42, 50, 36, 29, 32};
+
+    int i, j;
+    int shift_size;
+    unsigned char shift_byte, first_shift_bits, second_shift_bits, third_shift_bits, fourth_shift_bits;
+
+    memset(key_sets, 0, sizeof(key_set) * 17);
+    for (i = 0; i < 8; i++)
+    {
+        key_sets[0].k[i] = 0;
+    }
+
+    for (i = 0; i < 56; i++)
+    {
+        shift_size = initial_key_permutaion[i];
+        shift_byte = 0x80 >> ((shift_size - 1) % 8);
+        shift_byte &= main_key[(shift_size - 1) / 8];
+        shift_byte <<= ((shift_size - 1) % 8);
+
+        key_sets[0].k[i / 8] |= (shift_byte >> i % 8);
+    }
+
+    for (i = 0; i < 3; i++)
+    {
+        key_sets[0].c[i] = key_sets[0].k[i];
+    }
+
+    key_sets[0].c[3] = key_sets[0].k[3] & 0xF0;
+
+    for (i = 0; i < 3; i++)
+    {
+        key_sets[0].d[i] = (key_sets[0].k[i + 3] & 0x0F) << 4;
+        key_sets[0].d[i] |= (key_sets[0].k[i + 4] & 0xF0) >> 4;
+    }
+
+    key_sets[0].d[3] = (key_sets[0].k[6] & 0x0F) << 4;
+
+    for (i = 1; i < 17; i++)
+    {
+        for (j = 0; j < 4; j++)
+        {
+            key_sets[i].c[j] = key_sets[i - 1].c[j];
+            key_sets[i].d[j] = key_sets[i - 1].d[j];
+        }
+
+        shift_size = key_shift_sizes[i];
+        if (shift_size == 1)
+        {
+            shift_byte = 0x80;
+        }
+        else
+        {
+            shift_byte = 0xC0;
+        }
+
+        // Process C
+        first_shift_bits = shift_byte & key_sets[i].c[0];
+        second_shift_bits = shift_byte & key_sets[i].c[1];
+        third_shift_bits = shift_byte & key_sets[i].c[2];
+        fourth_shift_bits = shift_byte & key_sets[i].c[3];
+
+        key_sets[i].c[0] <<= shift_size;
+        key_sets[i].c[0] |= (second_shift_bits >> (8 - shift_size));
+
+        key_sets[i].c[1] <<= shift_size;
+        key_sets[i].c[1] |= (third_shift_bits >> (8 - shift_size));
+
+        key_sets[i].c[2] <<= shift_size;
+        key_sets[i].c[2] |= (fourth_shift_bits >> (8 - shift_size));
+
+        key_sets[i].c[3] <<= shift_size;
+        key_sets[i].c[3] |= (first_shift_bits >> (4 - shift_size));
+
+        // Process D
+        first_shift_bits = shift_byte & key_sets[i].d[0];
+        second_shift_bits = shift_byte & key_sets[i].d[1];
+        third_shift_bits = shift_byte & key_sets[i].d[2];
+        fourth_shift_bits = shift_byte & key_sets[i].d[3];
+
+        key_sets[i].d[0] <<= shift_size;
+        key_sets[i].d[0] |= (second_shift_bits >> (8 - shift_size));
+
+        key_sets[i].d[1] <<= shift_size;
+        key_sets[i].d[1] |= (third_shift_bits >> (8 - shift_size));
+
+        key_sets[i].d[2] <<= shift_size;
+        key_sets[i].d[2] |= (fourth_shift_bits >> (8 - shift_size));
+
+        key_sets[i].d[3] <<= shift_size;
+        key_sets[i].d[3] |= (first_shift_bits >> (4 - shift_size));
+
+        for (j = 0; j < 48; j++)
+        {
+            shift_size = sub_key_permutation[j];
+            if (shift_size <= 28)
+            {
+                shift_byte = 0x80 >> ((shift_size - 1) % 8);
+                shift_byte &= key_sets[i].c[(shift_size - 1) / 8];
+                shift_byte <<= ((shift_size - 1) % 8);
+            }
+            else
+            {
+                shift_byte = 0x80 >> ((shift_size - 29) % 8);
+                shift_byte &= key_sets[i].d[(shift_size - 29) / 8];
+                shift_byte <<= ((shift_size - 29) % 8);
+            }
+
+            key_sets[i].k[j / 8] |= (shift_byte >> j % 8);
+        }
+    }
+}
+
+void DmpServerDes::process_message(unsigned char *message_piece, unsigned char *processed_piece, key_set *key_sets, int mode)
+{
+
+    int initial_message_permutation[] = {58, 50, 42, 34, 26, 18, 10, 2,
+                                         60, 52, 44, 36, 28, 20, 12, 4,
+                                         62, 54, 46, 38, 30, 22, 14, 6,
+                                         64, 56, 48, 40, 32, 24, 16, 8,
+                                         57, 49, 41, 33, 25, 17, 9, 1,
+                                         59, 51, 43, 35, 27, 19, 11, 3,
+                                         61, 53, 45, 37, 29, 21, 13, 5,
+                                         63, 55, 47, 39, 31, 23, 15, 7};
+
+    int message_expansion[] = {32, 1, 2, 3, 4, 5,
+                               4, 5, 6, 7, 8, 9,
+                               8, 9, 10, 11, 12, 13,
+                               12, 13, 14, 15, 16, 17,
+                               16, 17, 18, 19, 20, 21,
+                               20, 21, 22, 23, 24, 25,
+                               24, 25, 26, 27, 28, 29,
+                               28, 29, 30, 31, 32, 1};
+    int S1[] = {14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
+                0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
+                4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
+                15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13};
+
+    int S2[] = {15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
+                3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
+                0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
+                13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9};
+
+    int S3[] = {10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
+                13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
+                13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
+                1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12};
+
+    int S4[] = {7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
+                13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
+                10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
+                3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14};
+
+    int S5[] = {2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
+                14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
+                4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
+                11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3};
+
+    int S6[] = {12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
+                10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
+                9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
+                4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13};
+
+    int S7[] = {4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
+                13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
+                1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
+                6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12};
+
+    int S8[] = {13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
+                1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
+                7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
+                2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11};
+
+    int right_sub_message_permutation[] = {16, 7, 20, 21,
+                                           29, 12, 28, 17,
+                                           1, 15, 23, 26,
+                                           5, 18, 31, 10,
+                                           2, 8, 24, 14,
+                                           32, 27, 3, 9,
+                                           19, 13, 30, 6,
+                                           22, 11, 4, 25};
+    int final_message_permutation[] = {40, 8, 48, 16, 56, 24, 64, 32,
+                                       39, 7, 47, 15, 55, 23, 63, 31,
+                                       38, 6, 46, 14, 54, 22, 62, 30,
+                                       37, 5, 45, 13, 53, 21, 61, 29,
+                                       36, 4, 44, 12, 52, 20, 60, 28,
+                                       35, 3, 43, 11, 51, 19, 59, 27,
+                                       34, 2, 42, 10, 50, 18, 58, 26,
+                                       33, 1, 41, 9, 49, 17, 57, 25};
+    int i, k;
+    int shift_size;
+    unsigned char shift_byte;
+
+    unsigned char initial_permutation[8];
+    memset(initial_permutation, 0, 8);
+    memset(processed_piece, 0, 8);
+
+    for (i = 0; i < 64; i++)
+    {
+        shift_size = initial_message_permutation[i];
+        shift_byte = 0x80 >> ((shift_size - 1) % 8);
+        shift_byte &= message_piece[(shift_size - 1) / 8];
+        shift_byte <<= ((shift_size - 1) % 8);
+
+        initial_permutation[i / 8] |= (shift_byte >> i % 8);
+    }
+
+    unsigned char l[4], r[4];
+    for (i = 0; i < 4; i++)
+    {
+        l[i] = initial_permutation[i];
+        r[i] = initial_permutation[i + 4];
+    }
+
+    unsigned char ln[4], rn[4], er[6], ser[4];
+
+    int key_index;
+    for (k = 1; k <= 16; k++)
+    {
+        memcpy(ln, r, 4);
+
+        memset(er, 0, 6);
+
+        for (i = 0; i < 48; i++)
+        {
+            shift_size = message_expansion[i];
+            shift_byte = 0x80 >> ((shift_size - 1) % 8);
+            shift_byte &= r[(shift_size - 1) / 8];
+            shift_byte <<= ((shift_size - 1) % 8);
+
+            er[i / 8] |= (shift_byte >> i % 8);
+        }
+
+        if (mode == DECRYPTION_MODE)
+        {
+            key_index = 17 - k;
+        }
+        else
+        {
+            key_index = k;
+        }
+
+        for (i = 0; i < 6; i++)
+        {
+            er[i] ^= key_sets[key_index].k[i];
+        }
+
+        unsigned char row, column;
+
+        for (i = 0; i < 4; i++)
+        {
+            ser[i] = 0;
+        }
+
+        // 0000 0000 0000 0000 0000 0000
+        // rccc crrc cccr rccc crrc cccr
+
+        // Byte 1
+        row = 0;
+        row |= ((er[0] & 0x80) >> 6);
+        row |= ((er[0] & 0x04) >> 2);
+
+        column = 0;
+        column |= ((er[0] & 0x78) >> 3);
+
+        ser[0] |= ((unsigned char)S1[row * 16 + column] << 4);
+
+        row = 0;
+        row |= (er[0] & 0x02);
+        row |= ((er[1] & 0x10) >> 4);
+
+        column = 0;
+        column |= ((er[0] & 0x01) << 3);
+        column |= ((er[1] & 0xE0) >> 5);
+
+        ser[0] |= (unsigned char)S2[row * 16 + column];
+
+        // Byte 2
+        row = 0;
+        row |= ((er[1] & 0x08) >> 2);
+        row |= ((er[2] & 0x40) >> 6);
+
+        column = 0;
+        column |= ((er[1] & 0x07) << 1);
+        column |= ((er[2] & 0x80) >> 7);
+
+        ser[1] |= ((unsigned char)S3[row * 16 + column] << 4);
+
+        row = 0;
+        row |= ((er[2] & 0x20) >> 4);
+        row |= (er[2] & 0x01);
+
+        column = 0;
+        column |= ((er[2] & 0x1E) >> 1);
+
+        ser[1] |= (unsigned char)S4[row * 16 + column];
+
+        // Byte 3
+        row = 0;
+        row |= ((er[3] & 0x80) >> 6);
+        row |= ((er[3] & 0x04) >> 2);
+
+        column = 0;
+        column |= ((er[3] & 0x78) >> 3);
+
+        ser[2] |= ((unsigned char)S5[row * 16 + column] << 4);
+
+        row = 0;
+        row |= (er[3] & 0x02);
+        row |= ((er[4] & 0x10) >> 4);
+
+        column = 0;
+        column |= ((er[3] & 0x01) << 3);
+        column |= ((er[4] & 0xE0) >> 5);
+
+        ser[2] |= (unsigned char)S6[row * 16 + column];
+
+        // Byte 4
+        row = 0;
+        row |= ((er[4] & 0x08) >> 2);
+        row |= ((er[5] & 0x40) >> 6);
+
+        column = 0;
+        column |= ((er[4] & 0x07) << 1);
+        column |= ((er[5] & 0x80) >> 7);
+
+        ser[3] |= ((unsigned char)S7[row * 16 + column] << 4);
+
+        row = 0;
+        row |= ((er[5] & 0x20) >> 4);
+        row |= (er[5] & 0x01);
+
+        column = 0;
+        column |= ((er[5] & 0x1E) >> 1);
+
+        ser[3] |= (unsigned char)S8[row * 16 + column];
+
+        for (i = 0; i < 4; i++)
+        {
+            rn[i] = 0;
+        }
+
+        for (i = 0; i < 32; i++)
+        {
+            shift_size = right_sub_message_permutation[i];
+            shift_byte = 0x80 >> ((shift_size - 1) % 8);
+            shift_byte &= ser[(shift_size - 1) / 8];
+            shift_byte <<= ((shift_size - 1) % 8);
+
+            rn[i / 8] |= (shift_byte >> i % 8);
+        }
+
+        for (i = 0; i < 4; i++)
+        {
+            rn[i] ^= l[i];
+        }
+
+        for (i = 0; i < 4; i++)
+        {
+            l[i] = ln[i];
+            r[i] = rn[i];
+        }
+    }
+
+    unsigned char pre_end_permutation[8];
+    for (i = 0; i < 4; i++)
+    {
+        pre_end_permutation[i] = r[i];
+        pre_end_permutation[4 + i] = l[i];
+    }
+
+    for (i = 0; i < 64; i++)
+    {
+        shift_size = final_message_permutation[i];
+        shift_byte = 0x80 >> ((shift_size - 1) % 8);
+        shift_byte &= pre_end_permutation[(shift_size - 1) / 8];
+        shift_byte <<= ((shift_size - 1) % 8);
+
+        processed_piece[i / 8] |= (shift_byte >> i % 8);
+    }
+}
+
+void DmpServerDes::copyUChar(unsigned char *data_block, unsigned char *source, int loc, int num)
+{
+    int i;
+    for (i = 0; i < num; i++)
+    {
+        data_block[i] = source[loc + i];
+    }
+}
+
+bool DmpServerDes::Encrypt(unsigned char *source, unsigned char *des_key, unsigned char *destination)
+{
+
+    // Generate DES key set*******************************************
+    int padding;
+    int block_count = 0, number_of_blocks;
+
+    unsigned char data_block[8];
+    unsigned char processed_block[8];
+    key_set *key_sets = (key_set *)malloc(17 * sizeof(key_set));
+
+    generate_sub_keys(des_key, key_sets);
+    // Generate DES key set*******************************************
+
+    int length = strlen((const char *)source);
+    number_of_blocks = length / 8 + ((length % 8) ? 1 : 0);
+
+    // Start read source word, encrypt to destination
+    for (int i = 0; i < length; i += 8)
+    {
+
+        block_count++;
+
+        if (block_count == number_of_blocks)
+        {
+            padding = 8 - length % 8;
+
+            copyUChar(data_block, source, i, 8 - padding);
+            if (padding < 8)
+            { // Fill empty data block bytes with padding
+                memset((data_block + 8 - padding), (unsigned char)padding, padding);
+            }
+            else if (padding == 8)
+            { // Write an extra block for padding
+                copyUChar(data_block, source, i, 8);
+            }
+        }
+        else
+        {
+            copyUChar(data_block, source, i, 8);
+        }
+
+        process_message(data_block, processed_block, key_sets, ENCRYPTION_MODE);
+        memcpy(destination + i, &processed_block, 8 * sizeof(char));
+
+        memset(data_block, 0, 8);
+    }
+
+    // Free up memory
+    free(key_sets);
+
+    return true;
+}
+
+bool DmpServerDes::Decrypt(unsigned char *source, int length, unsigned char *key, unsigned char *destination)
+{
+
+    // Generate DES key set*******************************************
+    int padding;
+    int block_count = 0, number_of_blocks;
+
+    unsigned char data_block[8];
+    unsigned char processed_block[8];
+    key_set *key_sets = (key_set *)malloc(17 * sizeof(key_set));
+
+    generate_sub_keys(key, key_sets);
+    // Generate DES key set*******************************************
+
+    //int length = strlen((const char*)source);
+    number_of_blocks = length / 8 + ((length % 8) ? 1 : 0);
+
+    // Start read source word
+    for (int i = 0; i < length; i += 8)
+    {
+
+        block_count++;
+
+        if (block_count == number_of_blocks)
+        {
+            copyUChar(data_block, source, i, 8);
+            process_message(data_block, processed_block, key_sets, DECRYPTION_MODE);
+            padding = processed_block[7];
+
+            if (padding < 8)
+            {
+                memcpy(destination + i, &processed_block, (8 - padding) * sizeof(char));
+            }
+            else
+            {
+                memcpy(destination + i, &processed_block, 8 * sizeof(char));
+            }
+        }
+        else
+        {
+            copyUChar(data_block, source, i, 8);
+            process_message(data_block, processed_block, key_sets, DECRYPTION_MODE);
+            memcpy(destination + i, &processed_block, 8 * sizeof(char));
+        }
+
+        memset(data_block, 0, 8);
+    }
+
+    // Free up memory
+    free(key_sets);
+
+    return true;
+}

+/**************************************************************************
+* file:              dmpserverdes.h
+
+* Author:            qingxiongf
+* Date:              2022-01-13 19:20:26
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpserverdes_h__
+#define __dmpserverdes_h__
+#include "dmap_server.h"
+#include <boost/filesystem.hpp>
+#include <unordered_map>
+
+#define ENCRYPTION_MODE 1
+#define DECRYPTION_MODE 0
+
+class SERVER_EXPORT DmpServerDes
+{
+public:
+    typedef struct
+    {
+        unsigned char k[8];
+        unsigned char c[4];
+        unsigned char d[4];
+    } key_set;
+
+    bool Encrypt(unsigned char *source, unsigned char *des_key, unsigned char *destination);
+    bool Decrypt(unsigned char *source, int length, unsigned char *key, unsigned char *destination);
+
+   // static std::string RsaBase64Encrypt(const std::string &source, const char* key);
+    static std::string DesBase64Decrypt(const std::string &source, const char* key);
+
+private:
+    void generate_key(unsigned char *key);
+    void generate_sub_keys(unsigned char *main_key, key_set *key_sets);
+    void process_message(unsigned char *message_piece, unsigned char *processed_piece, key_set *key_sets, int mode);
+    void copyUChar(unsigned char *data_block, unsigned char *source, int loc, int num);
+};
+
+#endif // __dmpserverdes_h__

@@ -9,7 +9,7 @@
 #include "dmpservermanager.h"
 #include "dmpserver.h"
 #include "dmphttputils.h"
-#include "dmpserverConfig.h"
+#include "dmpserverconfig.h"
 #include <memory>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/json_parser.hpp>

@@ -20,7 +20,7 @@
 #include "dmpserverregistry.h"
 
 
-#define URI_RELOAD    ("/API/Service/TileService/Reload")       //加载已注册服务接口     
+#define URI_RELOAD    ("/API/Service/Reload")       //加载已注册服务接口     
 class SERVER_EXPORT DmpServerManager
 {
 public:

@@ -16,6 +16,8 @@
 // #include <boost/algorithm/string.hpp>
 #include "dmplogger.h"
 
+
+
 DmpServerRequest::DmpServerRequest()
 { 
   isRestful_ = false;

@@ -39,19 +39,21 @@ DmpSpServerRequest::DmpSpServerRequest(SP_HttpRequest* request)
     }
     
     //获取querystring
-    std::string url(request->getURL());
-    //std::string  deurl=Percent::decode( url);
-    std::string::size_type pos = url.find("?");
+    std::string url(request->getURL());   
+    std::string deurl;
+    this->UrlDecode(url,deurl);
+
+    std::string::size_type pos = deurl.find("?");
     if (pos != std::string::npos) {
-        std::string path = url.substr(0, pos);
+        std::string path = deurl.substr(0, pos);
         setPath(path);
         std::string queryString;
-        queryString = url.substr(pos+1,url.length());
+        queryString = deurl.substr(pos+1,deurl.length());
         setQuery(queryString);
     }
     else {
         isRestful_ = true;
-        setPath(url);
+        setPath(deurl);
     }
     
     // for(int i=0; i< request->getParamCount(); i++) {
@@ -71,4 +73,50 @@ const void * DmpSpServerRequest::GetData() const
 int DmpSpServerRequest::GetDataLength() const
 {
    return dataLen_;
+}
+bool DmpSpServerRequest::UrlDecode(const std::string& src, std::string& dst)
+{
+	if(src.size() == 0)
+		return false;
+	int hex = 0;
+	for (size_t i = 0; i < src.length(); ++i)
+	{
+		switch (src[i])
+		{
+			case '+':
+				dst += ' ';
+				break;
+			case '%':
+				{
+					if (isxdigit(src[i + 1]) && isxdigit(src[i + 2]))
+					{
+						std::string hexStr = src.substr(i + 1, 2);
+						hex = strtol(hexStr.c_str(), 0, 16);
+						//字母和数字[0-9a-zA-Z]、一些特殊符号[$-_.+!*'(),] 、以及某些保留字[$&+,/:;=?@]
+						//可以不经过编码直接用于URL
+						if (!((hex >= 48 && hex <= 57) || //0-9
+						(hex >=97 && hex <= 122) ||   //a-z
+						(hex >=65 && hex <= 90) ||    //A-Z
+						//一些特殊符号及保留字[$-_.+!*'(),]  [$&+,/:;=?@]
+						hex == 0x21 || hex == 0x24 || hex == 0x26 || hex == 0x27 || hex == 0x28 || hex == 0x29
+						|| hex == 0x2a || hex == 0x2b|| hex == 0x2c || hex == 0x2d || hex == 0x2e || hex == 0x2f
+						|| hex == 0x3A || hex == 0x3B|| hex == 0x3D || hex == 0x3f || hex == 0x40 || hex == 0x5f
+						))
+						{
+							dst += char(hex);
+							i += 2;
+						}
+						else
+							dst += '%';
+					}
+					else
+						dst += '%';
+				}
+				break;
+			default:
+				dst += src[i];
+				break;
+		}
+	}
+	return true;
 }
\ No newline at end of file

@@ -23,6 +23,7 @@ public:
     DmpSpServerRequest(SP_HttpRequest* request);
     const void * GetData() const override;
 	int GetDataLength() const override;
+    bool UrlDecode(const std::string& src, std::string& dst);
 private:
     const void* data_;
     int dataLen_;

@@ -130,16 +130,16 @@ void DmpManagerApiHandler::regService(const DmpServerApiContext &context) const
                             break;
                         } 
                     
-                    default:
+                    default: 
                         break;
                     }
                     
-                    context.response()->write("{\"status\":\""+std::to_string(flag)+"\",\"url\":\""+url+"\",\"message\":\"Pulish service successful!\"}");
                     // std::string projData;
                     // DmpServerUtils::Base64Decode(project, &projData);
-                    // context.response()->removeHeader("Content-Type");
-                    // context.response()->setHeader("Content-Type", "text/xml;charset=utf-8");
-                    // context.response()->write(projData);
+                     context.response()->removeHeader("Content-Type");
+                     context.response()->setHeader("Content-Type", "text/xml;charset=utf-8");
+                    // context.response()->write(projData); 
+                     context.response()->write("{\"status\":\""+std::to_string(flag)+"\",\"url\":\""+url+"\",\"message\":\"Pulish service successful!\"}");                   
                 }
                 else
                 {
@@ -312,6 +312,12 @@ void DmpManagerApiHandler::GetTileServiceInfo(const DmpServerApiContext &context
                     path= pt.get<std::string>("projectlayers.maplayer.datasource");
                     confcdipath=path+"/conf.cdi";
                     confxmlpath=path+"/conf.xml";
+                    std::ifstream fread(confxmlpath, std::ifstream::binary);
+                    if(!fread)
+                    {
+                        context.response()->write("{\"status\":\"false\",\"message\":\"获取切片配置信息失败\"}");
+                        return;
+                    }
                     //读取切片配置文件conf.cdi
                     boost::property_tree::ptree pt_confcdi;                    
                     boost::property_tree::read_xml(confcdipath,pt_confcdi);  
@@ -334,6 +340,8 @@ void DmpManagerApiHandler::GetTileServiceInfo(const DmpServerApiContext &context
                     std::string tileCols=pt_confxml.get<std::string>("CacheInfo.TileCacheInfo.TileCols");
                     std::string tileRows=pt_confxml.get<std::string>("CacheInfo.TileCacheInfo.TileRows");
                     std::string dpi=pt_confxml.get<std::string>("CacheInfo.TileCacheInfo.DPI");
+                    std::string storageFormat=pt_confxml.get<std::string>("CacheInfo.CacheStorageInfo.StorageFormat");
+                    pt.put("vendor",storageFormat);
                     pt.put("projectCrs.spatialrefsys.wkt",strWKT);
                     pt.put("projectCrs.spatialrefsys.srid",wkid);
                     

@@ -9,18 +9,23 @@ SET (MAPSERVER_SRCS
   dmppgsqlpool.cpp
   dmppgsqlsourcepools.cpp
   wfs/dmpwfs.cpp
+  wfs/dmpwfsfilter.cpp
+  wfs/dmpgmlfilter.cpp
   wfs/dmpwfsgetcapabilities.cpp
   wfs/dmpwfsgetfeature.cpp
   wfs/dmpwfsparameters.cpp
+  wfs/dmpsqlfactory.cpp
   wms/dmpwmsrenderer.cpp
   wms/dmpwms.cpp
   wms/dmpwmsparameters.cpp
   wms/dmpwmsgetcapabilities.cpp
   wms/dmpwmsgetmap.cpp
+  wms/dmpwmsserviceinfo.cpp
   wms/dmpwmsgetfeatureinfo.cpp
   mapping/dmpmapping.cpp
   mapping/dmpeditservice.cpp
   mapping/dmpmappingparameters.cpp
+  mapping/dmpimageinfo.cpp
 )
 
 SET (MAPSERVER_HDRS
@@ -30,18 +35,23 @@ SET (MAPSERVER_HDRS
   dmppgsqlpool.h
   dmppgsqlsourcepools.h
   wfs/dmpwfs.h
+  wfs/dmpwfsfilter.h
+  wfs/dmpgmlfilter.h
   wfs/dmpwfsgetcapabilities.h
   wfs/dmpwfsgetfeature.h
   wfs/dmpwfsparameters.h
+  wfs/dmpsqlfactory.h
   wms/dmpwmsrenderer.h
   wms/dmpwms.h
   wms/dmpwmsparameters.h
   wms/dmpwmsgetcapabilities.h
   wms/dmpwmsgetmap.h
+  wms/dmpwmsserviceinfo.h
   wms/dmpwmsgetfeatureinfo.h
   mapping/dmpmapping.h
   mapping/dmpeditservice.h
   mapping/dmpmappingparameters.h
+  mapping/dmpimageinfo.h
 )
 
 ########################################################

@@ -34,7 +34,8 @@ public:
     ~DmpMapServer();
     std::string name() const override { return std::string("MapServer");}
     std::string alias() const override { return std::string("矢量地图服务");}
-    std::string path() const override { return std::string("^/DMap/Services/?([\\w./]*)/MapServer/([\\w]+)"); }
+    //std::string path() const override { return std::string("^/DMap/Services/?([\\w./]*)/MapServer/([\\w]+)"); }
+    std::string path() const override { return std::string("^/DMap/Services/?([\\w\\W./]*)/MapServer/([\\w]+)"); }
     std::string capability() const override;
     void executeRequest(DmpServerRequest &request, DmpServerResponse &response) override;
     bool publish(const std::string &serviceName, const std::string &title, unsigned int capability, const DmpProject &project) override;

@@ -7,11 +7,109 @@
 * copyright:         广州城市信息研究所有限公司
 ***************************************************************************/
 #include "dmpmapserverutil.h"
-#include <string.h>
+#include <iostream>
+#include <istream>
+#include <ostream>
+#include <string>
+#include <boost/asio.hpp>
+
+
+using boost::asio::ip::tcp;
 
 namespace mapserver
 { 
 
+void DmpMapServerUtil::responseGml(shared_ptr<DmpPgsql> pPgsqlConn, std::string &responseData,const string& layerName,const std::string &srid)
+{
+	
+//	rs->PrepareFieldhead(); //获得了结果集的字段类型
+	int shapeType = -1;
+
+	double xg1, yg1, xg2, yg2;
+	int havegSet = 0;
+	int count = 0;
+	int pointCountTemp = 0;
+	 char buff[5000] = {0};
+
+	responseData.append("<?xml version=\"1.0\" encoding=\"utf-8\" ?><wfs:FeatureCollection ");
+	responseData.append("xmlns:gims=\"http://www.esri.com/esri\" xmlns:gml=\"http://www.opengis.net/gml\" xmlns:wfs=\"http://www.opengis.net/wfs\" xmlns:ogc=\"http://www.opengis.net/ogc\">");
+
+   	
+	//bool paff = parseString.affine;
+	try
+	{
+		int fieldsCount = pPgsqlConn->GetFieldCount();
+		for (; pPgsqlConn->next();)
+		{
+			//	css++;
+			//if(css!=24)continue;
+			//break;
+			//string geometry = "";
+			//string properties = "";
+			responseData.append("<gims:featureMember>");
+			sprintf(buff, "<gims:%s fid=\"%s.%d\">", layerName.c_str(), layerName.c_str(), count + 1);
+			responseData.append(buff);
+			//responseData.append("\r\n");
+
+			//columns[md[ i ].getString(MetaData::ATTR_NAME)] = i;
+			for (int i = 0; i < fieldsCount; i++)
+			{
+				const char *sfieldName = pPgsqlConn->GetFieldName(i); //pPgsqlConn->field_name[i].c_str();
+				if (sfieldName == 0)
+				{
+					break;
+				}
+				if (strncmp(sfieldName, "RN_RN", 5) == 0)
+					continue;
+				std::string strFieldName = sfieldName;
+				//DmapDll::StringHelp::ToXMLString(strFieldName);
+			
+				if (strFieldName == "geometry_as_gml")
+				{
+					const char* value = pPgsqlConn->getString(i);
+					if(value) 
+					   responseData.append(value);
+					continue;
+				}
+				else
+				{
+					const char *v =  pPgsqlConn->getString(i);
+					sprintf(buff, "<gims:%s>%s</gims:%s>",  strFieldName.c_str(), v, strFieldName.c_str());
+					//properties += buff;
+					 responseData.append(buff);
+				}
+			
+			}
+			//tickAA=GetTickCount();
+
+			sprintf(buff, "</gims:%s>\r",layerName.c_str());
+			responseData.append(buff);
+			responseData.append("</gims:featureMember>");
+
+			count++;
+			//if(pointCount>25)break;
+
+			if (pointCountTemp > 2000)
+				break;
+			//Sleep(5000);
+			//	break;
+		}
+	}
+	catch (...)
+	{
+		
+	}
+
+	//sprintf(buff, "numberMatched=\"%ld\" numberReturned=\"%ld\" ", count, count);
+	//responseData.append(insertBuf, sql, strlen(sql));
+
+	
+
+	responseData.append("</wfs:FeatureCollection>");
+
+	return;
+}
+
     //以GeoJson的形式返回
 void DmpMapServerUtil::responseGeojson(shared_ptr<DmpPgsql> pPgsqlConn, std::string &responseData,const string& layerName,const string& srid)
 {
@@ -28,10 +126,10 @@ void DmpMapServerUtil::responseGeojson(shared_ptr<DmpPgsql> pPgsqlConn, std::str
 		int fieldsCount = pPgsqlConn->GetFieldCount();
 		for (int featureIndex = 0; pPgsqlConn->next(); featureIndex++)
 		{
-			
 			if (featureIndex > 0)
 				responseData.append(",");
-			//ab->AppendString(R"({"type":"Feature")");
+			
+			responseData.append(R"({"type":"Feature")");
 
 			string geometry = "";
 			string properties = "";
@@ -43,6 +141,7 @@ void DmpMapServerUtil::responseGeojson(shared_ptr<DmpPgsql> pPgsqlConn, std::str
 				{
 					break;
 				}
+			
 
 				if (strncmp(sfieldName, "RN_RN", 5) == 0)
 					continue;
@@ -148,4 +247,184 @@ void DmpMapServerUtil::responseGeojson(shared_ptr<DmpPgsql> pPgsqlConn, std::str
         }
         return   strsrc;   
     }
+
+
+
+	std::vector<std::string> DmpMapServerUtil::stringSplit(const std::string &str, const std::string &pattern) 
+	{
+		vector<std::string> stringList;
+		std::string subStr;
+		std::string tPattern;
+		size_t patternLen = pattern.length();
+		for (size_t i = 0; i < str.length(); i++)
+		{
+			if(pattern[0] == str[i])
+			{
+				tPattern = str.substr(i, patternLen);
+				if(tPattern == pattern)
+				{
+					i += patternLen -1;
+					if(!subStr.empty())
+					{
+                        stringList.push_back(subStr);
+						subStr.clear();
+					}
+				}
+				else
+				{
+					subStr.push_back(str[i]);
+				}
+			}
+			else
+			{
+				subStr.push_back(str[i]);
+			}
+		}
+
+		if(!subStr.empty())
+		{
+			stringList.push_back(subStr);
+		}
+		return stringList;
+		
+	}
+
+
+	int DmpMapServerUtil::HttpPost(const std::string& url, std::string& postData, std::string &reponse_data)
+	{
+        string host, port,path;
+		const std::string &http_ = "http://";
+		const std::string &https_ = "https://";
+		std::string temp_data = url;
+		if (temp_data.find(http_) == 0)
+		{
+			temp_data = temp_data.substr(http_.length());
+		}
+		else if (temp_data.find(https_) == 0)
+		{
+			temp_data = temp_data.substr(https_.length());
+		}
+		else
+		{
+			return 500;
+		}
+		// 解析域名
+		std::size_t idx = temp_data.find('/');
+		// 解析 域名后的page
+		if (std::string::npos == idx)
+		{
+			path = "/";
+			idx = temp_data.size();
+		}
+		else
+		{
+			path = temp_data.substr(idx);
+		}
+		// 解析域名
+		host = temp_data.substr(0, idx);
+		// 解析端口
+		idx = host.find(':');
+		if (std::string::npos == idx)
+		{
+			port = "80";
+		}
+		else
+		{
+			port = host.substr(idx + 1);
+			host = host.substr(0, idx);
+		}
+
+
+		try
+		{
+			boost::asio::io_service io_service;
+			//如果io_service存在复用的情况
+			if (io_service.stopped())
+				io_service.reset();
+
+			// 从dns取得域名下的所有ip
+			tcp::resolver resolver(io_service);
+			tcp::resolver::query query(host, port);
+			tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
+
+			// 尝试连接到其中的某个ip直到成功
+			tcp::socket socket(io_service);
+			boost::asio::connect(socket, endpoint_iterator);
+
+			// Form the request. We specify the "Connection: close" header so that the
+			// server will close the socket after transmitting the response. This will
+			// allow us to treat all data up until the EOF as the content.
+			boost::asio::streambuf request;
+			std::ostream request_stream(&request);
+			request_stream << "POST " << path.c_str() << " HTTP/1.0\r\n";
+			request_stream << "Host: " << host << ":" << port << "\r\n";
+			request_stream << "Accept: */*\r\n";
+			request_stream << "Content-Length: " << postData.length() << "\r\n";
+			request_stream << "Content-Type: application/x-www-form-urlencoded\r\n";
+			request_stream << "Connection: close\r\n\r\n";
+			request_stream << postData.c_str();
+
+			// Send the request.
+			boost::asio::write(socket, request);
+
+			// Read the response status line. The response streambuf will automatically
+			// grow to accommodate the entire line. The growth may be limited by passing
+			// a maximum size to the streambuf constructor.
+			boost::asio::streambuf response;
+			boost::asio::read_until(socket, response, "\r\n");
+
+			// Check that response is OK.
+			std::istream response_stream(&response);
+			std::string http_version;
+			response_stream >> http_version;
+			unsigned int status_code;
+			response_stream >> status_code;
+			std::string status_message;
+			std::getline(response_stream, status_message);
+			if (!response_stream || http_version.substr(0, 5) != "HTTP/")
+			{
+				reponse_data = "Invalid response";
+				return -2;
+			}
+			// 如果服务器返回非200都认为有错,不支持301/302等跳转
+			if (status_code != 200)
+			{
+				reponse_data = "Response returned with status code != 200 ";
+				return status_code;
+			}
+
+			// 传说中的包头可以读下来了
+			std::string header;
+			std::vector<string> headers;
+			while (std::getline(response_stream, header) && header != "\r")
+				headers.push_back(header);
+
+			// 读取所有剩下的数据作为包体
+			boost::system::error_code error;
+			while (boost::asio::read(socket, response,
+									 boost::asio::transfer_at_least(1), error))
+			{
+			}
+
+			//响应有数据
+			if (response.size())
+			{
+				std::istream response_stream(&response);
+				std::istreambuf_iterator<char> eos;
+				reponse_data = string(std::istreambuf_iterator<char>(response_stream), eos);
+			}
+
+			if (error != boost::asio::error::eof)
+			{
+				reponse_data = error.message();
+				return -3;
+			}
+		}
+		catch (std::exception &e)
+		{
+			reponse_data = e.what();
+			return -4;
+		}
+		return 0;
+	}
 }
\ No newline at end of file

@@ -14,14 +14,20 @@
 #include <memory>
 #include "dmppgsqlsourcepools.h"
 
+
 namespace mapserver 
 {
     class DmpMapServerUtil
     {
     public:
         static void responseGeojson(shared_ptr<DmpPgsql> pPgsqlConn, std::string &responseData,const string& layerName,const std::string &srid);
+        static void responseGml(shared_ptr<DmpPgsql> pPgsqlConn, std::string &responseData,const string& layerName,const std::string &srid);
         static void toJsonString(std::string &s);
         static std::string replace(std::string strsrc, std::string strfind, std::string strrep);
+
+        static std::vector<std::string> stringSplit(const std::string &str, const std::string &pattern);
+
+        static int HttpPost(const std::string& url, std::string& postData, std::string& responseData );
     };
 }
 

@@ -13,8 +13,11 @@
 #define MAX_SIZE 40
 namespace mapserver
 {
-	DmpPgsqlPool::DmpPgsqlPool()
+	DmpPgsqlPool::DmpPgsqlPool(const std::string& guid,const std::string& name, const std::string& alias)
 	{
+		guid_ = guid;
+		name_ = name;
+		alias_ = alias;
 		waitConnectSize_ = MAX_SIZE;
 		connectionTimeout_ = 15000;
 	}

@@ -19,42 +19,42 @@
 namespace mapserver
 {
 	class DmpPgsqlPool
-	{		
-public:
-		DmpPgsqlPool();
+	{
+	public:
+		DmpPgsqlPool(const std::string& guid,const std::string& name, const std::string& alias);
 		~DmpPgsqlPool();
-	    void ScannerConnectionTask();
+		void ScannerConnectionTask();
 		std::shared_ptr<DmpPgsql> TestDmpPgsql(void);
-        std::shared_ptr<DmpPgsql> GetPgsqlConn(void);
-		void ReleaseHandle(DmpPgsql*);
+		std::shared_ptr<DmpPgsql> GetPgsqlConn(void);
+		void ReleaseHandle(DmpPgsql *);
 
 		void Close(void);
-		bool Connect(const char * s);
-		DmpPgsql* GetConnect();
-        std::string guid()const { return guid_;} 
-	    std::string name()const { return name_;} 
-	    std::string alias()const{ return alias_;} 
-
-private:
-        std::string conninfo_;
+		bool Connect(const char *s);
+		DmpPgsql *GetConnect();
+		std::string guid() const { return guid_; }
+		std::string name() const { return name_; }
+		std::string alias() const { return alias_; }
+
+
+
+	private:
+		std::string conninfo_;
 		// 存储连接的队列
-        queue<DmpPgsql*> connectionQue_;
+		queue<DmpPgsql *> connectionQue_;
 		int waitConnectSize_;
 		int connectSize_ = 0;
 		mutex mutex_;
 		//连接超时时间
-		int connectionTimeout_;  
-
-      // 设置条件变量，用于连接生产线程和连接消费线程的通信
-       condition_variable cv_;
-	   bool isClose_ = false;
-       std::string guid_;
-	   std::string name_;
-	   std::string alias_;
+		int connectionTimeout_;
+
+		// 设置条件变量，用于连接生产线程和连接消费线程的通信
+		condition_variable cv_;
+		bool isClose_ = false;
+		std::string guid_;
+		std::string name_;
+		std::string alias_;
 	};
-	
-}
 
+}
 
 #endif //__dmppgsqlpool_h__
-

@@ -9,6 +9,15 @@
 
 #include "dmppgsqlsourcepools.h"
 #include <iostream>
+#include "dmphttpbase.h"
+#include "dmphttputils.h"
+#include "dmpmapserverutil.h"
+#include "dmpserverutils.h"
+#include "dmpserverdes.h"
+#include <boost/property_tree/ptree.hpp> 
+#include <boost/property_tree/json_parser.hpp> 
+#include <boost/typeof/typeof.hpp>
+
 //#include "DES.h"
 //#include "StringHelp.h"
 
@@ -79,9 +88,9 @@ namespace mapserver
         }
 
        
-        AddDatabasePool("postgis", name, name,name, name);
+        AddDatabasePool(name);
 
-         map<string, shared_ptr<DmpPgsqlPool>>::iterator poolIter2 = this->pgsqlPool_.find(name);
+        map<string, shared_ptr<DmpPgsqlPool>>::iterator poolIter2 = this->pgsqlPool_.find(name);
         if (poolIter2 != this->pgsqlPool_.end())
         {
             shared_ptr<DmpPgsqlPool> pool = poolIter2->second;
@@ -166,6 +175,9 @@ namespace mapserver
         return "";
     }
 
+ 
+
+
     bool DmpPgsqlSourcePools::UpdateDatabasePool()
     {
         printf("InitDatabasePool\r\n");
@@ -319,13 +331,6 @@ namespace mapserver
            string alias = pPgsqlConn->getString(2);
            string uri = pPgsqlConn->getString(3);
            string connectstr = pPgsqlConn->getString(4);
-          /* if(guid == "74c73a18-00c9-11ec-aced-0242ac110002")
-           {
-               continue;
-           }*/
-
-           
-
            string pgConnect= "";
            if(connectstr != "")
            {
@@ -440,13 +445,95 @@ namespace mapserver
 
     bool DmpPgsqlSourcePools::CreateDefaultDatabasePool(string dataType, string connStr)
     {
-        shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool());
+        shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool("","",""));
         defaultPool_ = newPool;
         bool result = defaultPool_->Connect(connStr.c_str());
-      
+
         return true;
     }
 
+    bool DmpPgsqlSourcePools::AddDatabasePool(string guid)
+    {
+        if (guid.find(" ") != string::npos && guid.size() > 50)
+        {
+            std::string connStr = guid;
+            shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool(guid,guid,guid));
+            newPool->Connect(connStr.c_str());
+            //newPool->Connect("PostgreSQLConn=hostaddr=172.26.99.173 port=5433 dbname='postgres' user='postgres' password='chinadci'");
+            pgsqlPool_[guid] = newPool;
+            return true;
+        }
+        else
+        {
+            string requestUrl = DmpServerConfig::Instance()->getMetaUrl();
+            if (requestUrl.size() > 0 && requestUrl[requestUrl.size() - 1] != '/')
+            {
+                requestUrl += "/";
+            }
+            requestUrl.append("API/Database/Detail?guid=");
+            requestUrl.append(guid);
+            std::string reponse_data = DmpServerConfig::Instance()->HttpGet(requestUrl);
+            if (!reponse_data.empty())
+            {
+                try
+                {
+                    std::stringstream stream(reponse_data);
+                    boost::property_tree::ptree pt;
+                    boost::property_tree::read_json(stream, pt);
+                    std::string name = pt.get<std::string>("data.name");
+                    std::string alias = pt.get<std::string>("data.alias");
+                    std::string sqlalchemy_uri_base64 = pt.get<std::string>("data.connectstr");
+                    std::string sqlalchemy_uri = DmpServerDes::DesBase64Decrypt(sqlalchemy_uri_base64, "Chinadci");
+
+                    shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool(guid,name,alias));
+                    if (newPool->Connect(sqlalchemy_uri.c_str()))
+                    {
+                        pgsqlPool_[guid] = newPool;
+                        return true;
+                    }
+                  
+                }
+                catch (...)
+                {
+                    return false;
+                }
+            }
+        }
+        return false;
+    }
+
+    string DmpPgsqlSourcePools::GetDbsource(const string& serviceid)
+    {
+        string requestUrl = DmpServerConfig::Instance()->getMetaUrl();
+        if (requestUrl.size() > 0 && requestUrl[requestUrl.size() - 1] != '/')
+        {
+            requestUrl += "/";
+        }
+        requestUrl.append("API/Database/Detail?guid=");
+        requestUrl.append(serviceid);
+        std::string reponse_data = DmpServerConfig::Instance()->HttpGet(requestUrl);
+        if (!reponse_data.empty())
+        {
+            try
+            {
+                std::stringstream stream(reponse_data);
+                boost::property_tree::ptree pt;
+                boost::property_tree::read_json(stream, pt);
+                std::string name = pt.get<std::string>("data.name");
+                std::string alias = pt.get<std::string>("data.alias");
+                std::string sqlalchemy_uri_base64 = pt.get<std::string>("data.connectstr");
+                std::string sqlalchemy_uri = DmpServerDes::DesBase64Decrypt(sqlalchemy_uri_base64, "Chinadci");
+
+                return sqlalchemy_uri;
+            }
+            catch (...)
+            {
+                return "";
+            }
+        }
+        return "";
+    }
+
     bool DmpPgsqlSourcePools::AddDatabasePool(string dataType,
                                           string guid,
                                           string databaseName,
@@ -454,7 +541,7 @@ namespace mapserver
                                           string connStr)
     {
        
-        shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool());
+        shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool(guid,databaseName,alias));
        // newPool->guid() = guid;
         //  newPool->m_name = databaseName;
         //  newPool->m_alias = alias;
@@ -468,7 +555,7 @@ namespace mapserver
      {
          if(pgsqlPool_.find(guid) == pgsqlPool_.end())
          {
-            shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool());
+            shared_ptr<DmpPgsqlPool> newPool(new DmpPgsqlPool(guid,databaseName,alias));
            // newPool->guid() = guid;
            // newPool->m_name = databaseName;
            // newPool->m_alias = alias;

@@ -7,58 +7,61 @@
 * copyright:         广州城市信息研究所有限公司
 ***************************************************************************/
 
-
 #ifndef __dmppgsqlsourcepools_h__
 #define __dmppgsqlsourcepools_h__
 
 #include <map>
 #include "dmppgsqlpool.h"
 #include <mutex>
+#include "dmpserverconfig.h"
+
 #define DMAP_DMDMS_DATABASE "dmdms_database"
 #define DMAP_SCHEMA "public"
 #define MAXCOUNT 200000
 
 namespace mapserver
 {
-    class DmpPgsqlPool;
-    class DmpPgsqlSourcePools
-    {
-    public:
-
-        DmpPgsqlSourcePools();
-        ~DmpPgsqlSourcePools();
-        static DmpPgsqlSourcePools* get_instance();
-
-        //获取默认数据库连接
-        shared_ptr<DmpPgsql> GetDefaultPgsqlConn();
-
-        //获取数据库连接
-        shared_ptr<DmpPgsql> GetPgsqlConn(const string& name);
-
-       // shared_ptr<DmpPgsql> GetPgsqlConn(char* name);
-
-        string GetDbSourceID(string name);
-
-        bool InitDatabasePool();
-
-        bool UpdateDatabasePool();
-        //创建默认数据库连接池
-        bool CreateDefaultDatabasePool(string dataType, string connStr);
-        // 添加数据库连接池
-        bool AddDatabasePool(string dataType, string guid, string databaseName, string alias, string connStr);
-        // Update 数据库连接池
-        bool UpdDatabasePool(string dataType, string guid, string databaseName, string alias, string connStr);
-      private:
-        shared_ptr<DmpPgsqlPool> defaultPool_;
-        map<string, shared_ptr<DmpPgsqlPool>> pgsqlPool_;
-        bool updateLock_ = false;
-
-     private:
-       mutex mutex_;
-       static DmpPgsqlSourcePools* instance_ptr;
-    };
-}
+  class DmpPgsqlPool;
+  class DmpPgsqlSourcePools
+  {
+  public:
+    DmpPgsqlSourcePools();
+    ~DmpPgsqlSourcePools();
+    static DmpPgsqlSourcePools *get_instance();
 
+    //获取默认数据库连接
+    shared_ptr<DmpPgsql> GetDefaultPgsqlConn();
 
-#endif //__dmppgsqlsourcepools_h__
+    //获取数据库连接
+    shared_ptr<DmpPgsql> GetPgsqlConn(const string &name);
+
+    // shared_ptr<DmpPgsql> GetPgsqlConn(char* name);
+
+    string GetDbSourceID(string name);
+
+    string GetDbsource(const string& serviceid);
 
+    bool InitDatabasePool();
+
+    bool UpdateDatabasePool();
+    //创建默认数据库连接池
+    bool CreateDefaultDatabasePool(string dataType, string connStr);
+    // 添加数据库连接池
+    bool AddDatabasePool(string dataType, string guid, string databaseName, string alias, string connStr);
+    // Update 数据库连接池
+    bool UpdDatabasePool(string dataType, string guid, string databaseName, string alias, string connStr);
+
+    bool AddDatabasePool(string guid);
+
+  private:
+    shared_ptr<DmpPgsqlPool> defaultPool_;
+    map<string, shared_ptr<DmpPgsqlPool>> pgsqlPool_;
+    bool updateLock_ = false;
+
+  private:
+    mutex mutex_;
+    static DmpPgsqlSourcePools *instance_ptr;
+  };
+}
+
+#endif //__dmppgsqlsourcepools_h__

@@ -11,6 +11,7 @@
 #include "dmpserverresponse.h"
 #include "dmpserverrequest.h"
 #include "dmpproject.h"
+#include "dmpvectorlayer.h"
 #include "dmpserverproject.h"
 #include <boost/property_tree/ptree.hpp> 
 #include <boost/property_tree/json_parser.hpp> 
@@ -21,7 +22,9 @@ namespace DmpMapping
     bool loadService(const DmpServerContext &context, ProjectMap& vectorMappingProjects)
     {
         const char *data = (char *)(context.request()->GetData());
-        if(data== nullptr ||  *data == '\0') 
+        
+
+        if(data== nullptr ||  *data == '\0' || context.request()->method() != DmpServerRequest::Method::POST_METHOD ) 
         {
              LOGGER_ERROR("post 参数错误");
              context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误!\"}");
@@ -31,12 +34,14 @@ namespace DmpMapping
         if(!context.serverProject())
         {
              LOGGER_ERROR("加载服务信息失败，服务名称是否错误");
-             context.response()->writeJson("{\"status\":\"false\",\"message\":\"加载服务信息失败，服务名称是否错误!\"}");
+             context.response()->writeJson("{\"status\":\"false\",\"message\":\"加载服务信息失败，服务名称错误!\"}");
              return false;
         }
         
         try
         {
+            std::string name = context.serverProject()->name();
+            std::string title = context.serverProject()->title();
             std::stringstream stream(data);
             boost::property_tree::ptree pt;
             boost::property_tree::read_json(stream, pt);
@@ -54,9 +59,55 @@ namespace DmpMapping
                     return false;
                 }
                 vectorMappingProjects[guid] =  project;
-                context.response()->removeHeader("Content-Type");
-                context.response()->setHeader("Content-Type", "text/xml;charset=utf-8");
-                context.response()->write(projectData);
+
+                int i = 0;
+                double minx, miny, maxx, maxy;
+                std::map<std::string, DmpMapLayer *> mapLayers = project->mapLayers();
+                for (std::map<std::string, DmpMapLayer *>::iterator iter = mapLayers.begin(); iter != mapLayers.end(); iter++)
+                {
+                    DmpMapLayer *layer = iter->second;
+                    if (i == 0)
+                    {
+                        minx = layer->extent().xmin();
+                        miny = layer->extent().ymin();
+                        maxx = layer->extent().xmax();
+                        maxy = layer->extent().ymax();
+                    }
+                    else
+                    {
+                        if (minx > layer->extent().xmin())
+                            minx = layer->extent().xmin();
+                        if (miny > layer->extent().ymin())
+                            miny = layer->extent().ymin();
+                        if (maxx < layer->extent().xmax())
+                            maxx = layer->extent().xmax();
+                        if (maxy < layer->extent().ymax())
+                            maxy = layer->extent().ymax();
+                    }
+                }
+                
+                char buff[250];
+                sprintf(buff, "{\"name\":\"%s\",\"title\":\"%s\",\"boundingBox\":{\"minx\":%f, \"miny\":%f,\"maxx\":%f, \"maxy\":%f }",
+                name.c_str(), title.c_str(),minx, miny, maxx, maxy);
+
+                std::string json = buff;
+                json.append(",\"maplayer\":[");
+                
+                i = 0;
+                for (std::map<std::string, DmpMapLayer *>::iterator iter = mapLayers.begin(); iter != mapLayers.end(); iter++)
+                {
+                    DmpVectorLayer *layer = (DmpVectorLayer*) iter->second;
+                    if(i>0)
+                    {
+                        json.append(",");
+                    }
+                    layer->writejson(json);
+                    i++;
+                }
+
+                json.append("]}");
+
+                context.response()->writeJson( json);
                 return true;
             }
             else
@@ -82,7 +133,7 @@ namespace DmpMapping
        return false;
     }
 
-    bool editService(const DmpServerContext &context,ProjectMap& vectorMappingProjects)
+    bool loadProjectService(const DmpServerContext &context,ProjectMap& vectorMappingProjects)
     {
         const char *data = (char *)(context.request()->GetData());
         if(data== nullptr ||  *data == '\0') 
@@ -91,11 +142,112 @@ namespace DmpMapping
              context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误!\"}");
              return false;
         }
+        
+        try
+        {
+            std::stringstream stream(data);
+            boost::property_tree::ptree pt;
+            boost::property_tree::read_json(stream, pt);
 
-        if(!context.serverProject())
+            std::string guid  = pt.get<std::string>("guid");
+            std::string project  = pt.get<std::string>("project");
+            if(!guid.empty() && !project.empty())
+            {
+                std::string projData;
+                if (!DmpServerUtils::Base64Decode(project, &projData))
+                {
+                    context.response()->writeJson("{\"status\":\"false\",\"message\":\"base64转码错误\"}");
+                    return false;
+                }
+                shared_ptr<DmpProject> project(new DmpProject());
+                if (!project->Read(projData))
+                {
+                    context.response()->writeJson("{\"status\":\"false\",\"message\":\"DMD文档错误\"}");
+                    return false;
+                }
+                vectorMappingProjects[guid] =  project;
+                
+                int i = 0;
+                double minx, miny, maxx, maxy;
+                std::map<std::string, DmpMapLayer *> mapLayers = project->mapLayers();
+                for (std::map<std::string, DmpMapLayer *>::iterator iter = mapLayers.begin(); iter != mapLayers.end(); iter++)
+                {
+                    DmpMapLayer *layer = iter->second;
+                    if (i == 0)
+                    {
+                        minx = layer->extent().xmin();
+                        miny = layer->extent().ymin();
+                        maxx = layer->extent().xmax();
+                        maxy = layer->extent().ymax();
+                    }
+                    else
+                    {
+                        if (minx > layer->extent().xmin())
+                            minx = layer->extent().xmin();
+                        if (miny > layer->extent().ymin())
+                            miny = layer->extent().ymin();
+                        if (maxx < layer->extent().xmax())
+                            maxx = layer->extent().xmax();
+                        if (maxy < layer->extent().ymax())
+                            maxy = layer->extent().ymax();
+                    }
+                }
+                
+                char buff[250];
+                sprintf(buff, "{\"name\":\"%s\",\"title\":\"%s\",\"boundingBox\":{\"minx\":%f, \"miny\":%f,\"maxx\":%f, \"maxy\":%f }",
+                guid.c_str(), "",minx, miny, maxx, maxy);
+
+                std::string json = buff;
+                json.append(",\"maplayer\":[");
+                
+                i = 0;
+                for (std::map<std::string, DmpMapLayer *>::iterator iter = mapLayers.begin(); iter != mapLayers.end(); iter++)
+                {
+                    DmpVectorLayer *layer = (DmpVectorLayer*) iter->second;
+                    if(i>0)
+                    {
+                        json.append(",");
+                    }
+                    layer->writejson(json);
+                    i++;
+                }
+
+                json.append("]}");
+
+                context.response()->writeJson( json);
+                return true;
+            }
+            else
+            {
+                LOGGER_ERROR("post 参数错误");
+                context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误!\"}");
+                return false;
+            }
+        }
+        catch (boost::property_tree::ptree_bad_path &e)
         {
-             LOGGER_ERROR("加载服务信息失败，服务名称是否错误");
-             context.response()->writeJson("{\"status\":\"false\",\"message\":\"加载服务信息失败，服务名称是否错误!\"}");
+            LOGGER_ERROR(e.what());
+            context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误\"}");
+            return false;
+        }
+        catch (boost::property_tree::ptree_bad_data &e)
+        {
+            LOGGER_ERROR(e.what());
+            context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误\"}");
+            return false;
+        }
+        context.response()->writeJson("{\"status\":\"false\",\"message\":\"未知错误\"}");
+        return false;
+    }
+
+    
+    bool editService(const DmpServerContext &context,ProjectMap& vectorMappingProjects)
+    {
+        const char *data = (char *)(context.request()->GetData());
+        if(data== nullptr ||  *data == '\0') 
+        {
+             LOGGER_ERROR("post 参数错误");
+             context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误!\"}");
              return false;
         }
         
@@ -112,15 +264,18 @@ namespace DmpMapping
                 std::string projData;
                 if (!DmpServerUtils::Base64Decode(project, &projData))
                 {
+                    context.response()->writeJson("{\"status\":\"false\",\"message\":\"base64转码错误\"}");
                     return false;
                 }
                 shared_ptr<DmpProject> project(new DmpProject());
                 if (!project->Read(projData))
                 {
+                    context.response()->writeJson("{\"status\":\"false\",\"message\":\"DMD文档错误\"}");
                     return false;
                 }
                 vectorMappingProjects[guid] =  project;
                 context.response()->writeJson("{\"status\":\"true\",\"message\":\"创建编辑服务工作空间成功!\"}");
+                return true;
             }
             else
             {
@@ -128,7 +283,6 @@ namespace DmpMapping
                 context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误!\"}");
                 return false;
             }
-            
         }
         catch (boost::property_tree::ptree_bad_path &e)
         {
@@ -142,7 +296,8 @@ namespace DmpMapping
             context.response()->writeJson("{\"status\":\"false\",\"message\":\"post 参数错误\"}");
             return false;
         }
-         return false;
+        context.response()->writeJson("{\"status\":\"false\",\"message\":\"未知错误\"}");
+        return false;
     }
    
 }
\ No newline at end of file

@@ -22,7 +22,7 @@ namespace DmpMapping
 
     bool loadService(const DmpServerContext &context,ProjectMap& vectorMappingProjects);
 
-
+    bool loadProjectService(const DmpServerContext &context,ProjectMap& vectorMappingProjects);
     bool editService(const DmpServerContext &context,ProjectMap& vectorMappingProjects);
 
 }

+/**************************************************************************
+* file:              dmpimageinfo.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-04 10:50:35
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include <unistd.h>
+#include <dirent.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <map>
+#include <set>
+#include <fontconfig/fontconfig.h>
+
+#include <boost/foreach.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/date_time.hpp>
+#include <boost/property_tree/ptree.hpp> 
+#include <boost/property_tree/json_parser.hpp> 
+#include <boost/typeof/typeof.hpp>
+#include "dmplogger.h"
+#include "dmpserverresponse.h"
+#include "dmpserverrequest.h"
+
+#include "dmpimageinfo.h"
+
+namespace DmpMapping
+{
+    void getTypefaceList(const DmpServerContext &context) 
+    {
+        FcConfig *config = FcInitLoadConfigAndFonts();
+        FcPattern *pat = FcPatternCreate();
+        FcObjectSet *os = FcObjectSetBuild(FC_FAMILY, FC_STYLE, FC_LANG, FC_FILE, (char *)0);
+        FcFontSet *fs = FcFontList(config, pat, os);
+        if (fs == nullptr)
+        {
+            context.response()->writeJson("{\"error\":\"load FcFontSet  failed\"}");
+            return;
+        }
+        //printf("Total matching fonts: %d\n", fs->nfont);
+        boost::property_tree::ptree ptDoc;
+        boost::property_tree::ptree ptRoot;
+
+        std::map<std::string, std::string> mapFont;
+        mapFont["SimSun"] = "宋体";
+        mapFont["NSimSun"] = "新宋体";
+        mapFont["SimHei"] = "黑体";
+        mapFont["FangSong"] = "仿宋";
+        mapFont["KaiTi"] = "楷体";
+        mapFont["LiSu"] = "隶书";
+        mapFont["YouYuan"] = "幼圆";
+        mapFont["STXihei"] = "华文细黑";
+        mapFont["STKaiti"] = "华文楷体";
+        mapFont["STSong"] = "华文宋体";
+        mapFont["STZhongsong"] = "华文中宋";
+        mapFont["STFangsong"] = "华文仿宋";
+        mapFont["FZShuTi"] = "方正舒体";
+        mapFont["FZYaoti"] = "方正姚体";
+        mapFont["STCaiyun"] = "华文彩云";
+        mapFont["STHupo"] = "华文琥珀";
+        mapFont["STLiti"] = "华文隶书";
+        mapFont["STXingkai"] = "华文行楷";
+        mapFont["STXinwei"] = "华文新魏";
+        mapFont["Microsoft YaHei"] = "微软雅黑";
+        mapFont["Microsoft JhengHei"] = "微軟正黑體";
+        mapFont["DengXian"] = "等线";
+        mapFont["MingLiU"] = "細明體";
+        mapFont["MingLiU_HKSCS"] = "細明體_HKSCS";
+        mapFont["MingLiU"] = "細明體";
+
+        std::set<std::string> setFont;
+        char buff[1000];
+        for (int i = 0; fs && i < fs->nfont; ++i)
+        {
+
+            FcPattern *font = fs->fonts[i];
+            FcChar8 *file, *style, *family, *prgname;
+            if (FcPatternGetString(font, FC_FILE, 0, &file) == FcResultMatch &&
+                FcPatternGetString(font, FC_FAMILY, 0, &family) == FcResultMatch &&
+                FcPatternGetString(font, FC_STYLE, 0, &style) == FcResultMatch)
+            {
+                sprintf(buff, "%s", family);
+                if (setFont.find(buff) == setFont.end())
+                {
+
+                    setFont.insert(buff);
+                    if (mapFont.find(buff) != mapFont.end())
+                    {
+                        boost::property_tree::ptree ptNode;
+                        ptNode.put("", buff);
+                        ptRoot.push_back(std::make_pair("", ptNode));
+                    }
+                }
+            }
+        }
+
+        for (std::set<std::string>::iterator iter = setFont.begin();
+             iter != setFont.end(); iter++)
+        {
+            if (mapFont.find(*iter) == mapFont.end())
+            {
+                boost::property_tree::ptree ptNode;
+                ptNode.put("", *iter);
+                ptRoot.push_back(std::make_pair("", ptNode));
+            }
+        }
+
+        FcFontSetDestroy(fs);
+
+        ptDoc.add_child("value", ptRoot);
+        std::stringstream stream;
+        write_json(stream, ptDoc);
+        std::string responseStr = stream.str();
+        context.response()->writeJson(responseStr);
+    }
+
+    void getImage(const DmpServerContext &context) 
+    {
+        DmpServerParameters params = context.request()->serverParameters();
+        std::string name;
+        params.getValue("name", name);
+
+        std::string imagePath = getFilePath("../symbollib/" + name);
+        FILE *file = fopen(imagePath.c_str(), "rb");
+
+        try
+        {
+            char buff[1024];
+            if (file == 0)
+            {
+                context.response()->writeJson("{\"error\":\"open file failed\"}");
+                return;
+            }
+
+            context.response()->removeHeader("Content-Type");
+            context.response()->setHeader("Content-Type", "image/png");
+
+            for (int i = 0; i < 20000; i++)
+            {
+                size_t t = fread(buff, 1, sizeof(buff), file);
+                context.response()->writeContent(buff, t);
+
+                if (t != sizeof(buff))
+                    break;
+            }
+            fclose(file);
+            return;
+        }
+        catch (...)
+        {
+            if (file)
+                fclose(file);
+        }
+        context.response()->writeJson("{\"error\":\"Parameter name is null\"}");
+    }
+
+    void getImageTypeList(const DmpServerContext &context) 
+    {
+        DIR *dirp;
+        struct dirent *dp;
+        std::string imagePath = getFilePath("../symbollib");
+        dirp = opendir(imagePath.c_str());
+
+        boost::property_tree::ptree ptDoc;
+        boost::property_tree::ptree ptRoot;
+
+        if (dirp)
+        {
+            while ((dp = readdir(dirp)) != NULL)
+            {
+                if (dp->d_name == NULL || dp->d_name[0] == '.')
+                {
+                    continue;
+                }
+
+                boost::property_tree::ptree ptDir;
+
+                ptDir.add("name", dp->d_name);
+                ptRoot.push_back(std::make_pair("", ptDir));
+                //ptRoot.add_child("imageType",ptDir);
+            }
+            closedir(dirp);
+        }
+        else
+        {
+            LOGGER_ERROR("not find dir " + imagePath);
+            context.response()->writeJson(R"({"value":[]})");
+            return ;
+        }
+
+        ptDoc.add_child("value", ptRoot);
+        std::stringstream stream;
+        write_json(stream, ptDoc);
+        std::string responseStr = stream.str();
+        context.response()->writeJson(responseStr);
+    }
+
+    void getImageList(const DmpServerContext &context) 
+    {
+        DmpServerParameters params = context.request()->serverParameters();
+        std::string name;
+        params.getValue("name", name);
+
+        if (name.empty())
+        {
+            context.response()->writeJson("{\"error\":\"Parameter name is null\"}");
+            return;
+        }
+
+        struct dirent *dp;
+        std::string imagePath = getFilePath("../symbollib/" + name);
+        DIR *dirp = opendir(imagePath.c_str());
+
+        boost::property_tree::ptree ptDoc;
+        boost::property_tree::ptree ptRoot;
+
+        if (dirp)
+        {
+            while ((dp = readdir(dirp)) != NULL)
+            {
+                boost::property_tree::ptree ptDir;
+                if (dp->d_name == NULL || dp->d_name[0] == '.')
+                {
+                    continue;
+                }
+                ptDir.add("name", dp->d_name);
+                ptDir.add("path", ("../symbollib/" + name + "/" + dp->d_name));
+                ptRoot.push_back(std::make_pair("", ptDir));
+            }
+            closedir(dirp);
+        }
+        else
+        {
+            LOGGER_ERROR("not find dir " + imagePath);
+            context.response()->writeJson(R"({"value":[]})");
+            return ;
+        }
+
+        ptDoc.add_child("value", ptRoot);
+        std::stringstream stream;
+        write_json(stream, ptDoc);
+        std::string responseStr = stream.str();
+        context.response()->writeJson(responseStr);
+    }
+
+    std::string getFilePath(const std::string &path) 
+    {
+        char sz[300] = {0};
+        if (getCurrentFolderPath(sz, sizeof(sz)) > 0)
+        {
+            std::string s;
+            s = sz;
+            size_t t = s.rfind('/');
+            sz[t] = 0;
+            if (path[0] == '/')
+            {
+                return path;
+            }
+            int i = 0;
+            if (path[0] == '.')
+            {
+                if (path[1] == '.')
+                {
+                    i++;
+                    s = sz;
+                    t = s.rfind('/');
+                    sz[t] = 0;
+                }
+                i++;
+            }
+            if ((sz[t] == '/' || sz[t] == '\\') && (path[i] == '/' || path[i] == '\\'))
+            {
+                i++;
+            }
+
+            int j = t;
+            for (j = t; i < path.length(); i++, j++)
+            {
+                if (path[i] == '\\')
+                {
+                    sz[j] = '/';
+                }
+                else
+                {
+                    sz[j] = path[i];
+                }
+            }
+            sz[j] = 0;
+            //strcat(sz, path.c_str());
+            return sz;
+        }
+        else
+            return 0;
+    }
+
+    size_t getCurrentFolderPath(char *processdir, size_t len) 
+    {
+        char *path_end;
+        if (readlink("/proc/self/exe", processdir, len) <= 0)
+            return -1;
+        path_end = strrchr(processdir, '/');
+        if (path_end == NULL)
+            return -1;
+        ++path_end;
+        //strcpy(processname, path_end);
+        *path_end = '\0';
+        return (size_t)(path_end - processdir);
+    }
+
+}
\ No newline at end of file

+/**************************************************************************
+* file:              dmpimageinfo.h
+
+* Author:            qingxiongf
+* Date:              2022-01-04 10:03:50
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpimageinfo_h__
+#define __dmpimageinfo_h__
+
+#include <map>
+#include <memory>
+#include <functional>
+#include "dmpservercontext.h"
+
+
+
+namespace DmpMapping
+{
+    void getTypefaceList(const DmpServerContext &context) ; //获取字体列表
+    void getImageTypeList(const DmpServerContext &context) ; //获取图片目录列表
+    void getImageList(const DmpServerContext &context) ; //获取图片列表
+    void getImage(const DmpServerContext &context) ; //获取图片
+    std::string getFilePath(const std::string& path);
+    size_t  getCurrentFolderPath(char *processdir, size_t len);
+}
+
+#endif // __dmpimageinfo_h__
+

@@ -17,8 +17,11 @@
 #include "dmpserverresponse.h"
 #include "dmplogger.h"
 #include "../wms/dmpwmsgetmap.h"
+#include "../wms/dmpwmsparameters.h"
 #include "dmpmapping.h"
 #include "dmpmappingparameters.h"
+#include "dmpimageinfo.h"
+
 using namespace std;
 
 namespace DmpMapping
@@ -47,10 +50,82 @@ namespace DmpMapping
     {
       loadService(context, vectorMappingProjects_);
     }
+    else if (boost::iequals(request, "loadDmdService"))
+    {
+      loadProjectService(context, vectorMappingProjects_);
+    }
+    else if (boost::iequals(request, "editService"))
+    {
+      editService(context, vectorMappingProjects_);
+    }
+    else if (boost::iequals(request,"gettypefacelist")) {
+       getTypefaceList(context);
+    }
+    else if (boost::iequals(request,"getimagetyplist")) {
+       getImageTypeList(context);
+    }
+    else if (boost::iequals(request,"getimagelist")) {
+       getImageList(context);
+    }
+    else if (boost::iequals(request,"getimage")) {
+       getImage(context);
+    }
     else if (boost::iequals(request, "getmap"))
     {
-      DmpWms::writeGetMap(context, params, nullptr);
+      const std::string mapGuid = params.MapGuid();
+      if (vectorMappingProjects_.find(mapGuid) != vectorMappingProjects_.end())
+      {
+        shared_ptr<DmpProject> project = vectorMappingProjects_.find(mapGuid)->second;
+        const DmpWms::DmpWmsParameters wmsParams(context.request()->serverParameters());
+        DmpWms::writeGetMap(context, wmsParams, project.get());
+      }
+      else
+      {
+        writeLock(rwmutex_);
+        if (vectorMappingProjects_.find(mapGuid) != vectorMappingProjects_.end())
+        {
+          shared_ptr<DmpProject> project = vectorMappingProjects_.find(mapGuid)->second;
+          const DmpWms::DmpWmsParameters wmsParams(context.request()->serverParameters());
+          DmpWms::writeGetMap(context, wmsParams, project.get());
+        }
+        else
+        {
+          std::string mapRenderer = params.MapRenderer();
+          if (!mapRenderer.empty())
+          {
+            std::string projData;
+            for(int i = 0; i< mapRenderer.size(); i++)
+            {
+                if(mapRenderer[i] == ' ')mapRenderer[i]= '+';
+            }
+            if (!DmpServerUtils::Base64Decode(mapRenderer, &projData))
+            {
+              context.response()->writeJson("{\"status\":\"false\",\"message\":\""+ mapRenderer +"  base64转码错误\"}");
+              return;
+            }
+            shared_ptr<DmpProject> project(new DmpProject());
+            if (!project->Read(projData))
+            {
+              context.response()->writeJson("{\"status\":\"false\",\"message\":\"DMD文档错误\"}");
+              return;
+            }
+            const DmpWms::DmpWmsParameters wmsParams(context.request()->serverParameters());
+            DmpWms::writeGetMap(context, wmsParams, project.get());
+            if(!mapGuid.empty())
+            {
+              vectorMappingProjects_[mapGuid] = project;
+            }
+            return;
+          }
+        }
+      }
     }
+   
   }
+
+
+
+
+
 } 
 

@@ -12,6 +12,12 @@
 #include <string>
 #include "dmpeditservice.h"
 #include "dmpservice.h"
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread.hpp>
+
+typedef boost::shared_mutex rwmutex;
+typedef boost::shared_lock<rwmutex> readLock;
+typedef boost::unique_lock<rwmutex> writeLock;
 namespace DmpMapping
 {
     class DmpMappingService : public DmpService
@@ -28,6 +34,7 @@ namespace DmpMapping
        
     //存储工程文档实例
        ProjectMap vectorMappingProjects_;
+       rwmutex rwmutex_;
     };
 }
 

@@ -87,4 +87,28 @@ namespace DmpMapping
         return value;
     }
 
+    std::string DmpMappingParameters::Map() const
+    {
+        std::string value = "";
+        GetStringParameter("MAP",value);
+        return value;
+    }
+
+    std::string DmpMappingParameters::MapGuid() const
+    {
+        std::string value = "";
+        if(!GetStringParameter("GUID",value))
+        {
+            GetStringParameter("MappingGUID",value);
+        }
+        return value;
+    }
+
+    std::string DmpMappingParameters::MapRenderer() const
+    {
+        std::string value = "";
+        GetStringParameter("MapRenderer", value);
+        return value;
+    }
+
 } // namespace DmpWms
\ No newline at end of file

@@ -23,6 +23,10 @@ namespace DmpMapping
         std::string Request() const;  //必须 值为GetMap GetCapabilities GetFeatureInfo GetFeatureInfo GetLegendGraphic
         std::string Version() const; //必须  服务版本， 值为 1.0.0, 1.1.0, 1.1.1, 1.3
 
+        std::string Map() const; 
+        std::string MapGuid() const; 
+        std::string MapRenderer() const;
+
     private:
         bool GetStringParameter(const char* key, std::string &value) const;
         bool GetIntParameter(const char* key, int& value) const;

+
+/**************************************************************************
+* file:              dmpgmlfilter.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-07 14:44:06
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpgmlfilter.h"
+#include <boost/dll/alias.hpp> // for BOOST_DLL_ALIAS
+#include <boost/filesystem.hpp>
+#include <boost/function.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <string>
+namespace DmpWfs
+{
+
+    DmpGmlFilter::DmpGmlFilter(/* args */)
+    {
+    }
+
+    DmpGmlFilter::~DmpGmlFilter()
+    {
+    }
+
+    bool DmpGmlFilter::Parse(const std::string &filter)
+    {
+        try
+        {
+            std::stringstream stream(filter);
+            boost::property_tree::ptree ptree;
+            boost::property_tree::read_xml(stream, ptree);
+            boost::property_tree::ptree::iterator ptroot = ptree.begin();
+
+            if( ptroot !=ptree.end() && (boost::iequals(ptroot->first,"fes:Filter")|| boost::iequals(ptroot->first,"Filter") || boost::iequals(ptroot->first,"ogc:Filter")))
+            {
+                bool isFirst = true;
+                
+                for (boost::property_tree::ptree::iterator ptchild = ptroot->second.begin(); ptchild != ptroot->second.end(); ++ptchild)
+                {
+                    if (!isFirst)
+                    {
+                        sql_ += " or ";
+                    }
+                    int k = _All(ptchild->first, ptchild->second);
+	            	//nc++;	
+
+                    printf("%s\r\n", ptchild->first.c_str());
+                }
+            }
+
+            /*if(!(strcmp(p,"fes:Filter")==0||strcmp(p,"Filter")==0 || strcmp(p,"ogc:Filter")==0))return Error(-12,"no filter node");
+            bool isFirst = true;
+            for (boost::property_tree::ptree::iterator ptchild = ptree.begin(); ptchild != ptree.end(); ++ptchild)
+            {
+                if (!isFirst)
+                {
+                    sql_ += " or ";
+                }
+
+                printf("%s\r\n",ptchild->first.c_str());
+               
+            }*/
+        }
+        catch (const std::exception &e)
+        {
+            
+        }
+
+        return false;
+    }
+
+    int DmpGmlFilter::Error(int errorcode, const char* err)
+    {
+        return 0;
+    }
+
+     std::string DmpGmlFilter::GetFieldName(const std::string& name)
+    {
+        int len = name.size();
+        char p[100];
+        strcpy(p, name.c_str());
+        for (int i = 0; i < len; i++)
+        {
+            if (name[i] == ':')
+            {
+                strcpy(p, &name[i + 1]);
+                len = strlen(p);
+                break;
+            }
+        }
+        std::string str = p;
+        return str;
+    }
+
+
+    
+    int DmpGmlFilter::_All(const std::string &ptname,boost::property_tree::ptree& ptree)
+    {
+
+        std::string name = GetFieldName(ptname);
+        const char *p = name.c_str();
+
+        if (0 == strcmp(p, "PropertyIsNotEqualTo"))
+                return _PropertyIsNotEqualTo(ptree);
+         return 0;
+        /*
+        switch (name.length())
+        {
+        case 2:
+            if (0 == strcmp(p, "Or"))
+                return _Or(ptree);
+            break;
+        case 3:
+            if (0 == strcmp(p, "Not"))
+                return _Not(ptree);
+            if (0 == strcmp(p, "And"))
+                return _And(ptree);
+            break;
+        case 4:
+            if (0 == strcmp(p, "BBOX"))
+                return _BBOX(ptree);
+            break;
+        case 6:
+            if (0 == strcmp(p, "Equals"))
+                return _Equals(ptree);
+            if (0 == strcmp(p, "Beyond"))
+                return _Beyond(ptree);
+            if (0 == strcmp(p, "Within"))
+                return _Within(ptree);
+            break;
+        case 7:
+            if (0 == strcmp(p, "Crosses"))
+                return _Crosses(ptree);
+            if (0 == strcmp(p, "Touches"))
+                return _Touches(ptree);
+            if (0 == strcmp(p, "DWithin"))
+                return _DWithin(ptree);
+            break;
+        case 8:
+            if (0 == strcmp(p, "Contains"))
+                return _Contains(ptree);
+            if (0 == strcmp(p, "Overlaps"))
+                return _Overlaps(ptree);
+            if (0 == strcmp(p, "Disjoint"))
+                return _Disjoint(ptree);
+            break;
+        case 9:
+            if (0 == strcmp(p, "FeatureId"))
+                return _FeatureId(ptree);
+            break;
+        case 10:
+            if (0 == strcmp(p, "Intersects"))
+                return _Intersects(ptree);
+            if (0 == strcmp(p, "ResourceId"))
+                return _FeatureId(ptree);
+            break;
+        case 11:
+            if (0 == strcmp(p, "GmlObjectId"))
+                return _GmlObjectId(ptree);
+            if (0 == strcmp(p, "DIntersects"))
+                return _DIntersects(ptree);
+            break;
+        case 14:
+            if (0 == strcmp(p, "PropertyIsLike"))
+                return _PropertyIsLike(ptree);
+            if (0 == strcmp(p, "PropertyIsNull"))
+                return _PropertyIsNull(ptree);
+            if (0 == strcmp(p, "fes:ResourceId") || 0 == strcmp(p, "ogc:ResourceId"))
+                return _FeatureId(ptree);
+            break;
+        case 17:
+            if (0 == strcmp(p, "PropertyIsBetween"))
+                return _PropertyIsBetween(ptree);
+            if (0 == strcmp(p, "PropertyIsEqualTo"))
+                return _PropertyIsEqualTo(ptree);
+            break;
+        case 18:
+            if (0 == strcmp(p, "PropertyIsLessThan"))
+                return _PropertyIsLessThan(ptree);
+            break;
+        case 20:
+            if (0 == strcmp(p, "PropertyIsNotEqualTo"))
+                return _PropertyIsNotEqualTo(ptree);
+            break;
+        case 21:
+            if (0 == strcmp(p, "PropertyIsGreaterThan"))
+                return _PropertyIsGreaterThan(ptree);
+            break;
+        case 27:
+            if (0 == strcmp(p, "PropertyIsLessThanOrEqualTo"))
+                return _PropertyIsLessThanOrEqualTo(ptree);
+            break;
+        case 30:
+            if (0 == strcmp(p, "PropertyIsGreaterThanOrEqualTo"))
+                return _PropertyIsGreaterThanOrEqualTo(ptree);
+            break;
+        default:
+            break;
+        }
+        sql_ += "1=1";
+        error_ = "Filter type error: ";
+        error_ += p;
+        return -17;*/
+    }
+
+    int DmpGmlFilter::_PropertyIsNotEqualTo(boost::property_tree::ptree& ptree)
+    {
+        return _PropertyOneEqual(ptree, "<>");
+    }
+
+    int DmpGmlFilter::_PropertyOneEqual(boost::property_tree::ptree &ptree,const char *type, int isLike)
+    {
+        int nc = 0, isExpression;
+        for (auto ptchild = ptree.begin(); ptchild != ptree.end(); ++ptchild)
+        {
+            if(ptchild->first == "<xmlattr>")
+                continue;
+            int r = _PropertyParse(ptchild->first, ptchild->second, isExpression, isLike); //这里IsLike设定的值是1
+            if (r) return r;
+
+            if (isExpression)
+            {
+                if (nc == 0)
+                {
+                    sql_ += type;
+                }
+                nc++;
+                if (nc == 2)
+                    return 0;
+            }
+        }
+        if (nc < 2)
+            return Error(-19, "no enough expression");
+        return 0;
+    }
+    /*
+        //<fes:Filter
+    //xmlns:fes="http://www.opengis.net/fes/2.0"
+    //xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    //xsi:schemaLocation="http://www.opengis.net/fes/2.0
+    //http://schemas.opengis.net/filter/2.0.0/filterAll.xsd">
+    //<fes:PropertyIsLike wildCard="*" singleChar="#" escapeChar="!">
+    //<fes:ValueReference>LAST_NAME</fes:ValueReference>
+    //<fes:Literal>JOHN*</fes:Literal>
+    //</fes:PropertyIsLike>
+    //</fes:Filter>
+    */
+
+    int DmpGmlFilter::_PropertyParse(const std::string& ptreeName, boost::property_tree::ptree& ptree, int &isExpression, int isLike)
+    {
+
+        isExpression = 0;
+        string name = this->GetFieldName(ptreeName);
+        const char *p = name.c_str();
+        std::string value = ptree.get_value<std::string>();
+        if (p == 0 || p[0] == 0)
+        {
+            sql_ += "('";
+            sql_ += value;
+            sql_ += "')";
+            return 0;
+        }
+        if (0 == strcmp(p, "Literal"))
+        {
+            isExpression = 1;
+            if (isLike)
+            {
+                sql_ += "('%";
+                sql_ += value;
+                sql_ += "%')";
+            }
+            else
+            {
+                sql_ += "('";
+                sql_ += value;
+                sql_ += "')";
+            }
+            return 0;
+        }
+      /*  if (0 == strcmp(p, "PropertyName") || 0 == strcmp(p, "ValueReference"))
+        {
+            isExpression = 1;
+            //std::string s=n->value();
+            //s=this->td->GetFieldQuery(s);
+            _AppendProperty(sql, n->value()); //添加了一个字段?
+
+            sql = sql + "::varchar";
+            //sql+=n->value();
+            return 0;
+        }
+        if (0 == strcmp(p, "Add"))
+        {
+            isExpression = 1;
+            return _PropertyParse4(ptree, "+");
+        }
+        if (0 == strcmp(p, "Sub"))
+        {
+            isExpression = 1;
+            return _PropertyParse4(ptree, "-");
+        }
+        if (0 == strcmp(p, "Mul"))
+        {
+            isExpression = 1;
+            return _PropertyParse4(ptree, "*");
+        }
+        if (0 == strcmp(p, "Div"))
+        {
+            isExpression = 1;
+            return _PropertyParse4(ptree, "/");
+        }
+        if (0 == strcmp(p, "Function"))
+        {
+            isExpression = 1;
+            return _PropertyParseFunction(ptree);
+        }*/
+        return 0;
+    }
+}
\ No newline at end of file

+/**************************************************************************
+* file:              dmpgmlfilter.h
+
+* Author:            qingxiongf
+* Date:              2022-01-07 14:43:56
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpgmlfilter_h__
+#define __dmpgmlfilter_h__
+
+#include <boost/property_tree/ptree.hpp> 
+#include <boost/property_tree/xml_parser.hpp> 
+#include <boost/typeof/typeof.hpp>
+#include <string>
+#include "dmpwfsgmlobject.h"
+/*
+* 参考文献
+* https://www.mapserver.org/ogc/filter_encoding.html
+*/
+using namespace std;
+namespace DmpWfs
+{
+    class DmpGmlFilter
+    {
+
+    public:
+        DmpGmlFilter();
+        ~DmpGmlFilter();
+
+        bool Parse(const std::string &filter);
+    private:
+        int Error(int errorcode, const char* err);
+        std::string GetFieldName(const std::string& name);
+        int _All(const std::string &name, boost::property_tree::ptree &ptree);
+
+        int _PropertyIsNotEqualTo(boost::property_tree::ptree &ptree);
+
+        int _PropertyParse(const std::string& ptreeName, boost::property_tree::ptree &ptreeode, int &isExpression, int isLike = 0);
+        int _PropertyOneEqual(boost::property_tree::ptree &ptree, const char *type, int isLike = 0);
+
+    private:
+        std::string sql_;
+        /* data */
+    };
+}
+
+#endif // __dmpgmlfilter_h__

@@ -35,29 +35,18 @@ namespace DmpWfs
         this->resultType_ = resultType;
     }
 
-    void DmpSqlFactory::appendCondition(char *c)
-    {
-        if (condition.size() == 0)
-        {
-            condition = c;
-        }
-        else
-        {
-            condition += " and ";
-            condition += c;
-        }
-    }
 
-    void DmpSqlFactory::appendCondition(std::string &c)
+
+    void DmpSqlFactory::appendCondition(const std::string &c)
     {
-        if (condition.size() == 0)
+        if (condition_.size() == 0)
         {
-            condition = c;
+            condition_ = c;
         }
         else
         {
-            condition += " and ";
-            condition += c;
+            condition_ += " and ";
+            condition_ += c;
         }
     }
 
@@ -70,27 +59,27 @@ namespace DmpWfs
         }
         else
         {
-            if (this->prop.size() == 0)
+            if (this->prop_.size() == 0)
             {
                 sql += "*";
             }
             else
-                sql += this->prop;
+                sql += this->prop_;
         }
         sql += " from \"";
-        sql += this->table;
+        sql += this->table_;
         sql += "\" where ";
-        if (this->condition.size() == 0)
+        if (this->condition_.size() == 0)
         {
             sql += "1=1";
         }
         else
         {
-            sql += this->condition;
+            sql += this->condition_;
         }
-        if (this->order.size() > 0)
+        if (this->order_.size() > 0)
         {
-            sql += this->order;
+            sql += this->order_;
         }
 
         if (count_ <= 0)
@@ -100,10 +89,12 @@ namespace DmpWfs
         if (count_ > 0 || startIndex_ > 0)
         {
             char sz[100];
-            sprintf(sz, " limit %ld offset %ld", count_, startIndex_);
+            sprintf(sz, " limit %d offset %d", count_, startIndex_);
             sql += sz;
         }
         return sql;
     }
 
+ 
+
 }
\ No newline at end of file

@@ -20,15 +20,17 @@ namespace DmpWfs
         ~DmpSqlFactory(void);
 
         void setStartIndexCount(int startIndex, int count, const std::string &resultType);
-        void appendCondition(std::string &c);
-        void appendCondition(char *c);
+        void appendCondition(const std::string &c);
+        void setProp(const std::string& prop) { prop_ = prop; } 
+        void setTable(const std::string& table){ table_ = table; }
+        void setOrder(const std::string& order){ order_ = order; }
         std::string getSql();
     
     private:
-        std::string prop;
-        std::string condition;
-        std::string order;
-        std::string table;
+        std::string prop_;
+        std::string condition_;
+        std::string order_;
+        std::string table_;
 
         std::string resultType_;
         int startIndex_;

@@ -52,7 +52,7 @@ namespace DmpWfs
       {
          writeGetCapabilities(context,params, project); 
       }
-      else if(boost::iequals(request, "getmap"))
+      else if(boost::iequals(request, "getfeature"))
       {
          writeGetFeature(context,params, project);
       } 

@@ -6,15 +6,1615 @@
 * Email:             qingxiongf@chinadci.com
 * copyright:         广州城市信息研究所有限公司
 ***************************************************************************/
+
 #include "dmpwfsfilter.h"
+#include <boost/algorithm/string/predicate.hpp>
+
 namespace DmpWfs
 {
-       
-    dmpwfsfilter::dmpwfsfilter(/* args */)
+    DmpWfsFilter::DmpWfsFilter(/* args */)
     {
     }
     
-    dmpwfsfilter::~dmpwfsfilter()
+    DmpWfsFilter::~DmpWfsFilter()
+    {
+    }
+
+    bool DmpWfsFilter::Parse(const std::string& filter)
+    {
+        try
+        {
+            std::stringstream stream(filter);
+            boost::property_tree::ptree ptree;
+            boost::property_tree::read_xml(stream, ptree);
+            boost::property_tree::ptree::iterator ptroot = ptree.begin();
+
+            if( ptroot !=ptree.end() && (boost::iequals(ptroot->first,"fes:Filter")|| boost::iequals(ptroot->first,"Filter") || boost::iequals(ptroot->first,"ogc:Filter")))
+            {
+                bool isFirst = true;
+                
+                for (boost::property_tree::ptree::iterator ptchild = ptroot->second.begin(); ptchild != ptroot->second.end(); ++ptchild)
+                {
+                    if (!isFirst)
+                    {
+                        sql_ += " or ";
+                    }
+                    int k = _All(ptchild->first, ptchild->second);
+                }
+            }
+        }
+        catch (const std::exception &e)
+        {
+            
+        }
+        return false;
+    }
+
+    bool DmpWfsFilter::ParseOrder(const std::string& orderby)
+    {
+        return false;
+    }
+
+    std::string DmpWfsFilter::GetFieldName(const std::string& name)
+    {
+        int len = name.size();
+        char p[100];
+        strcpy(p, name.c_str());
+        for (int i = 0; i < len; i++)
+        {
+            if (name[i] == ':')
+            {
+                strcpy(p, &name[i + 1]);
+                len = strlen(p);
+                break;
+            }
+        }
+        std::string str = p;
+        return str;
+    }
+
+    int DmpWfsFilter::_All(const std::string &ptname,boost::property_tree::ptree& ptree)
+    {
+
+        std::string name = GetFieldName(ptname);
+        const char *p = name.c_str();
+
+        switch (name.length())
+        {
+        case 2:
+            if (0 == strcmp(p, "Or"))
+                return _Or(ptree);
+            break;
+        case 3:
+            if (0 == strcmp(p, "Not"))
+                return _Not(ptree);
+            if (0 == strcmp(p, "And"))
+                return _And(ptree);
+            break;
+        case 4:
+            if (0 == strcmp(p, "BBOX"))
+                return _BBOX(ptree);
+            break;
+        case 6:
+            if (0 == strcmp(p, "Equals"))
+                return _Equals(ptree);
+            if (0 == strcmp(p, "Beyond"))
+                return _Beyond(ptree);
+            if (0 == strcmp(p, "Within"))
+                return _Within(ptree);
+            break;
+        case 7:
+            if (0 == strcmp(p, "Crosses"))
+                return _Crosses(ptree);
+            if (0 == strcmp(p, "Touches"))
+                return _Touches(ptree);
+            if (0 == strcmp(p, "DWithin"))
+                return _DWithin(ptree);
+            break;
+        case 8:
+            if (0 == strcmp(p, "Contains"))
+                return _Contains(ptree);
+            if (0 == strcmp(p, "Overlaps"))
+                return _Overlaps(ptree);
+            if (0 == strcmp(p, "Disjoint"))
+                return _Disjoint(ptree);
+            break;
+        case 9:
+            if (0 == strcmp(p, "FeatureId"))
+                return _FeatureId(ptree);
+            break;
+        case 10:
+            if (0 == strcmp(p, "Intersects"))
+                return _Intersects(ptree);
+            if (0 == strcmp(p, "ResourceId"))
+                return _FeatureId(ptree);
+            break;
+        case 11:
+            if (0 == strcmp(p, "GmlObjectId"))
+                return _GmlObjectId(ptree);
+            if (0 == strcmp(p, "DIntersects"))
+                return _DIntersects(ptree);
+            break;
+        case 14:
+            if (0 == strcmp(p, "PropertyIsLike"))
+                return _PropertyIsLike(ptree);
+            if (0 == strcmp(p, "PropertyIsNull"))
+                return _PropertyIsNull(ptree);
+            if (0 == strcmp(p, "fes:ResourceId") || 0 == strcmp(p, "ogc:ResourceId"))
+                return _FeatureId(ptree);
+            break;
+        case 17:
+            if (0 == strcmp(p, "PropertyIsBetween"))
+                return _PropertyIsBetween(ptree);
+            if (0 == strcmp(p, "PropertyIsEqualTo"))
+                return _PropertyIsEqualTo(ptree);
+            break;
+        case 18:
+            if (0 == strcmp(p, "PropertyIsLessThan"))
+                return _PropertyIsLessThan(ptree);
+            break;
+        case 20:
+            if (0 == strcmp(p, "PropertyIsNotEqualTo"))
+                return _PropertyIsNotEqualTo(ptree);
+            break;
+        case 21:
+            if (0 == strcmp(p, "PropertyIsGreaterThan"))
+                return _PropertyIsGreaterThan(ptree);
+            break;
+        case 27:
+            if (0 == strcmp(p, "PropertyIsLessThanOrEqualTo"))
+                return _PropertyIsLessThanOrEqualTo(ptree);
+            break;
+        case 30:
+            if (0 == strcmp(p, "PropertyIsGreaterThanOrEqualTo"))
+                return _PropertyIsGreaterThanOrEqualTo(ptree);
+            break;
+        default:
+            break;
+        }
+        sql_ += "1=1";
+        error_ = "Filter type error: ";
+        error_ += p;
+        return -17;
+    }
+
+    int DmpWfsFilter::_Or(boost::property_tree::ptree& ptree)
+    {
+        int nc = 0;
+        sql_ += "(";
+        for (auto ptchild =ptree.begin(); ptchild != ptree.end(); ++ptchild)
+        {
+            if (nc)
+            {
+                sql_ += " or ";
+            }
+            sql_ += "(";
+            int k = _All(ptchild->first, ptchild->second);
+            sql_ += ")";
+            nc++;
+        }
+        sql_ += ")";
+        return 0;
+    }
+    int DmpWfsFilter::_Not(boost::property_tree::ptree& ptree)
+    {
+        sql_ += "not (";
+        auto ptchild = ptree.begin();
+      //  xml_node<char> *node = n->first_node();
+        _All(ptchild->first, ptchild->second);
+        sql_ += ")";
+        return 0;
+    }
+    int DmpWfsFilter::_And(boost::property_tree::ptree& ptree)
+    {
+        int nc = 0;
+        sql_ += "(";
+        for (auto ptchild =ptree.begin(); ptchild != ptree.end(); ++ptchild)
+        {
+            if (nc)
+            {
+                sql_ += " and ";
+            }
+            sql_ += "(";
+            int k =  _All(ptchild->first, ptchild->second);
+            sql_ += ")";
+            nc++;
+        }
+        sql_ += ")";
+        return 0;
+    }
+    int DmpWfsFilter::_BBOX(boost::property_tree::ptree& ptree)
+    {
+        {
+           
+
+           // xml_node<char> *node = n->first_node("PropertyName");
+           // if (node == 0)
+           //    return -1;
+           // GetQueryField(propertyName.c_str());
+        }
+        std::string propertyName = ptree.get<std::string>("PropertyName");
+        const char *v = propertyName.c_str();
+
+        //从FILTER中得到了两个坐标点，构造一个POLYGON?
+        double x1, y1, x2, y2;
+        int re;
+
+        boost::property_tree::ptree ptEnvelope = ptree.get_child("Envelope");
+       // xml_node<char> *e = n->first_node("Envelope");
+       // if (e == 0)
+       //     e = n->first_node("Box");
+      //  if (ptEnvelope)
+        {
+            re = pEnvelope(ptEnvelope, &x1, &y1, &x2, &y2);
+        }
+       // else
+        {
+           // re = pEnvelope(n, &x1, &y1, &x2, &y2);
+        }
+        if (re)
+            return -1;
+
+        //	the_geom && 'BOX3D(90900 190900, 100100 200100)'::box3d
+        char s[1000];
+        std::string ss;
+       // ConnClassAll::GetBBox(x1, y1, x2, y2, fieldTemp, (char *)srs.c_str(), this->DatabaseType, ss);
+        sql_ += ss;
+        return 0;
+    }
+    int DmpWfsFilter::_Equals(boost::property_tree::ptree& ptree)
+    {
+        return pGeometrySql("st_equals", "EQUAL", 0, ptree, false); //得到了一条SQL语句
+    }
+    int DmpWfsFilter::_Beyond(boost::property_tree::ptree& ptree)
+    {
+        return pGeometrySql("st_disjoint", "DISJOINT", 1, ptree, true);
+    }
+    int DmpWfsFilter::_Within(boost::property_tree::ptree& ptree)
+    {
+        return pGeometrySql("st_within", "INSIDE", 0, ptree, false);
+    }
+    int DmpWfsFilter::_Crosses(boost::property_tree::ptree& ptree)
+    {
+        return pGeometrySql("st_crosses", "ANYINTERACT", 0, ptree, false);
+    }
+    int DmpWfsFilter::_Touches(boost::property_tree::ptree& ptree)
+    {
+        return pGeometrySql("st_touches", "TOUCH", 0, ptree, false);
+    }
+    int DmpWfsFilter::_DWithin(boost::property_tree::ptree& ptree)
+    {
+        return pGeometrySql("ST_DWithin", "INSIDE", 0, ptree, true);
+    }
+    int DmpWfsFilter::_Contains(boost::property_tree::ptree& ptree)
+    {
+        return pGeometrySql("st_contains", "CONTAINS", 0, ptree, false);
+    }
+    int DmpWfsFilter::_Overlaps(boost::property_tree::ptree& ptree)
+    {
+        return pGeometrySql("st_overlaps", "OVERLAPBDYDISJOINT+OVERLAPBDYINTERSECT", 0, ptree, false);
+    }
+    int DmpWfsFilter::_Disjoint(boost::property_tree::ptree& ptree)
+    {
+        return pGeometrySql("st_disjoint", "DISJOINT", 1, ptree, false);
+    }
+    int DmpWfsFilter::_FeatureId(boost::property_tree::ptree& ptree)
+    {
+        std::string str = ptree.get<std::string>("<xmlattr>.fid");
+       /* xml_attribute<char> *a = n->first_attribute("fid");
+        if (a == 0)
+        {
+            a = n->first_attribute("rid");
+        }
+        if (a)
+        {
+            std::string s = a->value();
+            int at = s.find(".");
+            if (at != string::npos)
+                s = s.substr(at + 1);
+            sql = sql + initConfig.GetGID(DatabaseType) + "='" + s + "'";
+        }*///
+        //<FeatureId fid=\"TREESA_1M.9012\"/> \
+
+        return 0;
+    }
+    int DmpWfsFilter::_Intersects(boost::property_tree::ptree& ptree)
+    {
+        //return pGeometrySql("st_intersection","ANYINTERACT",0,n,false);
+        return pGeometrySql("ST_Intersects", "ANYINTERACT", 0, ptree, false);
+    }
+
+    int DmpWfsFilter::_DIntersects(boost::property_tree::ptree& ptree)
+    {
+        //return pGeometrySql("st_intersection","ANYINTERACT",0,n,true);
+        return pGeometrySql("ST_Intersects", "ANYINTERACT", 0, ptree, true);
+    }
+
+    int DmpWfsFilter::_GmlObjectId(boost::property_tree::ptree& ptree)
+    {
+        return 0;
+    }
+    int DmpWfsFilter::_PropertyIsLike(boost::property_tree::ptree& ptree)
+    {
+        char wildCard = '*';
+        char singleCard = '.';
+        char escapeCard = '!';
+        //首先取得用户指定的通配符，并进行适当的转换
+      /*  xml_attribute<char> *attrWildCard = n->first_attribute("wildCard");
+        xml_attribute<char> *attrSingleCard = n->first_attribute("singleChar");
+        xml_attribute<char> *attrEscapeCard = n->first_attribute("escape");
+        if (attrWildCard)
+            wildCard = ((char *)attrWildCard->value())[0];
+        if (attrSingleCard)
+            singleCard = ((char *)attrSingleCard->value())[0];
+        if (attrEscapeCard)
+            escapeCard = ((char *)attrEscapeCard->value())[0];
+
+        xml_node<char> *node = n->first_node2("ValueReference", "PropertyName");
+        if (node == 0)
+            return Error(-15, "no enough expression");
+        _AppendProperty(sql, node->value());
+        if (DatabaseTypePostgreSQL == this->DatabaseType)
+        {
+            sql = sql + "::varchar";
+        }
+        sql_ += " LIKE ";
+        node = n->first_node("Literal");
+        if (node == 0)
+            return Error(-15, "no Literal expression");
+        char *valueTem = node->value();
+        DmapDll::StringHelp::ReplaceWildCards(valueTem, wildCard, singleCard, escapeCard);
+        sql_ += "'";
+        sql_ += valueTem;
+        sql_ += "'";
+        if (escapeCard != '!')
+        {
+            sql_ += " ESCAPE ";
+            sql_ += "'";
+            sql_ += escapeCard;
+            sql_ += "'";
+        }*///
+
+        return 0;
+        //return _PropertyOneEqual(n," like",1);
+    }
+    int DmpWfsFilter::_PropertyIsNull(boost::property_tree::ptree& ptree)
+    {
+        int isExpression;
+        for (auto ptchild =ptree.begin(); ptchild != ptree.end(); ++ptchild)
+        {
+            if(ptchild->first == "<xmlattr>")continue;
+            int r = _PropertyParse(ptchild->first,ptchild->second, isExpression);
+            if (r)
+                return r;
+            if (isExpression)
+            {
+                sql_ += " is null";
+            }
+            return 0;
+        }
+        return Error(-24, "_PropertyIsNull node missing");
+    }
+
+    int DmpWfsFilter::_PropertyIsBetween(boost::property_tree::ptree& ptree)
+    {
+        int isExpression, nc = 0;
+        //sql+="(";
+        for (auto ptchild =ptree.begin(); ptchild != ptree.end(); ++ptchild)
+        {
+            if(ptchild->first == "<xmlattr>")continue;
+            int r = _PropertyParse(ptchild->first, ptchild->second, isExpression);
+            if (r)
+                return r;
+            if (isExpression)
+            {
+                nc++;
+                break;
+            }
+        }
+        if (nc == 0)
+            return Error(-23, "no Property node");
+
+        sql_ += " between ";
+       /* {
+            xml_node<char> *node = n->first_node("LowerBoundary");
+            if (node == 0 || node->first_node() == 0)
+                return Error(-22, "no LowerBoundary node");
+            _PropertyParse(node->first_node(), isExpression);
+        }
+        sql_ += " and ";
+        {
+            xml_node<char> *node = n->first_node("UpperBoundary");
+            if (node == 0 || node->first_node() == 0)
+                return Error(-24, "no UpperBoundary node");
+            int isExpression;
+            _PropertyParse(ptchild->first, ptchild->second, isExpression);
+        }qingxiongf*/
+        //sql+=")";
+        return 0;
+    }
+    int DmpWfsFilter::_PropertyOneEqual(boost::property_tree::ptree& ptree,const char *type, int isLike)
+    {
+        int nc = 0, isExpression;
+        for (auto ptchild =ptree.begin(); ptchild != ptree.end(); ++ptchild)
+        {
+             if(ptchild->first == "<xmlattr>")continue;
+            int r = _PropertyParse(ptchild->first,ptchild->second, isExpression, isLike); //这里IsLike设定的值是1
+            if (r)
+                return r;
+            if (isExpression)
+            {
+                if (nc == 0)
+                {
+                    sql_ += type;
+                }
+                nc++;
+                if (nc == 2)
+                    return 0;
+            }
+        }
+        if (nc < 2)
+            return Error(-19, "no enough expression");
+        return 0;
+    }
+    int DmpWfsFilter::_PropertyIsEqualTo(boost::property_tree::ptree& ptree)
+    {
+        return _PropertyOneEqual(ptree, "=");
+    }
+    int DmpWfsFilter::_PropertyParse4(boost::property_tree::ptree& ptree,const char *f)
+    {
+        int nc = 0, isExpression;
+        sql_ += "(";
+        for (auto ptchild =ptree.begin(); ptchild != ptree.end(); ++ptchild)
+        {
+             if(ptchild->first == "<xmlattr>")continue;
+            int r = _PropertyParse(ptchild->first, ptchild->second, isExpression);
+            if (r)
+                return r;
+            if (isExpression)
+            {
+                if (nc == 0)
+                {
+                    sql_ += f;
+                }
+                nc++;
+                if (nc == 2)
+                {
+                    sql_ += ")";
+                    return 0;
+                }
+            }
+        }
+        if (nc < 2)
+            return Error(-19, "no enough expression");
+
+        return 0;
+    }
+    int DmpWfsFilter::_PropertyParseFunction(boost::property_tree::ptree& ptree)
+    {
+        {
+            std::string pattr_name = ptree.get<std::string>("<xmlattr>.name");
+            // xml_attribute<char> *nameNode = n->first_attribute("name");
+            //if (pattr == ptree.end())
+            //    return Error(-20, "no function name node");
+            // char *a = nameNode->value();
+            if (pattr_name == "")
+                return Error(-21, "no function name");
+            sql_ += pattr_name;
+        }
+
+        int isExpression;
+        sql_ += "(";
+        for (auto ptchild =ptree.begin(); ptchild != ptree.end(); ++ptchild)
+        {
+            int r = _PropertyParse(ptchild->first, ptchild->second, isExpression);
+            if (r)
+                return r;
+            if (isExpression)
+            {
+                sql_ += ",";
+            }
+        }
+
+        sql_[sql_.size() - 1] = ')';
+        //sql+=")";
+        return 0;
+    }
+    void DmpWfsFilter::_AppendProperty(std::string &sql, const char *str)
+    {
+       //sql_ += "\"";
+            sql_ += str;
+            //sql_ += "\"";
+    }
+
+    //<fes:Filter
+    //xmlns:fes="http://www.opengis.net/fes/2.0"
+    //xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    //xsi:schemaLocation="http://www.opengis.net/fes/2.0
+    //http://schemas.opengis.net/filter/2.0.0/filterAll.xsd">
+    //<fes:PropertyIsLike wildCard="*" singleChar="#" escapeChar="!">
+    //<fes:ValueReference>LAST_NAME</fes:ValueReference>
+    //<fes:Literal>JOHN*</fes:Literal>
+    //</fes:PropertyIsLike>
+    //</fes:Filter>
+
+    //我感觉这里应该有一个通配符的转换
+    int DmpWfsFilter::_PropertyParse(const std::string& ptreeName, boost::property_tree::ptree& ptree, int &isExpression, int isLike)
+    {
+        isExpression = 0;
+        string name = this->GetFieldName(ptreeName);
+        const char *p = name.c_str();
+        std::string value = ptree.get_value<std::string>();
+        if (p == 0 || p[0] == 0)
+        {
+            sql_ += "('";
+            sql_ += value;
+            sql_ += "')";
+            return 0;
+        }
+        if (0 == strcmp(p, "Literal"))
+        {
+            isExpression = 1;
+            if (isLike)
+            {
+                sql_ += "('%";
+                sql_ += value;
+                sql_ += "%')";
+            }
+            else
+            {
+                sql_ += "('";
+                sql_ += value;
+                sql_ += "')";
+            }
+            return 0;
+        }
+        if (0 == strcmp(p, "PropertyName") || 0 == strcmp(p, "ValueReference"))
+        {
+            isExpression = 1;
+            //std::string s=n->value();
+            //s=this->td->GetFieldQuery(s);
+            _AppendProperty(sql_,value.c_str()); //添加了一个字段?
+
+            sql_ = sql_ + "::varchar";
+            //sql+=n->value();
+            return 0;
+        }
+        if (0 == strcmp(p, "Add"))
+        {
+            isExpression = 1;
+            return _PropertyParse4(ptree, "+");
+        }
+        if (0 == strcmp(p, "Sub"))
+        {
+            isExpression = 1;
+            return _PropertyParse4(ptree, "-");
+        }
+        if (0 == strcmp(p, "Mul"))
+        {
+            isExpression = 1;
+            return _PropertyParse4(ptree, "*");
+        }
+        if (0 == strcmp(p, "Div"))
+        {
+            isExpression = 1;
+            return _PropertyParse4(ptree, "/");
+        }
+        if (0 == strcmp(p, "Function"))
+        {
+            isExpression = 1;
+            return _PropertyParseFunction(ptree);
+        }
+        return 0;
+    }
+    int DmpWfsFilter::_PropertyIsLessThan(boost::property_tree::ptree& ptree)
+    {
+        return _PropertyOneEqual(ptree, "<");
+    }
+    int DmpWfsFilter::_PropertyIsNotEqualTo(boost::property_tree::ptree& ptree)
+    {
+        return _PropertyOneEqual(ptree, "<>");
+    }
+    int DmpWfsFilter::_PropertyIsGreaterThan(boost::property_tree::ptree& ptree)
+    {
+        return _PropertyOneEqual(ptree, ">");
+    }
+    int DmpWfsFilter::_PropertyIsLessThanOrEqualTo(boost::property_tree::ptree& ptree)
+    {
+        return _PropertyOneEqual(ptree, "<=");
+    }
+    int DmpWfsFilter::_PropertyIsGreaterThanOrEqualTo(boost::property_tree::ptree& ptree)
     {
+        return _PropertyOneEqual(ptree, ">=");
+    }
+
+    void DmpWfsFilter::pParsesrsName(boost::property_tree::ptree& ptree)
+    {
+       // xml_attribute<char> *sr = n->first_attribute("srsName");
+        /*std::string  atrr = ptree.get<std::string>("srsName");
+        if (!atrr.empty())
+        {
+            char *s = _strdup(sr->value());
+            clsMalloc m(s);
+            if (s == 0 || s[0] == 0)
+                return;
+            char *ss[10];
+            int n = DmapDll::StringHelp::ParseStringTok(s, '#', ss, 10);
+            char *sa = ss[n - 1];
+            int len = strlen(sa);
+            for (int i = 0; i < len; i++)
+            {
+                if (sa[i] == '_')
+                    sa[i] = ':';
+            }
+            n = DmapDll::StringHelp::ParseStringTok(sa, ':', ss, 10);
+            //parse epsg:5432
+            sa = ss[n - 1];
+            strcpy_s((char *)srs.c_str(), sa);
+        } qingxiongf*/
+       
+    }
+    int DmpWfsFilter::pEnvelope(boost::property_tree::ptree& ptree, double *x1, double *y1, double *x2, double *y2)
+    {
+       /* xml_node<char> *node = n->first_node("lowerCorner"); //,"ogc:PropertyName");
+        if (node)
+        {
+            xml_node<char> *node1 = n->first_node("upperCorner"); //,"ogc:PropertyName");
+            if (!node1)
+                return this->Error(-2, "upperCorner missing");
+            sscanf(node->value(), "%lf %lf", x1, y1);
+            sscanf(node1->value(), "%lf %lf", x2, y2);
+            return 0;
+        }
+        else
+        {
+            std::vector<double> v;
+            int rt = pGeometryPointArray(n, v);
+            if (rt)
+                return rt;
+            if (v.size() < 4)
+                return Error(-16231, "point array too small");
+
+            //这里不太好吧，只要有个不合法的请求就会死掉
+            *x1 = v[0];
+            *y1 = v[1];
+            *x2 = v[2];
+            *y2 = v[3];
+            return 0;
+        }
+       qingxiongf*/
+
+        return Error(-4214, "envope parse error");
+    }
+
+ 
+
+    //这个函数是对数字进行解析(前到空格去掉，后面的空格可以作为结束标志。。。)
+    int DmpWfsFilter::pGeometryDouble(char *d, bool space_before, bool space_after, double &dbl)
+    {
+        char *p;
+        int st;
+        enum states //用来维护状态
+        {
+            INIT = 0,
+            NEED_DIG = 1,
+            DIG = 2,
+            NEED_DIG_DEC = 3,
+            DIG_DEC = 4,
+            EXP = 5,
+            NEED_DIG_EXP = 6,
+            DIG_EXP = 7,
+            END = 8
+        };
+
+        //下面这段代码主要是进行了所传数字有效性的验证吧？
+        if (space_before)
+            while (isspace(*d))
+                d++; //再次的消除空格
+        for (st = INIT, p = d; *p; p++)
+        {
+
+            if (isdigit(*p))
+            {
+                if (st == INIT || st == NEED_DIG)
+                    st = DIG; //刚开始或者是期望是数字,转换为是数字
+                else if (st == NEED_DIG_DEC)
+                    st = DIG_DEC; //期望是小数，转化为时小数
+                else if (st == NEED_DIG_EXP || st == EXP)
+                    st = DIG_EXP; //已经是一个科学计数法，或者期望是一个科学计数法
+                else if (st == DIG || st == DIG_DEC || st == DIG_EXP)
+                    ; //已经是数字，小数，科学计数法，则不做转换
+                else
+                    return Error(-4, "invalid digital");
+            }
+            else if (*p == '.')
+            {
+                if (st == DIG)
+                    st = NEED_DIG_DEC; //从数字转换到期望是小数的状态（否则出错）
+                else
+                    return Error(-4, "invalid digital");
+            }
+            else if (*p == '-' || *p == '+')
+            {
+                if (st == INIT)
+                    st = NEED_DIG;
+                else if (st == EXP)
+                    st = NEED_DIG_EXP;
+                else
+                    return Error(-4, "invalid digital");
+            }
+            else if (*p == 'e' || *p == 'E') //科学计数法
+            {
+                if (st == DIG || st == DIG_DEC)
+                    st = EXP;
+                else
+                    return Error(-4, "invalid digital");
+            }
+            else if (isspace(*p))
+            {
+                if (!space_after)
+                    return Error(-4, "invalid digital");
+                if (st == DIG || st == DIG_DEC || st == DIG_EXP)
+                    st = END;
+                else if (st == NEED_DIG_DEC)
+                    st = END;
+                else if (st == END)
+                    ;
+                else
+                    return Error(-4, "invalid digital");
+            }
+            else
+                return Error(-4, "invalid digital");
+        }
+
+        if (st != DIG && st != NEED_DIG_DEC && st != DIG_DEC && st != DIG_EXP && st != END)
+            return Error(-4, "invalid digital");
+        dbl = atof(d);
+        return 0;
+    }
+
+    //这个函数写的很棒啊。。。
+    int DmpWfsFilter::pGeometryPointValuePos(char *pos, std::vector<double> &v)
+    {
+        while (isspace(*pos))
+            pos++; /* Eat extra whitespaces if any */ //跳过空格
+        /* gml:pos pattern: 	x1 y1
+		 * 			x1 y1 z1
+		 */
+        int gml_dim = 0;
+        bool digit = false;
+        double dbl;
+        for (char *p = pos; *pos; pos++)
+        {
+            if (isdigit(*pos))
+                digit = true;
+            if (digit && (*pos == ' ' || *(pos + 1) == '\0'))
+            {
+                if (*pos == ' ')
+                    *pos = '\0';
+                gml_dim++;
+                if (gml_dim == 1)
+                {
+                    int rt = pGeometryDouble(p, true, true, dbl);
+                    if (rt)
+                        return rt;
+                    v.push_back(dbl);
+                }
+                else if (gml_dim == 2)
+                {
+                    int rt = pGeometryDouble(p, true, true, dbl);
+                    if (rt)
+                        return rt;
+                    v.push_back(dbl);
+                }
+                else if (gml_dim == 3)
+                {
+                }
+                //	pt.z = parse_gml_double(p, true, true);
+                p = pos + 1;
+                digit = false;
+            }
+        }
+
+        return 0;
+    }
+
+    int DmpWfsFilter::pGeometryPointValuePosList(boost::property_tree::ptree& ptree, std::vector<double> &v)
+    {
+      /*  int dim = 2;
+        xml_attribute<char> *pn = n->first_attribute("dimension");
+        if (pn)
+        {
+            dim = atoi(pn->value());
+        }
+        if (dim > 3 || dim < 2)
+            return Error(-6, "dim >3 or dim<2");
+        char *poslist = (char *)n->value();
+        while (isspace(*poslist))
+            poslist++;
+        double dbl;
+        int gml_dim = 0; //跳过空格
+        for (char *p = poslist, digit = false; *poslist; poslist++)
+        {
+            if (isdigit(*poslist))
+                digit = true;
+            //以空格分割
+            if (digit && (*poslist == ' ' || *(poslist + 1) == '\0'))
+            {
+                if (*poslist == ' ')
+                    *poslist = '\0';
+
+                gml_dim++;
+                if (gml_dim == 1)
+                {
+                    int rt = pGeometryDouble(p, true, true, dbl);
+                    if (rt)
+                        return rt;
+                    v.push_back(dbl);
+                }
+                else if (gml_dim == 2)
+                {
+                    int rt = pGeometryDouble(p, true, true, dbl);
+                    if (rt)
+                        return rt;
+                    v.push_back(dbl);
+                }
+                //else if (gml_dim == 3) pt.z = parse_gml_double(p, true, true);
+
+                if (gml_dim == dim)
+                {
+                    gml_dim = 0;
+                }
+                else if (*(poslist + 1) == '\0')
+                {
+                    return Error(-7, "char missing");
+                }
+
+                p = poslist + 1;
+                digit = false;
+            }
+        }qingxiongf*/
+        return 0;
+    }
+  
+    int DmpWfsFilter::pGeometryGetDis(boost::property_tree::ptree& ptree, double &dis)
+    {
+      /*
+
+        double ratio = 1;
+        {
+            rapidxml::xml_attribute<char> *t = n->first_attribute("unit");
+            if (t)
+            {
+                char *p = t->value();
+                size_t size = strlen(p);
+                int found = 0;
+                for (size_t i = size - 1; i >= 0; i--)
+                {
+                    if (p[i] == '#')
+                    {
+                        found = 1;
+                        p += i + 1;
+                        break;
+                    }
+                }
+                if (strcmp(p, "kilometers") == 0)
+                {
+                    ratio = 1000;
+                }
+                else if (strcmp(p, "kilometer") == 0)
+                {
+                    ratio = 1000;
+                }
+            }
+        }
+
+        double f = atof(n->value());
+        f = f * ratio;
+
+        dis = f;
+        //	rapidxml::xml_node<char> * t=n->first_node("X");
+qingxiongf*/
+        return 0;
+    }
+
+   void DmpWfsFilter::GetQueryField(std::string &field)
+    {
+       return ;
+    }
+
+    int DmpWfsFilter::Error(int code, const char *err)
+    {
+        error_ = err;
+        errorCode_ = code;
+        return code;
+    }
+
+    int DmpWfsFilter::pGeometrySql(const char *function,const char *oracle_mask, int isDisjoin, boost::property_tree::ptree &ptree, bool useBuffer)
+    {
+        {
+            std::string value = ptree.get<std::string>("PropertyName.ValueReference");
+           // xml_node<char> *nodeP = n->first_node2("PropertyName", "ValueReference"); //,"ogc:PropertyName");
+            //if (nodeP == 0 || nodeP->value()[0] == 0)
+            //    return Error(-15, "no PropertyName node");
+            GetQueryField(value);
+        }
+        double dis;
+        if (useBuffer)
+        {
+            boost::property_tree::ptree pDistance = ptree.get_child("Distance");
+           // xml_node<char> *nodeD = n->first_node("Distance"); //,"ogc:PropertyName");
+          //  if (nodeD == 0)
+           //     return Error(-15, "no Distance node");
+            int rt = pGeometryGetDis(pDistance, dis);
+            if (rt)
+                return Error(-15, "no Distance node");
+        }
+
+        std::string strOut;
+        double x1, y1, x2, y2;
+        int ee = GetGeomFromGml(ptree, strOut, x1, y1, x2, y2);
+        if (ee)
+            return Error(ee, "gml parse error");
+        if (useBuffer)
+        {
+            x1 -= dis;
+            y1 -= dis;
+            x2 += dis;
+            y2 += dis;
+        }
+
+        if (useBuffer)
+        {
+            if (strcmp(function, "ST_DWithin") == 0)
+            {
+                char sz[200];
+                sprintf(sz, "%lf", dis);
+                std::string s = strOut + ",";
+                s += sz;
+                strOut = s;
+            }
+            else
+            {
+                if (strcmp(function, "st_intersection") == 0)
+                {
+                    function = "st_intersects";
+                }
+
+                char sz[200];
+                sprintf(sz, "%lf", dis);
+                std::string s = "st_buffer(";
+                s = s + strOut;
+                s = s + ",";
+                s = s + sz;
+                s = s + ")";
+                strOut = s;
+            }
+        }
+        sql_ += function;
+        sql_ += "(";
+        {
+            std::string nameOut;
+           // ConnClassAll::GetSRIDName(fieldTemp, nameOut, (char *)srs.c_str(), this->DatabaseType);
+            sql_ += nameOut;
+        }
+        sql_ += ",";
+        sql_ += strOut;
+        sql_ += ")";
+
+        return 0;
+    }
+
+    /*
+    int DmpWfsFilter::pGeometryPointValueCoord(boost::property_tree::ptree& ptree, std::vector<double> &v)
+    {
+        double x, y;
+        rapidxml::xml_node<char> *t = n->first_node("X");
+        if (t == 0)
+            return Error(-9, "X node not found");
+        x = atof(t->value());
+        t = n->first_node("Y");
+        if (t == 0)
+            return Error(-10, "Y node not found");
+        y = atof(t->value());
+        v.push_back(x);
+        v.push_back(y);
+        return 0;
+    }
+    qingxiongf*/
+    /*
+    int DmpWfsFilter::pGeometryPointValuePointRep(boost::property_tree::ptree& ptree, std::vector<double> &v)
+    {
+        double x, y;
+        rapidxml::xml_node<char> *t = n->first_node("Point");
+        if (t == 0)
+            return Error(-9, "Point node not found");
+        t = t->first_node("pos");
+        if (t == 0)
+            return Error(-9, "pos node not found");
+        char *p = t->value();
+        sscanf(p, "%lf %lf", &x, &y);
+        v.push_back(x);
+        v.push_back(y);
+        return 0;
+    }
+qingxiongf*/
+    //来看看这个函数
+    int DmpWfsFilter::pGeometryPointValueCoordinates(char *p, std::vector<double> &v)
+    {
+        char cs, ts, dec;
+        cs = ',';
+        ts = ' ';
+        dec = '.';
+        bool digit;
+        int gml_dims;
+        while (isspace(*p))
+            p++;
+        char *q;
+        double dbl; //跳过空格
+        for (q = p, gml_dims = 0, digit = false; *p; p++)
+        {
+            if (isdigit(*p))
+                digit = true;
+            //逗号分割
+            if (*p == cs)
+            {
+                *p = '\0';
+                gml_dims++;
+
+                if (*(p + 1) == '\0')
+                    return Error(-8, "invalid gml");
+
+                if (gml_dims == 1)
+                {
+                    int rt = pGeometryDouble(q, false, true, dbl);
+                    if (rt)
+                        return rt;
+                    v.push_back(dbl);
+                }
+                else if (gml_dims == 2)
+                {
+                    int rt = pGeometryDouble(q, false, true, dbl);
+                    if (rt)
+                        return rt;
+                    v.push_back(dbl);
+                }
+
+                q = p + 1;
+            }
+            //空格分割...
+            else if (digit && (*p == ts || *(p + 1) == '\0'))
+            {
+                if (*p == ts)
+                    *p = '\0';
+                gml_dims++;
+
+                if (gml_dims < 2 || gml_dims > 3)
+                {
+                    return Error(-8, "invalid gml");
+                }
+
+                if (gml_dims == 3)
+                {
+                    int rt = pGeometryDouble(q, false, true, dbl);
+                    if (rt)
+                        return rt;
+                }
+                else
+                {
+                    int rt = pGeometryDouble(q, false, true, dbl);
+                    if (rt)
+                        return rt;
+                    v.push_back(dbl);
+                    //*hasz = false;
+                }
+
+                //	dynptarray_addPoint4d(dpa, &pt, 0);
+                digit = false;
+
+                q = p + 1;
+                gml_dims = 0;
+
+                /* Need to put standard decimal separator to atof handle */
+            }
+            else if (*p == dec && dec != '.')
+                *p = '.'; //处理小数
+        }
+        return 0;
+    }
+
+    //得到点数组
+    int DmpWfsFilter::pGeometryPointArray(boost::property_tree::ptree& ptree, std::vector<double> &v)
+    {
+        for (auto ptchild =ptree.begin(); ptchild != ptree.end(); ++ptchild)
+        {
+            std::string name = ptchild->first;
+
+            if (!strcmp((char *)name.c_str(), "pos") || !strcmp((char *)name.c_str(), "gml:pos")) //以空格分割的坐标数据
+            {
+                std::string value = ptchild->second.get_value<std::string>();
+                return pGeometryPointValuePos((char*)value.c_str(), v);
+            }
+            else if (!strcmp((char *)name.c_str(), "posList") || !strcmp((char *)name.c_str(), "gml:posList")) //有维度，以空格分割的坐标数据
+            {
+                return pGeometryPointValuePosList( ptchild->second, v);
+            }
+            else if (!strcmp((char *)name.c_str(), "coordinates") || !strcmp((char *)name.c_str(), "gml:coordinates")) //以空格或者逗号分割的数据
+            {
+                std::string value = ptchild->second.get_value<std::string>();
+                return pGeometryPointValueCoordinates((char*)value.c_str(), v);
+            }
+            else if (!strcmp((char *)name.c_str(), "coord") || !strcmp((char *)name.c_str(), "gml:coord")) //坐标，似乎只能得到一个点哦。。。
+            {
+                return pGeometryPointValueCoord(ptchild->second, v);
+            }
+            else if ((!strcmp((char *)name.c_str(), "pointRep")) || (!strcmp((char *)name.c_str(), "pointProperty")) || (!strcmp((char *)name.c_str(), "gml:pointRep")) || (!strcmp((char *)name.c_str(), "gml:pointProperty")))
+            {
+                return pGeometryPointValuePointRep(ptchild->second, v);
+            }
+        }
+        return Error(-10, "point node not exist");
+    }
+/*
+    int DmpWfsFilter::pGeometryEnvope(boost::property_tree::ptree& ptree, DmpWfsGmlObject **g)
+    {
+        pParsesrsName(n);
+        double x1, y1, x2, y2;
+        int re = pEnvelope(n, &x1, &y1, &x2, &y2);
+        if (re)
+            return Error(-25, "Envope error");
+        clsGmlBBox *mp = new clsGmlBBox(x1, y1, x2, y2);
+        *g = mp;
+        return 0;
+    }
+qingxingf*/
+/*
+    int DmpWfsFilter::pGeometryMultiPoint(boost::property_tree::ptree& ptree, DmpWfsGmlObject **g)
+    {
+        xml_node<char> *node;
+        clsGmlMultiPoint *mp = new clsGmlMultiPoint();
+        clsGmlPoint *l;
+        for (node = n->first_node2("pointMember", "pointMembers"); node; node = node->next_sibling2("pointMember", "pointMembers"))
+        {
+            rapidxml::xml_node<char> *t1 = node->first_node("Point");
+            if (t1 == 0)
+            {
+                delete mp;
+                return Error(-13, "no Point node");
+            }
+            int rt = pGeometryPoint(t1, (DmpWfsGmlObject **)(&l));
+            if (rt)
+            {
+                delete mp;
+                return rt;
+            }
+            mp->x.push_back(l->x);
+            mp->y.push_back(l->y);
+        }
+        if (mp->x.size() < 1)
+        {
+            delete mp;
+            return Error(-14, "no Point node");
+        }
+        *g = mp;
+        return 0;
+    }
+qingxingf*/
+/*
+    int DmpWfsFilter::pGeometryMultiPolyline(boost::property_tree::ptree& ptree, DmpWfsGmlObject **g)
+    {
+        xml_node<char> *node;
+        clsGmlPolyline *plyg = new clsGmlPolyline();
+        for (node = n->first_node("polylineMember"); node; node = node->next_sibling("polylineMember"))
+        {
+            xml_node<char> *nodeN;
+            for (nodeN = node->first_node("Polyline"); nodeN; nodeN = nodeN->next_sibling("Polyline"))
+            {
+                DmpWfsGmlObject *gT;
+                pGeometryPolyline(nodeN, &gT);
+                if (gT)
+                {
+                    plyg->Append((clsGmlPolyline *)gT);
+                    delete gT;
+                }
+            }
+        }
+        if (plyg->outer.size() < 1)
+        {
+            delete plyg;
+            return Error(-14, "no line string");
+        }
+        *g = plyg;
+        return 0;
+    }
+    qingxiongf*/
+/*
+    int DmpWfsFilter::pGeometryMultiPolygon(boost::property_tree::ptree& ptree, DmpWfsGmlObject **g)
+    {
+        xml_node<char> *node;
+        clsGmlPolygon *plyg = new clsGmlPolygon();
+        for (node = n->first_node2("polygonMember", "PolygonMember"); node; node = node->next_sibling2("polygonMember", "PolygonMember"))
+        {
+            xml_node<char> *nodeN;
+            for (nodeN = node->first_node("Polygon"); nodeN; nodeN = nodeN->next_sibling("Polygon"))
+            {
+                DmpWfsGmlObject *gT = NULL;
+                pGeometryPolygon(nodeN, &gT);
+                if (gT)
+                {
+                    plyg->Append((clsGmlPolygon *)gT);
+                    delete gT;
+                }
+            }
+        }
+
+        if (plyg->outer.size() < 1)
+        {
+            delete plyg;
+            return Error(-14, "no exterior ring");
+        }
+        *g = plyg;
+        return 0;
+    }
+    qingxingf*/
+    /*
+    int DmpWfsFilter::pGeometryPolygon(boost::property_tree::ptree& ptree, DmpWfsGmlObject **g)
+    {
+        xml_node<char> *node;
+        clsGmlPolygon *plyg = new clsGmlPolygon();
+        DmpWfsGmlObject *l;
+        for (node = n->first_node2("exterior", "outerBoundaryIs"); node; node = node->next_sibling2("exterior", "outerBoundaryIs"))
+        {
+            rapidxml::xml_node<char> *t1 = node->first_node("LinearRing");
+            if (t1 == 0)
+                t1 = node->first_node2("LineString", "lineString");
+            if (t1 == 0)
+            {
+                delete plyg;
+                return Error(-13, "no LineString node");
+            }
+            int rt = pGeometryLineString(t1, &l);
+            if (rt)
+            {
+                delete plyg;
+                return rt;
+            }
+            plyg->outer.push_back((clsGmlLineString *)l);
+        }
+        for (node = n->first_node2("interior", "innerBoundaryIs"); node; node = node->next_sibling2("interior", "innerBoundaryIs"))
+        {
+            rapidxml::xml_node<char> *t1 = node->first_node("LinearRing");
+            if (t1 == 0)
+                t1 = node->first_node2("LineString", "lineString");
+            if (t1 == 0)
+            {
+                delete plyg;
+                return Error(-13, "no LineString node");
+            }
+            int rt = pGeometryLineString(t1, &l);
+            if (rt)
+            {
+                delete plyg;
+                return rt;
+            }
+            plyg->inner.push_back((clsGmlLineString *)l);
+        }
+        if (plyg->outer.size() < 1)
+        {
+            delete plyg;
+            return Error(-14, "no exterior ring");
+        }
+
+        *g = plyg;
+        return 0;
+    }
+qingxingf*/
+/*
+    int DmpWfsFilter::pGeometryPolyline(boost::property_tree::ptree& ptree, DmpWfsGmlObject **g)
+    {
+        xml_node<char> *node;
+        clsGmlPolyline *plyg = new clsGmlPolyline();
+        DmpWfsGmlObject *l;
+        for (node = n->first_node2("lineStringMember", "gml::lineStringMember"); node; node = node->next_sibling2("lineStringMember", "gml::lineStringMember"))
+        {
+            rapidxml::xml_node<char> *t1 = node->first_node("LinearRing");
+            if (t1 == 0)
+                t1 = node->first_node2("LineString", "lineString");
+            if (t1 == 0)
+            {
+                delete plyg;
+                return Error(-13, "no LineString node");
+            }
+            int rt = pGeometryLineString(t1, &l);
+            if (rt)
+            {
+                delete plyg;
+                return rt;
+            }
+            plyg->outer.push_back((clsGmlLineString *)l);
+        }
+        if (plyg->outer.size() < 1)
+        {
+            delete plyg;
+            return Error(-14, "no linestring");
+        }
+        *g = plyg;
+        return 0;
+    }
+qingxingf*/
+    int DmpWfsFilter::pGeometryLineString(boost::property_tree::ptree& ptree, DmpWfsGmlObject **g)
+    {
+      /*
+        std::vector<double> v;
+        int rt = pGeometryPointArray(n, v);
+        if (rt)
+            return rt;
+        size_t vs = (size_t)v.size();
+        if (vs < 4)
+            return Error(-11, "point array too small");
+        size_t vs2 = vs / 2;
+        if ((2 * vs2) != vs)
+            return Error(-12, "point array error");
+
+        clsGmlLineString *l = new clsGmlLineString();
+        //l.size=
+        l->x.resize(vs2);
+        l->y.resize(vs2);
+        for (size_t i = 0, j = 0; i < vs2; i++)
+        {
+            l->x[i] = v[j];
+            j++;
+            l->y[i] = v[j];
+            j++;
+        }
+
+        *g = l; qingxiongf*/
+        return 0;
+    }
+/*
+    void DmpWfsFilter::parse_gml_srs(boost::property_tree::ptree& ptree, gmlSrs *srs)
+    {
+        char *p;
+        int is_planar;
+        bool latlon = false;
+        char sep = ':';
+
+        const char *srsname;
+        xml_attribute<char> *pn = n->first_attribute("srsName");
+        if (pn)
+        {
+            srsname = pn->value();
+        }
+        else
+        {
+            srs->srid = initConfig.DefaultSRID;
+            srs->reverse_axis = false;
+            return;
+        }
+
+        if (!strncmp((char *)srsname, "EPSG:", 5))
+        {
+            sep = ':';
+            latlon = false;
+        }
+        else if (!strncmp((char *)srsname, "urn:ogc:def:crs:EPSG:", 21) || !strncmp((char *)srsname, "urn:x-ogc:def:crs:EPSG:", 23) || !strncmp((char *)srsname, "urn:EPSG:geographicCRS:", 23))
+        {
+            sep = ':';
+            latlon = true;
+        }
+        else if (!strncmp((char *)srsname,
+                          "http://www.opengis.net/gml/srs/epsg.xml#", 40))
+        {
+            sep = '#';
+            latlon = false;
+        }
+        else
+        {
+            srs->srid = initConfig.DefaultSRID;
+            srs->reverse_axis = false;
+            return;
+        }
+
+        
+        for (p = (char *)srsname; *p; p++)
+            ;
+        for (--p; *p != sep; p--)
+        {
+            if (!isdigit(*p))
+            {
+                srs->srid = initConfig.DefaultSRID;
+                srs->reverse_axis = false;
+                return;
+            }
+        }
+
+        srs->srid = p;
+        p++; // atoi(++p);
+        int id = atoi(srs->srid.c_str());
+        return;
+    }
+
+    int DmpWfsFilter::pGeometryPoint(boost::property_tree::ptree& ptree, DmpWfsGmlObject **g)
+    {
+        std::vector<double> v;
+        int rt = pGeometryPointArray(n, v);
+        if (rt)
+            return rt;
+        if (v.size() < 2)
+            return Error(-10, "point array too small");
+        clsGmlPoint *p = new clsGmlPoint();
+        p->x = v[0];
+        p->y = v[1];
+        *g = p;
+        return 0;
+    }
+    int DmpWfsFilter::pGeometry(boost::property_tree::ptree& ptree, DmpWfsGmlObject **g)
+    {
+        rapidxml::xml_node<char> *t;
+        //这种方式更好
+        //for (auto ptchild =ptree.begin(); ptchild != ptree.end(); ++ptchild);
+
+        t = n->first_node2("Point", "gml:Point");
+        if (t)
+        {
+            pParsesrsName(t);
+            return pGeometryPoint(t, g);
+        }
+        t = n->first_node2("LineString", "gml:LineString");
+        if (t)
+        {
+            pParsesrsName(t);
+            return pGeometryLineString(t, g);
+        }
+        t = n->first_node2("Polygon", "MultiPolygonString");
+        t = t ? t : n->first_node2("gml:Polygon", "gml:MultiPolygonString");
+        if (t)
+        {
+            pParsesrsName(t);
+            return pGeometryPolygon(t, g);
+        }
+        t = n->first_node2("MultiPolygon", "gml:MultiPolygon");
+        if (t)
+        {
+            pParsesrsName(t);
+            return pGeometryMultiPolygon(t, g);
+        }
+        t = n->first_node2("Polyline", "MultiLineString");
+        t = t ? t : n->first_node2("gml:Polyline", "gml:MultiLineString");
+        if (t)
+        {
+            pParsesrsName(t);
+            return pGeometryPolyline(t, g);
+        }
+        t = n->first_node2("MultiPolyline", "gml:MultiPolyline");
+        if (t)
+        {
+            pParsesrsName(t);
+            return pGeometryMultiPolyline(t, g);
+        }
+        t = n->first_node2("Polyline", "MultiLine");
+        t = t ? t : n->first_node2("gml:Polyline", "gml:MultiLine");
+        if (t)
+        {
+            pParsesrsName(t);
+            return pGeometryPolyline(t, g);
+        }
+        t = n->first_node2("MultiPoint", "gml:MultiPoint");
+        if (t)
+        {
+            pParsesrsName(t);
+            return pGeometryMultiPoint(t, g);
+        }
+        t = n->first_node2("Envelope", "gml:Envelope");
+        if (t)
+        {
+            pParsesrsName(t);
+            return pGeometryEnvope(t, g);
+        }
+        t = n->first_node2("BBox", "gml:BBox");
+        if (t)
+        {
+            pParsesrsName(t);
+            return pGeometryEnvope(t, g);
+        }
+        return 0;
+    }
+  qingxionggf*/
+   /*
+    int DmpWfsFilter::ParseOrder(char *xml, void *tdp, int dtp)
+    {
+       err[0] = 0;
+        sql = "";
+        this->td = (TableDesc *)tdp;
+        this->DatabaseType = dtp;
+        try
+        {
+            xml_document<> doc; // character type defaults to char
+            doc.parse<0>(xml);
+            xml_node<char> *n = doc.first_node();
+            if (n == 0)
+            {
+                return Error(-12, "bad xml");
+            }
+            string name = this->GetFieldName(n->name());
+            const char *p = name.c_str();
+            if (strcmp(p, "SortBy"))
+                return Error(-12, "no filter node");
+            //sql="order by ";
+            int nc = 0; //<SortBy><SortProperty><ValueReference>OBJECTID</ValueReference><SortOrder>DESC</SortOrder></SortProperty><SortProperty><ValueReference>AREA</ValueReference><SortOrder>DESC</SortOrder></SortProperty></SortBy>
+            for (auto ptchild =ptree.begin(); ptchild != ptree.end(); ++ptchild)
+            {
+                if (strcmp(node->name(), "SortProperty") == 0)
+                {
+                    xml_node<char> *node1 = node->first_node2("ValueReference", "PropertyName");
+                    if (node1 == 0)
+                        continue;
+                    if (nc == 0)
+                    {
+                        sql_ += " order by ";
+                    }
+                    else
+                    {
+                        sql_ += ",";
+                    }
+                    _AppendProperty(sql, node1->value());
+                    node1 = node->first_node("SortOrder");
+                    if (node1)
+                    {
+                        sql_ += " ";
+                        sql_ += node1->value();
+                    }
+                    nc++;
+                }
+            }
+        }
+        catch (parse_error e)
+        {
+            //const char *w=e.what();
+            strncpy(this->err, e.what(), sizeof(this->err));
+            return -13;
+        }
+        catch (...)
+        {
+            strncpy(this->err, "unknow error", sizeof(this->err));
+            return -14;
+        }
+        return 0;
+    }
+    qingxingf*/
+
+    int DmpWfsFilter::GetGeomFromGml(boost::property_tree::ptree &ptreeode, std::string &strOut, double &x1, double &y1, double &x2, double &y2, void **geoOut)
+    {
+        if (geoOut)
+        {
+            *geoOut = 0;
+        }
+        strOut = "";
+    //    xml_node<char> *node = (xml_node<char> *)nn;
+        DmpWfsGmlObject *g = 0;
+        int e = pGeometry(ptreeode, &g); //很重要的函数
+                                     //	char sz[100];//int srid=-1;
+                                     //	itoa(srs,sz,10);
+        string srs = "";
+        //strcpy(sz,"NULL");
+        if (g)
+        {
+            //g->GetRect(x1, y1, x2, y2);
+            std::string sql;
+          //  g->GetString(sql);
+           strOut = "";//initConfig.geometryfromtext;
+                strOut += "st_geomfromtext('"; //strOut="geometryfromtext('";
+                strOut = strOut + sql;
+                strOut = strOut + "',";
+                //initConfig.DefaultGID;
+                strOut = strOut + srs;
+                strOut = strOut + ")";
+        }
+        else
+        {
+            return -28102;
+        }
+
+        return 0;
     }
 }
\ No newline at end of file

@@ -9,19 +9,91 @@
 
 #ifndef __dmpwfsfilter_h__
 #define __dmpwfsfilter_h__
-
+#include <boost/property_tree/ptree.hpp>
+#include <boost/property_tree/xml_parser.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <string>
+#include "dmpwfsgmlobject.h"
+using namespace std;
 namespace DmpWfs
 {
-    class dmpwfsfilter
-    {  
+    class DmpWfsFilter
+    {
     public:
-        dmpwfsfilter(/* args */);
-        ~dmpwfsfilter();
+        DmpWfsFilter(/* args */);
+        ~DmpWfsFilter();
+
+        bool Parse(const std::string &filter);
+        bool ParseOrder(const std::string &orderby);
+        std::string getSql() const { return sql_; }
+
+    private:
+        std::string sql_;
+        std::string error_;
+        int errorCode_;
+
+        std::string GetFieldName(const std::string& name);
+
+        int _All(const std::string &name, boost::property_tree::ptree &ptree);
+        int _Or(boost::property_tree::ptree &ptree);
+        int _Not(boost::property_tree::ptree &ptree);
+        int _And(boost::property_tree::ptree &ptree);
+        int _BBOX(boost::property_tree::ptree &ptree);
+        int _Equals(boost::property_tree::ptree &ptree);
+        int _Beyond(boost::property_tree::ptree &ptree);
+        int _Within(boost::property_tree::ptree &ptree);
+        int _Crosses(boost::property_tree::ptree &ptree);
+        int _Touches(boost::property_tree::ptree &ptree);
+        int _DWithin(boost::property_tree::ptree &ptree);
+        int _Contains(boost::property_tree::ptree &ptree);
+        int _Overlaps(boost::property_tree::ptree &ptree);
+        int _Disjoint(boost::property_tree::ptree &ptree);
+        int _FeatureId(boost::property_tree::ptree &ptree);
+        int _Intersects(boost::property_tree::ptree &ptree);
+        int _DIntersects(boost::property_tree::ptree &ptree);
+        int _GmlObjectId(boost::property_tree::ptree &ptree);
+        int _PropertyIsLike(boost::property_tree::ptree &ptree);
+        int _PropertyIsNull(boost::property_tree::ptree &ptree);
+        int _PropertyIsBetween(boost::property_tree::ptree &ptree);
+        int _PropertyIsEqualTo(boost::property_tree::ptree &ptree);
+        int _PropertyIsLessThan(boost::property_tree::ptree &ptree);
+        int _PropertyIsNotEqualTo(boost::property_tree::ptree &ptree);
+        int _PropertyIsGreaterThan(boost::property_tree::ptree &ptree);
+        int _PropertyIsLessThanOrEqualTo(boost::property_tree::ptree &ptree);
+        int _PropertyIsGreaterThanOrEqualTo(boost::property_tree::ptree &ptree);
+        int pEnvelope(boost::property_tree::ptree &ptree, double *x1, double *y1, double *x2, double *y2);
+
+        int pGeometry(boost::property_tree::ptree &ptree, DmpWfsGmlObject **g);
+        int pGeometryPoint(boost::property_tree::ptree &ptree, DmpWfsGmlObject **g);
+        int pGeometryLineString(boost::property_tree::ptree &ptree, DmpWfsGmlObject **g);
+        int pGeometryMultiPolyline(boost::property_tree::ptree &ptree, DmpWfsGmlObject **g);
+        int pGeometryMultiPolygon(boost::property_tree::ptree &ptree, DmpWfsGmlObject **g);
+        int pGeometryPolygon(boost::property_tree::ptree &ptree, DmpWfsGmlObject **g);
+        int pGeometryMultiPoint(boost::property_tree::ptree &ptree, DmpWfsGmlObject **g);
+        int pGeometryPolyline(boost::property_tree::ptree &ptree, DmpWfsGmlObject **g);
+        int pGeometryEnvope(boost::property_tree::ptree &ptree, DmpWfsGmlObject **g);
+        int pGeometryPointArray(boost::property_tree::ptree &ptree, std::vector<double> &v);
+        int pGeometryPointValue(char *p, std::vector<double> &v);
+        int pGeometryDouble(char *d, bool space_before, bool space_after, double &dbl);
+        int pGeometryPointValuePos(char *p, std::vector<double> &v);
+        int pGeometryPointValuePosList(boost::property_tree::ptree &ptree, std::vector<double> &v);
+        int pGeometryPointValueCoordinates(char *p, std::vector<double> &v);
+        int pGeometryPointValuePointRep(boost::property_tree::ptree &ptree, std::vector<double> &v);
+        int pGeometryPointValueCoord(boost::property_tree::ptree &ptree, std::vector<double> &v);
+        int pGeometryGetDis(boost::property_tree::ptree &ptree, double &dis);
+        int pGeometrySql(const char *function,const char *oracle_mask, int isDisjoin, boost::property_tree::ptree &ptree, bool useBuffer); //char *function,char *field,DmpWfsGmlObject *g,std::string &str);
     private:
-        /* data */
+        int Error(int code,const char * err);
+        void GetQueryField(std::string &field);
+        void _AppendProperty(std::string &sql, const char *str);
+        int  GetGeomFromGml(boost::property_tree::ptree &ptreeode,std::string &strOut,double &x1,double &y1,double &x2,double &y2,void **geoOut=0);
+        int _PropertyParse(const std::string& ptreeName, boost::property_tree::ptree &ptreeode, int &isExpression, int isLike = 0);
+        int _PropertyParse4(boost::property_tree::ptree &ptreeode,const char *f);
+        int _PropertyParseFunction(boost::property_tree::ptree &ptree);
+        int _PropertyOneEqual(boost::property_tree::ptree &ptree,const char *type, int isLike = 0);
+        void pParsesrsName(boost::property_tree::ptree& ptree);
     };
- 
-    
+
 }
 
 #endif // __dmpwfsfilter_h__

@@ -164,7 +164,7 @@ namespace DmpWfs
                ptFeatureType.add("Name", layer->name());
                ptFeatureType.add("Title", layer->title());
                ptFeatureType.add("DisplayColumn", "");
-               ptFeatureType.add("Geometry", "点");
+               ptFeatureType.add("Geometry", layer->GeomTypeString());
                ptFeatureType.add("GeometryColumn", layer->geom());
                ptFeatureType.add("SRS", srs);
 
@@ -187,7 +187,12 @@ namespace DmpWfs
                ptFeatureType.add_child("LatLongBoundingBox", ptBoundingbox);
 
                boost::property_tree::ptree ptFields;
-               for (; pPgsqlConn->next();)
+               char tablesql_buff[300];
+				sprintf(tablesql_buff, "select column_name,data_type from information_schema.columns where table_schema = '%s' and table_name = '%s'",
+					    layer->schema().c_str(),
+					    layer->name().c_str());
+				bool returnResult = pPgsqlConn->ExecWait(tablesql_buff);
+               for (;returnResult && pPgsqlConn->next();)
                {
                    std::string fieldname = pPgsqlConn->getString(0);
                    std::string typeString = pPgsqlConn->getString(1);

@@ -8,212 +8,330 @@
 ***************************************************************************/
 #include "dmpwfsgetfeature.h"
 #include "dmpsqlfactory.h"
+#include "dmpmapserverutil.h"
+#include "dmpgmlfilter.h"
+#include "dmpwfsfilter.h"
+#include "dmpserverresponse.h"
+#include "dmpserverrequest.h"
+#include "dmpserverproject.h"
+
+#include <string.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];
-	  DmpSqlFactory sqlFactory;
-
-	  int maxFeatures = params.MaxFeatures();
-	  int startIndex = params.StartIndex();
-	  std::string typeName = params.TypeName();
-	  std::string featureID = params.FeatureID();
-	  std::string propertyName = params.PropertyName();
-	  std::string resultType = params.ResultType();
-
-	  sqlFactory.setStartIndexCount(startIndex, maxFeatures, resultType);
-
-	  std::vector<std::string> ids;
-	  if (!featureID.empty())
-	  {
-		  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]);
-			  }
-		  }
-		  */
-	  }
+	void writeGetFeature(const DmpServerContext &context, const DmpWfsParameters &params,
+						 const DmpProject *project,
+						 bool projectSettings)
+	{
+		WfsGetFeature(context, params, project, projectSettings);
+	}
 
-	 /* std::vector<std::string> props;
-	  std::vector<std::string> propsAs;
-	  if (propertyName.empty())
-	  {
-		  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]);
-			  }
-		  }
-	  }
-	  */
+	std::string WfsGetFeature(const DmpServerContext &context, const DmpWfsParameters &params,
+							  const DmpProject *project,
+							  bool projectSettings)
+	{
+		char buff[5000];
+		DmpSqlFactory sqlFactory;
 
-	 // if (parseString.layerName == 0)
-	//	  return Error(buff, ErrorClass::ParaError, "layername not exist", ab);
+		int maxFeatures = params.MaxFeatures();
+		int startIndex = params.StartIndex();
+		std::string typeName = params.TypeName();
+		std::string featureID = params.FeatureID();
+		std::string propertyName = params.PropertyName();
+		DmpWfsParameters::Format resultType = params.ResultType();
+		std::string filter = params.Filter();
 
-	  //const char *realLayer=0;
-	  //GetUpLayerID是干什么的？
-	  //似乎就是加了些L啊什么的。。 。
-	 // if (_GetUperLayerId(parseString.layerName, sLayer) == false)
-	 //	  return Error(buff, ErrorClass::ParaError, "layer not exist", ab);
+		std::string sortby = params.Sortby();
 
-	 /* shared_ptr<MapLayer> mapLayer = service->GetLayer(parseString.layerName);
+		DmpWfsFilter wfsFilter;
+		wfsFilter.Parse(filter);
+		std::string sql0 = wfsFilter.getSql();
+		printf("%s\r\n", sql0.c_str());
 
-	
-	  if(mapLayer == nullptr)
-	  {
-		   return Error(buff, ErrorClass::ParaError, "layer not find", ab);
-	  }
+		sqlFactory.setStartIndexCount(startIndex, maxFeatures, "");
 
-	  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,"");
+		std::vector<std::string> ids;
+		if (!featureID.empty())
+		{
+			char *idstring[1000];
+			//将ID值以逗号分开，并返回个数
 
-	  if(fields == nullptr)
-	  {
-		  return Error(buff, ErrorClass::ParaError, "layername not exist", ab);
-	  }
+			vector<string> stringlist = mapserver::DmpMapServerUtil::stringSplit(propertyName, ",");
+			for (int i = 0; i < stringlist.size(); i++)
+			{
+				char *ss[2];
+				//形式：LayerName.ID
+				vector<string> stringList1 = mapserver::DmpMapServerUtil::stringSplit(idstring[i], ".");
+				//  int n = StringHelp::ParseStringTok(idstring[i], '.', ss, 2);
+				if (stringList1.size() == 2)
+				{
+					if (typeName.empty())
+					{
+						typeName = stringList1[0];
+					}
+					ids.push_back(stringList1[1]);
+				}
+				else if (stringList1.size() == 1)
+				{
+					ids.push_back(stringList1[0]);
+				}
+			}
+		}
 
-	
+		std::vector<std::string> props;
+		std::vector<std::string> propsAs;
+		if (!propertyName.empty())
+		{
 
+			vector<string> stringlist = mapserver::DmpMapServerUtil::stringSplit(propertyName, ",");
+			for (int i = 0; i < stringlist.size(); i++)
+			{
+				// char *ss[2];
+				std::string sProp, sPropAs;
+				vector<string> layernameSplit = mapserver::DmpMapServerUtil::stringSplit(stringlist[i], ".");
+				if (layernameSplit.size() == 2)
+				{
+					if (typeName.empty())
+					{
+						typeName = layernameSplit[0];
+					}
+					//又以空格分开
+					//  StringHelp::GetAsStringSql(ss[1], sProp, sPropAs);
+					props.push_back(sProp);
+					propsAs.push_back(sPropAs);
+					//sPropOrig=ss[1];
+				}
+				else if (layernameSplit.size() == 1)
+				{
+					//  StringHelp::GetAsStringSql(ss[0], sProp, sPropAs);
+					props.push_back(sProp);
+					propsAs.push_back(sPropAs); //props.push_back(ss[0]);
+				}
+			}
+		}
 
-      shared_ptr<TableDesc> pTabledesc = this->ToTableDesc(fields,mapLayer->m_layerName);
-	    
+		if (typeName.empty())
+		{
+			return "layername not exist";
+		}
 
-	  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);
-	  }
+		DmpVectorLayer *mapLayer = (DmpVectorLayer *)project->getLayer(typeName); //GetLayer(parseString.layerName);
+		if (mapLayer == nullptr)
+		{
+			return "layer not find";
+		}
 
-	  size_t idCount = ids.size();
+		shared_ptr<DmpPgsql> pPgsqlConn = DmpPgsqlSourcePools::get_instance()->GetPgsqlConn(mapLayer->source());
+		if (pPgsqlConn == nullptr)
+		{
+			return "连接数据库失败";
+		}
+		// shared_ptr<dmapFields> fields = pPgsqlConn->GetFields(mapLayer->m_layerName,"");
 
-	  
+		//if(fields == nullptr)
+		{
+			//return Error(buff, ErrorClass::ParaError, "layername not exist", ab);
+		}
 
-	  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);
+		//  shared_ptr<TableDesc> pTabledesc = this->ToTableDesc(fields,mapLayer->m_layerName);
 
-	  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))
+		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 (boost::iequals(sleft, "distinct"))
+					{
+						//  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());
+				}
+			}
+
+			sqlFactory.setProp(sF);
+		}
+		else
+		{
+			std::string prop;
+			GetAllField(prop, mapLayer, pPgsqlConn, resultType);
+			sqlFactory.setProp(prop);
+		}
+
+		size_t idCount = ids.size();
+
+		if (!filter.empty())
+		{
+			DmpWfsFilter wfsFilter;
+
+			if (wfsFilter.Parse(filter))
+			{
+				return "解析查询器错误";
+			}
+
+			sqlFactory.appendCondition(wfsFilter.getSql());
+		}
+
+		if (!sortby.empty())
+		{
+			DmpWfsFilter wfsFilter;
+			if (wfsFilter.ParseOrder(sortby))
+			{
+				return "参数sortby 解析错误！";
+			}
+			sqlFactory.setOrder(wfsFilter.getSql());
+		}
+		sqlFactory.setTable(mapLayer->name());
+		std::string sql = sqlFactory.getSql();
+		if (!pPgsqlConn->ExecWaitBinary(sql))
+		{
+			return "查询错误:" + pPgsqlConn->error();
+		}
+
+		if (resultType == DmpWfsParameters::Format::GeoJson)
+		{
+			std::string responseData;
+			std::string srid = std::__cxx11::to_string(mapLayer->crs().srid());
+			DmpMapServerUtil::responseGeojson(pPgsqlConn, responseData, mapLayer->name(), srid);
+			context.response()->writeJson(responseData);
+		}
+		else
+		{
+			std::string responseData;
+			std::string srid = std::__cxx11::to_string(mapLayer->crs().srid());
+			DmpMapServerUtil::responseGml(pPgsqlConn, responseData, mapLayer->name(), srid);
+			context.response()->removeHeader("Content-Type");
+    		context.response()->setHeader("Content-Type", "text/xml;charset=utf-8");
+    		context.response()->write(responseData);
+		}
+
+		// 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);
+		  return this->FormatWFSJsonCAll(pPgsqlConn, ab, parseString.layerName, buff, ver);
 	  }
 	  else
 	  {
 		  isPicture = 0;
-		  return this->FormatWFSXMLCAll(pWorkspace, ab, parseString.layerName, buff, ver);
+		  return this->FormatWFSXMLCAll(pPgsqlConn, ab, parseString.layerName, buff, ver);
 	  }*/
-	  return "";
-    }
+		return "";
+	}
+
+	void getAsStringSql(const string &str, std::string &sProp, std::string &sAs)
+	{
+		//char *ss[2];
+		vector<string> layernameSplit = mapserver::DmpMapServerUtil::stringSplit(str, ".");
+		//int n = ParseStringTok(str, ' ', ss, 2);
+		if (layernameSplit.size() == 1)
+		{
+			sProp = layernameSplit[0];
+			sAs = "";
+		}
+		else if (layernameSplit.size() > 1)
+		{
+			sProp = layernameSplit[0];
+			sAs = layernameSplit[1];
+		}
+	}
+
+	bool GetAllField(std::string &strOut, DmpVectorLayer *mapLayer,
+					 shared_ptr<DmpPgsql> pPgsqlConn, DmpWfsParameters::Format format)
+	{
+		string fields_str;
+		if (pPgsqlConn != nullptr)
+		{
+			char tablesql_buff[300];
+			std::sprintf(tablesql_buff, "select column_name,data_type from information_schema.columns where table_schema = '%s' and table_name = '%s'",
+						 mapLayer->schema().c_str(),
+						 mapLayer->name().c_str());
+
+			int returnResult = pPgsqlConn->ExecWait(tablesql_buff);
+			if (!returnResult)
+			{
+				string fields_str = " * ";
+			}
+			else
+			{
 
+				for (int i = 0; pPgsqlConn->next(); i++)
+				{
+					if (i > 0 && fields_str.length() > 0 && fields_str[fields_str.length() - 1] != ',')
+					{
+						fields_str += ",";
+					}
+					string fieldname = pPgsqlConn->getString(0);
+					string typeString = pPgsqlConn->getString(1);
+					int typeInt = PGFieldType::VarCharFieldType;
+					if (mapLayer->geom() == fieldname || typeString == "geometry")
+					{
+						typeString = "geometry";
+						typeInt = PGFieldType::ShapeFieldType;
+						if (format == DmpWfsParameters::Format::GeoJson)
+						{
+							fields_str += " st_asgeojson(\"" + (fieldname) + "\") as geometry_as_geojson";
+						}
+						else
+						{
+							fields_str += " st_asgml(\"" + (fieldname) + "\") as geometry_as_gml";
+						}
+					}
+					else if (typeString == "integer")
+					{
+						typeInt = PGFieldType::BigIntFieldType;
+						fields_str += " \"" + (fieldname) + "\"::varchar  ";
+					}
+					else if (typeString == "bigint")
+					{
+						typeInt = PGFieldType::BigIntFieldType;
+						fields_str += " \"" + (fieldname) + "\"::varchar ";
+					}
+					else if (typeString == "double precision" || typeString == "real" || typeString == "numeric")
+					{
+						typeInt = PGFieldType::DoubleFieldType;
+						fields_str += " \"" + (fieldname) + "\"::varchar  ";
+					}
+					else if (typeString == "character varying" || typeString == "text")
+					{
+						typeInt = PGFieldType::VarCharFieldType;
+						fields_str += " \"" + (fieldname) + "\" ";
+					}
+					else if (typeString == "bytea")
+					{
+						continue;
+					}
+					else if (typeString == "timestamp without time zone")
+					{
+						fields_str += " \"" + (fieldname) + "\"::varchar ";
+					}
+				}
+			}
+		}
+		else
+		{
+			fields_str = " * ";
+		}
 
+		strOut = fields_str;
 
+		return true;
+	}
 }
\ No newline at end of file

@@ -14,22 +14,29 @@
 #include <boost/typeof/typeof.hpp>
 #include <memory>
 #include <vector>
+#include <string>
 #include "dmpproject.h"
 #include "dmpwfsparameters.h"
 #include "dmpservercontext.h"
 #include "dmppgsqlsourcepools.h"
-
+#include "dmpvectorlayer.h"
+#include "dmpgmlfilter.h"
+using namespace mapserver;
 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);
+    std::string WfsGetFeature(const DmpServerContext &context,const DmpWfsParameters& params, 
+                             const  DmpProject* project,
+                           bool projectSettings = false);
+
+
+    void getAsStringSql(const string& str,std::string &sProp,std::string &sAs);
+
+    bool GetAllField(std::string &strOut,DmpVectorLayer* mapLayer,shared_ptr<DmpPgsql> pPgsqlConn, DmpWfsParameters::Format format);
 
-   
 }
 
 #endif // __dmpwfsgetfeature_h__

+/**************************************************************************
+* file:              dmpwfsgmlobject.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-06 13:39:11
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#include "dmpwfsgmlobject.h"
+
+
+ DmpWfsGmlObject::DmpWfsGmlObject()
+{
+
+}
+
+
+ ~DmpWfsGmlObject::DmpWfsGmlObject()
+{
+    
+}
\ No newline at end of file

+/**************************************************************************
+* file:              dmpwfsgmlobject.h
+
+* Author:            qingxiongf
+* Date:              2022-01-06 13:39:03
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpwfsgmlobject_h__
+#define __dmpwfsgmlobject_h__
+#include <string>
+
+namespace DmpWfs
+{
+    class DmpWfsGmlObject
+    {
+    public:
+        DmpWfsGmlObject(void);
+
+    public:
+        ~DmpWfsGmlObject(void);
+
+    public:
+        virtual void getString(std::string &str) = 0;
+        virtual void getObj(void *sg) = 0;
+        virtual void getRect(double &x1, double &y1, double &x2, double &y2) = 0;
+    };
+
+    class DmpWfsGmlPoint : public DmpWfsGmlObject
+    {
+    public:
+        DmpWfsGmlPoint(void);
+        DmpWfsGmlPoint(double x, double y);
+        ~DmpWfsGmlPoint(void);
+
+    public:
+        void getObj(void *sg);
+        void getString(std::string &s);
+        void getRect(double &x11, double &y11, double &x22, double &y22);
+
+    private:
+        double x;
+        double y;
+    };
+
+    
+
+
+}
+
+#endif // __dmpwfsgmlobject_h__

@@ -170,11 +170,23 @@ namespace DmpWfs
         return value;
     }
 
-    std::string DmpWfsParameters::ResultType() const //要素ID
+    DmpWfsParameters::Format DmpWfsParameters::ResultType() const 
     {
         std::string value = "";
         GetStringParameter("RESULTTYPE",value);
-        return value;
+        if (value.empty()) {
+              GetStringParameter("FORMAT",value);
+        }
+        if (value.empty()) {
+              return DmpWfsParameters::Format::GML3;
+        }
+        
+        Format f = Format::GML3;
+        boost::to_lower(value);
+        if (value.compare("geojson") == 0 || value.compare("json") == 0 ) {
+              f = DmpWfsParameters::Format::GeoJson;
+        }
+        return f;
     }
 
 }
\ No newline at end of file

@@ -51,7 +51,7 @@ namespace DmpWfs
         std::string PropertyName() const; //指定返回的要素属性，没有指定不返回
         std::string SrsName() const; //空间参考坐标
         std::string FeatureID() const; //要素ID
-        std::string ResultType() const;
+        DmpWfsParameters::Format ResultType() const;
 
         //std::string Expiry(); 
         

@@ -19,6 +19,8 @@
 #include "dmplogger.h"
 #include "dmpwmsgetcapabilities.h"
 #include "dmpwmsgetmap.h"
+#include "dmpwmsserviceinfo.h"
+#include "dmpwmsgetfeatureinfo.h"
 using namespace std;
 
 namespace DmpWms
@@ -50,14 +52,18 @@ namespace DmpWms
       {
           writeGetMap(context,params, project);
       } 
-      else if(boost::iequals(request,"thumbnail"))
+      else if(boost::iequals(request,"thumbnail") || boost::iequals(request,"getthumbnail"))
       {
           writeThumbnail(context,params, project);
       }
       else if(boost::iequals(request, "getfeatureinfo")) 
       {
-          
+          writeFeatureInfo(context,params, project);
       } 
+      else if(boost::iequals(request, "getserviceinfo"))
+      {
+         writeGetServiceInfo(context,params, project);
+      }
       else if(request == "getlegendgraphic")
       {
           

@@ -72,9 +72,14 @@ namespace DmpWms
 			mapRenderer.SetExtent(rect);
 			string responseData;
 			mapRenderer.GetFeatureInfo(responseData, x, y, featureCount);
-			context.response()->removeHeader("Content-Type");
-			context.response()->setHeader("Content-Type", "image/png");
-			context.response()->write(responseData);
+			if(responseData.empty())
+			{
+				context.response()->writeJson("null");
+			}
+			else
+			{
+				context.response()->writeJson(responseData);
+			}
 			return "";
 		}
 		catch (const std::exception &e)

@@ -63,7 +63,7 @@ namespace DmpWms
 			DmpWms::DmpWmsRenderer mapRenderer(height, width);
 
             std::string layers = params.Layers();
-			if (layers !="")
+			if (layers =="")
 			{
 				mapRenderer.AddWmsMapLayers(project);
 			}
@@ -125,6 +125,7 @@ namespace DmpWms
 	
 			shared_ptr<Rect> rect (new Rect(maxy, maxx, miny, minx));
 			mapRenderer.SetExtent(rect);
+			mapRenderer.AddWmsMapLayers(project);
 			mapRenderer.GetMap(nullptr, nullptr, nullptr, true);
 			string responseData;
 			mapRenderer.ToStream(responseData);

@@ -522,7 +522,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 					else if (typeString == "integer")
 					{
 						typeInt = PGFieldType::BigIntFieldType;
-						fields_str += " \"" + (fieldname) + "\" ";
+						fields_str += " \"" + (fieldname) + "\"::varchar ";
 					}
 					else if (typeString == "bigint")
 					{
@@ -532,7 +532,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 					else if (typeString == "double precision" || typeString == "real" || typeString == "numeric")
 					{
 						typeInt = PGFieldType::DoubleFieldType;
-						fields_str += " \"" + (fieldname) + "\" ";
+						fields_str += " \"" + (fieldname) + "\"::varchar ";
 					}
 					else if (typeString == "character varying" || typeString == "text")
 					{
@@ -572,7 +572,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 
 		string shapeName = layer->geom();
 		sql += format(" ST_DWithin(\"%s\", ST_GeometryFromText('POINT(%f %f)',%s), %f) limit %d ",
-					  shapeName.c_str(), x, y, layer->crs().srid(), dis, feature_count);
+					  shapeName.c_str(), x, y, layer->srid().c_str(), dis, feature_count);
 		//cout<<sql.c_str() <<endl;
 		return sql;
 	}
@@ -604,7 +604,7 @@ ST_GeometryFromText('POLYGON((%f %f, %f %f,  %f %f, %f %f,  %f %f))',%s),\
 			string sql = this->GetFeatureInfoSQL(layer, x0, y0, dis, feature_count); //sql语句中使用 ::box
 			if (sql == "")
 				continue;
-
+			printf("%s\r\n",sql.c_str());
 			string layerName = layer->name();
 			try
 			{

+/**************************************************************************
+* file:              dmpwmsserviceinfo.cpp
+
+* Author:            qingxiongf
+* Date:              2022-01-11 14:05:33
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+#include "dmpwmsserviceinfo.h"
+#include "dmpserverresponse.h"
+#include "dmpserverrequest.h"
+#include "dmpserverproject.h"
+
+namespace DmpWms
+{
+    void writeGetServiceInfo(const DmpServerContext &context, const DmpWmsParameters &params,
+                             const DmpProject *project,
+                             bool projectSettings)
+    {
+        boost::property_tree::ptree xmlRoot;
+  
+        std::string name = context.serverProject()->name();
+        std::string title = context.serverProject()->title();
+
+        boost::property_tree::ptree ptRoot;
+       
+        addServiceInfoLayers(ptRoot,project,name,title);
+        
+    
+        std::stringstream stream;
+        write_json(stream, ptRoot);
+        std::string json;
+        json = stream.str();
+
+        context.response()->writeJson(json);
+    }
+
+  void addServiceInfoLayers(boost::property_tree::ptree &pt,const DmpProject* project, std::string& name, std::string& title)
+  {
+    std::string srs = "EPSG:" + std::__cxx11::to_string(project->crs().srid());
+
+    boost::property_tree::ptree ptProject;
+   // ptProject.add("<xmlattr>.queryable","1");
+    ptProject.add("Name", name);
+    ptProject.add("Title", title);
+    ptProject.add("CRS", srs);
+
+    double minx,miny,maxx,maxy;
+    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++)
+    {
+      DmpMapLayer* layer = iter->second;
+       if(i ==0)
+       {
+          minx = layer->extent().xmin();
+          miny = layer->extent().ymin();
+          maxx = layer->extent().xmax();
+          maxy = layer->extent().ymax();
+       }
+       else
+       {
+          if(minx > layer->extent().xmin()) minx = layer->extent().xmin();
+          if(miny > layer->extent().ymin()) miny = layer->extent().ymin();
+          if(maxx < layer->extent().xmax()) maxx = layer->extent().xmax();
+          if(maxy < layer->extent().ymax()) maxy = layer->extent().ymax();
+       }
+       i++;
+    }
+
+    boost::property_tree::ptree ptGeographicBoundingbox; 
+    ptGeographicBoundingbox.add("westBoundLongitude", minx);
+    ptGeographicBoundingbox.add("eastBoundLongitude", maxx);
+    ptGeographicBoundingbox.add("southBoundLatitude", miny);
+    ptGeographicBoundingbox.add("northBoundLatitude", maxy);
+    ptProject.add_child("EX_GeographicBoundingBox",ptGeographicBoundingbox);
+
+    boost::property_tree::ptree ptLayers;
+    for (std::map<std::string, DmpMapLayer*>::iterator iter= mapLayers.begin();iter != mapLayers.end(); iter++)
+    {
+      DmpMapLayer* layer = iter->second;
+      addServiceInfoLayer(ptLayers,(DmpVectorLayer *)layer,srs);
+    }
+    ptProject.add_child("Layers",ptLayers);
+    pt.add_child("Service", ptProject);
+  }
+
+  void addServiceInfoLayer(boost::property_tree::ptree &pt, DmpVectorLayer* layer, const std::string& srs)
+  {
+    boost::property_tree::ptree ptLayer;
+    ptLayer.add("Name", layer->name());
+    ptLayer.add("Title", layer->title());
+    ptLayer.add("CRS", srs);
+    ptLayer.add("Type", layer->GeomTypeString());
+
+    boost::property_tree::ptree ptGeographicBoundingbox; 
+    ptGeographicBoundingbox.add("westBoundLongitude", layer->extent().xmin());
+    ptGeographicBoundingbox.add("eastBoundLongitude", layer->extent().xmax());
+    ptGeographicBoundingbox.add("southBoundLatitude", layer->extent().ymin());
+    ptGeographicBoundingbox.add("northBoundLatitude", layer->extent().ymax());
+    ptLayer.add_child("EX_GeographicBoundingBox",ptGeographicBoundingbox);
+     pt.push_back(std::make_pair("", ptLayer));
+    //pt.add_child("Layer", ptLayer);
+  }
+
+}
\ No newline at end of file

+/**************************************************************************
+* file:              dmpwmsserviceinfo.h
+
+* Author:            qingxiongf
+* Date:              2022-01-11 14:05:38
+* Email:             qingxiongf@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#ifndef __dmpwmsserviceinfo_h__
+#define __dmpwmsserviceinfo_h__
+#include <boost/property_tree/ptree.hpp> 
+#include <boost/property_tree/json_parser.hpp> 
+#include <boost/typeof/typeof.hpp>
+#include <memory>
+#include <vector>
+#include "dmpproject.h"
+#include "dmpwmsgetmap.h"
+#include "dmpservercontext.h"
+#include "dmpvectorlayer.h"
+namespace DmpWms
+{
+
+
+  /**
+   * Output GetServiceInfo response
+   */
+  void writeGetServiceInfo( const DmpServerContext &context,const DmpWmsParameters& params, 
+                             const  DmpProject* project,
+                             bool projectSettings = false);
+
+    void addServiceInfoLayers(boost::property_tree::ptree &pt,const DmpProject* project,std::string& name, std::string& title);
+
+    void addServiceInfoLayer(boost::property_tree::ptree &pt,DmpVectorLayer* layer,const std::string& srs);
+}
+
+
+#endif // __dmpwmsserviceinfo_h__

@@ -36,7 +36,8 @@ public:
     ~DmpTileServer();
     std::string name() const override { return std::string("TileServer");}
     std::string alias() const override { return std::string("瓦片服务");}
-    std::string path() const override { return std::string("^/DMap/Services/?([\\w./]*)/TileServer/([\\w.]+)([\\w./]*)"); }
+    //std::string path() const override { return std::string("^/DMap/Services/?([\\w./]*)/TileServer/([\\w.]+)([\\w./]*)"); }
+    std::string path() const override { return std::string("^/DMap/Services/?([\\w\\W./]*)/TileServer/([\\w.]+)([\\w./]*)"); }
     std::string capability() const override;
     void executeRequest(DmpServerRequest &request, DmpServerResponse &response) override;
     bool publish(const std::string &serviceName, const std::string &title, unsigned int capability, const DmpProject &project) override;

@@ -45,6 +45,7 @@ namespace tileserver
         }
         fread.close();
     }
+
     void DmpTmsTileProvider::GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& respons)
     {
        int tilematrix=0;

@@ -9,6 +9,10 @@
 #include "dmpesritileprovider.h"
 #include "dmpwmtsutils.h"
 #include <string>
+#include "dmptileproviderfactory.h"
+#include <iostream>
+#include "dmptilelayer.h"
+#include <cairo/cairo.h>
 
 namespace tileserver
 {
@@ -60,8 +64,65 @@ namespace tileserver
         }
         fread.close();
     }
-    void DmpEsriTileProvider::GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& respons)
+    void DmpEsriTileProvider::GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& response)
     {
+        std::string tilePath=dmpTileLayer->getDataSource();
+        DmpRectangle rectangle=dmpTileLayer->extent();
+        std::string format=dmpTileLayer->getFormat();
 
+        DmpPoint min=DmpPoint(rectangle.xmin(),rectangle.ymin());
+        DmpPoint max=DmpPoint(rectangle.xmax(),rectangle.ymax());
+        std::vector<DmpTileMatrixSet*> tileMatrixSets;
+        dmpTileLayer->getTileMatrixSets(tileMatrixSets); 
+        double resolution;
+        DmpPoint origin;
+        int  iLevel,xMinTile,yMinTile, xMaxTile, yMaxTile;
+        if(!TileProviderFactory::GetTileScale(dmpTileLayer,iLevel,xMinTile,yMinTile, xMaxTile, yMaxTile))
+        {
+            response.sendError(500, "缩略图范围错误:(");
+            return;
+        }
+        int heigth=abs(yMaxTile-yMinTile);
+        int width=abs(xMaxTile-xMinTile);
+        cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 256*(width+1), 256*(heigth+1));
+        cairo_t *cr =cairo_create (surface);
+        for( int i = 0 ; i <= width ; i++ )
+        {
+            for(int j=0;j<=heigth;j++)
+            {
+                std::string filepath;
+                if(GetTile(yMaxTile+j,xMinTile+i,iLevel,format,filepath))
+                {
+                    cairo_surface_t*  image = cairo_image_surface_create_from_png( filepath.c_str());
+                    TileProviderFactory::BufferCopy(image,surface,cr,i*256,j*256);
+                }
+                //TileProviderFactory::BufferCopy(image,surface,cr,i*256,j*256);
+                //cairo_surface_write_to_png (surface, "./wmts.png");
+            }
+        }
+        std::string responseData;
+        cairo_surface_write_to_png_stream(surface, TileProviderFactory::cairo_write_func, &responseData);
+        
+        response.removeHeader("Content-Type"); 
+        std::string f = (format == "jpg") ? "image/jpg" : "image/png";     
+        response.setHeader("Content-Type", f);
+        response.write(responseData);    
+        cairo_destroy (cr);
+        cairo_surface_destroy (surface);   
+    }
+    bool DmpEsriTileProvider::GetTile(const int row,const int col,const int level,const std::string& format,std::string& reTilePath)
+    {
+        std::string level_str = "L" + DmpWmtsUtils::IntToFormatStr(level);
+        std::string row_str = "R" + IntToHex8Str(row);
+        std::string col_str = "C" + IntToHex8Str(col);
+        
+        reTilePath = rootPath_ + level_str + "/"+ row_str+"/"+ col_str + "." + format;
+
+        std::ifstream fread(reTilePath, std::ifstream::binary);
+        if(!fread)
+        {
+            return false;
+        }
+        
     }
 }
\ No newline at end of file

@@ -20,7 +20,8 @@ namespace tileserver
     public:
       DmpEsriTileProvider(const std::string& rootPath);
       void WriteTile(const int row, const int col, const int level, const std::string& format, DmpServerResponse& response) override;
-      void GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& respons) override;
+      void GetTileThumbnail(DmpTileLayer* dmpTileLayer,DmpServerResponse& response) override;
+      bool GetTile(const int row,const int col,const int level,const std::string& format,std::string& reTilePath);
     private:
       std::string IntToHex8Str(const int num);
   };

@@ -105,6 +105,12 @@ namespace tileserver
             iLevel=id;
             resolution=relus;
             break;
+          } 
+          else if(leviter==tileLevels.cbegin()&&(heigth+1)*(width+1)>=9)
+          {
+             iLevel=id;
+             resolution=relus;
+             break;
           }
         }        
     }   
@@ -145,7 +151,7 @@ namespace tileserver
         }
         if(cr==NULL)
         {
-            cr =  cairo_create (pClsCSTo);
+          cr =  cairo_create (pClsCSTo);
         }
         cairo_set_source_surface(cr, pClsCSFrom, x, y); 
         cairo_paint(cr);