Initial commit based on GenericQtClient v0.3.0

libs/GenericCore/model/commands/edititemcommand.cpp

@@ -0,0 +1,80 @@
+#include "edititemcommand.h"
+
+#include <QDebug>
+
+#include "../metadata.h"
+#include "../tablemodel.h"
+
+EditItemCommand::EditItemCommand(TableModel* model,
+                                 const QModelIndex& index,
+                                 QMap<int, QVariant>& changedValues,
+                                 QUndoCommand* parent)
+    : QUndoCommand(parent)
+    , m_model(model)
+    , m_row(index.row()) {
+  qInfo() << "New EditCommand...";
+  QString commandText;
+
+  if (changedValues.size() == 1) {
+    qDebug() << "Only one value to change. Using more specific command text...";
+    const int role       = changedValues.firstKey();
+    const QVariant value = changedValues.first();
+    QString roleName     = model->roleNames().value(role);
+
+    if (USER_FACING_ROLES.contains(role)) {
+      commandText = QString("Setting '%1' of item '%2' to '%3'")
+                        .arg(roleName)
+                        .arg(index.data(DEFAULT_ROLE).toString())
+                        .arg(value.toString());
+    } else if (role == IdRole) {
+      commandText = QString("Setting '%1' of item '%2' to '%3'")
+                        .arg(roleName)
+                        .arg(index.data(DEFAULT_ROLE).toString())
+                        .arg(value.toString());
+    } else {
+      qWarning() << "Role didn't match! Using a generic command text...";
+      commandText = QString("Edit item '%1'").arg(index.data(DEFAULT_ROLE).toString());
+    }
+  } else {
+    qDebug() << "More than one value to change. Using a generic command text...";
+    commandText = QString("Edit item '%1'").arg(index.data(DEFAULT_ROLE).toString());
+  }
+  setText(commandText);
+
+  m_newValues = changedValues;
+
+  /// storing old values for undo step
+  m_oldValues = getOldValues(index, changedValues);
+}
+
+void EditItemCommand::undo() {
+  qDebug() << "Undoing the EditCommand...";
+  m_model->execEditItemData(m_row, m_oldValues);
+}
+
+void EditItemCommand::redo() {
+  qDebug() << "(Re-)doing the EditCommand...";
+  m_model->execEditItemData(m_row, m_newValues);
+}
+
+const QMap<int, QVariant> EditItemCommand::getOldValues(
+    const QModelIndex& index,
+    const QMap<int, QVariant>& changedValues) const {
+  QMap<int, QVariant> result;
+  QMap<int, QVariant>::const_iterator i;
+  for (i = changedValues.constBegin(); i != changedValues.constEnd(); ++i) {
+    const int role          = i.key();
+    const QVariant newValue = i.value();
+    const QVariant oldValue = index.data(role);
+    // TODO check if role is a editable role?
+    if (oldValue != newValue) {
+      qDebug() << "oldValue:" << oldValue << "!= newValue:" << newValue;
+      result.insert(role, oldValue);
+    } else {
+      qInfo() << "oldValue is already the same as newValue:" << oldValue;
+    }
+  }
+  // QVariant oldModifiedDate = index.data(ModifiedDateUTCRole);
+  // result.insert(ModifiedDateUTCRole, oldModifiedDate);
+  return result;
+}

libs/GenericCore/model/commands/edititemcommand.h

@@ -0,0 +1,33 @@
+#ifndef EDITITEMCOMMAND_H
+#define EDITITEMCOMMAND_H
+
+#include <QMap>
+#include <QUndoCommand>
+
+class TableModel;
+
+class EditItemCommand : public QUndoCommand {
+ public:
+  // TODO don't use simple pointer to model
+  /// Using simple pointer to model because there was a crash when closing the application with an
+  /// unclean undo stack
+  EditItemCommand(TableModel* model,
+                  const QModelIndex& index,
+                  QMap<int, QVariant>& changedValues,
+                  QUndoCommand* parent = nullptr);
+  /// QUndoCommand interface
+  void undo();
+  void redo();
+
+ private:
+  TableModel* m_model = nullptr;
+  const int m_row;
+  QMap<int, QVariant> m_oldValues;
+  QMap<int, QVariant> m_newValues;
+
+  /// private functions
+  const QMap<int, QVariant> getOldValues(const QModelIndex& index,
+                                         const QMap<int, QVariant>& changedValues) const;
+};
+
+#endif  // EDITITEMCOMMAND_H

libs/GenericCore/model/commands/insertrowscommand.cpp

