WtssDialog.cpp

Go to the documentation of this file.

/*
  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

  This file is part of the TerraLib - a Framework for building GIS enabled
  applications.

  TerraLib is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License,
  or (at your option) any later version.

  TerraLib is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with TerraLib. See COPYING. If not, write to
  TerraLib Team at <terralib-team@terralib.org>.
*/

/*!
  \file terralib/qt/plugins/wtss/WtssDialog.cpp

  \brief Configuration dialog for Web Time Series Services plugin.

  \author Matheus Cavassan Zaglia
 */

// TerraLib
#include "../../../maptools/MarkRendererManager.h"
#include "../../../se/Fill.h"
#include "../../../se/Mark.h"
#include "../../../se/Stroke.h"
#include "../../../se/Utils.h"
#include "../../widgets/tools/AbstractTool.h"
#include "../../widgets/tools/PointPicker.h"
#include "../../widgets/utils/ScopedCursor.h"
#include "../../widgets/Utils.h"

// QT
#include <QFileDialog>
#include <QInputDialog>
#include <QMessageBox>

//Qwt
#include <qwt_legend.h>

// STL
#include <ctime>
#include <fstream>

// Boost
#include <boost/format.hpp>

// wtss.cxx
#include <wtss-cxx/wtss.hpp>

#include "WtssDialog.h"
#include "Exception.h"
#include "ServerManager.h"
#include "ui_WtssDialogForm.h"

namespace cxx = wtss::cxx;

te::qt::plugins::wtss::WtssDialog::WtssDialog(QWidget *parent,
                                                Qt::WindowFlags f)
    : QDialog(parent, f),
      m_ui(new Ui::WtssDialogForm),
      dirty(false),
      m_checkServer(0),
      m_checkCoverage(0),
      m_checkAttribute(0),
      m_mapDisplay(nullptr),
      m_chartDisplay(nullptr),
      m_timeSeriesChartVec(0),
      m_timeSeriesVec(0)
{
  m_ui->setupUi(this);

  this->setWindowTitle(tr("Web Time Series Services"));

  m_ui->m_addToolButton->setIcon(QIcon::fromTheme("list-add"));
  m_ui->m_removeToolButton->setIcon(QIcon::fromTheme("list-remove"));
  m_ui->m_refreshToolButton->setIcon(QIcon::fromTheme("view-refresh"));
  m_ui->m_hideToolButton->setIcon(QIcon::fromTheme("hide"));
  m_ui->m_importToolButton->setIcon(QIcon::fromTheme("document-open"));
  m_ui->m_exportToolButton->setIcon(QIcon::fromTheme("document-save-as"));
  m_ui->m_queryToolButton->setIcon(QIcon::fromTheme("media-playback-start-green"));

  srand(time(nullptr));

  connect(m_ui->m_addToolButton, SIGNAL(clicked()), this,
          SLOT(onServerAddButtonClicked()));
  connect(m_ui->m_removeToolButton, SIGNAL(clicked()), this,
          SLOT(onServerRemoveButtonClicked()));
  connect(m_ui->m_serverTreeWidget, SIGNAL(itemChanged(QTreeWidgetItem *, int)),
          this, SLOT(onItemChecked(QTreeWidgetItem *)));
  connect(m_ui->m_helpPushButton, SIGNAL(clicked()), this, SLOT(onHelpButtonClicked()));
  connect(m_ui->m_closePushButton, SIGNAL(clicked()), this, SLOT(close()));
  connect(m_ui->m_hideToolButton, SIGNAL(clicked()), this,
          SLOT(onHideButtonClicked()));
  connect(m_ui->m_refreshToolButton, SIGNAL(clicked()), this,
          SLOT(onServerRefreshButtonClicked()));
  connect(m_ui->m_importToolButton, SIGNAL(clicked()), this,
          SLOT(onImportGraphClicked()));
  connect(m_ui->m_exportToolButton, SIGNAL(clicked()), this,
          SLOT(onExportGraphClicked()));
  connect(m_ui->m_queryToolButton, SIGNAL(clicked()), this,
          SLOT(onQueryButtonClicked()));
  connect(m_ui->m_coordSListWidget, SIGNAL(itemClicked(QListWidgetItem *)),
          this, SLOT(onAddCoordToList(QListWidgetItem *)));
  connect(m_ui->m_pointToolButton, SIGNAL(toggled(bool)), this,
          SLOT(onPointPickerToggled(bool)));

  loadSettings();

  dirty = true;
}

