WMSClient.cpp

Go to the documentation of this file.

#include "WMSClient.h"

// TerraLib
#include "../../../../core/filesystem/FileSystem.h"
#include "../../../../core/translator/Translator.h"
#include "../../../core/CurlWrapper.h"
#include "../../../core/Utils.h"
#include "../../../core/Exception.h"
#include "WMSClient.h"
#include "AbstractWMSXMLParserFactory.h"

// Boost
#include <boost/filesystem.hpp>
#include <boost/lexical_cast.hpp>

#include <string>

te::ws::ogc::WMSClient::WMSClient(const std::string usrDataDir, const std::string uri, const std::string version) :
  m_version(version),
  m_uri(uri)
{
  m_dataDir = usrDataDir + "/wms/";

  m_curl = std::shared_ptr<te::ws::core::CurlWrapper>(new te::ws::core::CurlWrapper());

  if(!m_uri.user().empty() && !m_uri.password().empty())
  {
    m_curl->setAuthenticationMethod(te::ws::core::HTTP_BASIC);
    m_curl->setUsername(m_uri.user());
    m_curl->setPassword(m_uri.password());
  }

  std::string baseUrl = m_uri.scheme() + "://" + m_uri.host();

  if (!m_uri.port().empty())
  {
    baseUrl = baseUrl + ":" + m_uri.port();
  }

  baseUrl = baseUrl + m_uri.path() + "?";

  if (!m_uri.query().empty())
  {
    std::string query = m_uri.query();

    size_t endsWith = query.rfind("&");

    if (endsWith != (query.size() - 1))
    {
      query.append("&");
    }

    baseUrl = baseUrl + query;
  }

  m_uri = te::core::URI(baseUrl);

  if (te::core::FileSystem::isDirectory(usrDataDir) && !te::core::FileSystem::exists(m_dataDir))
    te::core::FileSystem::createDirectories(m_dataDir);

  m_parser.reset(te::ws::ogc::wms::AbstractWMSXMLParserFactory::make(m_version));

}

te::ws::ogc::WMSClient::~WMSClient() = default;

void te::ws::ogc::WMSClient::updateCapabilities()
{
  std::string url = m_uri.uri();

  url = url + "SERVICE=WMS" + "&VERSION=" + m_version + "&REQUEST=GetCapabilities";

  m_curl->setTaskMessage(TE_TR("Getting Capabilities"));

  // Request the WMS Capabilities XML file
  std::string xmlPath = this->makeFileRequest(url, "capabilities.xml");

  try
  {
    // Parse the XML file into a struct
    m_capabilities = m_parser->parseCapabilities(xmlPath);
  }
  catch(te::ws::core::WrongVersionException&)
  {
    /*!
      According to version negotiation, the client must try to request with
      the higher supported version. If server response with an other version,
      client must try to request with an lower version.
    */
    if (m_version == "1.3.0")
    {
      m_version = "1.1.1";
      m_parser.reset(te::ws::ogc::wms::AbstractWMSXMLParserFactory::make(m_version));
      this->updateCapabilities();
    }
    else if (m_version == "1.1.1")
    {
      throw te::ws::core::UnsupportedVersionException() << te::ErrorDescription(TE_TR("Unsupported WMS response version!"));
    }
  }
  catch(te::ws::core::Exception&)
  {
    throw;
  }

}

const te::ws::ogc::wms::WMSCapabilities& te::ws::ogc::WMSClient::getCapabilities() const
{
  return m_capabilities;
}

void te::ws::ogc::WMSClient::setCapabilities(const te::ws::ogc::wms::WMSCapabilities &capabilities)
{
  m_capabilities = capabilities;
}

