dataloader.cpp

#include "dataloader.h"

#include <controllerfactory.h>

#include <domain/taskmanagerdata.h>
#include <domain/resource.h>
#include <domain/duration.h>
#include <domain/task.h>
#include <domain/taskstates.h>
#include <domain/resourcetype.h>
#include <domain/tasktype.h>
#include <domain/usertype.h>
#include <domain/clock.h>
#include <domain/project.h>
#include <domain/user.h>

#include <tools/stringexception.h>

#include <QDomDocument>
#include <QFile>
#include <QDateTime>

using namespace control;

QString DataLoader::description() const
{
    return "Load data";
}

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

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

ControllerInterface::ActionType DataLoader::actionType() const
{
    return LoadDataAction;
}

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

    themeLoader = factory->controllerByType(FileData, LoadThemeAction);

    if (themeLoader == 0)
        throw tools::StringException("No controller to load a theme");
}

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

void DataLoader::execute()
{
    if (!data->hasTheme())
    {
        ui->showMessage("You have to load a theme first");
        themeLoader->run();

        if (!data->hasTheme())
            return;
    }

    QString fileName = ui->getOpenFileName("", "XML files(*.xml)");
    if (fileName.isEmpty())
        return;
    
    data->clear();
    resourceRefs.clear();
    projectRefs.clear();
    taskRefs.clear();
    userRefs.clear();
    taskInvitees.clear();
    userInvitees.clear();
    
    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() != "mop:taskplanner")
    {
        ui->showError("This is not a correct XML file.");
        return;
    }

    bool succes = false;

    try
    {
        succes = load(root);
    }
    catch (tools::StringException e)
    {
        ui->showError(e.message());
        data->clear();
        return;
    }

    if (succes)
        ui->showMessage("The file was loaded succesfully.");
    else
    {
        ui->showError("The file has incorrect contents");
        data->clear();
    }
}

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

bool DataLoader::load(const QDomElement& root)
{
    projectRefs.clear();
    resourceRefs.clear();
    taskRefs.clear();

    //first parse the system time
    QDomElement systemTime = root.firstChildElement("mop:systemtime");
    data->clock()->setTime(QDateTime::fromString(systemTime.text(), Qt::ISODate));

    FOREACH_ELEMENT(element,root)
    {
        if (element.tagName() == "mop:projects")
        {
            if (!loadProjects(element))
                return false;
        }
        else if (element.tagName() == "mop:resources")
        {
            if (!loadResources(element))
                return false;
        }
        else if (element.tagName() == "mop:user")
        {
            if (!loadUser(element))
                return false;
        }
        else if (element.tagName() == "mop:systemtime")
        {
            //already done
        }
        else
        {
            throw tools::StringException(QString("illegal tag: %1")
                                                 .arg(element.tagName()));
        }
    }

    return loadInvitations() && createTasks();
}

bool DataLoader::loadProjects (const QDomElement& projects)
{
    FOREACH_ELEMENT(element, projects)
    {
        if (element.tagName() == "mop:project")
        {
            if (!loadProject(element))
                return false;
        }
        else
            return false;
    }

    return true;
}

bool DataLoader::loadProject (const QDomElement& project)
{
    QString projectRef = project.attribute("id");
    FOREACH_ELEMENT(element, project)
    {
        if (element.tagName() == "mop:description")
            projectRefs.insert(projectRef,data->createProject(element.text()));
        else
            throw tools::StringException("There is an error in the project tag: " + projectRef);
    }

    return true;
}

bool DataLoader::loadResources (const QDomElement& resources)
{
    FOREACH_ELEMENT(element, resources)
    {
        if (element.tagName() == "mop:resource")
        {
            if (!loadResource(element))
                return false;
        }
        else
            return false;
    }

    return true;
}

bool DataLoader::loadResource (const QDomElement& resource)
{
    QString description;
    domain::ResourceType* resourceType;

    QString resourceRef = resource.attribute("id");

    FOREACH_ELEMENT(element, resource)
    {
        if (element.tagName() == "mop:type")
        {
            domain::Type* type = data->typeById(element.text());

            if (type == 0)
            {
                throw tools::StringException(QString("Type with id %1 does not exist")
                                                .arg(element.text()));
            }

            resourceType = qobject_cast<domain::ResourceType*>(type);

            if (resourceType == 0)
            {
                throw tools::StringException(QString("Type with id %1 is not a resource type")
                                                    .arg(element.text()));
            }
        }
        else if (element.tagName() == "mop:description")
        {
            description = element.text();
        }
        else
            throw tools::StringException(QString("Unknown tag %1").arg(element.tagName()));
    }

    resourceRefs.insert(resourceRef,data->createResource(description, resourceType));

    return true;
}

