ElemsConfigTool/datacpp/dataManager.cpp

#include "datahpp/dataManager.h"
#include <iostream>
#include <QFile>
#include <QJsonDocument>
#include <QApplication>
#include <QDir>

DataManager* DataManager::getInstance()
{
    static DataManager dataManager;
    return &dataManager;
}

DataManager::DataManager()
{
    jsonTemp = new ReadJsonSrc(":/file/file/template.json");
    loadData();
}

DataManager::~DataManager()
{
    delete jsonTemp;
    saveData();
}

QString DataManager::getFileName(QString filePath)
{
    if(filePath == "双击添加资源文件") return filePath;
    int size = filePath.count();
    int pos = 0;
    for(int i=size-1;i>=0;i--){
        if(filePath[i] == '/'){
            pos = i+1;
            break;
        }
    }
    QString fileName;
    for(int i=pos;i<size;i++){
        fileName.push_back(filePath[i]);
    }
    return fileName;
}

//模板配置
QVector<ReadJsonSrc::Fields> DataManager::getTempFields(QString key, QString name)
{
    QVector<ReadJsonSrc::Fields> nullVec;
    int index = jsonTemp->getTemplateIndex(key,name);
    if(index == -1) return nullVec;
    return jsonTemp->templateMap[key][index].fields;
}

void DataManager::updateTempData()
{
    ReadJsonSrc* tmp = jsonTemp;
    jsonTemp = new ReadJsonSrc(":/file/file/template.json");
    delete tmp;
}

QStringList DataManager::getList(QString elem,ListType listType)
{
    QStringList list;
    if(listType == ListType::Anim){
        for(const auto &i:elements[elem]->statusEffect) list.push_back(i.name);
    }
    else if(listType == ListType::CollAnim){
        for(const auto &i:elements[elem]->collAnim) list.push_back(i.name);
    }
    else if(listType == ListType::Pool){
        for(const auto &i:elements[elem]->container) list.push_back(i.poolName);
    }
    else if(listType == ListType::AnimType){
        for(const auto &i:jsonTemp->templateMap["collAnimTemp"]) list.push_back(i.name);
    }
    else if(listType == ListType::StatusVal){
        for(const auto &i:elements[elem]->statusConfig) list.push_back(i.statusValue);
    }
    else if(listType == ListType::Events){
        for(const auto &i:jsonTemp->templateMap["eventTemp"]) list.push_back(i.name);
    }
    else if(listType == ListType::Actions){
        for(const auto &i:jsonTemp->templateMap["actionTemp"]) list.push_back(i.name);
    }
    else if(listType == ListType::PoolType){
        for(const auto &i:jsonTemp->templateMap["poolTemp"]) list.push_back(i.name);
    }
    else if(listType == ListType::Elem) return elements.keys();
    return list;
}

//元素及其基础属性
bool DataManager::existElem(QString elemName)
{
    return elements.contains(elemName);
}

void DataManager::addElem(QString elemName)
{
    elements[elemName] = new ElemPropertyData();
}

void DataManager::delElem(QString elemName)
{
    delete elements[elemName];
    elements.remove(elemName);
}

void DataManager::changeElemName(QString oriName, QString newName)
{
    ElemPropertyData* tmp = elements[oriName];
    elements.remove(oriName);
    elements[newName] = tmp;
}

void DataManager::changeMarkValue(QString elem, QString val)
{
    elements[elem]->labelName = val;
}

void DataManager::changePos(QString elem, QString val)
{
    elements[elem]->pos = val;
}

void DataManager::changeMaxLayer(QString elem, QString val)
{
    elements[elem]->maxLayer = val;
}

void DataManager::changeScore(QString elem, QString val)
{
    elements[elem]->score = val;
}
void DataManager::changeDropConfig(QString elem, int index)
{
    elements[elem]->dropConfig = static_cast<ElemPropertyData::DROPOPT>(index);
}
void DataManager::changeIconPath(QString elem, QString iconPath)
{
    elements[elem]->iconPath = iconPath;
}
void DataManager::changeLinkedState(QString elem, int state)
{
    elements[elem]->canBeLinked = state;
}
void DataManager::changeMoveAwayState(QString elem, int state)
{
    elements[elem]->canMoveAway = state;
}
QString DataManager::getMarkValue(QString elem)
{
    return elements[elem]->labelName;
}
QString DataManager::getPos(QString elem)
{
    return elements[elem]->pos;
}
QString DataManager::getMaxLayer(QString elem)
{
    return elements[elem]->maxLayer;
}
QString DataManager::getScore(QString elem)
{
    return elements[elem]->score;
}
int DataManager::getDropConfig(QString elem)
{
    return  static_cast<int>(elements[elem]->dropConfig);
}
QString DataManager::getIconPath(QString elem)
{
    return elements[elem]->iconPath;
}
bool DataManager::getMoveAwayState(QString elem)
{
    return elements[elem]->canMoveAway;
}
bool DataManager::getLinkedState(QString elem)
{
    return elements[elem]->canBeLinked;
}