const te::ws::ogc::wms::WMSGetMapResponse te::ws::ogc::WMSClient::getMap(const te::ws::ogc::wms::WMSGetMapRequest &request) const
{
  te::ws::ogc::wms::WMSGetMapResponse response;

  std::string url = this->buildGetMapRequestURL(request);

  te::core::URI wmsRequest (url);

  std::string buffer;

  m_curl->get(wmsRequest, buffer);

  response.m_buffer = buffer;
  response.m_size = static_cast<int>(buffer.size());
  response.m_format = request.m_format;

  return response;
}

const std::string te::ws::ogc::WMSClient::saveGetMap(const te::ws::ogc::wms::WMSGetMapRequest &request, const std::string &filename)
{

  std::string url = this->buildGetMapRequestURL(request);

  std::string path = this->makeFileRequest(url, filename);

  return path;
}

const te::ws::ogc::wms::WMSGetFeatureInfoResponse te::ws::ogc::WMSClient::getFeatureInfo(const te::ws::ogc::wms::WMSGetFeatureInfoRequest& request) const
{

  te::ws::ogc::wms::WMSGetFeatureInfoResponse response;

  std::string url = this->buildGetFeatureInfoURL(request);

  te::core::URI wmsRequest (url);

  std::string buffer;

  m_curl->get(wmsRequest, buffer);

  response.m_featureInfoContent = buffer;
  response.m_infoFormat = request.m_infoFormat;

  return response;
}

std::string te::ws::ogc::WMSClient::makeFileRequest(const std::string url, const std::string fileName) const
{
  std::string path = m_dataDir + fileName;

  m_curl->downloadFile(url, path);

  return path;
}

void te::ws::ogc::WMSClient::setCurlWrapper(te::ws::core::CurlWrapper* curlWrapper)
{
  m_curl.reset(curlWrapper);
}

std::string te::ws::ogc::WMSClient::buildGetMapRequestURL(const te::ws::ogc::wms::WMSGetMapRequest &request) const
{

  //Sets base URL
  std::string url;

  if(m_version == "1.3.0")
  {
    url = this->build130GetMapRequestURL(request);
  }
  else if (m_version == "1.1.1")
  {
    url = this->build111GetMapRequestURL(request);
  }

  return url;
}

std::string te::ws::ogc::WMSClient::build130GetMapRequestURL(const te::ws::ogc::wms::WMSGetMapRequest &request) const
{
  //Sets base URL
  std::string url = m_uri.uri();

  url = url + "SERVICE=WMS" + "&VERSION=" + m_version + "&REQUEST=GetMap";

  if(request.m_layers.size() > 0)
  {
    url += "&LAYERS=";

    for(size_t i = 0; i < request.m_layers.size(); i++)
    {
      url += request.m_layers[i];

      if(i != request.m_layers.size() - 1)
      {
        url += ",";
      }
    }
  }

  if(request.m_styles.size() > 0)
  {
    url += "&STYLES=";

    for(size_t i = 0; i < request.m_styles.size(); i++)
    {
      url += request.m_styles[i];

      if(i != request.m_styles.size() - 1)
      {
        url += ",";
      }
    }
  }

  if(!request.m_srs.empty())
  {
    url += "&CRS=" + request.m_srs;
  }

  bool isInverted = te::ws::core::IsInvertedEPSG(request.m_srs);

  if(isInverted)
  {
    url += "&BBOX=";
    url += boost::lexical_cast<std::string>(request.m_boundingBox.m_minY);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_boundingBox.m_minX);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_boundingBox.m_maxY);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_boundingBox.m_maxX);
  }
  else
  {
    url += "&BBOX=";
    url += boost::lexical_cast<std::string>(request.m_boundingBox.m_minX);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_boundingBox.m_minY);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_boundingBox.m_maxX);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_boundingBox.m_maxY);
  }



  url += "&WIDTH=" + boost::lexical_cast<std::string>(request.m_width);
  url += "&HEIGHT=" + boost::lexical_cast<std::string>(request.m_height);

  url += "&FORMAT=" + request.m_format;

  if(request.m_transparent)
  {
    url += "&TRANSPARENT=TRUE";
  }

  if(!request.m_bgColor.empty())
  {
    url += "&BGCOLOR=" + request.m_bgColor;
  }

  if(!request.m_time.empty())
  {
    url += "&TIME=" + request.m_time;
  }

  return url;
}