bool DataLoader::loadUser (const QDomElement& user)
{
    QDomElement name = user.firstChildElement("mop:name");
    domain::User* userPointer;

    QString typeId = user.firstChildElement("mop:type").text();
    domain::Type* type = data->typeById(typeId);

    if (type == 0)
        throw tools::StringException(QString("No type with id %1").arg(typeId));

    domain::UserType* userType = qobject_cast<domain::UserType*>(type);

    if (userType == 0)
    {
        throw tools::StringException(QString("Type with id %1 is not a user type")
                                            .arg(typeId));
    }

    if (!name.isNull())
        userPointer = data->createUser(userType, name.text());
    else
        throw tools::StringException("The name of a user is empty");

    userRefs[user.attribute("id")] = userPointer;

    QDomElement tasks = user.firstChildElement("mop:tasks");
    if (!loadTasks(tasks, userPointer))
        return false;

    QDomElement invitations = user.firstChildElement("mop:invitations");
    QMap<QString, QString> taskInvitationStateMap;
    FOREACH_ELEMENT (invitation, invitations)
    {
        QString task = invitation.attribute("task");
        QString status = invitation.attribute("status");
        taskInvitationStateMap[task] = status;
    }

    userInvitees.insert(userPointer, taskInvitationStateMap);

    return true;
}

bool DataLoader::loadReservations(const QDomElement& reservations,
                                  const QString& taskRef)
{
    FOREACH_ELEMENT(element, reservations)
    {
        if (element.tagName() == "mop:reservation")
        {
            if (!loadReservation(element, taskRef))
                return false;
        }
        else
            return false;
    }

    return true;
}

bool DataLoader::loadReservation(const QDomElement& reservation,
                                 const QString& taskRef)
{
    domain::Resource* resource;
    domain::Duration duration;
    QDateTime startDate;
    FOREACH_ELEMENT(element, reservation)
    {
        if (element.tagName() == "mop:time")
        {
            startDate = QDateTime::fromString(element.text(), Qt::ISODate);
        }
        else if (element.tagName() == "mop:duration")
        {
            duration = domain::Duration(element.text().toInt() * 60);
        }
        else if (element.tagName() == "mop:refResource")
        {
            resource = resourceRefs.value(element.text());
        }
        else
            throw tools::StringException(QString("Unknown tag %1")
                                                 .arg(element.tagName()));
    }

    domain::ReservationData reservationData;
    reservationData.duration = duration;
    reservationData.resource = resource;
    reservationData.startDate = startDate;
    taskData[taskRef].reservations << reservationData;

    return true;
}

bool DataLoader::loadTasks(const QDomElement& tasks, domain::User* userPointer)
{
    QList<QDomElement> tasksList;
    QDomNodeList nodeList = tasks.elementsByTagName("mop:task");

    for (int i = 0; i < nodeList.size(); i++)
        tasksList << nodeList.at(i).toElement();

    bool createdOne = true;

    while (createdOne && !tasksList.isEmpty())
    {
        createdOne = false;

        Q_FOREACH (QDomElement task, tasksList)
        {
            if (loadTask(task, userPointer))
            {
                createdOne = true;
                tasksList.removeAll(task);
            }
        }
    }

    if (!tasksList.isEmpty())
    {
        ui->showError("Error loading tasks");
        return false;
    }

    return true;
}