te::qt::plugins::wtss::WtssDialog::~WtssDialog() = default;

void te::qt::plugins::wtss::WtssDialog::setMapDisplay(
    te::qt::widgets::MapDisplay *mapDisplay)
{
  m_mapDisplay = mapDisplay;
  m_pickerAction->setChecked(true);
}

void te::qt::plugins::wtss::WtssDialog::setActionGroup(QActionGroup* actionGroup)
{
  m_actionGroup = actionGroup;
  enablePointPicker();
}

void te::qt::plugins::wtss::WtssDialog::enablePointPicker()
{
  m_pickerAction = new QAction(this);
  m_pickerAction->setIcon(QIcon::fromTheme("placemark"));
  m_pickerAction->setToolTip(tr("Create by Point"));
  m_pickerAction->setCheckable(true);
  m_pickerAction->setEnabled(true);

  m_ui->m_pointToolButton->setDefaultAction(m_pickerAction);
  m_ui->m_pointToolButton->setVisible(true);
  m_actionGroup->addAction(m_ui->m_pointToolButton->defaultAction());
}

void te::qt::plugins::wtss::WtssDialog::onServerAddButtonClicked()
{
  dirty = false;

  QInputDialog *inputDialog = new QInputDialog();
  inputDialog->setOptions(QInputDialog::NoButtons);

  bool accept;

  QString uri = inputDialog->getText(nullptr, "Add Server", "Server URI:",
                                     QLineEdit::Normal, "", &accept);
  if(!accept)
  {
    dirty = true;
    return;
  }

  if(!uri.isEmpty())
  {
    te::qt::widgets::ScopedCursor c(Qt::WaitCursor);

    try
    {
      te::qt::plugins::wtss::ServerManager::getInstance().addServer(uri);

      j_config = te::qt::plugins::wtss::ServerManager::getInstance()
                     .loadSettings()
                     .object();

      addServer(uri);
    }
    catch(...)
    {
      QMessageBox::warning(this, tr("Web Time Series"),
                           tr("An error has occurred, "
                              "please retype the wtss "
                              "server address."));
    }
  }
  else
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                         tr("Please, input a server."));
  }

  dirty = true;
}

void te::qt::plugins::wtss::WtssDialog::onServerRemoveButtonClicked()
{
  dirty = false;

  if(m_ui->m_serverTreeWidget->currentItem() &&
     !m_ui->m_serverTreeWidget->currentItem()->parent())
  {
    QMessageBox::StandardButton reply = QMessageBox::question(
        this, "Remove server",
        "Remove '" + m_ui->m_serverTreeWidget->currentItem()->text(0) +
            "' server?",
        QMessageBox::Yes | QMessageBox::No);

    if(reply == QMessageBox::Yes)
    {
      try
      {
        te::qt::plugins::wtss::ServerManager::getInstance().removeServer(
            m_ui->m_serverTreeWidget->currentItem()->text(0));

        j_config = te::qt::plugins::wtss::ServerManager::getInstance()
                       .loadSettings()
                       .object();

        delete m_ui->m_serverTreeWidget->currentItem();

        m_chartDisplay->detachItems(te::qt::widgets::TIMESERIES_CHART);

        QMessageBox::information(this, tr("Web Time Series"),
                                 tr("The server was removed with success."));
      }
      catch(...)
      {
        QMessageBox::warning(this, tr("Web Time Series"),
                             tr("An error has occurred, please try again."));
      }
    }
  }
  else
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                         tr("Please, select a server."));
  }

  dirty = true;
}

void te::qt::plugins::wtss::WtssDialog::onServerRefreshButtonClicked()
{
  dirty = false;
  if(m_ui->m_serverTreeWidget->currentItem() &&
     !m_ui->m_serverTreeWidget->currentItem()->parent())
  {
    try
    {
      QString uri = m_ui->m_serverTreeWidget->currentItem()->text(0);

      te::qt::plugins::wtss::ServerManager::getInstance().refreshServer(uri);

      delete m_ui->m_serverTreeWidget->currentItem();

      addServer(uri);
    }
    catch(...)
    {
      QMessageBox::warning(this, tr("Web Time Series"),
                           tr("An error has occurred, "
                              "please check server list."));
    }
  }
  else
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                         tr("Please, select a server."));
  }

  dirty = true;
}

