Items can be added to model dynamically.

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

@@ -70,7 +70,7 @@ void GenericCore::triggerApplicationUpdate() {
   QProcess::startDetached(toolFilePath, args);
 }
 
-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);

genericcore.h

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

model/tablemodel.cpp

@@ -1,13 +1,13 @@
 #include "tablemodel.h"
 
+#include "../formats/jsonparser.h"
 #include "modelitem.h"
 
-enum UserRoles { NameRole = Qt::UserRole + 1, DescriptionRole, InfoRole, AmountRole, FactorRole };
-static const QHash<int, QByteArray> ROLE_NAMES = {{NameRole, "Name"},
-                                                  {DescriptionRole, "Description"},
-                                                  {InfoRole, "Info"},
-                                                  {AmountRole, "Amount"},
-                                                  {FactorRole, "Factor"}};
+QHash<int, QByteArray> TableModel::ROLE_NAMES = {{NameRole, "Name"},
+                                                 {DescriptionRole, "Description"},
+                                                 {InfoRole, "Info"},
+                                                 {AmountRole, "Amount"},
+                                                 {FactorRole, "Factor"}};
 
 TableModel::TableModel(QObject* parent)
     : QAbstractTableModel{parent} {
@@ -28,6 +28,8 @@ Qt::ItemFlags TableModel::flags(const QModelIndex& index) const {
   return Qt::ItemIsEditable | QAbstractTableModel::flags(index);
 }
 
+QHash<int, QByteArray> TableModel::roleNames() const { return ROLE_NAMES; }
+
 int TableModel::rowCount(const QModelIndex& parent) const { return m_items.size(); }
 
 int TableModel::columnCount(const QModelIndex& parent) const { return ROLE_NAMES.size(); }
@@ -80,6 +82,31 @@ bool TableModel::setData(const QModelIndex& index, const QVariant& value, int ro
 
 // bool TableModel::setItemData(const QModelIndex& index, const QMap<int, QVariant>& roles) {}
 
+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,13 +8,19 @@ 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;
   QVariant data(const QModelIndex& index, int role) const override;
   QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
@@ -22,6 +28,10 @@ class TableModel : public QAbstractTableModel {
   bool setData(const QModelIndex& index, const QVariant& value, int role) override;
   // bool setItemData(const QModelIndex& index, const QMap<int, QVariant>& roles) override;
 
+ public slots:
+  void appendItems(const QByteArray& jsonDoc);
+  void insertItems(int startPosition, const QByteArray& jsonDoc, const QModelIndex& parentIndex);
+
  private:
   /// members
   QList<shared_ptr<ModelItem>> m_items;