arcanis/queued
1
0
Fork 0
mirror of https://github.com/arcan1s/queued.git synced 2025-07-16 15:19:56 +00:00
Code Issues Projects Releases Wiki Activity

massive api changes: replace public method results to Result<T, E>

Browse Source
This commit is contained in:
Evgenii Alekseev
2017-10-27 02:35:04 +03:00
parent de0653f038
commit bdb1dd0101
66 changed files with 1807 additions and 891 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
sources/queued-server/src/QueuedServer.cpp
View File

@ -45,17 +45,21 @@ void QueuedServer::init()
{
m_server->init(QueuedCoreAdaptor::getOption(
QueuedConfig::QueuedSettings::ServerTimeout)
.get()
.toInt());
QString address = QueuedCoreAdaptor::getOption(
QueuedConfig::QueuedSettings::ServerAddress)
.get()
.toString();
ushort port
= QueuedCoreAdaptor::getOption(QueuedConfig::QueuedSettings::ServerPort)
.get()
.toUInt();
m_server->listen(QHostAddress(address), port);
m_server->setMaxPendingConnections(
QueuedCoreAdaptor::getOption(
QueuedConfig::QueuedSettings::ServerMaxConnections)
.get()
.toInt());
qCInfo(LOG_SERV) << "Server listen on" << m_server->serverAddress()

2
sources/queued-server/src/QueuedTcpServerResponseHelper.h
View File

@ -42,7 +42,7 @@ typedef struct {
QString type;
bool valid;
} Request;
const QHash<int, QByteArray> HTTPCodeMap
static const QHash<int, QByteArray> HTTPCodeMap
= {{100, "Continue"},
{101, "Switching Protocols"},
{200, "OK"},

5
sources/queued-server/src/QueuedTcpServerResponseHelperApi1.cpp
View File

@ -139,7 +139,10 @@ QVariantHash QueuedTcpServerResponseHelperApi1::getStatus()
{
QVariantHash output = {{"code", 200}};
auto data = QueuedCoreAdaptor::getStatus();
auto res = QueuedCoreAdaptor::getStatus();
if (res.type() != Result::Content::Value)
return {};
auto data = res.get();
auto sections = data.keys();
sections.sort();
for (auto &section : sections) {

22
sources/queued-server/src/QueuedTcpServerResponseHelperAuth.cpp
View File

@ -25,9 +25,17 @@ QVariantHash QueuedTcpServerResponseHelperAuth::auth(const QVariantHash &_data)
QVariantHash output;
if (_data.contains("user") && _data.contains("password")) {
output["token"] = QueuedCoreAdaptor::auth(_data["user"].toString(),
_data["password"].toString());
output["code"] = output["token"].toString().isEmpty() ? 401 : 200;
auto res = QueuedCoreAdaptor::auth(_data["user"].toString(),
_data["password"].toString());
Result::match(
res,
[&output](const QString &val) {
output = {{"code", 200}, {"token", val}};
},
[&output](const QueuedError &err) {
output = {{"code", 401}, {"message", err.message().c_str()}};
});
} else {
output = {{"code", 400}, {"message", "No required fields found"}};
}
@ -40,5 +48,11 @@ bool QueuedTcpServerResponseHelperAuth::tryAuth(const QString &_token)
{
qCDebug(LOG_APP) << "Try auth with" << _token;
return QueuedCoreAdaptor::auth(_token);
auto res = QueuedCoreAdaptor::auth(_token);
bool ret = true;
Result::match(res, [&ret](const bool val) { ret = val; },
[&ret](const QueuedError &err) { ret = false; });
return ret;
}

31
sources/queued-server/src/QueuedTcpServerResponseHelperOption.cpp
View File

@ -24,7 +24,18 @@ QueuedTcpServerResponseHelperOption::getOption(const QString &_option)
{
qCDebug(LOG_SERV) << "Get option" << _option;
return {{"code", 200}, {"value", QueuedCoreAdaptor::getOption(_option)}};
auto res = QueuedCoreAdaptor::getOption(_option);
QVariantHash output;
Result::match(res,
[&output](const QVariant &val) {
output = {{"code", 200}, {"token", val}};
},
[&output](const QueuedError &) {
output = {{"code", 404}, {"message", "Option not found"}};
});
return output;
}
@ -36,8 +47,18 @@ QVariantHash QueuedTcpServerResponseHelperOption::setOption(
if (!_value.contains("value"))
return {{"code", 400}, {"message", "No required fields found"}};
return {{"code",
QueuedCoreAdaptor::sendOptionEdit(_option, _value["value"], _token)
? 200
: 400}};
auto res
= QueuedCoreAdaptor::sendOptionEdit(_option, _value["value"], _token);
QVariantHash output;
Result::match(
res,
[&output](const QVariant &) {
output = {{"code", 200}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}

36
sources/queued-server/src/QueuedTcpServerResponseHelperPermissions.cpp
View File

@ -32,10 +32,20 @@ QVariantHash QueuedTcpServerResponseHelperPermissions::addPermission(
if (permission == QueuedEnums::Permission::Invalid)
return {{"code", 400}, {"message", "Invalid permission"}};
return {{"code",
QueuedCoreAdaptor::sendUserPermissionAdd(_id, permission, _token)
? 200
: 400}};
auto res
= QueuedCoreAdaptor::sendUserPermissionAdd(_id, permission, _token);
QVariantHash output;
Result::match(
res,
[&output](const QVariant &) {
output = {{"code", 200}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}
@ -52,8 +62,18 @@ QVariantHash QueuedTcpServerResponseHelperPermissions::removePermission(
if (permission == QueuedEnums::Permission::Invalid)
return {{"code", 400}, {"message", "Invalid permission"}};
return {{"code", QueuedCoreAdaptor::sendUserPermissionRemove(
_id, permission, _token)
? 200
: 400}};
auto res
= QueuedCoreAdaptor::sendUserPermissionRemove(_id, permission, _token);
QVariantHash output;
Result::match(
res,
[&output](const QVariant &) {
output = {{"code", 200}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}

47
sources/queued-server/src/QueuedTcpServerResponseHelperPlugins.cpp
View File

@ -25,16 +25,38 @@ QueuedTcpServerResponseHelperPlugins::addPlugin(const QString &_name,
{
qCDebug(LOG_SERV) << "Add plugin" << _name;
return {
{"code", QueuedCoreAdaptor::sendPluginAdd(_name, _token) ? 200 : 400}};
auto res = QueuedCoreAdaptor::sendPluginAdd(_name, _token);
QVariantHash output;
Result::match(
res,
[&output](const bool) {
output = {{"code", 200}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}
QVariantHash QueuedTcpServerResponseHelperPlugins::listPlugins()
{
return {{"code", 200},
{"plugins", QueuedCoreAdaptor::getOption(
QueuedConfig::QueuedSettings::Plugins)}};
auto res
= QueuedCoreAdaptor::getOption(QueuedConfig::QueuedSettings::Plugins);
QVariantHash output;
Result::match(
res,
[&output](const QVariant &val) {
output = {{"code", 200}, {"plugins", val.toStringList()}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}
@ -44,6 +66,17 @@ QueuedTcpServerResponseHelperPlugins::removePlugin(const QString &_name,
{
qCDebug(LOG_SERV) << "Remove plugin" << _name;
return {{"code",
QueuedCoreAdaptor::sendPluginRemove(_name, _token) ? 200 : 400}};
auto res = QueuedCoreAdaptor::sendPluginRemove(_name, _token);
QVariantHash output;
Result::match(
res,
[&output](const bool) {
output = {{"code", 200}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}

135
sources/queued-server/src/QueuedTcpServerResponseHelperTask.cpp
View File

@ -25,15 +25,33 @@ QVariantHash QueuedTcpServerResponseHelperTask::addOrEditTask(
qCDebug(LOG_SERV) << "Add or edit task" << _id << "with data" << _data;
auto defs = getDefinitions(_data);
QVariantHash output;
if (_id > 0) {
// edit existing task
bool status = QueuedCoreAdaptor::sendTaskEdit(_id, defs, _token);
return {{"code", status ? 200 : 400}};
auto res = QueuedCoreAdaptor::sendTaskEdit(_id, defs, _token);
Result::match(
res,
[&output](const bool val) {
output = {{"code", val ? 200 : 500}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
} else {
// add new task
auto id = QueuedCoreAdaptor::sendTaskAdd(defs, _token);
return {{"code", id > 0 ? 200 : 400}, {"id", id}};
auto res = QueuedCoreAdaptor::sendTaskAdd(defs, _token);
Result::match(
res,
[&output](const long long val) {
output = {{"code", val ? 200 : 500}, {"id", val}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
}
return output;
}
@ -78,11 +96,25 @@ QueuedTcpServerResponseHelperTask::getTask(const long long _id,
auto property = _data["property"].toString();
QVariantHash output = {{"code", 200}};
if (property.isEmpty())
output["properties"] = QueuedCoreAdaptor::getTask(_id);
else
output["properties"] = QVariantHash(
{{property, QueuedCoreAdaptor::getTask(_id, property)}});
if (property.isEmpty()) {
auto res = QueuedCoreAdaptor::getTask(_id);
Result::match(
res,
[&output](const QVariantHash &val) { output["properties"] = val; },
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
} else {
auto res = QueuedCoreAdaptor::getTask(_id, property);
Result::match(
res,
[&output, &property](const QVariant &val) {
output["properties"] = {{property, val}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
}
return output;
}
@ -100,13 +132,20 @@ QueuedTcpServerResponseHelperTask::getTasks(const QVariantHash &_data,
QDateTime stop
= QDateTime::fromString(_data["stop"].toString(), Qt::ISODateWithMs);
QVariantHash output = {{"code", 200}};
QVariantHash output;
// some conversion magic
QVariantList outputReport;
auto report = QueuedCoreAdaptor::getTasks(userId, start, stop, _token);
for (auto &user : report)
outputReport.append(user);
output["report"] = outputReport;
auto res = QueuedCoreAdaptor::getTasks(userId, start, stop, _token);
Result::match(
res,
[&output, &outputReport](const QList<QVariantHash> &val) {
for (auto &user : val)
outputReport += user;
output = {{"code", 200}, {"report", outputReport}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}
@ -118,15 +157,63 @@ QueuedTcpServerResponseHelperTask::startOrStopTask(const long long _id,
{
qCDebug(LOG_SERV) << "Change task state" << _id;
QVariantHash task = QueuedCoreAdaptor::getTask(_id);
if (task.isEmpty())
return {{"code", 400}, {"message", "No task found"}};
auto res = QueuedCoreAdaptor::getTask(_id);
if (task["startTime"].toString().isEmpty()
|| !task["endTime"].toString().isEmpty())
return {{"code",
QueuedCoreAdaptor::sendTaskStart(_id, _token) ? 200 : 400}};
else
return {
{"code", QueuedCoreAdaptor::sendTaskStop(_id, _token) ? 200 : 400}};
QVariantHash output;
Result::match(
res,
[&output, &_id, &_token](const QVariantHash &val) {
if (val["startTime"].toString().isEmpty()
|| !val["endTime"].toString().isEmpty())
output = startTask(_id, _token);
else
output = stopTask(_id, _token);
},
[&output](const QueuedError &err) {
output = {{"code", 400}, {"message", err.message().c_str()}};
});
return output;
}
QVariantHash QueuedTcpServerResponseHelperTask::startTask(const long long _id,
const QString &_token)
{
qCDebug(LOG_SERV) << "Start task" << _id;
auto res = QueuedCoreAdaptor::sendTaskStart(_id, _token);
QVariantHash output;
Result::match(
res,
[&output](const bool val) {
output = {{"code", val ? 200 : 500}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}
QVariantHash QueuedTcpServerResponseHelperTask::stopTask(const long long _id,
const QString &_token)
{
qCDebug(LOG_SERV) << "Stop task" << _id;
auto res = QueuedCoreAdaptor::sendTaskStop(_id, _token);
QVariantHash output;
Result::match(
res,
[&output](const bool val) {
output = {{"code", val ? 200 : 500}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}

2
sources/queued-server/src/QueuedTcpServerResponseHelperTask.h
View File

@ -31,6 +31,8 @@ getDefinitions(const QVariantHash &_data);
QVariantHash getTask(const long long _id, const QVariantHash &_data);
QVariantHash getTasks(const QVariantHash &_data, const QString &_token);
QVariantHash startOrStopTask(const long long _id, const QString &_token);
QVariantHash startTask(const long long _id, const QString &_token);
QVariantHash stopTask(const long long _id, const QString &_token);
};

98
sources/queued-server/src/QueuedTcpServerResponseHelperUser.cpp
View File

@ -25,19 +25,40 @@ QVariantHash QueuedTcpServerResponseHelperUser::addOrEditUser(
qCDebug(LOG_SERV) << "Add user" << _user << "with data" << _data;
// try define if user exists first
auto userId = QueuedCoreAdaptor::getUserId(_user);
auto userIdRes = QueuedCoreAdaptor::getUserId(_user);
long long userId = -1;
Result::match(userIdRes, [&userId](const long long val) { userId = val; },
[&userId](const QueuedError &) {});
auto defs = getDefinitions(_data);
defs.name = _user;
QVariantHash output;
if (userId > 0) {
// edit existing user
bool status = QueuedCoreAdaptor::sendUserEdit(userId, defs, _token);
return {{"code", status ? 200 : 400}};
auto res = QueuedCoreAdaptor::sendUserEdit(userId, defs, _token);
Result::match(
res,
[&output](const bool val) {
output = {{"code", val ? 200 : 500}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
} else {
// add new user
auto id = QueuedCoreAdaptor::sendUserAdd(defs, _token);
return {{"code", id > 0 ? 200 : 400}, {"id", id}};
auto res = QueuedCoreAdaptor::sendUserAdd(defs, _token);
Result::match(
res,
[&output](const long long val) {
output = {{"code", val ? 200 : 500}, {"id", val}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
}
return output;
}
@ -48,7 +69,10 @@ QueuedTcpServerResponseHelperUser::getDefinitions(const QVariantHash &_data)
QueuedUser::QueuedUserDefinitions defs;
defs.email = _data["email"].toString();
defs.password = QueuedUser::hashFromPassword(_data["password"].toString());
auto res = QueuedCoreAdaptor::sendPasswordHash(_data["password"].toString());
Result::match(
res, [&defs](const QString &val) { defs.password = val; },
[](const QueuedError &) {});
defs.permissions = _data["permissions"].toUInt();
// limits
QueuedLimits::Limits limits;
@ -77,10 +101,17 @@ QueuedTcpServerResponseHelperUser::getReport(const QVariantHash &_data,
QVariantHash output = {{"code", 200}};
// some conversion magic
QVariantList outputReport;
auto report = QueuedCoreAdaptor::getPerformance(start, stop, _token);
for (auto &user : report)
outputReport.append(user);
output["report"] = outputReport;
auto res = QueuedCoreAdaptor::getPerformance(start, stop, _token);
Result::match(
res,
[&output, &outputReport](const QList<QVariantHash> &val) {
for (auto &user : val)
outputReport += user;
output = {{"code", 200}, {"report", outputReport}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}
@ -92,15 +123,35 @@ QueuedTcpServerResponseHelperUser::getUser(const QString &_user,
{
qCDebug(LOG_SERV) << "Get user data for" << _user << _data;
auto userId = QueuedCoreAdaptor::getUserId(_user);
auto userIdRes = QueuedCoreAdaptor::getUserId(_user);
long long userId = -1;
Result::match(userIdRes, [&userId](const long long val) { userId = val; },
[](const QueuedError &) {});
if (userId == -1)
return {{"code", 500}};
auto property = _data["property"].toString();
QVariantHash output = {{"code", 200}};
if (property.isEmpty())
output["properties"] = QueuedCoreAdaptor::getUser(userId);
else
output["properties"] = QVariantHash(
{{property, QueuedCoreAdaptor::getUser(userId, property)}});
if (property.isEmpty()) {
auto res = QueuedCoreAdaptor::getUser(userId);
Result::match(
res,
[&output](const QVariantHash &val) { output["properties"] = val; },
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
} else {
auto res = QueuedCoreAdaptor::getUser(userId, property);
Result::match(
res,
[&output, &property](const QVariant &val) {
output["properties"] = {{property, val}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
}
return output;
}
@ -120,10 +171,17 @@ QueuedTcpServerResponseHelperUser::getUsers(const QVariantHash &_data,
QVariantHash output = {{"code", 200}};
// some conversion magic
QVariantList outputReport;
auto report = QueuedCoreAdaptor::getUsers(lastLogin, permission, _token);
for (auto &user : report)
outputReport.append(user);
output["report"] = outputReport;
auto res = QueuedCoreAdaptor::getUsers(lastLogin, permission, _token);
Result::match(
res,
[&output, &outputReport](const QList<QVariantHash> &val) {
for (auto &user : val)
outputReport += user;
output = {{"code", 200}, {"report", outputReport}};
},
[&output](const QueuedError &err) {
output = {{"code", 500}, {"message", err.message().c_str()}};
});
return output;
}