taskstates.cpp

#include "taskstates.h"

#include "task.h"
#include "schedule.h"
#include "resource.h"
#include "duration.h"
#include "reservation.h"
#include "clock.h"
#include "statechangedata.h"

#include <tools/invaliddataexception.h>
#include <domain/businessrule2exception.h>

#include <QString>
#include <QMap>
#include <QDateTime>
#include <QDebug>

using namespace domain;

//TaskState

QList<TaskState::SettableState> TaskState::allStates()
{
    static QList<SettableState> ret;

    if (ret.isEmpty())
    {
        ret << Successful
            << Unfinished
            << Failed;
    }

    return ret;
}

TaskState* TaskState::stateForEnum(SettableState state)
{
    switch (state)
    {
        case Successful:
            return TaskSuccessful::instance();
        case Failed:
            return TaskFailed::instance();
        case Unfinished:
            return TaskUnfinished::instance();
    }

    qFatal("How embarrassing!");
    return 0;   //  Keep compiler happy!
}

QString TaskState::nameForEnum(SettableState state)
{
    return stateForEnum(state)->name();
}

TaskState::TaskState()
{
}

void TaskState::setTaskState(Task* task, TaskState* state)
{
    task->setState(state);
}

void TaskState::setTaskField(Task* task, const QString& id, const QVariant& value)
{
    task->_setField(id, value);
}

void TaskState::addTaskReservation(Task* task, Reservation* reservation)
{
    task->_addReservation(reservation);
}

void TaskState::setTaskProject(Task* task, Project* project)
{
    task->_setProject(project);
}

void TaskState::addTaskSubTask(Task* task, Task* subTask)
{
    task->_addSubTask(subTask);
}

void TaskState::updateTask(Task* task)
{
    setTaskState(task, this);
}

void TaskState::setField(Task*, const QString&, const QVariant&)
{
    throw tools::StringException(QString("Cannot set a field of a task with "
                                        "state %1.").arg(name()));
}

void TaskState::addReservation(Task*, Reservation*)
{
    throw tools::StringException(QString("Cannot add a reservation to a task "
                                         "with state %1.").arg(name()));
}

void TaskState::setProject(Task*, Project*)
{
    throw tools::StringException(QString("Cannot set the project of a task with "
                                         "state %1.").arg(name()));
}

void TaskState::addSubTask(Task*, Task*)
{
    throw tools::StringException(QString("Cannot add a sub task to a task "
                                         "with state %1.").arg(name()));
}

//TaskSuccessful

TaskSuccessful::TaskSuccessful()
{
}

TaskState::SettableState TaskSuccessful::settableState() const
{
    return Successful;
}

void TaskSuccessful::updateTask(Task* task)
{
    if (!task->canBeSuccessful())
    {
        try
        {
            task->setState(Unfinished);
        }
        catch (...)
        {
            task->setState(Failed);
        }
    }
    else
        setTaskState(task, this);
}

TaskState* TaskSuccessful::instance()
{
    static TaskSuccessful state;
    return &state;
}

QString TaskSuccessful::name() const
{
    return "Successful";
}

void TaskSuccessful::setProject(Task* task, Project* project)
{
    setTaskProject(task, project);
}

void TaskSuccessful::setField(Task* task, const QString& id, const QVariant& value)
{
    setTaskField(task, id, value);
}

void TaskSuccessful::addReservation(Task* task, Reservation* reservation)
{
    addTaskReservation(task, reservation);
}

//TaskFailed

TaskFailed::TaskFailed()
{
}

TaskState::SettableState TaskFailed::settableState() const
{
    return Failed;
}

TaskState* TaskFailed::instance()
{
    static TaskFailed state;
    return &state;
}

QString TaskFailed::name() const
{
    return "Failed";
}

void TaskFailed::setProject(Task* task, Project* project)
{
    setTaskProject(task, project);
}

void TaskFailed::setField(Task* task, const QString& id, const QVariant& value)
{
    setTaskField(task, id, value);
}

void TaskFailed::addReservation(Task* task, Reservation* reservation)
{
    addTaskReservation(task, reservation);
}

//TaskUnfinished

TaskUnfinished::TaskUnfinished()
{
}

TaskState::SettableState TaskUnfinished::settableState() const
{
    return Unfinished;
}

TaskState* TaskUnfinished::instance()
{
    static TaskUnfinished state;
    return &state;
}

QString TaskUnfinished::name() const
{
    return "Unfinished";
}

void TaskUnfinished::updateTask(Task* task)
{
    if (shouldBeFailed(task))
        setTaskState(task, TaskFailed::instance());
    else if (isAvailable(task))
        setTaskState(task, TaskAvailable::instance());
    else
        setTaskState(task, TaskUnavailable::instance());
}

bool TaskUnfinished::shouldBeFailed(Task* task)
{
    Q_FOREACH (const Task* subTask, task->subTasks())
    {
        if (subTask->state() == Failed)
            return true;
    }

    return Clock::currentTime() >= task->schedule().dueDate();
}

bool TaskUnfinished::isAvailable(const Task* task)
{
    QDateTime current = Clock::currentTime();

    if (task->schedule().startDate() > current ||
        task->schedule().dueDate() <= current)
    {
        return false;
    }

    Q_FOREACH (const Task* subTask, task->subTasks())
    {
        if (subTask->state() != Successful)
            return false;
    }

    return task->requirementsAreFulfilled();
}

void TaskUnfinished::setField(Task* task, const QString& id, const QVariant& value)
{
    setTaskField(task, id, value);
}

void TaskUnfinished::addReservation(Task* task, Reservation* reservation)
{
    addTaskReservation(task, reservation);
}

void TaskUnfinished::setProject(Task* task, Project* project)
{
    setTaskProject(task, project);
}

void TaskUnfinished::addSubTask(Task* task, Task* subTask)
{
    addTaskSubTask(task, subTask);
}

// TaskAvailable

TaskAvailable::TaskAvailable()
{

}

TaskState* TaskAvailable::instance()
{
    static TaskAvailable state;
    return &state;
}

QString TaskAvailable::name() const
{
    return TaskUnfinished::name() + " (available)";
}

// TaskUnavailable

TaskUnavailable::TaskUnavailable()
{

}

TaskState* TaskUnavailable::instance()
{
    static TaskUnavailable state;
    return &state;
}

QString TaskUnavailable::name() const
{
    return TaskUnfinished::name() + " (unavailable)";
}


// DeletingState

TaskDeleting::TaskDeleting()
{
}

TaskState* TaskDeleting::instance()
{
    static TaskDeleting state;
    return &state;
}

void TaskDeleting::addReservation(Task* task, Reservation* reservation)
{
    addTaskReservation(task, reservation);
}

void TaskDeleting::addSubTask(Task* task, Task* subTask)
{
    addTaskSubTask(task, subTask);
}

QString TaskDeleting::name() const
{
    return "Deleting";
}

void TaskDeleting::setProject(Task* task, Project* project)
{
    setTaskProject(task, project);
}

void TaskDeleting::setField(Task* task, const QString& id, const QVariant& value)
{
    setTaskField(task, id, value);
}

TaskState::SettableState TaskDeleting::settableState() const
{
    qFatal("This is embarrassing...");
    return (SettableState) 0;   // Keep compiler happy
}

---