Initial commit

Lts/Tools/DBUpdate/exercises_model.cpp

@@ -0,0 +1,304 @@
+/**
+  * @RDE_HEADER@
+  * DBUpdate - Exercises updates model
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  *
+  * Created by Iuliana Ojog, 2021-02-17
+  */
+
+#include "exercises_model.h"
+
+#include <ngltools/ngltools_dtg.h>
+#include <ngldb/nsqlquery.h>
+
+#include <QColor>
+
+namespace DBUpdate
+{
+
+ExercisesModel::ExercisesModel(QObject *parent)
+  : QAbstractTableModel(parent)
+  , m_logger(getLogger("ExercisesModel"))
+{}
+
+ExercisesModel::~ExercisesModel()
+{}
+
+bool ExercisesModel::initModel(const QSqlDatabase &db, const QString &version, const QStringList &schemas)
+{
+  beginResetModel();
+  m_vecData.clear();
+  endResetModel();
+
+  // no exercise updates
+  if (schemas.contains(QStringLiteral("NONE")))
+    return true;
+
+  NSqlQuery q(db), q1(db);
+  q.setForwardOnly(false);
+
+  QString stmt = QStringLiteral("SELECT id, name, begin_time, end_time, exercise_state_id FROM exm.exercise;");
+
+  if (!q.exec(stmt))
+    return false;
+
+  int upperVersion = version.split(QLatin1Char('.')).at(0).toInt();
+  int versionInt = version.section(QLatin1Char('.'), 1).toInt();
+  DEBUG_LOG(m_logger) << "versionInt: " << versionInt;
+
+  while (q.next())
+  {
+    ExerciseUpdate e;
+    e.id        = q.value(0).toInt();
+    e.name      = q.value(1).toString();
+    e.startTime = q.value(2).toLongLong();
+    e.endTime   = q.value(3).toLongLong();
+    e.stateId   = q.value(4).toInt();
+
+    e.schema    = QStringLiteral("EX_")+QString::number(e.id);
+    e.isChecked = false;
+
+    QString stmt_db = QStringLiteral("SELECT id, version, description, updated, success FROM ") + e.schema +
+        QStringLiteral(".db_version WHERE success = true ORDER BY cast(regexp_replace(split_part(version,'.',1),'[^0-9]', '', 'g') as integer ) DESC"
+                       ", cast(regexp_replace(split_part(version,'.',2),'[^0-9]', '', 'g') as integer ) DESC,  updated DESC LIMIT 1;");
+
+    if (q1.execAndFetch(stmt_db))
+    {
+      e.version     = q1.value(1).toString();
+      e.description = q1.value(2).toString();
+      e.updated     = q1.value(3).toLongLong();
+
+    }
+    int upperEVersion = e.version.split(QLatin1Char('.')).at(0).toInt();
+    int eVersion = e.version.section(QLatin1Char('.'), 1).toInt();
+    DEBUG_LOG(m_logger) << "eVersion: " << eVersion;
+
+    if (upperVersion <= upperEVersion && eVersion < versionInt)
+      e.isChecked = true;
+
+    int lastUpperVersion = m_lastUpdate.split(QLatin1Char('.')).at(0).toInt();
+    int lastUpdateInt = m_lastUpdate.section(QLatin1Char('.'), 1).toInt();
+    DEBUG_LOG(m_logger) << "lastUpdateInt: " << lastUpdateInt;
+
+    if ( upperEVersion > lastUpperVersion )
+      m_lastUpdate = e.version;
+    else if ( upperEVersion == lastUpperVersion && eVersion >= lastUpdateInt)
+      m_lastUpdate = e.version;
+
+    if (schemas.contains(e.schema, Qt::CaseInsensitive) ||
+        schemas.contains(QStringLiteral("ALL"), Qt::CaseInsensitive) || schemas.isEmpty() ||
+       (schemas.contains(QStringLiteral("NOT_TERMINATED"), Qt::CaseInsensitive) && e.stateId != 6))
+      insertRow(e);
+  }
+
+  INFO_LOG(m_logger) << "initModel - #exercises: " << m_vecData.size();
+
+  return true;
+}
+
+QVariant ExercisesModel::data(const QModelIndex &index, int role) const
+{
+  if (!index.isValid() || index.row() >= m_vecData.size())
+    return QVariant();
+
+  const ExerciseUpdate &e = m_vecData.at(index.row());
+
+  if (role == Qt::BackgroundRole && e.stateId == 6)
+  {
+    return QColor(Qt::gray);
+  }
+
+  if (role == Qt::DisplayRole)
+  {
+    switch (index.column())
+    {
+    case Id:
+      return e.id;
+    case Name:
+      return QString(e.name);
+    case StartTime:
+      return DTG::toStringMSec(e.startTime);
+    case EndTime:
+      return DTG::toStringMSec(e.endTime);
+    case StateId:
+      return toString(e.stateId);
+    case Version:
+      return e.version;
+    case Description:
+      return e.description;
+    case Updated:
+      return DTG::toStringMSec(e.updated);
+    case Schema:
+      return e.schema;
+    }
+  }
+  else if (role == Qt::CheckStateRole)
+  {
+    // CheckBoxes only for columns that are actually checkable
+    if (!flags(index).testFlag(Qt::ItemIsUserCheckable))
+      return QVariant();
+
+    if (index.column() == Columns::Schema)
+      return e.isChecked ? Qt::Checked : Qt::Unchecked;
+  }
+
+  return QVariant();
+}
+
+int ExercisesModel::rowCount(const QModelIndex &parent) const
+{
+  return parent.isValid() ? 0 : m_vecData.size();
+}
+
+int ExercisesModel::columnCount(const QModelIndex &parent) const
+{
+  return parent.isValid() ? 0 : Columns::Updated + 1;
+}
+
+QVariant ExercisesModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+  if (orientation == Qt::Horizontal
+      && role == Qt::DisplayRole)
+  {
+    Columns col = static_cast<Columns>(section);
+    switch (col)
+    {
+    case Id:
+      return tr("Id");
+    case Name:
+      return tr("Exercise name");
+    case StartTime:
+      return tr("Start Time");
+    case EndTime:
+      return tr("End Time");
+    case StateId:
+      return tr("Exercise State");
+    case Schema:
+      return tr("Schema");
+    case Version:
+      return tr("Version");
+    case Description:
+      return tr("Description");
+    case Updated:
+      return tr("Updated");
+    }
+  }
+  return QAbstractTableModel::headerData(section, orientation, role);
+}
+
+ExerciseUpdate ExercisesModel::getRowData(int row) const
+{
+  if (row < 0 || row >= m_vecData.size())
+    return ExerciseUpdate();
+  return m_vecData.at(row);
+}
+
+bool ExercisesModel::insertRow(const ExerciseUpdate &item)
+{
+  beginInsertRows(QModelIndex(), m_vecData.size(), m_vecData.size());
+  m_vecData.append(item);
+  endInsertRows();
+  return true;
+}
+
+Qt::ItemFlags ExercisesModel::flags(const QModelIndex &index) const
+{
+  auto f = QAbstractTableModel::flags(index);
+  if (!index.isValid() || index.row() >= m_vecData.size())
+    return f;
+  if (index.column() == Columns::Schema)
+    f.setFlag(Qt::ItemIsUserCheckable);
+//  if (!m_vecData[index.row()].isChecked)
+//    f.setFlag(Qt::ItemIsEnabled, false);
+  f.setFlag(Qt::ItemIsEditable, false);
+  f.setFlag(Qt::ItemIsSelectable, true);
+  return f;
+}
+
+bool ExercisesModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
+  if (!index.isValid())
+    return false;
+
+  if (role != Qt::CheckStateRole)
+    return false;
+
+  if (!value.canConvert<bool>())
+    return false;
+
+  bool bVal = value.toBool();
+
+  ExerciseUpdate &data = m_vecData[index.row()];
+  if (data.isChecked != bVal)
+  {
+    data.isChecked = bVal;
+    emit dataChanged(index, index);
+  }
+  return true;
+}
+
+QStringList ExercisesModel::getSchemasToUpdate()
+{
+  QStringList schemas;
+
+  for(const ExerciseUpdate &eu : qAsConst(m_vecData))
+  {
+    if (eu.isChecked)
+      schemas << eu.schema;
+  }
+
+  return schemas;
+}
+
+void ExercisesProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
+{
+  m_sourceModel = qobject_cast<ExercisesModel*>(sourceModel);
+  QSortFilterProxyModel::setSourceModel(sourceModel);
+}
+
+bool ExercisesProxyModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
+{
+  if (!m_sourceModel ||
+      source_left.column() != source_right.column() ||
+      !source_left.isValid() ||
+      !source_right.isValid())
+    return QSortFilterProxyModel::lessThan(source_left, source_right);
+  const auto &dataLeft = m_sourceModel->m_vecData.at(source_left.row());
+  const auto dataRight = m_sourceModel->m_vecData.at(source_right.row());
+  switch (source_left.column())
+  {
+    case ExercisesModel::StartTime:
+      return dataLeft.startTime < dataRight.startTime;
+    case ExercisesModel::EndTime:
+      return dataLeft.endTime < dataRight.endTime;
+    case ExercisesModel::Updated:
+      return dataLeft.updated < dataRight.updated;
+  }
+  return QSortFilterProxyModel::lessThan(source_left, source_right);
+}
+
+QString ExercisesModel::toString(int stateId) const
+{
+  switch (stateId)
+  {
+  case 0:
+    return tr("Unknown");
+  case 1:
+    return tr("Created");
+  case 2:
+    return tr("Started");
+  case 3:
+    return tr("Paused");
+  case 5:
+    return tr("Stopped");
+  case 6:
+    return tr("Terminated");
+  default:
+    return tr("Unknown");
+  }
+  return QString::number(stateId);
+}
+
+} // namespace DBUpdate