//状态与效果动画
QVector<ElemPropertyData::StatusEffect> DataManager::getAnimVec(QString elem)
{
    return elements[elem]->statusEffect;
}
QStringList DataManager::getTimelineList(QString elem,QString filePath)
{
    return elements[elem]->getTimelineList(filePath);
}
bool DataManager::existAnim(QString elem,QString animName)
{
    if(elements[elem]->getAnimIndex(animName) == -1) return false;
    return true;
}
void DataManager::addAnim(QString elem, QString animName)
{
    elements[elem]->statusEffect.push_back(ElemPropertyData::StatusEffect(animName));
}
void DataManager::delAnim(QString elem,int index)
{
    elements[elem]->statusEffect.remove(index);
}
void DataManager::changeAnimTable(QString elem, QString newData, int row, int column)
{
    if(column == 0) elements[elem]->statusEffect[row].name = newData;
    else if(column == 1) elements[elem]->statusEffect[row].res = newData;
    else if (column == 2) elements[elem]->statusEffect[row].timeline = newData;
    else if (column == 3) elements[elem]->statusEffect[row].zOrder = newData;
}
void DataManager::copyAnim(QString elem, QString animName, int copyIndex)
{
    ElemPropertyData::StatusEffect anim(animName);
    ElemPropertyData::StatusEffect copyData = elements[elem]->statusEffect[copyIndex];
    anim.res = copyData.res;
    anim.timeline = copyData.timeline;
    anim.zOrder = copyData.zOrder;
    elements[elem]->statusEffect.push_back(anim);
}

//收集动画
QString DataManager::getAnimType(QString elem, int index)
{
    return elements[elem]->collAnim[index].type;
}
void DataManager::setAnimType(QString elem, QString newType, int index)
{
    elements[elem]->collAnim[index].type = newType;
    elements[elem]->collAnim[index].dataMap.clear();
}
QMap<QString,QString> DataManager::getCollAnimDataMap(QString elem, int index)
{
    return elements[elem]->collAnim[index].dataMap;
}
void DataManager::setCollAnimDataMapVal(QString elem, int index, QString key, QString val)
{
    elements[elem]->collAnim[index].dataMap[key] = val;
}
bool DataManager::existCollAnim(QString elem, QString collAnimName)
{
    if(elements[elem]->getCollAnimIndex(collAnimName) == -1) return false;
    return true;
}
void DataManager::addCollAnim(QString elem,QString collAnimName)
{
    ElemPropertyData::CollAnim collAnim(collAnimName);
    elements[elem]->collAnim.push_back(collAnim);
}
void DataManager::delCollAnim(QString elem,int index)
{
    elements[elem]->collAnim.remove(index);
}
void DataManager::changeCollAnimName(QString elem,int index,QString newName)
{
    elements[elem]->collAnim[index].name = newName;
}

//状态配置
ElemPropertyData::StatusConfig DataManager::getStatusConfigData(QString elem,int index)
{
    return elements[elem]->statusConfig[index];
}