void te::qt::plugins::wtss::WtssDialog::onItemChecked(QTreeWidgetItem *item)
{
  if(dirty)
  {
    if(item->type() == treeItemType::attribute)
    {
      QString serverUri = item->parent()->parent()->text(0);
      QString cvName = item->parent()->text(0);
      QString attribute = item->text(0);

      te::qt::plugins::wtss::ServerManager::getInstance()
          .changeStatusAttribute(serverUri, cvName, attribute);

      if(!m_timeSeriesChartVec.empty())
      {
        bool attributeChecked = false;

        for(int i = 0; i < item->parent()->parent()->childCount(); ++i)
        {
          QTreeWidgetItem *attributeItem = item->parent()->child(i);
          if(attributeItem->text(0) != attribute)
          {
            if(attributeItem->checkState(0))
            {
              attributeChecked = true;

              for(int j = 0; j < m_timeSeriesChartVec.size(); ++j)
              {
                if(attribute.toUtf8().data() ==
                   std::string(
                       m_timeSeriesChartVec.at(j)->getTimeSeries()->getId()))
                {
                  m_timeSeriesChartVec.at(j)->detach();
                  m_timeSeriesChartVec.removeAt(j);
                }
              }
            }
          }
        }

        if(!attributeChecked)
        {
          m_chartDisplay->detachItems(te::qt::widgets::TIMESERIES_CHART);
          m_timeSeriesChartVec.clear();
        }
      }
    }
    else if(item->type() == treeItemType::coverage)
    {
      QString serverUri = item->parent()->text(0);
      QString cvName = item->text(0);
      te::qt::plugins::wtss::ServerManager::getInstance().changeStatusCoverage(
          serverUri, cvName);
      dirty = false;
      for(int i = 0; i < item->parent()->childCount(); ++i)
      {
        QTreeWidgetItem *cv = item->parent()->child(i);
        if(cv->text(0) != cvName)
        {
          if(cv->checkState(0))
            cv->setCheckState(0, Qt::Unchecked);
        }
      }
      dirty = true;
    }
    else if(item->type() == treeItemType::server)
    {
      QString serverUri = item->text(0);

      te::qt::plugins::wtss::ServerManager::getInstance().changeStatusServer(
          serverUri);
      dirty = false;
      int size = m_ui->m_serverTreeWidget->topLevelItemCount();
      for(int i = 0; i < size; ++i)
      {
        QTreeWidgetItem *sv = m_ui->m_serverTreeWidget->topLevelItem(i);
        QString server = sv->text(0);
        if(server != serverUri)
          sv->setCheckState(0, Qt::Unchecked);
      }
      dirty = true;
    }
  }
}

void te::qt::plugins::wtss::WtssDialog::onHideButtonClicked()
{
  if(m_ui->m_serverFrame->isVisible())
  {
    m_ui->m_serverFrame->hide();
    m_ui->m_hideToolButton->setIcon(QIcon::fromTheme("show"));
  }
  else
  {
    m_ui->m_serverFrame->show();
    m_ui->m_hideToolButton->setIcon(QIcon::fromTheme("hide"));
  }
}

void te::qt::plugins::wtss::WtssDialog::onHelpButtonClicked()
{
}

