You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6312 lines
244 KiB
6312 lines
244 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2012 maintech GmbH, Otto-Hahn-Str. 15, 97204 Hoechberg, Germany // |
|
// written by Christian Daniel // |
|
// Copyright (C) 2015-2023 Edouard Griffiths, F4EXB <f4exb06@gmail.com> // |
|
// Copyright (C) 2020-2023 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Copyright (C) 2021 Christoph Berg <myon@debian.org> // |
|
// // |
|
// Swagger server adapter interface // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program is distributed in the hope that it will be useful, // |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
// GNU General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include <QDirIterator> |
|
#include <QJsonDocument> |
|
#include <QJsonArray> |
|
|
|
#include <boost/lexical_cast.hpp> |
|
|
|
#include "SWGDemodAnalyzerActions.h" |
|
#include "httpdocrootsettings.h" |
|
#include "webapirequestmapper.h" |
|
#include "webapiutils.h" |
|
#include "SWGInstanceSummaryResponse.h" |
|
#include "SWGInstanceConfigResponse.h" |
|
#include "SWGInstanceDevicesResponse.h" |
|
#include "SWGInstanceChannelsResponse.h" |
|
#include "SWGInstanceFeaturesResponse.h" |
|
#include "SWGAudioDevices.h" |
|
#include "SWGLocationInformation.h" |
|
#include "SWGLimeRFESettings.h" |
|
#include "SWGPresets.h" |
|
#include "SWGPresetTransfer.h" |
|
#include "SWGPresetIdentifier.h" |
|
#include "SWGPresetExport.h" |
|
#include "SWGBase64Blob.h" |
|
#include "SWGFilePath.h" |
|
#include "SWGConfigurations.h" |
|
#include "SWGConfigurationIdentifier.h" |
|
#include "SWGConfigurationImportExport.h" |
|
#include "SWGDeviceSettings.h" |
|
#include "SWGDeviceState.h" |
|
#include "SWGDeviceReport.h" |
|
#include "SWGDeviceActions.h" |
|
#include "SWGWorkspaceInfo.h" |
|
#include "SWGWorkspaceActions.h" |
|
#include "SWGWindowList.h" |
|
#include "SWGGLSpectrumHistory.h" |
|
#include "SWGChannelsDetail.h" |
|
#include "SWGChannelSettings.h" |
|
#include "SWGChannelReport.h" |
|
#include "SWGChannelActions.h" |
|
#include "SWGSuccessResponse.h" |
|
#include "SWGErrorResponse.h" |
|
#include "SWGFeaturePresets.h" |
|
#include "SWGFeaturePresetIdentifier.h" |
|
#include "SWGFeatureSettings.h" |
|
#include "SWGFeatureReport.h" |
|
#include "SWGFeatureActions.h" |
|
#include "SWGGLSpectrum.h" |
|
#include "SWGGLSpectrumReport.h" |
|
#include "SWGSpectrumActions.h" |
|
#include "SWGGLSpectrumData.h" |
|
#include "SWGSpectrumServer.h" |
|
|
|
WebAPIRequestMapper::WebAPIRequestMapper(QObject* parent) : |
|
HttpRequestHandler(parent), |
|
m_adapter(0) |
|
{ |
|
#ifndef _MSC_VER |
|
Q_INIT_RESOURCE(webapi); |
|
#endif |
|
qtwebapp::HttpDocrootSettings docrootSettings; |
|
docrootSettings.path = ":/webapi"; |
|
m_staticFileController = new qtwebapp::StaticFileController(docrootSettings, parent); |
|
} |
|
|
|
WebAPIRequestMapper::~WebAPIRequestMapper() |
|
{ |
|
delete m_staticFileController; |
|
#ifndef _MSC_VER |
|
Q_CLEANUP_RESOURCE(webapi); |
|
#endif |
|
} |
|
|
|
void WebAPIRequestMapper::service(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
if (m_adapter == 0) // format service unavailable if adapter is null |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
response.setStatus(500,"Service not available"); |
|
|
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Service not available"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
else // normal processing |
|
{ |
|
QByteArray path=request.getPath(); |
|
|
|
// Handle pre-flight requests |
|
if (request.getMethod() == "OPTIONS") |
|
{ |
|
qDebug("WebAPIRequestMapper::service: method OPTIONS: assume pre-flight"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
response.setHeader("Access-Control-Allow-Headers", "*"); |
|
response.setHeader("Access-Control-Allow-Methods", "*"); |
|
response.setStatus(200, "OK"); |
|
return; |
|
} |
|
|
|
if (path == WebAPIAdapterInterface::instanceSummaryURL) { |
|
instanceSummaryService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceConfigURL) { |
|
instanceConfigService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceDevicesURL) { |
|
instanceDevicesService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceChannelsURL) { |
|
instanceChannelsService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceFeaturesURL) { |
|
instanceFeaturesService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceLoggingURL) { |
|
instanceLoggingService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceAudioURL) { |
|
instanceAudioService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceAudioInputParametersURL) { |
|
instanceAudioInputParametersService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceAudioOutputParametersURL) { |
|
instanceAudioOutputParametersService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceAudioInputCleanupURL) { |
|
instanceAudioInputCleanupService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceAudioOutputCleanupURL) { |
|
instanceAudioOutputCleanupService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceLocationURL) { |
|
instanceLocationService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instancePresetsURL) { |
|
instancePresetsService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instancePresetURL) { |
|
instancePresetService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instancePresetFileURL) { |
|
instancePresetFileService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instancePresetBlobURL) { |
|
instancePresetBlobService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceConfigurationsURL) { |
|
instanceConfigurationsService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceConfigurationURL) { |
|
instanceConfigurationService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceConfigurationFileURL) { |
|
instanceConfigurationFileService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceConfigurationBlobURL) { |
|
instanceConfigurationBlobService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceFeaturePresetsURL) { |
|
instanceFeaturePresetsService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceFeaturePresetURL) { |
|
instanceFeaturePresetService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceDeviceSetsURL) { |
|
instanceDeviceSetsService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceDeviceSetURL) { |
|
instanceDeviceSetService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceWorkspaceURL) { |
|
instanceWorkspaceService(request, response); |
|
} else if (path == WebAPIAdapterInterface::instanceWindowsURL) { |
|
instanceWindowsService(request, response); |
|
} else if (path == WebAPIAdapterInterface::featuresetURL) { |
|
featuresetService(request, response); |
|
} else if (path == WebAPIAdapterInterface::featuresetFeatureURL) { |
|
featuresetFeatureService(request, response); |
|
} else if (path == WebAPIAdapterInterface::featuresetPresetURL) { |
|
featuresetPresetService(request, response); |
|
} |
|
else |
|
{ |
|
std::smatch desc_match; |
|
std::string pathStr(path.constData(), path.length()); |
|
|
|
if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetURLRe)) { |
|
devicesetService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceURLRe)) { |
|
devicesetDeviceService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetSpectrumSettingsURLRe)) { |
|
devicesetSpectrumSettingsService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetSpectrumReportURLRe)) { |
|
devicesetSpectrumReportService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetSpectrumActionsURLRe)) { |
|
devicesetSpectrumActionsService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetSpectrumDataURLRe)) { |
|
devicesetSpectrumDataService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetSpectrumHistoryURLRe)) { |
|
devicesetSpectrumHistoryService(std::string(desc_match[1]), request, response, false); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetSpectrumHistoryImageURLRe)) { |
|
devicesetSpectrumHistoryService(std::string(desc_match[1]), request, response, true); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetSpectrumServerURLRe)) { |
|
devicesetSpectrumServerService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::workspaceActionsURLRe)) { |
|
workspaceActionsService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetSpectrumWorkspaceURLRe)) { |
|
devicesetSpectrumWorkspaceService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceSettingsURLRe)) { |
|
devicesetDeviceSettingsService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceRunURLRe)) { |
|
devicesetDeviceRunService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceSubsystemRunURLRe)) { |
|
devicesetDeviceSubsystemRunService(std::string(desc_match[1]), std::string(desc_match[2]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceReportURLRe)) { |
|
devicesetDeviceReportService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceActionsURLRe)) { |
|
devicesetDeviceActionsService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceWorkspaceURLRe)) { |
|
devicesetDeviceWorkspaceService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelsReportURLRe)) { |
|
devicesetChannelsReportService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelURLRe)) { |
|
devicesetChannelService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelIndexURLRe)) { |
|
devicesetChannelIndexService(std::string(desc_match[1]), std::string(desc_match[2]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelSettingsURLRe)) { |
|
devicesetChannelSettingsService(std::string(desc_match[1]), std::string(desc_match[2]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelReportURLRe)) { |
|
devicesetChannelReportService(std::string(desc_match[1]), std::string(desc_match[2]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelActionsURLRe)) { |
|
devicesetChannelActionsService(std::string(desc_match[1]), std::string(desc_match[2]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelWorkspaceURLRe)) { |
|
devicesetChannelWorkspaceService(std::string(desc_match[1]), std::string(desc_match[2]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureIndexURLRe)) { |
|
featuresetFeatureIndexService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureRunURLRe)) { |
|
featuresetFeatureRunService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureSettingsURLRe)) { |
|
featuresetFeatureSettingsService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureReportURLRe)) { |
|
featuresetFeatureReportService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureActionsURLRe)) { |
|
featuresetFeatureActionsService(std::string(desc_match[1]), request, response); |
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureWorkspaceURLRe)) { |
|
featuresetFeatureWorkspaceService(std::string(desc_match[1]), request, response); |
|
} |
|
else // serve static documentation pages |
|
{ |
|
m_staticFileController->service(request, response); |
|
} |
|
|
|
// QDirIterator it(":", QDirIterator::Subdirectories); |
|
// while (it.hasNext()) { |
|
// qDebug() << "WebAPIRequestMapper::service: " << it.next(); |
|
// } |
|
|
|
} |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceSummaryService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGInstanceSummaryResponse normalResponse; |
|
|
|
int status = m_adapter->instanceSummary(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
|
|
int status = m_adapter->instanceDelete(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceConfigService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGInstanceConfigResponse query; |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGInstanceConfigResponse normalResponse; |
|
int status = m_adapter->instanceConfigGet(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if ((request.getMethod() == "PUT") || (request.getMethod() == "PATCH")) |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
WebAPIAdapterInterface::ConfigKeys configKeys; |
|
SWGSDRangel::SWGInstanceConfigResponse query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
query.init(); |
|
|
|
if (validateConfig(query, jsonObject, configKeys)) |
|
{ |
|
int status = m_adapter->instanceConfigPutPatch( |
|
request.getMethod() == "PUT", |
|
query, |
|
configKeys, |
|
normalResponse, |
|
errorResponse |
|
); |
|
response.setStatus(status); |
|
qDebug("WebAPIRequestMapper::instanceConfigService: %s: %d", |
|
request.getMethod() == "PUT" ? "PUT" : "PATCH", status); |
|
|
|
if (status/100 == 2) |
|
{ |
|
normalResponse.setMessage(new QString("Configuration updated successfully")); |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} |
|
else |
|
{ |
|
normalResponse.setMessage(new QString("Error occurred while updating configuration")); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
|
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceDevicesService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGInstanceDevicesResponse normalResponse; |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
QByteArray dirStr = request.getParameter("direction"); |
|
int direction = 0; |
|
|
|
if (dirStr.length() != 0) |
|
{ |
|
bool ok; |
|
int tmp = dirStr.toInt(&ok); |
|
if (ok) { |
|
direction = tmp; |
|
} |
|
} |
|
|
|
int status = m_adapter->instanceDevices(direction, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceChannelsService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGInstanceChannelsResponse normalResponse; |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
QByteArray dirStr = request.getParameter("direction"); |
|
int direction = 0; |
|
|
|
if (dirStr.length() != 0) |
|
{ |
|
bool ok; |
|
int tmp = dirStr.toInt(&ok); |
|
if (ok) { |
|
direction = tmp; |
|
} |
|
} |
|
|
|
int status = m_adapter->instanceChannels(direction, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceFeaturesService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGInstanceFeaturesResponse normalResponse; |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
int status = m_adapter->instanceFeatures(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceLoggingService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGLoggingInfo query; |
|
SWGSDRangel::SWGLoggingInfo normalResponse; |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
int status = m_adapter->instanceLoggingGet(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "PUT") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
int status = m_adapter->instanceLoggingPut(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceAudioService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGAudioDevices normalResponse; |
|
|
|
int status = m_adapter->instanceAudioGet(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceAudioInputParametersService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGAudioInputDevice normalResponse; |
|
resetAudioInputDevice(normalResponse); |
|
QStringList audioInputDeviceKeys; |
|
|
|
if (validateAudioInputDevice(normalResponse, jsonObject, audioInputDeviceKeys)) |
|
{ |
|
if (request.getMethod() == "PATCH") |
|
{ |
|
int status = m_adapter->instanceAudioInputPatch( |
|
normalResponse, |
|
audioInputDeviceKeys, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
int status = m_adapter->instanceAudioInputDelete( |
|
normalResponse, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceAudioOutputParametersService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGAudioOutputDevice normalResponse; |
|
resetAudioOutputDevice(normalResponse); |
|
QStringList audioOutputDeviceKeys; |
|
|
|
if (validateAudioOutputDevice(normalResponse, jsonObject, audioOutputDeviceKeys)) |
|
{ |
|
if (request.getMethod() == "PATCH") |
|
{ |
|
int status = m_adapter->instanceAudioOutputPatch( |
|
normalResponse, |
|
audioOutputDeviceKeys, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
int status = m_adapter->instanceAudioOutputDelete( |
|
normalResponse, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceAudioInputCleanupService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "PATCH") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
|
|
int status = m_adapter->instanceAudioInputCleanupPatch(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceAudioOutputCleanupService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "PATCH") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
|
|
int status = m_adapter->instanceAudioOutputCleanupPatch(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceLocationService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGLocationInformation normalResponse; |
|
|
|
int status = m_adapter->instanceLocationGet(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "PUT") |
|
{ |
|
SWGSDRangel::SWGLocationInformation normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
normalResponse.fromJson(jsonStr); |
|
int status = m_adapter->instanceLocationPut(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instancePresetsService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGPresets normalResponse; |
|
int status = m_adapter->instancePresetsGet(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instancePresetService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "PATCH") |
|
{ |
|
SWGSDRangel::SWGPresetTransfer query; |
|
SWGSDRangel::SWGPresetIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (validatePresetTransfer(query)) |
|
{ |
|
int status = m_adapter->instancePresetPatch(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "PUT") |
|
{ |
|
SWGSDRangel::SWGPresetTransfer query; |
|
SWGSDRangel::SWGPresetIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (validatePresetTransfer(query)) |
|
{ |
|
int status = m_adapter->instancePresetPut(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGPresetTransfer query; |
|
SWGSDRangel::SWGPresetIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (validatePresetTransfer(query)) |
|
{ |
|
int status = m_adapter->instancePresetPost(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGPresetIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
normalResponse.fromJson(jsonStr); |
|
|
|
if (validatePresetIdentifer(normalResponse)) |
|
{ |
|
int status = m_adapter->instancePresetDelete(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instancePresetFileService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "PUT") |
|
{ |
|
SWGSDRangel::SWGFilePath query; |
|
SWGSDRangel::SWGPresetIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (query.getFilePath()) |
|
{ |
|
int status = m_adapter->instancePresetFilePut(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGPresetExport query; |
|
SWGSDRangel::SWGPresetIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (validatePresetExport(query)) |
|
{ |
|
int status = m_adapter->instancePresetFilePost(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instancePresetBlobService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "PUT") |
|
{ |
|
SWGSDRangel::SWGBase64Blob query; |
|
SWGSDRangel::SWGPresetIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (query.getBlob()) |
|
{ |
|
int status = m_adapter->instancePresetBlobPut(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGPresetIdentifier query; |
|
SWGSDRangel::SWGBase64Blob normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (validatePresetIdentifer(query)) |
|
{ |
|
int status = m_adapter->instancePresetBlobPost(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceConfigurationsService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGConfigurations normalResponse; |
|
int status = m_adapter->instanceConfigurationsGet(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceConfigurationService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "PATCH") |
|
{ |
|
SWGSDRangel::SWGConfigurationIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
normalResponse.fromJson(jsonStr); |
|
|
|
if (validateConfigurationIdentifier(normalResponse)) |
|
{ |
|
int status = m_adapter->instanceConfigurationPatch(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "PUT") |
|
{ |
|
SWGSDRangel::SWGConfigurationIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
normalResponse.fromJson(jsonStr); |
|
|
|
if (validateConfigurationIdentifier(normalResponse)) |
|
{ |
|
int status = m_adapter->instanceConfigurationPut(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGConfigurationIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
normalResponse.fromJson(jsonStr); |
|
|
|
if (validateConfigurationIdentifier(normalResponse)) |
|
{ |
|
int status = m_adapter->instanceConfigurationPost(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGConfigurationIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
normalResponse.fromJson(jsonStr); |
|
|
|
if (validateConfigurationIdentifier(normalResponse)) |
|
{ |
|
int status = m_adapter->instanceConfigurationDelete(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceConfigurationFileService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "PUT") |
|
{ |
|
SWGSDRangel::SWGFilePath query; |
|
SWGSDRangel::SWGConfigurationIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (query.getFilePath()) |
|
{ |
|
int status = m_adapter->instanceConfigurationFilePut(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGConfigurationImportExport query; |
|
SWGSDRangel::SWGConfigurationIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (query.getFilePath() && query.getConfiguration() && validateConfigurationIdentifier(*query.getConfiguration())) |
|
{ |
|
int status = m_adapter->instanceConfigurationFilePost(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceConfigurationBlobService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "PUT") |
|
{ |
|
SWGSDRangel::SWGBase64Blob query; |
|
SWGSDRangel::SWGConfigurationIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (query.getBlob()) |
|
{ |
|
int status = m_adapter->instanceConfigurationBlobPut(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGConfigurationIdentifier query; |
|
SWGSDRangel::SWGBase64Blob normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (validateConfigurationIdentifier(query)) |
|
{ |
|
int status = m_adapter->instanceConfigurationBlobPost(query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceFeaturePresetsService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGFeaturePresets normalResponse; |
|
int status = m_adapter->instanceFeaturePresetsGet(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceFeaturePresetService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGFeaturePresetIdentifier normalResponse; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
normalResponse.fromJson(jsonStr); |
|
|
|
if (validateFeaturePresetIdentifer(normalResponse)) |
|
{ |
|
int status = m_adapter->instanceFeaturePresetDelete(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceDeviceSetsService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGDeviceSetList normalResponse; |
|
int status = m_adapter->instanceDeviceSetsGet(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceDeviceSetService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
QByteArray dirStr = request.getParameter("direction"); |
|
int direction = 0; |
|
|
|
if (dirStr.length() != 0) |
|
{ |
|
bool ok; |
|
int tmp = dirStr.toInt(&ok); |
|
if (ok) { |
|
direction = tmp; |
|
} |
|
} |
|
|
|
int status = m_adapter->instanceDeviceSetPost(direction, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
int status = m_adapter->instanceDeviceSetDelete(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceWorkspaceService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
int status = m_adapter->instanceWorkspacePost(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
int status = m_adapter->instanceWorkspaceDelete(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::instanceWindowsService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGWindowList normalResponse; |
|
int status = m_adapter->instanceWindowsGet(normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
try |
|
{ |
|
SWGSDRangel::SWGDeviceSet normalResponse; |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
int status = m_adapter->devicesetGet(deviceSetIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
|
|
|
|
|
|
void WebAPIRequestMapper::devicesetSpectrumHistoryService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response, bool image) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
auto fail = [&](int status, const QString& message) |
|
{ |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setStatus(status, message.toLatin1().constData()); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = message; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
}; |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if (request.getMethod() != "GET") |
|
{ |
|
fail(405, "Invalid HTTP method"); |
|
return; |
|
} |
|
|
|
// Numbers from the query string, each checked rather than defaulted on a parse failure |
|
double seconds = 60.0; |
|
int bins = image ? 512 : 128; |
|
int rows = 512; |
|
double threshold = 6.0; |
|
qint64 startFrequency = 0; |
|
qint64 stopFrequency = 0; |
|
|
|
for (const char *name : {"seconds", "bins", "rows", "threshold", "startFrequency", "stopFrequency"}) |
|
{ |
|
QByteArray parameter = request.getParameter(name); |
|
|
|
if (parameter.isEmpty()) { |
|
continue; |
|
} |
|
|
|
bool parsed = false; |
|
const double value = QString(parameter).toDouble(&parsed); |
|
|
|
if (!parsed) |
|
{ |
|
fail(400, QString("%1 must be a number").arg(name)); |
|
return; |
|
} |
|
|
|
const QString key(name); |
|
|
|
if (key == "seconds") { |
|
seconds = value; |
|
} else if (key == "bins") { |
|
bins = (int) value; |
|
} else if (key == "rows") { |
|
rows = (int) value; |
|
} else if (key == "threshold") { |
|
threshold = value; |
|
} else if (key == "startFrequency") { |
|
startFrequency = (qint64) value; |
|
} else { |
|
stopFrequency = (qint64) value; |
|
} |
|
} |
|
|
|
if ((seconds <= 0.0) || (bins < 1) || (rows < 1)) |
|
{ |
|
fail(400, "seconds, bins and rows must be positive"); |
|
return; |
|
} |
|
|
|
if (image) |
|
{ |
|
QByteArray png; |
|
QJsonObject description; |
|
int status = m_adapter->devicesetSpectrumHistoryImageGet(deviceSetIndex, seconds, bins, startFrequency, stopFrequency, rows, png, description, errorResponse); |
|
|
|
if (status / 100 != 2) |
|
{ |
|
fail(status, errorResponse.getMessage() ? *errorResponse.getMessage() : QString("Error")); |
|
return; |
|
} |
|
|
|
response.setHeader("Content-Type", "image/png"); |
|
|
|
for (const QString& key : description.keys()) { |
|
response.setHeader(("X-Spectrum-History-" + key).toLatin1(), description[key].toVariant().toString().toLatin1()); |
|
} |
|
|
|
response.setStatus(200); |
|
response.write(png); |
|
} |
|
else |
|
{ |
|
SWGSDRangel::SWGGLSpectrumHistory normalResponse; |
|
normalResponse.init(); |
|
int status = m_adapter->devicesetSpectrumHistoryGet(deviceSetIndex, seconds, bins, startFrequency, stopFrequency, threshold, normalResponse, errorResponse); |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
fail(400, QString("Wrong integer conversion on index %1").arg(e.what())); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetSpectrumDataService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
// Query parameters rather than a body, as this is a read |
|
bool ok = false; |
|
QByteArray binsParam = request.getParameter("bins"); |
|
int bins = binsParam.isEmpty() ? 128 : QString(binsParam).toInt(&ok); |
|
|
|
if (!binsParam.isEmpty() && !ok) |
|
{ |
|
response.setStatus(400, "bins must be a number"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "bins must be a number"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
return; |
|
} |
|
|
|
// Checked rather than defaulted: an unparseable frequency reads as 0, which the |
|
// endpoint takes to mean the whole span, so a mistyped one would quietly return |
|
// plausible data for the wrong range |
|
qint64 startFrequency = 0; |
|
qint64 stopFrequency = 0; |
|
|
|
for (const char *name : {"startFrequency", "stopFrequency"}) |
|
{ |
|
QByteArray parameter = request.getParameter(name); |
|
|
|
if (parameter.isEmpty()) { |
|
continue; |
|
} |
|
|
|
bool parsed = false; |
|
qint64 value = QString(parameter).toLongLong(&parsed); |
|
|
|
if (!parsed) |
|
{ |
|
QString message = QString("%1 must be a number").arg(name); |
|
response.setStatus(400, message.toLatin1().constData()); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = message; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
return; |
|
} |
|
|
|
if (QString(name) == "startFrequency") { |
|
startFrequency = value; |
|
} else { |
|
stopFrequency = value; |
|
} |
|
} |
|
|
|
QByteArray reduceParam = request.getParameter("reduce"); |
|
QString reduce = reduceParam.isEmpty() ? QString("max") : QString(reduceParam); |
|
|
|
SWGSDRangel::SWGGLSpectrumData normalResponse; |
|
normalResponse.init(); |
|
int status = m_adapter->devicesetSpectrumDataGet( |
|
deviceSetIndex, bins, startFrequency, stopFrequency, reduce, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405, "Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion: " + QString(e.what()); |
|
response.setStatus(400, errorResponse.getMessage()->toLatin1().constData()); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetSpectrumActionsService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if (request.getMethod() == "POST") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGSpectrumActions query; |
|
QStringList spectrumActionsKeys; |
|
extractKeys(jsonObject, spectrumActionsKeys); |
|
query.fromJson(jsonStr); |
|
int status = m_adapter->devicesetSpectrumActionsPost(deviceSetIndex, spectrumActionsKeys, query, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Message to change the spectrum was submitted successfully"; |
|
} |
|
|
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
else |
|
{ |
|
response.setStatus(400, "Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405, "Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion: " + QString(e.what()); |
|
response.setStatus(400, errorResponse.getMessage()->toLatin1().constData()); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetSpectrumReportService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGGLSpectrumReport normalResponse; |
|
resetSpectrumReport(normalResponse); |
|
int status = m_adapter->devicesetSpectrumReportGet(deviceSetIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405, "Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion: " + QString(e.what()); |
|
response.setStatus(400, errorResponse.getMessage()->toLatin1().constData()); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetSpectrumSettingsService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if ((request.getMethod() == "PUT") || (request.getMethod() == "PATCH")) |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGGLSpectrum normalResponse; |
|
resetSpectrumSettings(normalResponse); |
|
QStringList spectrumSettingsKeys; |
|
|
|
if (validateSpectrumSettings(normalResponse, jsonObject, spectrumSettingsKeys)) |
|
{ |
|
int status = m_adapter->devicesetSpectrumSettingsPutPatch( |
|
deviceSetIndex, |
|
(request.getMethod() == "PUT"), // force settings on PUT |
|
spectrumSettingsKeys, |
|
normalResponse, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGGLSpectrum normalResponse; |
|
resetSpectrumSettings(normalResponse); |
|
int status = m_adapter->devicesetSpectrumSettingsGet(deviceSetIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetSpectrumServerService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGSpectrumServer normalResponse; |
|
int status = m_adapter->devicesetSpectrumServerGet(deviceSetIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
int status = m_adapter->devicesetSpectrumServerPost(deviceSetIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
int status = m_adapter->devicesetSpectrumServerDelete(deviceSetIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetSpectrumWorkspaceService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGWorkspaceInfo normalResponse; |
|
int status = m_adapter->devicesetSpectrumWorkspaceGet(deviceSetIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "PUT") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGWorkspaceInfo query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
|
|
if (validateWorkspaceInfo(query, jsonObject)) |
|
{ |
|
int status = m_adapter->devicesetSpectrumWorkspacePut( |
|
deviceSetIndex, |
|
query, |
|
normalResponse, |
|
errorResponse |
|
); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetDeviceService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if (request.getMethod() == "PUT") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGDeviceListItem query; |
|
SWGSDRangel::SWGDeviceListItem normalResponse; |
|
|
|
if (validateDeviceListItem(query, jsonObject)) |
|
{ |
|
int status = m_adapter->devicesetDevicePut(deviceSetIndex, query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Missing device identification"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Missing device identification"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetDeviceSettingsService( |
|
const std::string& indexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response |
|
) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if ((request.getMethod() == "PUT") || (request.getMethod() == "PATCH")) |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGDeviceSettings normalResponse; |
|
resetDeviceSettings(normalResponse); |
|
QStringList deviceSettingsKeys; |
|
|
|
if (validateDeviceSettings(normalResponse, jsonObject, deviceSettingsKeys)) |
|
{ |
|
int status = m_adapter->devicesetDeviceSettingsPutPatch( |
|
deviceSetIndex, |
|
(request.getMethod() == "PUT"), // force settings on PUT |
|
deviceSettingsKeys, |
|
normalResponse, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGDeviceSettings normalResponse; |
|
resetDeviceSettings(normalResponse); |
|
int status = m_adapter->devicesetDeviceSettingsGet(deviceSetIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetDeviceRunService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGDeviceState normalResponse; |
|
int status = m_adapter->devicesetDeviceRunGet(deviceSetIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGDeviceState normalResponse; |
|
int status = m_adapter->devicesetDeviceRunPost(deviceSetIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGDeviceState normalResponse; |
|
int status = m_adapter->devicesetDeviceRunDelete(deviceSetIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetDeviceSubsystemRunService(const std::string& indexStr, const std::string& subsystemIndexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
int subsystemIndex = boost::lexical_cast<int>(subsystemIndexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGDeviceState normalResponse; |
|
int status = m_adapter->devicesetDeviceSubsystemRunGet(deviceSetIndex, subsystemIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGDeviceState normalResponse; |
|
int status = m_adapter->devicesetDeviceSubsystemRunPost(deviceSetIndex, subsystemIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGDeviceState normalResponse; |
|
int status = m_adapter->devicesetDeviceSubsystemRunDelete(deviceSetIndex, subsystemIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetDeviceReportService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
try |
|
{ |
|
SWGSDRangel::SWGDeviceReport normalResponse; |
|
resetDeviceReport(normalResponse); |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
int status = m_adapter->devicesetDeviceReportGet(deviceSetIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetDeviceWorkspaceService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGWorkspaceInfo normalResponse; |
|
int status = m_adapter->devicesetDeviceWorkspaceGet(deviceSetIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "PUT") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGWorkspaceInfo query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
|
|
if (validateWorkspaceInfo(query, jsonObject)) |
|
{ |
|
int status = m_adapter->devicesetDeviceWorkspacePut( |
|
deviceSetIndex, |
|
query, |
|
normalResponse, |
|
errorResponse |
|
); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
} |
|
catch(const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetDeviceActionsService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
|
|
if (request.getMethod() == "POST") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGDeviceActions query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
resetDeviceActions(query); |
|
QStringList deviceActionsKeys; |
|
|
|
if (validateDeviceActions(query, jsonObject, deviceActionsKeys)) |
|
{ |
|
int status = m_adapter->devicesetDeviceActionsPost( |
|
deviceSetIndex, |
|
deviceActionsKeys, |
|
query, |
|
normalResponse, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch(const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetChannelsReportService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
try |
|
{ |
|
SWGSDRangel::SWGChannelsDetail normalResponse; |
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr); |
|
int status = m_adapter->devicesetChannelsReportGet(deviceSetIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on device set index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetChannelService( |
|
const std::string& deviceSetIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(deviceSetIndexStr); |
|
|
|
if (request.getMethod() == "POST") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGChannelSettings query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
resetChannelSettings(query); |
|
|
|
if (jsonObject.contains("direction")) { |
|
query.setDirection(jsonObject["direction"].toInt()); |
|
} else { |
|
query.setDirection(0); // assume Rx |
|
} |
|
|
|
if (jsonObject.contains("channelType") && jsonObject["channelType"].isString()) |
|
{ |
|
query.setChannelType(new QString(jsonObject["channelType"].toString())); |
|
|
|
int status = m_adapter->devicesetChannelPost(deviceSetIndex, query, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetChannelIndexService( |
|
const std::string& deviceSetIndexStr, |
|
const std::string& channelIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(deviceSetIndexStr); |
|
int channelIndex = boost::lexical_cast<int>(channelIndexStr); |
|
|
|
if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
int status = m_adapter->devicesetChannelDelete(deviceSetIndex, channelIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetChannelSettingsService( |
|
const std::string& deviceSetIndexStr, |
|
const std::string& channelIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(deviceSetIndexStr); |
|
int channelIndex = boost::lexical_cast<int>(channelIndexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGChannelSettings normalResponse; |
|
resetChannelSettings(normalResponse); |
|
int status = m_adapter->devicesetChannelSettingsGet(deviceSetIndex, channelIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if ((request.getMethod() == "PUT") || (request.getMethod() == "PATCH")) |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGChannelSettings normalResponse; |
|
resetChannelSettings(normalResponse); |
|
QStringList channelSettingsKeys; |
|
|
|
if (validateChannelSettings(normalResponse, jsonObject, channelSettingsKeys)) |
|
{ |
|
int status = m_adapter->devicesetChannelSettingsPutPatch( |
|
deviceSetIndex, |
|
channelIndex, |
|
(request.getMethod() == "PUT"), // force settings on PUT |
|
channelSettingsKeys, |
|
normalResponse, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetChannelReportService( |
|
const std::string& deviceSetIndexStr, |
|
const std::string& channelIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(deviceSetIndexStr); |
|
int channelIndex = boost::lexical_cast<int>(channelIndexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGChannelReport normalResponse; |
|
resetChannelReport(normalResponse); |
|
int status = m_adapter->devicesetChannelReportGet(deviceSetIndex, channelIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::devicesetChannelActionsService( |
|
const std::string& deviceSetIndexStr, |
|
const std::string& channelIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(deviceSetIndexStr); |
|
int channelIndex = boost::lexical_cast<int>(channelIndexStr); |
|
|
|
if (request.getMethod() == "POST") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGChannelActions query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
resetChannelActions(query); |
|
QStringList channelActionsKeys; |
|
|
|
if (validateChannelActions(query, jsonObject, channelActionsKeys)) |
|
{ |
|
int status = m_adapter->devicesetChannelActionsPost( |
|
deviceSetIndex, |
|
channelIndex, |
|
channelActionsKeys, |
|
query, |
|
normalResponse, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch(const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
|
|
void WebAPIRequestMapper::devicesetChannelWorkspaceService( |
|
const std::string& deviceSetIndexStr, |
|
const std::string& channelIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int deviceSetIndex = boost::lexical_cast<int>(deviceSetIndexStr); |
|
int channelIndex = boost::lexical_cast<int>(channelIndexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGWorkspaceInfo normalResponse; |
|
int status = m_adapter->devicesetChannelWorkspaceGet(deviceSetIndex, channelIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "PUT") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGWorkspaceInfo query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
|
|
if (validateWorkspaceInfo(query, jsonObject)) |
|
{ |
|
int status = m_adapter->devicesetChannelWorkspacePut( |
|
deviceSetIndex, |
|
channelIndex, |
|
query, |
|
normalResponse, |
|
errorResponse |
|
); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch(const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::featuresetService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGFeatureSet normalResponse; |
|
int status = m_adapter->featuresetGet(0, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::featuresetFeatureService( |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "POST") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGFeatureSettings query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
resetFeatureSettings(query); |
|
|
|
if (jsonObject.contains("featureType") && jsonObject["featureType"].isString()) |
|
{ |
|
query.setFeatureType(new QString(jsonObject["featureType"].toString())); |
|
|
|
int status = m_adapter->featuresetFeaturePost(0, query, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::featuresetPresetService( |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
if (request.getMethod() == "PATCH") |
|
{ |
|
SWGSDRangel::SWGFeaturePresetIdentifier query; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (validateFeaturePresetIdentifer(query)) |
|
{ |
|
int status = m_adapter->featuresetPresetPatch(0, query, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(query.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "PUT") |
|
{ |
|
SWGSDRangel::SWGFeaturePresetIdentifier query; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (validateFeaturePresetIdentifer(query)) |
|
{ |
|
int status = m_adapter->featuresetPresetPut(0, query, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(query.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGFeaturePresetIdentifier query; |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
query.fromJson(jsonStr); |
|
|
|
if (validateFeaturePresetIdentifer(query)) |
|
{ |
|
int status = m_adapter->featuresetPresetPost(0, query, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(query.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::featuresetFeatureIndexService( |
|
const std::string& featureIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int featureIndex = boost::lexical_cast<int>(featureIndexStr); |
|
|
|
if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
int status = m_adapter->featuresetFeatureDelete(0, featureIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::featuresetFeatureRunService( |
|
const std::string& featureIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int featureIndex = boost::lexical_cast<int>(featureIndexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGDeviceState normalResponse; |
|
int status = m_adapter->featuresetFeatureRunGet(0, featureIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "POST") |
|
{ |
|
SWGSDRangel::SWGDeviceState normalResponse; |
|
int status = m_adapter->featuresetFeatureRunPost(0, featureIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
|
|
} |
|
else if (request.getMethod() == "DELETE") |
|
{ |
|
SWGSDRangel::SWGDeviceState normalResponse; |
|
int status = m_adapter->featuresetFeatureRunDelete(0, featureIndex, normalResponse, errorResponse); |
|
|
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::featuresetFeatureSettingsService( |
|
const std::string& featureIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int featureIndex = boost::lexical_cast<int>(featureIndexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGFeatureSettings normalResponse; |
|
resetFeatureSettings(normalResponse); |
|
int status = m_adapter->featuresetFeatureSettingsGet(0, featureIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if ((request.getMethod() == "PUT") || (request.getMethod() == "PATCH")) |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGFeatureSettings normalResponse; |
|
resetFeatureSettings(normalResponse); |
|
QStringList featureSettingsKeys; |
|
|
|
if (validateFeatureSettings(normalResponse, jsonObject, featureSettingsKeys)) |
|
{ |
|
int status = m_adapter->featuresetFeatureSettingsPutPatch( |
|
0, |
|
featureIndex, |
|
(request.getMethod() == "PUT"), // force settings on PUT |
|
featureSettingsKeys, |
|
normalResponse, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::featuresetFeatureReportService( |
|
const std::string& featureIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int featureIndex = boost::lexical_cast<int>(featureIndexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGFeatureReport normalResponse; |
|
resetFeatureReport(normalResponse); |
|
int status = m_adapter->featuresetFeatureReportGet(0, featureIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::featuresetFeatureActionsService( |
|
const std::string& featureIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int featureIndex = boost::lexical_cast<int>(featureIndexStr); |
|
|
|
if (request.getMethod() == "POST") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGFeatureActions query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
resetFeatureActions(query); |
|
QStringList featureActionsKeys; |
|
|
|
if (validateFeatureActions(query, jsonObject, featureActionsKeys)) |
|
{ |
|
int status = m_adapter->featuresetFeatureActionsPost( |
|
0, |
|
featureIndex, |
|
featureActionsKeys, |
|
query, |
|
normalResponse, |
|
errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch(const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::workspaceActionsService( |
|
const std::string& workspaceIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int workspaceIndex = boost::lexical_cast<int>(workspaceIndexStr); |
|
|
|
if (request.getMethod() == "POST") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGWorkspaceActions query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
|
|
if (validateWorkspaceActions(query, jsonObject)) |
|
{ |
|
int status = m_adapter->workspaceActionsPost(workspaceIndex, query, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request: arrange must be one of cascade, tile, stackVertical, stack, autostack, tab"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch (const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on workspace index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::featuresetFeatureWorkspaceService( |
|
const std::string& featureIndexStr, |
|
qtwebapp::HttpRequest& request, |
|
qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
response.setHeader("Content-Type", "application/json"); |
|
response.setHeader("Access-Control-Allow-Origin", "*"); |
|
|
|
try |
|
{ |
|
int featureIndex = boost::lexical_cast<int>(featureIndexStr); |
|
|
|
if (request.getMethod() == "GET") |
|
{ |
|
SWGSDRangel::SWGWorkspaceInfo normalResponse; |
|
int status = m_adapter->featuresetFeatureWorkspaceGet(featureIndex, normalResponse, errorResponse); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else if (request.getMethod() == "PUT") |
|
{ |
|
QString jsonStr = request.getBody(); |
|
QJsonObject jsonObject; |
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response)) |
|
{ |
|
SWGSDRangel::SWGWorkspaceInfo query; |
|
SWGSDRangel::SWGSuccessResponse normalResponse; |
|
|
|
if (validateWorkspaceInfo(query, jsonObject)) |
|
{ |
|
int status = m_adapter->featuresetFeatureWorkspacePut( |
|
featureIndex, |
|
query, |
|
normalResponse, |
|
errorResponse |
|
); |
|
response.setStatus(status); |
|
|
|
if (status/100 == 2) { |
|
response.write(normalResponse.asJson().toUtf8()); |
|
} else { |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON request"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON request"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(400,"Invalid JSON format"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid JSON format"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
else |
|
{ |
|
response.setStatus(405,"Invalid HTTP method"); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Invalid HTTP method"; |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
catch(const boost::bad_lexical_cast &e) |
|
{ |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = "Wrong integer conversion on index"; |
|
response.setStatus(400,"Invalid data"); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::parseJsonBody(QString& jsonStr, QJsonObject& jsonObject, qtwebapp::HttpResponse& response) |
|
{ |
|
SWGSDRangel::SWGErrorResponse errorResponse; |
|
|
|
try |
|
{ |
|
QByteArray jsonBytes(jsonStr.toStdString().c_str()); |
|
QJsonParseError error; |
|
QJsonDocument doc = QJsonDocument::fromJson(jsonBytes, &error); |
|
|
|
if (error.error == QJsonParseError::NoError) |
|
{ |
|
jsonObject = doc.object(); |
|
} |
|
else |
|
{ |
|
QString errorMsg = QString("Input JSON error: ") + error.errorString() + QString(" at offset ") + QString::number(error.offset); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = errorMsg; |
|
response.setStatus(400, errorMsg.toUtf8()); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
} |
|
|
|
return (error.error == QJsonParseError::NoError); |
|
} |
|
catch (const std::exception& ex) |
|
{ |
|
QString errorMsg = QString("Error parsing request: ") + ex.what(); |
|
errorResponse.init(); |
|
*errorResponse.getMessage() = errorMsg; |
|
response.setStatus(500, errorMsg.toUtf8()); |
|
response.write(errorResponse.asJson().toUtf8()); |
|
|
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::validatePresetTransfer(SWGSDRangel::SWGPresetTransfer& presetTransfer) |
|
{ |
|
SWGSDRangel::SWGPresetIdentifier *presetIdentifier = presetTransfer.getPreset(); |
|
|
|
if (presetIdentifier == 0) { |
|
return false; |
|
} |
|
|
|
return validatePresetIdentifer(*presetIdentifier); |
|
} |
|
|
|
bool WebAPIRequestMapper::validatePresetIdentifer(SWGSDRangel::SWGPresetIdentifier& presetIdentifier) |
|
{ |
|
return (presetIdentifier.getGroupName() && presetIdentifier.getName() && presetIdentifier.getType()); |
|
} |
|
|
|
bool WebAPIRequestMapper::validateConfigurationIdentifier(SWGSDRangel::SWGConfigurationIdentifier& configruationIdentifier) |
|
{ |
|
return configruationIdentifier.getGroupName() && configruationIdentifier.getName(); |
|
} |
|
|
|
bool WebAPIRequestMapper::validateFeaturePresetIdentifer(SWGSDRangel::SWGFeaturePresetIdentifier& presetIdentifier) |
|
{ |
|
return (presetIdentifier.getGroupName() && presetIdentifier.getDescription()); |
|
} |
|
|
|
bool WebAPIRequestMapper::validatePresetExport(SWGSDRangel::SWGPresetExport& presetExport) |
|
{ |
|
if (presetExport.getFilePath() == 0) { |
|
return false; |
|
} |
|
|
|
SWGSDRangel::SWGPresetIdentifier *presetIdentifier = presetExport.getPreset(); |
|
|
|
if (presetIdentifier == 0) { |
|
return false; |
|
} |
|
|
|
return validatePresetIdentifer(*presetIdentifier); |
|
} |
|
|
|
bool WebAPIRequestMapper::validateConfigurationImportExport(SWGSDRangel::SWGConfigurationImportExport& configurationImportExport) |
|
{ |
|
if (configurationImportExport.getFilePath() == nullptr) { |
|
return false; |
|
} |
|
|
|
SWGSDRangel::SWGConfigurationIdentifier *congfigurationIdentifier = configurationImportExport.getConfiguration(); |
|
|
|
if (congfigurationIdentifier == nullptr) { |
|
return false; |
|
} |
|
|
|
return validateConfigurationIdentifier(*congfigurationIdentifier); |
|
} |
|
|
|
bool WebAPIRequestMapper::validateDeviceListItem(SWGSDRangel::SWGDeviceListItem& deviceListItem, QJsonObject& jsonObject) |
|
{ |
|
if (jsonObject.contains("direction")) { |
|
deviceListItem.setDirection(jsonObject["direction"].toInt()); |
|
} else { |
|
deviceListItem.setDirection(0); // assume Rx |
|
} |
|
|
|
bool identified = false; |
|
|
|
if (jsonObject.contains("displayedName") && jsonObject["displayedName"].isString()) |
|
{ |
|
deviceListItem.setDisplayedName(new QString(jsonObject["displayedName"].toString())); |
|
identified = true; |
|
} else { |
|
deviceListItem.setDisplayedName(0); |
|
} |
|
|
|
|
|
if (jsonObject.contains("hwType") && jsonObject["hwType"].isString()) |
|
{ |
|
deviceListItem.setHwType(new QString(jsonObject["hwType"].toString())); |
|
identified = true; |
|
} else { |
|
deviceListItem.setHwType(0); |
|
} |
|
|
|
if (jsonObject.contains("serial") && jsonObject["serial"].isString()) |
|
{ |
|
deviceListItem.setSerial(new QString(jsonObject["serial"].toString())); |
|
identified = true; |
|
} else { |
|
deviceListItem.setSerial(0); |
|
} |
|
|
|
if (jsonObject.contains("index")) { |
|
deviceListItem.setIndex(jsonObject["index"].toInt(-1)); |
|
} else { |
|
deviceListItem.setIndex(-1); |
|
} |
|
|
|
if (jsonObject.contains("sequence")){ |
|
deviceListItem.setSequence(jsonObject["sequence"].toInt(-1)); |
|
} else { |
|
deviceListItem.setSequence(-1); |
|
} |
|
|
|
if (jsonObject.contains("deviceStreamIndex")) { |
|
deviceListItem.setDeviceStreamIndex(jsonObject["deviceStreamIndex"].toInt(-1)); |
|
} else { |
|
deviceListItem.setDeviceStreamIndex(-1); |
|
} |
|
|
|
return identified; |
|
} |
|
|
|
bool WebAPIRequestMapper::validateDeviceSettings( |
|
SWGSDRangel::SWGDeviceSettings& deviceSettings, |
|
QJsonObject& jsonObject, |
|
QStringList& deviceSettingsKeys) |
|
{ |
|
if (jsonObject.contains("direction")) { |
|
deviceSettings.setDirection(jsonObject["direction"].toInt()); |
|
} else { |
|
deviceSettings.setDirection(0); // assume single Rx |
|
} |
|
|
|
if (jsonObject.contains("deviceHwType") && jsonObject["deviceHwType"].isString()) { |
|
deviceSettings.setDeviceHwType(new QString(jsonObject["deviceHwType"].toString())); |
|
} else { |
|
return false; |
|
} |
|
|
|
QString *deviceHwType = deviceSettings.getDeviceHwType(); |
|
QString deviceSettingsKey; |
|
|
|
if (deviceSettings.getDirection() == 0) // source |
|
{ |
|
if (WebAPIUtils::m_sourceDeviceHwIdToSettingsKey.contains(*deviceHwType)) { |
|
deviceSettingsKey = WebAPIUtils::m_sourceDeviceHwIdToSettingsKey[*deviceHwType]; |
|
} else { |
|
return false; |
|
} |
|
} |
|
else if (deviceSettings.getDirection() == 1) // sink |
|
{ |
|
if (WebAPIUtils::m_sinkDeviceHwIdToSettingsKey.contains(*deviceHwType)) { |
|
deviceSettingsKey = WebAPIUtils::m_sinkDeviceHwIdToSettingsKey[*deviceHwType]; |
|
} else { |
|
return false; |
|
} |
|
} |
|
else if (deviceSettings.getDirection() == 2) // MIMO |
|
{ |
|
if (WebAPIUtils::m_mimoDeviceHwIdToSettingsKey.contains(*deviceHwType)) { |
|
deviceSettingsKey = WebAPIUtils::m_mimoDeviceHwIdToSettingsKey[*deviceHwType]; |
|
} else { |
|
return false; |
|
} |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
return getDeviceSettings(deviceSettingsKey, &deviceSettings, jsonObject, deviceSettingsKeys); |
|
} |
|
|
|
bool WebAPIRequestMapper::validateDeviceActions( |
|
SWGSDRangel::SWGDeviceActions& deviceActions, |
|
QJsonObject& jsonObject, |
|
QStringList& deviceActionsKeys) |
|
{ |
|
if (jsonObject.contains("direction")) { |
|
deviceActions.setDirection(jsonObject["direction"].toInt()); |
|
} else { |
|
deviceActions.setDirection(0); // assume single Rx |
|
} |
|
|
|
if (jsonObject.contains("deviceHwType") && jsonObject["deviceHwType"].isString()) { |
|
deviceActions.setDeviceHwType(new QString(jsonObject["deviceHwType"].toString())); |
|
} else { |
|
return false; |
|
} |
|
|
|
QString *deviceHwType = deviceActions.getDeviceHwType(); |
|
QString deviceActionsKey; |
|
|
|
if (deviceActions.getDirection() == 0) // source |
|
{ |
|
if (WebAPIUtils::m_sourceDeviceHwIdToSettingsKey.contains(*deviceHwType)) { |
|
deviceActionsKey = WebAPIUtils::m_sourceDeviceHwIdToActionsKey[*deviceHwType]; |
|
} else { |
|
return false; |
|
} |
|
} |
|
else if (deviceActions.getDirection() == 1) // sink |
|
{ |
|
if (WebAPIUtils::m_sinkDeviceHwIdToSettingsKey.contains(*deviceHwType)) { |
|
deviceActionsKey = WebAPIUtils::m_sinkDeviceHwIdToActionsKey[*deviceHwType]; |
|
} else { |
|
return false; |
|
} |
|
} |
|
else if (deviceActions.getDirection() == 2) // MIMO |
|
{ |
|
if (WebAPIUtils::m_mimoDeviceHwIdToSettingsKey.contains(*deviceHwType)) { |
|
deviceActionsKey = WebAPIUtils::m_mimoDeviceHwIdToActionsKey[*deviceHwType]; |
|
} else { |
|
return false; |
|
} |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
return getDeviceActions(deviceActionsKey, &deviceActions, jsonObject, deviceActionsKeys); |
|
} |
|
|
|
bool WebAPIRequestMapper::validateChannelSettings( |
|
SWGSDRangel::SWGChannelSettings& channelSettings, |
|
QJsonObject& jsonObject, |
|
QStringList& channelSettingsKeys) |
|
{ |
|
if (jsonObject.contains("direction")) { |
|
channelSettings.setDirection(jsonObject["direction"].toInt()); |
|
} else { |
|
channelSettings.setDirection(0); // assume single Rx |
|
} |
|
|
|
if (jsonObject.contains("channelType") && jsonObject["channelType"].isString()) { |
|
channelSettings.setChannelType(new QString(jsonObject["channelType"].toString())); |
|
} else { |
|
return false; |
|
} |
|
|
|
QString *channelType = channelSettings.getChannelType(); |
|
|
|
if (WebAPIUtils::m_channelTypeToSettingsKey.contains(*channelType)) { |
|
return getChannelSettings(WebAPIUtils::m_channelTypeToSettingsKey[*channelType], &channelSettings, jsonObject, channelSettingsKeys); |
|
} else { |
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::validateChannelActions( |
|
SWGSDRangel::SWGChannelActions& channelActions, |
|
QJsonObject& jsonObject, |
|
QStringList& channelActionsKeys) |
|
{ |
|
if (jsonObject.contains("direction")) { |
|
channelActions.setDirection(jsonObject["direction"].toInt()); |
|
} else { |
|
channelActions.setDirection(0); // assume single Rx |
|
} |
|
|
|
if (jsonObject.contains("channelType") && jsonObject["channelType"].isString()) { |
|
channelActions.setChannelType(new QString(jsonObject["channelType"].toString())); |
|
} else { |
|
return false; |
|
} |
|
|
|
QString *channelType = channelActions.getChannelType(); |
|
|
|
if (WebAPIUtils::m_channelTypeToActionsKey.contains(*channelType)) { |
|
return getChannelActions(WebAPIUtils::m_channelTypeToActionsKey[*channelType], &channelActions, jsonObject, channelActionsKeys); |
|
} else { |
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::validateFeatureSettings( |
|
SWGSDRangel::SWGFeatureSettings& featureSettings, |
|
QJsonObject& jsonObject, |
|
QStringList& featureSettingsKeys) |
|
{ |
|
if (jsonObject.contains("featureType") && jsonObject["featureType"].isString()) { |
|
featureSettings.setFeatureType(new QString(jsonObject["featureType"].toString())); |
|
} else { |
|
return false; |
|
} |
|
|
|
QString *featureType = featureSettings.getFeatureType(); |
|
|
|
if (WebAPIUtils::m_featureTypeToSettingsKey.contains(*featureType)) { |
|
return getFeatureSettings(WebAPIUtils::m_featureTypeToSettingsKey[*featureType], &featureSettings, jsonObject, featureSettingsKeys); |
|
} else { |
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::validateFeatureActions( |
|
SWGSDRangel::SWGFeatureActions& featureActions, |
|
QJsonObject& jsonObject, |
|
QStringList& featureActionsKeys) |
|
{ |
|
if (jsonObject.contains("featureType") && jsonObject["featureType"].isString()) { |
|
featureActions.setFeatureType(new QString(jsonObject["featureType"].toString())); |
|
} else { |
|
return false; |
|
} |
|
|
|
QString *featureType = featureActions.getFeatureType(); |
|
|
|
if (WebAPIUtils::m_featureTypeToActionsKey.contains(*featureType)) { |
|
return getFeatureActions(WebAPIUtils::m_featureTypeToActionsKey[*featureType], &featureActions, jsonObject, featureActionsKeys); |
|
} else { |
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::validateAudioInputDevice( |
|
SWGSDRangel::SWGAudioInputDevice& audioInputDevice, |
|
QJsonObject& jsonObject, |
|
QStringList& audioInputDeviceKeys) |
|
{ |
|
if (jsonObject.contains("index")) { |
|
audioInputDevice.setIndex(jsonObject["index"].toInt()); |
|
} else { |
|
audioInputDevice.setIndex(-1); // assume systam default |
|
} |
|
if (jsonObject.contains("sampleRate")) |
|
{ |
|
audioInputDevice.setSampleRate(jsonObject["sampleRate"].toInt()); |
|
audioInputDeviceKeys.append("sampleRate"); |
|
} |
|
if (jsonObject.contains("volume")) |
|
{ |
|
audioInputDevice.setVolume(jsonObject["volume"].toDouble()); |
|
audioInputDeviceKeys.append("volume"); |
|
} |
|
return true; |
|
} |
|
|
|
bool WebAPIRequestMapper::validateAudioOutputDevice( |
|
SWGSDRangel::SWGAudioOutputDevice& audioOutputDevice, |
|
QJsonObject& jsonObject, |
|
QStringList& audioOutputDeviceKeys) |
|
{ |
|
if (jsonObject.contains("index")) { |
|
audioOutputDevice.setIndex(jsonObject["index"].toInt()); |
|
} else { |
|
audioOutputDevice.setIndex(-1); // assume systam default |
|
} |
|
if (jsonObject.contains("sampleRate")) |
|
{ |
|
audioOutputDevice.setSampleRate(jsonObject["sampleRate"].toInt()); |
|
audioOutputDeviceKeys.append("sampleRate"); |
|
} |
|
if (jsonObject.contains("copyToUDP")) |
|
{ |
|
audioOutputDevice.setCopyToUdp(jsonObject["copyToUDP"].toInt() == 0 ? 0 : 1); |
|
audioOutputDeviceKeys.append("copyToUDP"); |
|
} |
|
if (jsonObject.contains("udpUsesRTP")) |
|
{ |
|
audioOutputDevice.setUdpUsesRtp(jsonObject["udpUsesRTP"].toInt() == 0 ? 0 : 1); |
|
audioOutputDeviceKeys.append("udpUsesRTP"); |
|
} |
|
if (jsonObject.contains("udpChannelMode")) |
|
{ |
|
audioOutputDevice.setUdpChannelMode(jsonObject["udpChannelMode"].toInt()); |
|
audioOutputDeviceKeys.append("udpChannelMode"); |
|
} |
|
if (jsonObject.contains("udpChannelCodec")) |
|
{ |
|
audioOutputDevice.setUdpChannelCodec(jsonObject["udpChannelCodec"].toInt()); |
|
audioOutputDeviceKeys.append("udpChannelCodec"); |
|
} |
|
if (jsonObject.contains("udpDecimationFactor")) |
|
{ |
|
audioOutputDevice.setUdpDecimationFactor(jsonObject["udpDecimationFactor"].toInt()); |
|
audioOutputDeviceKeys.append("udpDecimationFactor"); |
|
} |
|
if (jsonObject.contains("udpAddress")) |
|
{ |
|
audioOutputDevice.setUdpAddress(new QString(jsonObject["udpAddress"].toString())); |
|
audioOutputDeviceKeys.append("udpAddress"); |
|
} |
|
if (jsonObject.contains("udpPort")) |
|
{ |
|
audioOutputDevice.setUdpPort(jsonObject["udpPort"].toInt()); |
|
audioOutputDeviceKeys.append("udpPort"); |
|
} |
|
if (jsonObject.contains("fileRecordName")) |
|
{ |
|
audioOutputDevice.setFileRecordName(new QString(jsonObject["fileRecordName"].toString())); |
|
audioOutputDeviceKeys.append("fileRecordName"); |
|
} |
|
if (jsonObject.contains("recordToFile")) |
|
{ |
|
audioOutputDevice.setRecordToFile(jsonObject["recordToFile"].toInt() == 0 ? 0 : 1); |
|
audioOutputDeviceKeys.append("recordToFile"); |
|
} |
|
if (jsonObject.contains("recordSilenceTime")) |
|
{ |
|
audioOutputDevice.setRecordSilenceTime(jsonObject["recordSilenceTime"].toInt()); |
|
audioOutputDeviceKeys.append("recordSilenceTime"); |
|
} |
|
return true; |
|
} |
|
|
|
bool WebAPIRequestMapper::validateSpectrumSettings(SWGSDRangel::SWGGLSpectrum& spectrumSettings, QJsonObject& jsonObject, QStringList& spectrumSettingsKeys) |
|
{ |
|
extractKeys(jsonObject, spectrumSettingsKeys); |
|
spectrumSettings.init(); |
|
spectrumSettings.fromJsonObject(jsonObject); |
|
// if (jsonObject.contains("fftSize")) |
|
// { |
|
// spectrumSettings.setFftSize(jsonObject["fftSize"].toInt(1024)); |
|
// spectrumSettingsKeys.append("fftSize"); |
|
// } |
|
// if (jsonObject.contains("fftOverlap")) |
|
// { |
|
// spectrumSettings.setFftOverlap(jsonObject["fftOverlap"].toInt(0)); |
|
// spectrumSettingsKeys.append("fftOverlap"); |
|
// } |
|
// if (jsonObject.contains("fftWindow")) |
|
// { |
|
// spectrumSettings.setFftWindow(jsonObject["fftWindow"].toInt(0)); |
|
// spectrumSettingsKeys.append("fftWindow"); |
|
// } |
|
// if (jsonObject.contains("refLevel")) |
|
// { |
|
// spectrumSettings.setRefLevel(jsonObject["refLevel"].toDouble(0.0)); |
|
// spectrumSettingsKeys.append("refLevel"); |
|
// } |
|
// if (jsonObject.contains("powerRange")) |
|
// { |
|
// spectrumSettings.setPowerRange(jsonObject["powerRange"].toDouble(100.0)); |
|
// spectrumSettingsKeys.append("powerRange"); |
|
// } |
|
// if (jsonObject.contains("fpsPeriodMs")) |
|
// { |
|
// spectrumSettings.setFpsPeriodMs(jsonObject["fpsPeriodMs"].toInt(50)); |
|
// spectrumSettingsKeys.append("fpsPeriodMs"); |
|
// } |
|
// if (jsonObject.contains("displayWaterfall")) |
|
// { |
|
// spectrumSettings.setDisplayWaterfall(jsonObject["displayWaterfall"].toInt(0)); |
|
// spectrumSettingsKeys.append("displayWaterfall"); |
|
// } |
|
// if (jsonObject.contains("invertedWaterfall")) |
|
// { |
|
// spectrumSettings.setInvertedWaterfall(jsonObject["invertedWaterfall"].toInt(0)); |
|
// spectrumSettingsKeys.append("invertedWaterfall"); |
|
// } |
|
// if (jsonObject.contains("displayHistogram")) |
|
// { |
|
// spectrumSettings.setDisplayHistogram(jsonObject["displayHistogram"].toInt(0)); |
|
// spectrumSettingsKeys.append("displayHistogram"); |
|
// } |
|
// if (jsonObject.contains("decay")) |
|
// { |
|
// spectrumSettings.setDecay(jsonObject["decay"].toInt(1)); |
|
// spectrumSettingsKeys.append("decay"); |
|
// } |
|
// if (jsonObject.contains("displayGrid")) |
|
// { |
|
// spectrumSettings.setDisplayGrid(jsonObject["displayGrid"].toInt(0)); |
|
// spectrumSettingsKeys.append("displayGrid"); |
|
// } |
|
// if (jsonObject.contains("displayGridIntensity")) |
|
// { |
|
// spectrumSettings.setDisplayGridIntensity(jsonObject["displayGridIntensity"].toInt(30)); |
|
// spectrumSettingsKeys.append("displayGridIntensity"); |
|
// } |
|
// if (jsonObject.contains("decayDivisor")) |
|
// { |
|
// spectrumSettings.setDecayDivisor(jsonObject["decayDivisor"].toInt(1)); |
|
// spectrumSettingsKeys.append("decayDivisor"); |
|
// } |
|
// if (jsonObject.contains("histogramStroke")) |
|
// { |
|
// spectrumSettings.setHistogramStroke(jsonObject["histogramStroke"].toInt(10)); |
|
// spectrumSettingsKeys.append("histogramStroke"); |
|
// } |
|
// if (jsonObject.contains("displayCurrent")) |
|
// { |
|
// spectrumSettings.setDisplayCurrent(jsonObject["displayCurrent"].toInt(1)); |
|
// spectrumSettingsKeys.append("displayCurrent"); |
|
// } |
|
// if (jsonObject.contains("displayTraceIntensity")) |
|
// { |
|
// spectrumSettings.setDisplayTraceIntensity(jsonObject["displayTraceIntensity"].toInt(50)); |
|
// spectrumSettingsKeys.append("displayTraceIntensity"); |
|
// } |
|
// if (jsonObject.contains("waterfallShare")) |
|
// { |
|
// spectrumSettings.setWaterfallShare(jsonObject["waterfallShare"].toDouble(0.5)); |
|
// spectrumSettingsKeys.append("waterfallShare"); |
|
// } |
|
// if (jsonObject.contains("averagingMode")) |
|
// { |
|
// spectrumSettings.setAveragingMode(jsonObject["averagingMode"].toInt(0)); |
|
// spectrumSettingsKeys.append("averagingMode"); |
|
// } |
|
// if (jsonObject.contains("averagingValue")) |
|
// { |
|
// spectrumSettings.setAveragingValue(jsonObject["averagingValue"].toInt(0)); |
|
// spectrumSettingsKeys.append("averagingValue"); |
|
// } |
|
// if (jsonObject.contains("linear")) |
|
// { |
|
// spectrumSettings.setLinear(jsonObject["linear"].toInt(0)); |
|
// spectrumSettingsKeys.append("linear"); |
|
// } |
|
// if (jsonObject.contains("ssb")) |
|
// { |
|
// spectrumSettings.setSsb(jsonObject["ssb"].toInt(0)); |
|
// spectrumSettingsKeys.append("ssb"); |
|
// } |
|
// if (jsonObject.contains("usb")) |
|
// { |
|
// spectrumSettings.setUsb(jsonObject["usb"].toInt(1)); |
|
// spectrumSettingsKeys.append("usb"); |
|
// } |
|
// if (jsonObject.contains("wsSpectrumAddress") && jsonObject["wsSpectrumAddress"].isString()) |
|
// { |
|
// spectrumSettings.setWsSpectrumAddress(new QString(jsonObject["wsSpectrumAddress"].toString())); |
|
// spectrumSettingsKeys.append("wsSpectrumAddress"); |
|
// } |
|
// if (jsonObject.contains("wsSpectrumPort")) |
|
// { |
|
// spectrumSettings.setWsSpectrumPort(jsonObject["wsSpectrumPort"].toInt(8887)); |
|
// spectrumSettingsKeys.append("wsSpectrumPort"); |
|
// } |
|
|
|
return true; |
|
} |
|
|
|
// The arrangement is an enumeration, and one outside it is refused here rather than passed on |
|
bool WebAPIRequestMapper::validateWorkspaceActions(SWGSDRangel::SWGWorkspaceActions& workspaceActions, QJsonObject& jsonObject) |
|
{ |
|
if (!jsonObject.contains("arrange") || !jsonObject["arrange"].isString()) { |
|
return false; |
|
} |
|
|
|
static const QStringList arrangements = {"cascade", "tile", "stackVertical", "stack", "autostack", "tab"}; |
|
QString arrange = jsonObject["arrange"].toString(); |
|
|
|
if (!arrangements.contains(arrange)) { |
|
return false; |
|
} |
|
|
|
workspaceActions.setArrange(new QString(arrange)); |
|
return true; |
|
} |
|
|
|
bool WebAPIRequestMapper::validateWorkspaceInfo(SWGSDRangel::SWGWorkspaceInfo& workspaceInfo, QJsonObject& jsonObject) |
|
{ |
|
// Either field on its own is a request: index moves the window, hidden shows or hides it. |
|
// What is absent is passed on as -1, since the object carries no other sign of absence |
|
// that the adapter can read |
|
const bool hasIndex = jsonObject.contains("index") && jsonObject["index"].isDouble(); |
|
const bool hasHidden = jsonObject.contains("hidden") && jsonObject["hidden"].isDouble(); |
|
|
|
if (!hasIndex && !hasHidden) { |
|
return false; |
|
} |
|
|
|
workspaceInfo.setIndex(hasIndex ? jsonObject["index"].toInt() : -1); |
|
workspaceInfo.setHidden(hasHidden ? (jsonObject["hidden"].toInt() != 0 ? 1 : 0) : -1); |
|
return true; |
|
} |
|
|
|
bool WebAPIRequestMapper::validateConfig( |
|
SWGSDRangel::SWGInstanceConfigResponse& config, |
|
QJsonObject& jsonObject, |
|
WebAPIAdapterInterface::ConfigKeys& configKeys) |
|
{ |
|
if (jsonObject.contains("preferences")) |
|
{ |
|
SWGSDRangel::SWGPreferences *preferences = new SWGSDRangel::SWGPreferences(); |
|
config.setPreferences(preferences); |
|
QJsonObject preferencesJson = jsonObject["preferences"].toObject(); |
|
configKeys.m_preferencesKeys = preferencesJson.keys(); |
|
preferences->fromJsonObject(preferencesJson); |
|
} |
|
|
|
if (jsonObject.contains("commands")) |
|
{ |
|
QList<SWGSDRangel::SWGCommand *> *commands = new QList<SWGSDRangel::SWGCommand *>(); |
|
config.setCommands(commands); |
|
QJsonArray commandsJson = jsonObject["commands"].toArray(); |
|
QJsonArray::const_iterator commandsIt = commandsJson.begin(); |
|
|
|
for (; commandsIt != commandsJson.end(); ++commandsIt) |
|
{ |
|
QJsonObject commandJson = commandsIt->toObject(); |
|
commands->append(new SWGSDRangel::SWGCommand()); |
|
configKeys.m_commandKeys.append(WebAPIAdapterInterface::CommandKeys()); |
|
configKeys.m_commandKeys.back().m_keys = commandJson.keys(); |
|
commands->back()->fromJsonObject(commandJson); |
|
} |
|
} |
|
|
|
if (jsonObject.contains("presets")) |
|
{ |
|
QList<SWGSDRangel::SWGPreset *> *presets = new QList<SWGSDRangel::SWGPreset *>(); |
|
config.setPresets(presets); |
|
QJsonArray presetsJson = jsonObject["presets"].toArray(); |
|
QJsonArray::const_iterator presetsIt = presetsJson.begin(); |
|
|
|
for (; presetsIt != presetsJson.end(); ++presetsIt) |
|
{ |
|
QJsonObject presetJson = presetsIt->toObject(); |
|
SWGSDRangel::SWGPreset *preset = new SWGSDRangel::SWGPreset(); |
|
presets->append(preset); |
|
configKeys.m_presetKeys.append(WebAPIAdapterInterface::PresetKeys()); |
|
appendPresetKeys(preset, presetJson, configKeys.m_presetKeys.back()); |
|
} |
|
} |
|
|
|
if (jsonObject.contains("featuresetpresets")) |
|
{ |
|
QList<SWGSDRangel::SWGFeatureSetPreset *> *featureSetPresets = new QList<SWGSDRangel::SWGFeatureSetPreset *>(); |
|
config.setFeaturesetpresets(featureSetPresets); |
|
QJsonArray presetsJson = jsonObject["featuresetpresets"].toArray(); |
|
QJsonArray::const_iterator featureSetPresetsIt = presetsJson.begin(); |
|
|
|
for (; featureSetPresetsIt != presetsJson.end(); ++featureSetPresetsIt) |
|
{ |
|
QJsonObject presetJson = featureSetPresetsIt->toObject(); |
|
SWGSDRangel::SWGFeatureSetPreset *featureSetPreset = new SWGSDRangel::SWGFeatureSetPreset(); |
|
featureSetPresets->append(featureSetPreset); |
|
configKeys.m_featureSetPresetKeys.append(WebAPIAdapterInterface::FeatureSetPresetKeys()); |
|
appendFeatureSetPresetKeys(featureSetPreset, presetJson, configKeys.m_featureSetPresetKeys.back()); |
|
} |
|
} |
|
|
|
if (jsonObject.contains("workingPreset")) |
|
{ |
|
SWGSDRangel::SWGPreset *preset = new SWGSDRangel::SWGPreset(); |
|
config.setWorkingPreset(preset); |
|
QJsonObject presetJson = jsonObject["workingPreset"].toObject(); |
|
appendPresetKeys(preset, presetJson, configKeys.m_workingPresetKeys); |
|
} |
|
|
|
if (jsonObject.contains("workingFeatureSetPreset")) |
|
{ |
|
SWGSDRangel::SWGFeatureSetPreset *preset = new SWGSDRangel::SWGFeatureSetPreset(); |
|
config.setWorkingFeatureSetPreset(preset); |
|
QJsonObject presetJson = jsonObject["workingFeatureSetPreset"].toObject(); |
|
appendFeatureSetPresetKeys(preset, presetJson, configKeys.m_workingFeatureSetPresetKeys); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
bool WebAPIRequestMapper::appendFeatureSetPresetKeys( |
|
SWGSDRangel::SWGFeatureSetPreset *preset, |
|
const QJsonObject& presetJson, |
|
WebAPIAdapterInterface::FeatureSetPresetKeys& featureSetPresetKeys |
|
) |
|
{ |
|
if (presetJson.contains("description")) |
|
{ |
|
preset->setDescription(new QString(presetJson["description"].toString())); |
|
featureSetPresetKeys.m_keys.append("description"); |
|
} |
|
if (presetJson.contains("group")) |
|
{ |
|
preset->setGroup(new QString(presetJson["group"].toString())); |
|
featureSetPresetKeys.m_keys.append("group"); |
|
} |
|
if (presetJson.contains("featureConfigs")) |
|
{ |
|
QJsonArray featuresJson = presetJson["featureConfigs"].toArray(); |
|
QJsonArray::const_iterator featuresIt = featuresJson.begin(); |
|
QList<SWGSDRangel::SWGFeatureConfig*> *features = new QList<SWGSDRangel::SWGFeatureConfig*>(); |
|
preset->setFeatureConfigs(features); |
|
|
|
for (; featuresIt != featuresJson.end(); ++featuresIt) |
|
{ |
|
QJsonObject featureJson = featuresIt->toObject(); |
|
SWGSDRangel::SWGFeatureConfig *featureConfig = new SWGSDRangel::SWGFeatureConfig(); |
|
featureSetPresetKeys.m_featureKeys.append(WebAPIAdapterInterface::FeatureKeys()); |
|
|
|
if (appendPresetFeatureKeys(featureConfig, featureJson, featureSetPresetKeys.m_featureKeys.back())) |
|
{ |
|
features->append(featureConfig); |
|
} |
|
else |
|
{ |
|
delete featureConfig; |
|
featureSetPresetKeys.m_featureKeys.takeLast(); // remove channel keys |
|
} |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
bool WebAPIRequestMapper::appendPresetKeys( |
|
SWGSDRangel::SWGPreset *preset, |
|
const QJsonObject& presetJson, |
|
WebAPIAdapterInterface::PresetKeys& presetKeys |
|
) |
|
{ |
|
if (presetJson.contains("centerFrequency")) |
|
{ |
|
preset->setCenterFrequency(presetJson["centerFrequency"].toInt()); |
|
presetKeys.m_keys.append("centerFrequency"); |
|
} |
|
if (presetJson.contains("dcOffsetCorrection")) |
|
{ |
|
preset->setDcOffsetCorrection(presetJson["dcOffsetCorrection"].toInt()); |
|
presetKeys.m_keys.append("dcOffsetCorrection"); |
|
} |
|
if (presetJson.contains("iqImbalanceCorrection")) |
|
{ |
|
preset->setIqImbalanceCorrection(presetJson["iqImbalanceCorrection"].toInt()); |
|
presetKeys.m_keys.append("iqImbalanceCorrection"); |
|
} |
|
if (presetJson.contains("iqImbalanceCorrection")) |
|
{ |
|
preset->setPresetType(presetJson["presetType"].toInt()); |
|
presetKeys.m_keys.append("presetType"); |
|
} |
|
if (presetJson.contains("description")) |
|
{ |
|
preset->setDescription(new QString(presetJson["description"].toString())); |
|
presetKeys.m_keys.append("description"); |
|
} |
|
if (presetJson.contains("group")) |
|
{ |
|
preset->setGroup(new QString(presetJson["group"].toString())); |
|
presetKeys.m_keys.append("group"); |
|
} |
|
if (presetJson.contains("layout")) |
|
{ |
|
preset->setLayout(new QString(presetJson["layout"].toString())); |
|
presetKeys.m_keys.append("layout"); |
|
} |
|
|
|
if (presetJson.contains("spectrumConfig")) |
|
{ |
|
QJsonObject spectrumJson = presetJson["spectrumConfig"].toObject(); |
|
presetKeys.m_spectrumKeys = spectrumJson.keys(); |
|
SWGSDRangel::SWGGLSpectrum *spectrum = new SWGSDRangel::SWGGLSpectrum(); |
|
preset->setSpectrumConfig(spectrum); |
|
spectrum->fromJsonObject(spectrumJson); |
|
} |
|
|
|
if (presetJson.contains("channelConfigs")) |
|
{ |
|
QJsonArray channelsJson = presetJson["channelConfigs"].toArray(); |
|
QJsonArray::const_iterator channelsIt = channelsJson.begin(); |
|
QList<SWGSDRangel::SWGChannelConfig*> *channels = new QList<SWGSDRangel::SWGChannelConfig*>(); |
|
preset->setChannelConfigs(channels); |
|
|
|
for (; channelsIt != channelsJson.end(); ++channelsIt) |
|
{ |
|
QJsonObject channelJson = channelsIt->toObject(); |
|
SWGSDRangel::SWGChannelConfig *channelConfig = new SWGSDRangel::SWGChannelConfig(); |
|
presetKeys.m_channelsKeys.append(WebAPIAdapterInterface::ChannelKeys()); |
|
|
|
if (appendPresetChannelKeys(channelConfig, channelJson, presetKeys.m_channelsKeys.back())) |
|
{ |
|
channels->append(channelConfig); |
|
} |
|
else |
|
{ |
|
delete channelConfig; |
|
presetKeys.m_channelsKeys.takeLast(); // remove channel keys |
|
} |
|
} |
|
} |
|
|
|
if (presetJson.contains("deviceConfigs")) |
|
{ |
|
QJsonArray devicesJson = presetJson["deviceConfigs"].toArray(); |
|
QJsonArray::const_iterator devicesIt = devicesJson.begin(); |
|
QList<SWGSDRangel::SWGDeviceConfig*> *devices = new QList<SWGSDRangel::SWGDeviceConfig*>(); |
|
preset->setDeviceConfigs(devices); |
|
|
|
for (; devicesIt != devicesJson.end(); ++devicesIt) |
|
{ |
|
QJsonObject deviceJson = devicesIt->toObject(); |
|
SWGSDRangel::SWGDeviceConfig *deviceConfig = new SWGSDRangel::SWGDeviceConfig(); |
|
presetKeys.m_devicesKeys.append(WebAPIAdapterInterface::DeviceKeys()); |
|
|
|
if (appendPresetDeviceKeys(deviceConfig, deviceJson, presetKeys.m_devicesKeys.back())) |
|
{ |
|
devices->append(deviceConfig); |
|
} |
|
else |
|
{ |
|
delete deviceConfig; |
|
presetKeys.m_devicesKeys.takeLast(); // remove device keys |
|
} |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
bool WebAPIRequestMapper::appendPresetFeatureKeys( |
|
SWGSDRangel::SWGFeatureConfig *feature, |
|
const QJsonObject& featureSettingsJson, |
|
WebAPIAdapterInterface::FeatureKeys& featureKeys |
|
) |
|
{ |
|
if (featureSettingsJson.contains("featureIdURI")) |
|
{ |
|
QString *featureURI = new QString(featureSettingsJson["featureIdURI"].toString()); |
|
feature->setFeatureIdUri(featureURI); |
|
featureKeys.m_keys.append("featureIdURI"); |
|
|
|
if (featureSettingsJson.contains("config") && WebAPIUtils::m_featureURIToSettingsKey.contains(*featureURI)) |
|
{ |
|
SWGSDRangel::SWGFeatureSettings *featureSettings = new SWGSDRangel::SWGFeatureSettings(); |
|
feature->setConfig(featureSettings); |
|
return getFeatureSettings( |
|
WebAPIUtils::m_channelURIToSettingsKey[*featureURI], |
|
featureSettings, |
|
featureSettingsJson["config"].toObject(), |
|
featureKeys.m_featureKeys |
|
); |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::appendPresetChannelKeys( |
|
SWGSDRangel::SWGChannelConfig *channel, |
|
const QJsonObject& channelSettingsJson, |
|
WebAPIAdapterInterface::ChannelKeys& channelKeys |
|
) |
|
{ |
|
if (channelSettingsJson.contains("channelIdURI")) |
|
{ |
|
QString *channelURI = new QString(channelSettingsJson["channelIdURI"].toString()); |
|
channel->setChannelIdUri(channelURI); |
|
channelKeys.m_keys.append("channelIdURI"); |
|
|
|
if (channelSettingsJson.contains("config") && WebAPIUtils::m_channelURIToSettingsKey.contains(*channelURI)) |
|
{ |
|
SWGSDRangel::SWGChannelSettings *channelSettings = new SWGSDRangel::SWGChannelSettings(); |
|
channel->setConfig(channelSettings); |
|
return getChannelSettings(WebAPIUtils::m_channelURIToSettingsKey[*channelURI], channelSettings, channelSettingsJson["config"].toObject(), channelKeys.m_channelKeys); |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::getChannelSettings( |
|
const QString& channelSettingsKey, |
|
SWGSDRangel::SWGChannelSettings *channelSettings, |
|
const QJsonObject& channelSettingsJson, |
|
QStringList& channelSettingsKeys |
|
) |
|
{ |
|
QStringList channelKeys = channelSettingsJson.keys(); |
|
|
|
if (channelKeys.contains(channelSettingsKey) && channelSettingsJson[channelSettingsKey].isObject()) |
|
{ |
|
QJsonObject settingsJsonObject = channelSettingsJson[channelSettingsKey].toObject(); |
|
extractKeys(settingsJsonObject, channelSettingsKeys); |
|
qDebug() << "WebAPIRequestMapper::getChannelSettings:" |
|
<< " channelSettingsKey: " << channelSettingsKey |
|
<< " channelSettingsKeys: " << channelSettingsKeys; |
|
|
|
if (channelSettingsKey == "ACARSDemodSettings") |
|
{ |
|
channelSettings->setAcarsDemodSettings(new SWGSDRangel::SWGACARSDemodSettings()); |
|
channelSettings->getAcarsDemodSettings()->init(); |
|
channelSettings->getAcarsDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "ADSBDemodSettings") |
|
{ |
|
channelSettings->setAdsbDemodSettings(new SWGSDRangel::SWGADSBDemodSettings()); |
|
channelSettings->getAdsbDemodSettings()->init(); |
|
channelSettings->getAdsbDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "AISDemodSettings") |
|
{ |
|
channelSettings->setAisDemodSettings(new SWGSDRangel::SWGAISDemodSettings()); |
|
channelSettings->getAisDemodSettings()->init(); |
|
channelSettings->getAisDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "AISModSettings") |
|
{ |
|
channelSettings->setAisModSettings(new SWGSDRangel::SWGAISModSettings()); |
|
channelSettings->getAisModSettings()->init(); |
|
channelSettings->getAisModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "AMDemodSettings") |
|
{ |
|
channelSettings->setAmDemodSettings(new SWGSDRangel::SWGAMDemodSettings()); |
|
channelSettings->getAmDemodSettings()->init(); |
|
channelSettings->getAmDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "AMModSettings") |
|
{ |
|
channelSettings->setAmModSettings(new SWGSDRangel::SWGAMModSettings()); |
|
channelSettings->getAmModSettings()->init(); |
|
channelSettings->getAmModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "APTDemodSettings") |
|
{ |
|
channelSettings->setAptDemodSettings(new SWGSDRangel::SWGAPTDemodSettings()); |
|
channelSettings->getAptDemodSettings()->init(); |
|
channelSettings->getAptDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "WefaxDemodSettings") |
|
{ |
|
channelSettings->setWefaxDemodSettings(new SWGSDRangel::SWGWefaxDemodSettings()); |
|
channelSettings->getWefaxDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "ATVDemodSettings") |
|
{ |
|
channelSettings->setAtvDemodSettings(new SWGSDRangel::SWGATVDemodSettings()); |
|
channelSettings->getAtvDemodSettings()->init(); |
|
channelSettings->getAtvDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "ATVModSettings") |
|
{ |
|
channelSettings->setAtvModSettings(new SWGSDRangel::SWGATVModSettings()); |
|
channelSettings->getAtvModSettings()->init(); |
|
channelSettings->getAtvModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "BeamSteeringCWModSettings") |
|
{ |
|
channelSettings->setBeamSteeringCwModSettings(new SWGSDRangel::SWGBeamSteeringCWModSettings()); |
|
channelSettings->getBeamSteeringCwModSettings()->init(); |
|
channelSettings->getBeamSteeringCwModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "BFMDemodSettings") |
|
{ |
|
channelSettings->setBfmDemodSettings(new SWGSDRangel::SWGBFMDemodSettings()); |
|
channelSettings->getBfmDemodSettings()->init(); |
|
channelSettings->getBfmDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "BFMModSettings") |
|
{ |
|
channelSettings->setBfmModSettings(new SWGSDRangel::SWGBFMModSettings()); |
|
channelSettings->getBfmModSettings()->init(); |
|
channelSettings->getBfmModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "ChannelAnalyzerSettings") |
|
{ |
|
channelSettings->setChannelAnalyzerSettings(new SWGSDRangel::SWGChannelAnalyzerSettings()); |
|
channelSettings->getChannelAnalyzerSettings()->init(); |
|
channelSettings->getChannelAnalyzerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "ChannelPowerSettings") |
|
{ |
|
channelSettings->setChannelPowerSettings(new SWGSDRangel::SWGChannelPowerSettings()); |
|
channelSettings->getChannelPowerSettings()->init(); |
|
channelSettings->getChannelPowerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "ChirpChatDemodSettings") |
|
{ |
|
channelSettings->setChirpChatDemodSettings(new SWGSDRangel::SWGChirpChatDemodSettings()); |
|
channelSettings->getChirpChatDemodSettings()->init(); |
|
channelSettings->getChirpChatDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "ChirpChatModSettings") |
|
{ |
|
channelSettings->setChirpChatModSettings(new SWGSDRangel::SWGChirpChatModSettings()); |
|
channelSettings->getChirpChatModSettings()->init(); // contains a list of strings |
|
channelSettings->getChirpChatModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "DATVDemodSettings") |
|
{ |
|
channelSettings->setDatvDemodSettings(new SWGSDRangel::SWGDATVDemodSettings()); |
|
channelSettings->getDatvDemodSettings()->init(); |
|
channelSettings->getDatvDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "DVBDemodSettings") |
|
{ |
|
channelSettings->setDvbDemodSettings(new SWGSDRangel::SWGDVBDemodSettings()); |
|
channelSettings->getDvbDemodSettings()->init(); |
|
channelSettings->getDvbDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "DATVModSettings") |
|
{ |
|
channelSettings->setDatvModSettings(new SWGSDRangel::SWGDATVModSettings()); |
|
channelSettings->getDatvModSettings()->init(); |
|
channelSettings->getDatvModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "DABDemodSettings") |
|
{ |
|
channelSettings->setDabDemodSettings(new SWGSDRangel::SWGDABDemodSettings()); |
|
channelSettings->getDabDemodSettings()->init(); |
|
channelSettings->getDabDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "DRMDemodSettings") |
|
{ |
|
channelSettings->setDrmDemodSettings(new SWGSDRangel::SWGDRMDemodSettings()); |
|
channelSettings->getDrmDemodSettings()->init(); |
|
channelSettings->getDrmDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "DOA2Settings") |
|
{ |
|
channelSettings->setDoa2Settings(new SWGSDRangel::SWGDOA2Settings()); |
|
channelSettings->getDoa2Settings()->init(); |
|
channelSettings->getDoa2Settings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "DSCDemodSettings") |
|
{ |
|
channelSettings->setDscDemodSettings(new SWGSDRangel::SWGDSCDemodSettings()); |
|
channelSettings->getDscDemodSettings()->init(); |
|
channelSettings->getDscDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "SELCALDemodSettings") |
|
{ |
|
channelSettings->setSelcalDemodSettings(new SWGSDRangel::SWGSELCALDemodSettings()); |
|
channelSettings->getSelcalDemodSettings()->init(); |
|
channelSettings->getSelcalDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "DSDDemodSettings") |
|
{ |
|
channelSettings->setDsdDemodSettings(new SWGSDRangel::SWGDSDDemodSettings()); |
|
channelSettings->getDsdDemodSettings()->init(); |
|
channelSettings->getDsdDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "DroneIDDemodSettings") |
|
{ |
|
channelSettings->setDroneIdDemodSettings(new SWGSDRangel::SWGDroneIDDemodSettings()); |
|
channelSettings->getDroneIdDemodSettings()->init(); |
|
channelSettings->getDroneIdDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "EndOfTrainDemodSettings") |
|
{ |
|
channelSettings->setEndOfTrainDemodSettings(new SWGSDRangel::SWGEndOfTrainDemodSettings()); |
|
channelSettings->getEndOfTrainDemodSettings()->init(); |
|
channelSettings->getEndOfTrainDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "FileSinkSettings") |
|
{ |
|
channelSettings->setFileSinkSettings(new SWGSDRangel::SWGFileSinkSettings()); |
|
channelSettings->getFileSinkSettings()->init(); |
|
channelSettings->getFileSinkSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "FileSourceSettings") |
|
{ |
|
channelSettings->setFileSourceSettings(new SWGSDRangel::SWGFileSourceSettings()); |
|
channelSettings->getFileSourceSettings()->init(); |
|
channelSettings->getFileSourceSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "FreeDVDemodSettings") |
|
{ |
|
channelSettings->setFreeDvDemodSettings(new SWGSDRangel::SWGFreeDVDemodSettings()); |
|
channelSettings->getFreeDvDemodSettings()->init(); |
|
channelSettings->getFreeDvDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "FreeDVModSettings") |
|
{ |
|
channelSettings->setFreeDvModSettings(new SWGSDRangel::SWGFreeDVModSettings()); |
|
channelSettings->getFreeDvModSettings()->init(); |
|
channelSettings->getFreeDvModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "FreqScannerSettings") |
|
{ |
|
channelSettings->setFreqScannerSettings(new SWGSDRangel::SWGFreqScannerSettings()); |
|
channelSettings->getFreqScannerSettings()->init(); |
|
channelSettings->getFreqScannerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "FreqTrackerSettings") |
|
{ |
|
channelSettings->setFreqTrackerSettings(new SWGSDRangel::SWGFreqTrackerSettings()); |
|
channelSettings->getFreqTrackerSettings()->init(); |
|
channelSettings->getFreqTrackerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "FT8DemodSettings") |
|
{ |
|
channelSettings->setFt8DemodSettings(new SWGSDRangel::SWGFT8DemodSettings()); |
|
channelSettings->getFt8DemodSettings()->init(); |
|
channelSettings->getFt8DemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "HeatMapSettings") |
|
{ |
|
channelSettings->setHeatMapSettings(new SWGSDRangel::SWGHeatMapSettings()); |
|
channelSettings->getHeatMapSettings()->init(); |
|
channelSettings->getHeatMapSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "IEEE_802_15_4_DemodSettings") |
|
{ |
|
channelSettings->setIeee802154DemodSettings(new SWGSDRangel::SWGIEEE_802_15_4_DemodSettings()); |
|
channelSettings->getIeee802154DemodSettings()->init(); |
|
channelSettings->getIeee802154DemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "IEEE_802_15_4_ModSettings") |
|
{ |
|
channelSettings->setIeee802154ModSettings(new SWGSDRangel::SWGIEEE_802_15_4_ModSettings()); |
|
channelSettings->getIeee802154ModSettings()->init(); |
|
channelSettings->getIeee802154ModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "ILSDemodSettings") |
|
{ |
|
channelSettings->setIlsDemodSettings(new SWGSDRangel::SWGILSDemodSettings()); |
|
channelSettings->getIlsDemodSettings()->init(); |
|
channelSettings->getIlsDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "InmarsatDemodSettings") |
|
{ |
|
channelSettings->setInmarsatDemodSettings(new SWGSDRangel::SWGInmarsatDemodSettings()); |
|
channelSettings->getInmarsatDemodSettings()->init(); |
|
channelSettings->getInmarsatDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "InterferometerSettings") |
|
{ |
|
channelSettings->setInterferometerSettings(new SWGSDRangel::SWGInterferometerSettings()); |
|
channelSettings->getInterferometerSettings()->init(); |
|
channelSettings->getInterferometerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "NavtexDemodSettings") |
|
{ |
|
channelSettings->setNavtexDemodSettings(new SWGSDRangel::SWGNavtexDemodSettings()); |
|
channelSettings->getNavtexDemodSettings()->init(); |
|
channelSettings->getNavtexDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "M17DemodSettings") |
|
{ |
|
channelSettings->setM17DemodSettings(new SWGSDRangel::SWGM17DemodSettings()); |
|
channelSettings->getM17DemodSettings()->init(); |
|
channelSettings->getM17DemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "M17ModSettings") |
|
{ |
|
channelSettings->setM17ModSettings(new SWGSDRangel::SWGM17ModSettings()); |
|
channelSettings->getM17ModSettings()->init(); |
|
channelSettings->getM17ModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "MeshtasticDemodSettings") |
|
{ |
|
channelSettings->setMeshtasticDemodSettings(new SWGSDRangel::SWGMeshtasticDemodSettings()); |
|
channelSettings->getMeshtasticDemodSettings()->init(); |
|
channelSettings->getMeshtasticDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "MeshtasticModSettings") |
|
{ |
|
channelSettings->setMeshtasticModSettings(new SWGSDRangel::SWGMeshtasticModSettings()); |
|
channelSettings->getMeshtasticModSettings()->init(); |
|
channelSettings->getMeshtasticModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "NFMDemodSettings") |
|
{ |
|
channelSettings->setNfmDemodSettings(new SWGSDRangel::SWGNFMDemodSettings()); |
|
channelSettings->getNfmDemodSettings()->init(); |
|
channelSettings->getNfmDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "NFMModSettings") |
|
{ |
|
channelSettings->setNfmModSettings(new SWGSDRangel::SWGNFMModSettings()); |
|
channelSettings->getNfmModSettings()->init(); |
|
channelSettings->getNfmModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "NoiseFigureSettings") |
|
{ |
|
channelSettings->setNoiseFigureSettings(new SWGSDRangel::SWGNoiseFigureSettings()); |
|
channelSettings->getNoiseFigureSettings()->init(); |
|
channelSettings->getNoiseFigureSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "LocalSinkSettings") |
|
{ |
|
channelSettings->setLocalSinkSettings(new SWGSDRangel::SWGLocalSinkSettings()); |
|
channelSettings->getLocalSinkSettings()->init(); // contains a QList |
|
channelSettings->getLocalSinkSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "LocalSourceSettings") |
|
{ |
|
channelSettings->setLocalSourceSettings(new SWGSDRangel::SWGLocalSourceSettings()); |
|
channelSettings->getLocalSourceSettings()->init(); |
|
channelSettings->getLocalSourceSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "PacketDemodSettings") |
|
{ |
|
channelSettings->setPacketDemodSettings(new SWGSDRangel::SWGPacketDemodSettings()); |
|
channelSettings->getPacketDemodSettings()->init(); |
|
channelSettings->getPacketDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "PacketModSettings") |
|
{ |
|
channelSettings->setPacketModSettings(new SWGSDRangel::SWGPacketModSettings()); |
|
channelSettings->getPacketModSettings()->init(); |
|
channelSettings->getPacketModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "PagerDemodSettings") |
|
{ |
|
channelSettings->setPagerDemodSettings(new SWGSDRangel::SWGPagerDemodSettings()); |
|
channelSettings->getPagerDemodSettings()->init(); |
|
channelSettings->getPagerDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "PSK31ModSettings") |
|
{ |
|
channelSettings->setPsk31ModSettings(new SWGSDRangel::SWGPSK31ModSettings()); |
|
channelSettings->getPsk31ModSettings()->init(); |
|
channelSettings->getPsk31ModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "RadioAstronomySettings") |
|
{ |
|
channelSettings->setRadioAstronomySettings(new SWGSDRangel::SWGRadioAstronomySettings()); |
|
channelSettings->getRadioAstronomySettings()->init(); |
|
channelSettings->getRadioAstronomySettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "RadioClockSettings") |
|
{ |
|
channelSettings->setRadioClockSettings(new SWGSDRangel::SWGRadioClockSettings()); |
|
channelSettings->getRadioClockSettings()->init(); |
|
channelSettings->getRadioClockSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "RadiosondeDemodSettings") |
|
{ |
|
channelSettings->setRadiosondeDemodSettings(new SWGSDRangel::SWGRadiosondeDemodSettings()); |
|
channelSettings->getRadiosondeDemodSettings()->init(); |
|
channelSettings->getRadiosondeDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "RemoteSinkSettings") |
|
{ |
|
channelSettings->setRemoteSinkSettings(new SWGSDRangel::SWGRemoteSinkSettings()); |
|
channelSettings->getRemoteSinkSettings()->init(); |
|
channelSettings->getRemoteSinkSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "RemoteSourceSettings") |
|
{ |
|
channelSettings->setRemoteSourceSettings(new SWGSDRangel::SWGRemoteSourceSettings()); |
|
channelSettings->getRemoteSourceSettings()->init(); |
|
channelSettings->getRemoteSourceSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "RemoteTCPSinkSettings") |
|
{ |
|
channelSettings->setRemoteTcpSinkSettings(new SWGSDRangel::SWGRemoteTCPSinkSettings()); |
|
channelSettings->getRemoteTcpSinkSettings()->init(); |
|
channelSettings->getRemoteTcpSinkSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "RTTYDemodSettings") |
|
{ |
|
channelSettings->setRttyDemodSettings(new SWGSDRangel::SWGRTTYDemodSettings()); |
|
channelSettings->getRttyDemodSettings()->init(); |
|
channelSettings->getRttyDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "PSK31DemodSettings") |
|
{ |
|
channelSettings->setPSK31DemodSettings(new SWGSDRangel::SWGPSK31DemodSettings()); |
|
channelSettings->getPSK31DemodSettings()->init(); |
|
channelSettings->getPSK31DemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "RTTYModSettings") |
|
{ |
|
channelSettings->setRttyModSettings(new SWGSDRangel::SWGRTTYModSettings()); |
|
channelSettings->getRttyModSettings()->init(); |
|
channelSettings->getRttyModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "SigMFFileSinkSettings") |
|
{ |
|
channelSettings->setSigMfFileSinkSettings(new SWGSDRangel::SWGSigMFFileSinkSettings()); |
|
channelSettings->getSigMfFileSinkSettings()->init(); |
|
channelSettings->getSigMfFileSinkSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "SSBDemodSettings") |
|
{ |
|
channelSettings->setSsbDemodSettings(new SWGSDRangel::SWGSSBDemodSettings()); |
|
channelSettings->getSsbDemodSettings()->init(); |
|
channelSettings->getSsbDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "SSBModSettings") |
|
{ |
|
channelSettings->setSsbModSettings(new SWGSDRangel::SWGSSBModSettings()); |
|
channelSettings->getSsbModSettings()->init(); |
|
channelSettings->getSsbModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "UDPSourceSettings") |
|
{ |
|
channelSettings->setUdpSourceSettings(new SWGSDRangel::SWGUDPSourceSettings()); |
|
channelSettings->getUdpSourceSettings()->init(); |
|
channelSettings->getUdpSourceSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "UDPSinkSettings") |
|
{ |
|
channelSettings->setUdpSinkSettings(new SWGSDRangel::SWGUDPSinkSettings()); |
|
channelSettings->getUdpSinkSettings()->init(); |
|
channelSettings->getUdpSinkSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
// else if (channelSettingsKey == "VORDemodMCSettings") |
|
// { |
|
// channelSettings->setVorDemodMcSettings(new SWGSDRangel::SWGVORDemodMCSettings()); |
|
// channelSettings->getVorDemodMcSettings()->fromJsonObject(settingsJsonObject); |
|
// } |
|
else if (channelSettingsKey == "VORDemodSettings") |
|
{ |
|
channelSettings->setVorDemodSettings(new SWGSDRangel::SWGVORDemodSettings()); |
|
channelSettings->getVorDemodSettings()->init(); |
|
channelSettings->getVorDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "WFMDemodSettings") |
|
{ |
|
channelSettings->setWfmDemodSettings(new SWGSDRangel::SWGWFMDemodSettings()); |
|
channelSettings->getWfmDemodSettings()->init(); |
|
channelSettings->getWfmDemodSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "WFMModSettings") |
|
{ |
|
channelSettings->setWfmModSettings(new SWGSDRangel::SWGWFMModSettings()); |
|
channelSettings->getWfmModSettings()->init(); |
|
channelSettings->getWfmModSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (channelSettingsKey == "WDSPRxSettings") |
|
{ |
|
channelSettings->setWdspRxSettings(new SWGSDRangel::SWGWDSPRxSettings()); |
|
channelSettings->getWdspRxSettings()->init(); |
|
channelSettings->getWdspRxSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::getChannelActions( |
|
const QString& channelActionsKey, |
|
SWGSDRangel::SWGChannelActions *channelActions, |
|
const QJsonObject& channelActionsJson, |
|
QStringList& channelActionsKeys |
|
) |
|
{ |
|
QStringList channelKeys = channelActionsJson.keys(); |
|
|
|
if (channelKeys.contains(channelActionsKey) && channelActionsJson[channelActionsKey].isObject()) |
|
{ |
|
QJsonObject actionsJsonObject = channelActionsJson[channelActionsKey].toObject(); |
|
channelActionsKeys = actionsJsonObject.keys(); |
|
|
|
if (channelActionsKey == "AISModActions") |
|
{ |
|
channelActions->setAisModActions(new SWGSDRangel::SWGAISModActions()); |
|
channelActions->getAisModActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "APTDemodActions") |
|
{ |
|
channelActions->setAptDemodActions(new SWGSDRangel::SWGAPTDemodActions()); |
|
channelActions->getAptDemodActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "WefaxDemodActions") |
|
{ |
|
channelActions->setWefaxDemodActions(new SWGSDRangel::SWGWefaxDemodActions()); |
|
channelActions->getWefaxDemodActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "DVBDemodActions") |
|
{ |
|
channelActions->setDvbDemodActions(new SWGSDRangel::SWGDVBDemodActions()); |
|
channelActions->getDvbDemodActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "DRMDemodActions") |
|
{ |
|
channelActions->setDrmDemodActions(new SWGSDRangel::SWGDRMDemodActions()); |
|
channelActions->getDrmDemodActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "FileSinkActions") |
|
{ |
|
channelActions->setFileSinkActions(new SWGSDRangel::SWGFileSinkActions()); |
|
channelActions->getFileSinkActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "FileSourceActions") |
|
{ |
|
channelActions->setFileSourceActions(new SWGSDRangel::SWGFileSourceActions()); |
|
channelActions->getFileSourceActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "FreqScannerActions") |
|
{ |
|
channelActions->setFreqScannerActions(new SWGSDRangel::SWGFreqScannerActions()); |
|
channelActions->getFreqScannerActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "IEEE_802_15_4_ModActions") |
|
{ |
|
channelActions->setIeee802154ModActions(new SWGSDRangel::SWGIEEE_802_15_4_ModActions()); |
|
channelActions->getIeee802154ModActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "MeshcoreModActions") |
|
{ |
|
channelActions->setMeshcoreModActions(new SWGSDRangel::SWGMeshcoreModActions()); |
|
channelActions->getMeshcoreModActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "RadioAstronomyActions") |
|
{ |
|
channelActions->setRadioAstronomyActions(new SWGSDRangel::SWGRadioAstronomyActions()); |
|
channelActions->getRadioAstronomyActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "PacketModActions") |
|
{ |
|
channelActions->setPacketModActions(new SWGSDRangel::SWGPacketModActions()); |
|
channelActions->getPacketModActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "PSK31ModActions") |
|
{ |
|
channelActions->setPsk31ModActions(new SWGSDRangel::SWGPSK31ModActions()); |
|
channelActions->getPsk31ModActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "RTTYModActions") |
|
{ |
|
channelActions->setRttyModActions(new SWGSDRangel::SWGRTTYModActions()); |
|
channelActions->getRttyModActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (channelActionsKey == "SigMFFileSinkActions") |
|
{ |
|
channelActions->setSigMfFileSinkActions(new SWGSDRangel::SWGSigMFFileSinkActions()); |
|
channelActions->getSigMfFileSinkActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::appendPresetDeviceKeys( |
|
SWGSDRangel::SWGDeviceConfig *device, |
|
const QJsonObject& deviceSettngsJson, |
|
WebAPIAdapterInterface::DeviceKeys& devicelKeys |
|
) |
|
{ |
|
if (deviceSettngsJson.contains("deviceId")) |
|
{ |
|
QString *deviceId = new QString(deviceSettngsJson["deviceId"].toString()); |
|
device->setDeviceId(deviceId); |
|
devicelKeys.m_keys.append("deviceId"); |
|
|
|
if (deviceSettngsJson.contains("deviceSerial")) |
|
{ |
|
device->setDeviceSerial(new QString(deviceSettngsJson["deviceSerial"].toString())); |
|
devicelKeys.m_keys.append("deviceSerial"); |
|
} |
|
|
|
if (deviceSettngsJson.contains("deviceSequence")) |
|
{ |
|
device->setDeviceSequence(deviceSettngsJson["deviceSequence"].toInt()); |
|
devicelKeys.m_keys.append("deviceSequence"); |
|
} |
|
|
|
if (deviceSettngsJson.contains("config") && WebAPIUtils::m_deviceIdToSettingsKey.contains(*deviceId)) |
|
{ |
|
SWGSDRangel::SWGDeviceSettings *deviceSettings = new SWGSDRangel::SWGDeviceSettings(); |
|
device->setConfig(deviceSettings); |
|
return getDeviceSettings( |
|
WebAPIUtils::m_deviceIdToSettingsKey[*deviceId], |
|
deviceSettings, |
|
deviceSettngsJson["config"].toObject(), |
|
devicelKeys.m_deviceKeys |
|
); |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::getDeviceSettings( |
|
const QString& deviceSettingsKey, |
|
SWGSDRangel::SWGDeviceSettings *deviceSettings, |
|
const QJsonObject& deviceSettingsJson, |
|
QStringList& deviceSettingsKeys |
|
) |
|
{ |
|
QStringList deviceKeys = deviceSettingsJson.keys(); |
|
|
|
if (deviceKeys.contains(deviceSettingsKey) && deviceSettingsJson[deviceSettingsKey].isObject()) |
|
{ |
|
QJsonObject settingsJsonObject = deviceSettingsJson[deviceSettingsKey].toObject(); |
|
extractKeys(settingsJsonObject, deviceSettingsKeys); |
|
qDebug() << "WebAPIRequestMapper::getDeviceSettings: deviceSettingsKeys: " << deviceSettingsKeys; |
|
|
|
if (deviceSettingsKey == "aaroniaRTSASettings") |
|
{ |
|
deviceSettings->setAaroniaRtsaSettings(new SWGSDRangel::SWGAaroniaRTSASettings()); |
|
deviceSettings->getAaroniaRtsaSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "aaroniaRTSAOutputSettings") |
|
{ |
|
deviceSettings->setAaroniaRtsaOutputSettings(new SWGSDRangel::SWGAaroniaRTSAOutputSettings()); |
|
deviceSettings->getAaroniaRtsaOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "airspySettings") |
|
{ |
|
deviceSettings->setAirspySettings(new SWGSDRangel::SWGAirspySettings()); |
|
deviceSettings->getAirspySettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "airspyHFSettings") |
|
{ |
|
deviceSettings->setAirspyHfSettings(new SWGSDRangel::SWGAirspyHFSettings()); |
|
deviceSettings->getAirspyHfSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "androidSDRDriverInputSettings") |
|
{ |
|
deviceSettings->setAndroidSdrDriverInputSettings(new SWGSDRangel::SWGAndroidSDRDriverInputSettings()); |
|
deviceSettings->getAndroidSdrDriverInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "audioCATSISOSettings") |
|
{ |
|
deviceSettings->setAudioCatsisoSettings(new SWGSDRangel::SWGAudioCATSISOSettings()); |
|
deviceSettings->getAudioCatsisoSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "audioInputSettings") |
|
{ |
|
deviceSettings->setAudioInputSettings(new SWGSDRangel::SWGAudioInputSettings()); |
|
deviceSettings->getAudioInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "audioOutputSettings") |
|
{ |
|
deviceSettings->setAudioOutputSettings(new SWGSDRangel::SWGAudioOutputSettings()); |
|
deviceSettings->getAudioOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "bladeRF1InputSettings") |
|
{ |
|
deviceSettings->setBladeRf1InputSettings(new SWGSDRangel::SWGBladeRF1InputSettings()); |
|
deviceSettings->getBladeRf1InputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "bladeRF1OutputSettings") |
|
{ |
|
deviceSettings->setBladeRf1OutputSettings(new SWGSDRangel::SWGBladeRF1OutputSettings()); |
|
deviceSettings->getBladeRf1OutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "bladeRF2InputSettings") |
|
{ |
|
deviceSettings->setBladeRf2InputSettings(new SWGSDRangel::SWGBladeRF2InputSettings()); |
|
deviceSettings->getBladeRf2InputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "bladeRF2OutputSettings") |
|
{ |
|
deviceSettings->setBladeRf2OutputSettings(new SWGSDRangel::SWGBladeRF2OutputSettings()); |
|
deviceSettings->getBladeRf2OutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "bladeRF2MIMOSettings") |
|
{ |
|
deviceSettings->setBladeRf2MimoSettings(new SWGSDRangel::SWGBladeRF2MIMOSettings()); |
|
deviceSettings->getBladeRf2MimoSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "fcdProSettings") |
|
{ |
|
deviceSettings->setFcdProSettings(new SWGSDRangel::SWGFCDProSettings()); |
|
deviceSettings->getFcdProSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "fcdProPlusSettings") |
|
{ |
|
deviceSettings->setFcdProPlusSettings(new SWGSDRangel::SWGFCDProPlusSettings()); |
|
deviceSettings->getFcdProPlusSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "fileInputSettings") |
|
{ |
|
deviceSettings->setFileInputSettings(new SWGSDRangel::SWGFileInputSettings()); |
|
deviceSettings->getFileInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "fileOutputSettings") |
|
{ |
|
deviceSettings->setFileOutputSettings(new SWGSDRangel::SWGFileOutputSettings()); |
|
deviceSettings->getFileOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "hackRFInputSettings") |
|
{ |
|
deviceSettings->setHackRfInputSettings(new SWGSDRangel::SWGHackRFInputSettings()); |
|
deviceSettings->getHackRfInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "hackRFOutputSettings") |
|
{ |
|
deviceSettings->setHackRfOutputSettings(new SWGSDRangel::SWGHackRFOutputSettings()); |
|
deviceSettings->getHackRfOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "kiwiSDRSettings") |
|
{ |
|
deviceSettings->setKiwiSdrSettings(new SWGSDRangel::SWGKiwiSDRSettings()); |
|
deviceSettings->getKiwiSdrSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "limeSdrInputSettings") |
|
{ |
|
deviceSettings->setLimeSdrInputSettings(new SWGSDRangel::SWGLimeSdrInputSettings()); |
|
deviceSettings->getLimeSdrInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "limeSdrOutputSettings") |
|
{ |
|
deviceSettings->setLimeSdrOutputSettings(new SWGSDRangel::SWGLimeSdrOutputSettings()); |
|
deviceSettings->getLimeSdrOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "limeSdrMIMOSettings") |
|
{ |
|
deviceSettings->setLimeSdrMimoSettings(new SWGSDRangel::SWGLimeSdrMIMOSettings()); |
|
deviceSettings->getLimeSdrMimoSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "metisMISOSettings") |
|
{ |
|
deviceSettings->setMetisMisoSettings(new SWGSDRangel::SWGMetisMISOSettings()); |
|
deviceSettings->getMetisMisoSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "perseusSettings") |
|
{ |
|
deviceSettings->setPerseusSettings(new SWGSDRangel::SWGPerseusSettings()); |
|
deviceSettings->getPerseusSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "plutoSdrInputSettings") |
|
{ |
|
deviceSettings->setPlutoSdrInputSettings(new SWGSDRangel::SWGPlutoSdrInputSettings()); |
|
deviceSettings->getPlutoSdrInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "plutoSdrOutputSettings") |
|
{ |
|
deviceSettings->setPlutoSdrOutputSettings(new SWGSDRangel::SWGPlutoSdrOutputSettings()); |
|
deviceSettings->getPlutoSdrOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "rtlSdrSettings") |
|
{ |
|
deviceSettings->setRtlSdrSettings(new SWGSDRangel::SWGRtlSdrSettings()); |
|
deviceSettings->getRtlSdrSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "sdrPlaySettings") |
|
{ |
|
deviceSettings->setSdrPlaySettings(new SWGSDRangel::SWGSDRPlaySettings()); |
|
deviceSettings->getSdrPlaySettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "sdrPlayV3Settings") |
|
{ |
|
deviceSettings->setSdrPlayV3Settings(new SWGSDRangel::SWGSDRPlayV3Settings()); |
|
deviceSettings->getSdrPlayV3Settings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "sigMFFileInputSettings") |
|
{ |
|
deviceSettings->setSigMfFileInputSettings(new SWGSDRangel::SWGSigMFFileInputSettings()); |
|
deviceSettings->getSigMfFileInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "soapySDRInputSettings") |
|
{ |
|
deviceSettings->setSoapySdrInputSettings(new SWGSDRangel::SWGSoapySDRInputSettings()); |
|
deviceSettings->getSoapySdrInputSettings()->init(); // contains complex objects |
|
deviceSettings->getSoapySdrInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "soapySDROutputSettings") |
|
{ |
|
deviceSettings->setSoapySdrOutputSettings(new SWGSDRangel::SWGSoapySDROutputSettings()); |
|
deviceSettings->getSoapySdrOutputSettings()->init(); // contains complex objects |
|
deviceSettings->getSoapySdrOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "testSourceSettings") |
|
{ |
|
deviceSettings->setTestSourceSettings(new SWGSDRangel::SWGTestSourceSettings()); |
|
deviceSettings->getTestSourceSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "testMISettings") |
|
{ |
|
deviceSettings->setTestMiSettings(new SWGSDRangel::SWGTestMISettings()); |
|
deviceSettings->getTestMiSettings()->init(); |
|
deviceSettings->getTestMiSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "testMOSyncSettings") |
|
{ |
|
deviceSettings->setTestMoSyncSettings(new SWGSDRangel::SWGTestMOSyncSettings()); |
|
deviceSettings->getTestMoSyncSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "usrpInputSettings") |
|
{ |
|
deviceSettings->setUsrpInputSettings(new SWGSDRangel::SWGUSRPInputSettings()); |
|
deviceSettings->getUsrpInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "usrpOutputSettings") |
|
{ |
|
deviceSettings->setUsrpOutputSettings(new SWGSDRangel::SWGUSRPOutputSettings()); |
|
deviceSettings->getUsrpOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "usrpMIMOSettings") |
|
{ |
|
deviceSettings->setUsrpMimoSettings(new SWGSDRangel::SWGUSRPMIMOSettings()); |
|
deviceSettings->getUsrpMimoSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "xtrxInputSettings") |
|
{ |
|
deviceSettings->setXtrxInputSettings(new SWGSDRangel::SWGXtrxInputSettings()); |
|
deviceSettings->getXtrxInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "xtrxOutputSettings") |
|
{ |
|
deviceSettings->setXtrxOutputSettings(new SWGSDRangel::SWGXtrxOutputSettings()); |
|
deviceSettings->getXtrxOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "XtrxMIMOSettings") |
|
{ |
|
deviceSettings->setXtrxMimoSettings(new SWGSDRangel::SWGXtrxMIMOSettings()); |
|
deviceSettings->getXtrxMimoSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "remoteInputSettings") |
|
{ |
|
deviceSettings->setRemoteInputSettings(new SWGSDRangel::SWGRemoteInputSettings()); |
|
deviceSettings->getRemoteInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "remoteTCPInputSettings") |
|
{ |
|
deviceSettings->setRemoteTcpInputSettings(new SWGSDRangel::SWGRemoteTCPInputSettings()); |
|
deviceSettings->getRemoteTcpInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "localInputSettings") |
|
{ |
|
deviceSettings->setLocalInputSettings(new SWGSDRangel::SWGLocalInputSettings()); |
|
deviceSettings->getLocalInputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "remoteOutputSettings") |
|
{ |
|
deviceSettings->setRemoteOutputSettings(new SWGSDRangel::SWGRemoteOutputSettings()); |
|
deviceSettings->getRemoteOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (deviceSettingsKey == "localOutputSettings") |
|
{ |
|
deviceSettings->setLocalOutputSettings(new SWGSDRangel::SWGLocalOutputSettings()); |
|
deviceSettings->getLocalOutputSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
} |
|
|
|
bool WebAPIRequestMapper::getDeviceActions( |
|
const QString& deviceActionsKey, |
|
SWGSDRangel::SWGDeviceActions *deviceActions, |
|
const QJsonObject& deviceActionsJson, |
|
QStringList& deviceActionsKeys |
|
) |
|
{ |
|
QStringList deviceKeys = deviceActionsJson.keys(); |
|
|
|
if (deviceKeys.contains(deviceActionsKey) && deviceActionsJson[deviceActionsKey].isObject()) |
|
{ |
|
QJsonObject actionsJsonObject = deviceActionsJson[deviceActionsKey].toObject(); |
|
deviceActionsKeys = actionsJsonObject.keys(); |
|
|
|
if (deviceActionsKey == "SigMFFileInputActions") |
|
{ |
|
deviceActions->setSigMfFileInputActions(new SWGSDRangel::SWGSigMFFileInputActions()); |
|
deviceActions->getSigMfFileInputActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
} |
|
|
|
bool WebAPIRequestMapper::getFeatureSettings( |
|
const QString& featureSettingsKey, |
|
SWGSDRangel::SWGFeatureSettings *featureSettings, |
|
const QJsonObject& featureSettingsJson, |
|
QStringList& featureSettingsKeys |
|
) |
|
{ |
|
QStringList featureKeys = featureSettingsJson.keys(); |
|
|
|
if (featureKeys.contains(featureSettingsKey) && featureSettingsJson[featureSettingsKey].isObject()) |
|
{ |
|
QJsonObject settingsJsonObject = featureSettingsJson[featureSettingsKey].toObject(); |
|
extractKeys(settingsJsonObject, featureSettingsKeys); |
|
qDebug() << "WebAPIRequestMapper::getFeatureSettings: featureSettingsKeys: " << featureSettingsKeys; |
|
|
|
if (featureSettingsKey == "AFCSettings") |
|
{ |
|
featureSettings->setAfcSettings(new SWGSDRangel::SWGAFCSettings()); |
|
featureSettings->getAfcSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "AISSSettings") |
|
{ |
|
featureSettings->setAisSettings(new SWGSDRangel::SWGAISSettings()); |
|
featureSettings->getAisSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "AircraftSettings") |
|
{ |
|
featureSettings->setAircraftSettings(new SWGSDRangel::SWGAircraftSettings()); |
|
featureSettings->getAircraftSettings()->init(); // fromJsonObject() fills the lists init() allocates |
|
featureSettings->getAircraftSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "AntennaToolsSettings") |
|
{ |
|
featureSettings->setAntennaToolsSettings(new SWGSDRangel::SWGAntennaToolsSettings()); |
|
featureSettings->getAntennaToolsSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "APRSSettings") |
|
{ |
|
featureSettings->setAprsSettings(new SWGSDRangel::SWGAPRSSettings()); |
|
featureSettings->getAprsSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "DemodAnalyzerSettings") |
|
{ |
|
featureSettings->setDemodAnalyzerSettings(new SWGSDRangel::SWGDemodAnalyzerSettings()); |
|
featureSettings->getDemodAnalyzerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "FreqDisplaySettings") |
|
{ |
|
featureSettings->setFreqDisplaySettings(new SWGSDRangel::SWGFreqDisplaySettings()); |
|
featureSettings->getFreqDisplaySettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "JogdialControllerSettings") |
|
{ |
|
featureSettings->setJogdialControllerSettings(new SWGSDRangel::SWGJogdialControllerSettings()); |
|
featureSettings->getJogdialControllerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "GS232ControllerSettings") |
|
{ |
|
featureSettings->setGs232ControllerSettings(new SWGSDRangel::SWGGS232ControllerSettings()); |
|
featureSettings->getGs232ControllerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "LimeRFESettings") |
|
{ |
|
featureSettings->setLimeRfeSettings(new SWGSDRangel::SWGLimeRFESettings()); |
|
featureSettings->getLimeRfeSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "MapSettings") |
|
{ |
|
featureSettings->setMapSettings(new SWGSDRangel::SWGMapSettings()); |
|
featureSettings->getMapSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "MorseDecoderSettings") |
|
{ |
|
featureSettings->setMorseDecoderSettings(new SWGSDRangel::SWGMorseDecoderSettings()); |
|
featureSettings->getMorseDecoderSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "PERTesterSettings") |
|
{ |
|
featureSettings->setPerTesterSettings(new SWGSDRangel::SWGPERTesterSettings()); |
|
featureSettings->getPerTesterSettings()->init(); |
|
featureSettings->getPerTesterSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "SatelliteTrackerSettings") |
|
{ |
|
featureSettings->setSatelliteTrackerSettings(new SWGSDRangel::SWGSatelliteTrackerSettings()); |
|
featureSettings->getSatelliteTrackerSettings()->init(); |
|
featureSettings->getSatelliteTrackerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "SIDSettings") |
|
{ |
|
featureSettings->setSidSettings(new SWGSDRangel::SWGSIDSettings()); |
|
featureSettings->getSidSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "SimplePTTSettings") |
|
{ |
|
featureSettings->setSimplePttSettings(new SWGSDRangel::SWGSimplePTTSettings()); |
|
featureSettings->getSimplePttSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "SkyMapSettings") |
|
{ |
|
featureSettings->setSkyMapSettings(new SWGSDRangel::SWGSkyMapSettings()); |
|
featureSettings->getSkyMapSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "StarTrackerSettings") |
|
{ |
|
featureSettings->setStarTrackerSettings(new SWGSDRangel::SWGStarTrackerSettings()); |
|
featureSettings->getStarTrackerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "RadiosondeSettings") |
|
{ |
|
featureSettings->setRadiosondeSettings(new SWGSDRangel::SWGRadiosondeSettings()); |
|
featureSettings->getRadiosondeSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "RigCtlServerSettings") |
|
{ |
|
featureSettings->setRigCtlServerSettings(new SWGSDRangel::SWGRigCtlServerSettings()); |
|
featureSettings->getRigCtlServerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "MCPServerSettings") |
|
{ |
|
featureSettings->setMcpServerSettings(new SWGSDRangel::SWGMCPServerSettings()); |
|
featureSettings->getMcpServerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else if (featureSettingsKey == "VORLocalizerSettings") |
|
{ |
|
featureSettings->setVorLocalizerSettings(new SWGSDRangel::SWGVORLocalizerSettings()); |
|
featureSettings->getVorLocalizerSettings()->fromJsonObject(settingsJsonObject); |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
bool WebAPIRequestMapper::getFeatureActions( |
|
const QString& featureActionsKey, |
|
SWGSDRangel::SWGFeatureActions *featureActions, |
|
const QJsonObject& featureActionsJson, |
|
QStringList& featureActionsKeys |
|
) |
|
{ |
|
QStringList featureKeys = featureActionsJson.keys(); |
|
|
|
if (featureKeys.contains(featureActionsKey) && featureActionsJson[featureActionsKey].isObject()) |
|
{ |
|
QJsonObject actionsJsonObject = featureActionsJson[featureActionsKey].toObject(); |
|
featureActionsKeys = actionsJsonObject.keys(); |
|
qDebug("WebAPIRequestMapper::getFeatureActions: %s", qPrintable(featureActionsKey)); |
|
|
|
if (featureActionsKey == "AFCActions") |
|
{ |
|
featureActions->setAfcActions(new SWGSDRangel::SWGAFCActions()); |
|
featureActions->getAfcActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "AircraftActions") |
|
{ |
|
featureActions->setAircraftActions(new SWGSDRangel::SWGAircraftActions()); |
|
featureActions->getAircraftActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "AMBEActions") |
|
{ |
|
featureActions->setAmbeActions(new SWGSDRangel::SWGAMBEActions()); |
|
featureActions->getAmbeActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "GS232ControllerActions") |
|
{ |
|
featureActions->setGs232ControllerActions(new SWGSDRangel::SWGGS232ControllerActions()); |
|
featureActions->getGs232ControllerActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "LimeRFEActions") |
|
{ |
|
featureActions->setLimeRfeActions(new SWGSDRangel::SWGLimeRFEActions()); |
|
featureActions->getLimeRfeActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "MapActions") |
|
{ |
|
featureActions->setMapActions(new SWGSDRangel::SWGMapActions()); |
|
featureActions->getMapActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "PERTesterActions") |
|
{ |
|
featureActions->setPerTesterActions(new SWGSDRangel::SWGPERTesterActions()); |
|
featureActions->getPerTesterActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "RigCtlServerActions") |
|
{ |
|
featureActions->setRigCtlServerActions(new SWGSDRangel::SWGRigCtlServerActions()); |
|
featureActions->getRigCtlServerActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "MCPServerActions") |
|
{ |
|
featureActions->setMcpServerActions(new SWGSDRangel::SWGMCPServerActions()); |
|
featureActions->getMcpServerActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "SatelliteTrackerActions") |
|
{ |
|
featureActions->setSatelliteTrackerActions(new SWGSDRangel::SWGSatelliteTrackerActions()); |
|
featureActions->getSatelliteTrackerActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "SimplePTTActions") |
|
{ |
|
featureActions->setSimplePttActions(new SWGSDRangel::SWGSimplePTTActions()); |
|
featureActions->getSimplePttActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "SkyMapActions") |
|
{ |
|
featureActions->setSkyMapActions(new SWGSDRangel::SWGSkyMapActions()); |
|
featureActions->getSkyMapActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "StarTrackerActions") |
|
{ |
|
featureActions->setStarTrackerActions(new SWGSDRangel::SWGStarTrackerActions()); |
|
featureActions->getStarTrackerActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "VORLocalizerActions") |
|
{ |
|
featureActions->setVorLocalizerActions(new SWGSDRangel::SWGVORLocalizerActions()); |
|
featureActions->getVorLocalizerActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "DemodAnalyzerActions") |
|
{ |
|
featureActions->setDemodAnalyzerActions(new SWGSDRangel::SWGDemodAnalyzerActions()); |
|
featureActions->getDemodAnalyzerActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else if (featureActionsKey == "MorseDecoderActions") |
|
{ |
|
featureActions->setMorseDecoderActions(new SWGSDRangel::SWGMorseDecoderActions()); |
|
featureActions->getMorseDecoderActions()->fromJsonObject(actionsJsonObject); |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
|
|
return true; |
|
} |
|
else |
|
{ |
|
return false; |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::extractKeys( |
|
const QJsonObject& rootJsonObject, |
|
QStringList& keyList |
|
) |
|
{ |
|
QStringList rootKeys = rootJsonObject.keys(); |
|
|
|
for (auto rootKey : rootKeys) |
|
{ |
|
keyList.append(rootKey); |
|
|
|
if (rootJsonObject[rootKey].isObject()) |
|
{ |
|
QStringList subKeys; |
|
extractKeys(rootJsonObject[rootKey].toObject(), subKeys); |
|
|
|
for (auto subKey : subKeys) { |
|
keyList.append(tr("%1.%2").arg(rootKey).arg(subKey)); |
|
} |
|
} |
|
else if (rootJsonObject[rootKey].isArray()) |
|
{ |
|
QJsonArray arrayJson = rootJsonObject[rootKey].toArray(); |
|
|
|
for (int arrayIndex = 0; arrayIndex < arrayJson.count(); arrayIndex++) |
|
{ |
|
QStringList subKeys; |
|
extractKeys(arrayJson.at(arrayIndex).toObject(), subKeys); |
|
keyList.append(tr("%1[%2]").arg(rootKey).arg(arrayIndex)); |
|
|
|
for (auto subKey : subKeys) { |
|
keyList.append(tr("%1[%2].%3").arg(rootKey).arg(arrayIndex).arg(subKey)); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
void WebAPIRequestMapper::resetSpectrumSettings(SWGSDRangel::SWGGLSpectrum& spectrumSettings) |
|
{ |
|
spectrumSettings.cleanup(); |
|
} |
|
|
|
void WebAPIRequestMapper::resetSpectrumReport(SWGSDRangel::SWGGLSpectrumReport& spectrumReport) |
|
{ |
|
spectrumReport.cleanup(); |
|
} |
|
|
|
void WebAPIRequestMapper::resetDeviceSettings(SWGSDRangel::SWGDeviceSettings& deviceSettings) |
|
{ |
|
deviceSettings.cleanup(); |
|
deviceSettings.setDeviceHwType(nullptr); |
|
deviceSettings.setAirspySettings(nullptr); |
|
deviceSettings.setAirspyHfSettings(nullptr); |
|
deviceSettings.setAndroidSdrDriverInputSettings(nullptr); |
|
deviceSettings.setAudioInputSettings(nullptr); |
|
deviceSettings.setBladeRf1InputSettings(nullptr); |
|
deviceSettings.setBladeRf1OutputSettings(nullptr); |
|
deviceSettings.setFcdProPlusSettings(nullptr); |
|
deviceSettings.setFcdProSettings(nullptr); |
|
deviceSettings.setFileInputSettings(nullptr); |
|
deviceSettings.setFileOutputSettings(nullptr); |
|
deviceSettings.setHackRfInputSettings(nullptr); |
|
deviceSettings.setHackRfOutputSettings(nullptr); |
|
deviceSettings.setLimeSdrInputSettings(nullptr); |
|
deviceSettings.setLimeSdrOutputSettings(nullptr); |
|
deviceSettings.setPerseusSettings(nullptr); |
|
deviceSettings.setPlutoSdrInputSettings(nullptr); |
|
deviceSettings.setPlutoSdrOutputSettings(nullptr); |
|
deviceSettings.setRtlSdrSettings(nullptr); |
|
deviceSettings.setRemoteOutputSettings(nullptr); |
|
deviceSettings.setRemoteInputSettings(nullptr); |
|
deviceSettings.setRemoteTcpInputSettings(nullptr); |
|
deviceSettings.setSdrPlaySettings(nullptr); |
|
deviceSettings.setSdrPlayV3Settings(nullptr); |
|
deviceSettings.setTestSourceSettings(nullptr); |
|
deviceSettings.setUsrpInputSettings(nullptr); |
|
deviceSettings.setUsrpOutputSettings(nullptr); |
|
deviceSettings.setUsrpMimoSettings(nullptr); |
|
} |
|
|
|
void WebAPIRequestMapper::resetDeviceReport(SWGSDRangel::SWGDeviceReport& deviceReport) |
|
{ |
|
deviceReport.cleanup(); |
|
deviceReport.setDeviceHwType(nullptr); |
|
deviceReport.setAirspyHfReport(nullptr); |
|
deviceReport.setAirspyReport(nullptr); |
|
deviceReport.setAndroidSdrDriverInputReport(nullptr); |
|
deviceReport.setFileInputReport(nullptr); |
|
deviceReport.setLimeSdrInputReport(nullptr); |
|
deviceReport.setLimeSdrOutputReport(nullptr); |
|
deviceReport.setPerseusReport(nullptr); |
|
deviceReport.setPlutoSdrInputReport(nullptr); |
|
deviceReport.setPlutoSdrOutputReport(nullptr); |
|
deviceReport.setRtlSdrReport(nullptr); |
|
deviceReport.setRemoteOutputReport(nullptr); |
|
deviceReport.setRemoteInputReport(nullptr); |
|
deviceReport.setRemoteTcpInputReport(nullptr); |
|
deviceReport.setSdrPlayReport(nullptr); |
|
deviceReport.setSdrPlayV3Report(nullptr); |
|
deviceReport.setUsrpOutputReport(nullptr); |
|
deviceReport.setUsrpMimoReport(nullptr); |
|
} |
|
|
|
void WebAPIRequestMapper::resetDeviceActions(SWGSDRangel::SWGDeviceActions& deviceActions) |
|
{ |
|
deviceActions.cleanup(); |
|
deviceActions.setDeviceHwType(nullptr); |
|
// deviceActions.setXtrxInputActions(nullptr); |
|
} |
|
|
|
void WebAPIRequestMapper::resetChannelSettings(SWGSDRangel::SWGChannelSettings& channelSettings) |
|
{ |
|
channelSettings.cleanup(); |
|
channelSettings.setChannelType(nullptr); |
|
channelSettings.setAcarsDemodSettings(nullptr); |
|
channelSettings.setAdsbDemodSettings(nullptr); |
|
channelSettings.setAisDemodSettings(nullptr); |
|
channelSettings.setAisModSettings(nullptr); |
|
channelSettings.setAmDemodSettings(nullptr); |
|
channelSettings.setAmModSettings(nullptr); |
|
channelSettings.setAptDemodSettings(nullptr); |
|
channelSettings.setWefaxDemodSettings(nullptr); |
|
channelSettings.setAtvDemodSettings(nullptr); |
|
channelSettings.setAtvModSettings(nullptr); |
|
channelSettings.setBfmDemodSettings(nullptr); |
|
channelSettings.setBfmModSettings(nullptr); |
|
channelSettings.setChannelPowerSettings(nullptr); |
|
channelSettings.setDatvModSettings(nullptr); |
|
channelSettings.setDvbDemodSettings(nullptr); |
|
channelSettings.setDabDemodSettings(nullptr); |
|
channelSettings.setDrmDemodSettings(nullptr); |
|
channelSettings.setDsdDemodSettings(nullptr); |
|
channelSettings.setDroneIdDemodSettings(nullptr); |
|
channelSettings.setEndOfTrainDemodSettings(nullptr); |
|
channelSettings.setFreqScannerSettings(nullptr); |
|
channelSettings.setFreqTrackerSettings(nullptr); |
|
channelSettings.setHeatMapSettings(nullptr); |
|
channelSettings.setIeee802154ModSettings(nullptr); |
|
channelSettings.setIlsDemodSettings(nullptr); |
|
channelSettings.setInmarsatDemodSettings(nullptr); |
|
channelSettings.setNavtexDemodSettings(nullptr); |
|
channelSettings.setNfmDemodSettings(nullptr); |
|
channelSettings.setNfmModSettings(nullptr); |
|
channelSettings.setNoiseFigureSettings(nullptr); |
|
channelSettings.setPacketDemodSettings(nullptr); |
|
channelSettings.setPacketModSettings(nullptr); |
|
channelSettings.setPagerDemodSettings(nullptr); |
|
channelSettings.setPsk31ModSettings(nullptr); |
|
channelSettings.setRadioAstronomySettings(nullptr); |
|
channelSettings.setRadioClockSettings(nullptr); |
|
channelSettings.setRadiosondeDemodSettings(nullptr); |
|
channelSettings.setRemoteSinkSettings(nullptr); |
|
channelSettings.setRemoteSourceSettings(nullptr); |
|
channelSettings.setRemoteTcpSinkSettings(nullptr); |
|
channelSettings.setRttyDemodSettings(nullptr); |
|
channelSettings.setRttyModSettings(nullptr); |
|
channelSettings.setSsbDemodSettings(nullptr); |
|
channelSettings.setSsbModSettings(nullptr); |
|
channelSettings.setUdpSourceSettings(nullptr); |
|
channelSettings.setUdpSinkSettings(nullptr); |
|
// channelSettings.setVorDemodMcSettings(nullptr); |
|
channelSettings.setVorDemodSettings(nullptr); |
|
channelSettings.setWfmDemodSettings(nullptr); |
|
channelSettings.setWfmModSettings(nullptr); |
|
} |
|
|
|
void WebAPIRequestMapper::resetChannelReport(SWGSDRangel::SWGChannelReport& channelReport) |
|
{ |
|
channelReport.cleanup(); |
|
channelReport.setChannelType(nullptr); |
|
channelReport.setAcarsDemodReport(nullptr); |
|
channelReport.setAdsbDemodReport(nullptr); |
|
channelReport.setAisDemodReport(nullptr); |
|
channelReport.setAisModReport(nullptr); |
|
channelReport.setAmDemodReport(nullptr); |
|
channelReport.setWefaxDemodReport(nullptr); |
|
channelReport.setAmModReport(nullptr); |
|
channelReport.setAtvDemodReport(nullptr); |
|
channelReport.setAtvModReport(nullptr); |
|
channelReport.setBfmDemodReport(nullptr); |
|
channelReport.setBfmModReport(nullptr); |
|
channelReport.setChannelPowerReport(nullptr); |
|
channelReport.setDatvModReport(nullptr); |
|
channelReport.setDvbDemodReport(nullptr); |
|
channelReport.setDrmDemodReport(nullptr); |
|
channelReport.setDsdDemodReport(nullptr); |
|
channelReport.setDroneIdDemodReport(nullptr); |
|
channelReport.setEndOfTrainDemodReport(nullptr); |
|
channelReport.setFreqScannerReport(nullptr); |
|
channelReport.setFreqTrackerReport(nullptr); |
|
channelReport.setHeatMapReport(nullptr); |
|
channelReport.setIlsDemodReport(nullptr); |
|
channelReport.setInmarsatDemodReport(nullptr); |
|
channelReport.setNavtexDemodReport(nullptr); |
|
channelReport.setNfmDemodReport(nullptr); |
|
channelReport.setNfmModReport(nullptr); |
|
channelReport.setNoiseFigureReport(nullptr); |
|
channelReport.setIeee802154ModReport(nullptr); |
|
channelReport.setPacketModReport(nullptr); |
|
channelReport.setPsk31ModReport(nullptr); |
|
channelReport.setRadioAstronomyReport(nullptr); |
|
channelReport.setRadioClockReport(nullptr); |
|
channelReport.setRadiosondeDemodReport(nullptr); |
|
channelReport.setRemoteSourceReport(nullptr); |
|
channelReport.setRttyDemodReport(nullptr); |
|
channelReport.setRttyModReport(nullptr); |
|
channelReport.setSsbDemodReport(nullptr); |
|
channelReport.setSsbModReport(nullptr); |
|
channelReport.setUdpSourceReport(nullptr); |
|
channelReport.setUdpSinkReport(nullptr); |
|
// channelReport.setVorDemodMcReport(nullptr); |
|
channelReport.setVorDemodReport(nullptr); |
|
channelReport.setWfmDemodReport(nullptr); |
|
channelReport.setWfmModReport(nullptr); |
|
} |
|
|
|
void WebAPIRequestMapper::resetChannelActions(SWGSDRangel::SWGChannelActions& channelActions) |
|
{ |
|
channelActions.cleanup(); |
|
channelActions.setAisModActions(nullptr); |
|
channelActions.setAptDemodActions(nullptr); |
|
channelActions.setWefaxDemodActions(nullptr); |
|
channelActions.setChannelType(nullptr); |
|
channelActions.setDrmDemodActions(nullptr); |
|
channelActions.setFileSourceActions(nullptr); |
|
channelActions.setFreqScannerActions(nullptr); |
|
channelActions.setIeee802154ModActions(nullptr); |
|
channelActions.setPacketModActions(nullptr); |
|
channelActions.setPsk31ModActions(nullptr); |
|
channelActions.setRadioAstronomyActions(nullptr); |
|
channelActions.setRttyModActions(nullptr); |
|
} |
|
|
|
void WebAPIRequestMapper::resetAudioInputDevice(SWGSDRangel::SWGAudioInputDevice& audioInputDevice) |
|
{ |
|
audioInputDevice.cleanup(); |
|
audioInputDevice.setName(nullptr); |
|
} |
|
|
|
void WebAPIRequestMapper::resetAudioOutputDevice(SWGSDRangel::SWGAudioOutputDevice& audioOutputDevice) |
|
{ |
|
audioOutputDevice.cleanup(); |
|
audioOutputDevice.setName(nullptr); |
|
audioOutputDevice.setUdpAddress(nullptr); |
|
} |
|
|
|
void WebAPIRequestMapper::resetFeatureSettings(SWGSDRangel::SWGFeatureSettings& featureSettings) |
|
{ |
|
featureSettings.cleanup(); |
|
featureSettings.setFeatureType(nullptr); |
|
featureSettings.setAircraftSettings(nullptr); |
|
featureSettings.setAisSettings(nullptr); |
|
featureSettings.setAntennaToolsSettings(nullptr); |
|
featureSettings.setAprsSettings(nullptr); |
|
featureSettings.setFreqDisplaySettings(nullptr); |
|
featureSettings.setGs232ControllerSettings(nullptr); |
|
featureSettings.setMapSettings(nullptr); |
|
featureSettings.setPerTesterSettings(nullptr); |
|
featureSettings.setSatelliteTrackerSettings(nullptr); |
|
featureSettings.setSidSettings(nullptr); |
|
featureSettings.setSimplePttSettings(nullptr); |
|
featureSettings.setSkyMapSettings(nullptr); |
|
featureSettings.setStarTrackerSettings(nullptr); |
|
featureSettings.setRadiosondeSettings(nullptr); |
|
featureSettings.setRigCtlServerSettings(nullptr); |
|
featureSettings.setMcpServerSettings(nullptr); |
|
} |
|
|
|
void WebAPIRequestMapper::resetFeatureReport(SWGSDRangel::SWGFeatureReport& featureReport) |
|
{ |
|
featureReport.cleanup(); |
|
featureReport.setFeatureType(nullptr); |
|
featureReport.setAfcReport(nullptr); |
|
featureReport.setAircraftReport(nullptr); |
|
featureReport.setFreqDisplayReport(nullptr); |
|
featureReport.setGs232ControllerReport(nullptr); |
|
featureReport.setPerTesterReport(nullptr); |
|
featureReport.setRigCtlServerReport(nullptr); |
|
featureReport.setMcpServerReport(nullptr); |
|
featureReport.setMapReport(nullptr); |
|
featureReport.setSatelliteTrackerReport(nullptr); |
|
featureReport.setSimplePttReport(nullptr); |
|
featureReport.setSkyMapReport(nullptr); |
|
featureReport.setStarTrackerReport(nullptr); |
|
featureReport.setVorLocalizerReport(nullptr); |
|
} |
|
|
|
void WebAPIRequestMapper::resetFeatureActions(SWGSDRangel::SWGFeatureActions& featureActions) |
|
{ |
|
featureActions.cleanup(); |
|
featureActions.setFeatureType(nullptr); |
|
featureActions.setAfcActions(nullptr); |
|
featureActions.setAircraftActions(nullptr); |
|
featureActions.setGs232ControllerActions(nullptr); |
|
featureActions.setMapActions(nullptr); |
|
featureActions.setPerTesterActions(nullptr); |
|
featureActions.setRigCtlServerActions(nullptr); |
|
featureActions.setMcpServerActions(nullptr); |
|
featureActions.setSatelliteTrackerActions(nullptr); |
|
featureActions.setSimplePttActions(nullptr); |
|
featureActions.setSkyMapActions(nullptr); |
|
featureActions.setStarTrackerActions(nullptr); |
|
featureActions.setVorLocalizerActions(nullptr); |
|
}
|
|
|