void DataManager::changeEventTable(QString elem,QString newData,int statusIndex,int row,int column)
{
    QVector<ElemPropertyData::EventConfig> &eventTable = elements[elem]->statusConfig[statusIndex].eventConfig;
    if(column == 0) eventTable[row].name = newData;
    else if(column == 2) eventTable[row].changeMagnitude = newData.toInt();
    else if(column == 3) eventTable[row].specialEffect = newData;
    else if(column == 5) eventTable[row].triggerAction = newData;
}
void DataManager::changeActionConfigData(QString elem, int statusIndex, int row, QMap<QString, QString> data)
{
    elements[elem]->statusConfig[statusIndex].eventConfig[row].actionConfig = data;
}
void DataManager::setEventTableCheckBox(QString elem, int statusIndex, int row, int column, int state)
{
    QVector<ElemPropertyData::EventConfig> &eventTable = elements[elem]->statusConfig[statusIndex].eventConfig;
    if(column == 1) eventTable[row].consisColor = state;
    else if(column == 4) eventTable[row].elimATLattices = state;
}
void DataManager::setFundCheckBox(QString elem, int statusIndex, CheckType checkType, int state)
{
    if(checkType == CheckType::Dropable) elements[elem]->statusConfig[statusIndex].dropable = state;
    else if(checkType == CheckType::MultiHit) elements[elem]->statusConfig[statusIndex].multiHit = state;
    else if(checkType == CheckType::NeedColl) elements[elem]->statusConfig[statusIndex].needCollect = state;
}
bool DataManager::existStatusVal(QString elem, QString statusVal)
{
    if(elements[elem]->getStatusValIndex(statusVal) == -1) return false;
    return true;
}
void DataManager::addStatus(QString elem, QString statusVal)
{
    ElemPropertyData::StatusConfig status(statusVal);
    if(elements[elem]->dropConfig == ElemPropertyData::DROPOPT::DROPABLE) status.dropable = true;
    if(elements[elem]->dropConfig == ElemPropertyData::DROPOPT::NOTDROPABLE) status.dropable = false;
    elements[elem]->statusConfig.push_back(status);
}
//TODO: 删除状态值时出现数组越界
void DataManager::delStatus(QString elem, int index)
{
    std::cout<<"current index:"<<index<<std::endl;
    std::cout<<"statusConfig size:"<<elements[elem]->statusConfig.size()<<std::endl;
    std::cout<<qPrintable(elements[elem]->statusConfig[index].statusValue)<<std::endl;
    elements[elem]->statusConfig.remove(index);
}
void DataManager::changeStatusVal(QString elem, int index, QString newVal)
{
    elements[elem]->statusConfig[index].statusValue = newVal;
}
void DataManager::changeStatusFundVal(QString elem, StatusDataType type, QString newData,int index)
{
    if(type == StatusDataType::ClickAnim) elements[elem]->statusConfig[index].clickAnim = newData;
    else if(type == StatusDataType::InitAnim) elements[elem]->statusConfig[index].initAnim = newData;
    else if(type == StatusDataType::CollAnim) elements[elem]->statusConfig[index].collAnim = newData;
    else if(type == StatusDataType::CollTar) elements[elem]->statusConfig[index].collTargetType = newData;
}
void DataManager::addEvent(QString elem, int index)
{
    ElemPropertyData::EventConfig event;
    elements[elem]->statusConfig[index].eventConfig.push_back(event);
}
void DataManager::delEvent(QString elem, int statusIndex, int row)
{
    elements[elem]->statusConfig[statusIndex].eventConfig.remove(row);
}
void DataManager::updateAllDropState(QString elem, bool state)
{
    int size = elements[elem]->statusConfig.size();
    for(int i=0;i<size;i++){
        elements[elem]->statusConfig[i].dropable = state;
    }
}
void DataManager::copyStatus(QString elem, QString statusVal, int copyIndex)
{
    ElemPropertyData::StatusConfig status(statusVal);
    ElemPropertyData::StatusConfig copyData = elements[elem]->statusConfig[copyIndex];
    status.initAnim = copyData.initAnim;
    status.clickAnim = copyData.clickAnim;
    status.multiHit = copyData.multiHit;
    status.dropable = copyData.dropable;
    if(copyData.needCollect){
        status.needCollect = true;
        status.collTargetType = copyData.collTargetType;
        status.collAnim = copyData.collAnim;
    }
    status.eventConfig = copyData.eventConfig;
    elements[elem]->statusConfig.push_back(status);
}