void te::qt::plugins::wtss::WtssDialog::onImportGraphClicked()
{
  QString csvFile =
      QFileDialog::getOpenFileName(this, tr("Select a TimeSeries CSV file"),
                                   te::qt::widgets::GetFilePathFromSettings("timeseriescsv"), "CSV file (*.csv)");

  if(csvFile.isEmpty())
    return;

  QFileInfo file(csvFile);

  te::qt::widgets::AddFilePathToSettings(file.absolutePath(), "timeseriescsv");

  std::ifstream csv(csvFile.toUtf8().data());

  std::string str;
  std::getline(csv, str);

  m_timeSeriesVec.clear();

  m_timeSeriesVec.push_back(
      new te::st::TimeSeries(file.completeBaseName().toUtf8().data()));

  while(std::getline(csv, str))
  {
    QString qstr = QString::fromUtf8(str.c_str());
    QStringList fields = qstr.split(',');
    QStringList date = fields.front().split("/");

    te::dt::DateTime *time = new te::dt::Date(boost::gregorian::date(
        date.at(2).toInt(), date.at(1).toInt(), date.at(0).toInt()));

    double value = fields.back().toDouble();

    m_timeSeriesVec.back()->add(time, value);
  }
  plotTimeSeries();
}

void te::qt::plugins::wtss::WtssDialog::onExportGraphClicked()
{
  if(m_result.query.attributes.empty())
    return;

  QString cvName(QString::fromUtf8(m_result.coverage.name.c_str()));

  std::vector<cxx::queried_attribute_t> attributes =
      m_result.coverage.queried_attributes;

  for(unsigned int i = 0; i < attributes.size(); i++)
  {
    cxx::queried_attribute_t attribute = attributes[i];

    QString csvFile = QFileDialog::getSaveFileName(
        this, tr("Save File"),
        te::qt::widgets::GetFilePathFromSettings("timeseriescsv") + "/" +
                "long" + m_ui->m_longLineEdit->text() + "_" + "lat" +
                m_ui->m_latLineEdit->text() + "_" + attribute.name.c_str() + ".csv",
        "CSV file (*.csv)");

    if(csvFile.isEmpty())
      return;

    QFileInfo info(csvFile);

    te::qt::widgets::AddFilePathToSettings(info.absolutePath(), "timeseriescsv");

    if(info.suffix().isEmpty())
      csvFile.append(".csv");

    std::ofstream myfile(csvFile.toUtf8().data());

    myfile << "Timeline,Value" << std::endl;

    for(unsigned int j = 0; j < attribute.values.size(); ++j)
    {
      QJsonObject j_attribute =
          te::qt::plugins::wtss::ServerManager::getInstance().getAttribute(
              QString::fromUtf8(m_lastQueriedServer.c_str()), cvName,
              QString::fromUtf8(attribute.name.c_str()));

      cxx::date d = m_result.coverage.timeline[j];

      double value =
          attribute.values[j] * j_attribute["scale_factor"].toDouble();

      myfile << d.day << "/" << d.month << "/" << d.year << "," << value
             << std::endl;
    }
    myfile.close();
  }
}

void te::qt::plugins::wtss::WtssDialog::onQueryButtonClicked()
{
  cxx::timeseries_query_t query;

  if(m_ui->m_latLineEdit->text().isEmpty() &&
     m_ui->m_longLineEdit->text().isEmpty())
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                         tr("Input the latitude and longitude coordinate."));
    return;
  }
  else if(m_ui->m_latLineEdit->text().isEmpty())
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                         tr("Input the latitude coordinate."));
    return;
  }
  else if(m_ui->m_longLineEdit->text().isEmpty())
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                         tr("Input the longitude coordinate."));
    return;
  }

  query.latitude = m_ui->m_latLineEdit->text().toDouble();
  query.longitude = m_ui->m_longLineEdit->text().toDouble();

  QDate startDate = m_ui->m_startDateEdit->date();
  QDate endDate = m_ui->m_endDateEdit->date();

  if(!startDate.operator<=(endDate))
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                         tr("The date informed is invalid."));
    return;
  }

  te::qt::plugins::wtss::ServerManager::getInstance().addDateFilter(
      startDate.toString("dd/MM/yyyy"), endDate.toString("dd/MM/yyyy"));

  query.start_date = startDate.toString("yyyy-MM-dd").toUtf8().data();
  query.end_date = endDate.toString("yyyy-MM-dd").toUtf8().data();

  doTimeseriesQuery(query);

  addMarker(query.longitude, query.latitude);
}

