taskcreator.cpp

#include "taskcreator.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/usertype.h>
#include <domain/project.h>

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

#include <QDebug>

using namespace control;

ControllerInterface::ActionType TaskCreator::actionType() const
{
    return CreateAction;
}

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

QString TaskCreator::description() const
{
    return "Create task";
}

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

void TaskCreator::execute()
{
    //ask the user for the type of task to create
    QList<domain::TaskType*> types = data->taskTypes();

    if (types.isEmpty())
    {
        ui->showError("No known task types, load a theme first");
        return;
    }

    QMap<QString, domain::TaskType*> typeMap;

    Q_FOREACH (domain::TaskType* type, types)
        typeMap[type->name()] = type;

    QString msg = "What type of task would you like to create?";
    data::StringInputData typeInput = ui->getChoice(typeMap.keys(), msg);

    if (!typeInput.processData)
        return;

    domain::TaskType* type = typeMap[typeInput];
    if (!type->userCanCreate(user()->userType()))
    {
        ui->showError(QString("User of type \"%1\" is not allowed "
                              "to create a task of type \"%2\"")
                                .arg(user()->userType()->name())
                                .arg(type->name()));

        return;
    }

    QList<const domain::Task*> taskList = tools::makeConstList(data->tasks());

    Q_FOREACH (const domain::Task* task, taskList)
    {
        if (task->user() != user())
            taskList.removeAll(task);
    }

    domain::Task* task;

    try
    {
        data::TaskRepresentation rep;
        TaskModel tasks(data, taskList);
        rep.subTasks = &tasks;
        rep.type = data::TaskTypeDetails(type);
        UserRequirementsModel userReqs(type);
        rep.userReqs = &userReqs;
        ResourceRequirementsModel resourceReqs(type);
        rep.resourceReqs = &resourceReqs;
        data::TaskDetails details = ui->getTaskDetails(rep);

        if (!details.processData)
            return;

        domain::Schedule schedule(details.duration, details.startTime,
                                  details.endTime);

        task = data->createTask(type, user(), schedule);

        try
        {

            Q_FOREACH (QModelIndex index, details.selectedTasks.selection)
            {
                domain::Task* dep = data->task(tasks.taskForIndex(index));
                task->addSubTask(dep);
            }

            Q_FOREACH (QString field, details.fields.keys())
                task->setField(field, details.fields[field]);
        }
        catch (tools::InvalidDataException& e)
        {
            data->removeData(task);
            throw e;
        }
    }
    catch (tools::StringException e)
    {
        ui->showError(e.message());
        return;
    }

    QMap<QString, domain::Project*> projectsMap;

    Q_FOREACH (domain::Project* project, data->projects())
        projectsMap[project->description()] = project;

    if (!projectsMap.isEmpty())
    {
        data::StringInputData input = ui->getChoice(projectsMap.keys(),
                                                    "Choose a project");

        if (input.processData)
        {
            try
            {
                task->setProject(projectsMap[input]);
            }
            catch (tools::StringException& e)
            {
                ui->showError(e.message());
            }
        }
    }

    TaskModel newTasks(data, taskList << task);
    ui->showModel(&newTasks, QString("Tasks of user %1").arg(user()->name()));
}

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

Q_EXPORT_PLUGIN2(controller_taskcreator, TaskCreator)

---