@@ -0,0 +1,33 @@
+#include "insertrowscommand.h"
+
+#include <QDebug>
+
+#include "../tablemodel.h"
+
+InsertRowsCommand::InsertRowsCommand(TableModel* model,
+                                     int startRow,
+                                     QList<ModelItemValues> valueList,
+                                     QUndoCommand* parent)
+    : QUndoCommand(parent)
+    , m_tableModel(model)
+    , m_startRow(startRow)
+    , m_valueList(valueList) {
+  qInfo() << "New InsertCommand...";
+  const QString commandText =
+      QString("inserting %1 item(s) on row %2").arg(valueList.length()).arg(startRow);
+  setText(commandText);
+}
+
+void InsertRowsCommand::undo() {
+  qDebug() << "Undoing the InsertCommand...";
+  if (m_tableModel) {
+    m_tableModel->execRemoveItems(m_startRow, m_valueList.length());
+  }
+}
+
+void InsertRowsCommand::redo() {
+  qDebug() << "(Re-)doing the InsertCommand...";
+  if (m_tableModel) {
+    m_tableModel->execInsertItems(m_startRow, m_valueList);
+  }
+}

libs/GenericCore/model/commands/insertrowscommand.h

@@ -0,0 +1,30 @@
+#ifndef INSERTROWSCOMMAND_H
+#define INSERTROWSCOMMAND_H
+
+#include <QUndoCommand>
+
+typedef QMap<int, QVariant> ModelItemValues;
+
+class TableModel;
+
+class InsertRowsCommand : public QUndoCommand {
+ public:
+  // TODO don't use simple pointer to model
+  /// Using simple pointer to model because there was a crash when closing the application with an
+  /// unclean undo stack
+  InsertRowsCommand(TableModel* model,
+                    int startRow,
+                    QList<ModelItemValues> valueList,
+                    QUndoCommand* parent = nullptr);
+
+  /// QUndoCommand interface
+  void undo() override;
+  void redo() override;
+
+ private:
+  TableModel* m_tableModel;
+  const int m_startRow;
+  const QList<ModelItemValues> m_valueList;
+};
+
+#endif  // INSERTROWSCOMMAND_H

libs/GenericCore/model/commands/removerowscommand.cpp

@@ -0,0 +1,41 @@
+#include "removerowscommand.h"
+
+#include <QDebug>
+
+#include "../tablemodel.h"
+
+RemoveRowsCommand::RemoveRowsCommand(TableModel* model,
+                                     const int startRow,
+                                     const int nRows,
+                                     QUndoCommand* parent)
+    : QUndoCommand(parent)
+    , m_tableModel(model)
+    , m_startRow(startRow) {
+  qInfo() << "New RemoveCommand...";
+  const QString commandText =
+      QString("removing %1 item(s) on position %2").arg(nRows).arg(startRow);
+  setText(commandText);
+
+  for (int row = 0; row < nRows; ++row) {
+    const int rowPosition = startRow + row;
+    QModelIndex index     = m_tableModel->index(rowPosition, 0);
+
+    ModelItemValues values = m_tableModel->getItemValues(index);
+
+    m_valueList.append(values);
+  }
+}
+
+void RemoveRowsCommand::undo() {
+  qDebug() << "Undoing the RemoveCommand...";
+  if (m_tableModel) {
+    m_tableModel->execInsertItems(m_startRow, m_valueList);
+  }
+}
+
+void RemoveRowsCommand::redo() {
+  qDebug() << "(Re-)doing the RemoveCommand...";
+  if (m_tableModel) {
+    m_tableModel->execRemoveItems(m_startRow, m_valueList.length());
+  }
+}

libs/GenericCore/model/commands/removerowscommand.h

@@ -0,0 +1,30 @@
+#ifndef REMOVEROWSCOMMAND_H
+#define REMOVEROWSCOMMAND_H
+
+#include <QUndoCommand>
+
+class TableModel;
+
+typedef QMap<int, QVariant> ModelItemValues;
+
+class RemoveRowsCommand : public QUndoCommand {
+ public:
+  // TODO don't use simple pointer to model
+  /// Using simple pointer to model because there was a crash when closing the application with an
+  /// unclean undo stack
+  RemoveRowsCommand(TableModel* model,
+                    const int startRow,
+                    const int nRows,
+                    QUndoCommand* parent = nullptr);
+
+  /// QUndoCommand interface
+  void undo() override;
+  void redo() override;
+
+ private:
+  TableModel* m_tableModel;
+  const int m_startRow;
+  QList<ModelItemValues> m_valueList;
+};
+
+#endif  // REMOVEROWSCOMMAND_H