tasktype.cpp

#include "tasktype.h"

#include "clock.h"
#include "task.h"
#include "invitation.h"
#include "user.h"
#include "usertype.h"
#include "resourcetype.h"
#include "reservation.h"

#include <QVariant>
#include "resource.h"
#include <tools/invaliddataexception.h>

namespace domain
{

struct TaskTypePrivate
{
    QList<Field> fields;
    QList<Requirement*> requirements;
    QList<UserType*> potentialOwners;
    TaskType* q;

    TaskTypePrivate(TaskType* qq) : q(qq)
    {
    }

    ~TaskTypePrivate()
    {
        qDeleteAll(requirements);
    }

    template<typename T>
    QList<Requirement*> requirementByType()
    {
        QList<Requirement*> ret;

        Q_FOREACH (Requirement* req, requirements)
        {
            if (qobject_cast<T>(req->type) != 0)
                ret << req;
        }

        return ret;
    }

    template<typename Req, typename Type>
    Req* addRequirement(Type* type, unsigned min, unsigned max)
    {
        if (max < min)
        {
            throw tools::InvalidDataException(QString("Invalid arguments for "
            "requirement of type %1. Maximum value (%2) is less than minimum "
            "value (%3)").arg(type->name()).arg(min).arg(max));
        }

        Q_FOREACH (Requirement* req, requirements)
        {
            if (req->type == type)
            {
                throw tools::InvalidDataException(QString("Cannot have multiple "
                                "requirements for type %1").arg(type->name()));
            }
        }

        Req* req = new Req(type);
        req->min = min;
        req->max = max;
        requirements << req;

        emit q->dataChanged();

        return req;
    }
};

TaskType::TaskType(const QString& id, const QString& name) : Type(id, name),
                                                    d(new TaskTypePrivate(this))
{
}

TaskType::~TaskType()
{
    delete d;
}

const QList<Field>& TaskType::fields() const
{
    return d->fields;
}

const QList<Requirement*>& TaskType::requirements() const
{
    return d->requirements;
}

QList<Requirement*> TaskType::resourceRequirements() const
{
    return d->requirementByType<ResourceType*>();
}

QList<Requirement*> TaskType::userRequirements() const
{
    return d->requirementByType<UserType*>();
}

bool TaskType::requirementsAreFulfilled(const Task* task) const
{
    if (task->taskType() != this)
        return false;

    Q_FOREACH (Requirement* requirement, d->requirements)
    {
        if (!requirement->isFulfilled(task))
            return false;
    }

    return true;
}

bool TaskType::canBeSuccessful(const domain::Task* task) const
{
    Q_FOREACH (Requirement* requirement, d->requirements)
    {
        if (!requirement->canBeSuccessful(task))
            return false;
    }

    return true;
}

const QList<UserType*>& TaskType::potentialOwners() const
{
    return d->potentialOwners;
}

bool TaskType::userCanCreate (UserType* userType) const
{
    return potentialOwners().contains(userType);
}

void TaskType::addField(const domain::Field& field)
{
    if (!field.isValid())
    {
        throw tools::InvalidDataException(QString("Invalid field to add to "
        "tasktype %1: field insufficiently instantiated").arg(this->name()));
    }
    else if (!this->fieldById(field.id).isNull())
    {
        throw tools::InvalidDataException(QString("Invalid field to add to "
        "tasktype %1. Duplicate ID %2").arg(this->name()).arg(field.id));
    }

    d->fields << field;
    emit dataChanged();
}

UserRequirement* TaskType::addRequirement(
                            UserType* type, unsigned int min, unsigned int max)
{
    return d->addRequirement<UserRequirement>(type, min, max);
}

ResourceRequirement* TaskType::addRequirement(
                        ResourceType* type, unsigned int min, unsigned int max)
{
    return d->addRequirement<ResourceRequirement>(type, min, max);
}
void TaskType::addPotentialOwner(UserType* owner)
{
    if (!potentialOwners().contains(owner))
    {
        d->potentialOwners << owner;
        emit dataChanged();
    }
}

Field TaskType::fieldById(const QString& id) const
{
    Q_FOREACH (Field field, d->fields)
    {
        if (field.id == id)
            return field;
    }

    return Field();
}

Requirement* TaskType::requirementByType(Type* type) const
{
    Q_FOREACH (Requirement* req, d->requirements)
    {
        if (req->type == type)
            return req;
    }

    return 0;
}

bool Field::isValid(const QVariant& val) const
{
    QVariant value = val;

    if (value.toString().isEmpty())
        return false;

    if (nature == Textual)
        return value.convert(QVariant::String);
    else
        return value.convert(QVariant::Int);
}

bool Field::isNull() const
{
    return id.isEmpty();
}

bool Field::isValid() const
{
    return !(id.isEmpty() || name.isEmpty());
}

Requirement::Requirement(Type* type) : type(type)
{
}

UserRequirement::UserRequirement(UserType* userType) : Requirement(userType)
{
}

UserRequirement::~UserRequirement()
{
}

bool UserRequirement::isFulfilled(const Task* task) const
{
    unsigned count = 0;

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

    return count >= min && count <= max;
}

bool UserRequirement::canBeSuccessful(const domain::Task* task) const
{
    return isFulfilled(task);
}

ResourceRequirement::ResourceRequirement(ResourceType* resourceType) :
                                                       Requirement(resourceType)
{
}

ResourceRequirement::~ResourceRequirement()
{
}

bool ResourceRequirement::isFulfilled(const Task* task) const
{
    unsigned count = 0;

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

    return count >= min && count <= max;
}

bool ResourceRequirement::canBeSuccessful(const domain::Task* task) const
{
    unsigned count = 0;

    Q_FOREACH (const Reservation* reservation, task->reservations())
    {
        if (reservation->resource()->resourceType() == type &&
            reservation->time() <= Clock::currentTime())
        {
            count++;
        }
    }

    return count >= min && count <= max;

}

}

---