Merge branch 'develop' into feature/UndoRedoWithModelData

CMakeLists.txt

@@ -24,6 +24,7 @@ add_library(${TARGET_APP} STATIC
   data/settingshandler.h data/settingshandler.cpp
   model/tablemodel.h model/tablemodel.cpp
   model/modelitem.h model/modelitem.cpp
+  formats/jsonparser.h formats/jsonparser.cpp
 )
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})

formats/jsonparser.cpp

@@ -0,0 +1,58 @@
+#include "jsonparser.h"
+
+#include <QJsonArray>
+#include <QJsonObject>
+
+#include "../model/tablemodel.h"
+
+QList<QHash<int, QVariant>> JsonParser::toItemValuesList(const QByteArray& jsonData,
+                                                         const QString& objectName) {
+  QList<QHash<int, QVariant>> result;
+
+  if (jsonData.isEmpty()) {
+    return result;
+  }
+
+  QJsonArray itemArray = extractItemArray(jsonData, objectName);
+
+  foreach (QJsonValue value, itemArray) {
+    QJsonObject itemJsonObject  = value.toObject();
+    QHash<int, QVariant> values = jsonObjectToItemValues(itemJsonObject);
+    result.append(values);
+  }
+  return result;
+}
+
+QHash<int, QVariant> JsonParser::jsonObjectToItemValues(const QJsonObject& itemJsonObject) {
+  QHash<int, QVariant> values;
+
+  // TODO make this more generic (by reading from model meta data)
+  values[TableModel::NameRole] =
+      itemJsonObject[TableModel::ROLE_NAMES.value(TableModel::NameRole)].toString();
+  values[TableModel::DescriptionRole] =
+      itemJsonObject[TableModel::ROLE_NAMES.value(TableModel::DescriptionRole)].toString();
+  values[TableModel::InfoRole] =
+      itemJsonObject[TableModel::ROLE_NAMES.value(TableModel::InfoRole)].toString();
+  values[TableModel::AmountRole] =
+      itemJsonObject[TableModel::ROLE_NAMES.value(TableModel::AmountRole)].toInt();
+  values[TableModel::FactorRole] =
+      itemJsonObject[TableModel::ROLE_NAMES.value(TableModel::FactorRole)].toDouble();
+
+  return values;
+}
+
+JsonParser::JsonParser() {}
+
+QJsonArray JsonParser::extractItemArray(const QByteArray& jsonData, const QString& objectName) {
+  QJsonDocument doc = QJsonDocument::fromJson(jsonData);
+  QJsonArray itemArray;
+  if (objectName.isEmpty()) {
+    itemArray = doc.array();
+
+  } else {
+    QJsonObject rootObject = doc.object();
+    itemArray              = rootObject.value(QString("items")).toArray();
+  }
+
+  return itemArray;
+}

formats/jsonparser.h

@@ -0,0 +1,23 @@
+#ifndef JSONPARSER_H
+#define JSONPARSER_H
+
+#include <QVariant>
+
+class QJsonObject;
+class QString;
+class QByteArray;
+class QJsonArray;
+
+class JsonParser {
+ public:
+  static QList<QHash<int, QVariant>> toItemValuesList(const QByteArray& jsonData,
+                                                      const QString& objectName = "");
+
+ private:
+  explicit JsonParser();
+
+  static QJsonArray extractItemArray(const QByteArray& jsonData, const QString& objectName);
+  static QHash<int, QVariant> jsonObjectToItemValues(const QJsonObject& itemJsonObject);
+};
+
+#endif  // JSONPARSER_H

genericcore.cpp

