taskmodifier.cpp

#include "taskmodifier.h"

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

#include <domain/taskmanagerdata.h>
#include <domain/schedule.h>
#include <domain/user.h>
#include <domain/taskstates.h>

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

#include <QDebug>

using namespace control;

ControllerInterface::ActionType TaskModifier::actionType() const
{
    return ModifyAction;
}

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

QString TaskModifier::description() const
{
    return "Modify task";
}

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

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

void TaskModifier::execute()
{
    QList<const domain::Task*> tasksList = tools::makeConstList(data->tasksForUser(user()));

    if (tasksList.isEmpty())
    {
        ui->showWarning(QString("User %1 does not have any tasks").arg(user()->name()));
        return;
    }

    TaskModel tasks(data, tasksList);
    data::SelectionData selection = ui->getSelection("Select a task", &tasks);

    if (!selection.processData)
        return;

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

    Q_ASSERT(selection.selection.count() == 1);

    bool tryAgain;
    do
    {
        tryAgain = false;

        try
        {
            execute(tasks.taskForIndex(selection.selection.first()));
        }
        catch (tools::StringException& e)
        {
            tryAgain = ui->askQuestion(e.message(), 0,
                                       "Would you like to correct this?");
        }
    }
    while (tryAgain);
}

void TaskModifier::execute(const domain::StorableData* data)
{
    const domain::Task* originalTask = qobject_cast<const domain::Task*>(data);

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

    if (originalTask->state() == domain::TaskState::Successful ||
        originalTask->state() == domain::TaskState::Failed)
    {
        ui->showError("Cannot update task details because the state of the "
                      "selected task is " +
                       originalTask->stateString().toLower() + ".");
        return;
    }

    QList<const domain::Task*> taskList = 
                        tools::makeConstList(this->data->tasksForUser(user()));
    taskList.removeAll(originalTask);
    TaskModel tasks(this->data, taskList);
    data::TaskDetails currentDetails(originalTask);

    Q_FOREACH (const domain::Task* subTask, originalTask->subTasks())
    {
        currentDetails.selectedTasks.selection
                    << tasks.indexForTask(this->data->task(subTask));
    }

    data::TaskRepresentation rep;
    rep.subTasks = &tasks;
    rep.type = data::TaskTypeDetails(originalTask->taskType());
    rep.details = currentDetails;
    UserRequirementsModel userReqs(this->data->task(originalTask));
    rep.userReqs = &userReqs;
    ResourceRequirementsModel resourceReqs(this->data->task(originalTask));
    rep.resourceReqs = &resourceReqs;
    data::TaskDetails details = ui->getTaskDetails(rep);

    if (!details.processData)
        return;

    domain::Schedule schedule(details.duration, details.startTime,
                              details.endTime);
    QList<domain::Task*> subTasks;
    Q_FOREACH (QModelIndex index, details.selectedTasks.selection)
    {
        subTasks << this->data->task(tasks.taskForIndex(index));
    }
    QList<domain::InvitationData> invitations;

    Q_FOREACH(const domain::Invitation* invitation, originalTask->invitations())
    {
        domain::InvitationData invitationData;
        if (invitation->state() == domain::Invitation::Accepted)
            invitationData.state = domain::Invitation::Pending;
        else
            invitationData.state = invitation->state();

        invitationData.user = this->data->user(invitation->user());
        invitations << invitationData;
    }
    QList<domain::ReservationData> reservations;
    Q_FOREACH(const domain::Reservation* reservation, originalTask->reservations())
    {
        domain::ReservationData reservationData;
        reservationData.duration = reservation->duration();
        reservationData.resource = this->data->resource(reservation->resource());
        reservationData.startDate = reservation->time();
        reservations << reservationData;
        this->data->removeData(reservation);
    }

    domain::Task* newTask;

    try
    {
        newTask = this->data->createTask(originalTask->taskType(),
                                         originalTask->user(), schedule,
                                         originalTask->state(), subTasks,
                                         invitations, reservations);

        Q_FOREACH (QString field, details.fields.keys())
            newTask->setField(field, details.fields[field]);

        Q_FOREACH (const domain::Task* superTask, originalTask->superTasks())
            this->data->task(superTask)->addSubTask(newTask);

        newTask->setProject(this->data->project(originalTask->project()));

        this->data->removeData(originalTask);
    }
    catch (tools::StringException e)
    {
        this->data->removeData(newTask);
        Q_FOREACH(domain::ReservationData reservation, reservations)
        {
            this->data->createReservation(originalTask, reservation.resource,
                                          reservation.startDate,
                                          reservation.duration);
        }
        throw e;
    }
}

Q_EXPORT_PLUGIN2(controller_taskmodifier, TaskModifier)

---