std::string te::ws::ogc::WMSClient::build111GetMapRequestURL(const te::ws::ogc::wms::WMSGetMapRequest &request) const
{
  //Sets base URL
  std::string url = m_uri.uri();


  url = url + "SERVICE=WMS" + "&VERSION=" + m_version + "&REQUEST=GetMap";

  if(request.m_layers.size() > 0)
  {
    url += "&LAYERS=";

    for(size_t i = 0; i < request.m_layers.size(); i++)
    {
      url += request.m_layers[i];

      if(i != request.m_layers.size() - 1)
      {
        url += ",";
      }
    }
  }

  if(request.m_styles.size() > 0)
  {
    url += "&STYLES=";

    for(size_t i = 0; i < request.m_styles.size(); i++)
    {
      url += request.m_styles[i];

      if(i != request.m_styles.size() - 1)
      {
        url += ",";
      }
    }
  }

  if(!request.m_srs.empty())
  {
    url += "&SRS=" + request.m_srs;
  }

  url += "&BBOX=";
  url += boost::lexical_cast<std::string>(request.m_boundingBox.m_minX);
  url += ",";
  url += boost::lexical_cast<std::string>(request.m_boundingBox.m_minY);
  url += ",";
  url += boost::lexical_cast<std::string>(request.m_boundingBox.m_maxX);
  url += ",";
  url += boost::lexical_cast<std::string>(request.m_boundingBox.m_maxY);


  url += "&WIDTH=" + boost::lexical_cast<std::string>(request.m_width);
  url += "&HEIGHT=" + boost::lexical_cast<std::string>(request.m_height);

  url += "&FORMAT=" + request.m_format;

  if(request.m_transparent)
  {
    url += "&TRANSPARENT=TRUE";
  }

  if(!request.m_bgColor.empty())
  {
    url += "&BGCOLOR=" + request.m_bgColor;
  }

  if(!request.m_time.empty())
  {
    url += "&TIME=" + request.m_time;
  }

  return url;
}

std::string te::ws::ogc::WMSClient::buildGetFeatureInfoURL(const te::ws::ogc::wms::WMSGetFeatureInfoRequest& request) const
{
  //Sets base URL
  std::string url;

  if(m_version == "1.3.0")
  {
    url = this->build130GetFeatureInfoURL(request);
  }
  else if (m_version == "1.1.1")
  {
    url = this->build111GetFeatureInfoURL(request);
  }

  return url;
}