//容器池
ElemPropertyData::ContainerConfig DataManager::getContainData(QString elem,int index)
{
    return elements[elem]->container[index];
}
void DataManager::changeContainTable(QString elem, int index, int row, int column, QString data)
{
    QVector<ElemPropertyData::ContainTable> &table = elements[elem]->container[index].table;
    if(column == 0) table[row].key = data;
    else if(column == 1) table[row].res = data;
    else if(column == 2) table[row].initTimeline = data;
    else if(column == 3) table[row].clickTimeline = data;
    else if(column == 4) table[row].effectTimeline = data;
    else if(column == 5) table[row].vanishTimeline = data;
    else if(column == 6) table[row].zOrder = data;
}
bool DataManager::existPool(QString elem, QString poolName)
{
    if(elements[elem]->getPoolIndex(poolName) == -1) return false;
    return true;
}
void DataManager::addPool(QString elem, QString poolName)
{
    ElemPropertyData::ContainerConfig pool(poolName);
    elements[elem]->container.push_back(pool);
}
void DataManager::delPool(QString elem, int index)
{
    std::cout<<"current pool index:"<<index<<std::endl;
    std::cout<<"pool size:"<<elements[elem]->container.size()<<std::endl;
    std::cout<<qPrintable(elements[elem]->container[index].poolName)<<std::endl;
    elements[elem]->container.remove(index);
}
void DataManager::changePoolName(QString elem, int index, QString newName)
{
    elements[elem]->container[index].poolName = newName;
}
bool DataManager::existKey(QString elem,int poolIndex,QString key)
{
    if(elements[elem]->getKeyIndex(poolIndex,key) == -1) return false;
    return true;
}
void DataManager::addKey(QString elem, int poolIndex,QString keyName)
{
    ElemPropertyData::ContainTable key(keyName);
    elements[elem]->container[poolIndex].table.push_back(key);
}
void DataManager::delKey(QString elem, int poolIndex, int row)
{
    elements[elem]->container[poolIndex].table.remove(row);
}
void DataManager::changeContainType(QString elem, int poolIndex, QString poolType)
{
    elements[elem]->container[poolIndex].type = poolType;
}
void DataManager::copyKey(QString elem, int poolIndex, QString keyName, int copyIndex)
{
    ElemPropertyData::ContainTable copyData = elements[elem]->container[poolIndex].table[copyIndex];
    ElemPropertyData::ContainTable key(keyName);
    key.clickTimeline = copyData.clickTimeline;
    key.effectTimeline = copyData.effectTimeline;
    key.initTimeline = copyData.initTimeline;
    key.res = copyData.res;
    key.vanishTimeline = copyData.vanishTimeline;
    key.zOrder = copyData.zOrder;
    elements[elem]->container[poolIndex].table.push_back(key);
}

//子元素
QVector<ElemPropertyData::ChildElem> DataManager::getChildElemTable(QString elem)
{
    return elements[elem]->childElem;
}
void DataManager::changeChildElemTable(QString elem, int row, int column, QString data)
{
    QVector<ElemPropertyData::ChildElem> &table = elements[elem]->childElem;
    if(column == 0) table[row].name = data;
    else if(column == 1) table[row].container = data;
}
bool DataManager::existChildElem(QString elem, QString childElemName)
{
    if(elements[elem]->getChildElemIndex(childElemName) == -1) return false;
    return true;
}
void DataManager::addChildElem(QString elem, QString childElemName)
{
    ElemPropertyData::ChildElem childElem(childElemName);
    elements[elem]->childElem.push_back(childElem);
}
void DataManager::delChildElem(QString elem, int index)
{
    elements[elem]->childElem.remove(index);
}

//数据保存
///加载数据
bool DataManager::loadData()
{
    QFile loadFile(QDir::homePath() + "/Documents/RedInterstitialData/ElemsConf/data.json");
    if(!loadFile.open(QIODevice::ReadOnly)){
        qWarning("can't open data file!");
        return false;
    }
    QJsonDocument loadDoc(QJsonDocument::fromJson(loadFile.readAll()));
    read(loadDoc.object());
    loadFile.close();
    return true;
}

///读数据
void DataManager::read(const QJsonObject &json)
{
    elements.clear();
    QStringList keys = json.keys();
    for(int i=0;i<keys.size();i++)
    {
        QString elem = keys[i];
        elements[elem] = new ElemPropertyData();
        elements[elem]->readData(json[elem].toObject());
    }
}

///写数据
void DataManager::write(QJsonObject &json) const
{
    QStringList keys = elements.keys();
    for(int i=0;i<keys.size();i++)
    {
        QString elem = keys[i];
        QJsonObject obj;
        elements[elem]->writeData(obj);
        json.insert(elem,obj);
    }
}

