controllerinterface.cpp

#include "controllerinterface.h"

#include "unsupportedactionexception.h"
#include "controllerfactory.h"

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

using namespace control;

ControllerInterface::~ControllerInterface()
{
}

void ControllerInterface::init(domain::TaskManagerData* data,
                               ui::UiInterface* ui, ControllerFactory*)
{
    this->data = data;
    this->ui = ui;
}

void ControllerInterface::run()
{
    if (checkUser())
        execute();
}

void ControllerInterface::run(const domain::StorableData* data)
{
    if (checkUser())
        execute(data);
}

void ControllerInterface::execute(const domain::StorableData*)
{
    throw UnsupportedActionException();
}

bool ControllerInterface::checkUser() const
{
    if (!userIsValid())
    {
        QString msg;

        if (!userHasLoggedIn())
        {
            msg = "Cannot execute use case \"%1\" without being logged in";
            msg = msg.arg(description());
        }
        else
        {
            msg = "User %1 is not allowed to execute use case \"%2\"";
            msg = msg.arg(user()->name()).arg(description());
        }

        ui->showError(msg);

        return false;
    }

    return true;
}

bool ControllerInterface::userHasLoggedIn() const
{
    return ui->user() != 0;
}

bool ControllerInterface::userIsAdmin() const
{
    return userHasLoggedIn() && user()->isAdmin();
}

QString control::ControllerInterface::dataTypeString() const
{
    return dataTypeToString(dataType());
}

QString control::ControllerInterface::actionTypeString() const
{
    return actionTypeToString(actionType());
}

QString ControllerInterface::actionTypeToString(ActionType type)
{
    switch (type)
    {
        case CreateAction:   return "Create";
        case RemoveAction:   return "Remove";
        case ModifyAction:   return "Modify";
        case LoadDataAction: return "Load";
        default:             return "Other";
    }
}

QString ControllerInterface::dataTypeToString(DataType type)
{
    switch (type)
    {
        case FileData:          return "&File";
        case TaskData:          return "&Task";
        case ResourceData:      return "&Resource";
        case ProjectData:       return "&Project";
        case InvitationData:    return "&Invitations";
        case ReservationData:   return "Reser&vation";
        case UserData:          return "&User";
        default:                return "&Other";
    }
}

bool ControllerInterface::userCanExecute() const
{
    return true;
}

const domain::User* control::ControllerInterface::user() const
{
    Q_ASSERT(userHasLoggedIn());
    return ui->user();
}

---