SDRAngel  4.11.5
Developer docs for <a href="https://github.com/f4exb/sdrangel">SDRangel<\a>, an Open Source Qt5 / OpenGL 3.0+ SDR and signal analyzer frontend to various hardware.
webapirequestmapper.cpp
Go to the documentation of this file.
1 // Copyright (C) 2017 Edouard Griffiths, F4EXB. //
3 // //
4 // Swagger server adapter interface //
5 // //
6 // This program is free software; you can redistribute it and/or modify //
7 // it under the terms of the GNU General Public License as published by //
8 // the Free Software Foundation as version 3 of the License, or //
9 // (at your option) any later version. //
10 // //
11 // This program is distributed in the hope that it will be useful, //
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of //
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
14 // GNU General Public License V3 for more details. //
15 // //
16 // You should have received a copy of the GNU General Public License //
17 // along with this program. If not, see <http://www.gnu.org/licenses/>. //
19 
20 #include <QDirIterator>
21 #include <QJsonDocument>
22 #include <QJsonArray>
23 
24 #include <boost/lexical_cast.hpp>
25 
26 #include "httpdocrootsettings.h"
27 #include "webapirequestmapper.h"
28 #include "SWGInstanceSummaryResponse.h"
29 #include "SWGInstanceConfigResponse.h"
30 #include "SWGInstanceDevicesResponse.h"
31 #include "SWGInstanceChannelsResponse.h"
32 #include "SWGAudioDevices.h"
33 #include "SWGLocationInformation.h"
34 #include "SWGDVSerialDevices.h"
35 #include "SWGAMBEDevices.h"
36 #include "SWGPresets.h"
37 #include "SWGPresetTransfer.h"
38 #include "SWGPresetIdentifier.h"
39 #include "SWGPresetImport.h"
40 #include "SWGPresetExport.h"
41 #include "SWGDeviceSettings.h"
42 #include "SWGDeviceState.h"
43 #include "SWGDeviceReport.h"
44 #include "SWGChannelsDetail.h"
45 #include "SWGChannelSettings.h"
46 #include "SWGChannelReport.h"
47 #include "SWGSuccessResponse.h"
48 #include "SWGErrorResponse.h"
49 
50 WebAPIRequestMapper::WebAPIRequestMapper(QObject* parent) :
51  HttpRequestHandler(parent),
52  m_adapter(0)
53 {
54 #ifndef _MSC_VER
55  Q_INIT_RESOURCE(webapi);
56 #endif
57  qtwebapp::HttpDocrootSettings docrootSettings;
58  docrootSettings.path = ":/webapi";
59  m_staticFileController = new qtwebapp::StaticFileController(docrootSettings, parent);
60 }
61 
62 WebAPIRequestMapper::~WebAPIRequestMapper()
63 {
64  delete m_staticFileController;
65 #ifndef _MSC_VER
66  Q_CLEANUP_RESOURCE(webapi);
67 #endif
68 }
69 
70 void WebAPIRequestMapper::service(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
71 {
72  if (m_adapter == 0) // format service unavailable if adapter is null
73  {
74  SWGSDRangel::SWGErrorResponse errorResponse;
75  response.setHeader("Content-Type", "application/json");
76  response.setHeader("Access-Control-Allow-Origin", "*");
77  response.setStatus(500,"Service not available");
78 
79  errorResponse.init();
80  *errorResponse.getMessage() = "Service not available";
81  response.write(errorResponse.asJson().toUtf8());
82  }
83  else // normal processing
84  {
85  QByteArray path=request.getPath();
86 
87  // Handle pre-flight requests
88  if (request.getMethod() == "OPTIONS")
89  {
90  qDebug("WebAPIRequestMapper::service: method OPTIONS: assume pre-flight");
91  response.setHeader("Access-Control-Allow-Origin", "*");
92  response.setHeader("Access-Control-Allow-Headers", "*");
93  response.setHeader("Access-Control-Allow-Methods", "*");
94  response.setStatus(200, "OK");
95  return;
96  }
97 
98  if (path == WebAPIAdapterInterface::instanceSummaryURL) {
99  instanceSummaryService(request, response);
100  } else if (path == WebAPIAdapterInterface::instanceConfigURL) {
101  instanceConfigService(request, response);
102  } else if (path == WebAPIAdapterInterface::instanceDevicesURL) {
103  instanceDevicesService(request, response);
104  } else if (path == WebAPIAdapterInterface::instanceChannelsURL) {
105  instanceChannelsService(request, response);
106  } else if (path == WebAPIAdapterInterface::instanceLoggingURL) {
107  instanceLoggingService(request, response);
108  } else if (path == WebAPIAdapterInterface::instanceAudioURL) {
109  instanceAudioService(request, response);
110  } else if (path == WebAPIAdapterInterface::instanceAudioInputParametersURL) {
111  instanceAudioInputParametersService(request, response);
112  } else if (path == WebAPIAdapterInterface::instanceAudioOutputParametersURL) {
113  instanceAudioOutputParametersService(request, response);
114  } else if (path == WebAPIAdapterInterface::instanceAudioInputCleanupURL) {
115  instanceAudioInputCleanupService(request, response);
116  } else if (path == WebAPIAdapterInterface::instanceAudioOutputCleanupURL) {
117  instanceAudioOutputCleanupService(request, response);
118  } else if (path == WebAPIAdapterInterface::instanceLocationURL) {
119  instanceLocationService(request, response);
120  } else if (path == WebAPIAdapterInterface::instanceAMBESerialURL) {
121  instanceAMBESerialService(request, response);
122  } else if (path == WebAPIAdapterInterface::instanceAMBEDevicesURL) {
123  instanceAMBEDevicesService(request, response);
124  } else if (path == WebAPIAdapterInterface::instancePresetsURL) {
125  instancePresetsService(request, response);
126  } else if (path == WebAPIAdapterInterface::instancePresetURL) {
127  instancePresetService(request, response);
128  } else if (path == WebAPIAdapterInterface::instancePresetFileURL) {
129  instancePresetFileService(request, response);
130  } else if (path == WebAPIAdapterInterface::instanceDeviceSetsURL) {
131  instanceDeviceSetsService(request, response);
132  } else if (path == WebAPIAdapterInterface::instanceDeviceSetURL) {
133  instanceDeviceSetService(request, response);
134  }
135  else
136  {
137  std::smatch desc_match;
138  std::string pathStr(path.constData(), path.length());
139 
140  if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetURLRe)) {
141  devicesetService(std::string(desc_match[1]), request, response);
142  } else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceURLRe)) {
143  devicesetDeviceService(std::string(desc_match[1]), request, response);
144  } else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetFocusURLRe)) {
145  devicesetFocusService(std::string(desc_match[1]), request, response);
146  } else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceSettingsURLRe)) {
147  devicesetDeviceSettingsService(std::string(desc_match[1]), request, response);
148  } else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceRunURLRe)) {
149  devicesetDeviceRunService(std::string(desc_match[1]), request, response);
150  } else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetDeviceReportURLRe)) {
151  devicesetDeviceReportService(std::string(desc_match[1]), request, response);
152  } else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelsReportURLRe)) {
153  devicesetChannelsReportService(std::string(desc_match[1]), request, response);
154  } else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelURLRe)) {
155  devicesetChannelService(std::string(desc_match[1]), request, response);
156  } else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelIndexURLRe)) {
157  devicesetChannelIndexService(std::string(desc_match[1]), std::string(desc_match[2]), request, response);
158  } else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelSettingsURLRe)) {
159  devicesetChannelSettingsService(std::string(desc_match[1]), std::string(desc_match[2]), request, response);
160  } else if (std::regex_match(pathStr, desc_match, WebAPIAdapterInterface::devicesetChannelReportURLRe)) {
161  devicesetChannelReportService(std::string(desc_match[1]), std::string(desc_match[2]), request, response);
162  }
163  else // serve static documentation pages
164  {
165  m_staticFileController->service(request, response);
166  }
167 
168 // QDirIterator it(":", QDirIterator::Subdirectories);
169 // while (it.hasNext()) {
170 // qDebug() << "WebAPIRequestMapper::service: " << it.next();
171 // }
172 
173  }
174  }
175 }
176 
177 void WebAPIRequestMapper::instanceSummaryService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
178 {
179  SWGSDRangel::SWGErrorResponse errorResponse;
180  response.setHeader("Content-Type", "application/json");
181  response.setHeader("Access-Control-Allow-Origin", "*");
182 
183  if (request.getMethod() == "GET")
184  {
185  SWGSDRangel::SWGInstanceSummaryResponse normalResponse;
186 
187  int status = m_adapter->instanceSummary(normalResponse, errorResponse);
188  response.setStatus(status);
189 
190  if (status/100 == 2) {
191  response.write(normalResponse.asJson().toUtf8());
192  } else {
193  response.write(errorResponse.asJson().toUtf8());
194  }
195  }
196  else if (request.getMethod() == "DELETE")
197  {
198  SWGSDRangel::SWGSuccessResponse normalResponse;
199 
200  int status = m_adapter->instanceDelete(normalResponse, errorResponse);
201  response.setStatus(status);
202 
203  if (status/100 == 2) {
204  response.write(normalResponse.asJson().toUtf8());
205  } else {
206  response.write(errorResponse.asJson().toUtf8());
207  }
208  }
209  else
210  {
211  response.setStatus(405,"Invalid HTTP method");
212  errorResponse.init();
213  *errorResponse.getMessage() = "Invalid HTTP method";
214  response.write(errorResponse.asJson().toUtf8());
215  }
216 }
217 
218 void WebAPIRequestMapper::instanceConfigService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
219 {
220  SWGSDRangel::SWGErrorResponse errorResponse;
221  response.setHeader("Content-Type", "application/json");
222  response.setHeader("Access-Control-Allow-Origin", "*");
223 
224  if (request.getMethod() == "GET")
225  {
226  SWGSDRangel::SWGInstanceConfigResponse normalResponse;
227  int status = m_adapter->instanceConfigGet(normalResponse, errorResponse);
228  response.setStatus(status);
229 
230  if (status/100 == 2) {
231  response.write(normalResponse.asJson().toUtf8());
232  } else {
233  response.write(errorResponse.asJson().toUtf8());
234  }
235  }
236 }
237 
238 void WebAPIRequestMapper::instanceDevicesService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
239 {
240  SWGSDRangel::SWGInstanceDevicesResponse normalResponse;
241  SWGSDRangel::SWGErrorResponse errorResponse;
242  response.setHeader("Content-Type", "application/json");
243  response.setHeader("Access-Control-Allow-Origin", "*");
244 
245  if (request.getMethod() == "GET")
246  {
247  QByteArray dirStr = request.getParameter("direction");
248  int direction = 0;
249 
250  if (dirStr.length() != 0)
251  {
252  bool ok;
253  int tmp = dirStr.toInt(&ok);
254  if (ok) {
255  direction = tmp;
256  }
257  }
258 
259  int status = m_adapter->instanceDevices(direction, normalResponse, errorResponse);
260  response.setStatus(status);
261 
262  if (status/100 == 2) {
263  response.write(normalResponse.asJson().toUtf8());
264  } else {
265  response.write(errorResponse.asJson().toUtf8());
266  }
267  }
268  else
269  {
270  response.setStatus(405,"Invalid HTTP method");
271  errorResponse.init();
272  *errorResponse.getMessage() = "Invalid HTTP method";
273  response.write(errorResponse.asJson().toUtf8());
274  }
275 }
276 
277 void WebAPIRequestMapper::instanceChannelsService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
278 {
279  SWGSDRangel::SWGInstanceChannelsResponse normalResponse;
280  SWGSDRangel::SWGErrorResponse errorResponse;
281  response.setHeader("Content-Type", "application/json");
282  response.setHeader("Access-Control-Allow-Origin", "*");
283 
284  if (request.getMethod() == "GET")
285  {
286  QByteArray dirStr = request.getParameter("direction");
287  int direction = 0;
288 
289  if (dirStr.length() != 0)
290  {
291  bool ok;
292  int tmp = dirStr.toInt(&ok);
293  if (ok) {
294  direction = tmp;
295  }
296  }
297 
298  int status = m_adapter->instanceChannels(direction, normalResponse, errorResponse);
299  response.setStatus(status);
300 
301  if (status/100 == 2) {
302  response.write(normalResponse.asJson().toUtf8());
303  } else {
304  response.write(errorResponse.asJson().toUtf8());
305  }
306  }
307  else
308  {
309  response.setStatus(405,"Invalid HTTP method");
310  errorResponse.init();
311  *errorResponse.getMessage() = "Invalid HTTP method";
312  response.write(errorResponse.asJson().toUtf8());
313  }
314 }
315 
316 void WebAPIRequestMapper::instanceLoggingService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
317 {
318  SWGSDRangel::SWGLoggingInfo query;
319  SWGSDRangel::SWGLoggingInfo normalResponse;
320  SWGSDRangel::SWGErrorResponse errorResponse;
321  response.setHeader("Content-Type", "application/json");
322  response.setHeader("Access-Control-Allow-Origin", "*");
323 
324  if (request.getMethod() == "GET")
325  {
326  int status = m_adapter->instanceLoggingGet(normalResponse, errorResponse);
327  response.setStatus(status);
328 
329  if (status/100 == 2) {
330  response.write(normalResponse.asJson().toUtf8());
331  } else {
332  response.write(errorResponse.asJson().toUtf8());
333  }
334  }
335  else if (request.getMethod() == "PUT")
336  {
337  QString jsonStr = request.getBody();
338  QJsonObject jsonObject;
339 
340  if (parseJsonBody(jsonStr, jsonObject, response))
341  {
342  query.fromJson(jsonStr);
343  int status = m_adapter->instanceLoggingPut(query, normalResponse, errorResponse);
344  response.setStatus(status);
345 
346  if (status/100 == 2) {
347  response.write(normalResponse.asJson().toUtf8());
348  } else {
349  response.write(errorResponse.asJson().toUtf8());
350  }
351  }
352  else
353  {
354  response.setStatus(400,"Invalid JSON format");
355  errorResponse.init();
356  *errorResponse.getMessage() = "Invalid JSON format";
357  response.write(errorResponse.asJson().toUtf8());
358  }
359  }
360  else
361  {
362  response.setStatus(405,"Invalid HTTP method");
363  errorResponse.init();
364  *errorResponse.getMessage() = "Invalid HTTP method";
365  response.write(errorResponse.asJson().toUtf8());
366  }
367 }
368 
369 void WebAPIRequestMapper::instanceAudioService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
370 {
371  SWGSDRangel::SWGErrorResponse errorResponse;
372  response.setHeader("Content-Type", "application/json");
373  response.setHeader("Access-Control-Allow-Origin", "*");
374 
375  if (request.getMethod() == "GET")
376  {
377  SWGSDRangel::SWGAudioDevices normalResponse;
378 
379  int status = m_adapter->instanceAudioGet(normalResponse, errorResponse);
380  response.setStatus(status);
381 
382  if (status/100 == 2) {
383  response.write(normalResponse.asJson().toUtf8());
384  } else {
385  response.write(errorResponse.asJson().toUtf8());
386  }
387  }
388  else
389  {
390  response.setStatus(405,"Invalid HTTP method");
391  errorResponse.init();
392  *errorResponse.getMessage() = "Invalid HTTP method";
393  response.write(errorResponse.asJson().toUtf8());
394  }
395 }
396 
397 void WebAPIRequestMapper::instanceAudioInputParametersService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
398 {
399  SWGSDRangel::SWGErrorResponse errorResponse;
400  response.setHeader("Content-Type", "application/json");
401  response.setHeader("Access-Control-Allow-Origin", "*");
402 
403  QString jsonStr = request.getBody();
404  QJsonObject jsonObject;
405 
406  if (parseJsonBody(jsonStr, jsonObject, response))
407  {
408  SWGSDRangel::SWGAudioInputDevice normalResponse;
409  resetAudioInputDevice(normalResponse);
410  QStringList audioInputDeviceKeys;
411 
412  if (validateAudioInputDevice(normalResponse, jsonObject, audioInputDeviceKeys))
413  {
414  if (request.getMethod() == "PATCH")
415  {
416  int status = m_adapter->instanceAudioInputPatch(
417  normalResponse,
418  audioInputDeviceKeys,
419  errorResponse);
420  response.setStatus(status);
421 
422  if (status/100 == 2) {
423  response.write(normalResponse.asJson().toUtf8());
424  } else {
425  response.write(errorResponse.asJson().toUtf8());
426  }
427  }
428  else if (request.getMethod() == "DELETE")
429  {
430  int status = m_adapter->instanceAudioInputDelete(
431  normalResponse,
432  errorResponse);
433  response.setStatus(status);
434 
435  if (status/100 == 2) {
436  response.write(normalResponse.asJson().toUtf8());
437  } else {
438  response.write(errorResponse.asJson().toUtf8());
439  }
440  }
441  else
442  {
443  response.setStatus(405,"Invalid HTTP method");
444  errorResponse.init();
445  *errorResponse.getMessage() = "Invalid HTTP method";
446  response.write(errorResponse.asJson().toUtf8());
447  }
448  }
449  else
450  {
451  response.setStatus(400,"Invalid JSON request");
452  errorResponse.init();
453  *errorResponse.getMessage() = "Invalid JSON request";
454  response.write(errorResponse.asJson().toUtf8());
455  }
456  }
457  else
458  {
459  response.setStatus(400,"Invalid JSON format");
460  errorResponse.init();
461  *errorResponse.getMessage() = "Invalid JSON format";
462  response.write(errorResponse.asJson().toUtf8());
463  }
464 }
465 
466 void WebAPIRequestMapper::instanceAudioOutputParametersService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
467 {
468  SWGSDRangel::SWGErrorResponse errorResponse;
469  response.setHeader("Content-Type", "application/json");
470  response.setHeader("Access-Control-Allow-Origin", "*");
471 
472  QString jsonStr = request.getBody();
473  QJsonObject jsonObject;
474 
475  if (parseJsonBody(jsonStr, jsonObject, response))
476  {
477  SWGSDRangel::SWGAudioOutputDevice normalResponse;
478  resetAudioOutputDevice(normalResponse);
479  QStringList audioOutputDeviceKeys;
480 
481  if (validateAudioOutputDevice(normalResponse, jsonObject, audioOutputDeviceKeys))
482  {
483  if (request.getMethod() == "PATCH")
484  {
485  int status = m_adapter->instanceAudioOutputPatch(
486  normalResponse,
487  audioOutputDeviceKeys,
488  errorResponse);
489  response.setStatus(status);
490 
491  if (status/100 == 2) {
492  response.write(normalResponse.asJson().toUtf8());
493  } else {
494  response.write(errorResponse.asJson().toUtf8());
495  }
496  }
497  else if (request.getMethod() == "DELETE")
498  {
499  int status = m_adapter->instanceAudioOutputDelete(
500  normalResponse,
501  errorResponse);
502  response.setStatus(status);
503 
504  if (status/100 == 2) {
505  response.write(normalResponse.asJson().toUtf8());
506  } else {
507  response.write(errorResponse.asJson().toUtf8());
508  }
509  }
510  else
511  {
512  response.setStatus(405,"Invalid HTTP method");
513  errorResponse.init();
514  *errorResponse.getMessage() = "Invalid HTTP method";
515  response.write(errorResponse.asJson().toUtf8());
516  }
517  }
518  else
519  {
520  response.setStatus(400,"Invalid JSON request");
521  errorResponse.init();
522  *errorResponse.getMessage() = "Invalid JSON request";
523  response.write(errorResponse.asJson().toUtf8());
524  }
525  }
526  else
527  {
528  response.setStatus(400,"Invalid JSON format");
529  errorResponse.init();
530  *errorResponse.getMessage() = "Invalid JSON format";
531  response.write(errorResponse.asJson().toUtf8());
532  }
533 }
534 
535 void WebAPIRequestMapper::instanceAudioInputCleanupService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
536 {
537  SWGSDRangel::SWGErrorResponse errorResponse;
538  response.setHeader("Content-Type", "application/json");
539  response.setHeader("Access-Control-Allow-Origin", "*");
540 
541  if (request.getMethod() == "PATCH")
542  {
543  SWGSDRangel::SWGSuccessResponse normalResponse;
544 
545  int status = m_adapter->instanceAudioInputCleanupPatch(normalResponse, errorResponse);
546  response.setStatus(status);
547 
548  if (status/100 == 2) {
549  response.write(normalResponse.asJson().toUtf8());
550  } else {
551  response.write(errorResponse.asJson().toUtf8());
552  }
553  }
554  else
555  {
556  response.setStatus(405,"Invalid HTTP method");
557  errorResponse.init();
558  *errorResponse.getMessage() = "Invalid HTTP method";
559  response.write(errorResponse.asJson().toUtf8());
560  }
561 }
562 
563 void WebAPIRequestMapper::instanceAudioOutputCleanupService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
564 {
565  SWGSDRangel::SWGErrorResponse errorResponse;
566  response.setHeader("Content-Type", "application/json");
567  response.setHeader("Access-Control-Allow-Origin", "*");
568 
569  if (request.getMethod() == "PATCH")
570  {
571  SWGSDRangel::SWGSuccessResponse normalResponse;
572 
573  int status = m_adapter->instanceAudioOutputCleanupPatch(normalResponse, errorResponse);
574  response.setStatus(status);
575 
576  if (status/100 == 2) {
577  response.write(normalResponse.asJson().toUtf8());
578  } else {
579  response.write(errorResponse.asJson().toUtf8());
580  }
581  }
582  else
583  {
584  response.setStatus(405,"Invalid HTTP method");
585  errorResponse.init();
586  *errorResponse.getMessage() = "Invalid HTTP method";
587  response.write(errorResponse.asJson().toUtf8());
588  }
589 }
590 
591 void WebAPIRequestMapper::instanceLocationService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
592 {
593  SWGSDRangel::SWGErrorResponse errorResponse;
594  response.setHeader("Content-Type", "application/json");
595  response.setHeader("Access-Control-Allow-Origin", "*");
596 
597  if (request.getMethod() == "GET")
598  {
599  SWGSDRangel::SWGLocationInformation normalResponse;
600 
601  int status = m_adapter->instanceLocationGet(normalResponse, errorResponse);
602  response.setStatus(status);
603 
604  if (status/100 == 2) {
605  response.write(normalResponse.asJson().toUtf8());
606  } else {
607  response.write(errorResponse.asJson().toUtf8());
608  }
609  }
610  else if (request.getMethod() == "PUT")
611  {
612  SWGSDRangel::SWGLocationInformation normalResponse;
613  QString jsonStr = request.getBody();
614  QJsonObject jsonObject;
615 
616  if (parseJsonBody(jsonStr, jsonObject, response))
617  {
618  normalResponse.fromJson(jsonStr);
619  int status = m_adapter->instanceLocationPut(normalResponse, errorResponse);
620  response.setStatus(status);
621 
622  if (status/100 == 2) {
623  response.write(normalResponse.asJson().toUtf8());
624  } else {
625  response.write(errorResponse.asJson().toUtf8());
626  }
627  }
628  else
629  {
630  response.setStatus(400,"Invalid JSON format");
631  errorResponse.init();
632  *errorResponse.getMessage() = "Invalid JSON format";
633  response.write(errorResponse.asJson().toUtf8());
634  }
635  }
636  else
637  {
638  response.setStatus(405,"Invalid HTTP method");
639  errorResponse.init();
640  *errorResponse.getMessage() = "Invalid HTTP method";
641  response.write(errorResponse.asJson().toUtf8());
642  }
643 }
644 
645 void WebAPIRequestMapper::instanceAMBESerialService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
646 {
647  SWGSDRangel::SWGErrorResponse errorResponse;
648  response.setHeader("Content-Type", "application/json");
649  response.setHeader("Access-Control-Allow-Origin", "*");
650 
651  if (request.getMethod() == "GET")
652  {
653  SWGSDRangel::SWGDVSerialDevices normalResponse;
654 
655  int status = m_adapter->instanceAMBESerialGet(normalResponse, errorResponse);
656  response.setStatus(status);
657 
658  if (status/100 == 2) {
659  response.write(normalResponse.asJson().toUtf8());
660  } else {
661  response.write(errorResponse.asJson().toUtf8());
662  }
663  }
664  else
665  {
666  response.setStatus(405,"Invalid HTTP method");
667  errorResponse.init();
668  *errorResponse.getMessage() = "Invalid HTTP method";
669  response.write(errorResponse.asJson().toUtf8());
670  }
671 }
672 
673 void WebAPIRequestMapper::instanceAMBEDevicesService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
674 {
675  SWGSDRangel::SWGErrorResponse errorResponse;
676  response.setHeader("Content-Type", "application/json");
677  response.setHeader("Access-Control-Allow-Origin", "*");
678 
679  if (request.getMethod() == "GET")
680  {
681  SWGSDRangel::SWGAMBEDevices normalResponse;
682 
683  int status = m_adapter->instanceAMBEDevicesGet(normalResponse, errorResponse);
684  response.setStatus(status);
685 
686  if (status/100 == 2) {
687  response.write(normalResponse.asJson().toUtf8());
688  } else {
689  response.write(errorResponse.asJson().toUtf8());
690  }
691  }
692  else if ((request.getMethod() == "PATCH") || (request.getMethod() == "PUT"))
693  {
694  SWGSDRangel::SWGAMBEDevices query;
695  SWGSDRangel::SWGAMBEDevices normalResponse;
696  QString jsonStr = request.getBody();
697  QJsonObject jsonObject;
698 
699  if (parseJsonBody(jsonStr, jsonObject, response))
700  {
701  if (validateAMBEDevices(query, jsonObject))
702  {
703  int status;
704 
705  if (request.getMethod() == "PATCH") {
706  status = m_adapter->instanceAMBEDevicesPatch(query, normalResponse, errorResponse);
707  } else {
708  status = m_adapter->instanceAMBEDevicesPut(query, normalResponse, errorResponse);
709  }
710 
711  response.setStatus(status);
712 
713  if (status/100 == 2) {
714  response.write(normalResponse.asJson().toUtf8());
715  } else {
716  response.write(errorResponse.asJson().toUtf8());
717  }
718  }
719  else
720  {
721  response.setStatus(400,"Invalid JSON request");
722  errorResponse.init();
723  *errorResponse.getMessage() = "Invalid JSON request";
724  response.write(errorResponse.asJson().toUtf8());
725  }
726  }
727  else
728  {
729  response.setStatus(400,"Invalid JSON format");
730  errorResponse.init();
731  *errorResponse.getMessage() = "Invalid JSON format";
732  response.write(errorResponse.asJson().toUtf8());
733  }
734  }
735  else if (request.getMethod() == "DELETE")
736  {
737  SWGSDRangel::SWGSuccessResponse normalResponse;
738 
739  int status = m_adapter->instanceAMBEDevicesDelete(normalResponse, errorResponse);
740  response.setStatus(status);
741 
742  if (status/100 == 2) {
743  response.write(normalResponse.asJson().toUtf8());
744  } else {
745  response.write(errorResponse.asJson().toUtf8());
746  }
747  }
748  else
749  {
750  response.setStatus(405,"Invalid HTTP method");
751  errorResponse.init();
752  *errorResponse.getMessage() = "Invalid HTTP method";
753  response.write(errorResponse.asJson().toUtf8());
754  }
755 }
756 
757 void WebAPIRequestMapper::instancePresetsService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
758 {
759  SWGSDRangel::SWGErrorResponse errorResponse;
760  response.setHeader("Content-Type", "application/json");
761  response.setHeader("Access-Control-Allow-Origin", "*");
762 
763  if (request.getMethod() == "GET")
764  {
765  SWGSDRangel::SWGPresets normalResponse;
766  int status = m_adapter->instancePresetsGet(normalResponse, errorResponse);
767  response.setStatus(status);
768 
769  if (status/100 == 2) {
770  response.write(normalResponse.asJson().toUtf8());
771  } else {
772  response.write(errorResponse.asJson().toUtf8());
773  }
774  }
775 }
776 
777 void WebAPIRequestMapper::instancePresetService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
778 {
779  SWGSDRangel::SWGErrorResponse errorResponse;
780  response.setHeader("Content-Type", "application/json");
781  response.setHeader("Access-Control-Allow-Origin", "*");
782 
783  if (request.getMethod() == "PATCH")
784  {
785  SWGSDRangel::SWGPresetTransfer query;
786  SWGSDRangel::SWGPresetIdentifier normalResponse;
787  QString jsonStr = request.getBody();
788  QJsonObject jsonObject;
789 
790  if (parseJsonBody(jsonStr, jsonObject, response))
791  {
792  query.fromJson(jsonStr);
793 
794  if (validatePresetTransfer(query))
795  {
796  int status = m_adapter->instancePresetPatch(query, normalResponse, errorResponse);
797  response.setStatus(status);
798 
799  if (status/100 == 2) {
800  response.write(normalResponse.asJson().toUtf8());
801  } else {
802  response.write(errorResponse.asJson().toUtf8());
803  }
804  }
805  else
806  {
807  response.setStatus(400,"Invalid JSON request");
808  errorResponse.init();
809  *errorResponse.getMessage() = "Invalid JSON request";
810  response.write(errorResponse.asJson().toUtf8());
811  }
812  }
813  else
814  {
815  response.setStatus(400,"Invalid JSON format");
816  errorResponse.init();
817  *errorResponse.getMessage() = "Invalid JSON format";
818  response.write(errorResponse.asJson().toUtf8());
819  }
820  }
821  else if (request.getMethod() == "PUT")
822  {
823  SWGSDRangel::SWGPresetTransfer query;
824  SWGSDRangel::SWGPresetIdentifier normalResponse;
825  QString jsonStr = request.getBody();
826  QJsonObject jsonObject;
827 
828  if (parseJsonBody(jsonStr, jsonObject, response))
829  {
830  query.fromJson(jsonStr);
831 
832  if (validatePresetTransfer(query))
833  {
834  int status = m_adapter->instancePresetPut(query, normalResponse, errorResponse);
835  response.setStatus(status);
836 
837  if (status/100 == 2) {
838  response.write(normalResponse.asJson().toUtf8());
839  } else {
840  response.write(errorResponse.asJson().toUtf8());
841  }
842  }
843  else
844  {
845  response.setStatus(400,"Invalid JSON request");
846  errorResponse.init();
847  *errorResponse.getMessage() = "Invalid JSON request";
848  response.write(errorResponse.asJson().toUtf8());
849  }
850  }
851  else
852  {
853  response.setStatus(400,"Invalid JSON format");
854  errorResponse.init();
855  *errorResponse.getMessage() = "Invalid JSON format";
856  response.write(errorResponse.asJson().toUtf8());
857  }
858  }
859  else if (request.getMethod() == "POST")
860  {
861  SWGSDRangel::SWGPresetTransfer query;
862  SWGSDRangel::SWGPresetIdentifier normalResponse;
863  QString jsonStr = request.getBody();
864  QJsonObject jsonObject;
865 
866  if (parseJsonBody(jsonStr, jsonObject, response))
867  {
868  query.fromJson(jsonStr);
869 
870  if (validatePresetTransfer(query))
871  {
872  int status = m_adapter->instancePresetPost(query, normalResponse, errorResponse);
873  response.setStatus(status);
874 
875  if (status/100 == 2) {
876  response.write(normalResponse.asJson().toUtf8());
877  } else {
878  response.write(errorResponse.asJson().toUtf8());
879  }
880  }
881  else
882  {
883  response.setStatus(400,"Invalid JSON request");
884  errorResponse.init();
885  *errorResponse.getMessage() = "Invalid JSON request";
886  response.write(errorResponse.asJson().toUtf8());
887  }
888  }
889  else
890  {
891  response.setStatus(400,"Invalid JSON format");
892  errorResponse.init();
893  *errorResponse.getMessage() = "Invalid JSON format";
894  response.write(errorResponse.asJson().toUtf8());
895  }
896  }
897  else if (request.getMethod() == "DELETE")
898  {
899  SWGSDRangel::SWGPresetIdentifier normalResponse;
900  QString jsonStr = request.getBody();
901  QJsonObject jsonObject;
902 
903  if (parseJsonBody(jsonStr, jsonObject, response))
904  {
905  normalResponse.fromJson(jsonStr);
906 
907  if (validatePresetIdentifer(normalResponse))
908  {
909  int status = m_adapter->instancePresetDelete(normalResponse, errorResponse);
910  response.setStatus(status);
911 
912  if (status/100 == 2) {
913  response.write(normalResponse.asJson().toUtf8());
914  } else {
915  response.write(errorResponse.asJson().toUtf8());
916  }
917  }
918  else
919  {
920  response.setStatus(400,"Invalid JSON request");
921  errorResponse.init();
922  *errorResponse.getMessage() = "Invalid JSON request";
923  response.write(errorResponse.asJson().toUtf8());
924  }
925  }
926  else
927  {
928  response.setStatus(400,"Invalid JSON format");
929  errorResponse.init();
930  *errorResponse.getMessage() = "Invalid JSON format";
931  response.write(errorResponse.asJson().toUtf8());
932  }
933  }
934  else
935  {
936  response.setStatus(405,"Invalid HTTP method");
937  errorResponse.init();
938  *errorResponse.getMessage() = "Invalid HTTP method";
939  response.write(errorResponse.asJson().toUtf8());
940  }
941 }
942 
943 void WebAPIRequestMapper::instancePresetFileService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
944 {
945  SWGSDRangel::SWGErrorResponse errorResponse;
946  response.setHeader("Content-Type", "application/json");
947  response.setHeader("Access-Control-Allow-Origin", "*");
948 
949  if (request.getMethod() == "PUT")
950  {
951  SWGSDRangel::SWGPresetImport query;
952  SWGSDRangel::SWGPresetIdentifier normalResponse;
953  QString jsonStr = request.getBody();
954  QJsonObject jsonObject;
955 
956  if (parseJsonBody(jsonStr, jsonObject, response))
957  {
958  query.fromJson(jsonStr);
959 
960  if (query.getFilePath())
961  {
962  int status = m_adapter->instancePresetFilePut(query, normalResponse, errorResponse);
963  response.setStatus(status);
964 
965  if (status/100 == 2) {
966  response.write(normalResponse.asJson().toUtf8());
967  } else {
968  response.write(errorResponse.asJson().toUtf8());
969  }
970  }
971  else
972  {
973  response.setStatus(400,"Invalid JSON request");
974  errorResponse.init();
975  *errorResponse.getMessage() = "Invalid JSON request";
976  response.write(errorResponse.asJson().toUtf8());
977  }
978  }
979  else
980  {
981  response.setStatus(400,"Invalid JSON format");
982  errorResponse.init();
983  *errorResponse.getMessage() = "Invalid JSON format";
984  response.write(errorResponse.asJson().toUtf8());
985  }
986  }
987  else if (request.getMethod() == "POST")
988  {
989  SWGSDRangel::SWGPresetExport query;
990  SWGSDRangel::SWGPresetIdentifier normalResponse;
991  QString jsonStr = request.getBody();
992  QJsonObject jsonObject;
993 
994  if (parseJsonBody(jsonStr, jsonObject, response))
995  {
996  query.fromJson(jsonStr);
997 
998  if (validatePresetExport(query))
999  {
1000  int status = m_adapter->instancePresetFilePost(query, normalResponse, errorResponse);
1001  response.setStatus(status);
1002 
1003  if (status/100 == 2) {
1004  response.write(normalResponse.asJson().toUtf8());
1005  } else {
1006  response.write(errorResponse.asJson().toUtf8());
1007  }
1008  }
1009  else
1010  {
1011  response.setStatus(400,"Invalid JSON request");
1012  errorResponse.init();
1013  *errorResponse.getMessage() = "Invalid JSON request";
1014  response.write(errorResponse.asJson().toUtf8());
1015  }
1016  }
1017  else
1018  {
1019  response.setStatus(400,"Invalid JSON format");
1020  errorResponse.init();
1021  *errorResponse.getMessage() = "Invalid JSON format";
1022  response.write(errorResponse.asJson().toUtf8());
1023  }
1024  }
1025  else
1026  {
1027  response.setStatus(405,"Invalid HTTP method");
1028  errorResponse.init();
1029  *errorResponse.getMessage() = "Invalid HTTP method";
1030  response.write(errorResponse.asJson().toUtf8());
1031  }
1032 }
1033 
1034 void WebAPIRequestMapper::instanceDeviceSetsService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
1035 {
1036  SWGSDRangel::SWGErrorResponse errorResponse;
1037  response.setHeader("Content-Type", "application/json");
1038  response.setHeader("Access-Control-Allow-Origin", "*");
1039 
1040  if (request.getMethod() == "GET")
1041  {
1042  SWGSDRangel::SWGDeviceSetList normalResponse;
1043  int status = m_adapter->instanceDeviceSetsGet(normalResponse, errorResponse);
1044  response.setStatus(status);
1045 
1046  if (status/100 == 2) {
1047  response.write(normalResponse.asJson().toUtf8());
1048  } else {
1049  response.write(errorResponse.asJson().toUtf8());
1050  }
1051  }
1052  else
1053  {
1054  response.setStatus(405,"Invalid HTTP method");
1055  errorResponse.init();
1056  *errorResponse.getMessage() = "Invalid HTTP method";
1057  response.write(errorResponse.asJson().toUtf8());
1058  }
1059 }
1060 
1061 void WebAPIRequestMapper::instanceDeviceSetService(qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
1062 {
1063  SWGSDRangel::SWGErrorResponse errorResponse;
1064  response.setHeader("Content-Type", "application/json");
1065  response.setHeader("Access-Control-Allow-Origin", "*");
1066 
1067  if (request.getMethod() == "POST")
1068  {
1069  SWGSDRangel::SWGSuccessResponse normalResponse;
1070  QByteArray dirStr = request.getParameter("direction");
1071  int direction = 0;
1072 
1073  if (dirStr.length() != 0)
1074  {
1075  bool ok;
1076  int tmp = dirStr.toInt(&ok);
1077  if (ok) {
1078  direction = tmp;
1079  }
1080  }
1081 
1082  int status = m_adapter->instanceDeviceSetPost(direction, normalResponse, errorResponse);
1083  response.setStatus(status);
1084 
1085  if (status/100 == 2) {
1086  response.write(normalResponse.asJson().toUtf8());
1087  } else {
1088  response.write(errorResponse.asJson().toUtf8());
1089  }
1090  }
1091  else if (request.getMethod() == "DELETE")
1092  {
1093  SWGSDRangel::SWGSuccessResponse normalResponse;
1094  int status = m_adapter->instanceDeviceSetDelete(normalResponse, errorResponse);
1095  response.setStatus(status);
1096 
1097  if (status/100 == 2) {
1098  response.write(normalResponse.asJson().toUtf8());
1099  } else {
1100  response.write(errorResponse.asJson().toUtf8());
1101  }
1102  }
1103  else
1104  {
1105  response.setStatus(405,"Invalid HTTP method");
1106  errorResponse.init();
1107  *errorResponse.getMessage() = "Invalid HTTP method";
1108  response.write(errorResponse.asJson().toUtf8());
1109  }
1110 }
1111 
1112 void WebAPIRequestMapper::devicesetService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
1113 {
1114  SWGSDRangel::SWGErrorResponse errorResponse;
1115  response.setHeader("Content-Type", "application/json");
1116  response.setHeader("Access-Control-Allow-Origin", "*");
1117 
1118  if (request.getMethod() == "GET")
1119  {
1120  try
1121  {
1122  SWGSDRangel::SWGDeviceSet normalResponse;
1123  int deviceSetIndex = boost::lexical_cast<int>(indexStr);
1124  int status = m_adapter->devicesetGet(deviceSetIndex, normalResponse, errorResponse);
1125  response.setStatus(status);
1126 
1127  if (status/100 == 2) {
1128  response.write(normalResponse.asJson().toUtf8());
1129  } else {
1130  response.write(errorResponse.asJson().toUtf8());
1131  }
1132  }
1133  catch (const boost::bad_lexical_cast &e)
1134  {
1135  errorResponse.init();
1136  *errorResponse.getMessage() = "Wrong integer conversion on device set index";
1137  response.setStatus(400,"Invalid data");
1138  response.write(errorResponse.asJson().toUtf8());
1139  }
1140  }
1141  else
1142  {
1143  response.setStatus(405,"Invalid HTTP method");
1144  errorResponse.init();
1145  *errorResponse.getMessage() = "Invalid HTTP method";
1146  response.write(errorResponse.asJson().toUtf8());
1147  }
1148 }
1149 
1150 void WebAPIRequestMapper::devicesetFocusService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
1151 {
1152  SWGSDRangel::SWGErrorResponse errorResponse;
1153  response.setHeader("Content-Type", "application/json");
1154  response.setHeader("Access-Control-Allow-Origin", "*");
1155 
1156  try
1157  {
1158  int deviceSetIndex = boost::lexical_cast<int>(indexStr);
1159 
1160  if (request.getMethod() == "PATCH")
1161  {
1162  SWGSDRangel::SWGSuccessResponse normalResponse;
1163  int status = m_adapter->devicesetFocusPatch(deviceSetIndex, normalResponse, errorResponse);
1164 
1165  response.setStatus(status);
1166 
1167  if (status/100 == 2) {
1168  response.write(normalResponse.asJson().toUtf8());
1169  } else {
1170  response.write(errorResponse.asJson().toUtf8());
1171  }
1172  }
1173  else
1174  {
1175  response.setStatus(405,"Invalid HTTP method");
1176  errorResponse.init();
1177  *errorResponse.getMessage() = "Invalid HTTP method";
1178  response.write(errorResponse.asJson().toUtf8());
1179  }
1180  }
1181  catch (const boost::bad_lexical_cast &e)
1182  {
1183  errorResponse.init();
1184  *errorResponse.getMessage() = "Wrong integer conversion on device set index";
1185  response.setStatus(400,"Invalid data");
1186  response.write(errorResponse.asJson().toUtf8());
1187  }
1188 }
1189 
1190 void WebAPIRequestMapper::devicesetDeviceService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
1191 {
1192  SWGSDRangel::SWGErrorResponse errorResponse;
1193  response.setHeader("Content-Type", "application/json");
1194  response.setHeader("Access-Control-Allow-Origin", "*");
1195 
1196  try
1197  {
1198  int deviceSetIndex = boost::lexical_cast<int>(indexStr);
1199 
1200  if (request.getMethod() == "PUT")
1201  {
1202  QString jsonStr = request.getBody();
1203  QJsonObject jsonObject;
1204 
1205  if (parseJsonBody(jsonStr, jsonObject, response))
1206  {
1207  SWGSDRangel::SWGDeviceListItem query;
1208  SWGSDRangel::SWGDeviceListItem normalResponse;
1209 
1210  if (validateDeviceListItem(query, jsonObject))
1211  {
1212  int status = m_adapter->devicesetDevicePut(deviceSetIndex, query, normalResponse, errorResponse);
1213  response.setStatus(status);
1214 
1215  if (status/100 == 2) {
1216  response.write(normalResponse.asJson().toUtf8());
1217  } else {
1218  response.write(errorResponse.asJson().toUtf8());
1219  }
1220  }
1221  else
1222  {
1223  response.setStatus(400,"Missing device identification");
1224  errorResponse.init();
1225  *errorResponse.getMessage() = "Missing device identification";
1226  response.write(errorResponse.asJson().toUtf8());
1227  }
1228  }
1229  else
1230  {
1231  response.setStatus(400,"Invalid JSON format");
1232  errorResponse.init();
1233  *errorResponse.getMessage() = "Invalid JSON format";
1234  response.write(errorResponse.asJson().toUtf8());
1235  }
1236  }
1237  else
1238  {
1239  response.setStatus(405,"Invalid HTTP method");
1240  errorResponse.init();
1241  *errorResponse.getMessage() = "Invalid HTTP method";
1242  response.write(errorResponse.asJson().toUtf8());
1243  }
1244  }
1245  catch (const boost::bad_lexical_cast &e)
1246  {
1247  errorResponse.init();
1248  *errorResponse.getMessage() = "Wrong integer conversion on device set index";
1249  response.setStatus(400,"Invalid data");
1250  response.write(errorResponse.asJson().toUtf8());
1251  }
1252 }
1253 
1254 void WebAPIRequestMapper::devicesetDeviceSettingsService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
1255 {
1256  SWGSDRangel::SWGErrorResponse errorResponse;
1257  response.setHeader("Content-Type", "application/json");
1258  response.setHeader("Access-Control-Allow-Origin", "*");
1259 
1260  try
1261  {
1262  int deviceSetIndex = boost::lexical_cast<int>(indexStr);
1263 
1264  if ((request.getMethod() == "PUT") || (request.getMethod() == "PATCH"))
1265  {
1266  QString jsonStr = request.getBody();
1267  QJsonObject jsonObject;
1268 
1269  if (parseJsonBody(jsonStr, jsonObject, response))
1270  {
1271  SWGSDRangel::SWGDeviceSettings normalResponse;
1272  resetDeviceSettings(normalResponse);
1273  QStringList deviceSettingsKeys;
1274 
1275  if (validateDeviceSettings(normalResponse, jsonObject, deviceSettingsKeys))
1276  {
1277  int status = m_adapter->devicesetDeviceSettingsPutPatch(
1278  deviceSetIndex,
1279  (request.getMethod() == "PUT"), // force settings on PUT
1280  deviceSettingsKeys,
1281  normalResponse,
1282  errorResponse);
1283  response.setStatus(status);
1284 
1285  if (status/100 == 2) {
1286  response.write(normalResponse.asJson().toUtf8());
1287  } else {
1288  response.write(errorResponse.asJson().toUtf8());
1289  }
1290  }
1291  else
1292  {
1293  response.setStatus(400,"Invalid JSON request");
1294  errorResponse.init();
1295  *errorResponse.getMessage() = "Invalid JSON request";
1296  response.write(errorResponse.asJson().toUtf8());
1297  }
1298  }
1299  else
1300  {
1301  response.setStatus(400,"Invalid JSON format");
1302  errorResponse.init();
1303  *errorResponse.getMessage() = "Invalid JSON format";
1304  response.write(errorResponse.asJson().toUtf8());
1305  }
1306  }
1307  else if (request.getMethod() == "GET")
1308  {
1309  SWGSDRangel::SWGDeviceSettings normalResponse;
1310  resetDeviceSettings(normalResponse);
1311  int status = m_adapter->devicesetDeviceSettingsGet(deviceSetIndex, normalResponse, errorResponse);
1312  response.setStatus(status);
1313 
1314  if (status/100 == 2) {
1315  response.write(normalResponse.asJson().toUtf8());
1316  } else {
1317  response.write(errorResponse.asJson().toUtf8());
1318  }
1319  }
1320  else
1321  {
1322  response.setStatus(405,"Invalid HTTP method");
1323  errorResponse.init();
1324  *errorResponse.getMessage() = "Invalid HTTP method";
1325  response.write(errorResponse.asJson().toUtf8());
1326  }
1327  }
1328  catch (const boost::bad_lexical_cast &e)
1329  {
1330  errorResponse.init();
1331  *errorResponse.getMessage() = "Wrong integer conversion on device set index";
1332  response.setStatus(400,"Invalid data");
1333  response.write(errorResponse.asJson().toUtf8());
1334  }
1335 }
1336 
1337 void WebAPIRequestMapper::devicesetDeviceRunService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
1338 {
1339  SWGSDRangel::SWGErrorResponse errorResponse;
1340  response.setHeader("Content-Type", "application/json");
1341  response.setHeader("Access-Control-Allow-Origin", "*");
1342 
1343  try
1344  {
1345  int deviceSetIndex = boost::lexical_cast<int>(indexStr);
1346 
1347  if (request.getMethod() == "GET")
1348  {
1349  SWGSDRangel::SWGDeviceState normalResponse;
1350  int status = m_adapter->devicesetDeviceRunGet(deviceSetIndex, normalResponse, errorResponse);
1351 
1352  response.setStatus(status);
1353 
1354  if (status/100 == 2) {
1355  response.write(normalResponse.asJson().toUtf8());
1356  } else {
1357  response.write(errorResponse.asJson().toUtf8());
1358  }
1359  }
1360  else if (request.getMethod() == "POST")
1361  {
1362  SWGSDRangel::SWGDeviceState normalResponse;
1363  int status = m_adapter->devicesetDeviceRunPost(deviceSetIndex, normalResponse, errorResponse);
1364 
1365  response.setStatus(status);
1366 
1367  if (status/100 == 2) {
1368  response.write(normalResponse.asJson().toUtf8());
1369  } else {
1370  response.write(errorResponse.asJson().toUtf8());
1371  }
1372  }
1373  else if (request.getMethod() == "DELETE")
1374  {
1375  SWGSDRangel::SWGDeviceState normalResponse;
1376  int status = m_adapter->devicesetDeviceRunDelete(deviceSetIndex, normalResponse, errorResponse);
1377 
1378  response.setStatus(status);
1379 
1380  if (status/100 == 2) {
1381  response.write(normalResponse.asJson().toUtf8());
1382  } else {
1383  response.write(errorResponse.asJson().toUtf8());
1384  }
1385  }
1386  else
1387  {
1388  response.setStatus(405,"Invalid HTTP method");
1389  errorResponse.init();
1390  *errorResponse.getMessage() = "Invalid HTTP method";
1391  response.write(errorResponse.asJson().toUtf8());
1392  }
1393  }
1394  catch (const boost::bad_lexical_cast &e)
1395  {
1396  errorResponse.init();
1397  *errorResponse.getMessage() = "Wrong integer conversion on device set index";
1398  response.setStatus(400,"Invalid data");
1399  response.write(errorResponse.asJson().toUtf8());
1400  }
1401 }
1402 
1403 void WebAPIRequestMapper::devicesetDeviceReportService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
1404 {
1405  SWGSDRangel::SWGErrorResponse errorResponse;
1406  response.setHeader("Content-Type", "application/json");
1407  response.setHeader("Access-Control-Allow-Origin", "*");
1408 
1409  if (request.getMethod() == "GET")
1410  {
1411  try
1412  {
1413  SWGSDRangel::SWGDeviceReport normalResponse;
1414  resetDeviceReport(normalResponse);
1415  int deviceSetIndex = boost::lexical_cast<int>(indexStr);
1416  int status = m_adapter->devicesetDeviceReportGet(deviceSetIndex, normalResponse, errorResponse);
1417  response.setStatus(status);
1418 
1419  if (status/100 == 2) {
1420  response.write(normalResponse.asJson().toUtf8());
1421  } else {
1422  response.write(errorResponse.asJson().toUtf8());
1423  }
1424  }
1425  catch (const boost::bad_lexical_cast &e)
1426  {
1427  errorResponse.init();
1428  *errorResponse.getMessage() = "Wrong integer conversion on device set index";
1429  response.setStatus(400,"Invalid data");
1430  response.write(errorResponse.asJson().toUtf8());
1431  }
1432  }
1433  else
1434  {
1435  response.setStatus(405,"Invalid HTTP method");
1436  errorResponse.init();
1437  *errorResponse.getMessage() = "Invalid HTTP method";
1438  response.write(errorResponse.asJson().toUtf8());
1439  }
1440 }
1441 
1442 void WebAPIRequestMapper::devicesetChannelsReportService(const std::string& indexStr, qtwebapp::HttpRequest& request, qtwebapp::HttpResponse& response)
1443 {
1444  SWGSDRangel::SWGErrorResponse errorResponse;
1445  response.setHeader("Content-Type", "application/json");
1446  response.setHeader("Access-Control-Allow-Origin", "*");
1447 
1448  if (request.getMethod() == "GET")
1449  {
1450  try
1451  {
1452  SWGSDRangel::SWGChannelsDetail normalResponse;
1453  int deviceSetIndex = boost::lexical_cast<int>(indexStr);
1454  int status = m_adapter->devicesetChannelsReportGet(deviceSetIndex, normalResponse, errorResponse);
1455  response.setStatus(status);
1456 
1457  if (status/100 == 2) {
1458  response.write(normalResponse.asJson().toUtf8());
1459  } else {
1460  response.write(errorResponse.asJson().toUtf8());
1461  }
1462  }
1463  catch (const boost::bad_lexical_cast &e)
1464  {
1465  errorResponse.init();
1466  *errorResponse.getMessage() = "Wrong integer conversion on device set index";
1467  response.setStatus(400,"Invalid data");
1468  response.write(errorResponse.asJson().toUtf8());
1469  }
1470  }
1471  else
1472  {
1473  response.setStatus(405,"Invalid HTTP method");
1474  errorResponse.init();
1475  *errorResponse.getMessage() = "Invalid HTTP method";
1476  response.write(errorResponse.asJson().toUtf8());
1477  }
1478 }
1479 
1480 void WebAPIRequestMapper::devicesetChannelService(
1481  const std::string& deviceSetIndexStr,
1482  qtwebapp::HttpRequest& request,
1483  qtwebapp::HttpResponse& response)
1484 {
1485  SWGSDRangel::SWGErrorResponse errorResponse;
1486  response.setHeader("Content-Type", "application/json");
1487  response.setHeader("Access-Control-Allow-Origin", "*");
1488 
1489  try
1490  {
1491  int deviceSetIndex = boost::lexical_cast<int>(deviceSetIndexStr);
1492 
1493  if (request.getMethod() == "POST")
1494  {
1495  QString jsonStr = request.getBody();
1496  QJsonObject jsonObject;
1497 
1498  if (parseJsonBody(jsonStr, jsonObject, response))
1499  {
1500  SWGSDRangel::SWGChannelSettings query;
1501  SWGSDRangel::SWGSuccessResponse normalResponse;
1502  resetChannelSettings(query);
1503 
1504  if (jsonObject.contains("direction")) {
1505  query.setDirection(jsonObject["direction"].toInt());
1506  } else {
1507  query.setDirection(0); // assume Rx
1508  }
1509 
1510  if (jsonObject.contains("channelType") && jsonObject["channelType"].isString())
1511  {
1512  query.setChannelType(new QString(jsonObject["channelType"].toString()));
1513 
1514  int status = m_adapter->devicesetChannelPost(deviceSetIndex, query, normalResponse, errorResponse);
1515 
1516  response.setStatus(status);
1517 
1518  if (status/100 == 2) {
1519  response.write(normalResponse.asJson().toUtf8());
1520  } else {
1521  response.write(errorResponse.asJson().toUtf8());
1522  }
1523  }
1524  else
1525  {
1526  response.setStatus(400,"Invalid JSON request");
1527  errorResponse.init();
1528  *errorResponse.getMessage() = "Invalid JSON request";
1529  response.write(errorResponse.asJson().toUtf8());
1530  }
1531  }
1532  else
1533  {
1534  response.setStatus(400,"Invalid JSON format");
1535  errorResponse.init();
1536  *errorResponse.getMessage() = "Invalid JSON format";
1537  response.write(errorResponse.asJson().toUtf8());
1538  }
1539  }
1540  else
1541  {
1542  response.setStatus(405,"Invalid HTTP method");
1543  errorResponse.init();
1544  *errorResponse.getMessage() = "Invalid HTTP method";
1545  response.write(errorResponse.asJson().toUtf8());
1546  }
1547  }
1548  catch (const boost::bad_lexical_cast &e)
1549  {
1550  errorResponse.init();
1551  *errorResponse.getMessage() = "Wrong integer conversion on index";
1552  response.setStatus(400,"Invalid data");
1553  response.write(errorResponse.asJson().toUtf8());
1554  }
1555 }
1556 
1557 void WebAPIRequestMapper::devicesetChannelIndexService(
1558  const std::string& deviceSetIndexStr,
1559  const std::string& channelIndexStr,
1560  qtwebapp::HttpRequest& request,
1561  qtwebapp::HttpResponse& response)
1562 {
1563  SWGSDRangel::SWGErrorResponse errorResponse;
1564  response.setHeader("Content-Type", "application/json");
1565  response.setHeader("Access-Control-Allow-Origin", "*");
1566 
1567  try
1568  {
1569  int deviceSetIndex = boost::lexical_cast<int>(deviceSetIndexStr);
1570  int channelIndex = boost::lexical_cast<int>(channelIndexStr);
1571 
1572  if (request.getMethod() == "DELETE")
1573  {
1574  SWGSDRangel::SWGSuccessResponse normalResponse;
1575  int status = m_adapter->devicesetChannelDelete(deviceSetIndex, channelIndex, normalResponse, errorResponse);
1576 
1577  response.setStatus(status);
1578 
1579  if (status/100 == 2) {
1580  response.write(normalResponse.asJson().toUtf8());
1581  } else {
1582  response.write(errorResponse.asJson().toUtf8());
1583  }
1584  }
1585  else
1586  {
1587  response.setStatus(405,"Invalid HTTP method");
1588  errorResponse.init();
1589  *errorResponse.getMessage() = "Invalid HTTP method";
1590  response.write(errorResponse.asJson().toUtf8());
1591  }
1592  }
1593  catch (const boost::bad_lexical_cast &e)
1594  {
1595  errorResponse.init();
1596  *errorResponse.getMessage() = "Wrong integer conversion on index";
1597  response.setStatus(400,"Invalid data");
1598  response.write(errorResponse.asJson().toUtf8());
1599  }
1600 }
1601 
1602 void WebAPIRequestMapper::devicesetChannelSettingsService(
1603  const std::string& deviceSetIndexStr,
1604  const std::string& channelIndexStr,
1605  qtwebapp::HttpRequest& request,
1606  qtwebapp::HttpResponse& response)
1607 {
1608  SWGSDRangel::SWGErrorResponse errorResponse;
1609  response.setHeader("Content-Type", "application/json");
1610  response.setHeader("Access-Control-Allow-Origin", "*");
1611 
1612  try
1613  {
1614  int deviceSetIndex = boost::lexical_cast<int>(deviceSetIndexStr);
1615  int channelIndex = boost::lexical_cast<int>(channelIndexStr);
1616 
1617  if (request.getMethod() == "GET")
1618  {
1619  SWGSDRangel::SWGChannelSettings normalResponse;
1620  resetChannelSettings(normalResponse);
1621  int status = m_adapter->devicesetChannelSettingsGet(deviceSetIndex, channelIndex, normalResponse, errorResponse);
1622  response.setStatus(status);
1623 
1624  if (status/100 == 2) {
1625  response.write(normalResponse.asJson().toUtf8());
1626  } else {
1627  response.write(errorResponse.asJson().toUtf8());
1628  }
1629  }
1630  else if ((request.getMethod() == "PUT") || (request.getMethod() == "PATCH"))
1631  {
1632  QString jsonStr = request.getBody();
1633  QJsonObject jsonObject;
1634 
1635  if (parseJsonBody(jsonStr, jsonObject, response))
1636  {
1637  SWGSDRangel::SWGChannelSettings normalResponse;
1638  resetChannelSettings(normalResponse);
1639  QStringList channelSettingsKeys;
1640 
1641  if (validateChannelSettings(normalResponse, jsonObject, channelSettingsKeys))
1642  {
1643  int status = m_adapter->devicesetChannelSettingsPutPatch(
1644  deviceSetIndex,
1645  channelIndex,
1646  (request.getMethod() == "PUT"), // force settings on PUT
1647  channelSettingsKeys,
1648  normalResponse,
1649  errorResponse);
1650  response.setStatus(status);
1651 
1652  if (status/100 == 2) {
1653  response.write(normalResponse.asJson().toUtf8());
1654  } else {
1655  response.write(errorResponse.asJson().toUtf8());
1656  }
1657  }
1658  else
1659  {
1660  response.setStatus(400,"Invalid JSON request");
1661  errorResponse.init();
1662  *errorResponse.getMessage() = "Invalid JSON request";
1663  response.write(errorResponse.asJson().toUtf8());
1664  }
1665  }
1666  else
1667  {
1668  response.setStatus(400,"Invalid JSON format");
1669  errorResponse.init();
1670  *errorResponse.getMessage() = "Invalid JSON format";
1671  response.write(errorResponse.asJson().toUtf8());
1672  }
1673  }
1674  else
1675  {
1676  response.setStatus(405,"Invalid HTTP method");
1677  errorResponse.init();
1678  *errorResponse.getMessage() = "Invalid HTTP method";
1679  response.write(errorResponse.asJson().toUtf8());
1680  }
1681  }
1682  catch (const boost::bad_lexical_cast &e)
1683  {
1684  errorResponse.init();
1685  *errorResponse.getMessage() = "Wrong integer conversion on index";
1686  response.setStatus(400,"Invalid data");
1687  response.write(errorResponse.asJson().toUtf8());
1688  }
1689 }
1690 
1691 void WebAPIRequestMapper::devicesetChannelReportService(
1692  const std::string& deviceSetIndexStr,
1693  const std::string& channelIndexStr,
1694  qtwebapp::HttpRequest& request,
1695  qtwebapp::HttpResponse& response)
1696 {
1697  SWGSDRangel::SWGErrorResponse errorResponse;
1698  response.setHeader("Content-Type", "application/json");
1699  response.setHeader("Access-Control-Allow-Origin", "*");
1700 
1701  try
1702  {
1703  int deviceSetIndex = boost::lexical_cast<int>(deviceSetIndexStr);
1704  int channelIndex = boost::lexical_cast<int>(channelIndexStr);
1705 
1706  if (request.getMethod() == "GET")
1707  {
1708  SWGSDRangel::SWGChannelReport normalResponse;
1709  resetChannelReport(normalResponse);
1710  int status = m_adapter->devicesetChannelReportGet(deviceSetIndex, channelIndex, normalResponse, errorResponse);
1711  response.setStatus(status);
1712 
1713  if (status/100 == 2) {
1714  response.write(normalResponse.asJson().toUtf8());
1715  } else {
1716  response.write(errorResponse.asJson().toUtf8());
1717  }
1718  }
1719  }
1720  catch (const boost::bad_lexical_cast &e)
1721  {
1722  errorResponse.init();
1723  *errorResponse.getMessage() = "Wrong integer conversion on index";
1724  response.setStatus(400,"Invalid data");
1725  response.write(errorResponse.asJson().toUtf8());
1726  }
1727 }
1728 
1729 bool WebAPIRequestMapper::parseJsonBody(QString& jsonStr, QJsonObject& jsonObject, qtwebapp::HttpResponse& response)
1730 {
1731  SWGSDRangel::SWGErrorResponse errorResponse;
1732 
1733  try
1734  {
1735  QByteArray jsonBytes(jsonStr.toStdString().c_str());
1736  QJsonParseError error;
1737  QJsonDocument doc = QJsonDocument::fromJson(jsonBytes, &error);
1738 
1739  if (error.error == QJsonParseError::NoError)
1740  {
1741  jsonObject = doc.object();
1742  }
1743  else
1744  {
1745  QString errorMsg = QString("Input JSON error: ") + error.errorString() + QString(" at offset ") + QString::number(error.offset);
1746  errorResponse.init();
1747  *errorResponse.getMessage() = errorMsg;
1748  response.setStatus(400, errorMsg.toUtf8());
1749  response.write(errorResponse.asJson().toUtf8());
1750  }
1751 
1752  return (error.error == QJsonParseError::NoError);
1753  }
1754  catch (const std::exception& ex)
1755  {
1756  QString errorMsg = QString("Error parsing request: ") + ex.what();
1757  errorResponse.init();
1758  *errorResponse.getMessage() = errorMsg;
1759  response.setStatus(500, errorMsg.toUtf8());
1760  response.write(errorResponse.asJson().toUtf8());
1761 
1762  return false;
1763  }
1764 }
1765 
1766 bool WebAPIRequestMapper::validatePresetTransfer(SWGSDRangel::SWGPresetTransfer& presetTransfer)
1767 {
1768  SWGSDRangel::SWGPresetIdentifier *presetIdentifier = presetTransfer.getPreset();
1769 
1770  if (presetIdentifier == 0) {
1771  return false;
1772  }
1773 
1774  return validatePresetIdentifer(*presetIdentifier);
1775 }
1776 
1777 bool WebAPIRequestMapper::validatePresetIdentifer(SWGSDRangel::SWGPresetIdentifier& presetIdentifier)
1778 {
1779  return (presetIdentifier.getGroupName() && presetIdentifier.getName() && presetIdentifier.getType());
1780 }
1781 
1782 bool WebAPIRequestMapper::validatePresetExport(SWGSDRangel::SWGPresetExport& presetExport)
1783 {
1784  if (presetExport.getFilePath() == 0) {
1785  return false;
1786  }
1787 
1788  SWGSDRangel::SWGPresetIdentifier *presetIdentifier = presetExport.getPreset();
1789 
1790  if (presetIdentifier == 0) {
1791  return false;
1792  }
1793 
1794  return validatePresetIdentifer(*presetIdentifier);
1795 }
1796 
1797 bool WebAPIRequestMapper::validateDeviceListItem(SWGSDRangel::SWGDeviceListItem& deviceListItem, QJsonObject& jsonObject)
1798 {
1799  if (jsonObject.contains("direction")) {
1800  deviceListItem.setDirection(jsonObject["direction"].toInt());
1801  } else {
1802  deviceListItem.setDirection(0); // assume Rx
1803  }
1804 
1805  bool identified = false;
1806 
1807  if (jsonObject.contains("displayedName") && jsonObject["displayedName"].isString())
1808  {
1809  deviceListItem.setDisplayedName(new QString(jsonObject["displayedName"].toString()));
1810  identified = true;
1811  } else {
1812  deviceListItem.setDisplayedName(0);
1813  }
1814 
1815 
1816  if (jsonObject.contains("hwType") && jsonObject["hwType"].isString())
1817  {
1818  deviceListItem.setHwType(new QString(jsonObject["hwType"].toString()));
1819  identified = true;
1820  } else {
1821  deviceListItem.setHwType(0);
1822  }
1823 
1824  if (jsonObject.contains("serial") && jsonObject["serial"].isString())
1825  {
1826  deviceListItem.setSerial(new QString(jsonObject["serial"].toString()));
1827  identified = true;
1828  } else {
1829  deviceListItem.setSerial(0);
1830  }
1831 
1832  if (jsonObject.contains("index")) {
1833  deviceListItem.setIndex(jsonObject["index"].toInt(-1));
1834  } else {
1835  deviceListItem.setIndex(-1);
1836  }
1837 
1838  if (jsonObject.contains("sequence")){
1839  deviceListItem.setSequence(jsonObject["sequence"].toInt(-1));
1840  } else {
1841  deviceListItem.setSequence(-1);
1842  }
1843 
1844  if (jsonObject.contains("deviceStreamIndex")) {
1845  deviceListItem.setDeviceStreamIndex(jsonObject["deviceStreamIndex"].toInt(-1));
1846  } else {
1847  deviceListItem.setDeviceStreamIndex(-1);
1848  }
1849 
1850  return identified;
1851 }
1852 
1853 bool WebAPIRequestMapper::validateDeviceSettings(
1854  SWGSDRangel::SWGDeviceSettings& deviceSettings,
1855  QJsonObject& jsonObject,
1856  QStringList& deviceSettingsKeys)
1857 {
1858  if (jsonObject.contains("direction")) {
1859  deviceSettings.setDirection(jsonObject["direction"].toInt());
1860  } else {
1861  deviceSettings.setDirection(0); // assume single Rx
1862  }
1863 
1864  if (jsonObject.contains("deviceHwType") && jsonObject["deviceHwType"].isString()) {
1865  deviceSettings.setDeviceHwType(new QString(jsonObject["deviceHwType"].toString()));
1866  } else {
1867  return false;
1868  }
1869 
1870  QString *deviceHwType = deviceSettings.getDeviceHwType();
1871 
1872  if ((*deviceHwType == "Airspy") && (deviceSettings.getDirection() == 0))
1873  {
1874  if (jsonObject.contains("airspySettings") && jsonObject["airspySettings"].isObject())
1875  {
1876  QJsonObject airspySettingsJsonObject = jsonObject["airspySettings"].toObject();
1877  deviceSettingsKeys = airspySettingsJsonObject.keys();
1878  deviceSettings.setAirspySettings(new SWGSDRangel::SWGAirspySettings());
1879  deviceSettings.getAirspySettings()->fromJsonObject(airspySettingsJsonObject);
1880  return true;
1881  }
1882  else
1883  {
1884  return false;
1885  }
1886  }
1887  else if ((*deviceHwType == "AirspyHF") && (deviceSettings.getDirection() == 0))
1888  {
1889  if (jsonObject.contains("airspyHFSettings") && jsonObject["airspyHFSettings"].isObject())
1890  {
1891  QJsonObject airspyHFSettingsJsonObject = jsonObject["airspyHFSettings"].toObject();
1892  deviceSettingsKeys = airspyHFSettingsJsonObject.keys();
1893  deviceSettings.setAirspyHfSettings(new SWGSDRangel::SWGAirspyHFSettings());
1894  deviceSettings.getAirspyHfSettings()->fromJsonObject(airspyHFSettingsJsonObject);
1895  return true;
1896  }
1897  else
1898  {
1899  return false;
1900  }
1901  }
1902  else if ((*deviceHwType == "BladeRF1") && (deviceSettings.getDirection() == 0))
1903  {
1904  if (jsonObject.contains("bladeRF1InputSettings") && jsonObject["bladeRF1InputSettings"].isObject())
1905  {
1906  QJsonObject bladeRF1InputSettingsJsonObject = jsonObject["bladeRF1InputSettings"].toObject();
1907  deviceSettingsKeys = bladeRF1InputSettingsJsonObject.keys();
1908  deviceSettings.setBladeRf1InputSettings(new SWGSDRangel::SWGBladeRF1InputSettings());
1909  deviceSettings.getBladeRf1InputSettings()->fromJsonObject(bladeRF1InputSettingsJsonObject);
1910  return true;
1911  }
1912  else
1913  {
1914  return false;
1915  }
1916  }
1917  else if ((*deviceHwType == "BladeRF1") && (deviceSettings.getDirection() == 1))
1918  {
1919  if (jsonObject.contains("bladeRF1OutputSettings") && jsonObject["bladeRF1OutputSettings"].isObject())
1920  {
1921  QJsonObject bladeRF1OutputSettingsJsonObject = jsonObject["bladeRF1OutputSettings"].toObject();
1922  deviceSettingsKeys = bladeRF1OutputSettingsJsonObject.keys();
1923  deviceSettings.setBladeRf1OutputSettings(new SWGSDRangel::SWGBladeRF1OutputSettings());
1924  deviceSettings.getBladeRf1OutputSettings()->fromJsonObject(bladeRF1OutputSettingsJsonObject);
1925  return true;
1926  }
1927  else
1928  {
1929  return false;
1930  }
1931  }
1932  else if ((*deviceHwType == "BladeRF2") && (deviceSettings.getDirection() == 0))
1933  {
1934  if (jsonObject.contains("bladeRF2InputSettings") && jsonObject["bladeRF2InputSettings"].isObject())
1935  {
1936  QJsonObject bladeRF2InputSettingsJsonObject = jsonObject["bladeRF2InputSettings"].toObject();
1937  deviceSettingsKeys = bladeRF2InputSettingsJsonObject.keys();
1938  deviceSettings.setBladeRf2InputSettings(new SWGSDRangel::SWGBladeRF2InputSettings());
1939  deviceSettings.getBladeRf2InputSettings()->fromJsonObject(bladeRF2InputSettingsJsonObject);
1940  return true;
1941  }
1942  else
1943  {
1944  return false;
1945  }
1946  }
1947  else if ((*deviceHwType == "BladeRF2") && (deviceSettings.getDirection() == 1))
1948  {
1949  if (jsonObject.contains("bladeRF2OutputSettings") && jsonObject["bladeRF2OutputSettings"].isObject())
1950  {
1951  QJsonObject bladeRF2OutputSettingsJsonObject = jsonObject["bladeRF2OutputSettings"].toObject();
1952  deviceSettingsKeys = bladeRF2OutputSettingsJsonObject.keys();
1953  deviceSettings.setBladeRf2OutputSettings(new SWGSDRangel::SWGBladeRF2OutputSettings());
1954  deviceSettings.getBladeRf2OutputSettings()->fromJsonObject(bladeRF2OutputSettingsJsonObject);
1955  return true;
1956  }
1957  else
1958  {
1959  return false;
1960  }
1961  }
1962  else if (*deviceHwType == "FCDPro")
1963  {
1964  if (jsonObject.contains("fcdProSettings") && jsonObject["fcdProSettings"].isObject())
1965  {
1966  QJsonObject fcdProSettingsJsonObject = jsonObject["fcdProSettings"].toObject();
1967  deviceSettingsKeys = fcdProSettingsJsonObject.keys();
1968  deviceSettings.setFcdProSettings(new SWGSDRangel::SWGFCDProSettings());
1969  deviceSettings.getFcdProSettings()->fromJsonObject(fcdProSettingsJsonObject);
1970  return true;
1971  }
1972  else
1973  {
1974  return false;
1975  }
1976  }
1977  else if (*deviceHwType == "FCDPro+")
1978  {
1979  if (jsonObject.contains("fcdProPlusSettings") && jsonObject["fcdProPlusSettings"].isObject())
1980  {
1981  QJsonObject fcdProPlusSettingsJsonObject = jsonObject["fcdProPlusSettings"].toObject();
1982  deviceSettingsKeys = fcdProPlusSettingsJsonObject.keys();
1983  deviceSettings.setFcdProPlusSettings(new SWGSDRangel::SWGFCDProPlusSettings());
1984  deviceSettings.getFcdProPlusSettings()->fromJsonObject(fcdProPlusSettingsJsonObject);
1985  return true;
1986  }
1987  else
1988  {
1989  return false;
1990  }
1991  }
1992  else if (*deviceHwType == "FileInput")
1993  {
1994  if (jsonObject.contains("fileInputSettings") && jsonObject["fileInputSettings"].isObject())
1995  {
1996  QJsonObject fileInputSettingsJsonObject = jsonObject["fileInputSettings"].toObject();
1997  deviceSettingsKeys = fileInputSettingsJsonObject.keys();
1998  deviceSettings.setFileInputSettings(new SWGSDRangel::SWGFileInputSettings());
1999  deviceSettings.getFileInputSettings()->fromJsonObject(fileInputSettingsJsonObject);
2000  return true;
2001  }
2002  else
2003  {
2004  return false;
2005  }
2006  }
2007  else if ((*deviceHwType == "HackRF") && (deviceSettings.getDirection() == 0))
2008  {
2009  if (jsonObject.contains("hackRFInputSettings") && jsonObject["hackRFInputSettings"].isObject())
2010  {
2011  QJsonObject hackRFInputSettingsJsonObject = jsonObject["hackRFInputSettings"].toObject();
2012  deviceSettingsKeys = hackRFInputSettingsJsonObject.keys();
2013  deviceSettings.setHackRfInputSettings(new SWGSDRangel::SWGHackRFInputSettings());
2014  deviceSettings.getHackRfInputSettings()->fromJsonObject(hackRFInputSettingsJsonObject);
2015  return true;
2016  }
2017  else
2018  {
2019  return false;
2020  }
2021  }
2022  else if ((*deviceHwType == "HackRF") && (deviceSettings.getDirection() == 1))
2023  {
2024  if (jsonObject.contains("hackRFOutputSettings") && jsonObject["hackRFOutputSettings"].isObject())
2025  {
2026  QJsonObject hackRFOutputSettingsJsonObject = jsonObject["hackRFOutputSettings"].toObject();
2027  deviceSettingsKeys = hackRFOutputSettingsJsonObject.keys();
2028  deviceSettings.setHackRfOutputSettings(new SWGSDRangel::SWGHackRFOutputSettings());
2029  deviceSettings.getHackRfOutputSettings()->fromJsonObject(hackRFOutputSettingsJsonObject);
2030  return true;
2031  }
2032  else
2033  {
2034  return false;
2035  }
2036  }
2037  else if ((*deviceHwType == "KiwiSDR") && (deviceSettings.getDirection() == 0))
2038  {
2039  if (jsonObject.contains("kiwiSDRSettings") && jsonObject["kiwiSDRSettings"].isObject())
2040  {
2041  QJsonObject kiwiSDRSettingsJsonObject = jsonObject["kiwiSDRSettings"].toObject();
2042  deviceSettingsKeys = kiwiSDRSettingsJsonObject.keys();
2043  deviceSettings.setKiwiSdrSettings(new SWGSDRangel::SWGKiwiSDRSettings());
2044  deviceSettings.getKiwiSdrSettings()->fromJsonObject(kiwiSDRSettingsJsonObject);
2045  return true;
2046  }
2047  else
2048  {
2049  return false;
2050  }
2051  }
2052  else if ((*deviceHwType == "LimeSDR") && (deviceSettings.getDirection() == 0))
2053  {
2054  if (jsonObject.contains("limeSdrInputSettings") && jsonObject["limeSdrInputSettings"].isObject())
2055  {
2056  QJsonObject limeSdrInputSettingsJsonObject = jsonObject["limeSdrInputSettings"].toObject();
2057  deviceSettingsKeys = limeSdrInputSettingsJsonObject.keys();
2058  deviceSettings.setLimeSdrInputSettings(new SWGSDRangel::SWGLimeSdrInputSettings());
2059  deviceSettings.getLimeSdrInputSettings()->fromJsonObject(limeSdrInputSettingsJsonObject);
2060  return true;
2061  }
2062  else
2063  {
2064  return false;
2065  }
2066  }
2067  else if ((*deviceHwType == "LimeSDR") && (deviceSettings.getDirection() == 1))
2068  {
2069  if (jsonObject.contains("limeSdrOutputSettings") && jsonObject["limeSdrOutputSettings"].isObject())
2070  {
2071  QJsonObject limeSdrOutputSettingsJsonObject = jsonObject["limeSdrOutputSettings"].toObject();
2072  deviceSettingsKeys = limeSdrOutputSettingsJsonObject.keys();
2073  deviceSettings.setLimeSdrOutputSettings(new SWGSDRangel::SWGLimeSdrOutputSettings());
2074  deviceSettings.getLimeSdrOutputSettings()->fromJsonObject(limeSdrOutputSettingsJsonObject);
2075  return true;
2076  }
2077  else
2078  {
2079  return false;
2080  }
2081  }
2082  else if (*deviceHwType == "Perseus")
2083  {
2084  if (jsonObject.contains("perseusSettings") && jsonObject["perseusSettings"].isObject())
2085  {
2086  QJsonObject perseusSettingsJsonObject = jsonObject["perseusSettings"].toObject();
2087  deviceSettingsKeys = perseusSettingsJsonObject.keys();
2088  deviceSettings.setPerseusSettings(new SWGSDRangel::SWGPerseusSettings());
2089  deviceSettings.getPerseusSettings()->fromJsonObject(perseusSettingsJsonObject);
2090  return true;
2091  }
2092  else
2093  {
2094  return false;
2095  }
2096  }
2097  else if ((*deviceHwType == "PlutoSDR") && (deviceSettings.getDirection() == 0))
2098  {
2099  if (jsonObject.contains("plutoSdrInputSettings") && jsonObject["plutoSdrInputSettings"].isObject())
2100  {
2101  QJsonObject plutoSdrInputSettingsJsonObject = jsonObject["plutoSdrInputSettings"].toObject();
2102  deviceSettingsKeys = plutoSdrInputSettingsJsonObject.keys();
2103  deviceSettings.setPlutoSdrInputSettings(new SWGSDRangel::SWGPlutoSdrInputSettings());
2104  deviceSettings.getPlutoSdrInputSettings()->fromJsonObject(plutoSdrInputSettingsJsonObject);
2105  return true;
2106  }
2107  else
2108  {
2109  return false;
2110  }
2111  }
2112  else if ((*deviceHwType == "PlutoSDR") && (deviceSettings.getDirection() == 1))
2113  {
2114  if (jsonObject.contains("plutoSdrOutputSettings") && jsonObject["plutoSdrOutputSettings"].isObject())
2115  {
2116  QJsonObject plutoSdrOutputSettingsJsonObject = jsonObject["plutoSdrOutputSettings"].toObject();
2117  deviceSettingsKeys = plutoSdrOutputSettingsJsonObject.keys();
2118  deviceSettings.setPlutoSdrOutputSettings(new SWGSDRangel::SWGPlutoSdrOutputSettings());
2119  deviceSettings.getPlutoSdrOutputSettings()->fromJsonObject(plutoSdrOutputSettingsJsonObject);
2120  return true;
2121  }
2122  else
2123  {
2124  return false;
2125  }
2126  }
2127  else if (*deviceHwType == "RTLSDR")
2128  {
2129  if (jsonObject.contains("rtlSdrSettings") && jsonObject["rtlSdrSettings"].isObject())
2130  {
2131  QJsonObject rtlSdrSettingsJsonObject = jsonObject["rtlSdrSettings"].toObject();
2132  deviceSettingsKeys = rtlSdrSettingsJsonObject.keys();
2133  deviceSettings.setRtlSdrSettings(new SWGSDRangel::SWGRtlSdrSettings());
2134  deviceSettings.getRtlSdrSettings()->fromJsonObject(rtlSdrSettingsJsonObject);
2135  return true;
2136  }
2137  else
2138  {
2139  return false;
2140  }
2141  }
2142  else if (*deviceHwType == "SDRplay1")
2143  {
2144  if (jsonObject.contains("sdrPlaySettings") && jsonObject["sdrPlaySettings"].isObject())
2145  {
2146  QJsonObject sdrPlaySettingsJsonObject = jsonObject["sdrPlaySettings"].toObject();
2147  deviceSettingsKeys = sdrPlaySettingsJsonObject.keys();
2148  deviceSettings.setSdrPlaySettings(new SWGSDRangel::SWGSDRPlaySettings());
2149  deviceSettings.getSdrPlaySettings()->fromJsonObject(sdrPlaySettingsJsonObject);
2150  return true;
2151  }
2152  else
2153  {
2154  return false;
2155  }
2156  }
2157  else if ((*deviceHwType == "SoapySDR") && (deviceSettings.getDirection() == 0))
2158  {
2159  if (jsonObject.contains("soapySDRInputSettings") && jsonObject["soapySDRInputSettings"].isObject())
2160  {
2161  QJsonObject soapySdrInputSettingsJsonObject = jsonObject["soapySDRInputSettings"].toObject();
2162  deviceSettingsKeys = soapySdrInputSettingsJsonObject.keys();
2163  deviceSettings.setSoapySdrInputSettings(new SWGSDRangel::SWGSoapySDRInputSettings());
2164  deviceSettings.getSoapySdrInputSettings()->init(); // contains complex objects
2165  deviceSettings.getSoapySdrInputSettings()->fromJsonObject(soapySdrInputSettingsJsonObject);
2166  return true;
2167  }
2168  else
2169  {
2170  return false;
2171  }
2172  }
2173  else if ((*deviceHwType == "SoapySDR") && (deviceSettings.getDirection() == 1))
2174  {
2175  if (jsonObject.contains("soapySDROutputSettings") && jsonObject["soapySDROutputSettings"].isObject())
2176  {
2177  QJsonObject soapySdrOutputSettingsJsonObject = jsonObject["soapySDROutputSettings"].toObject();
2178  deviceSettingsKeys = soapySdrOutputSettingsJsonObject.keys();
2179  deviceSettings.setSoapySdrOutputSettings(new SWGSDRangel::SWGSoapySDROutputSettings());
2180  deviceSettings.getSoapySdrInputSettings()->init(); // contains complex objects
2181  deviceSettings.getSoapySdrOutputSettings()->fromJsonObject(soapySdrOutputSettingsJsonObject);
2182  return true;
2183  }
2184  else
2185  {
2186  return false;
2187  }
2188  }
2189  else if (*deviceHwType == "TestSource")
2190  {
2191  if (jsonObject.contains("testSourceSettings") && jsonObject["testSourceSettings"].isObject())
2192  {
2193  QJsonObject testSourceSettingsJsonObject = jsonObject["testSourceSettings"].toObject();
2194  deviceSettingsKeys = testSourceSettingsJsonObject.keys();
2195  deviceSettings.setTestSourceSettings(new SWGSDRangel::SWGTestSourceSettings());
2196  deviceSettings.getTestSourceSettings()->fromJsonObject(testSourceSettingsJsonObject);
2197  return true;
2198  }
2199  else
2200  {
2201  return false;
2202  }
2203  }
2204  else if ((*deviceHwType == "TestMI") && (deviceSettings.getDirection() == 2))
2205  {
2206  if (jsonObject.contains("TestMISettings") && jsonObject["TestMISettings"].isObject())
2207  {
2208  QJsonObject testMISettingsJsonObject = jsonObject["TestMISettings"].toObject();
2209  deviceSettingsKeys = testMISettingsJsonObject.keys();
2210 
2211  if (deviceSettingsKeys.contains("streams") && testMISettingsJsonObject["streams"].isArray())
2212  {
2213  appendSettingsArrayKeys(testMISettingsJsonObject, "streams", deviceSettingsKeys);
2214  }
2215 
2216  deviceSettings.setTestMiSettings(new SWGSDRangel::SWGTestMISettings());
2217  deviceSettings.getTestMiSettings()->fromJsonObject(testMISettingsJsonObject);
2218  return true;
2219  }
2220  else
2221  {
2222  return false;
2223  }
2224  }
2225  else if ((*deviceHwType == "XTRX") && (deviceSettings.getDirection() == 0))
2226  {
2227  if (jsonObject.contains("xtrxInputSettings") && jsonObject["xtrxInputSettings"].isObject())
2228  {
2229  QJsonObject xtrxInputSettingsJsonObject = jsonObject["xtrxInputSettings"].toObject();
2230  deviceSettingsKeys = xtrxInputSettingsJsonObject.keys();
2231  deviceSettings.setXtrxInputSettings(new SWGSDRangel::SWGXtrxInputSettings());
2232  deviceSettings.getXtrxInputSettings()->fromJsonObject(xtrxInputSettingsJsonObject);
2233  return true;
2234  }
2235  else
2236  {
2237  return false;
2238  }
2239  }
2240  else if ((*deviceHwType == "XTRX") && (deviceSettings.getDirection() == 1))
2241  {
2242  if (jsonObject.contains("xtrxOutputSettings") && jsonObject["xtrxOutputSettings"].isObject())
2243  {
2244  QJsonObject xtrxOutputSettingsJsonObject = jsonObject["xtrxOutputSettings"].toObject();
2245  deviceSettingsKeys = xtrxOutputSettingsJsonObject.keys();
2246  deviceSettings.setXtrxOutputSettings(new SWGSDRangel::SWGXtrxOutputSettings());
2247  deviceSettings.getXtrxOutputSettings()->fromJsonObject(xtrxOutputSettingsJsonObject);
2248  return true;
2249  }
2250  else
2251  {
2252  return false;
2253  }
2254  }
2255  else if ((*deviceHwType == "RemoteInput") && (deviceSettings.getDirection() == 0))
2256  {
2257  if (jsonObject.contains("remoteInputSettings") && jsonObject["remoteInputSettings"].isObject())
2258  {
2259  QJsonObject remoteInputSettingsJsonObject = jsonObject["remoteInputSettings"].toObject();
2260  deviceSettingsKeys = remoteInputSettingsJsonObject.keys();
2261  deviceSettings.setRemoteInputSettings(new SWGSDRangel::SWGRemoteInputSettings());
2262  deviceSettings.getRemoteInputSettings()->fromJsonObject(remoteInputSettingsJsonObject);
2263  return true;
2264  }
2265  else
2266  {
2267  return false;
2268  }
2269  }
2270  else if ((*deviceHwType == "LocalInput") && (deviceSettings.getDirection() == 0))
2271  {
2272  if (jsonObject.contains("localInputSettings") && jsonObject["localInputSettings"].isObject())
2273  {
2274  QJsonObject localInputSettingsJsonObject = jsonObject["localInputSettings"].toObject();
2275  deviceSettingsKeys = localInputSettingsJsonObject.keys();
2276  deviceSettings.setLocalInputSettings(new SWGSDRangel::SWGLocalInputSettings());
2277  deviceSettings.getLocalInputSettings()->fromJsonObject(localInputSettingsJsonObject);
2278  return true;
2279  }
2280  else
2281  {
2282  return false;
2283  }
2284  }
2285  else if ((*deviceHwType == "RemoteOutput") && (deviceSettings.getDirection() == 1))
2286  {
2287  if (jsonObject.contains("remoteOutputSettings") && jsonObject["remoteOutputSettings"].isObject())
2288  {
2289  QJsonObject remoteOutputSettingsJsonObject = jsonObject["remoteOutputSettings"].toObject();
2290  deviceSettingsKeys = remoteOutputSettingsJsonObject.keys();
2291  deviceSettings.setRemoteOutputSettings(new SWGSDRangel::SWGRemoteOutputSettings());
2292  deviceSettings.getRemoteOutputSettings()->fromJsonObject(remoteOutputSettingsJsonObject);
2293  return true;
2294  }
2295  else
2296  {
2297  return false;
2298  }
2299  }
2300  else if ((*deviceHwType == "LocalOutput") && (deviceSettings.getDirection() == 1))
2301  {
2302  if (jsonObject.contains("localOutputSettings") && jsonObject["localOutputSettings"].isObject())
2303  {
2304  QJsonObject localOutputSettingsJsonObject = jsonObject["localOutputSettings"].toObject();
2305  deviceSettingsKeys = localOutputSettingsJsonObject.keys();
2306  deviceSettings.setLocalOutputSettings(new SWGSDRangel::SWGLocalOutputSettings());
2307  deviceSettings.getLocalOutputSettings()->fromJsonObject(localOutputSettingsJsonObject);
2308  return true;
2309  }
2310  else
2311  {
2312  return false;
2313  }
2314  }
2315  else
2316  {
2317  return false;
2318  }
2319 }
2320 
2321 bool WebAPIRequestMapper::validateChannelSettings(
2322  SWGSDRangel::SWGChannelSettings& channelSettings,
2323  QJsonObject& jsonObject,
2324  QStringList& channelSettingsKeys)
2325 {
2326  if (jsonObject.contains("direction")) {
2327  channelSettings.setDirection(jsonObject["direction"].toInt());
2328  } else {
2329  channelSettings.setDirection(0); // assume single Rx
2330  }
2331 
2332  if (jsonObject.contains("channelType") && jsonObject["channelType"].isString()) {
2333  channelSettings.setChannelType(new QString(jsonObject["channelType"].toString()));
2334  } else {
2335  return false;
2336  }
2337 
2338  QString *channelType = channelSettings.getChannelType();
2339 
2340  if (*channelType == "AMDemod")
2341  {
2342  if (channelSettings.getDirection() == 0)
2343  {
2344  QJsonObject amDemodSettingsJsonObject = jsonObject["AMDemodSettings"].toObject();
2345  channelSettingsKeys = amDemodSettingsJsonObject.keys();
2346  channelSettings.setAmDemodSettings(new SWGSDRangel::SWGAMDemodSettings());
2347  channelSettings.getAmDemodSettings()->fromJsonObject(amDemodSettingsJsonObject);
2348  return true;
2349  }
2350  else {
2351  return false;
2352  }
2353  }
2354  else if (*channelType == "AMMod")
2355  {
2356  if (channelSettings.getDirection() == 1)
2357  {
2358  QJsonObject amModSettingsJsonObject = jsonObject["AMModSettings"].toObject();
2359  channelSettingsKeys = amModSettingsJsonObject.keys();
2360 
2361  if (channelSettingsKeys.contains("cwKeyer"))
2362  {
2363  QJsonObject cwKeyerSettingsJsonObject;
2364  appendSettingsSubKeys(amModSettingsJsonObject, cwKeyerSettingsJsonObject, "cwKeyer", channelSettingsKeys);
2365  }
2366 
2367  channelSettings.setAmModSettings(new SWGSDRangel::SWGAMModSettings());
2368  channelSettings.getAmModSettings()->fromJsonObject(amModSettingsJsonObject);
2369  return true;
2370  }
2371  else {
2372  return false;
2373  }
2374  }
2375  else if (*channelType == "ATVMod")
2376  {
2377  if (channelSettings.getDirection() == 1)
2378  {
2379  QJsonObject atvModSettingsJsonObject = jsonObject["ATVModSettings"].toObject();
2380  channelSettingsKeys = atvModSettingsJsonObject.keys();
2381  channelSettings.setAtvModSettings(new SWGSDRangel::SWGATVModSettings());
2382  channelSettings.getAtvModSettings()->fromJsonObject(atvModSettingsJsonObject);
2383  return true;
2384  }
2385  else {
2386  return false;
2387  }
2388  }
2389  else if (*channelType == "BFMDemod")
2390  {
2391  if (channelSettings.getDirection() == 0)
2392  {
2393  QJsonObject bfmDemodSettingsJsonObject = jsonObject["BFMDemodSettings"].toObject();
2394  channelSettingsKeys = bfmDemodSettingsJsonObject.keys();
2395  channelSettings.setBfmDemodSettings(new SWGSDRangel::SWGBFMDemodSettings());
2396  channelSettings.getBfmDemodSettings()->fromJsonObject(bfmDemodSettingsJsonObject);
2397  return true;
2398  }
2399  else {
2400  return false;
2401  }
2402  }
2403  else if (*channelType == "DSDDemod")
2404  {
2405  if (channelSettings.getDirection() == 0)
2406  {
2407  QJsonObject dsdDemodSettingsJsonObject = jsonObject["DSDDemodSettings"].toObject();
2408  channelSettingsKeys = dsdDemodSettingsJsonObject.keys();
2409  channelSettings.setDsdDemodSettings(new SWGSDRangel::SWGDSDDemodSettings());
2410  channelSettings.getDsdDemodSettings()->fromJsonObject(dsdDemodSettingsJsonObject);
2411  return true;
2412  }
2413  else {
2414  return false;
2415  }
2416  }
2417  else if (*channelType == "FreeDVDemod")
2418  {
2419  if (channelSettings.getDirection() == 0)
2420  {
2421  QJsonObject freeDVDemodSettingsJsonObject = jsonObject["FreeDVDemodSettings"].toObject();
2422  channelSettingsKeys = freeDVDemodSettingsJsonObject.keys();
2423  channelSettings.setFreeDvDemodSettings(new SWGSDRangel::SWGFreeDVDemodSettings());
2424  channelSettings.getFreeDvDemodSettings()->fromJsonObject(freeDVDemodSettingsJsonObject);
2425  return true;
2426  }
2427  else {
2428  return false;
2429  }
2430  }
2431  else if (*channelType == "FreeDVMod")
2432  {
2433  if (channelSettings.getDirection() == 1)
2434  {
2435  QJsonObject freeDVModSettingsJsonObject = jsonObject["FreeDVModSettings"].toObject();
2436  channelSettingsKeys = freeDVModSettingsJsonObject.keys();
2437  channelSettings.setFreeDvModSettings(new SWGSDRangel::SWGFreeDVModSettings());
2438  channelSettings.getFreeDvModSettings()->fromJsonObject(freeDVModSettingsJsonObject);
2439  return true;
2440  }
2441  else {
2442  return false;
2443  }
2444  }
2445  else if (*channelType == "FreqTracker")
2446  {
2447  if (channelSettings.getDirection() == 0)
2448  {
2449  QJsonObject freqTrackerSettingsJsonObject = jsonObject["FreqTrackerSettings"].toObject();
2450  channelSettingsKeys = freqTrackerSettingsJsonObject.keys();
2451  channelSettings.setFreqTrackerSettings(new SWGSDRangel::SWGFreqTrackerSettings());
2452  channelSettings.getFreqTrackerSettings()->fromJsonObject(freqTrackerSettingsJsonObject);
2453  return true;
2454  }
2455  else {
2456  return false;
2457  }
2458  }
2459  else if (*channelType == "NFMDemod")
2460  {
2461  if (channelSettings.getDirection() == 0)
2462  {
2463  QJsonObject nfmDemodSettingsJsonObject = jsonObject["NFMDemodSettings"].toObject();
2464  channelSettingsKeys = nfmDemodSettingsJsonObject.keys();
2465  channelSettings.setNfmDemodSettings(new SWGSDRangel::SWGNFMDemodSettings());
2466  channelSettings.getNfmDemodSettings()->fromJsonObject(nfmDemodSettingsJsonObject);
2467  return true;
2468  }
2469  else {
2470  return false;
2471  }
2472  }
2473  else if (*channelType == "NFMMod")
2474  {
2475  if (channelSettings.getDirection() == 1)
2476  {
2477  QJsonObject nfmModSettingsJsonObject = jsonObject["NFMModSettings"].toObject();
2478  channelSettingsKeys = nfmModSettingsJsonObject.keys();
2479 
2480  if (channelSettingsKeys.contains("cwKeyer"))
2481  {
2482  QJsonObject cwKeyerSettingsJsonObject;
2483  appendSettingsSubKeys(nfmModSettingsJsonObject, cwKeyerSettingsJsonObject, "cwKeyer", channelSettingsKeys);
2484  }
2485 
2486  channelSettings.setNfmModSettings(new SWGSDRangel::SWGNFMModSettings());
2487  channelSettings.getNfmModSettings()->fromJsonObject(nfmModSettingsJsonObject);
2488  return true;
2489  }
2490  else {
2491  return false;
2492  }
2493  }
2494  else if (*channelType == "LocalSink")
2495  {
2496  if (channelSettings.getDirection() == 0)
2497  {
2498  QJsonObject localChannelSinkSettingsJsonObject = jsonObject["LocalSinkSettings"].toObject();
2499  channelSettingsKeys = localChannelSinkSettingsJsonObject.keys();
2500  channelSettings.setLocalSinkSettings(new SWGSDRangel::SWGLocalSinkSettings());
2501  channelSettings.getLocalSinkSettings()->fromJsonObject(localChannelSinkSettingsJsonObject);
2502  return true;
2503  }
2504  else {
2505  return false;
2506  }
2507  }
2508  else if (*channelType == "LocalSource")
2509  {
2510  if (channelSettings.getDirection() == 1)
2511  {
2512  QJsonObject localChannelSourceSettingsJsonObject = jsonObject["LocalSourceSettings"].toObject();
2513  channelSettingsKeys = localChannelSourceSettingsJsonObject.keys();
2514  channelSettings.setLocalSourceSettings(new SWGSDRangel::SWGLocalSourceSettings());
2515  channelSettings.getLocalSourceSettings()->fromJsonObject(localChannelSourceSettingsJsonObject);
2516  return true;
2517  }
2518  else {
2519  return false;
2520  }
2521  }
2522  else if (*channelType == "RemoteSink")
2523  {
2524  if (channelSettings.getDirection() == 0)
2525  {
2526  QJsonObject remoteChannelSinkSettingsJsonObject = jsonObject["RemoteSinkSettings"].toObject();
2527  channelSettingsKeys = remoteChannelSinkSettingsJsonObject.keys();
2528  channelSettings.setRemoteSinkSettings(new SWGSDRangel::SWGRemoteSinkSettings());
2529  channelSettings.getRemoteSinkSettings()->fromJsonObject(remoteChannelSinkSettingsJsonObject);
2530  return true;
2531  }
2532  else {
2533  return false;
2534  }
2535  }
2536  else if (*channelType == "RemoteSource")
2537  {
2538  if (channelSettings.getDirection() == 1)
2539  {
2540  QJsonObject remoteChannelSourceSettingsJsonObject = jsonObject["RemoteSourceSettings"].toObject();
2541  channelSettingsKeys = remoteChannelSourceSettingsJsonObject.keys();
2542  channelSettings.setRemoteSourceSettings(new SWGSDRangel::SWGRemoteSourceSettings());
2543  channelSettings.getRemoteSourceSettings()->fromJsonObject(remoteChannelSourceSettingsJsonObject);
2544  return true;
2545  }
2546  else {
2547  return false;
2548  }
2549  }
2550  else if (*channelType == "SSBDemod")
2551  {
2552  if (channelSettings.getDirection() == 0)
2553  {
2554  QJsonObject ssbDemodSettingsJsonObject = jsonObject["SSBDemodSettings"].toObject();
2555  channelSettingsKeys = ssbDemodSettingsJsonObject.keys();
2556  channelSettings.setSsbDemodSettings(new SWGSDRangel::SWGSSBDemodSettings());
2557  channelSettings.getSsbDemodSettings()->fromJsonObject(ssbDemodSettingsJsonObject);
2558  return true;
2559  }
2560  else {
2561  return false;
2562  }
2563  }
2564  else if (*channelType == "SSBMod")
2565  {
2566  if (channelSettings.getDirection() == 1)
2567  {
2568  QJsonObject ssbModSettingsJsonObject = jsonObject["SSBModSettings"].toObject();
2569  channelSettingsKeys = ssbModSettingsJsonObject.keys();
2570 
2571  if (channelSettingsKeys.contains("cwKeyer"))
2572  {
2573  QJsonObject cwKeyerSettingsJsonObject;
2574  appendSettingsSubKeys(ssbModSettingsJsonObject, cwKeyerSettingsJsonObject, "cwKeyer", channelSettingsKeys);
2575  }
2576 
2577  channelSettings.setSsbModSettings(new SWGSDRangel::SWGSSBModSettings());
2578  channelSettings.getSsbModSettings()->fromJsonObject(ssbModSettingsJsonObject);
2579  return true;
2580  }
2581  else {
2582  return false;
2583  }
2584  }
2585  else if (*channelType == "UDPSource")
2586  {
2587  if (channelSettings.getDirection() == 1)
2588  {
2589  QJsonObject udpSourceSettingsJsonObject = jsonObject["UDPSourceSettings"].toObject();
2590  channelSettingsKeys = udpSourceSettingsJsonObject.keys();
2591  channelSettings.setUdpSourceSettings(new SWGSDRangel::SWGUDPSourceSettings());
2592  channelSettings.getUdpSourceSettings()->fromJsonObject(udpSourceSettingsJsonObject);
2593  return true;
2594  }
2595  else {
2596  return false;
2597  }
2598  }
2599  else if (*channelType == "UDPSink")
2600  {
2601  if (channelSettings.getDirection() == 0)
2602  {
2603  QJsonObject udpSinkSettingsJsonObject = jsonObject["UDPSinkSettings"].toObject();
2604  channelSettingsKeys = udpSinkSettingsJsonObject.keys();
2605  channelSettings.setUdpSinkSettings(new SWGSDRangel::SWGUDPSinkSettings());
2606  channelSettings.getUdpSinkSettings()->fromJsonObject(udpSinkSettingsJsonObject);
2607  return true;
2608  }
2609  else {
2610  return false;
2611  }
2612  }
2613  else if (*channelType == "WFMDemod")
2614  {
2615  if (channelSettings.getDirection() == 0)
2616  {
2617  QJsonObject wfmDemodSettingsJsonObject = jsonObject["WFMDemodSettings"].toObject();
2618  channelSettingsKeys = wfmDemodSettingsJsonObject.keys();
2619  channelSettings.setWfmDemodSettings(new SWGSDRangel::SWGWFMDemodSettings());
2620  channelSettings.getWfmDemodSettings()->fromJsonObject(wfmDemodSettingsJsonObject);
2621  return true;
2622  }
2623  else {
2624  return false;
2625  }
2626  }
2627  else if (*channelType == "WFMMod")
2628  {
2629  if (channelSettings.getDirection() == 1)
2630  {
2631  QJsonObject wfmModSettingsJsonObject = jsonObject["WFMModSettings"].toObject();
2632  channelSettingsKeys = wfmModSettingsJsonObject.keys();
2633 
2634  if (channelSettingsKeys.contains("cwKeyer"))
2635  {
2636  QJsonObject cwKeyerSettingsJsonObject;
2637  appendSettingsSubKeys(wfmModSettingsJsonObject, cwKeyerSettingsJsonObject, "cwKeyer", channelSettingsKeys);
2638  }
2639 
2640  channelSettings.setWfmModSettings(new SWGSDRangel::SWGWFMModSettings());
2641  channelSettings.getWfmModSettings()->fromJsonObject(wfmModSettingsJsonObject);
2642  return true;
2643  }
2644  else {
2645  return false;
2646  }
2647  }
2648  else
2649  {
2650  return false;
2651  }
2652 }
2653 
2654 bool WebAPIRequestMapper::validateAudioInputDevice(
2655  SWGSDRangel::SWGAudioInputDevice& audioInputDevice,
2656  QJsonObject& jsonObject,
2657  QStringList& audioInputDeviceKeys)
2658 {
2659  if (jsonObject.contains("index")) {
2660  audioInputDevice.setIndex(jsonObject["index"].toInt());
2661  } else {
2662  audioInputDevice.setIndex(-1); // assume systam default
2663  }
2664  if (jsonObject.contains("sampleRate"))
2665  {
2666  audioInputDevice.setSampleRate(jsonObject["sampleRate"].toInt());
2667  audioInputDeviceKeys.append("sampleRate");
2668  }
2669  if (jsonObject.contains("volume"))
2670  {
2671  audioInputDevice.setVolume(jsonObject["volume"].toDouble());
2672  audioInputDeviceKeys.append("volume");
2673  }
2674  return true;
2675 }
2676 
2677 bool WebAPIRequestMapper::validateAudioOutputDevice(
2678  SWGSDRangel::SWGAudioOutputDevice& audioOutputDevice,
2679  QJsonObject& jsonObject,
2680  QStringList& audioOutputDeviceKeys)
2681 {
2682  if (jsonObject.contains("index")) {
2683  audioOutputDevice.setIndex(jsonObject["index"].toInt());
2684  } else {
2685  audioOutputDevice.setIndex(-1); // assume systam default
2686  }
2687  if (jsonObject.contains("sampleRate"))
2688  {
2689  audioOutputDevice.setSampleRate(jsonObject["sampleRate"].toInt());
2690  audioOutputDeviceKeys.append("sampleRate");
2691  }
2692  if (jsonObject.contains("copyToUDP"))
2693  {
2694  audioOutputDevice.setCopyToUdp(jsonObject["copyToUDP"].toInt() == 0 ? 0 : 1);
2695  audioOutputDeviceKeys.append("copyToUDP");
2696  }
2697  if (jsonObject.contains("udpUsesRTP"))
2698  {
2699  audioOutputDevice.setUdpUsesRtp(jsonObject["udpUsesRTP"].toInt() == 0 ? 0 : 1);
2700  audioOutputDeviceKeys.append("udpUsesRTP");
2701  }
2702  if (jsonObject.contains("udpChannelMode"))
2703  {
2704  audioOutputDevice.setUdpChannelMode(jsonObject["udpChannelMode"].toInt());
2705  audioOutputDeviceKeys.append("udpChannelMode");
2706  }
2707  if (jsonObject.contains("udpChannelCodec"))
2708  {
2709  audioOutputDevice.setUdpChannelCodec(jsonObject["udpChannelCodec"].toInt());
2710  audioOutputDeviceKeys.append("udpChannelCodec");
2711  }
2712  if (jsonObject.contains("udpDecimationFactor"))
2713  {
2714  audioOutputDevice.setUdpDecimationFactor(jsonObject["udpDecimationFactor"].toInt());
2715  audioOutputDeviceKeys.append("udpDecimationFactor");
2716  }
2717  if (jsonObject.contains("udpAddress"))
2718  {
2719  audioOutputDevice.setUdpAddress(new QString(jsonObject["udpAddress"].toString()));
2720  audioOutputDeviceKeys.append("udpAddress");
2721  }
2722  if (jsonObject.contains("udpPort"))
2723  {
2724  audioOutputDevice.setUdpPort(jsonObject["udpPort"].toInt());
2725  audioOutputDeviceKeys.append("udpPort");
2726  }
2727  return true;
2728 }
2729 
2730 bool WebAPIRequestMapper::validateAMBEDevices(SWGSDRangel::SWGAMBEDevices& ambeDevices, QJsonObject& jsonObject)
2731 {
2732  if (jsonObject.contains("nbDevices"))
2733  {
2734  int nbDevices = jsonObject["nbDevices"].toInt();
2735 
2736  if (jsonObject.contains("ambeDevices"))
2737  {
2738  QJsonArray ambeDevicesJson = jsonObject["ambeDevices"].toArray();
2739 
2740  if (nbDevices != ambeDevicesJson.size()) {
2741  return false;
2742  }
2743 
2744  ambeDevices.init();
2745  ambeDevices.setNbDevices(nbDevices);
2746  QList<SWGSDRangel::SWGAMBEDevice *> *ambeList = ambeDevices.getAmbeDevices();
2747 
2748  for (int i = 0; i < nbDevices; i++)
2749  {
2750  QJsonObject ambeDeviceJson = ambeDevicesJson.at(i).toObject();
2751  if (ambeDeviceJson.contains("deviceRef") && ambeDeviceJson.contains("delete"))
2752  {
2753  ambeList->push_back(new SWGSDRangel::SWGAMBEDevice());
2754  ambeList->back()->init();
2755  ambeList->back()->setDeviceRef(new QString(ambeDeviceJson["deviceRef"].toString()));
2756  ambeList->back()->setDelete(ambeDeviceJson["delete"].toInt());
2757  }
2758  else
2759  {
2760  return false;
2761  }
2762  }
2763 
2764  return true;
2765  }
2766  }
2767 
2768  return false;
2769 }
2770 
2771 void WebAPIRequestMapper::appendSettingsSubKeys(
2772  const QJsonObject& parentSettingsJsonObject,
2773  QJsonObject& childSettingsJsonObject,
2774  const QString& parentKey,
2775  QStringList& keyList)
2776 {
2777  childSettingsJsonObject = parentSettingsJsonObject[parentKey].toObject();
2778  QStringList childSettingsKeys = childSettingsJsonObject.keys();
2779 
2780  for (int i = 0; i < childSettingsKeys.size(); i++) {
2781  keyList.append(parentKey + QString(".") + childSettingsKeys.at(i));
2782  }
2783 }
2784 
2785 void WebAPIRequestMapper::appendSettingsArrayKeys(
2786  const QJsonObject& parentSettingsJsonObject,
2787  const QString& parentKey,
2788  QStringList& keyList)
2789 {
2790  QJsonArray streams = parentSettingsJsonObject[parentKey].toArray();
2791 
2792  for (int istream = 0; istream < streams.count(); istream++)
2793  {
2794  QJsonValue v = streams.takeAt(istream);
2795 
2796  if (v.isObject())
2797  {
2798  QJsonObject streamSettingsJsonObject = v.toObject();
2799  QStringList streamSettingsKeys = streamSettingsJsonObject.keys();
2800 
2801  for (int i = 0; i < streamSettingsKeys.size(); i++) {
2802  keyList.append(tr("streams[%1].%2").arg(istream).arg(streamSettingsKeys[i]));
2803  }
2804  }
2805  }
2806 }
2807 
2808 
2809 void WebAPIRequestMapper::resetDeviceSettings(SWGSDRangel::SWGDeviceSettings& deviceSettings)
2810 {
2811  deviceSettings.cleanup();
2812  deviceSettings.setDeviceHwType(0);
2813  deviceSettings.setAirspySettings(0);
2814  deviceSettings.setAirspyHfSettings(0);
2815  deviceSettings.setBladeRf1InputSettings(0);
2816  deviceSettings.setBladeRf1OutputSettings(0);
2817  deviceSettings.setFcdProPlusSettings(0);
2818  deviceSettings.setFcdProSettings(0);
2819  deviceSettings.setFileInputSettings(0);
2820  deviceSettings.setHackRfInputSettings(0);
2821  deviceSettings.setHackRfOutputSettings(0);
2822  deviceSettings.setLimeSdrInputSettings(0);
2823  deviceSettings.setLimeSdrOutputSettings(0);
2824  deviceSettings.setPerseusSettings(0);
2825  deviceSettings.setPlutoSdrInputSettings(0);
2826  deviceSettings.setPlutoSdrOutputSettings(0);
2827  deviceSettings.setRtlSdrSettings(0);
2828  deviceSettings.setRemoteOutputSettings(0);
2829  deviceSettings.setRemoteInputSettings(0);
2830  deviceSettings.setSdrPlaySettings(0);
2831  deviceSettings.setTestSourceSettings(0);
2832 }
2833 
2834 void WebAPIRequestMapper::resetDeviceReport(SWGSDRangel::SWGDeviceReport& deviceReport)
2835 {
2836  deviceReport.cleanup();
2837  deviceReport.setDeviceHwType(0);
2838  deviceReport.setAirspyHfReport(0);
2839  deviceReport.setAirspyReport(0);
2840  deviceReport.setFileInputReport(0);
2841  deviceReport.setLimeSdrInputReport(0);
2842  deviceReport.setLimeSdrOutputReport(0);
2843  deviceReport.setPerseusReport(0);
2844  deviceReport.setPlutoSdrInputReport(0);
2845  deviceReport.setPlutoSdrOutputReport(0);
2846  deviceReport.setRtlSdrReport(0);
2847  deviceReport.setRemoteOutputReport(0);
2848  deviceReport.setRemoteInputReport(0);
2849  deviceReport.setSdrPlayReport(0);
2850 }
2851 
2852 void WebAPIRequestMapper::resetChannelSettings(SWGSDRangel::SWGChannelSettings& channelSettings)
2853 {
2854  channelSettings.cleanup();
2855  channelSettings.setChannelType(0);
2856  channelSettings.setAmDemodSettings(0);
2857  channelSettings.setAmModSettings(0);
2858  channelSettings.setAtvModSettings(0);
2859  channelSettings.setBfmDemodSettings(0);
2860  channelSettings.setDsdDemodSettings(0);
2861  channelSettings.setNfmDemodSettings(0);
2862  channelSettings.setNfmModSettings(0);
2863  channelSettings.setRemoteSinkSettings(0);
2864  channelSettings.setRemoteSourceSettings(0);
2865  channelSettings.setSsbDemodSettings(0);
2866  channelSettings.setSsbModSettings(0);
2867  channelSettings.setUdpSourceSettings(0);
2868  channelSettings.setUdpSinkSettings(0);
2869  channelSettings.setWfmDemodSettings(0);
2870  channelSettings.setWfmModSettings(0);
2871 }
2872 
2873 void WebAPIRequestMapper::resetChannelReport(SWGSDRangel::SWGChannelReport& channelReport)
2874 {
2875  channelReport.cleanup();
2876  channelReport.setChannelType(0);
2877  channelReport.setAmDemodReport(0);
2878  channelReport.setAmModReport(0);
2879  channelReport.setAtvModReport(0);
2880  channelReport.setBfmDemodReport(0);
2881  channelReport.setDsdDemodReport(0);
2882  channelReport.setNfmDemodReport(0);
2883  channelReport.setNfmModReport(0);
2884  channelReport.setRemoteSourceReport(0);
2885  channelReport.setSsbDemodReport(0);
2886  channelReport.setSsbModReport(0);
2887  channelReport.setUdpSourceReport(0);
2888  channelReport.setUdpSinkReport(0);
2889  channelReport.setWfmDemodReport(0);
2890  channelReport.setWfmModReport(0);
2891 }
2892 
2893 void WebAPIRequestMapper::resetAudioInputDevice(SWGSDRangel::SWGAudioInputDevice& audioInputDevice)
2894 {
2895  audioInputDevice.cleanup();
2896  audioInputDevice.setName(0);
2897 }
2898 
2899 void WebAPIRequestMapper::resetAudioOutputDevice(SWGSDRangel::SWGAudioOutputDevice& audioOutputDevice)
2900 {
2901  audioOutputDevice.cleanup();
2902  audioOutputDevice.setName(0);
2903  audioOutputDevice.setUdpAddress(0);
2904 }
SWGSDRangel::SWGSoapySDRInputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGSoapySDRInputSettings.cpp:219
WebAPIAdapterInterface::devicesetDeviceRunGet
virtual int devicesetDeviceRunGet(int deviceSetIndex, SWGSDRangel::SWGDeviceState &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:615
WebAPIRequestMapper::WebAPIRequestMapper
WebAPIRequestMapper(QObject *parent=0)
Definition: webapirequestmapper.cpp:50
SWGSDRangel::SWGHackRFInputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGHackRFInputSettings.cpp:144
WebAPIAdapterInterface::devicesetFocusPatch
virtual int devicesetFocusPatch(int deviceSetIndex, SWGSDRangel::SWGSuccessResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:545
WebAPIRequestMapper::m_staticFileController
qtwebapp::StaticFileController * m_staticFileController
Definition: webapirequestmapper.h:49
SWGSDRangel::SWGRemoteSourceSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGRemoteSourceSettings.cpp:106
SWGSDRangel::SWGFreqTrackerSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGFreqTrackerSettings.cpp:149
WebAPIRequestMapper::resetChannelSettings
void resetChannelSettings(SWGSDRangel::SWGChannelSettings &deviceSettings)
Definition: webapirequestmapper.cpp:2852
qtwebapp::HttpRequest::getBody
QByteArray getBody() const
Definition: httprequest.cpp:396
SWGSDRangel::SWGDeviceListItem::setDeviceStreamIndex
void setDeviceStreamIndex(qint32 device_stream_index)
Definition: SWGDeviceListItem.cpp:237
SWGSDRangel::SWGChannelSettings::setSsbDemodSettings
void setSsbDemodSettings(SWGSSBDemodSettings *ssb_demod_settings)
Definition: SWGChannelSettings.cpp:575
SWGSDRangel::SWGDeviceReport::setSdrPlayReport
void setSdrPlayReport(SWGSDRPlayReport *sdr_play_report)
Definition: SWGDeviceReport.cpp:535
SWGSDRangel::SWGDeviceReport::setLimeSdrOutputReport
void setLimeSdrOutputReport(SWGLimeSdrOutputReport *lime_sdr_output_report)
Definition: SWGDeviceReport.cpp:445
SWGSDRangel::SWGDeviceReport::setDeviceHwType
void setDeviceHwType(QString *device_hw_type)
Definition: SWGDeviceReport.cpp:355
SWGSDRangel::SWGBladeRF1InputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGBladeRF1InputSettings.cpp:149
WebAPIRequestMapper::validateAudioInputDevice
bool validateAudioInputDevice(SWGSDRangel::SWGAudioInputDevice &audioInputDevice, QJsonObject &jsonObject, QStringList &audioInputDeviceKeys)
Definition: webapirequestmapper.cpp:2654
WebAPIAdapterInterface::instanceDeviceSetDelete
virtual int instanceDeviceSetDelete(SWGSDRangel::SWGSuccessResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:515
SWGSDRangel::SWGChannelReport::setSsbModReport
void setSsbModReport(SWGSSBModReport *ssb_mod_report)
Definition: SWGChannelReport.cpp:469
WebAPIAdapterInterface::instanceAMBEDevicesDelete
virtual int instanceAMBEDevicesDelete(SWGSDRangel::SWGSuccessResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:363
SWGSDRangel::SWGNFMDemodSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGNFMDemodSettings.cpp:161
SWGSDRangel::SWGChannelSettings::getLocalSourceSettings
SWGLocalSourceSettings * getLocalSourceSettings()
Definition: SWGChannelSettings.cpp:531
SWGSDRangel::SWGDeviceSettings::setLocalInputSettings
void setLocalInputSettings(SWGLocalInputSettings *local_input_settings)
Definition: SWGDeviceSettings.cpp:631
SWGSDRangel::SWGDeviceSettings::getFcdProSettings
SWGFCDProSettings * getFcdProSettings()
Definition: SWGDeviceSettings.cpp:547
WebAPIAdapterInterface::instancePresetDelete
virtual int instancePresetDelete(SWGSDRangel::SWGPresetIdentifier &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:439
SWGSDRangel::SWGDeviceSettings::getLocalInputSettings
SWGLocalInputSettings * getLocalInputSettings()
Definition: SWGDeviceSettings.cpp:627
WebAPIAdapterInterface::devicesetChannelSettingsGet
virtual int devicesetChannelSettingsGet(int deviceSetIndex, int channelIndex, SWGSDRangel::SWGChannelSettings &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:732
WebAPIRequestMapper::instanceAMBEDevicesService
void instanceAMBEDevicesService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:673
SWGSDRangel::SWGDeviceSettings::setBladeRf1OutputSettings
void setBladeRf1OutputSettings(SWGBladeRF1OutputSettings *blade_rf1_output_settings)
Definition: SWGDeviceSettings.cpp:531
SWGSDRangel::SWGDeviceSettings::setBladeRf1InputSettings
void setBladeRf1InputSettings(SWGBladeRF1InputSettings *blade_rf1_input_settings)
Definition: SWGDeviceSettings.cpp:511
WebAPIRequestMapper::devicesetDeviceService
void devicesetDeviceService(const std::string &indexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1190
SWGSDRangel::SWGChannelSettings::setBfmDemodSettings
void setBfmDemodSettings(SWGBFMDemodSettings *bfm_demod_settings)
Definition: SWGChannelSettings.cpp:445
SWGSDRangel::SWGPresetImport::fromJson
virtual SWGPresetImport * fromJson(QString &jsonString) override
Definition: SWGPresetImport.cpp:67
WebAPIAdapterInterface::instanceSummary
virtual int instanceSummary(SWGSDRangel::SWGInstanceSummaryResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:69
WebAPIAdapterInterface::devicesetDeviceSettingsURLRe
static std::regex devicesetDeviceSettingsURLRe
Definition: webapiadapterinterface.h:808
SWGSDRangel::SWGChannelReport::setSsbDemodReport
void setSsbDemodReport(SWGSSBDemodReport *ssb_demod_report)
Definition: SWGChannelReport.cpp:449
SWGSDRangel::SWGDeviceSettings::getBladeRf2OutputSettings
SWGBladeRF2OutputSettings * getBladeRf2OutputSettings()
Definition: SWGDeviceSettings.cpp:537
WebAPIRequestMapper::instanceChannelsService
void instanceChannelsService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:277
SWGSDRangel::SWGDeviceSettings::setPlutoSdrOutputSettings
void setPlutoSdrOutputSettings(SWGPlutoSdrOutputSettings *pluto_sdr_output_settings)
Definition: SWGDeviceSettings.cpp:671
SWGSDRangel::SWGChannelSettings::getNfmDemodSettings
SWGNFMDemodSettings * getNfmDemodSettings()
Definition: SWGChannelSettings.cpp:501
WebAPIRequestMapper::validateAudioOutputDevice
bool validateAudioOutputDevice(SWGSDRangel::SWGAudioOutputDevice &audioOutputDevice, QJsonObject &jsonObject, QStringList &audioOutputDeviceKeys)
Definition: webapirequestmapper.cpp:2677
WebAPIRequestMapper::instanceAMBESerialService
void instanceAMBESerialService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:645
SWGSDRangel::SWGDeviceReport::setPerseusReport
void setPerseusReport(SWGPerseusReport *perseus_report)
Definition: SWGDeviceReport.cpp:475
WebAPIRequestMapper::devicesetChannelSettingsService
void devicesetChannelSettingsService(const std::string &deviceSetIndexStr, const std::string &channelIndexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1602
SWGSDRangel::SWGNFMModSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGNFMModSettings.cpp:163
SWGSDRangel::SWGDeviceSettings::setLimeSdrInputSettings
void setLimeSdrInputSettings(SWGLimeSdrInputSettings *lime_sdr_input_settings)
Definition: SWGDeviceSettings.cpp:611
SWGSDRangel::SWGDeviceState::asJson
virtual QString asJson() override
Definition: SWGDeviceState.cpp:68
WebAPIAdapterInterface::devicesetDeviceReportURLRe
static std::regex devicesetDeviceReportURLRe
Definition: webapiadapterinterface.h:810
SWGSDRangel::SWGChannelSettings::setWfmDemodSettings
void setWfmDemodSettings(SWGWFMDemodSettings *wfm_demod_settings)
Definition: SWGChannelSettings.cpp:605
WebAPIRequestMapper::instanceConfigService
void instanceConfigService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:218
SWGSDRangel::SWGDeviceSettings::getSdrPlaySettings
SWGSDRPlaySettings * getSdrPlaySettings()
Definition: SWGDeviceSettings.cpp:707
SWGSDRangel::SWGChannelSettings::setNfmModSettings
void setNfmModSettings(SWGNFMModSettings *nfm_mod_settings)
Definition: SWGChannelSettings.cpp:515
SWGSDRangel::SWGDeviceReport::setRemoteInputReport
void setRemoteInputReport(SWGRemoteInputReport *remote_input_report)
Definition: SWGDeviceReport.cpp:525
SWGSDRangel::SWGDeviceSettings::setXtrxInputSettings
void setXtrxInputSettings(SWGXtrxInputSettings *xtrx_input_settings)
Definition: SWGDeviceSettings.cpp:761
WebAPIRequestMapper::devicesetChannelService
void devicesetChannelService(const std::string &deviceSetIndexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1480
SWGSDRangel::SWGDeviceSettings::getTestSourceSettings
SWGTestSourceSettings * getTestSourceSettings()
Definition: SWGDeviceSettings.cpp:737
SWGSDRangel::SWGAudioDevices::asJson
virtual QString asJson() override
Definition: SWGAudioDevices.cpp:99
SWGSDRangel::SWGChannelReport::setRemoteSourceReport
void setRemoteSourceReport(SWGRemoteSourceReport *remote_source_report)
Definition: SWGChannelReport.cpp:459
WebAPIRequestMapper::devicesetDeviceSettingsService
void devicesetDeviceSettingsService(const std::string &indexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1254
SWGSDRangel::SWGDeviceSettings::getBladeRf1OutputSettings
SWGBladeRF1OutputSettings * getBladeRf1OutputSettings()
Definition: SWGDeviceSettings.cpp:527
SWGSDRangel::SWGDeviceSettings::asJson
virtual QString asJson() override
Definition: SWGDeviceSettings.cpp:343
WebAPIAdapterInterface::instanceLocationGet
virtual int instanceLocationGet(SWGSDRangel::SWGLocationInformation &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:275
qtwebapp::HttpRequest::getParameter
QByteArray getParameter(const QByteArray &name) const
Definition: httprequest.cpp:381
SWGSDRangel::SWGChannelSettings::setWfmModSettings
void setWfmModSettings(SWGWFMModSettings *wfm_mod_settings)
Definition: SWGChannelSettings.cpp:615
WebAPIAdapterInterface::instanceAudioOutputParametersURL
static QString instanceAudioOutputParametersURL
Definition: webapiadapterinterface.h:794
SWGSDRangel::SWGDeviceSetList::asJson
virtual QString asJson() override
Definition: SWGDeviceSetList.cpp:86
SWGSDRangel::SWGDeviceSettings::getLimeSdrOutputSettings
SWGLimeSdrOutputSettings * getLimeSdrOutputSettings()
Definition: SWGDeviceSettings.cpp:617
WebAPIRequestMapper::validatePresetTransfer
bool validatePresetTransfer(SWGSDRangel::SWGPresetTransfer &presetTransfer)
Definition: webapirequestmapper.cpp:1766
SWGSDRangel::SWGLocalInputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGLocalInputSettings.cpp:94
WebAPIRequestMapper::validatePresetExport
bool validatePresetExport(SWGSDRangel::SWGPresetExport &presetExport)
Definition: webapirequestmapper.cpp:1782
WebAPIRequestMapper::resetDeviceSettings
void resetDeviceSettings(SWGSDRangel::SWGDeviceSettings &deviceSettings)
Definition: webapirequestmapper.cpp:2809
WebAPIRequestMapper::devicesetDeviceReportService
void devicesetDeviceReportService(const std::string &indexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1403
SWGSDRangel::SWGDeviceSettings::getRtlSdrSettings
SWGRtlSdrSettings * getRtlSdrSettings()
Definition: SWGDeviceSettings.cpp:677
qtwebapp::HttpRequest::getPath
QByteArray getPath() const
Definition: httprequest.cpp:348
SWGSDRangel::SWGDeviceSettings::getPerseusSettings
SWGPerseusSettings * getPerseusSettings()
Definition: SWGDeviceSettings.cpp:647
SWGSDRangel::SWGChannelReport::setDsdDemodReport
void setDsdDemodReport(SWGDSDDemodReport *dsd_demod_report)
Definition: SWGChannelReport.cpp:379
SWGSDRangel::SWGDeviceSettings::setSoapySdrOutputSettings
void setSoapySdrOutputSettings(SWGSoapySDROutputSettings *soapy_sdr_output_settings)
Definition: SWGDeviceSettings.cpp:731
WebAPIAdapterInterface::devicesetChannelSettingsPutPatch
virtual int devicesetChannelSettingsPutPatch(int deviceSetIndex, int channelIndex, bool force, const QStringList &channelSettingsKeys, SWGSDRangel::SWGChannelSettings &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:750
WebAPIAdapterInterface::instanceLoggingGet
virtual int instanceLoggingGet(SWGSDRangel::SWGLoggingInfo &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:143
WebAPIAdapterInterface::devicesetDeviceReportGet
virtual int devicesetDeviceReportGet(int deviceSetIndex, SWGSDRangel::SWGDeviceReport &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:663
SWGSDRangel::SWGAMDemodSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGAMDemodSettings.cpp:146
SWGSDRangel::SWGErrorResponse::asJson
virtual QString asJson() override
Definition: SWGErrorResponse.cpp:68
WebAPIAdapterInterface::instanceAudioOutputCleanupURL
static QString instanceAudioOutputCleanupURL
Definition: webapiadapterinterface.h:796
SWGSDRangel::SWGDeviceSettings::setSdrPlaySettings
void setSdrPlaySettings(SWGSDRPlaySettings *sdr_play_settings)
Definition: SWGDeviceSettings.cpp:711
SWGSDRangel::SWGATVModSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGATVModSettings.cpp:205
SWGSDRangel::SWGLocalSinkSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGLocalSinkSettings.cpp:109
SWGSDRangel::SWGBFMDemodSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGBFMDemodSettings.cpp:146
SWGSDRangel::SWGChannelSettings::setNfmDemodSettings
void setNfmDemodSettings(SWGNFMDemodSettings *nfm_demod_settings)
Definition: SWGChannelSettings.cpp:505
SWGSDRangel::SWGDeviceSettings::getSoapySdrOutputSettings
SWGSoapySDROutputSettings * getSoapySdrOutputSettings()
Definition: SWGDeviceSettings.cpp:727
SWGSDRangel::SWGDeviceSettings::setPerseusSettings
void setPerseusSettings(SWGPerseusSettings *perseus_settings)
Definition: SWGDeviceSettings.cpp:651
SWGSDRangel::SWGDeviceListItem::setDirection
void setDirection(qint32 direction)
Definition: SWGDeviceListItem.cpp:217
SWGSDRangel::SWGChannelSettings::getUdpSourceSettings
SWGUDPSourceSettings * getUdpSourceSettings()
Definition: SWGChannelSettings.cpp:581
SWGSDRangel::SWGSoapySDROutputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGSoapySDROutputSettings.cpp:197
SWGSDRangel::SWGDeviceSettings::getAirspySettings
SWGAirspySettings * getAirspySettings()
Definition: SWGDeviceSettings.cpp:487
WebAPIRequestMapper::validateAMBEDevices
bool validateAMBEDevices(SWGSDRangel::SWGAMBEDevices &ambeDevices, QJsonObject &jsonObject)
Definition: webapirequestmapper.cpp:2730
SWGSDRangel::SWGAMModSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGAMModSettings.cpp:148
SWGSDRangel::SWGChannelSettings::getFreqTrackerSettings
SWGFreqTrackerSettings * getFreqTrackerSettings()
Definition: SWGChannelSettings.cpp:491
WebAPIRequestMapper::instanceAudioService
void instanceAudioService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:369
SWGSDRangel::SWGDVSerialDevices::asJson
virtual QString asJson() override
Definition: SWGDVSerialDevices.cpp:79
WebAPIRequestMapper::instanceAudioOutputCleanupService
void instanceAudioOutputCleanupService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:563
SWGSDRangel::SWGDeviceSettings::getPlutoSdrOutputSettings
SWGPlutoSdrOutputSettings * getPlutoSdrOutputSettings()
Definition: SWGDeviceSettings.cpp:667
SWGSDRangel::SWGDeviceReport::setAirspyReport
void setAirspyReport(SWGAirspyReport *airspy_report)
Definition: SWGDeviceReport.cpp:375
qtwebapp::HttpResponse::setHeader
void setHeader(QByteArray name, QByteArray value)
Definition: httpresponse.cpp:20
WebAPIAdapterInterface::devicesetDeviceRunPost
virtual int devicesetDeviceRunPost(int deviceSetIndex, SWGSDRangel::SWGDeviceState &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:631
WebAPIRequestMapper::devicesetChannelsReportService
void devicesetChannelsReportService(const std::string &deviceSetIndexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1442
WebAPIAdapterInterface::instanceAMBESerialGet
virtual int instanceAMBESerialGet(SWGSDRangel::SWGDVSerialDevices &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:303
WebAPIRequestMapper::validatePresetIdentifer
bool validatePresetIdentifer(SWGSDRangel::SWGPresetIdentifier &presetIdentifier)
Definition: webapirequestmapper.cpp:1777
SWGSDRangel::SWGChannelSettings::setChannelType
void setChannelType(QString *channel_type)
Definition: SWGChannelSettings.cpp:375
SWGSDRangel::SWGDeviceSettings::getTestMiSettings
SWGTestMISettings * getTestMiSettings()
Definition: SWGDeviceSettings.cpp:747
SWGSDRangel::SWGLocationInformation::fromJson
virtual SWGLocationInformation * fromJson(QString &jsonString) override
Definition: SWGLocationInformation.cpp:56
SWGSDRangel::SWGPresetTransfer::fromJson
virtual SWGPresetTransfer * fromJson(QString &jsonString) override
Definition: SWGPresetTransfer.cpp:58
SWGSDRangel::SWGChannelSettings::setLocalSinkSettings
void setLocalSinkSettings(SWGLocalSinkSettings *local_sink_settings)
Definition: SWGChannelSettings.cpp:525
SWGSDRangel::SWGRtlSdrSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGRtlSdrSettings.cpp:159
SWGSDRangel::SWGPerseusSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGPerseusSettings.cpp:134
SWGSDRangel::SWGUDPSourceSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGUDPSourceSettings.cpp:181
SWGSDRangel::SWGPresets::asJson
virtual QString asJson() override
Definition: SWGPresets.cpp:79
SWGSDRangel::SWGDeviceSet::asJson
virtual QString asJson() override
Definition: SWGDeviceSet.cpp:88
SWGSDRangel::SWGRemoteInputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGRemoteInputSettings.cpp:118
WebAPIRequestMapper::devicesetService
void devicesetService(const std::string &indexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1112
SWGSDRangel::SWGDeviceSettings::setAirspySettings
void setAirspySettings(SWGAirspySettings *airspy_settings)
Definition: SWGDeviceSettings.cpp:491
SWGSDRangel::SWGChannelReport::setUdpSinkReport
void setUdpSinkReport(SWGUDPSinkReport *udp_sink_report)
Definition: SWGChannelReport.cpp:489
arg
Fixed< IntType, IntBits > arg(const std::complex< Fixed< IntType, IntBits > > &val)
Definition: fixed.h:2401
SWGSDRangel::SWGChannelSettings::setRemoteSourceSettings
void setRemoteSourceSettings(SWGRemoteSourceSettings *remote_source_settings)
Definition: SWGChannelSettings.cpp:555
WebAPIAdapterInterface::devicesetDeviceRunDelete
virtual int devicesetDeviceRunDelete(int deviceSetIndex, SWGSDRangel::SWGDeviceState &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:647
SWGSDRangel::SWGPresetTransfer::getPreset
SWGPresetIdentifier * getPreset()
Definition: SWGPresetTransfer.cpp:109
WebAPIAdapterInterface::instanceAudioInputCleanupPatch
virtual int instanceAudioInputCleanupPatch(SWGSDRangel::SWGSuccessResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:247
WebAPIAdapterInterface::devicesetGet
virtual int devicesetGet(int deviceSetIndex, SWGSDRangel::SWGDeviceSet &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:529
SWGSDRangel::SWGChannelsDetail::asJson
virtual QString asJson() override
Definition: SWGChannelsDetail.cpp:79
WebAPIAdapterInterface::instancePresetPut
virtual int instancePresetPut(SWGSDRangel::SWGPresetTransfer &query, SWGSDRangel::SWGPresetIdentifier &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:407
WebAPIRequestMapper::devicesetChannelIndexService
void devicesetChannelIndexService(const std::string &deviceSetIndexStr, const std::string &channelIndexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1557
SWGSDRangel::SWGLocalOutputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGLocalOutputSettings.cpp:77
WebAPIRequestMapper::appendSettingsArrayKeys
void appendSettingsArrayKeys(const QJsonObject &parentSettingsJsonObject, const QString &parentKey, QStringList &keyList)
Definition: webapirequestmapper.cpp:2785
SWGSDRangel::SWGPresetExport::getPreset
SWGPresetIdentifier * getPreset()
Definition: SWGPresetExport.cpp:111
SWGSDRangel::SWGDeviceSettings::getBladeRf1InputSettings
SWGBladeRF1InputSettings * getBladeRf1InputSettings()
Definition: SWGDeviceSettings.cpp:507
SWGSDRangel::SWGXtrxOutputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGXtrxOutputSettings.cpp:137
SWGSDRangel::SWGDeviceSettings::getLocalOutputSettings
SWGLocalOutputSettings * getLocalOutputSettings()
Definition: SWGDeviceSettings.cpp:637
WebAPIRequestMapper::instanceDevicesService
void instanceDevicesService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:238
SWGSDRangel::SWGAudioOutputDevice::setUdpAddress
void setUdpAddress(QString *udp_address)
Definition: SWGAudioOutputDevice.cpp:305
SWGSDRangel::SWGChannelSettings::getWfmDemodSettings
SWGWFMDemodSettings * getWfmDemodSettings()
Definition: SWGChannelSettings.cpp:601
WebAPIRequestMapper::instanceDeviceSetService
void instanceDeviceSetService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1061
WebAPIAdapterInterface::instanceAudioOutputCleanupPatch
virtual int instanceAudioOutputCleanupPatch(SWGSDRangel::SWGSuccessResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:261
WebAPIAdapterInterface::instanceAMBEDevicesPatch
virtual int instanceAMBEDevicesPatch(SWGSDRangel::SWGAMBEDevices &query, SWGSDRangel::SWGAMBEDevices &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:347
SWGSDRangel::SWGChannelSettings::getBfmDemodSettings
SWGBFMDemodSettings * getBfmDemodSettings()
Definition: SWGChannelSettings.cpp:441
SWGSDRangel::SWGChannelSettings::getFreeDvModSettings
SWGFreeDVModSettings * getFreeDvModSettings()
Definition: SWGChannelSettings.cpp:481
WebAPIAdapterInterface::instancePresetPost
virtual int instancePresetPost(SWGSDRangel::SWGPresetTransfer &query, SWGSDRangel::SWGPresetIdentifier &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:423
SWGSDRangel::SWGChannelReport::setChannelType
void setChannelType(QString *channel_type)
Definition: SWGChannelReport.cpp:319
WebAPIAdapterInterface::devicesetURLRe
static std::regex devicesetURLRe
Definition: webapiadapterinterface.h:805
SWGSDRangel::SWGChannelReport::setAtvModReport
void setAtvModReport(SWGATVModReport *atv_mod_report)
Definition: SWGChannelReport.cpp:359
WebAPIAdapterInterface::instancePresetsGet
virtual int instancePresetsGet(SWGSDRangel::SWGPresets &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:377
WebAPIAdapterInterface::devicesetDeviceSettingsGet
virtual int devicesetDeviceSettingsGet(int deviceSetIndex, SWGSDRangel::SWGDeviceSettings &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:579
SWGSDRangel::SWGChannelSettings::getDsdDemodSettings
SWGDSDDemodSettings * getDsdDemodSettings()
Definition: SWGChannelSettings.cpp:451
SWGSDRangel::SWGDeviceSettings::getXtrxInputSettings
SWGXtrxInputSettings * getXtrxInputSettings()
Definition: SWGDeviceSettings.cpp:757
WebAPIAdapterInterface::instanceAudioInputPatch
virtual int instanceAudioInputPatch(SWGSDRangel::SWGAudioInputDevice &response, const QStringList &audioInputKeys, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:187
WebAPIRequestMapper::parseJsonBody
bool parseJsonBody(QString &jsonStr, QJsonObject &jsonObject, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1729
SWGSDRangel::SWGAudioInputDevice::setSampleRate
void setSampleRate(qint32 sample_rate)
Definition: SWGAudioInputDevice.cpp:163
SWGSDRangel::SWGDeviceSettings::setHackRfOutputSettings
void setHackRfOutputSettings(SWGHackRFOutputSettings *hack_rf_output_settings)
Definition: SWGDeviceSettings.cpp:591
WebAPIAdapterInterface::devicesetDevicePut
virtual int devicesetDevicePut(int deviceSetIndex, SWGSDRangel::SWGDeviceListItem &query, SWGSDRangel::SWGDeviceListItem &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:561
SWGSDRangel::SWGChannelSettings::getAmDemodSettings
SWGAMDemodSettings * getAmDemodSettings()
Definition: SWGChannelSettings.cpp:411
SWGSDRangel::SWGAMBEDevices::setNbDevices
void setNbDevices(qint32 nb_devices)
Definition: SWGAMBEDevices.cpp:107
SWGSDRangel::SWGWFMModSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGWFMModSettings.cpp:153
SWGSDRangel::SWGDeviceSettings::setLocalOutputSettings
void setLocalOutputSettings(SWGLocalOutputSettings *local_output_settings)
Definition: SWGDeviceSettings.cpp:641
SWGSDRangel::SWGDeviceReport::setPlutoSdrOutputReport
void setPlutoSdrOutputReport(SWGPlutoSdrOutputReport *pluto_sdr_output_report)
Definition: SWGDeviceReport.cpp:495
SWGSDRangel::SWGDeviceSettings::getXtrxOutputSettings
SWGXtrxOutputSettings * getXtrxOutputSettings()
Definition: SWGDeviceSettings.cpp:767
SWGSDRangel::SWGDeviceSettings::setFileInputSettings
void setFileInputSettings(SWGFileInputSettings *file_input_settings)
Definition: SWGDeviceSettings.cpp:571
WebAPIAdapterInterface::instanceAudioOutputDelete
virtual int instanceAudioOutputDelete(SWGSDRangel::SWGAudioOutputDevice &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:233
SWGSDRangel::SWGChannelSettings::setAmDemodSettings
void setAmDemodSettings(SWGAMDemodSettings *am_demod_settings)
Definition: SWGChannelSettings.cpp:415
WebAPIRequestMapper::instancePresetService
void instancePresetService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:777
SWGSDRangel::SWGDeviceListItem::setDisplayedName
void setDisplayedName(QString *displayed_name)
Definition: SWGDeviceListItem.cpp:177
WebAPIAdapterInterface::instanceAMBEDevicesGet
virtual int instanceAMBEDevicesGet(SWGSDRangel::SWGAMBEDevices &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:317
WebAPIRequestMapper::instanceLoggingService
void instanceLoggingService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:316
WebAPIAdapterInterface::instanceAudioInputParametersURL
static QString instanceAudioInputParametersURL
Definition: webapiadapterinterface.h:793
SWGSDRangel::SWGChannelReport::setWfmModReport
void setWfmModReport(SWGWFMModReport *wfm_mod_report)
Definition: SWGChannelReport.cpp:509
SWGSDRangel::SWGChannelReport::setBfmDemodReport
void setBfmDemodReport(SWGBFMDemodReport *bfm_demod_report)
Definition: SWGChannelReport.cpp:369
SWGSDRangel::SWGChannelReport::setWfmDemodReport
void setWfmDemodReport(SWGWFMDemodReport *wfm_demod_report)
Definition: SWGChannelReport.cpp:499
WebAPIAdapterInterface::instanceChannels
virtual int instanceChannels(int direction, SWGSDRangel::SWGInstanceChannelsResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:127
SWGSDRangel::SWGFCDProPlusSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGFCDProPlusSettings.cpp:159
WebAPIRequestMapper::instanceAudioInputCleanupService
void instanceAudioInputCleanupService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:535
SWGSDRangel::SWGFCDProSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGFCDProSettings.cpp:204
SWGSDRangel::SWGChannelSettings::setSsbModSettings
void setSsbModSettings(SWGSSBModSettings *ssb_mod_settings)
Definition: SWGChannelSettings.cpp:565
WebAPIRequestMapper::instanceSummaryService
void instanceSummaryService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:177
SWGSDRangel::SWGDeviceSettings::setTestSourceSettings
void setTestSourceSettings(SWGTestSourceSettings *test_source_settings)
Definition: SWGDeviceSettings.cpp:741
SWGSDRangel::SWGChannelSettings::getAtvModSettings
SWGATVModSettings * getAtvModSettings()
Definition: SWGChannelSettings.cpp:431
i
int32_t i
Definition: decimators.h:244
WebAPIRequestMapper::m_adapter
WebAPIAdapterInterface * m_adapter
Definition: webapirequestmapper.h:48
SWGSDRangel::SWGDeviceReport::setRtlSdrReport
void setRtlSdrReport(SWGRtlSdrReport *rtl_sdr_report)
Definition: SWGDeviceReport.cpp:505
SWGSDRangel::SWGHackRFOutputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGHackRFOutputSettings.cpp:122
SWGSDRangel::SWGAudioOutputDevice::setUdpDecimationFactor
void setUdpDecimationFactor(qint32 udp_decimation_factor)
Definition: SWGAudioOutputDevice.cpp:295
SWGSDRangel::SWGDeviceReport::setRemoteOutputReport
void setRemoteOutputReport(SWGRemoteOutputReport *remote_output_report)
Definition: SWGDeviceReport.cpp:515
SWGSDRangel::SWGDeviceSettings::setKiwiSdrSettings
void setKiwiSdrSettings(SWGKiwiSDRSettings *kiwi_sdr_settings)
Definition: SWGDeviceSettings.cpp:601
SWGSDRangel::SWGChannelSettings::setUdpSinkSettings
void setUdpSinkSettings(SWGUDPSinkSettings *udp_sink_settings)
Definition: SWGChannelSettings.cpp:595
SWGSDRangel::SWGPresetIdentifier::fromJson
virtual SWGPresetIdentifier * fromJson(QString &jsonString) override
Definition: SWGPresetIdentifier.cpp:72
SWGSDRangel::SWGBladeRF2InputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGBladeRF2InputSettings.cpp:149
WebAPIRequestMapper::validateChannelSettings
bool validateChannelSettings(SWGSDRangel::SWGChannelSettings &deviceSettings, QJsonObject &jsonObject, QStringList &channelSettingsKeys)
Definition: webapirequestmapper.cpp:2321
SWGSDRangel::SWGTestSourceSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGTestSourceSettings.cpp:164
SWGSDRangel::SWGPlutoSdrOutputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGPlutoSdrOutputSettings.cpp:142
SWGSDRangel::SWGKiwiSDRSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGKiwiSDRSettings.cpp:111
SWGSDRangel::SWGChannelSettings::getSsbModSettings
SWGSSBModSettings * getSsbModSettings()
Definition: SWGChannelSettings.cpp:561
WebAPIAdapterInterface::instanceAudioGet
virtual int instanceAudioGet(SWGSDRangel::SWGAudioDevices &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:173
SWGSDRangel::SWGDeviceSettings::getFcdProPlusSettings
SWGFCDProPlusSettings * getFcdProPlusSettings()
Definition: SWGDeviceSettings.cpp:557
WebAPIAdapterInterface::devicesetChannelsReportGet
virtual int devicesetChannelsReportGet(int deviceSetIndex, SWGSDRangel::SWGChannelsDetail &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:679
WebAPIRequestMapper::resetAudioInputDevice
void resetAudioInputDevice(SWGSDRangel::SWGAudioInputDevice &audioInputDevice)
Definition: webapirequestmapper.cpp:2893
WebAPIRequestMapper::devicesetDeviceRunService
void devicesetDeviceRunService(const std::string &indexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1337
SWGSDRangel::SWGDeviceSettings::setBladeRf2InputSettings
void setBladeRf2InputSettings(SWGBladeRF2InputSettings *blade_rf2_input_settings)
Definition: SWGDeviceSettings.cpp:521
SWGSDRangel::SWGDeviceListItem::setHwType
void setHwType(QString *hw_type)
Definition: SWGDeviceListItem.cpp:187
WebAPIRequestMapper::service
void service(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:70
SWGSDRangel::SWGDeviceSettings::setLimeSdrOutputSettings
void setLimeSdrOutputSettings(SWGLimeSdrOutputSettings *lime_sdr_output_settings)
Definition: SWGDeviceSettings.cpp:621
SWGSDRangel::SWGSDRPlaySettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGSDRPlaySettings.cpp:159
SWGSDRangel::SWGDeviceReport::setFileInputReport
void setFileInputReport(SWGFileInputReport *file_input_report)
Definition: SWGDeviceReport.cpp:415
SWGSDRangel::SWGAMBEDevices::asJson
virtual QString asJson() override
Definition: SWGAMBEDevices.cpp:79
WebAPIAdapterInterface::instanceAudioInputCleanupURL
static QString instanceAudioInputCleanupURL
Definition: webapiadapterinterface.h:795
SWGSDRangel::SWGFreeDVModSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGFreeDVModSettings.cpp:153
SWGSDRangel::SWGChannelSettings::asJson
virtual QString asJson() override
Definition: SWGChannelSettings.cpp:278
SWGSDRangel::SWGLocalSourceSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGLocalSourceSettings.cpp:109
SWGSDRangel::SWGDeviceSettings::setFcdProSettings
void setFcdProSettings(SWGFCDProSettings *fcd_pro_settings)
Definition: SWGDeviceSettings.cpp:551
WebAPIAdapterInterface::instancePresetFilePost
virtual int instancePresetFilePost(SWGSDRangel::SWGPresetExport &query, SWGSDRangel::SWGPresetIdentifier &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:469
WebAPIRequestMapper::devicesetFocusService
void devicesetFocusService(const std::string &indexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1150
SWGSDRangel::SWGDeviceSettings::setRtlSdrSettings
void setRtlSdrSettings(SWGRtlSdrSettings *rtl_sdr_settings)
Definition: SWGDeviceSettings.cpp:681
WebAPIAdapterInterface::instanceAudioOutputPatch
virtual int instanceAudioOutputPatch(SWGSDRangel::SWGAudioOutputDevice &response, const QStringList &audioOutputKeys, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:203
SWGSDRangel::SWGChannelSettings::setAmModSettings
void setAmModSettings(SWGAMModSettings *am_mod_settings)
Definition: SWGChannelSettings.cpp:425
SWGSDRangel::SWGDeviceSettings::getAirspyHfSettings
SWGAirspyHFSettings * getAirspyHfSettings()
Definition: SWGDeviceSettings.cpp:497
SWGSDRangel::SWGAudioOutputDevice::setUdpChannelCodec
void setUdpChannelCodec(qint32 udp_channel_codec)
Definition: SWGAudioOutputDevice.cpp:285
WebAPIAdapterInterface::devicesetChannelsReportURLRe
static std::regex devicesetChannelsReportURLRe
Definition: webapiadapterinterface.h:815
SWGSDRangel::SWGDeviceSettings::setFcdProPlusSettings
void setFcdProPlusSettings(SWGFCDProPlusSettings *fcd_pro_plus_settings)
Definition: SWGDeviceSettings.cpp:561
SWGSDRangel::SWGFileInputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGFileInputSettings.cpp:94
WebAPIAdapterInterface::devicesetChannelReportGet
virtual int devicesetChannelReportGet(int deviceSetIndex, int channelIndex, SWGSDRangel::SWGChannelReport &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:773
WebAPIRequestMapper::resetDeviceReport
void resetDeviceReport(SWGSDRangel::SWGDeviceReport &deviceReport)
Definition: webapirequestmapper.cpp:2834
SWGSDRangel::SWGDeviceSettings::setRemoteOutputSettings
void setRemoteOutputSettings(SWGRemoteOutputSettings *remote_output_settings)
Definition: SWGDeviceSettings.cpp:691
WebAPIAdapterInterface::instanceLoggingPut
virtual int instanceLoggingPut(SWGSDRangel::SWGLoggingInfo &query, SWGSDRangel::SWGLoggingInfo &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:157
SWGSDRangel::SWGChannelSettings::getWfmModSettings
SWGWFMModSettings * getWfmModSettings()
Definition: SWGChannelSettings.cpp:611
SWGSDRangel::SWGFreeDVDemodSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGFreeDVDemodSettings.cpp:136
WebAPIRequestMapper::validateDeviceSettings
bool validateDeviceSettings(SWGSDRangel::SWGDeviceSettings &deviceSettings, QJsonObject &jsonObject, QStringList &deviceSettingsKeys)
Definition: webapirequestmapper.cpp:1853
WebAPIAdapterInterface::devicesetChannelReportURLRe
static std::regex devicesetChannelReportURLRe
Definition: webapiadapterinterface.h:814
SWGSDRangel::SWGDeviceSettings::setTestMiSettings
void setTestMiSettings(SWGTestMISettings *test_mi_settings)
Definition: SWGDeviceSettings.cpp:751
SWGSDRangel::SWGLimeSdrOutputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGLimeSdrOutputSettings.cpp:162
SWGSDRangel::SWGDeviceSettings::setRemoteInputSettings
void setRemoteInputSettings(SWGRemoteInputSettings *remote_input_settings)
Definition: SWGDeviceSettings.cpp:701
SWGSDRangel::SWGChannelSettings::getSsbDemodSettings
SWGSSBDemodSettings * getSsbDemodSettings()
Definition: SWGChannelSettings.cpp:571
WebAPIAdapterInterface::devicesetFocusURLRe
static std::regex devicesetFocusURLRe
Definition: webapiadapterinterface.h:806
SWGSDRangel::SWGDeviceListItem::asJson
virtual QString asJson() override
Definition: SWGDeviceListItem.cpp:128
SWGSDRangel::SWGDeviceReport::setAirspyHfReport
void setAirspyHfReport(SWGAirspyHFReport *airspy_hf_report)
Definition: SWGDeviceReport.cpp:385
SWGSDRangel::SWGChannelSettings::setFreqTrackerSettings
void setFreqTrackerSettings(SWGFreqTrackerSettings *freq_tracker_settings)
Definition: SWGChannelSettings.cpp:495
SWGSDRangel::SWGChannelSettings::setFreeDvDemodSettings
void setFreeDvDemodSettings(SWGFreeDVDemodSettings *free_dv_demod_settings)
Definition: SWGChannelSettings.cpp:475
SWGSDRangel::SWGChannelReport::asJson
virtual QString asJson() override
Definition: SWGChannelReport.cpp:237
SWGSDRangel::SWGDeviceSettings::getFileInputSettings
SWGFileInputSettings * getFileInputSettings()
Definition: SWGDeviceSettings.cpp:567
SWGSDRangel::SWGWFMDemodSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGWFMDemodSettings.cpp:131
SWGSDRangel::SWGChannelSettings::getFreeDvDemodSettings
SWGFreeDVDemodSettings * getFreeDvDemodSettings()
Definition: SWGChannelSettings.cpp:471
SWGSDRangel::SWGChannelReport::setAmDemodReport
void setAmDemodReport(SWGAMDemodReport *am_demod_report)
Definition: SWGChannelReport.cpp:339
SWGSDRangel::SWGChannelSettings::setDsdDemodSettings
void setDsdDemodSettings(SWGDSDDemodSettings *dsd_demod_settings)
Definition: SWGChannelSettings.cpp:455
SWGSDRangel::SWGDeviceReport::asJson
virtual QString asJson() override
Definition: SWGDeviceReport.cpp:264
SWGSDRangel::SWGSSBModSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGSSBModSettings.cpp:178
qtwebapp::HttpResponse::write
void write(QByteArray data, bool lastPart=false)
Definition: httpresponse.cpp:98
SWGSDRangel::SWGAirspyHFSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGAirspyHFSettings.cpp:154
SWGSDRangel::SWGPresetExport::fromJson
virtual SWGPresetExport * fromJson(QString &jsonString) override
Definition: SWGPresetExport.cpp:60
qtwebapp::HttpResponse::setStatus
void setStatus(int statusCode, QByteArray description=QByteArray())
Definition: httpresponse.cpp:37
WebAPIAdapterInterface::devicesetChannelSettingsURLRe
static std::regex devicesetChannelSettingsURLRe
Definition: webapiadapterinterface.h:813
SWGSDRangel::SWGChannelSettings::setRemoteSinkSettings
void setRemoteSinkSettings(SWGRemoteSinkSettings *remote_sink_settings)
Definition: SWGChannelSettings.cpp:545
SWGSDRangel::SWGAMBEDevices::getAmbeDevices
QList< SWGAMBEDevice * > * getAmbeDevices()
Definition: SWGAMBEDevices.cpp:113
WebAPIAdapterInterface::instancePresetFilePut
virtual int instancePresetFilePut(SWGSDRangel::SWGPresetImport &query, SWGSDRangel::SWGPresetIdentifier &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:453
SWGSDRangel::SWGChannelSettings::getLocalSinkSettings
SWGLocalSinkSettings * getLocalSinkSettings()
Definition: SWGChannelSettings.cpp:521
WebAPIRequestMapper::devicesetChannelReportService
void devicesetChannelReportService(const std::string &deviceSetIndexStr, const std::string &channelIndexStr, qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1691
WebAPIAdapterInterface::instanceConfigGet
virtual int instanceConfigGet(SWGSDRangel::SWGInstanceConfigResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:97
SWGSDRangel::SWGLoggingInfo::asJson
virtual QString asJson() override
Definition: SWGLoggingInfo.cpp:93
WebAPIRequestMapper::instanceLocationService
void instanceLocationService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:591
SWGSDRangel::SWGDeviceSettings::getHackRfOutputSettings
SWGHackRFOutputSettings * getHackRfOutputSettings()
Definition: SWGDeviceSettings.cpp:587
SWGSDRangel::SWGDeviceSettings::setHackRfInputSettings
void setHackRfInputSettings(SWGHackRFInputSettings *hack_rf_input_settings)
Definition: SWGDeviceSettings.cpp:581
SWGSDRangel::SWGChannelReport::setNfmDemodReport
void setNfmDemodReport(SWGNFMDemodReport *nfm_demod_report)
Definition: SWGChannelReport.cpp:429
SWGSDRangel::SWGChannelSettings::setAtvModSettings
void setAtvModSettings(SWGATVModSettings *atv_mod_settings)
Definition: SWGChannelSettings.cpp:435
WebAPIAdapterInterface::devicesetDeviceURLRe
static std::regex devicesetDeviceURLRe
Definition: webapiadapterinterface.h:807
WebAPIAdapterInterface::instanceDelete
virtual int instanceDelete(SWGSDRangel::SWGSuccessResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:83
WebAPIAdapterInterface::instanceAMBEDevicesPut
virtual int instanceAMBEDevicesPut(SWGSDRangel::SWGAMBEDevices &query, SWGSDRangel::SWGAMBEDevices &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:331
SWGSDRangel::SWGDeviceSettings::getRemoteOutputSettings
SWGRemoteOutputSettings * getRemoteOutputSettings()
Definition: SWGDeviceSettings.cpp:687
WebAPIAdapterInterface::instanceLocationPut
virtual int instanceLocationPut(SWGSDRangel::SWGLocationInformation &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:289
SWGSDRangel::SWGAirspySettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGAirspySettings.cpp:159
SWGSDRangel::SWGDeviceSettings::getHackRfInputSettings
SWGHackRFInputSettings * getHackRfInputSettings()
Definition: SWGDeviceSettings.cpp:577
SWGSDRangel::SWGChannelSettings::getNfmModSettings
SWGNFMModSettings * getNfmModSettings()
Definition: SWGChannelSettings.cpp:511
SWGSDRangel::SWGRemoteOutputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGRemoteOutputSettings.cpp:131
WebAPIAdapterInterface::devicesetChannelURLRe
static std::regex devicesetChannelURLRe
Definition: webapiadapterinterface.h:811
SWGSDRangel::SWGDeviceSettings::getPlutoSdrInputSettings
SWGPlutoSdrInputSettings * getPlutoSdrInputSettings()
Definition: SWGDeviceSettings.cpp:657
WebAPIRequestMapper::resetAudioOutputDevice
void resetAudioOutputDevice(SWGSDRangel::SWGAudioOutputDevice &audioOutputDevice)
Definition: webapirequestmapper.cpp:2899
SWGSDRangel::SWGPresetIdentifier::asJson
virtual QString asJson() override
Definition: SWGPresetIdentifier.cpp:93
WebAPIRequestMapper::instanceDeviceSetsService
void instanceDeviceSetsService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:1034
WebAPIRequestMapper::appendSettingsSubKeys
void appendSettingsSubKeys(const QJsonObject &parentSettingsJsonObject, QJsonObject &childSettingsJsonObject, const QString &parentKey, QStringList &keyList)
Definition: webapirequestmapper.cpp:2771
SWGSDRangel::SWGChannelReport::setNfmModReport
void setNfmModReport(SWGNFMModReport *nfm_mod_report)
Definition: SWGChannelReport.cpp:439
WebAPIAdapterInterface::devicesetDeviceRunURLRe
static std::regex devicesetDeviceRunURLRe
Definition: webapiadapterinterface.h:809
SWGSDRangel::SWGUDPSinkSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGUDPSinkSettings.cpp:181
SWGSDRangel::SWGAudioOutputDevice::setUdpUsesRtp
void setUdpUsesRtp(qint32 udp_uses_rtp)
Definition: SWGAudioOutputDevice.cpp:265
SWGSDRangel::SWGBladeRF1OutputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGBladeRF1OutputSettings.cpp:122
SWGSDRangel::SWGXtrxInputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGXtrxInputSettings.cpp:174
SWGSDRangel::SWGChannelSettings::getUdpSinkSettings
SWGUDPSinkSettings * getUdpSinkSettings()
Definition: SWGChannelSettings.cpp:591
SWGSDRangel::SWGDeviceSettings::setAirspyHfSettings
void setAirspyHfSettings(SWGAirspyHFSettings *airspy_hf_settings)
Definition: SWGDeviceSettings.cpp:501
SWGSDRangel::SWGChannelSettings::getRemoteSinkSettings
SWGRemoteSinkSettings * getRemoteSinkSettings()
Definition: SWGChannelSettings.cpp:541
WebAPIRequestMapper::instanceAudioOutputParametersService
void instanceAudioOutputParametersService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:466
SWGSDRangel::SWGDeviceSettings::getRemoteInputSettings
SWGRemoteInputSettings * getRemoteInputSettings()
Definition: SWGDeviceSettings.cpp:697
WebAPIAdapterInterface::devicesetChannelDelete
virtual int devicesetChannelDelete(int deviceSetIndex, int channelIndex, SWGSDRangel::SWGSuccessResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:713
WebAPIRequestMapper::instancePresetsService
void instancePresetsService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:757
SWGSDRangel::SWGLimeSdrInputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGLimeSdrInputSettings.cpp:199
SWGSDRangel::SWGSuccessResponse::asJson
virtual QString asJson() override
Definition: SWGSuccessResponse.cpp:68
WebAPIAdapterInterface::devicesetDeviceSettingsPutPatch
virtual int devicesetDeviceSettingsPutPatch(int deviceSetIndex, bool force, const QStringList &channelSettingsKeys, SWGSDRangel::SWGDeviceSettings &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:595
SWGSDRangel::SWGDeviceSettings::setPlutoSdrInputSettings
void setPlutoSdrInputSettings(SWGPlutoSdrInputSettings *pluto_sdr_input_settings)
Definition: SWGDeviceSettings.cpp:661
SWGSDRangel::SWGDeviceSettings::setSoapySdrInputSettings
void setSoapySdrInputSettings(SWGSoapySDRInputSettings *soapy_sdr_input_settings)
Definition: SWGDeviceSettings.cpp:721
qtwebapp::StaticFileController::service
void service(HttpRequest &request, HttpResponse &response)
Definition: staticfilecontroller.cpp:62
SWGSDRangel::SWGDeviceSettings::getLimeSdrInputSettings
SWGLimeSdrInputSettings * getLimeSdrInputSettings()
Definition: SWGDeviceSettings.cpp:607
SWGSDRangel::SWGDeviceSettings::setDirection
void setDirection(qint32 direction)
Definition: SWGDeviceSettings.cpp:471
WebAPIAdapterInterface::instanceDeviceSetPost
virtual int instanceDeviceSetPost(int direction, SWGSDRangel::SWGSuccessResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:499
SWGSDRangel::SWGChannelReport::setAmModReport
void setAmModReport(SWGAMModReport *am_mod_report)
Definition: SWGChannelReport.cpp:349
WebAPIRequestMapper::resetChannelReport
void resetChannelReport(SWGSDRangel::SWGChannelReport &deviceSettings)
Definition: webapirequestmapper.cpp:2873
SWGSDRangel::SWGChannelSettings::setLocalSourceSettings
void setLocalSourceSettings(SWGLocalSourceSettings *local_source_settings)
Definition: SWGChannelSettings.cpp:535
WebAPIAdapterInterface::instancePresetPatch
virtual int instancePresetPatch(SWGSDRangel::SWGPresetTransfer &query, SWGSDRangel::SWGPresetIdentifier &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:391
WebAPIAdapterInterface::instanceDeviceSetsGet
virtual int instanceDeviceSetsGet(SWGSDRangel::SWGDeviceSetList &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:485
SWGSDRangel::SWGPlutoSdrInputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGPlutoSdrInputSettings.cpp:184
WebAPIRequestMapper::instanceAudioInputParametersService
void instanceAudioInputParametersService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:397
SWGSDRangel::SWGDSDDemodSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGDSDDemodSettings.cpp:196
WebAPIAdapterInterface::instanceAudioInputDelete
virtual int instanceAudioInputDelete(SWGSDRangel::SWGAudioInputDevice &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:219
SWGSDRangel::SWGSSBDemodSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGSSBDemodSettings.cpp:171
SWGSDRangel::SWGChannelSettings::getRemoteSourceSettings
SWGRemoteSourceSettings * getRemoteSourceSettings()
Definition: SWGChannelSettings.cpp:551
SWGSDRangel::SWGBladeRF2OutputSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGBladeRF2OutputSettings.cpp:122
SWGSDRangel::SWGChannelReport::setUdpSourceReport
void setUdpSourceReport(SWGUDPSourceReport *udp_source_report)
Definition: SWGChannelReport.cpp:479
WebAPIAdapterInterface::devicesetChannelPost
virtual int devicesetChannelPost(int deviceSetIndex, SWGSDRangel::SWGChannelSettings &query, SWGSDRangel::SWGSuccessResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:695
SWGSDRangel::SWGLoggingInfo::fromJson
virtual SWGLoggingInfo * fromJson(QString &jsonString) override
Definition: SWGLoggingInfo.cpp:72
SWGSDRangel::SWGAudioInputDevice::asJson
virtual QString asJson() override
Definition: SWGAudioInputDevice.cpp:103
WebAPIRequestMapper::instancePresetFileService
void instancePresetFileService(qtwebapp::HttpRequest &request, qtwebapp::HttpResponse &response)
Definition: webapirequestmapper.cpp:943
SWGSDRangel::SWGDeviceSettings::setXtrxOutputSettings
void setXtrxOutputSettings(SWGXtrxOutputSettings *xtrx_output_settings)
Definition: SWGDeviceSettings.cpp:771
SWGSDRangel::SWGDeviceSettings::getBladeRf2InputSettings
SWGBladeRF2InputSettings * getBladeRf2InputSettings()
Definition: SWGDeviceSettings.cpp:517
SWGSDRangel::SWGDeviceSettings::setDeviceHwType
void setDeviceHwType(QString *device_hw_type)
Definition: SWGDeviceSettings.cpp:461
qtwebapp::HttpRequest::getMethod
QByteArray getMethod() const
Definition: httprequest.cpp:342
SWGSDRangel::SWGRemoteSinkSettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGRemoteSinkSettings.cpp:126
SWGSDRangel::SWGDeviceReport::setPlutoSdrInputReport
void setPlutoSdrInputReport(SWGPlutoSdrInputReport *pluto_sdr_input_report)
Definition: SWGDeviceReport.cpp:485
SWGSDRangel::SWGDeviceReport::setLimeSdrInputReport
void setLimeSdrInputReport(SWGLimeSdrInputReport *lime_sdr_input_report)
Definition: SWGDeviceReport.cpp:425
SWGSDRangel::SWGChannelSettings::setUdpSourceSettings
void setUdpSourceSettings(SWGUDPSourceSettings *udp_source_settings)
Definition: SWGChannelSettings.cpp:585
SWGSDRangel::SWGDeviceSettings::setBladeRf2OutputSettings
void setBladeRf2OutputSettings(SWGBladeRF2OutputSettings *blade_rf2_output_settings)
Definition: SWGDeviceSettings.cpp:541
SWGSDRangel::SWGTestMISettings::fromJsonObject
virtual void fromJsonObject(QJsonObject &json) override
Definition: SWGTestMISettings.cpp:95
SWGSDRangel::SWGDeviceSettings::getKiwiSdrSettings
SWGKiwiSDRSettings * getKiwiSdrSettings()
Definition: SWGDeviceSettings.cpp:597
SWGSDRangel::SWGDeviceSettings::getSoapySdrInputSettings
SWGSoapySDRInputSettings * getSoapySdrInputSettings()
Definition: SWGDeviceSettings.cpp:717
WebAPIAdapterInterface::devicesetChannelIndexURLRe
static std::regex devicesetChannelIndexURLRe
Definition: webapiadapterinterface.h:812
SWGSDRangel::SWGAudioOutputDevice::setUdpChannelMode
void setUdpChannelMode(qint32 udp_channel_mode)
Definition: SWGAudioOutputDevice.cpp:275
WebAPIAdapterInterface::instanceDevices
virtual int instanceDevices(int direction, SWGSDRangel::SWGInstanceDevicesResponse &response, SWGSDRangel::SWGErrorResponse &error)
Definition: webapiadapterinterface.h:111
SWGSDRangel::SWGChannelSettings::setFreeDvModSettings
void setFreeDvModSettings(SWGFreeDVModSettings *free_dv_mod_settings)
Definition: SWGChannelSettings.cpp:485
WebAPIRequestMapper::validateDeviceListItem
bool validateDeviceListItem(SWGSDRangel::SWGDeviceListItem &deviceListItem, QJsonObject &jsonObject)
Definition: webapirequestmapper.cpp:1797
Generated on Fri Aug 2 2019 17:56:33 for SDRAngel by   doxygen 1.8.13