mirror of
https://github.com/f4exb/sdrangel.git
synced 2025-06-09 10:12:25 -04:00
1a9b6d1763
Add GS232 Rotator Controller feature plugin. Add altitude and station name to My Positon. Use QtDeploy to ensure all required Qt libraries are included (Should fix OpenGL issues)
4820 lines
184 KiB
C++
4820 lines
184 KiB
C++
///////////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (C) 2017 Edouard Griffiths, F4EXB. //
|
|
// //
|
|
// 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 "httpdocrootsettings.h"
|
|
#include "webapirequestmapper.h"
|
|
#include "SWGInstanceSummaryResponse.h"
|
|
#include "SWGInstanceConfigResponse.h"
|
|
#include "SWGInstanceDevicesResponse.h"
|
|
#include "SWGInstanceChannelsResponse.h"
|
|
#include "SWGAudioDevices.h"
|
|
#include "SWGLocationInformation.h"
|
|
#include "SWGDVSerialDevices.h"
|
|
#include "SWGAMBEDevices.h"
|
|
#include "SWGLimeRFEDevices.h"
|
|
#include "SWGLimeRFESettings.h"
|
|
#include "SWGLimeRFEPower.h"
|
|
#include "SWGPresets.h"
|
|
#include "SWGPresetTransfer.h"
|
|
#include "SWGPresetIdentifier.h"
|
|
#include "SWGPresetImport.h"
|
|
#include "SWGPresetExport.h"
|
|
#include "SWGDeviceSettings.h"
|
|
#include "SWGDeviceState.h"
|
|
#include "SWGDeviceReport.h"
|
|
#include "SWGDeviceActions.h"
|
|
#include "SWGChannelsDetail.h"
|
|
#include "SWGChannelSettings.h"
|
|
#include "SWGChannelReport.h"
|
|
#include "SWGChannelActions.h"
|
|
#include "SWGSuccessResponse.h"
|
|
#include "SWGErrorResponse.h"
|
|
#include "SWGFeatureSetList.h"
|
|
#include "SWGFeatureSettings.h"
|
|
#include "SWGFeatureReport.h"
|
|
#include "SWGFeatureActions.h"
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_channelURIToSettingsKey = {
|
|
{"sdrangel.channel.adsbdemod", "ADSBDemodSettings"},
|
|
{"sdrangel.channel.amdemod", "AMDemodSettings"},
|
|
{"de.maintech.sdrangelove.channel.am", "AMDemodSettings"}, // remap
|
|
{"sdrangel.channeltx.modam", "AMModSettings"},
|
|
{"sdrangel.channeltx.modatv", "ATVModSettings"},
|
|
{"sdrangel.channel.bfm", "BFMDemodSettings"},
|
|
{"sdrangel.channel.chanalyzer", "ChannelAnalyzerSettings"},
|
|
{"sdrangel.channel.chanalyzerng", "ChannelAnalyzerSettings"}, // remap
|
|
{"org.f4exb.sdrangelove.channel.chanalyzer", "ChannelAnalyzerSettings"}, // remap
|
|
{"sdrangel.channel.demodatv", "ATVDemodSettings"},
|
|
{"sdrangel.channel.demoddatv", "DATVDemodSettings"},
|
|
{"sdrangel.channel.dsddemod", "DSDDemodSettings"},
|
|
{"sdrangel.channel.filesink", "FileSinkSettings"},
|
|
{"sdrangel.channeltx.filesource", "FileSourceSettings"},
|
|
{"sdrangel.channel.freedvdemod", "FreeDVDemodSettings"},
|
|
{"sdrangel.channeltx.freedvmod", "FreeDVModSettings"},
|
|
{"sdrangel.channel.freqtracker", "FreqTrackerSettings"},
|
|
{"sdrangel.channel.nfmdemod", "NFMDemodSettings"},
|
|
{"de.maintech.sdrangelove.channel.nfm", "NFMDemodSettings"}, // remap
|
|
{"sdrangel.channeltx.modnfm", "NFMModSettings"},
|
|
{"sdrangel.demod.localsink", "LocalSinkSettings"},
|
|
{"sdrangel.channel.localsink", "LocalSinkSettings"}, // remap
|
|
{"sdrangel.channel.localsource", "LocalSourceSettings"},
|
|
{"sdrangel.channeltx.modpacket", "PacketModSettings"},
|
|
{"sdrangel.channeltx.mod802.15.4", "IEEE_802_15_4_ModSettings"},
|
|
{"sdrangel.demod.remotesink", "RemoteSinkSettings"},
|
|
{"sdrangel.channeltx.remotesource", "RemoteSourceSettings"},
|
|
{"sdrangel.channeltx.modssb", "SSBModSettings"},
|
|
{"sdrangel.channel.ssbdemod", "SSBDemodSettings"},
|
|
{"de.maintech.sdrangelove.channel.ssb", "SSBDemodSettings"}, // remap
|
|
{"sdrangel.channeltx.udpsource", "UDPSourceSettings"},
|
|
{"sdrangel.channeltx.udpsink", "UDPSourceSettings"}, // remap
|
|
{"sdrangel.channel.udpsink", "UDPSinkSettings"},
|
|
{"sdrangel.channel.udpsrc", "UDPSinkSettings"}, // remap
|
|
{"sdrangel.channel.wfmdemod", "WFMDemodSettings"},
|
|
{"de.maintech.sdrangelove.channel.wfm", "WFMDemodSettings"}, // remap
|
|
{"sdrangel.channeltx.modwfm", "WFMModSettings"}
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_deviceIdToSettingsKey = {
|
|
{"sdrangel.samplesource.airspy", "airspySettings"},
|
|
{"sdrangel.samplesource.airspyhf", "airspyHFSettings"},
|
|
{"sdrangel.samplesource.bladerf1input", "bladeRF1InputSettings"},
|
|
{"sdrangel.samplesource.bladerf", "bladeRF1InputSettings"}, // remap
|
|
{"sdrangel.samplesink.bladerf1output", "bladeRF1OutputSettings"},
|
|
{"sdrangel.samplesource.bladerf1output", "bladeRF1OutputSettings"}, // remap
|
|
{"sdrangel.samplesource.bladerfoutput", "bladeRF1OutputSettings"}, // remap
|
|
{"sdrangel.samplesource.bladerf2input", "bladeRF2InputSettings"},
|
|
{"sdrangel.samplesink.bladerf2output", "bladeRF2OutputSettings"},
|
|
{"sdrangel.samplesource.bladerf2output", "bladeRF2OutputSettings"}, // remap
|
|
{"sdrangel.samplesource.fcdpro", "fcdProSettings"},
|
|
{"sdrangel.samplesource.fcdproplus", "fcdProPlusSettings"},
|
|
{"sdrangel.samplesource.fileinput", "fileInputSettings"},
|
|
{"sdrangel.samplesource.filesource", "fileInputSettings"}, // remap
|
|
{"sdrangel.samplesource.hackrf", "hackRFInputSettings"},
|
|
{"sdrangel.samplesink.hackrf", "hackRFOutputSettings"},
|
|
{"sdrangel.samplesource.hackrfoutput", "hackRFOutputSettings"}, // remap
|
|
{"sdrangel.samplesource.kiwisdrsource", "kiwiSDRSettings"},
|
|
{"sdrangel.samplesource.limesdr", "limeSdrInputSettings"},
|
|
{"sdrangel.samplesink.limesdr", "limeSdrOutputSettings"},
|
|
{"sdrangel.samplesource.localinput", "localInputSettings"},
|
|
{"sdrangel.samplesink.localoutput", "localOutputSettings"},
|
|
{"sdrangel.samplesource.localoutput", "localOutputSettings"}, // remap
|
|
{"sdrangel.samplesource.perseus", "perseusSettings"},
|
|
{"sdrangel.samplesource.plutosdr", "plutoSdrInputSettings"},
|
|
{"sdrangel.samplesink.plutosdr", "plutoSdrOutputSettings"},
|
|
{"sdrangel.samplesource.rtlsdr", "rtlSdrSettings"},
|
|
{"sdrangel.samplesource.remoteinput", "remoteInputSettings"},
|
|
{"sdrangel.samplesink.remoteoutput", "remoteOutputSettings"},
|
|
{"sdrangel.samplesource.sdrplay", "sdrPlaySettings"},
|
|
{"sdrangel.samplesource.soapysdrinput", "soapySDRInputSettings"},
|
|
{"sdrangel.samplesink.soapysdroutput", "soapySDROutputSettings"},
|
|
{"sdrangel.samplesource.testsource", "testSourceSettings"},
|
|
{"sdrangel.samplesource.usrp", "usrpInputSettings"},
|
|
{"sdrangel.samplesink.usrp", "usrpOutputSettings"},
|
|
{"sdrangel.samplesource.xtrx", "XtrxInputSettings"},
|
|
{"sdrangel.samplesink.xtrx", "XtrxOutputSettings"}
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_channelTypeToSettingsKey = {
|
|
{"ADSBDemod", "ADSBDemodSettings"},
|
|
{"AMDemod", "AMDemodSettings"},
|
|
{"AMMod", "AMModSettings"},
|
|
{"ATVDemod", "ATVDemodSettings"},
|
|
{"ATVMod", "ATVModSettings"},
|
|
{"BFMDemod", "BFMDemodSettings"},
|
|
{"ChannelAnalyzer", "ChannelAnalyzerSettings"},
|
|
{"DATVDemod", "DATVDemodSettings"},
|
|
{"DSDDemod", "DSDDemodSettings"},
|
|
{"FileSink", "FileSinkSettings"},
|
|
{"FileSource", "FileSourceSettings"},
|
|
{"FreeDVDemod", "FreeDVDemodSettings"},
|
|
{"FreeDVMod", "FreeDVModSettings"},
|
|
{"FreqTracker", "FreqTrackerSettings"},
|
|
{"IEEE_802_15_4_Mod", "IEEE_802_15_4_ModSettings"},
|
|
{"NFMDemod", "NFMDemodSettings"},
|
|
{"NFMMod", "NFMModSettings"},
|
|
{"PacketMod", "PacketModSettings"},
|
|
{"LocalSink", "LocalSinkSettings"},
|
|
{"LocalSource", "LocalSourceSettings"},
|
|
{"RemoteSink", "RemoteSinkSettings"},
|
|
{"RemoteSource", "RemoteSourceSettings"},
|
|
{"SSBMod", "SSBModSettings"},
|
|
{"SSBDemod", "SSBDemodSettings"},
|
|
{"UDPSink", "UDPSourceSettings"},
|
|
{"UDPSource", "UDPSinkSettings"},
|
|
{"WFMDemod", "WFMDemodSettings"},
|
|
{"WFMMod", "WFMModSettings"}
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_channelTypeToActionsKey = {
|
|
{"FileSink", "FileSinkActions"},
|
|
{"FileSource", "FileSourceActions"},
|
|
{"IEEE_802_15_4_Mod", "IEEE_802_15_4_ModActions"},
|
|
{"PacketMod", "PacketModActions"}
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_sourceDeviceHwIdToSettingsKey = {
|
|
{"Airspy", "airspySettings"},
|
|
{"AirspyHF", "airspyHFSettings"},
|
|
{"BladeRF1", "bladeRF1InputSettings"},
|
|
{"BladeRF2", "bladeRF2InputSettings"},
|
|
{"FCDPro", "fcdProSettings"},
|
|
{"FCDPro+", "fcdProPlusSettings"},
|
|
{"FileInput", "fileInputSettings"},
|
|
{"HackRF", "hackRFInputSettings"},
|
|
{"KiwiSDR", "kiwiSDRSettings"},
|
|
{"LimeSDR", "limeSdrInputSettings"},
|
|
{"LocalInput", "localInputSettings"},
|
|
{"Perseus", "perseusSettings"},
|
|
{"PlutoSDR", "plutoSdrInputSettings"},
|
|
{"RTLSDR", "rtlSdrSettings"},
|
|
{"RemoteInput", "remoteInputSettings"},
|
|
{"SDRplay1", "sdrPlaySettings"},
|
|
{"SoapySDR", "soapySDRInputSettings"},
|
|
{"TestSource", "testSourceSettings"},
|
|
{"USRP", "usrpInputSettings"},
|
|
{"XTRX", "XtrxInputSettings"}
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_sourceDeviceHwIdToActionsKey = {
|
|
{"Airspy", "airspyActions"},
|
|
{"AirspyHF", "airspyHFActions"},
|
|
{"BladeRF1", "bladeRF1InputActions"},
|
|
{"FCDPro", "fcdProActions"},
|
|
{"FCDPro+", "fcdProPlusActions"},
|
|
{"HackRF", "hackRFInputActions"},
|
|
{"KiwiSDR", "kiwiSDRActions"},
|
|
{"LimeSDR", "limeSdrInputActions"},
|
|
{"LocalInput", "localInputActions"},
|
|
{"Perseus", "perseusActions"},
|
|
{"PlutoSDR", "plutoSdrInputActions"},
|
|
{"RemoteInput", "remoteInputActions"},
|
|
{"RTLSDR", "rtlSdrActions"},
|
|
{"SDRplay1", "sdrPlayActions"},
|
|
{"SoapySDR", "soapySDRInputActions"},
|
|
{"TestSource", "testSourceActions"},
|
|
{"USRP", "usrpSourceActions"},
|
|
{"XTRX", "xtrxInputActions"}
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_sinkDeviceHwIdToSettingsKey = {
|
|
{"BladeRF1", "bladeRF1OutputSettings"},
|
|
{"BladeRF2", "bladeRF2OutputSettings"},
|
|
{"HackRF", "hackRFOutputSettings"},
|
|
{"LimeSDR", "limeSdrOutputSettings"},
|
|
{"LocalOutput", "localOutputSettings"},
|
|
{"PlutoSDR", "plutoSdrOutputSettings"},
|
|
{"RemoteOutput", "remoteOutputSettings"},
|
|
{"SoapySDR", "soapySDROutputSettings"},
|
|
{"USRP", "usrpOutputSettings"},
|
|
{"XTRX", "xtrxOutputSettings"}
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_sinkDeviceHwIdToActionsKey = {
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_mimoDeviceHwIdToSettingsKey= {
|
|
{"BladeRF2", "bladeRF2MIMOSettings"},
|
|
{"TestMI", "testMISettings"},
|
|
{"TestMOSync", "testMOSyncSettings"}
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_mimoDeviceHwIdToActionsKey= {
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_featureTypeToSettingsKey = {
|
|
{"GS232Controller", "GS232ControllerSettings"},
|
|
{"SimplePTT", "SimplePTTSettings"},
|
|
{"RigCtlServer", "RigCtlServerSettings"}
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_featureTypeToActionsKey = {
|
|
{"SimplePTT", "SimplePTTActions"}
|
|
};
|
|
|
|
const QMap<QString, QString> WebAPIRequestMapper::m_featureURIToSettingsKey = {
|
|
{"sdrangel.feature.gs232controller", "GS232ControllerSettings"},
|
|
{"sdrangel.feature.simpleptt", "SimplePTTSettings"},
|
|
{"sdrangel.feature.rigctlserver", "RigCtlServerSettings"}
|
|
};
|
|
|
|
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::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::instanceAMBESerialURL) {
|
|
instanceAMBESerialService(request, response);
|
|
} else if (path == WebAPIAdapterInterface::instanceAMBEDevicesURL) {
|
|
instanceAMBEDevicesService(request, response);
|
|
} else if (path == WebAPIAdapterInterface::instanceLimeRFESerialURL) {
|
|
instanceLimeRFESerialService(request, response);
|
|
} else if (path == WebAPIAdapterInterface::instanceLimeRFEConfigURL) {
|
|
instanceLimeRFEConfigService(request, response);
|
|
} else if (path == WebAPIAdapterInterface::instanceLimeRFERunURL) {
|
|
instanceLimeRFERunService(request, response);
|
|
} else if (path == WebAPIAdapterInterface::instanceLimeRFEPowerURL) {
|
|
instanceLimeRFEPowerService(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::instanceDeviceSetsURL) {
|
|
instanceDeviceSetsService(request, response);
|
|
} else if (path == WebAPIAdapterInterface::instanceDeviceSetURL) {
|
|
instanceDeviceSetService(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::devicesetFocusURLRe)) {
|
|
devicesetFocusService(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::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::featuresetURLRe)) {
|
|
featuresetService(std::string(desc_match[1]), request, response);
|
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureURLRe)) {
|
|
featuresetFeatureService(std::string(desc_match[1]), request, response);
|
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureIndexURLRe)) {
|
|
featuresetFeatureIndexService(std::string(desc_match[1]), std::string(desc_match[2]), request, response);
|
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureRunURLRe)) {
|
|
featuresetFeatureRunService(std::string(desc_match[1]), std::string(desc_match[2]), request, response);
|
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureSettingsURLRe)) {
|
|
featuresetFeatureSettingsService(std::string(desc_match[1]), std::string(desc_match[2]), request, response);
|
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureReportURLRe)) {
|
|
featuresetFeatureReportService(std::string(desc_match[1]), std::string(desc_match[2]), request, response);
|
|
} else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::featuresetFeatureActionsURLRe)) {
|
|
featuresetFeatureActionsService(std::string(desc_match[1]), std::string(desc_match[2]), 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 occured 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::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::instanceAMBESerialService(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::SWGDVSerialDevices normalResponse;
|
|
|
|
int status = m_adapter->instanceAMBESerialGet(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::instanceAMBEDevicesService(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::SWGAMBEDevices normalResponse;
|
|
|
|
int status = m_adapter->instanceAMBEDevicesGet(normalResponse, errorResponse);
|
|
response.setStatus(status);
|
|
|
|
if (status/100 == 2) {
|
|
response.write(normalResponse.asJson().toUtf8());
|
|
} else {
|
|
response.write(errorResponse.asJson().toUtf8());
|
|
}
|
|
}
|
|
else if ((request.getMethod() == "PATCH") || (request.getMethod() == "PUT"))
|
|
{
|
|
SWGSDRangel::SWGAMBEDevices query;
|
|
SWGSDRangel::SWGAMBEDevices normalResponse;
|
|
QString jsonStr = request.getBody();
|
|
QJsonObject jsonObject;
|
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response))
|
|
{
|
|
if (validateAMBEDevices(query, jsonObject))
|
|
{
|
|
int status;
|
|
|
|
if (request.getMethod() == "PATCH") {
|
|
status = m_adapter->instanceAMBEDevicesPatch(query, normalResponse, errorResponse);
|
|
} else {
|
|
status = m_adapter->instanceAMBEDevicesPut(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::SWGSuccessResponse normalResponse;
|
|
|
|
int status = m_adapter->instanceAMBEDevicesDelete(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::instanceLimeRFESerialService(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::SWGLimeRFEDevices normalResponse;
|
|
|
|
int status = m_adapter->instanceLimeRFESerialGet(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::instanceLimeRFEConfigService(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")
|
|
{
|
|
QByteArray serialStr = request.getParameter("serial");
|
|
SWGSDRangel::SWGLimeRFESettings normalResponse;
|
|
|
|
int status = m_adapter->instanceLimeRFEConfigGet(serialStr, 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::SWGLimeRFESettings query;
|
|
SWGSDRangel::SWGSuccessResponse normalResponse;
|
|
QString jsonStr = request.getBody();
|
|
QJsonObject jsonObject;
|
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response))
|
|
{
|
|
QStringList limeRFESettingsKeys;
|
|
|
|
if (validateLimeRFEConfig(query, jsonObject, limeRFESettingsKeys))
|
|
{
|
|
if (limeRFESettingsKeys.contains("devicePath"))
|
|
{
|
|
int status = m_adapter->instanceLimeRFEConfigPut(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,"LimeRFE device path expected in JSON body");
|
|
errorResponse.init();
|
|
*errorResponse.getMessage() = "Invalid 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(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::instanceLimeRFERunService(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::SWGLimeRFESettings query;
|
|
QString jsonStr = request.getBody();
|
|
QJsonObject jsonObject;
|
|
|
|
if (parseJsonBody(jsonStr, jsonObject, response))
|
|
{
|
|
QStringList limeRFESettingsKeys;
|
|
|
|
if (validateLimeRFEConfig(query, jsonObject, limeRFESettingsKeys))
|
|
{
|
|
if (limeRFESettingsKeys.contains("devicePath"))
|
|
{
|
|
SWGSDRangel::SWGSuccessResponse normalResponse;
|
|
int status = m_adapter->instanceLimeRFERunPut(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,"LimeRFE device path expected in JSON body");
|
|
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(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::instanceLimeRFEPowerService(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")
|
|
{
|
|
QByteArray serialStr = request.getParameter("serial");
|
|
SWGSDRangel::SWGLimeRFEPower normalResponse;
|
|
|
|
int status = m_adapter->instanceLimeRFEPowerGet(serialStr, 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::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::SWGPresetImport 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::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::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::devicesetFocusService(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() == "PATCH")
|
|
{
|
|
SWGSDRangel::SWGSuccessResponse normalResponse;
|
|
int status = m_adapter->devicesetFocusPatch(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::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::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::featuresetService(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::SWGFeatureSet normalResponse;
|
|
int deviceSetIndex = boost::lexical_cast<int>(indexStr);
|
|
int status = m_adapter->featuresetGet(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::featuresetFeatureService(
|
|
const std::string& featureSetIndexStr,
|
|
qtwebapp::HttpRequest& request,
|
|
qtwebapp::HttpResponse& response)
|
|
{
|
|
SWGSDRangel::SWGErrorResponse errorResponse;
|
|
response.setHeader("Content-Type", "application/json");
|
|
response.setHeader("Access-Control-Allow-Origin", "*");
|
|
|
|
try
|
|
{
|
|
int featureSetIndex = boost::lexical_cast<int>(featureSetIndexStr);
|
|
|
|
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(featureSetIndex, 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::featuresetFeatureIndexService(
|
|
const std::string& featureSetIndexStr,
|
|
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 featureSetIndex = boost::lexical_cast<int>(featureSetIndexStr);
|
|
int featureIndex = boost::lexical_cast<int>(featureIndexStr);
|
|
|
|
if (request.getMethod() == "DELETE")
|
|
{
|
|
SWGSDRangel::SWGSuccessResponse normalResponse;
|
|
int status = m_adapter->featuresetFeatureDelete(featureSetIndex, 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& featureSetIndexStr,
|
|
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 featureSetIndex = boost::lexical_cast<int>(featureSetIndexStr);
|
|
int featureIndex = boost::lexical_cast<int>(featureIndexStr);
|
|
|
|
if (request.getMethod() == "GET")
|
|
{
|
|
SWGSDRangel::SWGDeviceState normalResponse;
|
|
int status = m_adapter->featuresetFeatureRunGet(featureSetIndex, 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(featureSetIndex, 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(featureSetIndex, 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& featureSetIndexStr,
|
|
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 featureSetIndex = boost::lexical_cast<int>(featureSetIndexStr);
|
|
int featureIndex = boost::lexical_cast<int>(featureIndexStr);
|
|
|
|
if (request.getMethod() == "GET")
|
|
{
|
|
SWGSDRangel::SWGFeatureSettings normalResponse;
|
|
resetFeatureSettings(normalResponse);
|
|
int status = m_adapter->featuresetFeatureSettingsGet(featureSetIndex, 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(
|
|
featureSetIndex,
|
|
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& featureSetIndexStr,
|
|
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 featureSetIndex = boost::lexical_cast<int>(featureSetIndexStr);
|
|
int featureIndex = boost::lexical_cast<int>(featureIndexStr);
|
|
|
|
if (request.getMethod() == "GET")
|
|
{
|
|
SWGSDRangel::SWGFeatureReport normalResponse;
|
|
resetFeatureReport(normalResponse);
|
|
int status = m_adapter->featuresetFeatureReportGet(featureSetIndex, 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& featureSetIndexStr,
|
|
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 featureSetIndex = boost::lexical_cast<int>(featureSetIndexStr);
|
|
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(
|
|
featureSetIndex,
|
|
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());
|
|
}
|
|
}
|
|
|
|
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::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::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 (m_sourceDeviceHwIdToSettingsKey.contains(*deviceHwType)) {
|
|
deviceSettingsKey = m_sourceDeviceHwIdToSettingsKey[*deviceHwType];
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
else if (deviceSettings.getDirection() == 1) // sink
|
|
{
|
|
if (m_sinkDeviceHwIdToSettingsKey.contains(*deviceHwType)) {
|
|
deviceSettingsKey = m_sinkDeviceHwIdToSettingsKey[*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 (m_sourceDeviceHwIdToSettingsKey.contains(*deviceHwType)) {
|
|
deviceActionsKey = m_sourceDeviceHwIdToActionsKey[*deviceHwType];
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
else if (deviceActions.getDirection() == 1) // sink
|
|
{
|
|
if (m_sinkDeviceHwIdToSettingsKey.contains(*deviceHwType)) {
|
|
deviceActionsKey = m_sinkDeviceHwIdToActionsKey[*deviceHwType];
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
else if (deviceActions.getDirection() == 2) // MIMO
|
|
{
|
|
if (m_mimoDeviceHwIdToSettingsKey.contains(*deviceHwType)) {
|
|
deviceActionsKey = 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 (m_channelTypeToSettingsKey.contains(*channelType)) {
|
|
return getChannelSettings(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 (m_channelTypeToActionsKey.contains(*channelType)) {
|
|
return getChannelActions(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 (m_featureTypeToSettingsKey.contains(*featureType)) {
|
|
return getFeatureSettings(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 (m_featureTypeToActionsKey.contains(*featureType)) {
|
|
return getFeatureActions(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");
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool WebAPIRequestMapper::validateAMBEDevices(SWGSDRangel::SWGAMBEDevices& ambeDevices, QJsonObject& jsonObject)
|
|
{
|
|
if (jsonObject.contains("nbDevices"))
|
|
{
|
|
int nbDevices = jsonObject["nbDevices"].toInt();
|
|
|
|
if (jsonObject.contains("ambeDevices"))
|
|
{
|
|
QJsonArray ambeDevicesJson = jsonObject["ambeDevices"].toArray();
|
|
|
|
if (nbDevices != ambeDevicesJson.size()) {
|
|
return false;
|
|
}
|
|
|
|
ambeDevices.init();
|
|
ambeDevices.setNbDevices(nbDevices);
|
|
QList<SWGSDRangel::SWGAMBEDevice *> *ambeList = ambeDevices.getAmbeDevices();
|
|
|
|
for (int i = 0; i < nbDevices; i++)
|
|
{
|
|
QJsonObject ambeDeviceJson = ambeDevicesJson.at(i).toObject();
|
|
if (ambeDeviceJson.contains("deviceRef") && ambeDeviceJson.contains("delete"))
|
|
{
|
|
ambeList->push_back(new SWGSDRangel::SWGAMBEDevice());
|
|
ambeList->back()->init();
|
|
ambeList->back()->setDeviceRef(new QString(ambeDeviceJson["deviceRef"].toString()));
|
|
ambeList->back()->setDelete(ambeDeviceJson["delete"].toInt());
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool WebAPIRequestMapper::validateLimeRFEConfig(SWGSDRangel::SWGLimeRFESettings& limeRFESettings, QJsonObject& jsonObject, QStringList& limeRFESettingsKeys)
|
|
{
|
|
if (jsonObject.contains("devicePath"))
|
|
{
|
|
limeRFESettings.setDevicePath(new QString(jsonObject["devicePath"].toString()));
|
|
limeRFESettingsKeys.append("devicePath");
|
|
}
|
|
if (jsonObject.contains("rxChannels"))
|
|
{
|
|
limeRFESettings.setRxChannels(jsonObject["rxChannels"].toInt());
|
|
limeRFESettingsKeys.append("rxChannels");
|
|
}
|
|
if (jsonObject.contains("rxWidebandChannel"))
|
|
{
|
|
limeRFESettings.setRxWidebandChannel(jsonObject["rxWidebandChannel"].toInt());
|
|
limeRFESettingsKeys.append("rxWidebandChannel");
|
|
}
|
|
if (jsonObject.contains("rxHAMChannel"))
|
|
{
|
|
limeRFESettings.setRxHamChannel(jsonObject["rxHAMChannel"].toInt());
|
|
limeRFESettingsKeys.append("rxHAMChannel");
|
|
}
|
|
if (jsonObject.contains("rxCellularChannel"))
|
|
{
|
|
limeRFESettings.setRxCellularChannel(jsonObject["rxCellularChannel"].toInt());
|
|
limeRFESettingsKeys.append("rxCellularChannel");
|
|
}
|
|
if (jsonObject.contains("rxPort"))
|
|
{
|
|
limeRFESettings.setRxPort(jsonObject["rxPort"].toInt());
|
|
limeRFESettingsKeys.append("rxPort");
|
|
}
|
|
if (jsonObject.contains("attenuationFactor"))
|
|
{
|
|
limeRFESettings.setAttenuationFactor(jsonObject["attenuationFactor"].toInt());
|
|
limeRFESettingsKeys.append("attenuationFactor");
|
|
}
|
|
if (jsonObject.contains("amfmNotch"))
|
|
{
|
|
limeRFESettings.setAmfmNotch(jsonObject["amfmNotch"].toInt());
|
|
limeRFESettingsKeys.append("amfmNotch");
|
|
}
|
|
if (jsonObject.contains("txChannels"))
|
|
{
|
|
limeRFESettings.setTxChannels(jsonObject["txChannels"].toInt());
|
|
limeRFESettingsKeys.append("txChannels");
|
|
}
|
|
if (jsonObject.contains("txWidebandChannel"))
|
|
{
|
|
limeRFESettings.setTxWidebandChannel(jsonObject["txWidebandChannel"].toInt());
|
|
limeRFESettingsKeys.append("txWidebandChannel");
|
|
}
|
|
if (jsonObject.contains("txHAMChannel"))
|
|
{
|
|
limeRFESettings.setTxHamChannel(jsonObject["txHAMChannel"].toInt());
|
|
limeRFESettingsKeys.append("txHAMChannel");
|
|
}
|
|
if (jsonObject.contains("txCellularChannel"))
|
|
{
|
|
limeRFESettings.setTxCellularChannel(jsonObject["txCellularChannel"].toInt());
|
|
limeRFESettingsKeys.append("txCellularChannel");
|
|
}
|
|
if (jsonObject.contains("txPort"))
|
|
{
|
|
limeRFESettings.setTxPort(jsonObject["txPort"].toInt());
|
|
limeRFESettingsKeys.append("txPort");
|
|
}
|
|
if (jsonObject.contains("rxOn"))
|
|
{
|
|
limeRFESettings.setRxOn(jsonObject["rxOn"].toInt());
|
|
limeRFESettingsKeys.append("rxOn");
|
|
}
|
|
if (jsonObject.contains("txOn"))
|
|
{
|
|
limeRFESettings.setTxOn(jsonObject["txOn"].toInt());
|
|
limeRFESettingsKeys.append("txOn");
|
|
}
|
|
if (jsonObject.contains("swrEnable"))
|
|
{
|
|
limeRFESettings.setSwrEnable(jsonObject["swrEnable"].toInt());
|
|
limeRFESettingsKeys.append("swrEnable");
|
|
}
|
|
if (jsonObject.contains("swrSource"))
|
|
{
|
|
limeRFESettings.setSwrSource(jsonObject["swrSource"].toInt());
|
|
limeRFESettingsKeys.append("swrSource");
|
|
}
|
|
|
|
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") && m_featureURIToSettingsKey.contains(*featureURI))
|
|
{
|
|
SWGSDRangel::SWGFeatureSettings *featureSettings = new SWGSDRangel::SWGFeatureSettings();
|
|
feature->setConfig(featureSettings);
|
|
return getFeatureSettings(
|
|
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") && m_channelURIToSettingsKey.contains(*channelURI))
|
|
{
|
|
SWGSDRangel::SWGChannelSettings *channelSettings = new SWGSDRangel::SWGChannelSettings();
|
|
channel->setConfig(channelSettings);
|
|
return getChannelSettings(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();
|
|
channelSettingsKeys = settingsJsonObject.keys();
|
|
|
|
// get possible sub-keys
|
|
if (channelSettingsKeys.contains("cwKeyer"))
|
|
{
|
|
QJsonObject cwJson; // unused
|
|
appendSettingsSubKeys(settingsJsonObject, cwJson, "cwKeyer", channelSettingsKeys);
|
|
}
|
|
|
|
if (channelSettingsKey == "ADSBDemodSettings")
|
|
{
|
|
channelSettings->setAdsbDemodSettings(new SWGSDRangel::SWGADSBDemodSettings());
|
|
channelSettings->getAdsbDemodSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "AMDemodSettings")
|
|
{
|
|
channelSettings->setAmDemodSettings(new SWGSDRangel::SWGAMDemodSettings());
|
|
channelSettings->getAmDemodSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "AMModSettings")
|
|
{
|
|
channelSettings->setAmModSettings(new SWGSDRangel::SWGAMModSettings());
|
|
channelSettings->getAmModSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "ATVDemodSettings")
|
|
{
|
|
channelSettings->setAtvDemodSettings(new SWGSDRangel::SWGATVDemodSettings());
|
|
channelSettings->getAtvDemodSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "ATVModSettings")
|
|
{
|
|
channelSettings->setAtvModSettings(new SWGSDRangel::SWGATVModSettings());
|
|
channelSettings->getAtvModSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "BFMDemodSettings")
|
|
{
|
|
channelSettings->setBfmDemodSettings(new SWGSDRangel::SWGBFMDemodSettings());
|
|
channelSettings->getBfmDemodSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "ChannelAnalyzerSettings")
|
|
{
|
|
processChannelAnalyzerSettings(channelSettings, settingsJsonObject, channelSettingsKeys);
|
|
}
|
|
else if (channelSettingsKey == "DATVDemodSettings")
|
|
{
|
|
channelSettings->setDatvDemodSettings(new SWGSDRangel::SWGDATVDemodSettings());
|
|
channelSettings->getDatvDemodSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "DSDDemodSettings")
|
|
{
|
|
channelSettings->setDsdDemodSettings(new SWGSDRangel::SWGDSDDemodSettings());
|
|
channelSettings->getDsdDemodSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "FileSinkSettings")
|
|
{
|
|
channelSettings->setFileSinkSettings(new SWGSDRangel::SWGFileSinkSettings());
|
|
channelSettings->getFileSinkSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "FileSourceSettings")
|
|
{
|
|
channelSettings->setFileSourceSettings(new SWGSDRangel::SWGFileSourceSettings());
|
|
channelSettings->getFileSourceSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "FreeDVDemodSettings")
|
|
{
|
|
channelSettings->setFreeDvDemodSettings(new SWGSDRangel::SWGFreeDVDemodSettings());
|
|
channelSettings->getFreeDvDemodSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "FreeDVModSettings")
|
|
{
|
|
channelSettings->setFreeDvModSettings(new SWGSDRangel::SWGFreeDVModSettings());
|
|
channelSettings->getFreeDvModSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "FreqTrackerSettings")
|
|
{
|
|
channelSettings->setFreqTrackerSettings(new SWGSDRangel::SWGFreqTrackerSettings());
|
|
channelSettings->getFreqTrackerSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "IEEE_802_15_4_ModSettings")
|
|
{
|
|
channelSettings->setIeee802154ModSettings(new SWGSDRangel::SWGIEEE_802_15_4_ModSettings());
|
|
channelSettings->getIeee802154ModSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "NFMDemodSettings")
|
|
{
|
|
channelSettings->setNfmDemodSettings(new SWGSDRangel::SWGNFMDemodSettings());
|
|
channelSettings->getNfmDemodSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "NFMModSettings")
|
|
{
|
|
channelSettings->setNfmModSettings(new SWGSDRangel::SWGNFMModSettings());
|
|
channelSettings->getNfmModSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "LocalSinkSettings")
|
|
{
|
|
channelSettings->setLocalSinkSettings(new SWGSDRangel::SWGLocalSinkSettings());
|
|
channelSettings->getLocalSinkSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "LocalSourceSettings")
|
|
{
|
|
channelSettings->setLocalSourceSettings(new SWGSDRangel::SWGLocalSourceSettings());
|
|
channelSettings->getLocalSourceSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "PacketModSettings")
|
|
{
|
|
channelSettings->setPacketModSettings(new SWGSDRangel::SWGPacketModSettings());
|
|
channelSettings->getPacketModSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "RemoteSinkSettings")
|
|
{
|
|
channelSettings->setRemoteSinkSettings(new SWGSDRangel::SWGRemoteSinkSettings());
|
|
channelSettings->getRemoteSinkSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "RemoteSourceSettings")
|
|
{
|
|
channelSettings->setRemoteSourceSettings(new SWGSDRangel::SWGRemoteSourceSettings());
|
|
channelSettings->getRemoteSourceSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "SSBDemodSettings")
|
|
{
|
|
channelSettings->setSsbDemodSettings(new SWGSDRangel::SWGSSBDemodSettings());
|
|
channelSettings->getSsbDemodSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "SSBModSettings")
|
|
{
|
|
channelSettings->setSsbModSettings(new SWGSDRangel::SWGSSBModSettings());
|
|
channelSettings->getSsbModSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "UDPSourceSettings")
|
|
{
|
|
channelSettings->setUdpSourceSettings(new SWGSDRangel::SWGUDPSourceSettings());
|
|
channelSettings->getUdpSourceSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "UDPSinkSettings")
|
|
{
|
|
channelSettings->setUdpSinkSettings(new SWGSDRangel::SWGUDPSinkSettings());
|
|
channelSettings->getUdpSinkSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "WFMDemodSettings")
|
|
{
|
|
channelSettings->setWfmDemodSettings(new SWGSDRangel::SWGWFMDemodSettings());
|
|
channelSettings->getWfmDemodSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (channelSettingsKey == "WFMModSettings")
|
|
{
|
|
channelSettings->setWfmModSettings(new SWGSDRangel::SWGWFMModSettings());
|
|
channelSettings->getWfmModSettings()->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 == "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 == "IEEE_802_15_4_ModActions")
|
|
{
|
|
channelActions->setIeee802154ModActions(new SWGSDRangel::SWGIEEE_802_15_4_ModActions());
|
|
channelActions->getIeee802154ModActions()->fromJsonObject(actionsJsonObject);
|
|
}
|
|
else if (channelActionsKey == "PacketModActions")
|
|
{
|
|
channelActions->setPacketModActions(new SWGSDRangel::SWGPacketModActions());
|
|
channelActions->getPacketModActions()->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") && m_deviceIdToSettingsKey.contains(*deviceId))
|
|
{
|
|
SWGSDRangel::SWGDeviceSettings *deviceSettings = new SWGSDRangel::SWGDeviceSettings();
|
|
device->setConfig(deviceSettings);
|
|
return getDeviceSettings(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();
|
|
deviceSettingsKeys = settingsJsonObject.keys();
|
|
|
|
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 == "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 == "bladeRF2InputSettings")
|
|
{
|
|
deviceSettings->setBladeRf2OutputSettings(new SWGSDRangel::SWGBladeRF2OutputSettings());
|
|
deviceSettings->getBladeRf2OutputSettings()->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 == "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 == "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 == "soapySDRInputSettings")
|
|
{
|
|
processSoapySDRSettings(deviceSettings, settingsJsonObject, deviceSettingsKeys, true);
|
|
// deviceSettings->setSoapySdrInputSettings(new SWGSDRangel::SWGSoapySDRInputSettings());
|
|
// deviceSettings->getSoapySdrInputSettings()->init(); // contains complex objects
|
|
// deviceSettings->getSoapySdrInputSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (deviceSettingsKey == "soapySDROutputSettings")
|
|
{
|
|
processSoapySDRSettings(deviceSettings, settingsJsonObject, deviceSettingsKeys, false);
|
|
// 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 == "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 == "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 == "remoteInputSettings")
|
|
{
|
|
deviceSettings->setRemoteInputSettings(new SWGSDRangel::SWGRemoteInputSettings());
|
|
deviceSettings->getRemoteInputSettings()->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 == "xtrxInputActions")
|
|
// {
|
|
// deviceActions->setXtrxInputActions(new SWGSDRangel::SWGXtrxInputActions());
|
|
// deviceActions->getXtrxInputActions()->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();
|
|
featureSettingsKeys = settingsJsonObject.keys();
|
|
|
|
if (featureSettingsKey == "GS232ControllerSettings")
|
|
{
|
|
featureSettings->setGs232ControllerSettings(new SWGSDRangel::SWGGS232ControllerSettings());
|
|
featureSettings->getGs232ControllerSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (featureSettingsKey == "SimplePTTSettings")
|
|
{
|
|
featureSettings->setSimplePttSettings(new SWGSDRangel::SWGSimplePTTSettings());
|
|
featureSettings->getSimplePttSettings()->fromJsonObject(settingsJsonObject);
|
|
}
|
|
else if (featureSettingsKey == "RigCtlServerSettings")
|
|
{
|
|
featureSettings->setRigCtlServerSettings(new SWGSDRangel::SWGRigCtlServerSettings());
|
|
featureSettings->getRigCtlServerSettings()->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();
|
|
|
|
if (featureActionsKey == "SimplePTTActions")
|
|
{
|
|
featureActions->setSimplePttActions(new SWGSDRangel::SWGSimplePTTActions());
|
|
featureActions->getSimplePttActions()->fromJsonObject(actionsJsonObject);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void WebAPIRequestMapper::appendSettingsSubKeys(
|
|
const QJsonObject& parentSettingsJsonObject,
|
|
QJsonObject& childSettingsJsonObject,
|
|
const QString& parentKey,
|
|
QStringList& keyList)
|
|
{
|
|
childSettingsJsonObject = parentSettingsJsonObject[parentKey].toObject();
|
|
QStringList childSettingsKeys = childSettingsJsonObject.keys();
|
|
|
|
for (int i = 0; i < childSettingsKeys.size(); i++) {
|
|
keyList.append(parentKey + QString(".") + childSettingsKeys.at(i));
|
|
}
|
|
}
|
|
|
|
void WebAPIRequestMapper::appendSettingsArrayKeys(
|
|
const QJsonObject& parentSettingsJsonObject,
|
|
const QString& parentKey,
|
|
QStringList& keyList)
|
|
{
|
|
QJsonArray arrayJson = parentSettingsJsonObject[parentKey].toArray();
|
|
|
|
for (int arrayIndex = 0; arrayIndex < arrayJson.count(); arrayIndex++)
|
|
{
|
|
QJsonValue v = arrayJson.at(arrayIndex);
|
|
|
|
if (v.isObject())
|
|
{
|
|
QJsonObject itemSettingsJsonObject = v.toObject();
|
|
QStringList itemSettingsKeys = itemSettingsJsonObject.keys();
|
|
keyList.append(tr("%1[%2]").arg(parentKey).arg(arrayIndex));
|
|
|
|
for (int i = 0; i < itemSettingsKeys.size(); i++) {
|
|
keyList.append(tr("%1[%2].%3").arg(parentKey).arg(arrayIndex).arg(itemSettingsKeys[i]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void WebAPIRequestMapper::resetDeviceSettings(SWGSDRangel::SWGDeviceSettings& deviceSettings)
|
|
{
|
|
deviceSettings.cleanup();
|
|
deviceSettings.setDeviceHwType(nullptr);
|
|
deviceSettings.setAirspySettings(nullptr);
|
|
deviceSettings.setAirspyHfSettings(nullptr);
|
|
deviceSettings.setBladeRf1InputSettings(nullptr);
|
|
deviceSettings.setBladeRf1OutputSettings(nullptr);
|
|
deviceSettings.setFcdProPlusSettings(nullptr);
|
|
deviceSettings.setFcdProSettings(nullptr);
|
|
deviceSettings.setFileInputSettings(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.setSdrPlaySettings(nullptr);
|
|
deviceSettings.setTestSourceSettings(nullptr);
|
|
deviceSettings.setUsrpInputSettings(nullptr);
|
|
deviceSettings.setUsrpOutputSettings(nullptr);
|
|
}
|
|
|
|
void WebAPIRequestMapper::resetDeviceReport(SWGSDRangel::SWGDeviceReport& deviceReport)
|
|
{
|
|
deviceReport.cleanup();
|
|
deviceReport.setDeviceHwType(nullptr);
|
|
deviceReport.setAirspyHfReport(nullptr);
|
|
deviceReport.setAirspyReport(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.setSdrPlayReport(nullptr);
|
|
deviceReport.setUsrpOutputReport(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.setAdsbDemodSettings(nullptr);
|
|
channelSettings.setAmDemodSettings(nullptr);
|
|
channelSettings.setAmModSettings(nullptr);
|
|
channelSettings.setAtvModSettings(nullptr);
|
|
channelSettings.setBfmDemodSettings(nullptr);
|
|
channelSettings.setDsdDemodSettings(nullptr);
|
|
channelSettings.setIeee802154ModSettings(nullptr);
|
|
channelSettings.setNfmDemodSettings(nullptr);
|
|
channelSettings.setNfmModSettings(nullptr);
|
|
channelSettings.setPacketModSettings(nullptr);
|
|
channelSettings.setRemoteSinkSettings(nullptr);
|
|
channelSettings.setRemoteSourceSettings(nullptr);
|
|
channelSettings.setSsbDemodSettings(nullptr);
|
|
channelSettings.setSsbModSettings(nullptr);
|
|
channelSettings.setUdpSourceSettings(nullptr);
|
|
channelSettings.setUdpSinkSettings(nullptr);
|
|
channelSettings.setWfmDemodSettings(nullptr);
|
|
channelSettings.setWfmModSettings(nullptr);
|
|
}
|
|
|
|
void WebAPIRequestMapper::resetChannelReport(SWGSDRangel::SWGChannelReport& channelReport)
|
|
{
|
|
channelReport.cleanup();
|
|
channelReport.setChannelType(nullptr);
|
|
channelReport.setAdsbDemodReport(nullptr);
|
|
channelReport.setAmDemodReport(nullptr);
|
|
channelReport.setAmModReport(nullptr);
|
|
channelReport.setAtvModReport(nullptr);
|
|
channelReport.setBfmDemodReport(nullptr);
|
|
channelReport.setDsdDemodReport(nullptr);
|
|
channelReport.setNfmDemodReport(nullptr);
|
|
channelReport.setNfmModReport(nullptr);
|
|
channelReport.setIeee802154ModReport(nullptr);
|
|
channelReport.setPacketModReport(nullptr);
|
|
channelReport.setRemoteSourceReport(nullptr);
|
|
channelReport.setSsbDemodReport(nullptr);
|
|
channelReport.setSsbModReport(nullptr);
|
|
channelReport.setUdpSourceReport(nullptr);
|
|
channelReport.setUdpSinkReport(nullptr);
|
|
channelReport.setWfmDemodReport(nullptr);
|
|
channelReport.setWfmModReport(nullptr);
|
|
}
|
|
|
|
void WebAPIRequestMapper::resetChannelActions(SWGSDRangel::SWGChannelActions& channelActions)
|
|
{
|
|
channelActions.cleanup();
|
|
channelActions.setChannelType(nullptr);
|
|
channelActions.setFileSourceActions(nullptr);
|
|
channelActions.setIeee802154ModActions(nullptr);
|
|
channelActions.setPacketModActions(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.setSimplePttSettings(nullptr);
|
|
}
|
|
|
|
void WebAPIRequestMapper::resetFeatureReport(SWGSDRangel::SWGFeatureReport& featureReport)
|
|
{
|
|
featureReport.cleanup();
|
|
featureReport.setFeatureType(nullptr);
|
|
featureReport.setSimplePttReport(nullptr);
|
|
}
|
|
|
|
void WebAPIRequestMapper::resetFeatureActions(SWGSDRangel::SWGFeatureActions& featureActions)
|
|
{
|
|
featureActions.cleanup();
|
|
featureActions.setFeatureType(nullptr);
|
|
featureActions.setSimplePttActions(nullptr);
|
|
}
|
|
|
|
void WebAPIRequestMapper::processChannelAnalyzerSettings(
|
|
SWGSDRangel::SWGChannelSettings *channelSettings,
|
|
const QJsonObject& channelSettingsJson,
|
|
QStringList& channelSettingsKeys
|
|
)
|
|
{
|
|
SWGSDRangel::SWGChannelAnalyzerSettings *channelAnalyzerSettings = new SWGSDRangel::SWGChannelAnalyzerSettings();
|
|
channelSettings->setChannelAnalyzerSettings(channelAnalyzerSettings);
|
|
channelAnalyzerSettings->init();
|
|
|
|
if (channelSettingsJson.contains("bandwidth")) {
|
|
channelAnalyzerSettings->setBandwidth(channelSettingsJson["bandwidth"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("downSample")) {
|
|
channelAnalyzerSettings->setDownSample(channelSettingsJson["downSample"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("downSampleRate")) {
|
|
channelAnalyzerSettings->setDownSampleRate(channelSettingsJson["downSampleRate"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("fll")) {
|
|
channelAnalyzerSettings->setFll(channelSettingsJson["fll"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("frequency")) {
|
|
channelAnalyzerSettings->setFrequency(channelSettingsJson["frequency"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("inputType")) {
|
|
channelAnalyzerSettings->setInputType(channelSettingsJson["inputType"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("lowCutoff")) {
|
|
channelAnalyzerSettings->setLowCutoff(channelSettingsJson["lowCutoff"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("pll")) {
|
|
channelAnalyzerSettings->setPll(channelSettingsJson["pll"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("pllPskOrder")) {
|
|
channelAnalyzerSettings->setPllPskOrder(channelSettingsJson["pllPskOrder"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("rgbColor")) {
|
|
channelAnalyzerSettings->setRgbColor(channelSettingsJson["rgbColor"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("rrc")) {
|
|
channelAnalyzerSettings->setRrc(channelSettingsJson["rrc"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("rrcRolloff")) {
|
|
channelAnalyzerSettings->setRrcRolloff(channelSettingsJson["rrcRolloff"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("spanLog2")) {
|
|
channelAnalyzerSettings->setSpanLog2(channelSettingsJson["spanLog2"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("ssb")) {
|
|
channelAnalyzerSettings->setSsb(channelSettingsJson["ssb"].toInt());
|
|
}
|
|
if (channelSettingsJson.contains("title")) {
|
|
channelAnalyzerSettings->setTitle(new QString(channelSettingsJson["title"].toString()));
|
|
}
|
|
|
|
if (channelSettingsJson.contains("spectrumConfig"))
|
|
{
|
|
SWGSDRangel::SWGGLSpectrum *spectrum = new SWGSDRangel::SWGGLSpectrum();
|
|
spectrum->init();
|
|
channelAnalyzerSettings->setSpectrumConfig(spectrum);
|
|
QJsonObject spectrumJson;
|
|
appendSettingsSubKeys(channelSettingsJson, spectrumJson, "spectrumConfig", channelSettingsKeys);
|
|
spectrum->fromJsonObject(spectrumJson);
|
|
}
|
|
|
|
if (channelSettingsJson.contains("scopeConfig") && channelSettingsJson["scopeConfig"].isObject())
|
|
{
|
|
SWGSDRangel::SWGGLScope *scopeConfig = new SWGSDRangel::SWGGLScope();
|
|
scopeConfig->init();
|
|
channelAnalyzerSettings->setScopeConfig(scopeConfig);
|
|
QJsonObject scopeConfigJson;
|
|
appendSettingsSubKeys(channelSettingsJson, scopeConfigJson, "scopeConfig", channelSettingsKeys);
|
|
scopeConfig->fromJsonObject(scopeConfigJson);
|
|
|
|
if (scopeConfigJson.contains("tracesData") && scopeConfigJson["tracesData"].isArray())
|
|
{
|
|
QList<SWGSDRangel::SWGTraceData *> *tracesData = new QList<SWGSDRangel::SWGTraceData *>();
|
|
scopeConfig->setTracesData(tracesData);
|
|
QJsonArray tracesJson = scopeConfigJson["tracesData"].toArray();
|
|
|
|
for (int i = 0; i < tracesJson.size(); i++)
|
|
{
|
|
SWGSDRangel::SWGTraceData *traceData = new SWGSDRangel::SWGTraceData();
|
|
tracesData->append(traceData);
|
|
QJsonObject traceJson = tracesJson.at(i).toObject();
|
|
traceData->fromJsonObject(traceJson);
|
|
}
|
|
|
|
QStringList tracesDataKeys;
|
|
appendSettingsArrayKeys(scopeConfigJson, "tracesData", tracesDataKeys);
|
|
|
|
for (int i = 0; i < tracesDataKeys.size(); i++) {
|
|
channelSettingsKeys.append(QString("scopeConfig.") + tracesDataKeys.at(i));
|
|
}
|
|
}
|
|
|
|
if (scopeConfigJson.contains("triggersData") && scopeConfigJson["triggersData"].isArray())
|
|
{
|
|
QList<SWGSDRangel::SWGTriggerData *> *triggersData = new QList<SWGSDRangel::SWGTriggerData *>();
|
|
scopeConfig->setTriggersData(triggersData);
|
|
QJsonArray triggersJson = scopeConfigJson["triggersData"].toArray();
|
|
|
|
for (int i = 0; i < triggersJson.size(); i++)
|
|
{
|
|
SWGSDRangel::SWGTriggerData *triggerData = new SWGSDRangel::SWGTriggerData();
|
|
triggersData->append(triggerData);
|
|
QJsonObject triggerJson = triggersJson.at(i).toObject();
|
|
triggerData->fromJsonObject(triggerJson);
|
|
}
|
|
|
|
QStringList triggersDataKeys;
|
|
appendSettingsArrayKeys(scopeConfigJson, "triggersData", triggersDataKeys);
|
|
|
|
for (int i = 0; i < triggersDataKeys.size(); i++) {
|
|
channelSettingsKeys.append(QString("scopeConfig.") + triggersDataKeys.at(i));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void WebAPIRequestMapper::processSoapySDRSettings(
|
|
SWGSDRangel::SWGDeviceSettings *deviceSettings,
|
|
QJsonObject& deviceSettingsJson,
|
|
QStringList& deviceSettingsKeys,
|
|
bool inputElseOutput
|
|
)
|
|
{
|
|
if (inputElseOutput)
|
|
{
|
|
SWGSDRangel::SWGSoapySDRInputSettings *swgSoapySDRInputSettings = new SWGSDRangel::SWGSoapySDRInputSettings();
|
|
deviceSettings->setSoapySdrInputSettings(swgSoapySDRInputSettings);
|
|
swgSoapySDRInputSettings->init();
|
|
|
|
if (deviceSettingsJson.contains("centerFrequency")) {
|
|
swgSoapySDRInputSettings->setCenterFrequency(deviceSettingsJson["centerFrequency"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("LOppmTenths")) {
|
|
swgSoapySDRInputSettings->setLOppmTenths(deviceSettingsJson["LOppmTenths"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("devSampleRate")) {
|
|
swgSoapySDRInputSettings->setDevSampleRate(deviceSettingsJson["devSampleRate"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("log2Decim")) {
|
|
swgSoapySDRInputSettings->setLog2Decim(deviceSettingsJson["log2Decim"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("fcPos")) {
|
|
swgSoapySDRInputSettings->setFcPos(deviceSettingsJson["fcPos"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("softDCCorrection")) {
|
|
swgSoapySDRInputSettings->setSoftDcCorrection(deviceSettingsJson["softDCCorrection"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("softIQCorrection")) {
|
|
swgSoapySDRInputSettings->setSoftIqCorrection(deviceSettingsJson["softIQCorrection"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("transverterMode")) {
|
|
swgSoapySDRInputSettings->setTransverterMode(deviceSettingsJson["transverterMode"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("transverterDeltaFrequency")) {
|
|
swgSoapySDRInputSettings->setTransverterDeltaFrequency(deviceSettingsJson["transverterDeltaFrequency"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("antenna")) {
|
|
swgSoapySDRInputSettings->setAntenna(new QString(deviceSettingsJson["antenna"].toString()));
|
|
}
|
|
if (deviceSettingsJson.contains("bandwidth")) {
|
|
swgSoapySDRInputSettings->setBandwidth(deviceSettingsJson["bandwidth"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("globalGain")) {
|
|
swgSoapySDRInputSettings->setGlobalGain(deviceSettingsJson["globalGain"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("autoGain")) {
|
|
swgSoapySDRInputSettings->setAutoGain(deviceSettingsJson["autoGain"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("autoDCCorrection")) {
|
|
swgSoapySDRInputSettings->setAutoDcCorrection(deviceSettingsJson["autoDCCorrection"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("autoIQCorrection")) {
|
|
swgSoapySDRInputSettings->setAutoIqCorrection(deviceSettingsJson["autoIQCorrection"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("dcCorrection"))
|
|
{
|
|
SWGSDRangel::SWGComplex *swgComplex = new SWGSDRangel::SWGComplex;
|
|
swgSoapySDRInputSettings->setDcCorrection(swgComplex);
|
|
QJsonObject complexJson = deviceSettingsJson["dcCorrection"].toObject();
|
|
|
|
if (complexJson.contains("real")) {
|
|
swgComplex->setReal(complexJson["real"].toDouble());
|
|
}
|
|
if (complexJson.contains("imag")) {
|
|
swgComplex->setImag(complexJson["imag"].toDouble());
|
|
}
|
|
}
|
|
if (deviceSettingsJson.contains("iqCorrection"))
|
|
{
|
|
SWGSDRangel::SWGComplex *swgComplex = new SWGSDRangel::SWGComplex;
|
|
swgSoapySDRInputSettings->setIqCorrection(swgComplex);
|
|
QJsonObject complexJson = deviceSettingsJson["iqCorrection"].toObject();
|
|
|
|
if (complexJson.contains("real")) {
|
|
swgComplex->setReal(complexJson["real"].toDouble());
|
|
}
|
|
if (complexJson.contains("imag")) {
|
|
swgComplex->setImag(complexJson["imag"].toDouble());
|
|
}
|
|
}
|
|
if (deviceSettingsJson.contains("useReverseAPI")) {
|
|
swgSoapySDRInputSettings->setUseReverseApi(deviceSettingsJson["useReverseAPI"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("reverseAPIAddress")) {
|
|
swgSoapySDRInputSettings->setReverseApiAddress(new QString(deviceSettingsJson["reverseAPIAddress"].toString()));
|
|
}
|
|
if (deviceSettingsJson.contains("reverseAPIPort")) {
|
|
swgSoapySDRInputSettings->setReverseApiPort(deviceSettingsJson["reverseAPIPort"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("reverseAPIDeviceIndex")) {
|
|
swgSoapySDRInputSettings->setReverseApiDeviceIndex(deviceSettingsJson["reverseAPIDeviceIndex"].toInt());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SWGSDRangel::SWGSoapySDROutputSettings *swgSoapySDROutputSettings = new SWGSDRangel::SWGSoapySDROutputSettings();
|
|
deviceSettings->setSoapySdrOutputSettings(swgSoapySDROutputSettings);
|
|
swgSoapySDROutputSettings->init();
|
|
|
|
if (deviceSettingsJson.contains("centerFrequency")) {
|
|
swgSoapySDROutputSettings->setCenterFrequency(deviceSettingsJson["centerFrequency"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("LOppmTenths")) {
|
|
swgSoapySDROutputSettings->setLOppmTenths(deviceSettingsJson["LOppmTenths"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("devSampleRate")) {
|
|
swgSoapySDROutputSettings->setDevSampleRate(deviceSettingsJson["devSampleRate"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("log2Interp")) {
|
|
swgSoapySDROutputSettings->setLog2Interp(deviceSettingsJson["log2Interp"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("transverterMode")) {
|
|
swgSoapySDROutputSettings->setTransverterMode(deviceSettingsJson["transverterMode"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("transverterDeltaFrequency")) {
|
|
swgSoapySDROutputSettings->setTransverterDeltaFrequency(deviceSettingsJson["transverterDeltaFrequency"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("antenna")) {
|
|
swgSoapySDROutputSettings->setAntenna(new QString(deviceSettingsJson["antenna"].toString()));
|
|
}
|
|
if (deviceSettingsJson.contains("bandwidth")) {
|
|
swgSoapySDROutputSettings->setBandwidth(deviceSettingsJson["bandwidth"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("globalGain")) {
|
|
swgSoapySDROutputSettings->setGlobalGain(deviceSettingsJson["globalGain"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("autoGain")) {
|
|
swgSoapySDROutputSettings->setAutoGain(deviceSettingsJson["autoGain"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("autoDCCorrection")) {
|
|
swgSoapySDROutputSettings->setAutoDcCorrection(deviceSettingsJson["autoDCCorrection"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("autoIQCorrection")) {
|
|
swgSoapySDROutputSettings->setAutoIqCorrection(deviceSettingsJson["autoIQCorrection"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("dcCorrection"))
|
|
{
|
|
SWGSDRangel::SWGComplex *swgComplex = new SWGSDRangel::SWGComplex;
|
|
swgSoapySDROutputSettings->setDcCorrection(swgComplex);
|
|
QJsonObject complexJson = deviceSettingsJson["dcCorrection"].toObject();
|
|
|
|
if (complexJson.contains("real")) {
|
|
swgComplex->setReal(complexJson["real"].toDouble());
|
|
}
|
|
if (complexJson.contains("imag")) {
|
|
swgComplex->setImag(complexJson["imag"].toDouble());
|
|
}
|
|
}
|
|
if (deviceSettingsJson.contains("iqCorrection"))
|
|
{
|
|
SWGSDRangel::SWGComplex *swgComplex = new SWGSDRangel::SWGComplex;
|
|
swgSoapySDROutputSettings->setIqCorrection(swgComplex);
|
|
QJsonObject complexJson = deviceSettingsJson["iqCorrection"].toObject();
|
|
|
|
if (complexJson.contains("real")) {
|
|
swgComplex->setReal(complexJson["real"].toDouble());
|
|
}
|
|
if (complexJson.contains("imag")) {
|
|
swgComplex->setImag(complexJson["imag"].toDouble());
|
|
}
|
|
}
|
|
if (deviceSettingsJson.contains("useReverseAPI")) {
|
|
swgSoapySDROutputSettings->setUseReverseApi(deviceSettingsJson["useReverseAPI"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("reverseAPIAddress")) {
|
|
swgSoapySDROutputSettings->setReverseApiAddress(new QString(deviceSettingsJson["reverseAPIAddress"].toString()));
|
|
}
|
|
if (deviceSettingsJson.contains("reverseAPIPort")) {
|
|
swgSoapySDROutputSettings->setReverseApiPort(deviceSettingsJson["reverseAPIPort"].toInt());
|
|
}
|
|
if (deviceSettingsJson.contains("reverseAPIDeviceIndex")) {
|
|
swgSoapySDROutputSettings->setReverseApiDeviceIndex(deviceSettingsJson["reverseAPIDeviceIndex"].toInt());
|
|
}
|
|
}
|
|
|
|
if (deviceSettingsKeys.contains("deviceArgSettings"))
|
|
{
|
|
QList<SWGSDRangel::SWGArgValue *> *swgArgSettings = new QList<SWGSDRangel::SWGArgValue *>;
|
|
QJsonArray argsJson = deviceSettingsJson["deviceArgSettings"].toArray();
|
|
|
|
if (inputElseOutput) {
|
|
deviceSettings->getSoapySdrInputSettings()->setDeviceArgSettings(swgArgSettings);
|
|
} else {
|
|
deviceSettings->getSoapySdrOutputSettings()->setDeviceArgSettings(swgArgSettings);
|
|
}
|
|
|
|
for (int i = 0; i < argsJson.count(); i++)
|
|
{
|
|
SWGSDRangel::SWGArgValue *argValue = new SWGSDRangel::SWGArgValue();
|
|
swgArgSettings->append(argValue);
|
|
QJsonObject argValueJson = argsJson.at(i).toObject();
|
|
argValue->fromJsonObject(argValueJson);
|
|
}
|
|
|
|
appendSettingsArrayKeys(deviceSettingsJson, "deviceArgSettings", deviceSettingsKeys);
|
|
}
|
|
|
|
if (deviceSettingsKeys.contains("individualGains"))
|
|
{
|
|
QList<SWGSDRangel::SWGArgValue *> *swgIndividualGains = new QList<SWGSDRangel::SWGArgValue *>;
|
|
QJsonArray argsJson = deviceSettingsJson["individualGains"].toArray();
|
|
|
|
if (inputElseOutput) {
|
|
deviceSettings->getSoapySdrInputSettings()->setIndividualGains(swgIndividualGains);
|
|
} else {
|
|
deviceSettings->getSoapySdrOutputSettings()->setIndividualGains(swgIndividualGains);
|
|
}
|
|
|
|
for (int i = 0; i < argsJson.count(); i++)
|
|
{
|
|
SWGSDRangel::SWGArgValue *argValue = new SWGSDRangel::SWGArgValue();
|
|
swgIndividualGains->append(argValue);
|
|
QJsonObject argValueJson = argsJson.at(i).toObject();
|
|
argValue->fromJsonObject(argValueJson);
|
|
}
|
|
|
|
appendSettingsArrayKeys(deviceSettingsJson, "individualGains", deviceSettingsKeys);
|
|
}
|
|
|
|
if (deviceSettingsKeys.contains("streamArgSettings"))
|
|
{
|
|
QList<SWGSDRangel::SWGArgValue *> *swgStreamArgSettings = new QList<SWGSDRangel::SWGArgValue *>;
|
|
QJsonArray argsJson = deviceSettingsJson["streamArgSettings"].toArray();
|
|
|
|
if (inputElseOutput) {
|
|
deviceSettings->getSoapySdrInputSettings()->setStreamArgSettings(swgStreamArgSettings);
|
|
} else {
|
|
deviceSettings->getSoapySdrOutputSettings()->setStreamArgSettings(swgStreamArgSettings);
|
|
}
|
|
|
|
for (int i = 0; i < argsJson.count(); i++)
|
|
{
|
|
SWGSDRangel::SWGArgValue *argValue = new SWGSDRangel::SWGArgValue();
|
|
swgStreamArgSettings->append(argValue);
|
|
QJsonObject argValueJson = argsJson.at(i).toObject();
|
|
argValue->fromJsonObject(argValueJson);
|
|
}
|
|
|
|
appendSettingsArrayKeys(deviceSettingsJson, "streamArgSettings", deviceSettingsKeys);
|
|
}
|
|
|
|
if (deviceSettingsKeys.contains("tunableElements"))
|
|
{
|
|
QList<SWGSDRangel::SWGArgValue *> *swgTunableElements = new QList<SWGSDRangel::SWGArgValue *>;
|
|
QJsonArray argsJson = deviceSettingsJson["tunableElements"].toArray();
|
|
|
|
if (inputElseOutput) {
|
|
deviceSettings->getSoapySdrInputSettings()->setTunableElements(swgTunableElements);
|
|
} else {
|
|
deviceSettings->getSoapySdrOutputSettings()->setTunableElements(swgTunableElements);
|
|
}
|
|
|
|
for (int i = 0; i < argsJson.count(); i++)
|
|
{
|
|
SWGSDRangel::SWGArgValue *argValue = new SWGSDRangel::SWGArgValue();
|
|
swgTunableElements->append(argValue);
|
|
QJsonObject argValueJson = argsJson.at(i).toObject();
|
|
argValue->fromJsonObject(argValueJson);
|
|
}
|
|
|
|
appendSettingsArrayKeys(deviceSettingsJson, "tunableElements", deviceSettingsKeys);
|
|
}
|
|
}
|