task.cpp

#include "task.h"

#include "schedule.h"
#include "resource.h"
#include "project.h"
#include "duration.h"
#include "taskstates.h"
#include "user.h"
#include "statechangedata.h"
#include "schedule.h"
#include "tasktype.h"
#include "usertype.h"
#include "resourcetype.h"
#include "clock.h"
#include "taskmanagerdata.h"

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

#include <QString>
#include <QDateTime>
#include <QList>
#include <QVariant>
#include <QDebug>

namespace domain
{

struct TaskPrivate
{
    TaskPrivate(Task* qq, TaskType* type, User* user, const Schedule& schedule);

    Task* q;
    TaskType* type;
    User* user;
    QMap<QString, QVariant> fields;
    Schedule schedule;
    TaskState* state;
    QList<Reservation*> reservations;
    QList<Invitation*> invitations;
    QList<Task*> subTasks;
    QList<Task*> superTasks;
    Project* project;

    bool violatesBusinessRule1(Task* dependencyToAdd);
    QList<const Task*> subTasksViolatingBusinessRule2(TaskState::SettableState newState);
    QList<const Task*> superTasksViolatingBusinessRule2(domain::TaskState::SettableState state);
    bool violatesBusinessRule3(TaskState::SettableState newState);
    unsigned nbReservations(ResourceType* resType);
    unsigned nbActiveInvitations(UserType* userType);
};

TaskPrivate::TaskPrivate(Task* qq, TaskType* type, User* user,
                         const Schedule& schedule) : q(qq),
                                                     type(type),
                                                     user(user),
                                                     schedule(schedule)
{
    if (user == 0)
        throw tools::InvalidDataException("No user given.");

    if (!type->userCanCreate(user->userType()))
    {
        throw tools::InvalidDataException(QString("User of type \"%1\" is not allowed "
                                                    "to create a task of type \"%2\"")
                                                    .arg(user->userType()->name())
                                                    .arg(type->name()));
    }

    state = 0;
    project = 0;
}

Task::Task(TaskType* type, domain::User* user, const domain::Schedule& schedule,
           TaskState::SettableState state, const QList<Task*>& subTasks,
           const QList<InvitationData>& invitations,
           const QList<ReservationData>& reservations) :
            d(new TaskPrivate(this, type, user, schedule))
{
    try
    {
        Q_FOREACH (InvitationData invitation, invitations)
        {
            Invitation* inv = TaskManagerData::instance()->
                                        _createInvitation(this, invitation.user);
            inv->setState(invitation.state);
        }

        Q_FOREACH (ReservationData reservation, reservations)
        {
            TaskManagerData::instance()->_createReservation(this,
                                                            reservation.resource,
                                                            reservation.startDate,
                                                            reservation.duration);
        }

        Q_FOREACH (Task* subTask, subTasks)
            _addSubTask(subTask);

        user->addTask(this);

        setState(state);
    }
    catch (tools::StringException& e)
    {
        Q_FOREACH (Invitation* invitation, d->invitations)
            TaskManagerData::instance()->removeData(invitation);

        Q_FOREACH (Reservation* reservation, d->reservations)
            TaskManagerData::instance()->removeData(reservation);

        Q_FOREACH (Task* subTask, subTasks)
            removeSubTask(subTask);

        user->removeTask(this);

        throw e;
    }

    Clock::newEvent(schedule.dueDate(), this);
    Clock::newEvent(schedule.startDate(), this);
    connect(type, SIGNAL(dataChanged()), this, SLOT(notify()));
}

Task::~Task()
{
    d->state = TaskDeleting::instance();
    deleteDependentData();
    setProject(0);
    d->user->removeTask(this);
    Clock::deleteEvents(this);

    Q_FOREACH (Task* task, d->superTasks)
        task->removeSubTask(this);

    Q_FOREACH (Task* task, d->subTasks)
        removeSubTask(task);

    delete d;
}

void Task::setField(const QString& id, const QVariant& value)
{
    d->state->setField(this, id, value);
}

void Task::_setField(const QString& id, const QVariant& value)
{
    Field field = d->type->fieldById(id);

    if (field.isNull())
        throw tools::InvalidDataException(QString("No field with id %1").arg(id));

    if (!field.isValid(value))
    {
        throw tools::InvalidDataException(QString("Invalid value for field"
                                                  " with name \"%1\"").arg(field.name));
    }

    d->fields[id] = value;
}

QVariant Task::field(const QString& id) const
{
    if (d->fields.contains(id))
        return d->fields[id];

    return QVariant();
}

QMap<QString, QVariant> Task::fields() const
{
    return d->fields;
}

void Task::addReservation(Reservation* reservation)
{
    if (d->state == 0)
        _addReservation(reservation);
    else
        d->state->addReservation(this, reservation);
}

void Task::_addReservation(Reservation* reservation)
{
    ResourceType* resType = reservation->resource()->resourceType();
    Requirement* req = d->type->requirementByType(resType);

    if (req == 0)
    {
        throw tools::InvalidDataException(QString("No requirement for resource "
                                            "of type %1").arg(resType->name()));
    }
    if (d->nbReservations(resType) >= req->max)
    {
        throw tools::InvalidDataException(QString("Maximum number of reservations "
                           "of type %1 already obtained").arg(resType->name()));
    }

    if (reservation->duration() < d->schedule.duration())
    {
        QString msg("The reservation for resource \"%1\" is shorter than the"
                    " duration of the task");
        throw tools::InvalidDataException(msg.arg(reservation->resource()
                                          ->description()));
    }

    Q_FOREACH (Reservation* res, d->reservations)
    {
        if (!res->overlapsWith(reservation, d->schedule.duration()))
        {
            QString newResStr = reservation->resource()->description();
            QString problemResStr = res->resource()->description();
            QString msg("The reservation for resource \"%1\" does not overlap with "
                        "the reservation of resource \"%2\"");

            throw tools::InvalidDataException(msg.arg(newResStr).arg(problemResStr));
        }
    }

    d->reservations << reservation;
    Clock::newEvent(reservation->time(), this);
    Clock::newEvent(reservation->endTime(), this);
}

void Task::removeReservation(Reservation* reservation)
{
    d->reservations.removeAll(reservation);
}

QList<const Reservation*> Task::reservations() const
{
    return tools::makeConstList(d->reservations);
}

unsigned Task::nbActiveReservations(ResourceType* type) const
{
    unsigned count = 0;

    Q_FOREACH (Reservation* reservation, d->reservations)
    {
        if (reservation->resource()->resourceType() == type && reservation->isActive())
            count++;
    }

    return count;
}

QList<const Invitation*> Task::invitations() const
{
    return tools::makeConstList(d->invitations);
}

unsigned Task::nbAcceptedInvitations(UserType* type) const
{
    unsigned count = 0;

    Q_FOREACH (Invitation* invitation, d->invitations)
    {
        if (invitation->user()->userType() == type &&
            invitation->state() == Invitation::Accepted)
        {
            count++;
        }
    }

    return count;
}

const Schedule& Task::schedule() const
{
    return d->schedule;
}

QString Task::stateString() const
{
    return d->state->name();
}

TaskState::SettableState Task::state() const
{
    return d->state->settableState();
}

void Task::setState(TaskState::SettableState newState)
{
    StateChangeData changeData = canHaveAsState(newState);

    if (!changeData.isChangePossible())
        throw tools::InvalidDataException(changeData.message());

    Q_FOREACH (const Task* constTask, changeData.violatingTasks())
    {
        Task* task = const_cast<Task*>(constTask);
        TaskState::stateForEnum(changeData.suggestedState(task))->updateTask(task);
    }

    TaskState::stateForEnum(newState)->updateTask(this);
}

void Task::setState(TaskState* state)
{
    d->state = state;
    emit dataChanged();
}

StateChangeData Task::canHaveAsState(TaskState::SettableState state) const
{
    QList<const Task*> violatingTasks;

    //check business rule 2 for the sub tasks
    violatingTasks = d->subTasksViolatingBusinessRule2(state);

    if (!violatingTasks.isEmpty())
    {
        StateChangeData ret(false);
        ret.addViolatingTask(violatingTasks.first());
        ret.setMessage("The selected task cannot be updated to given state:\n\n"
                       "If a foregoing task is failed, the selected task has to"
                       " be failed.\nIf a foregoing task is unfinished, the"
                       " selected task cannot be successful");
        return ret;
    }

    //check business rule 3
    if (d->violatesBusinessRule3(state))
    {
        StateChangeData ret(false);
        ret.setMessage("The selected task cannot be updated to given state:\n"
                       "If the selected task is not started yet, it cannot be"
                       " successful.\nIf the selected task is past its"
                       " deadline, it cannot be unfinished.");
        return ret;
    }

    //if the new state is successful, this task should be either available or,
    //if it doesn't have a state yet, have all its requirements fulfilled
    if (state == TaskState::Successful)
    {
        if (d->state == 0)
        {
            if (!canBeSuccessful())
            {
                StateChangeData ret(false);
                ret.setMessage("Cannot create a successful task "
                               "without all requirements being fulfilled");
                return ret;
            }
        }
        else if (!isAvailable() && d->state != TaskSuccessful::instance())
        {
            StateChangeData ret(false);
            ret.setMessage("Cannot set the state of an unavailable task to Successful");
            return ret;
        }
    }

    //check business rule 2 for the super tasks
    //we are now sure the state can be updated
    StateChangeData ret(true);

    violatingTasks = d->superTasksViolatingBusinessRule2(state);

    if (!violatingTasks.isEmpty())
    {
        TaskState::SettableState newState = (state == TaskState::Unfinished) ?
                                            TaskState::Unfinished :
                                            TaskState::Failed;

        TaskState* oldState = d->state;
        d->state = TaskState::stateForEnum(newState);

        Q_FOREACH (const Task* task, violatingTasks)
        {
            if (!task->canHaveAsState(newState))
            {
                StateChangeData ret(false);
                ret.setMessage(QString("The state of task %1 needs to be changed"
                                        " to %2 but this is impossible.")
                                            .arg(task->id())
                                            .arg(TaskState::nameForEnum(newState)));
                d->state = oldState;
                return ret;
            }

            ret.addViolatingTask(task, newState);
        }

        d->state = oldState;

        ret.setMessage(QString("The new state for the selected task is"
                                " conflicting with the state of depending"
                                " tasks.\nThe suggested new state is %1.")
                                .arg(TaskState::nameForEnum(newState)));
    }

    return ret;
}

void Task::addSubTask(Task* dependency)
{
    d->state->addSubTask(this, dependency);
}

void Task::_addSubTask(Task* dependency)
{
    if (!d->subTasks.contains(dependency))
    {
        if (!dependency->dependsOn(this))
        {
            if (!d->violatesBusinessRule1(dependency))
            {
                d->subTasks << dependency;
                dependency->d->superTasks << this;
                notify();
            }
            else
                throw tools::InvalidDataException("Business rule 1 is violated.");
        }
        else
            throw tools::InvalidDataException("Dependency loop detected.");
    }
}

void Task::addInvitation(Invitation* invitation)
{
    if (invitation->user() == d->user)
    {
        throw tools::InvalidDataException("It is impossible to invite yourself "
                                          "for a task");
    }

    Q_FOREACH (Invitation* inv, d->invitations)
    {
        if (inv->user() == invitation->user())
        {
            throw tools::InvalidDataException(QString("You have already invited "
                                                      "user %1")
                                                      .arg(inv->user()->name()));
        }
    }

    UserType* userType = invitation->user()->userType();
    Requirement* req = d->type->requirementByType(userType);

    if (req == 0)
    {
        throw tools::InvalidDataException(QString("No requirement for a user of "
                                                  "type %1").arg(userType->name()));
    }
    if (d->nbActiveInvitations(userType) >= req->max)
    {
        throw tools::InvalidDataException(QString("Maximum number of invitations"
                                                  " for users of type %1 reached")
                                                  .arg(userType->name()));
    }

    d->invitations << invitation;
    notify();
    emit dataChanged();
}

void Task::removeInvitation(Invitation* invitation)
{
    d->invitations.removeAll(invitation);
    notify();
    emit dataChanged();
}

void Task::removeSubTask(Task* dependency)
{
    if (d->subTasks.contains(dependency))
    {
        d->subTasks.removeAll(dependency);
        dependency->d->superTasks.removeAll(this);

        emit dependency->dataChanged();
        emit dataChanged();
    }
}

bool Task::dependsOn(const Task* other) const
{
    if (other == this)
        return true;

    Q_FOREACH (Task* dependency, d->subTasks)
    {
        if (dependency == other || dependency->dependsOn(other))
            return true;
    }

   return false;
}

bool Task::isAvailable() const
{
    return dynamic_cast<TaskAvailable*>(d->state) != 0;
}

bool Task::requirementsAreFulfilled() const
{
    return d->type->requirementsAreFulfilled(this);
}

bool Task::canBeSuccessful() const
{
    return d->type->canBeSuccessful(this);
}

TaskType* Task::taskType() const
{
    return d->type;
}

const Project* Task::project() const
{
    return d->project;
}

const User* Task::user() const
{
    return d->user;
}

void Task::setProject(Project* project)
{
    d->state->setProject(this, project);
}

void Task::_setProject(Project* project)
{
    if (d->project != project)
    {
        if (d->project != 0)
            d->project->removeTask(this);

        d->project = project;

        if (d->project != 0)
            d->project->addTask(this);

        emit dataChanged();
    }
}

QList<const Task*> Task::subTasks() const
{
    return tools::makeConstList(d->subTasks);
}

QDateTime Task::earliestEndTime() const
{
    QDateTime earliestStartTime = schedule().startDate();
    QDateTime tempStartTime;

    Q_FOREACH(const Task* subtask, subTasks())
    {
        tempStartTime = subtask->earliestEndTime();
        if (tempStartTime > earliestStartTime)
            earliestStartTime = tempStartTime;
    }

    return earliestStartTime.addSecs(schedule().duration().totalSeconds());
}

QList<Task*> Task::superTasks()
{
    return d->superTasks;
}

QList<const Task*> Task::superTasks() const
{
    return tools::makeConstList(d->superTasks);
}

QList<const Task*> Task::allSuperTasks() const
{
    QSet<const Task*> allSuperTasks = QSet<const Task*>::fromList(superTasks());
    Q_FOREACH (const Task* task, allSuperTasks)
    {
        allSuperTasks += QSet<const Task*>::fromList(task->allSuperTasks());
    }
    return allSuperTasks.toList();
}

void Task::notify()
{
    if (d->state != 0)
    {
        d->state->updateTask(this);
    }
}

QList<StorableData*> Task::dependentData() const
{
    QList<StorableData*> ret;

    Q_FOREACH (Reservation* reservation, d->reservations)
        ret << reservation;
    Q_FOREACH (Invitation* invitation, d->invitations)
        ret << invitation;

    return ret;
}

bool TaskPrivate::violatesBusinessRule1(domain::Task* dependencyToAdd)
{
    QDateTime depEndTime = dependencyToAdd->earliestEndTime();

    if (q->schedule().dueDate() >=
        depEndTime.addSecs(q->schedule().duration().totalSeconds()))
    {
        return false;
    }

    return true;
}

QList<const domain::Task*>
TaskPrivate::subTasksViolatingBusinessRule2(TaskState::SettableState state)
{
    QList<const Task*> ret;

    Q_FOREACH(const Task* subTask, q->subTasks())
    {
        if (subTask->state() == TaskState::Failed)
        {
            if (state != TaskState::Failed)
                ret << subTask;
        }
        else if (subTask->state() == TaskState::Unfinished)
        {
            if (state == TaskState::Successful)
                ret << subTask;
        }
    }

    return ret;
}

QList<const domain::Task*>
TaskPrivate::superTasksViolatingBusinessRule2(TaskState::SettableState state)
{
    QList<const Task*> ret;

    if (state != TaskState::Successful)
    {
        Q_FOREACH(const Task* superTask, q->allSuperTasks())
        {
            if (state == TaskState::Unfinished)
            {
                if (superTask->state() == TaskState::Successful)
                    ret << superTask;
            }
            else if (state == TaskState::Failed)
            {
                if (superTask->state() != TaskState::Failed )
                    ret << superTask;
            }
        }
    }

    return ret;
}

bool TaskPrivate::violatesBusinessRule3(TaskState::SettableState newState)
{
    //check business rule 3
    QDateTime currentTime = Clock::currentTime();

    if (currentTime < schedule.startDate())
    {
        if (newState == TaskState::Successful)
            return true;
    }
    if (currentTime > schedule.dueDate())
    {
        if (newState == TaskState::Unfinished)
            return true;
    }

    return false;
}

unsigned TaskPrivate::nbReservations(ResourceType* resType)
{
    unsigned ret = 0;

    Q_FOREACH (Reservation* res, reservations)
    {
        if (res->resource()->resourceType() == resType)
            ret++;
    }

    return ret;
}

unsigned TaskPrivate::nbActiveInvitations(UserType* userType)
{
    unsigned ret = 0;

    Q_FOREACH (Invitation* invitation, invitations)
    {
        if (invitation->user()->userType() == userType &&
            invitation->state() != Invitation::Declined)
        {
            ret++;
        }
    }

    return ret;
}

}

---