First shot at MappingTreeModel

MappingTreeModel is a generic approach at mappings files to generic
data, eg atttributes, actors or themes. It compiles, but nothing more.
So expect many exciting bugs and SegFaults.

1 files changed, 244 insertions, 0 deletions

diff --git a/mappingtreemodel.cpp b/mappingtreemodel.cpp
new file mode 100644
index 0000000..e48c608
--- /dev/null
+++ b/mappingtreemodel.cpp
@@ -0,0 +1,244 @@
+/*
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  as published by the Free Software Foundation; either version
+  2 of the License, or (at your option) any later version.
+*/
+
+#include <QSqlDatabase>
+#include <QSqlQuery>
+
+#include "mappingtreemodel.h"
+#include "smtreeitem.h"
+
+MappingTreeModel::MappingTreeModel(QStringList &headers, QObject *parent) : SmTreeModel(headers, parent), mType(-1) {
+    //init database
+    mDb = QSqlDatabase::database("treedb");
+    mTypesQ = new QSqlQuery(mDb);
+    mTypesQ->prepare("SELECT imappings_type_id, tmappings_type_name FROM mapppings_type");
+    getMappingTypes();
+
+    //prepare Queries
+    mTypeParentsQ = new QSqlQuery(mDb);
+    mTypeParentsQ->prepare("SELECT imapping_id, tmapping_name, tscreated FROM mappings WHERE imapping_id NOT IN (SELECT imapping_id FROM mappings_parents) AND imapping_type = :type");
+    mChildrenQ = new QSqlQuery(mDb);
+    mChildrenQ->prepare("SELECT mappings.imapping_id, mappings.tmapping_name, mappings.tscreated FROM mappings, mappings_parents WHERE mappings_parents.iparent_id = :id AND mappings.imapping_id = mappings_parents.imapping_id");
+    mUpdateTypeQ = new QSqlQuery(mDb);
+    mUpdateTypeQ->prepare("UPDATE mappings_type SET tmappings_type_name = :value WHERE imappings_type_id = :id");
+    mUpdateChildQ = new QSqlQuery(mDb);
+    mUpdateChildQ->prepare("UPDATE mappings SET tmapping_name = :value WHERE imapping_id = :id");
+    mAddMappingTypeQ = new QSqlQuery(mDb);
+    mAddMappingTypeQ->prepare("INSERT INTO mappings_type (tmappings_type_name) VALUES(:value)");
+    mDeleteMappingTypeQ = new QSqlQuery(mDb);
+    mDeleteMappingTypeQ->prepare("DELETE FROM mappings_type WHERE imappings_type_id = :id");
+    mAddChildQ = new QSqlQuery(mDb);
+    mAddChildQ->prepare("INSERT INTO mappings (tmapping_name, imapping_type) VALUES(:name, :type)");
+    mSelectChildQ = new QSqlQuery(mDb);
+    mSelectChildQ->prepare("SELECT imapping_id, tmapping_name, tscreated FROM mappings WHERE tmapping_name = :name AND imapping_type = :type");
+    mAddParentQ = new QSqlQuery(mDb);
+    mAddParentQ->prepare("INSERT INTO mappings_parents VALUES(:id, :parentid");
+    mDeleteChildQ = new QSqlQuery(mDb);
+    mDeleteChildQ->prepare("DELETE FROM mappings WHERE imapping_id = :id");
+}
+
+MappingTreeModel::~MappingTreeModel(){
+    delete mTypesQ;
+    delete mTypeParentsQ;
+    delete mChildrenQ;
+    delete mUpdateTypeQ;
+    delete mUpdateChildQ;
+    delete mAddMappingTypeQ;
+    delete mDeleteMappingTypeQ;
+    delete mAddChildQ;
+    delete mSelectChildQ;
+    delete mAddParentQ;
+    delete mDeleteChildQ;
+    mDb = QSqlDatabase();
+}
+
+QStringList MappingTreeModel::mappingTypeNames() const {
+    QStringList retval;
+    foreach(mappingType t, mMappingTypes){
+        retval << t.name.toString();
+    }
+    qSort(retval);
+    return retval;
+}
+
+int MappingTreeModel::mappingTypeIdFromName(const QVariant &name) const{
+    foreach(const mappingType t, mMappingTypes){
+        if(t.name == name){
+            return t.id.toInt();
+        }
+    }
+    return -1;
+}
+
+QString MappingTreeModel::mappingTypeNameFromId(int id) const{
+    foreach(const mappingType t, mMappingTypes){
+        if(t.id == id){
+            return t.name.toString();
+        }
+    }
+    return QString();
+}
+
+QVariant MappingTreeModel::data(const QModelIndex &index, int role) const{
+    if(!index.isValid()){
+        return QVariant();
+    }
+    SmTreeItem *item = itemAt(index);
+    if(role == NameRole){
+        return item->data(Name);
+    }
+    if(role == IdRole){
+        return item->data(Id);
+    }
+    if(role == AddedRole){
+        return item->data(Added);
+    }
+    return SmTreeModel::data(index, role);
+}
+
+bool MappingTreeModel::setData(const QModelIndex &index, const QVariant &value, int role){
+    if(!index.isValid()){
+        return false;
+    }
+    if(role == Qt::EditRole || role == NameRole){
+        mDb.transaction();
+        SmTreeItem *item = itemAt(index);
+        QSqlQuery *q = 0;
+        if(item == root()){
+            q = mUpdateTypeQ;
+        }else{
+            q = mUpdateChildQ;
+        }
+        q->bindValue(":value", value);
+        q->bindValue(":id", item->data(Id));
+        if(q->exec()){
+            item->setData(Name, value);
+            emit dataChanged(index, index);
+            mDb.commit();
+            return true;
+        }
+        mDb.rollback();
+    }
+    return false;
+}
+
+bool MappingTreeModel::addMappingType(const QString &type){
+    mAddMappingTypeQ->bindValue(":value", type);
+    mDb.transaction();
+    if(mAddMappingTypeQ->exec()){
+        mDb.commit();
+        getMappingTypes();
+        return true;
+    }
+    mDb.rollback();
+    return false;
+}
+
+bool MappingTreeModel::deleteMappingType(int typeId){
+    mDeleteMappingTypeQ->bindValue(":id", typeId);
+    mDb.transaction();
+    if(mDeleteMappingTypeQ->exec()){
+        mDb.commit();
+        getMappingTypes();
+        return true;
+    }
+    mDb.rollback();
+    return false;
+}
+
+bool MappingTreeModel::addChild(const QVariant &name, const QModelIndex &parent){
+    if(!parent.isValid()){
+        return false;
+    }
+    SmTreeItem *pItem = itemAt(parent);
+    mAddChildQ->bindValue(":name", name);
+    mAddChildQ->bindValue(":type", mType);
+    if(mAddChildQ->exec()){
+        mSelectChildQ->bindValue(":name", name);
+        mSelectChildQ->bindValue(":type", mType);
+        while(mSelectChildQ->next()){
+            QList<QVariant> newData;
+            newData << mSelectChildQ->value(1) << mSelectChildQ->value(0) << mSelectChildQ->value(2);
+            SmTreeItem *childItem = new SmTreeItem(newData, pItem);
+            pItem->appendChild(childItem);
+            mAddParentQ->bindValue(":id", childItem->data(Id));
+            mAddParentQ->bindValue(":parentid", pItem->data(Id));
+            mAddParentQ->exec();
+            emit dataChanged(parent, parent);
+            return true;
+        }
+    }
+    return false;
+}
+
+bool MappingTreeModel::deleteChild(const QModelIndex &idx){
+    if(!idx.isValid()){
+        return false;
+    }
+    SmTreeItem *item = itemAt(idx);
+    if(item->childCount() > 0){
+        return false;
+    }
+    mDeleteChildQ->bindValue(":id", item->data(Id));
+    if(mDeleteChildQ->exec()){
+        const QModelIndex &parent = idx.parent();
+        SmTreeItem *pItem = itemAt(parent);
+        pItem->removeChild(item->row());
+        emit dataChanged(parent, parent);
+        return true;
+    }
+    return false;
+}
+
+void MappingTreeModel::populate(){
+    if(mType == -1){
+        return;
+    }
+    // get nodes with root as parent
+    mTypeParentsQ->bindValue(":type", mType);
+    if(mTypeParentsQ->exec()){
+        SmTreeItem *rootItem = new SmTreeItem(NumFields);
+        rootItem->setData(Name, mappingTypeNameFromId(mType));
+        rootItem->setData(Id, mType);
+        //collect children recursive
+        while(mTypeParentsQ->next()){
+            QList<QVariant> childData;
+            childData << mTypeParentsQ->value(1) << mTypeParentsQ->value(0) << mTypeParentsQ->value(2);
+            SmTreeItem *childItem = new SmTreeItem(childData, rootItem);
+            rootItem->appendChild(childItem);
+            getChildrenRecursive(childItem);
+        }
+        setRoot(rootItem);
+    }
+}
+
+void MappingTreeModel::getMappingTypes(){
+    bool qRes = mTypesQ->exec();
+    if(qRes){
+        mMappingTypes.clear();
+        while(mTypesQ->next()){
+            mappingType t;
+            t.id = mTypesQ->value(0);
+            t.name = mTypesQ->value(1);
+            mMappingTypes << t;
+        }
+        emit mappingTypesChanged();
+    }
+}
+
+void MappingTreeModel::getChildrenRecursive(SmTreeItem *item){
+    mChildrenQ->bindValue(":id", item->data(Id));
+    if(mChildrenQ->exec()){
+        while(mChildrenQ->next()){
+            QList<QVariant> childData;
+            childData << mChildrenQ->value(1) << mChildrenQ->value(0) << mChildrenQ->value(2);
+            SmTreeItem *child = new SmTreeItem(childData, item);
+            item->appendChild(child);
+            getChildrenRecursive(child);
+        }
+    }
+}