std::string te::ws::ogc::WMSClient::build130GetFeatureInfoURL(const te::ws::ogc::wms::WMSGetFeatureInfoRequest &request) const
{
  //Sets base URL
  std::string url = m_uri.uri();

  url = url + "SERVICE=WMS" + "&VERSION=" + m_version + "&REQUEST=GetFeatureInfo";

  if(request.m_getMap.m_layers.size() > 0)
  {
    url += "&LAYERS=";

    for(size_t i = 0; i < request.m_getMap.m_layers.size(); i++)
    {
      url += request.m_getMap.m_layers[i];

      if(i != request.m_getMap.m_layers.size() - 1)
      {
        url += ",";
      }
    }
  }

  if(request.m_getMap.m_styles.size() > 0)
  {
    url += "&STYLES=";

    for(size_t i = 0; i < request.m_getMap.m_styles.size(); i++)
    {
      url += request.m_getMap.m_styles[i];

      if(i != request.m_getMap.m_styles.size() - 1)
      {
        url += ",";
      }
    }
  }

  if(!request.m_getMap.m_srs.empty())
  {
    url += "&CRS=" + request.m_getMap.m_srs;
  }

  bool isInverted = te::ws::core::IsInvertedEPSG(request.m_getMap.m_srs);

  if(isInverted)
  {
    url += "&BBOX=";
    url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_minY);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_minX);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_maxY);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_maxX);
  }
  else
  {
    url += "&BBOX=";
    url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_minX);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_minY);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_maxX);
    url += ",";
    url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_maxY);
  }

  url += "&WIDTH=" + boost::lexical_cast<std::string>(request.m_getMap.m_width);
  url += "&HEIGHT=" + boost::lexical_cast<std::string>(request.m_getMap.m_height);

  if(request.m_queryLayers.size() > 0)
  {
    url += "&QUERY_LAYERS=";

    for(size_t i = 0; i < request.m_queryLayers.size(); i++)
    {
      url += request.m_queryLayers[i];

      if(i != request.m_queryLayers.size() - 1)
      {
        url += ",";
      }
    }
  }

  if(!request.m_infoFormat.empty())
  {
    url += "&INFO_FORMAT=" + request.m_infoFormat;
  }

  url += "&FEATURE_COUNT=" + boost::lexical_cast<std::string>(request.m_featureCount);

  url += "&i=" + boost::lexical_cast<std::string>(request.m_i);
  url += "&j=" + boost::lexical_cast<std::string>(request.m_j);

  if(!request.m_exceptions.empty())
  {
    url += "&EXCEPTIONS=" + request.m_exceptions;
  }

  return url;
}

std::string te::ws::ogc::WMSClient::build111GetFeatureInfoURL(const te::ws::ogc::wms::WMSGetFeatureInfoRequest &request) const
{
  //Sets base URL
  std::string url = m_uri.uri();

  url = url + "SERVICE=WMS" + "&VERSION=" + m_version + "&REQUEST=GetFeatureInfo";

  if(request.m_getMap.m_layers.size() > 0)
  {
    url += "&LAYERS=";

    for(size_t i = 0; i < request.m_getMap.m_layers.size(); i++)
    {
      url += request.m_getMap.m_layers[i];

      if(i != request.m_getMap.m_layers.size() - 1)
      {
        url += ",";
      }
    }
  }

  if(request.m_getMap.m_styles.size() > 0)
  {
    url += "&STYLES=";

    for(size_t i = 0; i < request.m_getMap.m_styles.size(); i++)
    {
      url += request.m_getMap.m_styles[i];

      if(i != request.m_getMap.m_styles.size() - 1)
      {
        url += ",";
      }
    }
  }

  if(!request.m_getMap.m_srs.empty())
  {
    url += "&SRS=" + request.m_getMap.m_srs;
  }


  url += "&BBOX=";
  url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_minX);
  url += ",";
  url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_minY);
  url += ",";
  url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_maxX);
  url += ",";
  url += boost::lexical_cast<std::string>(request.m_getMap.m_boundingBox.m_maxY);

  url += "&WIDTH=" + boost::lexical_cast<std::string>(request.m_getMap.m_width);
  url += "&HEIGHT=" + boost::lexical_cast<std::string>(request.m_getMap.m_height);

  if(request.m_queryLayers.size() > 0)
  {
    url += "&QUERY_LAYERS=";

    for(size_t i = 0; i < request.m_queryLayers.size(); i++)
    {
      url += request.m_queryLayers[i];

      if(i != request.m_queryLayers.size() - 1)
      {
        url += ",";
      }
    }
  }

  if(!request.m_infoFormat.empty())
  {
    url += "&INFO_FORMAT=" + request.m_infoFormat;
  }

  url += "&FEATURE_COUNT=" + boost::lexical_cast<std::string>(request.m_featureCount);

  url += "&X=" + boost::lexical_cast<std::string>(request.m_i);
  url += "&Y=" + boost::lexical_cast<std::string>(request.m_j);

  if(!request.m_exceptions.empty())
  {
    url += "&EXCEPTIONS=" + request.m_exceptions;
  }

  return url;
}