DatabaseGenerator.hpp

#pragma once

#include <ChangeListener.hpp>
#include <Configuration.hpp>
#include <databases/DatabaseManager.hpp>
#include <databases/DatabaseUtils.hpp>
#include <Showcase.hpp>
#include <Utils.hpp>
#include <Export.hpp>

#include <boost/expected/expected.hpp>

namespace Showcase
{
  template <typename GeneratorType>
  class SHOWCASE_API DatabaseGenerator : public GeneratorType
  {
  public:
    DatabaseGenerator();
    virtual ~DatabaseGenerator();

    virtual QString protocol() const override;
    virtual bool init(const GraphNode & node) override;
    virtual bool isValidId(const NodeId & id) = 0;
    ChangeListenerPtr changeListener();

    void doKeyValueQuery(const QString & command, PropertyMap & props,
                         const QStringList & columns);
    boost::expected<QString>  getTheme() const;

    QString connectionName();

    NodeId targetNode() const;
    NodeId listenerId() const;

  private:
    QString m_connectionName;
    ChangeListener::Key m_key;
    NodeId m_node;
  };


  template <typename GeneratorType>
  DatabaseGenerator<GeneratorType>::DatabaseGenerator()
  {
  }

  template <typename GeneratorType>
  DatabaseGenerator<GeneratorType>::~DatabaseGenerator()
  {
    auto listener = changeListener();
    if(listener)
      listener->unsubscribeToChanges(m_key);
  }

  template <typename GeneratorType>
  QString DatabaseGenerator<GeneratorType>::protocol() const
  {
    QString proto = Utils::protocol(targetNode());
    if(DatabaseManager::supportsProtocol(proto))
      return proto;
    return "";
  }

  template <typename GeneratorType>
  bool DatabaseGenerator<GeneratorType>::init(const GraphNode & node)
  {
    if(!GeneratorType::init(node))
      return false;
    if (!isValidId(node.id))
      return false;

    m_node = node.id;

    m_connectionName = DB::getServer(node.id);

    ChangeListener::NotifiableWeakPtr me =
        std::dynamic_pointer_cast<Notifiable>(this->shared_from_this());

    auto listener = changeListener();
    if(listener)
      m_key = listener->subscribeToChanges(DB::getBaseNodeId(node.id), me);

    return true;
  }

  template <typename GeneratorType>
  ChangeListenerPtr DatabaseGenerator<GeneratorType>::changeListener()
  {
    if(auto s = Showcase::weakInstance().lock()) {
      auto remoteControl = s->remoteControl();
      return remoteControl->changeListener();
    }

    return nullptr;
  }

  template <typename GeneratorType>
  void DatabaseGenerator<GeneratorType>::doKeyValueQuery(const QString & command, PropertyMap & props,
                                                 const QStringList & columns)
  {
    auto databaseConnection = DatabaseManager::connection(m_connectionName);
    QSqlQuery query(databaseConnection);
    query.prepare(command);
    QList<QVariantMap> q = DB::query(query, columns);

    for (const auto & r : q) {
      QByteArray key = r.value(columns.at(0)).toByteArray();
      QVariant value = r.value(columns.at(1));
      props[key] = value;
    }
  }

  template <typename GeneratorType>
  boost::expected<QString> DatabaseGenerator<GeneratorType>::getTheme() const
  {
    RunConfigurationPtr config = Showcase::instance()->runConfiguration();
    if (config) {
      auto theme = config->theme.id;
      if (!theme.isEmpty())
        return QString(theme);
    }
    return boost::make_unexpected("No valid theme");
  }

  template <typename GeneratorType>
  QString DatabaseGenerator<GeneratorType>::connectionName()
  {
    return m_connectionName;
  }

  template <typename GeneratorType>
  NodeId DatabaseGenerator<GeneratorType>::targetNode() const
  {
    return m_node;
  }

  template<typename GeneratorType>
  NodeId DatabaseGenerator<GeneratorType>::listenerId() const
  {
    return m_key.first;
  }
}