invitationmanager.cpp

#include "invitationmanager.h"

#include <controldata.h>
#include <domain/taskmanagerdata.h>
#include <domain/invitation.h>
#include <domain/user.h>
#include <models/invitationmodel.h>
#include <models/taskmodel.h>
#include <models/usermodel.h>
#include <tools/invaliddataexception.h>
#include <tools/functions.h>

using namespace control;

ControllerInterface::ActionType InvitationManager::actionType() const
{
    return ManageAction;
}

ControllerInterface::DataType InvitationManager::dataType() const
{
    return InvitationData;
}

QString InvitationManager::description() const
{
    return "Manage invitations";
}

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

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

void InvitationManager::execute()
{
    QList<domain::Task*> tasksForUser = data->tasksForUser(user());

    if (tasksForUser.isEmpty())
    {
        ui->showWarning(QString("User %1 does not have any tasks").arg(user()->name()));
        return;
    }

    TaskModel tasks(data, tools::makeConstList(tasksForUser));
    data::SelectionData selectedTasks = ui->getSelection(
                    "Select a task for managing its invitations", &tasks);

    if (!selectedTasks.processData)
        return;

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

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

    domain::Task* task =
        data->task(tasks.taskForIndex(selectedTasks.selection.first()));

    InvitationModel invitations(data, task);
    ui->showModel(&invitations, "This is a list of the invitations "
                                                        "of the selected task");

    QStringList list;
    list << "Add" << "Remove";
    data::StringInputData choice =
            ui->getChoice(list,"Do you want to add or remove an invitation?");

    if (!choice.processData)
        return;

    if ((QString)choice == "Add")
    {
        UserModel users(data);
        data::SelectionData selectedUser =
                    ui->getSelection("Select a user you want to invite", &users);

        if (!selectedUser.processData)
            return;

        if (selectedUser.selection.isEmpty())
        {
            ui->showError("No user selected");
            return;
        }

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

        try
        {
            domain::User* user =
                data->user(users.userForIndex(selectedUser.selection.first()));

            data->createInvitation(task, user);
            ui->showMessage("Invitation successfully created");
            return;
        }
        catch(tools::InvalidDataException e)
        {
            ui->showError(e.message());
            execute();
            return;
        }
    }
    else if ((QString) choice == "Remove")
    {
        if (task->invitations().isEmpty())
        {
            ui->showWarning("No invitations to remove for the selected task");
            return;
        }

        data::SelectionData selectedInvitation =
                ui->getSelection("Select an invitation to remove", &invitations);

        if (!selectedInvitation.processData)
            return;

        if (selectedInvitation.selection.isEmpty())
        {
            ui->showError("No invitation selected");
            return;
        }

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

        const domain::Invitation* inv = invitations.
                        invitationForIndex(selectedInvitation.selection.first());

        try
        {
            data->removeData(inv);
            ui->showMessage("Invitation successfully removed");
        }
        catch (tools::StringException e)
        {
            ui->showError(e.message());
        }

        execute();
        return;
    }
    else
    {
        qFatal("This is embarrasing");
    }
}

Q_EXPORT_PLUGIN2(controller_invitationmanager, InvitationManager)

---