taskupdater.cpp

#include "taskupdater.h"

#include <controllerfactory.h>
#include <controldata.h>
#include <models/taskmodel.h>
#include <models/resourcemodel.h>
#include <models/userrequirementsmodel.h>
#include <models/resourcerequirementsmodel.h>

#include <domain/task.h>
#include <domain/taskmanagerdata.h>
#include <domain/taskstates.h>
#include <domain/businessrule2exception.h>
#include <domain/statechangedata.h>

#include <tools/invaliddataexception.h>
#include <tools/functions.h>

#include <QDebug>

using namespace control;

QString TaskUpdater::description() const
{
    return "Update task";
}

ControllerInterface::ActionType TaskUpdater::actionType() const
{
    return UpdateAction;
}

ControllerInterface::DataType TaskUpdater::dataType() const
{
    return TaskData;
}

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

bool TaskUpdater::userIsValid() const
{
    return userHasLoggedIn() && !userIsAdmin();
}

void TaskUpdater::execute()
{
    TaskModel tasks(data, tools::makeConstList(data->tasksForUser(user())));
    data::SelectionData selection = ui->getSelection("Select a task", &tasks);

    if (!selection.processData)
        return;

    QModelIndexList list = selection.selection;

    if (list.isEmpty())
    {
        ui->showWarning("No task selected.");
        return;
    }

    Q_ASSERT(list.size() == 1);

    const domain::Task* task = tasks.taskForIndex(list.first());

    try
    {
        execute(task);
    }
    catch (tools::StringException e)
    {
        ui->showError(e.message());
    }
}

void TaskUpdater::execute(const domain::StorableData* data)
{

    domain::Task* task = this->data->task(qobject_cast<const domain::Task*>(data));

    if (task == 0)
       throw tools::InvalidDataException("Given data is not a task.");


    // Show the details of the task
    control::data::TaskDetails taskDetailsToShow(task);
    QList<domain::Task*> subtasksToShow;

    Q_FOREACH (const domain::Task* taskPointer, task->subTasks())
        subtasksToShow << this->data->task(taskPointer);

    TaskModel subtasksModel(this->data, tools::makeConstList(subtasksToShow));
    data::TaskRepresentation rep;
    rep.subTasks = &subtasksModel;
    rep.type = data::TaskTypeDetails(task->taskType());
    rep.details = taskDetailsToShow;
    UserRequirementsModel userReqs(task);
    rep.userReqs = &userReqs;
    ResourceRequirementsModel resourceReqs(task);
    rep.resourceReqs = &resourceReqs;

    if (!ui->showTaskDetails(rep).processData)
        return;

    // Fetch the selected state
    QStringList listStates;
    Q_FOREACH (domain::TaskState::SettableState state, domain::TaskState::allStates())
    {
        listStates << domain::TaskState::nameForEnum(state);
    }

    QString selectedString = ui->getChoice(listStates,
        "Select the state to which you want to set the task");

    if (selectedString.isEmpty())
    {
        ui->showError("No state selected.");
        return;
    }

    domain::TaskState::SettableState selectedState;
    Q_FOREACH (domain::TaskState::SettableState state, domain::TaskState::allStates())
    {
        if (domain::TaskState::nameForEnum(state) == selectedString)
            selectedState = state;
    }

    //check wether the selected state can be set on task
    domain::StateChangeData changeData = task->canHaveAsState(selectedState);
    QList<const domain::Task*> badTasks = changeData.violatingTasks();
    QString message = changeData.message();
    TaskModel model(this->data, badTasks);

    if (!changeData.isChangePossible())
    {
        if (badTasks.isEmpty())
            ui->showError(message);
        else
            ui->showModel(&model, message);
    }
    else
    {
        if (!changeData.areMoreChangesNeeded() || ui->askQuestion(message, &model,
                            "Would you like to proceed?"))
        {
            task->setState(selectedState);
        }
    }
}

Q_EXPORT_PLUGIN2(controller_taskupdater, TaskUpdater)

---