///保存数据
bool DataManager::saveData()
{
    QJsonObject dataObj;
    write(dataObj);
    //判断该路径是否存在，若不存在则创建
    QString path = QDir::homePath()+"/Documents/RedInterstitialData/ElemsConf";
    std::cout<<qPrintable(path)<<std::endl;
    QDir *dir = new QDir;
    if(!dir->exists(path)){
        bool ismkdir = dir->mkpath(path);
        if(!ismkdir){
            qDebug() << "create path fail" <<Qt::endl;
            return false;
        }
    }
    delete  dir;
    QFile file(QDir::homePath() + "/Documents/RedInterstitialData/ElemsConf/data.json");
    if(!file.open(QIODevice::WriteOnly)){
        qDebug()<<"file open failed!";
        return false;
    }
    QJsonDocument jdoc;
    jdoc.setObject(dataObj);
    file.write(jdoc.toJson(QJsonDocument::Indented));
    file.close();
    return true;
}


//导出数据
///检查标识值是否重复
bool DataManager::findElemLabelName(QString elem,QString labelName)
{
    QStringList elems= elements.keys();
    for(int i=0;i<elems.size();i++)
    {
        if(elem!=elems[i] && labelName==elements[elems[i]]->labelName)
            return true;
    }
    return false;
}
///数据导出合法性检查
bool DataManager::exportIsValid()
{
    QStringList elems= elements.keys();
    for(int i=0;i<elems.size();i++)
    {
        QString key = elems[i];
        ElemPropertyData* data = elements[key];
        QString elemMessage = "元素"+key+"导出错误!";
        //基础属性合法性检查
        if(data->labelName.toInt() <= 0){
            exportMessage = elemMessage+"\n标识值必须是大于0的数字！";
            return false;
        }
        if(findElemLabelName(key,data->labelName)){
            exportMessage = "元素标识值重复！";
            return false;
        }
        if(data->maxLayer.toInt() <= 0){
            exportMessage = elemMessage+"\n最大层数必须是大于0的数字！";
            return false;
        }
        if(data->score.toInt() <= 0){
            exportMessage = elemMessage+"\n分数必须是大于0的数字！";
            return false;
        }
        if(data->pos.isEmpty() || getGridPos(data->pos).isEmpty()){
            exportMessage = elemMessage+"\n位置数据不合法！";
            return false;
        }

        //状态与效果动画检查
        QVector<ElemPropertyData::StatusEffect> animVec = data->statusEffect;
        for(int j=0;j<animVec.size();j++)
        {
            if(animVec[j].res == "双击添加资源文件"){
                exportMessage = elemMessage+"\n动画"+animVec[j].name+"未添加资源文件！";
                return false;
            }
            if(animVec[j].timeline == "尚未选择"){
                exportMessage = elemMessage+"\n动画"+animVec[j].name+"未选择时间线！";
                return false;
            }
        }

        //收集动画
        QVector<ElemPropertyData::CollAnim> collAnimVec = data->collAnim;
        for(int j=0;j<collAnimVec.size();j++)
        {
            if(collAnimVec[j].type == "尚未选择"){
                exportMessage = elemMessage+"\n收集动画"+collAnimVec[j].name+"未选择动画类型";
                return false;
            }
            QMap<QString,QString> collMap = collAnimVec[j].dataMap;
            QStringList collMapKeys = collMap.keys();
            for(int k=0;k<collMapKeys.size();k++)
            {
                QString collMapKey = collMapKeys[k];
                //检查动态配置选项中有没有为空的单行输入或未选择的下拉选项
                if(collMap[collMapKey].isEmpty() || collMap[collMapKey] == "尚未选择"){
                    exportMessage = elemMessage+"\n收集动画"+collAnimVec[j].name+collMapKey+"属性配置不完全";
                    return false;
                }
            }
        }

        //状态配置
        QVector<ElemPropertyData::StatusConfig> statusVec = data->statusConfig;
        for(int j=0;j<statusVec.size();j++)
        {
            //基础属性
            if(statusVec[j].initAnim == "尚未选择"){
                exportMessage = elemMessage+"\n状态"+statusVec[j].statusValue+"未选择初始动画";
                return false;
            }
            if(statusVec[j].clickAnim == "尚未选择"){
                exportMessage = elemMessage+"\n状态"+statusVec[j].statusValue+"未选择点击动画";
                return false;
            }
            if(statusVec[j].needCollect){
                if(statusVec[j].collTargetType.isEmpty() || statusVec[j].collTargetType.toInt() <= 0){
                    exportMessage = elemMessage+"\n状态"+statusVec[j].statusValue+"收集的目标类型必须是大于0的数字";
                    return false;
                }
            }
            //事件配置
            QVector<ElemPropertyData::EventConfig> eventVec = statusVec[j].eventConfig;
            for(int k=0;k<eventVec.size();k++)
            {
                if(eventVec[k].name == "尚未选择"){
                    exportMessage = elemMessage+"\n状态"+statusVec[j].statusValue+"事件配置未选择事件名称";
                    return false;
                }
                if(eventVec[k].specialEffect == "尚未选择"){
                    exportMessage = elemMessage+"\n状态"+statusVec[j].statusValue+"事件配置未选择特效";
                    return false;
                }
                //触发动作暂不处理
            }
        }

        //容器池配置
        QVector<ElemPropertyData::ContainerConfig> poolVec = data->container;
        for(int j=0;j<poolVec.size();j++)
        {
            if(poolVec[j].type == "尚未选择"){
                exportMessage = elemMessage+"\n容器"+poolVec[j].poolName+"未选择类型";
                return false;
            }
            QVector<ElemPropertyData::ContainTable> table = poolVec[j].table;
            for(int k=0;k<table.size();k++)
            {
                if(table[k].res == "双击添加资源文件"){
                    exportMessage = elemMessage+"\n容器"+poolVec[j].poolName+"键"+table[k].key+"未选择资源文件";
                    return false;
                }
                if(table[k].initTimeline == "尚未选择" || table[k].clickTimeline == "尚未选择" || table[k].effectTimeline == "尚未选择" || table[k].vanishTimeline == "尚未选择"){
                    exportMessage = elemMessage+"\n容器"+poolVec[j].poolName+"键"+table[k].key+"未选择时间线";
                    return false;
                }
            }
        }

        //子元素配置
        QVector<ElemPropertyData::ChildElem> childElemVec = data->childElem;
        for(int j=0;j<childElemVec.size();j++)
        {
            if(childElemVec[j].container == "尚未选择"){
                exportMessage = elemMessage+"\n容器"+poolVec[j].poolName+"子元素"+childElemVec[j].name+"使用的池子未选择";
                return false;
            }
        }
    }
    return true;
}