bool DataLoader::loadTask(const QDomElement& task, domain::User* userPointer)
{
    QString taskRef = task.attribute("id");
    QDateTime startDate;
    QDateTime dueDate;
    QDomElement reservationsElement;
    QMap<QString,QVariant> fieldsmap;
    QStringList invitees;
    domain::Duration duration;
    domain::TaskState::SettableState state;
    domain::Project* project;
    domain::TaskType* type;
    QStringList subTasks;

    FOREACH_ELEMENT(element, task)
    {
        if (element.tagName() == "mop:startDate")
        {
            startDate = QDateTime::fromString(element.text(), Qt::ISODate);
        }
        else if (element.tagName() == "mop:endDate")
        {
            dueDate = QDateTime::fromString(element.text(), Qt::ISODate);
        }
        else if (element.tagName() == "mop:duration")
        {
            duration = domain::Duration(element.text().toInt() * 60);
        }
        else if (element.tagName() == "mop:status")
        {
            if (element.text() == "Successful")
                state = domain::TaskState::Successful;
            else if (element.text() == "Unfinished")
                state = domain::TaskState::Unfinished;
            else if (element.text() == "Failed")
                state = domain::TaskState::Failed;
            else
                return false;
        }
        else if (element.tagName() == "mop:refProject")
        {
            project = projectRefs.value(element.text());
        }
        else if (element.tagName() == "mop:dependsOn")
        {
            FOREACH_ELEMENT (subTask, element)
            {
                Q_ASSERT(subTask.tagName() == "mop:refTask");

                subTasks << subTask.text();
            }
        }
        else if (element.tagName() == "mop:type")
        {
            domain::Type* typePtr = data->typeById(element.text());
            type = qobject_cast<domain::TaskType*>(typePtr);

            if (type == 0)
            {
                throw tools::StringException(QString("Type with id %1 is not a task type")
                                                    .arg(typePtr->id()));
            }
        }
        else if (element.tagName() == "mop:fields")
        {
            FOREACH_ELEMENT(field, element)
            {
                QString id = field.attribute("id");
                QVariant value = field.attribute("value");
                fieldsmap[id] = value;
            }
        }
        else if (element.tagName() == "mop:invitees")
        {
            FOREACH_ELEMENT (refUser, element)
                invitees << refUser.text();
        }
        else if (element.tagName() == "mop:reservations")
        {
            reservationsElement = element;
        }
        else
            throw tools::StringException(QString("Unknown tag: %1").arg(element.tagName()));
    }

    TaskData taskData;
    taskData.type = type;
    taskData.schedule = domain::Schedule(duration, startDate, dueDate);
    taskData.user = userPointer;
    taskData.state = state;
    taskData.subTasks = subTasks;
    taskData.project = project;
    taskData.fieldsMap = fieldsmap;
    this->taskData.insert(taskRef, taskData);

    Q_FOREACH (QString invitee, invitees)
        taskInvitees.insert(taskRef, invitee);

    loadReservations(reservationsElement, taskRef);

    return true;
}

bool DataLoader::loadInvitations()
{
    QStringList tasksDone;

    Q_FOREACH (QString task, taskInvitees.keys())
    {
        if (tasksDone.contains(task))
            continue;

        tasksDone << task;

        Q_FOREACH (QString userRef, taskInvitees.values(task))
        {
            domain::User* user = userRefs[userRef];

            typedef QMap<QString, QString> TaskInvitationStateMap;
            Q_FOREACH (TaskInvitationStateMap taskInvitationStateMap,
                       userInvitees.values(user))
            {
                Q_FOREACH (QString taskRef, taskInvitationStateMap.keys())
                {
                    if (taskRef == task)
                    {
                        domain::InvitationData invitation;
                        invitation.user = user;
                        QString status = taskInvitationStateMap[taskRef];

                        if (status == "pending")
                            invitation.state = domain::Invitation::Pending;
                        else if (status == "accepted")
                            invitation.state = domain::Invitation::Accepted;
                        else if (status == "declined")
                            invitation.state = domain::Invitation::Declined;

                        taskData[taskRef].invitations << invitation;
                    }
                }
            }
        }
    }

    return true;
}

bool DataLoader::createTasks()
{
    QStringList doneTasks;
    bool createdOne = true;
    while (createdOne)
    {
        createdOne = false;

        Q_FOREACH(QString taskRef, taskData.keys())
        {
            TaskData dataTask = taskData[taskRef];
            bool allSubTasksCreated = true;
            Q_FOREACH(QString subTaskRef, dataTask.subTasks)
            {
                if (!taskRefs.contains(subTaskRef))
                {
                    allSubTasksCreated = false;
                    break;
                }
            }
            if (allSubTasksCreated && !doneTasks.contains(taskRef))
            {
                QList<domain::Task*> subTasks;
                Q_FOREACH(QString subTaskRef, dataTask.subTasks)
                {
                    subTasks << taskRefs[subTaskRef];
                }
                domain::Task* task = data->createTask(dataTask.type, dataTask.user,
                                                      dataTask.schedule,
                                                      dataTask.state, subTasks,
                                                      dataTask.invitations,
                                                      dataTask.reservations);
                Q_FOREACH(QString fieldID, dataTask.fieldsMap.keys())
                {
                    task->setField(fieldID, dataTask.fieldsMap[fieldID]);
                }

                task->setProject(dataTask.project);
                createdOne = true;
                doneTasks << taskRef;
                taskRefs[taskRef] = task;
            }
        }
    }
    return taskRefs.size() == taskData.keys().size();
}

Q_EXPORT_PLUGIN2(controller_dataloader, DataLoader)

---