themeloader.cpp

#include "themeloader.h"

#include <controllerfactory.h>

#include <domain/resourcetype.h>
#include <domain/usertype.h>
#include <domain/tasktype.h>
#include <domain/taskmanagerdata.h>

#include <tools/stringexception.h>

#include <QDomDocument>
#include <QFile>

#include <limits>

using namespace control;

QString ThemeLoader::description() const
{
    return "Load theme";
}

ControllerInterface::ActionType ThemeLoader::actionType() const
{
    return LoadThemeAction;
}

ControllerInterface::DataType ThemeLoader::dataType() const
{
    return FileData;
}

QString ThemeLoader::name() const
{
    return "ThemeLoader";
}

bool ThemeLoader::userIsValid() const
{
    return true;
}

#define FOREACH_ELEMENT(element,node) \
    for (QDomElement element = node.firstChildElement(); !element.isNull(); \
        element = element.nextSiblingElement())

void ThemeLoader::execute()
{
    if(data->hasData())
    {
        //bool save = ui->askQuestion("Would you like to save first?");

        //if(save)
            //dataSaver->run();

        data->clear();
    }
    data->clearTheme();

    QString fileName = ui->getOpenFileName("", "XML files(*.xml)");
    if (fileName.isEmpty())
        return;

    QDomDocument doc;
    QFile file(fileName);

    if(!file.open(QIODevice::ReadOnly))
    {
        ui->showError("Could not open the specified file.");
        return;
    }

    QString errorString;
    int errorLine, errorColumn;

    if (!doc.setContent(&file, &errorString, &errorLine, &errorColumn))
    {
        file.close();
        QString error("The file could not be loaded\nLine %1, Column %2: %3");
        ui->showError(error.arg(errorLine).arg(errorColumn).arg(errorString));
        return;
    }

    file.close();

    QDomElement root = doc.documentElement();
    if (root.tagName() != "t:theme")
    {
        ui->showError("This is not a correct XML file.");
        return;
    }

    QDomElement resourceTypes = root.firstChildElement("t:resourceTypes");

    FOREACH_ELEMENT(type, resourceTypes)
    {
        QString id = type.attribute("id");
        QString name = type.attribute("name");

        data->createResourceType(id, name);
    }

    QDomElement userTypes = root.firstChildElement("t:userTypes");

    FOREACH_ELEMENT(type, userTypes)
    {
        QString id = type.attribute("id");
        QString name = type.attribute("name");

        data->createUserType(id, name);
    }

    QDomElement taskTypes = root.firstChildElement("t:taskTypes");

    FOREACH_ELEMENT(type, taskTypes)
    {
        QString id = type.attribute("id");
        QString name = type.attribute("name");
        domain::TaskType* taskType = data->createTaskType(id, name);

        FOREACH_ELEMENT(element, type)
        {
            QString tag = element.tagName();

            if (tag == "t:fields")
            {
                FOREACH_ELEMENT(field, element)
                {
                    QString id = field.attribute("id");
                    QString name = field.attribute("name");
                    QString nature = field.attribute("nature");

                    domain::Field f;
                    f.id = id;
                    f.name = name;

                    if (nature == "textual")
                        f.nature = domain::Field::Textual;
                    else
                        f.nature = domain::Field::Numerical;

                    taskType->addField(f);
                }
            }
            else if (tag == "t:requires")
            {
                FOREACH_ELEMENT(requirement, element)
                {
                    QString type = requirement.attribute("type");
                    QString min = requirement.attribute("min");
                    QString max = requirement.attribute("max");

                    domain::Type* typePtr = data->typeById(type);
                    domain::UserType* userType = qobject_cast<domain::UserType*>(typePtr);
                    domain::ResourceType* resourceType =
                                    qobject_cast<domain::ResourceType*>(typePtr);

                    unsigned minValue, maxValue;
                    minValue = min.toUInt();

                    if (max == "*")
                        maxValue = std::numeric_limits<unsigned>::max();
                    else
                        maxValue = max.toUInt();

                    if (typePtr == 0)
                    {
                        ui->showError(QString("Type %1 not defined").arg(type));
                        data->clearTheme();
                        return;
                    }
                    else if (userType != 0)
                        taskType->addRequirement(userType, minValue, maxValue);
                    else if (resourceType != 0)
                        taskType->addRequirement(resourceType, minValue, maxValue);
                    else
                    {
                        ui->showError(QString("Type %1 may not be a task type").arg(type));
                        data->clearTheme();
                        return;
                    }
                }
            }
            else if (tag == "t:owners")
            {
                FOREACH_ELEMENT(owner, element)
                {
                    QString typeStr = owner.attribute("type");
                    domain::Type* type = data->typeById(typeStr);
                    domain::UserType* userType = qobject_cast<domain::UserType*>(type);

                    if (type == 0)
                    {
                        ui->showError(QString("Type %1 not defined").arg(typeStr));
                        data->clearTheme();
                        return;
                    }
                    else if (userType == 0)
                    {
                        ui->showError(QString("Type %1 should be a user type").arg(typeStr));
                        data->clearTheme();
                        return;
                    }

                    taskType->addPotentialOwner(userType);
                }
            }
        }
    }

    ui->showMessage("Theme successfully loaded");
}

void ThemeLoader::init(domain::TaskManagerData* data, ui::UiInterface* ui,
                       ControllerFactory* factory)
{
    ControllerInterface::init(data, ui, factory);

    //dataSaver = factory->controllerByType(FileData, SaveAction);

    //if (dataSaver == 0)
        //throw tools::StringException("No controller to save data");
}

Q_EXPORT_PLUGIN2(controller_dataloader, ThemeLoader)

---