@@ -76,7 +76,7 @@ void GenericCore::triggerApplicationUpdate() {
 
 std::shared_ptr<QUndoStack> GenericCore::getModUndoStack() const { return m_modelUndoStack; }
 
-std::shared_ptr<QAbstractItemModel> GenericCore::getModel() const { return m_mainModel; }
+std::shared_ptr<TableModel> GenericCore::getModel() const { return m_mainModel; }
 
 void GenericCore::setupModels() {
   m_mainModel = make_shared<TableModel>(this);
@@ -88,7 +88,6 @@ QString GenericCore::getMaintenanceToolFilePath() const {
 
 /// setting the applicationDirPath hard coded to test update feature from IDE
 #ifdef QT_DEBUG
-  // REFACTOR retrieve application name automatically instead of using hard coded name
   applicationDirPath = QString("/opt/%1").arg(APPLICATION_NAME);
 #endif
 

genericcore.h

@@ -23,7 +23,7 @@ class GenericCore : public QObject {
   void triggerApplicationUpdate();
 
   std::shared_ptr<QUndoStack> getModUndoStack() const;
-  std::shared_ptr<QAbstractItemModel> getModel() const;
+  std::shared_ptr<TableModel> getModel() const;
 
  signals:
   void displayStatusMessage(QString message);

model/tablemodel.cpp

@@ -1,17 +1,17 @@
 #include "tablemodel.h"
 
+#include "../formats/jsonparser.h"
 #include "modelitem.h"
 
-enum UserRoles { NameRole = Qt::UserRole + 1, DescriptionRole, InfoRole, AmountRole, FactorRole };
+QHash<int, QByteArray> TableModel::ROLE_NAMES = {{NameRole, "Name"},
-static const QHash<int, QByteArray> ROLE_NAMES = {{NameRole, "Name"},
+                                                 {DescriptionRole, "Description"},
-                                                  {DescriptionRole, "Description"},
+                                                 {InfoRole, "Info"},
-                                                  {InfoRole, "Info"},
+                                                 {AmountRole, "Amount"},
-                                                  {AmountRole, "Amount"},
+                                                 {FactorRole, "Factor"}};
-                                                  {FactorRole, "Factor"}};
 
 TableModel::TableModel(QObject* parent)
     : QAbstractTableModel{parent} {
-  for (int row = 0; row < 23; ++row) {
+  for (int row = 0; row < 5; ++row) {
     QHash<int, QVariant> values;
     values[NameRole]        = QString("Item %1").arg(row);
     values[DescriptionRole] = QString("This is item %1").arg(row);
@@ -28,9 +28,17 @@ Qt::ItemFlags TableModel::flags(const QModelIndex& index) const {
   return Qt::ItemIsEditable | QAbstractTableModel::flags(index);
 }
 
-int TableModel::rowCount(const QModelIndex& parent) const { return m_items.size(); }
+QHash<int, QByteArray> TableModel::roleNames() const { return ROLE_NAMES; }
 
-int TableModel::columnCount(const QModelIndex& parent) const { return ROLE_NAMES.size(); }
+int TableModel::rowCount(const QModelIndex& parent) const {
+  Q_UNUSED(parent);
+  return m_items.size();
+}
+
+int TableModel::columnCount(const QModelIndex& parent) const {
+  Q_UNUSED(parent);
+  return ROLE_NAMES.size();
+}
 
 QVariant TableModel::data(const QModelIndex& index, int role) const {
   const int row    = index.row();
@@ -46,6 +54,7 @@ QVariant TableModel::data(const QModelIndex& index, int role) const {
   int roleForColumn = getRoleForColumn(column);
   switch (role) {
     case Qt::DisplayRole:
+    case Qt::EditRole:
       return m_items.at(row)->data(roleForColumn);
   }
 
@@ -79,6 +88,50 @@ bool TableModel::setData(const QModelIndex& index, const QVariant& value, int ro
 
 // bool TableModel::setItemData(const QModelIndex& index, const QMap<int, QVariant>& roles) {}
 
+bool TableModel::removeRows(int firstRow, int nRows, const QModelIndex& parentIndex) {
+  if (parentIndex != QModelIndex()) {
+    qWarning() << "Removing of child rows is not supported yet!";
+    return false;
+  }
+
+  const int lastRow = firstRow + nRows - 1;
+  if (firstRow < 0 || lastRow >= m_items.size()) {
+    qWarning() << "Trying to remove rows is out of bounds!";
+    return false;
+  }
+
+  beginRemoveRows(QModelIndex(), firstRow, lastRow);
+  m_items.remove(firstRow, nRows);
+  endRemoveRows();
+
+  return true;
+}
+
+void TableModel::appendItems(const QByteArray& jsonDoc) { insertItems(-1, jsonDoc, QModelIndex()); }
+
+void TableModel::insertItems(int startPosition,
+                             const QByteArray& jsonDoc,
+                             const QModelIndex& parentIndex) {
+  qInfo() << "Inserting item(s) into model...";
+  if (parentIndex != QModelIndex()) {
+    qWarning() << "Using invalid parent index (no child support for now)";
+  }
+  if (startPosition == -1 || startPosition > m_items.size()) {
+    /// Appending item(s)
+    startPosition = m_items.size();
+  }
+
+  QList<QHash<int, QVariant>> valueList = JsonParser::toItemValuesList(jsonDoc);
+  const int nRows                       = valueList.size();
+  beginInsertRows(QModelIndex(), startPosition, startPosition + nRows - 1);
+  for (int row = 0; row < nRows; ++row) {
+    const int rowPosition      = startPosition + row;
+    shared_ptr<ModelItem> item = make_unique<ModelItem>(valueList.at(row));
+    m_items.insert(rowPosition, std::move(item));
+  }
+  endInsertRows();
+}
+
 int TableModel::getRoleForColumn(const int column) const {
   switch (column) {
     case 0:

model/tablemodel.h

@@ -8,20 +8,33 @@ class ModelItem;
 using namespace std;
 
 class TableModel : public QAbstractTableModel {
+  Q_OBJECT
+
  public:
+  enum UserRoles { NameRole = Qt::UserRole + 1, DescriptionRole, InfoRole, AmountRole, FactorRole };
+  static QHash<int, QByteArray> ROLE_NAMES;
+
   explicit TableModel(QObject* parent = nullptr);
 
   /// QAbstractItemModel interface
   Qt::ItemFlags flags(const QModelIndex& index) const override;
+  QHash<int, QByteArray> roleNames() const override;
 
-  int rowCount(const QModelIndex& parent) const override;
+  int rowCount(const QModelIndex& parent = QModelIndex()) const override;
-  int columnCount(const QModelIndex& parent) const override;
+  int columnCount(const QModelIndex& parent = QModelIndex()) const override;
   QVariant data(const QModelIndex& index, int role) const override;
   QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
 
   bool setData(const QModelIndex& index, const QVariant& value, int role) override;
   // bool setItemData(const QModelIndex& index, const QMap<int, QVariant>& roles) override;
 
+ public slots:
+  // bool insertRows(int position, int rows, const QModelIndex& parentIndex = QModelIndex())
+  // override;
+  bool removeRows(int firstRow, int nRows, const QModelIndex& parentIndex = QModelIndex()) override;
+  void appendItems(const QByteArray& jsonDoc);
+  void insertItems(int startPosition, const QByteArray& jsonDoc, const QModelIndex& parentIndex);
+
  private:
   /// members
   QList<shared_ptr<ModelItem>> m_items;