305 lines
7.9 KiB
C++
Executable File
305 lines
7.9 KiB
C++
Executable File
/**
|
|
* @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
|