VFS_form.cpp

Go to the documentation of this file.

 
#include <stdio.h>
 
#include "VFS_datastore/VFS_datastore.h"
 
#include "VFS_form.h"
//#include "VFS.h"
 
#include "fields/breakField.h"
 
//QJsonObject VFS_form::_noDiffTypes = { { "metadata", QJsonValue { false } } };
 
VFS_form::VFS_form(QString baseForm)
: _index(1)
, _breakCount(1)
, _baseForm(baseForm)
{
 
}
 
VFS_form::~VFS_form()
{
 
}
 
void VFS_form::setBase(QString baseForm)
{
        _baseForm = baseForm;
}
 
void VFS_form::setHelp(QString helpText)
{
        _helpText = helpText;
}
 
QJsonValue VFS_form::cleanValue(QJsonValue v, bool isValue)
{
        QJsonValue r = v;
 
        if (v.isObject())
        {
                QJsonObject o = v.toObject();
                QString n;
                QJsonValue c;
 
                for (QJsonObject::iterator i=o.begin();i!=o.end();++i)
                {
                        n = i.key();
                        c = i.value();
 
                        if (!isValue)
                        {       if (n != "value")
                                {
                                        o.remove(n);
                                        --i;                                    //arg!
                                }
                                else
                                        o[n] = cleanValue(c,true);
                        }
                        else
                        {
                                o[n] = cleanValue(c);
                        }
                }
 
                r = o;
        }
 
        return r;
}
 
QJsonDocument VFS_form::toJsonDocument(bool useAttributes)
{
        if (useAttributes)
        {
                QJsonObject o;
                o["attributes"] = _form;
 
                if (_helpText!="")
                        o["help"] = _helpText;
 
                return QJsonDocument(o);
        }
 
        return QJsonDocument(_form);
}
 
QJsonDocument VFS_form::toSubclassDocument()
{
        QJsonObject o;
 
        if (_baseForm=="")      o["base"] = QJsonValue::Null;
        else                    o["base"] = _baseForm;
 
        //should come from base...
        //if (_helpText!="")    o["help"] = _helpText;
 
        QJsonObject v;
        QJsonObject::iterator i = _form.begin();
 
        while (i != _form.end())
        {
                QString var = i.key();
                QJsonObject val = i.value().toObject();
 
                if (val.contains("value"))
                {       QJsonObject vv;
                        vv["value"] = cleanValue(val["value"],true);
                        v[var] = vv;
                }
                //else
                //      printf("Form field %s has no value!\n",qUtf8Printable(var));
 
                ++i;
        }
 
        //o["attributes"] = _form;
        o["attributes"] = v;
 
        //printf("SUBCLASS:\n%s\n",qUtf8Printable(QJsonDocument(o).toJson()));
 
        return QJsonDocument(o);
}
 
void VFS_form::append(QString name, VFS_form_field field, int index)
{
        if (_form.contains(name))
                printf("Warning: form already contains field '%s'... it will be replaced.\n",qUtf8Printable(name));
 
        field.setLabel(name.left(1).toUpper()+name.mid(1),false);
 
        if (index == -1)
                field.setIndex(_index++);
        else
                field.setIndex(index);
 
        _form[name] = field;
}
 
void VFS_form::remove(QString name)
{
        if (_form.contains(name))
                _form.remove(name);
}
 
void VFS_form::replace(QString name, VFS_form_field field)
{
        if (_form.contains(name))
        {
                QJsonObject f = _form[name].toObject();
                field.setIndex( f.value("index").toInt() );
                field.setLabel( f.value("label").toString() );
                _form[name] = field;
        }
        else
                append(name,field);
}
 
void VFS_form::removeIndexRange(int s, int e)
{
        QStringList keys = _form.keys();
 
        int j;
        for (int i=0;i<keys.length();i++)
        {       j = _form[keys[i]].toObject()["index"].toInt();
                if (j>=s && j<=e)
                        _form.remove( keys[i] );
        }
}
 
bool VFS_form::contains(QString field)
{
        return _form.contains(field);
}
 
bool VFS_form::setValue(QString var, QJsonValue val)
{
        //printf("DIFF: %s\n",qUtf8Printable(QJsonDocument(val.toObject()).toJson()));
 
        if (contains(var))
        {
                QJsonObject v = _form[var].toObject();
 
                if (val.isObject() && v.contains("value") && v["value"].isObject())
                {
                        //printf("KEY: %s, case 1\n",qUtf8Printable(var));
                        QJsonObject vo = val.toObject();
 
                        if (vo.contains("value") && vo["value"].isObject())
                        {
                                //printf("KEY: %s, case 1a\n",qUtf8Printable(var));
                                v["value"] = VFS_datastore::applyJsonDiff(v["value"].toObject(),vo["value"].toObject());
                        }
                        else
                        {
                                //printf("KEY: %s, case 1b\n",qUtf8Printable(var));
                                v["value"] = VFS_datastore::applyJsonDiff(v["value"].toObject(),vo);
                        }
                }
                else if (val.isObject())
                {
                        //printf("KEY: %s, case 2\n",qUtf8Printable(var));
                        v = VFS_datastore::applyJsonDiff(v,val.toObject());
                }
                else
                {
                        //printf("KEY: %s, case 3\n",qUtf8Printable(var));
                        v["value"] = val;
                }
 
                _form[var] = v;
                return true;
        }
 
        return false;
}
 
QJsonValue VFS_form::getValue(QString var)
{
        if (contains(var))
        {
                QJsonObject o = _form[var].toObject();
 
                if (o.contains("value"))
                        return o["value"];
 
                if (o.contains("default"))
                        return o["default"];
        }
 
        return QJsonValue::Null;
}
 
bool VFS_form::setOption(QString var, QString option, QJsonValue o)
{
        if (contains(var))
        {
                QJsonObject v = _form[var].toObject();
                QJsonObject op = v["options"].toObject();
                op[option] = o;
                v["options"] = op;
 
                _form[var] = v;
                return true;
        }
 
        return false;
}
 
QJsonValue VFS_form::getOption(QString var, QString option)
{
        if (contains(var))
        {
                QJsonObject o = _form[var].toObject()["options"].toObject();
 
                if (o.contains(option))
                        return o[option];
        }
 
        return QJsonValue::Null;
}
 
void VFS_form::addBreak(int index)
{
        append(QString("break%1").arg(_breakCount++),breakField(),index);
}
 
/*
void VFS_form::submit(QJsonObject values)
{
        Q_UNUSED(values);
 
        printf("WOULD SUBMIT HERE!\n");
}
*/
 
void VFS_form::applyDiff(QJsonObject diff, bool useAttributes)
{
        if (useAttributes && diff.contains("attributes"))
                diff = diff["attributes"].toObject();
 
        QJsonObject::iterator i = diff.begin();
        while (i != diff.end())
        {
                if (_form.contains(i.key()))
                {
                        if (i.value().isNull())
                                remove(i.key());
                        else
                                setValue(i.key(),i.value());
                }
                //else
                //      create new field
 
                i++;
        }
}