taskworker.cpp

#include "taskworker.h"

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

#include <domain/taskmanagerdata.h>
#include <domain/user.h>
#include <domain/invitation.h>

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

#include <QPluginLoader>
#include <QDir>
#include <QDebug>

#ifdef Q_OS_WIN32
#define FILTER "focus_*.dll"
#else
#define FILTER "libfocus_*.so"
#endif

using namespace control;

ControllerInterface::ActionType TaskWorker::actionType() const
{
    return CustomAction;
}

ControllerInterface::DataType TaskWorker::dataType() const
{
    return NoData;
}

QString TaskWorker::description() const
{
    return "Focus work";
}

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

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

void TaskWorker::execute()
{
    Q_ASSERT(!focusStrategies.isEmpty());

    QMap<QString, FocusInterface*> strategyMap;

    Q_FOREACH (FocusInterface* c, focusStrategies)
        strategyMap[c->description()] = c;

    data::StringInputData choice = ui->getChoice(strategyMap.keys(),
                                                 "Please choose how you want to focus:");

    if (!choice.processData)
        return;

    Q_ASSERT(strategyMap.contains(choice));

    currentTasks = data->tasksForUser(user());

    Q_FOREACH (const domain::Invitation* inv, user()->invitations())
        currentTasks << data->task(inv->task());

    if (!strategyMap[choice]->applyFocus(&currentTasks))
        return;

    if (currentTasks.isEmpty())
        ui->showMessage("No tasks in the selected focus.");
    else
        showTaskList();
}

void TaskWorker::execute(const domain::StorableData* data)
{
    Q_ASSERT(taskUpdater != 0);
    Q_ASSERT(taskModifier != 0);

    domain::Task* task = this->data->task(qobject_cast<const domain::Task*>(data));

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

    QString changeFocusOption = "Change focus";
    QString returnOption = "Return to task list";
    QString modifyOption = "Modify task details";
    QString updateOption = "Update task status";

    QStringList options = QStringList() << changeFocusOption << returnOption
                                        << modifyOption << updateOption;

    QList<domain::Task*> subTasksList;

    Q_FOREACH (const domain::Task* subTask, task->subTasks())
        subTasksList << this->data->task(subTask);

    data::TaskRepresentation rep;
    TaskModel subTasks(this->data, tools::makeConstList(subTasksList));
    rep.subTasks = &subTasks;
    rep.type = data::TaskTypeDetails(task->taskType());
    data::TaskDetails details(task);
    rep.details = details;
    UserRequirementsModel userReqs(task);
    rep.userReqs = &userReqs;
    ResourceRequirementsModel resourceReqs(task);
    rep.resourceReqs = &resourceReqs;

    control::data::StringInputData input = ui->showTaskDetails(rep, options);

    if (!input.processData)
        return;

    QString chosenOption = input.data;

    if (chosenOption == changeFocusOption)
        execute();
    else if (chosenOption == returnOption)
        showTaskList();
    else if (chosenOption == modifyOption)
        taskModifier->run(task);
    else if (chosenOption == updateOption)
        taskUpdater->run(task);
    else
        qFatal("Unkown option chosen.");
}

void TaskWorker::showTaskList()
{
    TaskModel taskModel(data, tools::makeConstList(currentTasks));
    data::SelectionData selection = ui->getSelection("Select a task", &taskModel);

    if (!selection.processData)
        return;

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

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

    try
    {
        execute(taskModel.taskForIndex(selection.selection.first()));
    }
    catch (tools::StringException e)
    {
        ui->showError(e.message());
    }
}

void TaskWorker::init(domain::TaskManagerData* data, ui::UiInterface* ui,
                      ControllerFactory* factory)
{
    ControllerInterface::init(data, ui, factory);

    QDir pluginsDir = PLUGINS_PATH;
    pluginsDir.setNameFilters(QStringList() << FILTER);

    //load focus plugins
    QStringList files = pluginsDir.entryList(QDir::Files);

    Q_FOREACH (QString fileName, files)
    {
        QPluginLoader pluginLoader(pluginsDir.absoluteFilePath(fileName));

        if (pluginLoader.load())
        {
            FocusInterface* strategy =
                        qobject_cast<FocusInterface*>(pluginLoader.instance());

            if (strategy != 0)
            {
                strategy->init(data, ui);
                focusStrategies << strategy;
            }
        }
        else
        {
            qDebug() << "Failed to load" << fileName
                     << "because" << pluginLoader.errorString();
        }
    }

    if (focusStrategies.isEmpty())
        throw tools::StringException("No focus strategies found.");

    taskModifier = factory->controllerByType(TaskData, ModifyAction);

    if (taskModifier == 0)
        throw tools::StringException("No controller to modify a task.");

    taskUpdater = factory->controllerByType(TaskData, UpdateAction);

    if (taskUpdater == 0)
        throw tools::StringException("No controller to update a task's status.");
}

Q_EXPORT_PLUGIN2(controller_taskworker, TaskWorker)

---