QString DataManager::getExportMessage()
{
    return exportMessage;
}

///将位置字符串拆分成多对坐标
QVector<QVector<int>> DataManager::getGridPos(QString str)
{
    //转换失败返回空数组
    QVector<QVector<int>> nullAns;
    QVector<QVector<int>> posNumPairs;
    //依据逗号分割
    QStringList posStrPairs = str.split(QLatin1Char(','));
    for(int i=0;i<posStrPairs.size();i++)
    {
        //依据：分割，若分割组数不为2说明输入不合法
        QStringList posStrPair = posStrPairs[i].split(QLatin1Char(':'));
        if(posStrPair.size()!=2) return nullAns;
        QVector<int> posNumPair;
        //检查第一个字符串是否为数字
        bool ok;
        int num1 = posStrPair[0].toInt(&ok);
        if(!ok) return nullAns;
        posNumPair.push_back(num1);
        //检查第二个字符串是否为数字
        int num2 = posStrPair[1].toInt(&ok);
        if(!ok) return nullAns;
        posNumPair.push_back(num2);
        posNumPairs.push_back(posNumPair);
    }
    return posNumPairs;
}

bool DataManager::exportData(QString fileName)
{
    if(!exportIsValid()) return false;
    //导出为json
    QJsonObject dataObj;
    QStringList keys = elements.keys();
    for(int i=0;i<keys.size();i++)
    {
        QString elem = keys[i];
        QJsonObject obj;
        elements[elem]->exportData(obj);
        dataObj.insert(elements[elem]->labelName,obj);
    }
    QFile file(fileName);
    if(!file.open(QIODevice::WriteOnly)){
        qDebug()<<"file open failed!";
        return false;
    }
    QJsonObject elemObj;
    elemObj["elements"] = dataObj;
    QJsonDocument jdoc;
    jdoc.setObject(elemObj);
    file.write(jdoc.toJson(QJsonDocument::Indented));
    file.close();
    return true;
}

QString DataManager::getTempId(QString key, QString name)
{
    int index = jsonTemp->getTemplateIndex(key,name);
    return jsonTemp->templateMap[key][index].id;
}

QString DataManager::getTempFieldId(QString key, QString name, QString fieldName)
{
    int nameIndex = jsonTemp->getTemplateIndex(key,name);
    QVector<ReadJsonSrc::Fields> fields = jsonTemp->templateMap[key][nameIndex].fields;
    for(int i=0;i<fields.size();i++)
    {
        if(fields[i].name == fieldName)
            return fields[i].id;
    }
    QString str;
    return str;
}