void te::qt::plugins::wtss::WtssDialog::onAddCoordToList(
    QListWidgetItem *coordSelected)
{
  cxx::timeseries_query_t query;

  //Get coordinate
  QStringList selectedCoord = coordSelected->text().split(",");

  query.longitude = selectedCoord.front().toDouble();
  query.latitude = selectedCoord.back().toDouble();

  //Get date
  QDate startDate = m_ui->m_startDateEdit->date();
  QDate endDate = m_ui->m_endDateEdit->date();

  if(!startDate.operator<=(endDate))
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                         tr("The date informed is invalid."));
    return;
  }

  te::qt::plugins::wtss::ServerManager::getInstance().addDateFilter(
      startDate.toString("dd/MM/yyyy"), endDate.toString("dd/MM/yyyy"));

  query.start_date = startDate.toString("yyyy-MM-dd").toUtf8().data();
  query.end_date = endDate.toString("yyyy-MM-dd").toUtf8().data();

  doTimeseriesQuery(query);

  std::unique_ptr<te::srs::Converter> converter(new te::srs::Converter());

  converter->setSourceSRID(4326);
  converter->setTargetSRID(m_mapDisplay->getSRID());

  te::gm::Coord2D coord;

  converter->convert(query.longitude, query.latitude, coord.x, coord.y);

  const te::gm::Envelope& currEnv = m_mapDisplay->getExtent();

  double auxX = (currEnv.m_urx - currEnv.m_llx) / 2;
  double auxY = (currEnv.m_ury - currEnv.m_lly) / 2;

  te::gm::Envelope env;

  env.m_llx = coord.x - auxX;
  env.m_lly = coord.y - auxY;
  env.m_urx = coord.x + auxX;
  env.m_ury = coord.y + auxY;

  m_mapDisplay->setExtent(env, true);

  addMarker(query.longitude, query.latitude);
}

void te::qt::plugins::wtss::WtssDialog::onGetPointCoordinate(QPointF &coord)
{
  std::unique_ptr<te::srs::Converter> converter(new te::srs::Converter());

  try
  {
    converter->setSourceSRID(m_mapDisplay->getSRID());
    converter->setTargetSRID(4326);
  }
  catch(...)
  {
    QMessageBox::warning(this, tr("Web Time Series"), tr("The display SRS is unknown."));
    return;
  }

  te::gm::Coord2D c;

  converter->convert(coord.x(), coord.y(), c.x, c.y);

  cxx::timeseries_query_t query;

  query.longitude = c.x;
  query.latitude = c.y;

  QDate startDate = m_ui->m_startDateEdit->date();
  QDate endDate = m_ui->m_endDateEdit->date();

  if(!startDate.operator <=(endDate))
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                         tr("The date informed is invalid."));
    return;
  }

  te::qt::plugins::wtss::ServerManager::getInstance().addDateFilter(
              startDate.toString("dd/MM/yyyy"), endDate.toString("dd/MM/yyyy"));

  query.start_date = startDate.toString("yyyy-MM-dd").toUtf8().data();
  query.end_date = endDate.toString("yyyy-MM-dd").toUtf8().data();

  if(m_ui->m_serverTreeWidget->topLevelItemCount() > 0)
  {
    doTimeseriesQuery(query);

    addMarker(query.longitude, query.latitude);
  }
}

void te::qt::plugins::wtss::WtssDialog::onPointPickerToggled(bool checked)
{
  if(!checked)
    return;

  if(!m_actionGroup->actions().contains(m_pickerAction))
    m_actionGroup->addAction(m_ui->m_pointToolButton->defaultAction());

  te::qt::widgets::PointPicker* pp = new te::qt::widgets::PointPicker(m_mapDisplay, Qt::CrossCursor);
  m_mapDisplay->setCurrentTool(pp);

  connect(pp, SIGNAL(pointPicked(QPointF&)), this, SLOT(onGetPointCoordinate(QPointF&)));
}

