qt6-migration-pipeline/Lts/Common/CodeGen/svc_dao.cpp.grantlee

/**
  * @RDE_HEADER@
  * Template for 'real' structures including insert/update/delete functions for db
  * $Id: svc_db_impl.cpp.grantlee 56901 2022-04-22 04:21:30Z karwat $
  * $HeadURL: svn://192.168.133.21/TDS/branches/product/features/25_02_refactoring/Lts/Common/CodeGen/svc_db_impl.cpp.grantlee $
  * $Author: karwat $
  */

{% autoescape off %}
// filename: {{ namespace_abbr }}_dao.cpp
#include "{{ namespace_abbr }}_dao.h"
{% if custom_db_procs %}
#include <{{ include_prefix }}/{{ namespace_abbr }}_db_impl_custom.h>
{% endif %}

#include <ngldb/dbtransaction.h>
#include <ngldb/nsqlquery.h>
#include <ngldb/dbconnection.h>
#include <ngldb/sql_query_janitor.h>
#include <QtSql/QSqlError>
#include <QVariant>
#include <NGLLogger/INGLLogger.h>

namespace {{ namespace }}
{

Dao::Dao(int exerciseId)
  : m_query(nullptr)
  , m_exerciseId(exerciseId)
  , m_bEmitMessageOnError(true)
  , m_bCanHandleSchemas(true)
  , m_ownDatabaseConnection(true)
  , m_logger(getLogger("Db"))
{}

Dao::~Dao()
{
  m_query = nullptr;
{% if has_db_notifications %}
  QSqlDriver *driver = m_dbConnection.driver();
  if (driver && m_dbConnection.isOpen())
  {
{% for cpp_struct in cpp_structs %}{% for db_notify in cpp_struct.dbNotifications %}    driver->unsubscribeFromNotification(QStringLiteral("{{ db_notify }}"));
{% endfor %}{% endfor %}  }
{% endif %}
  if (m_ownDatabaseConnection && m_dbConnection.isOpen())
    m_dbConnection.close();
}

bool Dao::init(const QString &dbUser,
               const QString &dbPasswd,
               const QString &dbDriver,
               const QString &dbHost,
               const QString &dbName)
{
  m_ownDatabaseConnection = true;

  m_dbConnection = DBConnection::open(m_logger, dbUser, dbPasswd, dbDriver, dbHost, dbName, schemaName());

  return initInternal();
}

bool Dao::initInternal()
{
  QSqlDriver *driver = m_dbConnection.driver();
  if (!driver)
  {
    WARNING_LOG(m_logger) << "No SQL driver loaded - no database available!";
    return false;
  }
  const QString driverName = m_dbConnection.driverName();
  DEBUG_LOG(m_logger) << "Connected to database " << m_dbConnection.databaseName() << "@" << m_dbConnection.hostName()
                       << ", schema: " << schemaName() << ", used driver: " << driverName;
  if (!m_dbConnection.isOpen())
  {
    WARNING_LOG(m_logger) << "Database connection is no open - can not initialize database interface";
    return false;
  }
  if (driverName == QLatin1String("QSQLITE"))
    m_bCanHandleSchemas = false;

{% if has_db_notifications %}
  if (!driver->hasFeature(QSqlDriver::EventNotifications))
  {
    WARNING_LOG(m_logger) << "Can not subscribe to notifications - sqldriver does not support this feature!";
  }
  else
  {
    connect(driver, QOverload<const QString&,QSqlDriver::NotificationSource,const QVariant&>::of(&QSqlDriver::notification),
            this, &Dao::onNotification);
{% for cpp_struct in cpp_structs %}{% for db_notify in cpp_struct.dbNotifications %}driver->subscribeToNotification(QStringLiteral("{{ db_notify }}"));{% endfor %}{% endfor %}
  }
{% endif %}
  m_query = std::unique_ptr<NSqlQuery>(new NSqlQuery(m_dbConnection, m_logger));
  return true;
}

QString Dao::schemaName() const
{
  if (!m_bCanHandleSchemas)
    return QString();
  if (m_exerciseId <= 0)
    return QStringLiteral("{{ namespace_abbr }}");
  return DBCommon::getExerciseSchemaName(m_exerciseId);
}

QString Dao::dbUser() const
{
  if (m_exerciseId > 0)
    return QStringLiteral("ets_ex_00");
  else
    return QStringLiteral("ets_") + schemaName();
}

void Dao::setEmitMessageOnError(bool bEmit)
{
  m_bEmitMessageOnError = bEmit;
}

QString Dao::getTableName(const QString &tableName) const
{
  if (!m_bCanHandleSchemas)
    return tableName;
  if (m_exerciseId > 0)
    return DBCommon::getExerciseTableName(tableName, m_exerciseId);
  return QStringLiteral("{{ namespace_abbr }}.") + tableName;
}

QSqlError Dao::getLastError() const
{
  return m_lastError;
}

{% if has_db_notifications %}
void Dao::onNotification(const QString &name, QSqlDriver::NotificationSource source, const QVariant &payload)
{
  DEBUG_LOG(m_logger) << "Notification source = " << source;
  if (source == QSqlDriver::SelfSource)
    return;
  // search coresponding signal
{% for cpp_struct in cpp_structs %}{% for db_notify in cpp_struct.dbNotifications %}
  if (name == QStringLiteral("{{ db_notify }}"))
  {
    emit signal{{ db_notify }}(payload.toInt());

    return;
  }
  {% endfor %}{% endfor %}
}
{% endif %}

{% for cpp_struct in cpp_structs %}
//
// --> Struct: Database::{{ cpp_struct.name }}
//

bool Dao::select(QVector<Database::{{ cpp_struct.name }}> &dataVec, const QString &where)
{
  SqlQueryJanitor   janitor(m_query);
  const auto cb =[&dataVec] (const Database::{{ cpp_struct.name }} &data)
  {
    dataVec.push_back(data);
  };
  return selectPrepareInternal{{ cpp_struct.name }}(where) && selectFetchInternal{{ cpp_struct.name }}(cb);
}

bool Dao::selectPrepareInternal{{ cpp_struct.name }}(const QString &where)
{
  const QString tableName(getTableName(QStringLiteral("{{ cpp_struct.viewTableName }}")));
  const QString stmt(QStringLiteral("SELECT {% for row in cpp_struct.viewMember %}{{ row.dbColumnNameView }}{% if not forloop.last %}, {% endif %}{% endfor %}"
                                    " FROM ") + tableName + where);
  return m_query->prepare(stmt);
}

bool Dao::selectFetchInternal{{ cpp_struct.name }}(const std::function<void(const Database::{{ cpp_struct.name }} &data)> &cb)
{
  if (!m_query->exec(m_bEmitMessageOnError))
  {
    m_lastError = m_query->lastError();
    return false;
  }

  Database::{{ cpp_struct.name }} data;
  while (m_query->next())
  {
    int i = 0;
    {% for row in cpp_struct.viewMember %}
    data.{{ row.cppMemberName }}{{ row.cppFromQvPre1 }} = {{ row.cppFromQvPre2 }}m_query->value(i++){{ row.cppFromQvPost }};{% endfor %}
    cb(data);
  }

  return true;
}

// <-- Database::{{ cpp_struct.name }} end
{% endfor %}

/*static*/ QString Dao::qVariantToJsonString(const QVariant &value)
{
  return value.isNull() ? QStringLiteral("{}") : value.toString();
}

} // namespace {{ namespace }}
{% endautoescape %}