init_json_settings_by_cpp_template

/* Template class for initialization different settings structs
*  Ability to using in client class JS like syntax:
*  auto settings = new ConceptSettings();
*  qDebug() << settings.visibility.name << settings.visibility.status;
*/

#include "conceptsettings.hpp"
//template QJsonObject ConceptSettings::saveJSettings<Sets>(Sets& );
//template QJsonObject ConceptSettings::saveJSettings<VisibilitySettings>(VisibilitySettings& );

ConceptSettings::ConceptSettings(QJsonDocument cfconfJson)
{
  this->paramsJson = cfconfJson;
}

ConceptSettings::ConceptSettings(QVariant& cfconfJson) : jsonRaw(fromJson(cfconfJson.toByteArray()))
{
    this->sets                  = this->loadSettings<Sets>();
    this->visibility            = this->loadSettings<VisibilitySettings>();
    this->labels                = this->loadSettings<Lables>();
    this->general_settings      = this->loadSettings<GeneralSettings>();
    this->export_format         = this->loadExportSettings<ExportFormat>();

    //DDE_DBG(cfconfJson);

    if(this->jsonRaw.isEmpty())
        this->emptyJson = true;
}

template<class U>
U ConceptSettings::getSettings()
{
    U obj;
    return obj;
};

template<class T>
T ConceptSettings::loadSettings()
{
    T obj;

    for(auto type : obj.types)
    {
        if(obj.mapSets[type])
        {
            *obj.mapSets[type] = this->jsonRaw[obj.name][type].toArray();
        }
    }
    return obj;
};


template<class T>
T ConceptSettings::loadExportSettings()
{
    T obj;
    for(auto arr : this->jsonRaw[obj.name].toArray())
    {
        for(auto type : obj.types)
        {
            if(!arr.toObject()[type].toArray().isEmpty())
            {
                obj.mapSets[type] = new QJsonArray(arr.toObject()[type].toArray());
            }
             obj.mapSchemas.insert(arr.toObject()["TYPE"].toString(), obj.mapSets);
        }
    }
    return obj;
};

template<typename T>
QJsonObject ConceptSettings::saveJSettings(T& obj)
{
    QJsonObject json, jobj;
    for(auto type : obj.types)
    {
         if(obj.mapSets[type])
            json.insert(type, *obj.mapSets[type]);
    }

    return json;
};

QString ConceptSettings::toJsonStr()
{
    QJsonObject jset;
    jset.insert(this->sets.name, this->saveJSettings<Sets>(this->sets));
    jset.insert(this->visibility.name, this->saveJSettings<VisibilitySettings>(this->visibility));
    jset.insert(this->labels.name, this->saveJSettings<Lables>(this->labels));

    return QJsonDocument(jset).toJson();
}

void ConceptSettings::setValue(QString type, QString name, QString value)
{
    this->settings[type][name] = value;
}

void ConceptSettings::setValue(QString type, QString name, QJsonArray value)
{
   this->settingsArr[type][name] = value;
}

QJsonDocument* ConceptSettings::saveJsonFromArr()
{
    QJsonObject json;
    QMapIterator<QString, QMap<QString, QJsonValue>> i(this->settingsArr);
    while (i.hasNext()) {
        i.next();
        QJsonObject jsonb;
        QMapIterator<QString, QJsonValue> ii(i.value());
        while (ii.hasNext()) {
            ii.next();
            jsonb.insert(ii.key(), ii.value());
        }
        json.insert(i.key(), jsonb);
    }
    QJsonDocument* doc = new QJsonDocument(json);
    return doc;
}