void te::qt::plugins::wtss::WtssDialog::loadSettings()
{
  try
  {
    //Define chartStyle
    te::qt::widgets::ChartStyle* chartStyle = new te::qt::widgets::ChartStyle();
    chartStyle->setTitle(QString::fromUtf8("Web Time Series"));
    chartStyle->setAxisX(QString::fromUtf8("Timeline"));
    chartStyle->setAxisY(QString::fromUtf8("Value"));

    m_chartDisplay = new te::qt::widgets::ChartDisplay(
        m_ui->m_timeSeriesFrame, QString::fromUtf8("Web Time Series"),
        chartStyle);

    QGridLayout *m_layout = new QGridLayout(m_ui->m_timeSeriesFrame);
    m_layout->addWidget(m_chartDisplay, 0, 0);
    m_layout->setContentsMargins(0, 0, 0, 0);

    //Define marker
    te::se::Stroke *stroke = te::se::CreateStroke("#000000", "1");
    te::se::Fill *fill = te::se::CreateFill("#000000", "1.0");
    te::se::Mark* marker = te::se::CreateMark("cross", stroke, fill);
    m_rgbaMarker =
        te::map::MarkRendererManager::getInstance().render(marker, 12);

    //Get server settings
    j_config = te::qt::plugins::wtss::ServerManager::getInstance()
                   .loadSettings()
                   .object();

    QJsonObject j_servers = j_config.find("servers").value().toObject();

    if(j_servers.isEmpty())
      return;

    for(QJsonObject::iterator it = j_servers.begin(); it != j_servers.end(); ++it)
      addServer(it.key());

    //Get date settings
    QJsonObject j_datefilter = j_config.find("date_filter").value().toObject();

    if(j_datefilter.isEmpty())
      return;

    QString startDate = j_datefilter.find("start_date").value().toString();

    QString endDate = j_datefilter.find("end_date").value().toString();

    m_ui->m_startDateEdit->setDate(QDate::fromString(startDate, "dd/MM/yyyy"));

    m_ui->m_endDateEdit->setDate(QDate::fromString(endDate, "dd/MM/yyyy"));
  }
  catch(...)
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                         tr("An error has occurred, "
                            "when try to load settings."));
  }
}

void te::qt::plugins::wtss::WtssDialog::addServer(QString server)
{
  QJsonObject j_servers = j_config.find("servers").value().toObject();

  QJsonObject j_server = j_servers.find(server).value().toObject();

  QTreeWidgetItem *serverItem =
      new QTreeWidgetItem(m_ui->m_serverTreeWidget, treeItemType::server);

  serverItem->setText(0, server);

  serverItem->setFlags(serverItem->flags() | Qt::ItemIsUserCheckable);

  bool active = j_server.find("active").value().toBool();

  if(active)
    serverItem->setCheckState(0, Qt::Checked);
  else
    serverItem->setCheckState(0, Qt::Unchecked);

  addCoverage(serverItem, j_server);
}

void te::qt::plugins::wtss::WtssDialog::addCoverage(
    QTreeWidgetItem *serverItem, QJsonObject j_server)
{
  QJsonObject j_coverages = j_server["coverages"].toObject();

  for(QJsonObject::iterator it = j_coverages.begin(); it != j_coverages.end();
      it++)
  {
    bool active = it.value().toObject().find("active").value().toBool();
    QTreeWidgetItem *coverageItem =
        new QTreeWidgetItem(treeItemType::coverage);

    coverageItem->setText(0, it.key());

    coverageItem->setFlags(coverageItem->flags() | Qt::ItemIsUserCheckable);

    if(active)
      coverageItem->setCheckState(0, Qt::Checked);
    else
      coverageItem->setCheckState(0, Qt::Unchecked);

    serverItem->addChild(coverageItem);

    addAtributes(coverageItem, it.value().toObject());
  }
}

void te::qt::plugins::wtss::WtssDialog::addAtributes(
    QTreeWidgetItem *coverageItem, QJsonObject j_coverage)
{
  QJsonObject j_attributes = j_coverage.find("attributes").value().toObject();

  for(QJsonObject::iterator it = j_attributes.begin(); it != j_attributes.end();
      it++)
  {
    QString attribute = it.key();

    bool active = it.value().toObject().find("active").value().toBool();
    QTreeWidgetItem *attributeItem =
        new QTreeWidgetItem(treeItemType::attribute);

    attributeItem->setText(0, attribute);
    attributeItem->setFlags(attributeItem->flags() | Qt::ItemIsUserCheckable);

    if(active)
      attributeItem->setCheckState(0, Qt::Checked);
    else
      attributeItem->setCheckState(0, Qt::Unchecked);

    coverageItem->addChild(attributeItem);
  }
}

