577 lines
20 KiB
C++
577 lines
20 KiB
C++
#include "RestQueryHandler.h"
|
|
#include "Version.h"
|
|
|
|
using namespace Rest;
|
|
using namespace Logging;
|
|
using namespace Downloader;
|
|
using namespace JasonPP;
|
|
|
|
void RestQueryHandler::PreInit()
|
|
{
|
|
log = new Logger("RestQueryHandler");
|
|
|
|
return;
|
|
}
|
|
|
|
bool RestQueryHandler::ProcessQuery(const std::string clientAdress, const Json& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
// Print the client ip address alongide every log
|
|
log->SetAdditionalInformation(std::string("@") + clientAdress);
|
|
|
|
if (!ValidateField("request", JDType::STRING, request, responseBody))
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::BAD_REQUEST;
|
|
return false;
|
|
}
|
|
JsonBlock requestBody = request.AsJson;
|
|
std::string requestName = requestBody.Get("request").AsString;
|
|
|
|
|
|
|
|
if (requestName == "kill_yourself") return KillYourself(requestBody, responseBody, responseCode);
|
|
else if (requestName == "queue_download") return QueueDownload(requestBody, responseBody, responseCode);
|
|
else if (requestName == "fetch_session_cache") return FetchSessionCache(requestBody, responseBody, responseCode);
|
|
else if (requestName == "fetch_alltime_cache") return FetchAlltimeCache(requestBody, responseBody, responseCode);
|
|
else if (requestName == "get_disk_usage") return GetDiskUsage(requestBody, responseBody, responseCode);
|
|
else if (requestName == "clear_download_cache") return ClearDownloadCache(requestBody, responseBody, responseCode);
|
|
else if (requestName == "clear_logs") return ClearLogs(requestBody, responseBody, responseCode);
|
|
else if (requestName == "foo") return Example_Foo(requestBody, responseBody, responseCode);
|
|
else if (requestName == "show_console") return ShowConsole(requestBody, responseBody, responseCode);
|
|
else if (requestName == "hide_console") return HideConsole(requestBody, responseBody, responseCode);
|
|
else if (requestName == "get_os_name") return GetOSName(requestBody, responseBody, responseCode);
|
|
else if (requestName == "fetch_session_logs") return FetchSessionLogs(requestBody, responseBody, responseCode);
|
|
else if (requestName == "fetch_alltime_logs") return FetchAlltimeLogs(requestBody, responseBody, responseCode);
|
|
else if (requestName == "update_dep_yt-dlp") return UpdateYtDlp(requestBody, responseBody, responseCode);
|
|
else if (requestName == "remove_download_entry") return RemoveDownloadEntry(requestBody, responseBody, responseCode);
|
|
else if (requestName == "update_config") return UpdateConfig(requestBody, responseBody, responseCode);
|
|
else if (requestName == "reset_config_to_default_values") return ResetConfigDefaults(requestBody, responseBody, responseCode);
|
|
else if (requestName == "get_server_version") return GetServerVersion(requestBody, responseBody, responseCode);
|
|
|
|
|
|
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::NOT_FOUND, "The requested request was not found."));
|
|
responseCode = HTTP_STATUS_CODE::NOT_FOUND;
|
|
return false;
|
|
}
|
|
|
|
void RestQueryHandler::PostExit()
|
|
{
|
|
delete log;
|
|
log = nullptr;
|
|
|
|
return;
|
|
}
|
|
|
|
bool RestQueryHandler::Example_Foo(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("message") = "Bar!";
|
|
std::cout << "Bar!" << std::endl;
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::QueueDownload(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
// Fetch parameters
|
|
if ((!ValidateField("video_url", JDType::STRING, request, responseBody)) ||
|
|
(!ValidateField("mode", JDType::STRING, request, responseBody)))
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::BAD_REQUEST;
|
|
return false;
|
|
}
|
|
|
|
std::string videoUrl = request.Get("video_url").AsString;
|
|
std::string modeParam = request.Get("mode").AsString;
|
|
std::string qualityParam;
|
|
|
|
// 'quality' is an optional parameter. Default value is 'best'
|
|
if ((ValidateField("quality", JDType::STRING, request, responseBody)))
|
|
{
|
|
qualityParam = request.Get("quality").AsString;
|
|
}
|
|
else
|
|
{
|
|
qualityParam = "best";
|
|
}
|
|
|
|
// Process parameters
|
|
// Process download mode
|
|
DOWNLOAD_MODE mode;
|
|
if (modeParam == "video") mode = DOWNLOAD_MODE::VIDEO;
|
|
else if (modeParam == "audio") mode = DOWNLOAD_MODE::AUDIO;
|
|
else
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::BAD_REQUEST;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::BAD_REQUEST, "Parameter 'mode' is of wrong value. Should be either 'video' or 'audio'."));
|
|
return false;
|
|
}
|
|
|
|
// Process download quality
|
|
DOWNLOAD_QUALITY quality = DownloadManager::GetDownloadQualityByName(qualityParam);
|
|
if (quality == DOWNLOAD_QUALITY::INVALID) {
|
|
responseCode = HTTP_STATUS_CODE::BAD_REQUEST;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::BAD_REQUEST, "Parameter 'quality' is of wrong value. Choose either 'best', '1440p', '1080p', '720p', '480p', '360p', '240p', or '144p'."));
|
|
return false;
|
|
}
|
|
|
|
log->cout << "Queued video \"" << videoUrl << "\"...";
|
|
log->Flush();
|
|
|
|
std::string tubId = DownloadManager::QueueDownload(videoUrl, mode, quality);
|
|
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("message") = "Download queued!";
|
|
responseBody.Set("queue_position") = (long long int)DownloadManager::GetQueueLength();
|
|
responseBody.Set("tubio_id") = tubId;
|
|
JsonArray cache = DownloadManager::GetAlltimeCacheAsJson(time(0) - XGControl::boot_time, -1);
|
|
responseBody.Set("cache_size") = (long long int)cache.Size();
|
|
responseBody.Set("cache") = cache;
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::FetchSessionCache(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
//log->cout << "Asking for session cache...";
|
|
//log->Flush();
|
|
|
|
time_t max_age = time(0) - XGControl::boot_time; // Default max_age is session length
|
|
std::size_t max_num = (std::size_t )-1; // Default max_num is infinite
|
|
|
|
JsonBlock dummy;
|
|
if (ValidateField("max_age", JDType::INT, request, dummy))
|
|
{
|
|
// Only respect the given max_age, if the age does not exceed tubio boot-time!
|
|
// This way we can ensure that only entries of this SESSION will appear!
|
|
if (request["max_age"].AsInt >= 0)
|
|
{
|
|
#ifdef _WIN
|
|
max_age = min(request["max_age"].AsInt, max_age);
|
|
#else
|
|
max_age = std::min<long int>(request["max_age"].AsInt, max_age);
|
|
#endif
|
|
}
|
|
}
|
|
if (ValidateField("max_num", JDType::INT, request, dummy))
|
|
{
|
|
max_num = request["max_num"].AsInt;
|
|
}
|
|
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
JsonArray cache = DownloadManager::GetAlltimeCacheAsJson(max_age, max_num);
|
|
responseBody.Set("cache_size") = (long long int)cache.Size();
|
|
responseBody.Set("cache") = cache;
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::FetchAlltimeCache(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
//log->cout << "Asking for whole cache...";
|
|
//log->Flush();
|
|
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
JsonArray cache = DownloadManager::GetAlltimeCacheAsJson(-1, -1); // Get ALL the data
|
|
responseBody.Set("cache_size") = (long long int)cache.Size();
|
|
responseBody.Set("cache") = cache;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::ClearDownloadCache(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
log->cout << "Clearing download cache...";
|
|
log->Flush();
|
|
|
|
bool wait = !DownloadManager::ClearDownloadCache();
|
|
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
|
|
if (wait)
|
|
{
|
|
responseBody.Set("status") = "OK_WAIT";
|
|
responseBody.Set("message") = "Download cache cannot be cleared right now because there are active downloads, but will be cleared as soon as those have finished!";
|
|
}
|
|
else
|
|
{
|
|
responseBody.Set("message") = "Download cache has been cleared!";
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::KillYourself(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
XGControl::keepServerRunning = false;
|
|
|
|
log->cout << "Shutting down server upon client request...";
|
|
log->Flush();
|
|
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("message") = "Goodbye! :3";
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::HideConsole(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
if (ConsoleManager::IsSupported())
|
|
{
|
|
log->cout << "Hiding console...";
|
|
log->Flush();
|
|
|
|
bool didAnythingChange = ConsoleManager::HideConsole();
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("message") = (didAnythingChange) ? "Console is now hidden!" : "Console was already hidden!";
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::NOT_IMPLEMENTED;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::NOT_IMPLEMENTED));
|
|
responseBody.Set("message") = "This feature is currently only supported on Windows! Make sure to compile with preprocessor directive _WIN!";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool RestQueryHandler::ShowConsole(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
if (ConsoleManager::IsSupported())
|
|
{
|
|
log->cout << "Showing console...";
|
|
log->Flush();
|
|
|
|
bool didAnythingChange = ConsoleManager::ShowConsole();
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("message") = (didAnythingChange) ? "Console is now shown!" : "Console was already shown!";
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::NOT_IMPLEMENTED;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::NOT_IMPLEMENTED));
|
|
responseBody.Set("message") = "This feature is currently only supported on Windows! Make sure to compile with preprocessor directive _WIN!";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool RestQueryHandler::GetOSName(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
log->cout << "Asking for server OS name...";
|
|
log->Flush();
|
|
|
|
std::string osName = "Other";
|
|
#ifdef _WIN
|
|
osName = "Windows";
|
|
#elif __APPLE__ || __MACH__
|
|
osName = "Mac OSX";
|
|
#elif __linux__
|
|
osName = "Linux";
|
|
#elif __FreeBSD__
|
|
osName = "FreeBSD";
|
|
#elif __unix || __unix__
|
|
osName = "Unix";
|
|
#endif
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("os_name") = osName;
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::FetchSessionLogs(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
//log->cout << "Fetching session logs...";
|
|
//log->Flush();
|
|
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
JsonArray logs = LogHistory::GetCompleteLogHistoryAsJson(time(0) - XGControl::boot_time + 1, -1);
|
|
responseBody.Set("logs_size") = (long long int)logs.Size();
|
|
responseBody.Set("logs") = logs;
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::FetchAlltimeLogs(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
//log->cout << "Fetching alltime logs...";
|
|
//log->Flush();
|
|
|
|
time_t max_age = -1;
|
|
std::size_t max_num = (std::size_t) - 1;
|
|
|
|
JsonBlock dummy;
|
|
if (ValidateField("max_age", JDType::INT, request, dummy))
|
|
{
|
|
max_age = request["max_age"].AsInt;
|
|
}
|
|
if (ValidateField("max_num", JDType::INT, request, dummy))
|
|
{
|
|
max_num = request["max_num"].AsInt;
|
|
}
|
|
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
JsonArray logs = LogHistory::GetCompleteLogHistoryAsJson(max_age, max_num);
|
|
responseBody.Set("logs_size") = (long long int)logs.Size();
|
|
responseBody.Set("logs") = logs;
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::GetDiskUsage(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
log->cout << "Fetching disk usage...";
|
|
log->Flush();
|
|
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
|
|
JsonBlock diskUsages;
|
|
|
|
long long int dlcache = 0;
|
|
if (FileSystem::ExistsDirectory(XGConfig::downloader.cachedir))
|
|
{
|
|
dlcache = FileSystem::CalculateSize(XGConfig::downloader.cachedir, true);
|
|
}
|
|
diskUsages.Set("dlcache") = dlcache;
|
|
|
|
long long int logs = 0;
|
|
if (FileSystem::Exists("log.txt"))
|
|
{
|
|
logs += FileSystem::CalculateSize("log.txt");
|
|
}
|
|
if (FileSystem::Exists("log.json"))
|
|
{
|
|
logs += FileSystem::CalculateSize("log.json");
|
|
}
|
|
diskUsages.Set("logs") = logs;
|
|
|
|
long long int misc = 0;
|
|
if (FileSystem::Exists("config.json"))
|
|
{
|
|
misc += FileSystem::CalculateSize("config.json");
|
|
}
|
|
diskUsages.Set("misc") = misc;
|
|
|
|
long long int dependencies = 0;
|
|
if (FileSystem::Exists("ffmpeg.exe"))
|
|
{
|
|
dependencies += FileSystem::CalculateSize("ffmpeg.exe");
|
|
}
|
|
if (FileSystem::Exists("ffprobe.exe"))
|
|
{
|
|
dependencies += FileSystem::CalculateSize("ffprobe.exe");
|
|
}
|
|
if (FileSystem::Exists("ffplay.exe"))
|
|
{
|
|
dependencies += FileSystem::CalculateSize("ffplay.exe");
|
|
}
|
|
if (FileSystem::Exists("yt-dlp.exe"))
|
|
{
|
|
dependencies += FileSystem::CalculateSize("yt-dlp.exe");
|
|
}
|
|
diskUsages.Set("dependencies") = dependencies;
|
|
|
|
diskUsages.Set("total") = dlcache + logs + misc + dependencies;
|
|
|
|
responseBody.Set("disk_usage") = diskUsages;
|
|
responseBody.Set("message") = "Disk usage in bytes. Dependencies are 0 on linux, because the dependencies should be installed globally.";
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::ClearLogs(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("message") = "The logs have been cleared.";
|
|
|
|
LogHistory::ClearLogHistory();
|
|
log->cout << "Cleared logs...";
|
|
log->Flush();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::UpdateYtDlp(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
log->cout << "Updating yt-dlp...";
|
|
log->Flush();
|
|
|
|
std::string result = Updater::UpdateYtDlp();
|
|
if (result == "OK")
|
|
{
|
|
log->cout << " => OK!";
|
|
log->Flush();
|
|
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("message") = "Updated yt-dlp.exe successfully!";
|
|
}
|
|
else if (result == "not implemented")
|
|
{
|
|
log->cout << " => NOT_IMPLEMENTED!";
|
|
log->Flush();
|
|
|
|
log->Flush();
|
|
responseCode = HTTP_STATUS_CODE::NOT_IMPLEMENTED;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::NOT_IMPLEMENTED));
|
|
responseBody.Set("message") = "On linux you have to update yt-dlp yourself since it is a system-wide package handled by various package managers!";
|
|
}
|
|
else // Some other error
|
|
{
|
|
log->cout << " => urlmon error: " << result;
|
|
log->Flush();
|
|
|
|
responseCode = HTTP_STATUS_CODE::INTERNAL_SERVER_ERROR;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::INTERNAL_SERVER_ERROR));
|
|
responseBody.Set("message") = "Unable do update yt-dlp.exe! See urlmon " + result;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::RemoveDownloadEntry(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
if (!ValidateField("id", JDType::STRING, request, responseBody))
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::BAD_REQUEST;
|
|
return false;
|
|
}
|
|
|
|
log->cout << "Removing download id " << request["id"].AsString << "...";
|
|
log->Flush();
|
|
|
|
bool didSucceed = Downloader::DownloadManager::RemoveFromCacheByID(request["id"].AsString);
|
|
|
|
if (didSucceed)
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("message") = "Successfully removed.";
|
|
}
|
|
else
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::BAD_REQUEST;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::BAD_REQUEST));
|
|
responseBody.Set("message") = "Failed.";
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::UpdateConfig(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
|
|
JsonBlock dummy;
|
|
if (ValidateField("config", JDType::JSON, request, dummy))
|
|
{
|
|
bool prevStateConsole = XGConfig::general.show_console;
|
|
XGConfig::LoadFromJson(request.Get("config").AsJson);
|
|
|
|
// Update console, if necessary
|
|
if (XGConfig::general.show_console != prevStateConsole)
|
|
{
|
|
if (XGConfig::general.show_console) ConsoleManager::ShowConsole();
|
|
else ConsoleManager::HideConsole();
|
|
}
|
|
|
|
log->cout << "Updated config values...";
|
|
log->Flush();
|
|
XGConfig::Save();
|
|
|
|
responseBody.Set("message") = "Updated settings";
|
|
}
|
|
else
|
|
{
|
|
responseBody.Set("message") = "Updated no settings";
|
|
}
|
|
|
|
responseBody.Set("config") = XGConfig::GetSavefileBuffer();
|
|
return true;
|
|
}
|
|
|
|
bool RestQueryHandler::ResetConfigDefaults(const JsonBlock& request, JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
log->cout << "Reset config values to default...";
|
|
log->Flush();
|
|
|
|
bool prevStateConsole = XGConfig::general.show_console;
|
|
XGConfig::LoadDefaultValues();
|
|
XGConfig::Save();
|
|
// Update console, if necessary
|
|
if (XGConfig::general.show_console != prevStateConsole)
|
|
{
|
|
if (XGConfig::general.show_console) ConsoleManager::ShowConsole();
|
|
else ConsoleManager::HideConsole();
|
|
}
|
|
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("message") = "Reset config to default...";
|
|
responseBody.Set("config") = XGConfig::GetSavefileBuffer();
|
|
return true;
|
|
}
|
|
|
|
bool Rest::RestQueryHandler::GetServerVersion(const JasonPP::JsonBlock& request, JasonPP::JsonBlock& responseBody, HTTP_STATUS_CODE& responseCode)
|
|
{
|
|
responseCode = HTTP_STATUS_CODE::OK;
|
|
responseBody.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::OK));
|
|
responseBody.Set("server_version").SetFloatData(TUBIO_SERVER_VERSION);
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool RestQueryHandler::ValidateField(const std::string name, const JasonPP::JDType type, const JasonPP::Json& checkThat, JasonPP::JsonBlock& putErrorResponseHere)
|
|
{
|
|
if (checkThat.GetDataType() != JDType::JSON)
|
|
{
|
|
putErrorResponseHere = RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::BAD_REQUEST, "The request body must be a json struct! No json array or similar...");
|
|
return false;
|
|
}
|
|
|
|
const JsonBlock& cachedJson = checkThat.AsJson;
|
|
|
|
if (cachedJson.DoesShorthandExist(name))
|
|
{
|
|
const JsonData& cached = cachedJson.ShorthandGet(name);
|
|
|
|
if ((cached.GetDataType() == type) ||
|
|
((cached.IsOfNumericType()) && (type == JDType::INT)) ||
|
|
((cached.IsOfNumericType()) && (type == JDType::FLOAT)))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
std::stringstream ss;
|
|
ss << "Mandatory value \"" << name << "\" is of wrong type (" << JsonDataType2String(cached.GetDataType()) << ")" << std::endl;
|
|
ss << "Should be of type " << JsonDataType2String(type) << "! (Integers can be casted to floats)";
|
|
|
|
putErrorResponseHere.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::BAD_REQUEST, ss.str()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
putErrorResponseHere.CloneFrom(RestResponseTemplates::GetByCode(HTTP_STATUS_CODE::BAD_REQUEST, std::string("Missing mandatory value '" + name + "'")));
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
Logger* RestQueryHandler::log;
|