bool te::qt::plugins::wtss::WtssDialog::validateQuery()
{
  if(!m_checkServer)
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                           tr("Please, select a server"));
    return false;
  }
  if(!m_checkCoverage)
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                           tr("Please, select a coverage."));
    return false;
  }
  if(!m_checkAttribute)
  {
    QMessageBox::warning(this, tr("Web Time Series"),
                             tr("Please, select an attribute."));
    return false;
  }

  return true;
}

void te::qt::plugins::wtss::WtssDialog::doTimeseriesQuery(
    cxx::timeseries_query_t query)
{
  clearCanvas();

  m_ui->m_latLineEdit->setText(QString::number(query.latitude));
  m_ui->m_longLineEdit->setText(QString::number(query.longitude));

  te::qt::widgets::ScopedCursor c(Qt::WaitCursor);

  QJsonObject j_object = te::qt::plugins::wtss::ServerManager::getInstance()
                             .loadSettings()
                             .object();

  if(j_object.isEmpty())
    return;

  QJsonObject j_servers = j_object.find("servers").value().toObject();

  QJsonObject j_server;

  m_checkServer = false;
  m_checkCoverage = false;
  m_checkAttribute = false;

  for(QJsonObject::iterator it_server = j_servers.begin();
      it_server != j_servers.end(); ++it_server)
  {
    j_server = it_server.value().toObject();

    if(j_server.find("active").value().toBool())
    {
      std::string serverUri = it_server.key().toStdString();

      QJsonObject j_coverages = j_server["coverages"].toObject();

      for(QJsonObject::iterator it_coverages = j_coverages.begin();
          it_coverages != j_coverages.end(); it_coverages++)
      {
        if(it_coverages.value().toObject().find("active").value().toBool())
        {
          cxx::timeseries_query_t new_q;

          new_q.latitude = query.latitude;
          new_q.longitude = query.longitude;
          new_q.coverage_name = it_coverages.key().toUtf8().data();
          new_q.start_date = query.start_date;
          new_q.end_date = query.end_date;

          QJsonObject j_attributes = it_coverages.value()
                                         .toObject()
                                         .find("attributes")
                                         .value()
                                         .toObject();

          for(QJsonObject::iterator it_attributes = j_attributes.begin();
              it_attributes != j_attributes.end(); it_attributes++)
          {
            QJsonObject j_attribute = it_attributes.value().toObject();

            if(j_attribute["active"].toBool() == true)
            {
              new_q.attributes.push_back(it_attributes.key().toUtf8().data());
              m_checkAttribute = true;
            }
          }

          if(new_q.attributes.size() > 0)
          {
            cxx::client remote(serverUri);

            try
            {
              m_result = remote.time_series(new_q);
              m_lastQueriedServer = it_server.key().toUtf8().data();
              convertToTimeSeries(m_result);
            }
            catch(const std::exception&)
            {
              QMessageBox::warning(this, tr("Web Time Series"),
                                   tr("The coordinates "
                                      "informed are invalid."));
              return;
            }
          }
          m_checkCoverage = true;
        }
      }
      m_checkServer = true;
    }
  }

  if(!validateQuery())
  {
    m_chartDisplay->detachItems(te::qt::widgets::TIMESERIES_CHART);
    return;
  }

  addLocation(query.longitude, query.latitude);

  plotTimeSeries();
}

void te::qt::plugins::wtss::WtssDialog::convertToTimeSeries(
    cxx::timeseries_query_result_t result)
{
  QString cvName(QString::fromUtf8(result.coverage.name.c_str()));

  std::vector<cxx::queried_attribute_t> attributes =
      result.coverage.queried_attributes;

  m_timeSeriesVec.clear();

  for(unsigned int i = 0; i < attributes.size(); i++)
  {
    cxx::queried_attribute_t attribute = attributes[i];

    m_timeSeriesVec.push_back(new te::st::TimeSeries(attribute.name));

    for(unsigned int j = 0; j < attribute.values.size(); ++j)
    {
      QJsonObject j_attribute =
          te::qt::plugins::wtss::ServerManager::getInstance().getAttribute(
              QString::fromUtf8(m_lastQueriedServer.c_str()), cvName,
              QString::fromUtf8(attribute.name.c_str()));

      cxx::date d = result.coverage.timeline[j];
      te::dt::DateTime *time =
          new te::dt::Date(boost::gregorian::date(d.year, d.month, d.day));

      double value =
          attribute.values[j] * j_attribute["scale_factor"].toDouble();

      m_timeSeriesVec.at(i)->add(time, value);
    }
  }
}

void te::qt::plugins::wtss::WtssDialog::plotTimeSeries()
{
  if(m_timeSeriesVec.empty())
    return;

  for(unsigned int i = 0; i < m_timeSeriesVec.size(); ++i)
  {
    te::qt::widgets::TimeSeriesChart* timeSeriesChart =
        new te::qt::widgets::TimeSeriesChart(m_timeSeriesVec.at(i));

    timeSeriesChart->setTitle(tr(m_timeSeriesVec.at(i)->getId().c_str()));

    if(!m_timeSeriesChartVec.empty())
    {
      for(int j = 0; j < m_timeSeriesChartVec.size(); ++j)
      {
        if(std::string(m_timeSeriesVec.at(i)->getId()) ==
           std::string(m_timeSeriesChartVec.at(j)->getTimeSeries()->getId()))
        {
          m_timeSeriesChartVec.at(j)->detach();
          m_timeSeriesChartVec.removeAt(j);
        }
      }
    }

    m_timeSeriesChartVec.push_back(timeSeriesChart);
  }

  for(int i = 0; i < m_timeSeriesChartVec.size(); ++i)
  {
    m_timeSeriesChartVec.at(i)->setPen(QPen(randomColor()));
    m_timeSeriesChartVec.at(i)->attach(m_chartDisplay);

    m_chartDisplay->insertLegend(new QwtLegend(), QwtPlot::RightLegend);
    m_chartDisplay->adjustDisplay();
    m_chartDisplay->show();
  }
}

void te::qt::plugins::wtss::WtssDialog::addMarker(double x, double y)
{
  const te::gm::Envelope &env = m_mapDisplay->getExtent();

  te::qt::widgets::Canvas canvas(m_mapDisplay->getDraftPixmap());

  canvas.setWindow(env.m_llx, env.m_lly, env.m_urx, env.m_ury);
  canvas.setPointPattern(m_rgbaMarker, 12, 12);

  std::unique_ptr<te::srs::Converter> converter(new te::srs::Converter());

  converter->setSourceSRID(4326);
  converter->setTargetSRID(m_mapDisplay->getSRID());

  te::gm::Coord2D coord;

  converter->convert(x, y, coord.x, coord.y);

  te::gm::Point point(coord.x, coord.y);

  canvas.setPointColor(te::color::RGBAColor(0, 0, 0, 0));
  canvas.draw(&point);

  m_mapDisplay->repaint();
}

QColor te::qt::plugins::wtss::WtssDialog::randomColor()
{
  int r = rand() % 255;
  int g = rand() % 255;
  int b = rand() % 255;
  return QColor(r, g, b);
}

void te::qt::plugins::wtss::WtssDialog::addLocation(double x, double y)
{
  QList<QListWidgetItem *> coord = m_ui->m_coordSListWidget->findItems(
      QString::number(x) + "," + QString::number(y), Qt::MatchExactly);
  if(coord.length() != 0)
    return;

  m_ui->m_coordSListWidget->addItem(QString::number(x) + "," +
                                    QString::number(y));
}

void te::qt::plugins::wtss::WtssDialog::clearCanvas()
{
  te::qt::widgets::Canvas canvas(m_mapDisplay->getDraftPixmap());

  canvas.clear();

  m_mapDisplay->refresh();
}

void te::qt::plugins::wtss::WtssDialog::closeEvent(QCloseEvent * /*e*/)
{
  m_chartDisplay->detachItems(te::qt::widgets::TIMESERIES_CHART);

  m_ui->m_coordSListWidget->clear();

  m_ui->m_latLineEdit->clear();
  m_ui->m_longLineEdit->clear();

  clearCanvas();

  m_mapDisplay->setCursor(Qt::ArrowCursor);
  m_mapDisplay->setCurrentTool(nullptr, false);

  emit close();
}